Prism2 Region Adapter für AvalonDocks DocumentPane und DockingPane?

Question

Hat jemand Beispielcode zum Erstellen eines Region-Adapters für AvalonDocks DocumentPane und DockingPane?

Answer 1

Mein Ratschlag wäre in Microsoft.Practices.Composite.Presentation.Regions in der Prism-Quelle zu suchen. Sehen Sie sich speziell den ItemsControlRegionAdapter an und verwenden Sie ihn als Vorlage. Denken Sie daran, von RegionAdapterBase <> erben:

public class ItemsControlRegionAdapter : RegionAdapterBase<ItemsControl> 

und außer Kraft zu setzen ConfigureRegionAdapterMappings() in der Bootstrap-Programm. Das wäre in etwa so aussehen:

protected override RegionAdapterMappings ConfigureRegionAdapterMappings() 
{ 
    RegionAdapterMappings mappings = base.ConfigureRegionAdapterMappings(); 
    mappings.RegisterMapping(typeof(Canvas), Container.Resolve<CanvasRegionAdapter>()); 
    return mappings; 
} 

Answer 2

Der Markus Raufer zwei Region Adapter zum CompositeWpfContrib Projekt CodePlex hinzugefügt, die sowohl DocumentPane und DockingPane unterstützt.

Answer 3

Da Avalon DocumentPane und DockingPane beide auf dem System.Windows.Controls.Primitives.Selector basieren, können Sie den Standard SelectorRegionAdapter in Prism verwenden.

Gerade Basis, um Ihre Kontrolle über DockableContent

<ad:DockableContent x:Class="DesignerWPF.UserControl1" 
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
      xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
      mc:Ignorable="d" 
      xmlns:ad="clr-namespace:AvalonDock;assembly=AvalonDock" 
      d:DesignHeight="300" d:DesignWidth="300" Title="dans"> 
    <Grid> 
     <TextBox Text="sdfdf"></TextBox> 
    </Grid> 
</ad:DockableContent> 

auf Haupt Shell.xmal setzen die Regionen in der dockablepane

 <ad:DockingManager x:Name="dockManager" Grid.Row="1" Margin="0,4,0,0"> 
      <ad:ResizingPanel Orientation="Horizontal"> 
       <ad:DockablePane cal:RegionManager.RegionName="LeftRegion"> 

       </ad:DockablePane> 
       <ad:DocumentPane cal:RegionManager.RegionName="DocumentRegion"> 

       </ad:DocumentPane> 
      </ad:ResizingPanel> 
     </ad:DockingManager> 

dann, wenn Sie Ihren Moderator für das Steuerelement initialisieren wird es in angezeigt bekommen das Dock.

public class UserTestControl : IModule 
    { 
     public UserTestControl(IUnityContainer container, IRegionManager regionManager) 
     { 
      Container = container; 
      RegionManager = regionManager; 
     } 
     public void Initialize() 
     { 
      var addFundView = Container.Resolve<UserControl1>(); 
      RegionManager.Regions["LeftRegion"].Add(addFundView); 
     } 

     public IUnityContainer Container { get; private set; } 
     public IRegionManager RegionManager { get; private set; } 
    } 

Answer 4

I Raffaeu Bermuda Schnipsel verwendet haben Avalon Registerkarte Region Adapter zu unterstützen, fand aber, dass es einige Probleme, die nicht gelöst werden, ist:

1- Es bietet keine Unterstützung für aa bestimmte Ansicht aktivieren (aka - tab - DockableContent), so dass der Code Region.Activate(object view) nicht funktioniert.

2- Alle Registerkarten sind standardmäßig in der Region aktiv. So hat Region.ActiveViews Sammlung standardmäßig alle Ansichten, dies ist nicht ideal, da ich manchmal überprüfen musste, ob eine Ansicht aktiv ist oder nicht (Sie könnten sich eine Schaltfläche zum Speichern in einem Werkzeugleistenbereich vorstellen, die einen SaveCommand nur für die aktuelle aktive Ansicht ausführt = tab in unserem Fall)

3 - Geschlossene Ansichten werden nicht wirklich geschlossen, nur versteckt. Auch wenn Sie die HideOnClose = true beim Hinzufügen der neuenDockableContent setzen, wird es immer noch nicht aus Region.Views Sammlung entfernt. Dies könnte zu Problemen mit Speicherlecks führen.

4- Wenn Sie einen zuvor hinzugefügten DockableContent im Bereich haben, werden sie nicht synchronisiert und zur Region.Views-Auflistung hinzugefügt.

Also hier sind der Code Ich benutze jetzt, es ist nur ein kleines zwicken aus dem Selector Adapter und Selector Sync Verhalten in PRISM Quellcode gefunden:

AvalonRegionAdapter Klasse:

public class AvalonRegionAdapter : RegionAdapterBase<DocumentPane> 
{ 
    public AvalonRegionAdapter(IRegionBehaviorFactory factory) : base(factory) {} 

    protected override void AttachBehaviors(IRegion region, DocumentPane regionTarget) 
    { 
     if (region == null) throw new System.ArgumentNullException("region"); 
     //Add the behavior that syncs the items source items with the rest of the items 
     region.Behaviors.Add(AvalonDocumentSyncBehavior.BehaviorKey, 
          new AvalonDocumentSyncBehavior() 
     { 
      HostControl = regionTarget 
     }); 
     base.AttachBehaviors(region, regionTarget); 
    } 

    protected override void Adapt(IRegion region, DocumentPane regionTarget){ } 

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

AvalonDocumentSyncBehavior Verhalten Code:

public class AvalonDocumentSyncBehavior : RegionBehavior, IHostAwareRegionBehavior 
{ 
    /// <summary> 
    /// Name that identifies the SelectorItemsSourceSyncBehavior behavior in a collection of RegionsBehaviors. 
    /// </summary> 
    public static readonly string BehaviorKey = "AvalonDocumentSyncBehavior"; 
    private bool updatingActiveViewsInHostControlSelectionChanged; 
    private Selector hostControl; 

    /// <summary> 
    /// Gets or sets the <see cref="DependencyObject"/> that the <see cref="IRegion"/> is attached to. 
    /// </summary> 
    /// <value> 
    /// A <see cref="DependencyObject"/> that the <see cref="IRegion"/> is attached to. 
    /// </value> 
    /// <remarks>For this behavior, the host control must always be a <see cref="Selector"/> or an inherited class.</remarks> 
    public DependencyObject HostControl 
    { 
     get 
     { 
      return this.hostControl; 
     } 

     set 
     { 
      this.hostControl = value as Selector; 
     } 
    } 

    /// <summary> 
    /// Starts to monitor the <see cref="IRegion"/> to keep it in synch with the items of the <see cref="HostControl"/>. 
    /// </summary> 
    protected override void OnAttach() 
    { 
     bool itemsSourceIsSet = this.hostControl.ItemsSource != null; 
     if (itemsSourceIsSet) 
     { 
      //throw new InvalidOperationException(Resources.ItemsControlHasItemsSourceException); 
     } 

     this.SynchronizeItems(); 

     this.hostControl.SelectionChanged += this.HostControlSelectionChanged; 
     this.Region.ActiveViews.CollectionChanged += this.ActiveViews_CollectionChanged; 
     this.Region.Views.CollectionChanged += this.Views_CollectionChanged; 
    } 

    private void Views_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) 
    { 
     if (e.Action == NotifyCollectionChangedAction.Add) 
     { 
      int startIndex = e.NewStartingIndex; 
      foreach (object newItem in e.NewItems) 
      { 
       UIElement view = newItem as UIElement; 
       TabViewModel viewModel = ((UserControl)view).DataContext as TabViewModel; 
       if (view != null) 
       { 
        DockableContent newDockableContent = new DockableContent(); 
        newDockableContent.Content = newItem; 
        //if associated view has metadata then apply it. 
        newDockableContent.Title = view.GetType().ToString(); 
        if (viewModel != null) 
        { 
         //Image img = new Image(); 
         //img.Source = new BitmapImage(new Uri(@"Resources/Alerts.png", UriKind.Relative)); 
         newDockableContent.Title = viewModel.TabModel.Title; 
         newDockableContent.IsCloseable = viewModel.TabModel.CanClose; 
         //newContentPane.Icon = img.Source; 
        } 

        //When contentPane is closed remove from the associated region 
        newDockableContent.Closed += new EventHandler(newDockableContent_Closed); 

        newDockableContent.HideOnClose = false; 
        this.hostControl.Items.Add(newDockableContent); 
        newDockableContent.Activate(); 
       } 
      } 
     } 
     else if (e.Action == NotifyCollectionChangedAction.Remove) 
     { 
      foreach (object oldItem in e.OldItems) 
      { 
       this.hostControl.Items.Remove(oldItem); 
      } 
     } 
    } 

    void newDockableContent_Closed(object sender, EventArgs e) 
    { 
     var dockableContent = sender as DockableContent; 
     if(dockableContent != null) 
      if (this.Region.Views.Contains(dockableContent.Content)) 
      { 
       this.Region.Remove(dockableContent.Content); 
      } 
    } 

    private void SynchronizeItems() 
    { 
     List<object> existingItems = new List<object>(); 

     // Control must be empty before "Binding" to a region 
     foreach (object childItem in this.hostControl.Items) 
     { 
      existingItems.Add(childItem); 
     } 

     foreach (object view in this.Region.Views) 
     { 
      this.hostControl.Items.Add(view); 
     } 

     foreach (object existingItem in existingItems) 
     { 
      this.Region.Add(existingItem); 
     } 
    } 


    private void ActiveViews_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) 
    { 
     if (this.updatingActiveViewsInHostControlSelectionChanged) 
     { 
      // If we are updating the ActiveViews collection in the HostControlSelectionChanged, that 
      // means the user has set the SelectedItem or SelectedItems himself and we don't need to do that here now 
      return; 
     } 

     if (e.Action == NotifyCollectionChangedAction.Add) 
     { 
      var selectedDockableContent = this.hostControl.SelectedItem as DockableContent; 
      if (selectedDockableContent != null 
       && selectedDockableContent.Content != null 
       && selectedDockableContent.Content != e.NewItems[0] 
       && this.Region.ActiveViews.Contains(selectedDockableContent.Content)) 
      { 
       this.Region.Deactivate(selectedDockableContent.Content); 
      } 

      var _UIElement = e.NewItems[0] as FrameworkElement; 
      this.hostControl.SelectedItem = _UIElement.Parent; 
     } 
     else if (e.Action == NotifyCollectionChangedAction.Remove && 
       e.OldItems.Contains(this.hostControl.SelectedItem)) 
     { 
      this.hostControl.SelectedItem = null; 
     } 
    } 

    private void HostControlSelectionChanged(object sender, SelectionChangedEventArgs e) 
    { 
     try 
     { 
      // Record the fact that we are now updating active views in the HostControlSelectionChanged method. 
      // This is needed to prevent the ActiveViews_CollectionChanged() method from firing. 
      this.updatingActiveViewsInHostControlSelectionChanged = true; 

      object source; 
      source = e.OriginalSource; 

      if (source == sender) 
      { 
       foreach (object item in e.RemovedItems) 
       { 
        // check if the view is in both Views and ActiveViews collections (there may be out of sync) 
        var dockableContent = item as DockableContent; 
        if (this.Region.Views.Contains(dockableContent.Content) && this.Region.ActiveViews.Contains(dockableContent.Content)) 
        { 
         this.Region.Deactivate(dockableContent.Content); 
        } 
       } 

       foreach (object item in e.AddedItems) 
       { 
        var dockableContent = item as DockableContent; 
        if (this.Region.Views.Contains(dockableContent.Content) && 
         !this.Region.ActiveViews.Contains(dockableContent.Content)) 
        { 
         this.Region.Activate(dockableContent.Content); 
        } 
       } 
      } 
     } 
     finally 
     { 
      this.updatingActiveViewsInHostControlSelectionChanged = false; 
     } 
    } 
} 

C Ode auf Bootstrap den Adapter

protected override RegionAdapterMappings ConfigureRegionAdapterMappings() 
{ 
    var mappings = base.ConfigureRegionAdapterMappings(); 
    mappings.RegisterMapping(typeof(AvalonDock.DocumentPane), 
          this.Container.Resolve<AvalonRegionAdapter>()); 
    return mappings; 
} 

Dann müssen Sie die TabModel und die TabViewModel ab Raffaeu Bermuda

public sealed class TabModel : DependencyObject 
{ 
    public string Title 
    { 
     get { return (string)GetValue(TitleProperty); } 
     set { SetValue(TitleProperty, value); } 
    } 

    // Using a DependencyProperty as the backing store for Title. This enables animation, styling, binding, etc... 
    public static readonly DependencyProperty TitleProperty = 
     DependencyProperty.Register("Title", typeof(string), typeof(TabModel)); 

    public bool CanClose 
    { 
     get { return (bool)GetValue(CanCloseProperty); } 
     set { SetValue(CanCloseProperty, value); } 
    } 

    // Using a DependencyProperty as the backing store for CanClose. This enables animation, styling, binding, etc... 
    public static readonly DependencyProperty CanCloseProperty = 
     DependencyProperty.Register("CanClose", typeof(bool), typeof(TabModel)); 

    public bool IsModified 
    { 
     get { return (bool)GetValue(IsModifiedProperty); } 
     set { SetValue(IsModifiedProperty, value); } 
    } 

    // Using a DependencyProperty as the backing store for IsModified. This enables animation, styling, binding, etc... 
    public static readonly DependencyProperty IsModifiedProperty = 
     DependencyProperty.Register("IsModified", typeof(bool), typeof(TabModel)); 

} 

Und ein TabViewModel wirkt als Basisklasse zu konfigurieren:

public class TabViewModel : INotifyPropertyChanged 
{ 
    private TabModel _tabModel; 

    public TabModel TabModel 
    { 
     get { return this._tabModel; } 
     set 
     { 
      this._tabModel = value; 
      OnPropertyChanged("TabModel"); 
     } 
    } 
    public TabViewModel() 
    { 
     this.TabModel = new TabModel(); 
     this.TabModel.CanClose = true; 
     this.TabModel.IsModified = false; 
    } 
    public event PropertyChangedEventHandler PropertyChanged; 
    public void OnPropertyChanged(string info) 
    { 
     if (PropertyChanged != null) 
     { 
      PropertyChanged(this, new PropertyChangedEventArgs(info)); 
     } 
    } 
} 

Lassen Sie mich Wenn Sie weitere Hilfe benötigen, werde ich in naher Zukunft einen Blog veröffentlichen.