XamDockManager Prism Region Adapter: Update 3

        /// <summary>
        /// Used to track the region that a ContentPane belongs to so that we can access the region from within the ContentPane.Closed event handler
        /// </summary>
        private static readonly DependencyProperty RegionProperty = DependencyProperty.RegisterAttached(“Region”, typeof(IRegion), typeof(TabGroupPaneRegionAdapter), null);

        public TabGroupPaneRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory)
            : base(regionBehaviorFactory)
        {
        }

        protected override void Adapt(IRegion region, TabGroupPane regionTarget)
        {
            if (regionTarget.ItemsSource != null)
                throw new InvalidOperationException(“ItemsSource property is not empty. This control is being associated with a region, but the control is already bound to something else. If you did not explicitly set the control’s ItemSource property, this exception may be caused by a change in the value of the inherited RegionManager attached property.”);

            SynchronizeItems(region, regionTarget);

            region.Views.CollectionChanged += (Object sender, NotifyCollectionChangedEventArgs e) =>
            {
                OnViewsCollectionChanged(sender, e, region, regionTarget);
            };
        }

        protected override void AttachBehaviors(IRegion region, TabGroupPane regionTarget)
        {
            base.AttachBehaviors(region, regionTarget);

            if (!region.Behaviors.ContainsKey(TabGroupPaneRegionActiveAwareBehavior.BehaviorKey))
                region.Behaviors.Add(TabGroupPaneRegionActiveAwareBehavior.BehaviorKey, new TabGroupPaneRegionActiveAwareBehavior { HostControl = regionTarget });
        }

        protected override IRegion CreateRegion()
        {
            return new SingleActiveRegion();
        }

        private void OnViewsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e, IRegion region, TabGroupPane regionTarget)
        {
            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                //we want to add them behind any previous views that may have been manually declare in XAML or injected
                int startIndex = e.NewStartingIndex;
                foreach (object newItem in e.NewItems)
                {
                    ContentPane contentPane = PrepareContainerForItem(newItem, region);

                    if (regionTarget.Items.Count != startIndex)
                        startIndex = 0;

                    //we must make sure we bring the TabGroupPane into view.  If we don’t a System.StackOverflowException will occur in
                    //UIAutomationProvider.dll if trying to add a ContentPane to a TabGroupPane that is not in view.
                    //This is most common when using nested TabGroupPane regions. If you don’t need this, you can comment it out.
                    regionTarget.BringIntoView();

                    regionTarget.Items.Insert(startIndex, contentPane);
                }
            }
            else if (e.Action == NotifyCollectionChangedAction.Remove)
            {
                if (regionTarget.Items.Count == 0)
                    return;

                IEnumerable<ContentPane> contentPanes = XamDockManager.GetDockManager(regionTarget).GetPanes(PaneNavigationOrder.VisibleOrder);
                foreach (ContentPane contentPane in contentPanes)
                {
                    if (e.OldItems.Contains(contentPane) || e.OldItems.Contains(contentPane.Content))
                        contentPane.ExecuteCommand(ContentPaneCommands.Close);
                }
            }
        }

        /// <summary>
        /// Takes all the views that were declared in XAML manually and merges them with the region.
        /// </summary>
        private void SynchronizeItems(IRegion region, TabGroupPane regionTarget)
        {
            if (regionTarget.Items.Count > 0)
            {
                foreach (object item in regionTarget.Items)
                {
                    PrepareContainerForItem(item, region);
                    region.Add(item);
                }
            }
        }

        /// <summary>
        /// Prepares a view being injected as a ContentPane
        /// </summary>
        /// <param name=”item”>the view</param>
        /// <returns>The injected view as a ContentPane</returns>
        protected ContentPane PrepareContainerForItem(object item, IRegion region)
        {
            ContentPane container = item as ContentPane;

            if (container == null)
            {
                container = new ContentPane();
                container.Content = item; //the content is the item being injected
                container.DataContext = ResolveDataContext(item); //make sure the dataContext is the same as the item. Most likely a ViewModel
                container.SetValue(IsGeneratedProperty, true); //we generated this one
                CreateDockAwareBindings(container);
            }

            container.SetValue(RegionProperty, region); //let’s keep track of which region the container belongs to

            container.CloseAction = PaneCloseAction.RemovePane; //make it easy on ourselves and have the pane manage removing itself from the XamDockManager
            container.Closed += Container_Closed;

            return container;
        }

        void Container_Closed(object sender, PaneClosedEventArgs e)
        {
            ContentPane contentPane = sender as ContentPane;
            if (contentPane != null)
            {
                contentPane.Closed -= Container_Closed; //no memory leaks

                IRegion region = contentPane.GetValue(RegionProperty) as IRegion; //get the region associated with the ContentPane so that we can remove it.
                if (region != null)
                {
                    if (region.Views.Contains(contentPane)) //we are dealing with a ContentPane directly
                        region.Remove(contentPane);

                    var item = contentPane.Content; //this view was injected and set as the content of our ContentPane
                    if (item != null && region.Views.Contains(item))
                        region.Remove(item);
                }

                ClearContainerForItem(contentPane); //reduce memory leaks
            }
        }

        /// <summary>
        /// Checks to see if the item being injected implements the IDockAware interface and creates the necessary data bindings.
        /// </summary>
        /// <remarks>
        /// First we will check if the ContentPane.Content property implements the IDockAware interface. Depending on the type of item being injected,
        /// this may be a View or a ViewModel. If no IDockAware interface is found to create a binding, we next move to the ContentPane.DataContext property, which will
        /// most likely be a ViewModel.
        /// </remarks>
        /// <param name=”container”></param>
        void CreateDockAwareBindings(ContentPane contentPane)
        {
            Binding binding = new Binding(“Header”);

            //let’s first check the item that was injected for IDockAware. This may be a View or ViewModel
            var dockAwareContent = contentPane.Content as IDockAware;
            if (dockAwareContent != null)
                binding.Source = dockAwareContent;

            //nothing was found on the item being injected, let’s check the DataContext
            if (binding.Source == null)
            {
                //fall back to data context of the content pane, which is most likely a ViewModel
                var dockAwareDataContext = contentPane.DataContext as IDockAware;
                if (dockAwareDataContext != null)
                    binding.Source = dockAwareDataContext;
            }

            contentPane.SetBinding(ContentPane.HeaderProperty, binding);
        }

        /// <summary>
        /// Sets the Content property of a generated ContentPane to null.
        /// </summary>
        /// <param name=”contentPane”>The ContentPane</param>
        protected void ClearContainerForItem(ContentPane contentPane)
        {
            if ((bool)contentPane.GetValue(IsGeneratedProperty))
            {
                contentPane.ClearValue(ContentPane.HeaderProperty); //remove any bindings
                contentPane.Content = null;
            }
        }

        /// <summary>
        /// Finds the DataContext of an item.
        /// </summary>
        /// <remarks>
        /// If we are injecting a View, the result will be the Views DataContext. If we are injecting a ViewModel, the result will be the ViewModel.
        /// </remarks>
        /// <param name=”item”>The item</param>
        /// <returns>A Views DataContext or a ViewModel</returns>
        private object ResolveDataContext(object item)
        {
            FrameworkElement frameworkElement = item as FrameworkElement;
            return frameworkElement == null ? item : frameworkElement.DataContext;
        }
    }
}

    XamDockManager _parentDockManager;

    TabGroupPane _hostControl;
    public DependencyObject HostControl
    {
        get { return _hostControl; }
        set { _hostControl = value as TabGroupPane; }
    }

    protected override void OnAttach()
    {
        _parentDockManager = XamDockManager.GetDockManager(_hostControl);
        if (_parentDockManager != null)
            _parentDockManager.ActivePaneChanged += DockManager_ActivePaneChanged;

        Region.ActiveViews.CollectionChanged += ActiveViews_CollectionChanged;
    }

    void DockManager_ActivePaneChanged(object sender, RoutedPropertyChangedEventArgs<ContentPane> e)
    {
        if (e.OldValue != null)
        {
            var item = e.OldValue;

            //are we dealing with a ContentPane directly
            if (Region.Views.Contains(item) && Region.ActiveViews.Contains(item))
            {
                Region.Deactivate(item);
            }
            else
            {
                //now check to see if we have any views that were injected
                var contentControl = item as ContentControl;
                if (contentControl != null)
                {
                    var injectedView = contentControl.Content;
                    if (Region.Views.Contains(injectedView) && Region.ActiveViews.Contains(injectedView))
                        Region.Deactivate(injectedView);
                }
            }
        }

        if (e.NewValue != null)
        {
            var item = e.NewValue;

            //are we dealing with a ContentPane directly
            if (Region.Views.Contains(item) && !this.Region.ActiveViews.Contains(item))
            {
                Region.Activate(item);
            }
            else
            {
                //now check to see if we have any views that were injected
                var contentControl = item as ContentControl;
                if (contentControl != null)
                {
                    var injectedView = contentControl.Content;
                    if (Region.Views.Contains(injectedView) && !this.Region.ActiveViews.Contains(injectedView))
                        Region.Activate(injectedView);
                }
            }
        }
    }

    void ActiveViews_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        if (e.Action == NotifyCollectionChangedAction.Add)
        {
            //are we dealing with a view
            FrameworkElement frameworkElement = e.NewItems[0] as FrameworkElement;
            if (frameworkElement != null)
            {
                ContentPane contentPane = frameworkElement as ContentPane;
                if (contentPane == null)
                    contentPane = frameworkElement.Parent as ContentPane;

                if (contentPane != null && !contentPane.IsActivePane)
                    contentPane.Activate();
            }
            else
            {
                //must be a viewmodel
                object viewModel = e.NewItems[0];
                var contentPane = GetContentPaneFromFromViewModel(viewModel);
                if (contentPane != null)
                    contentPane.Activate();
            }
        }
    }

    ContentPane GetContentPaneFromFromViewModel(object viewModel)
    {
        var panes = XamDockManager.GetDockManager(_hostControl).GetPanes(PaneNavigationOrder.VisibleOrder);
        foreach (ContentPane contentPane in panes)
        {
            if (contentPane.DataContext == viewModel)
                return contentPane;               
        }

        return null;
    }
}

    private ObservableCollection<ViewAViewModel> _views;
    public ObservableCollection<ViewAViewModel> Views
    {
        get { return _views; }
        set
        {
            _views = value;
            NotifyPropertyChanged(“Views”);
        }
    }

    public DelegateCommand<object> ActivateCommand { get; set; }
    public DelegateCommand<object> OpenCommand { get; set; }
    public DelegateCommand<object> CloseCommand { get; set; }

    public ShellViewModel(IUnityContainer container, IRegionManager regionManager)
    {
        _container = container;
        _regionManager = regionManager;

        ActivateCommand = new DelegateCommand<object>(Activate);
        OpenCommand = new DelegateCommand<object>(Open, CanOpen);
        CloseCommand = new DelegateCommand<object>(Close);

        //generate some data
        Views = new ObservableCollection<ViewAViewModel>();
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
        Views.Add(_container.Resolve<ViewAViewModel>());
    }

    void Activate(object viewModel)
    {
        if (viewModel == null)
            return;

        IRegion region = _regionManager.Regions[KnownRegionNames.TabGroupPaneOne]; //get the region
        if (region.Views.Contains(viewModel))
            region.Activate(viewModel); //activate the viewModel
    }

    void Close(object viewModel)
    {
        if (viewModel == null)
            return;

        IRegion region = _regionManager.Regions[KnownRegionNames.TabGroupPaneOne]; //get the region
        if (region.Views.Contains(viewModel))
            region.Remove(viewModel); //remove the viewModel
    }

    void Open(object viewModel)
    {
        IRegion region = _regionManager.Regions[KnownRegionNames.TabGroupPaneOne]; //get the region

        if (!region.Views.Contains(viewModel))
            region.Add(viewModel); //add the viewModel

        region.Activate(viewModel); //active the viewModel
    }

    bool CanOpen(object viewModel)
    {
        return viewModel != null;
    }

    #region INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged;
    protected void NotifyPropertyChanged(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }

    #endregion //INotifyPropertyChanged
}