Composite WPF (PRISM) and docking

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using AvalonDock;
using Microsoft.Practices.Composite.Presentation.Regions;
 
namespace CalToAvalonDockProxy
{
 
public class AvalonDockRegion : Region
{
private Selector pane;
private readonly Dictionary<object, ManagedContent> viewToPane =
new Dictionary<object, ManagedContent>();
 
public AvalonDockRegion()
{
Views.CollectionChanged += Views_CollectionChanged;
}
 
private void Views_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if ((pane != null)&&(e.Action == NotifyCollectionChangedAction.Add))
{
ManagedContent dc = null;
object view = e.NewItems[0];
string header = GetHeaderInfoFromView(view);
if (pane is DockablePane)
{
dc = new DockableContent
{
  Name = Name,
  Content = view,
  DockableStyle = DockableStyle.Document,
  Title = header,
  Background = null,
  IsEnabled = true
};
}
else if (pane is DocumentPane)
{
var docCont = new DocumentContent
       {
           Name = Name,
           Content = view,
           Title = header,
           Background = null,
           IsEnabled = true
       };
docCont.Closed += docCont_Closed;
dc = docCont;
}
 
if (dc != null)
{
viewToPane.Add(view,dc);
pane.Items.Add(dc);
}
}
}
 
/// 
/// should queue some inteface like IHeaderInfoProvider to get from a view information about tab's header
/// Unfortunately, IHeaderInfoProvider wasn't included into CAL library (only in examples),
/// so we have to inherit from AvalonDockRegion in order to be independant from project's business logics
/// 
protected virtual string GetHeaderInfoFromView(object view)
{
return "";
}
 
private void docCont_Closed(object sender, System.EventArgs e)
{
foreach (var pair in viewToPane)
{
if (pair.Value == sender)
{
Remove(pair.Key);
break;
}
}
}
 
public void Bind(UIElement content)
{
if (content is ContentControl)
{
foreach (var view in Views)
{
((ContentControl)content).Content = view;
break;
}
}
else if (content is Selector)
{
pane = (Selector)content;
}
}
 
public override void Activate(object view)
{
base.Activate(view);
ManagedContent content;
if (viewToPane.TryGetValue(view,out content))
{
pane.SelectedItem = content;
}
}
}
}

public abstract class CustomRegionsBootstrapper
{
//just a copy of UnityBootstrapper class, except:
....
//code also taken from UnityBootstrapper class, but
//1. Part of code extracted to a virtual ConfigureRegions function 
//2. Removed references to private CAL project resources in exceptions, replaced by a simple text strings.
public virtual void Run(bool runWithDefaultConfiguration)
{
this.useDefaultConfiguration = runWithDefaultConfiguration;
ILoggerFacade logger = this.LoggerFacade;
if (logger == null)
{
throw new InvalidOperationException("The ILoggerFacade is required and cannot be null.");
}
 
logger.Log("Creating Unity container", Category.Debug, Priority.Low);
this.Container = this.CreateContainer();
if (this.Container == null)
{
throw new InvalidOperationException("The IUnityContainer is required and cannot be null.");
}
 
this.Container.AddNewExtension();
this.ConfigureContainer();
 
ConfigureRegions();
 
logger.Log("Initializing modules", Category.Debug, Priority.Low);
this.InitializeModules();
 
logger.Log("Bootstrapper sequence completed", Category.Debug, Priority.Low);
}
 
//just a piece of code from method Run moved here
protected virtual void ConfigureRegions()
{
loggerFacade.Log("Configuring region adapters", Category.Debug, Priority.Low);
 
this.ConfigureRegionAdapterMappings();
this.ConfigureDefaultRegionBehaviors();
 
loggerFacade.Log("Creating shell", Category.Debug, Priority.Low);
DependencyObject shell = this.CreateShell();
if (shell != null)
{
RegionManager.SetRegionManager(shell, this.Container.Resolve());
RegionManager.UpdateRegions();
}
}
}

   class MyDockingClientBootstrapper : CustomRegionsBootstrapper
{
//just a traditional module registatration
protected override IModuleCatalog GetModuleCatalog()
{
var catalog = new ModuleCatalog();
catalog.AddModule(typeof(Module1))
.AddModule(typeof(Module2))
.AddModule(typeof(Module3))
 
return catalog;
}
 
private IRegionManager regionManager;
 
protected void RegisterRegion(string regionName)
{
var reg = new AvalonDockRegion { Name = regionName };
regionManager.Regions.Add(reg);
}
 
//overriding the region creation logics - creates a region for every module
protected override void ConfigureRegions()
{
regionManager = Container.Resolve();
RegisterRegion("Module1");
RegisterRegion("Module2");
RegisterRegion("Module3");
}
 
public void BindRegionToGui(string regionName, UIElement content)
{
var reg = (AvalonDockRegion)regionManager.Regions[regionName];
reg.Bind(content);
}
}

public partial class MainWindow
{
public MainWindow()
{
InitializeComponent();
 
App.Bootstrapper.BindRegionToGui("Module1", module1Pane);
App.Bootstrapper.BindRegionToGui("Module2", module2Pane);
App.Bootstrapper.BindRegionToGui("Module3", module3Pane);
}
}