c# - para - plantillas logos gratis

¿Cómo cargo automáticamente un diseño en mi instancia de AvalonDock?

Question

He integrado AvalonDock 2.0 en mi aplicación. He vinculado el documento y las fuentes anclables a mi modelo de vista, que se representan con los controles de usuario adecuados a través de DataTemplate s.

Puedo cargar y guardar diseños con XmlLayoutSerializer . Necesito admitir la carga de diseños predefinidos a pedido (a través de Button s y ICommand s). Eso también funciona

Lo que no consigo es trabajar cargando un diseño serializado automáticamente cuando el DockingManager cargar los modelos de vista y sus vistas (controles de usuario).

Intenté cargar mi diseño en DockingManager.DataContextChanged pero creo que se dispara demasiado pronto porque el diseño se carga con los documentos en la sección oculta y los documentos duplicados en las secciones visibles. Los paneles renderizados no reflejan el diseño cargado y cuando el diseño se guarda de nuevo, los duplicados se acumulan en la sección oculta.

<ad:DockingManager Name="DockingManager"
DataContext="{Binding Project}"
DataContextChanged="DockingManager_OnDataContextChanged"
ActiveContent="{Binding Active}"
AnchorablesSource="{Binding Anchorables}"
DocumentsSource="{Binding Documents}">
<ad:DockingManager.Theme>
<ad:AeroTheme/>
</ad:DockingManager.Theme>
<ad:DockingManager.LayoutItemTemplateSelector>
<views:PanesTemplateSelector>
<views:PanesTemplateSelector.ChartTemplate>
<DataTemplate>
<views:Chart/>
</DataTemplate>
</views:PanesTemplateSelector.ChartTemplate>
<views:PanesTemplateSelector.WorkspaceTemplate>
<DataTemplate>
<Views:Workspace/>
</DataTemplate>
</views:PanesTemplateSelector.WorkspaceTemplate>
...
</views:PanesTemplateSelector>
</ad:DockingManager.LayoutItemTemplateSelector>
<ad:DockingManager.LayoutItemContainerStyle>
<Style TargetType="{x:Type ad:LayoutItem}">
<Setter Property="Title" Value="{Binding Model.DisplayText}"/>
<Setter Property="ContentId" Value="{Binding Model.ContentId}"/>
</Style>
</ad:DockingManager.LayoutItemContainerStyle>
<ad:LayoutRoot>
<!--<ad:LayoutPanel>
<ad:LayoutDocumentPane/>
<ad:LayoutAnchorablePane/>
</ad:LayoutPanel>-->
</ad:LayoutRoot>
</ad:DockingManager>

... y el código subyacente ...

private void SaveLayout() {
if (this.DataContext == null)
return;
var xmlLayoutSerializer = new XmlLayoutSerializer(this.DockingManager);
var stringBuilder = new StringBuilder();
using (var textWriter = new StringWriter(stringBuilder))
xmlLayoutSerializer.Serialize(textWriter);
var serialized = stringBuilder.ToString();
(this.DataContext as dynamic).XmlSerializedAndEscapedLayout = HttpUtility.HtmlEncode(serialized);
}
private void LoadLayout()
{
if (DataContext == null)
return;
var encoded = (DataContext as dynamic).XmlSerializedAndEscapedLayout;
var window = Window.GetWindow(this);
window.Closing += (sender, args) => SaveLayout();
if (String.IsNullOrWhiteSpace(encoded))
return;
var serialized = HttpUtility.HtmlDecode(encoded);
var xmlLayoutSerializer = new XmlLayoutSerializer(DockingManager);
using (var stringReader = new StringReader(serialized))
xmlLayoutSerializer.Deserialize(stringReader);
}
private void DockingManager_OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
if (e.NewValue != null) // A type check here would be best, I know.
LoadLayout();
}

... Y el modelo de vista ...

public class ProjectViewModel
{
public IModel Model { get; private set; }
public String SerializedLayout { get; set; }
public ViewModelBase Active { get; set; }
private readonly ObservableCollection<ViewModelBase> documents;
public ReadOnlyObservableCollection<ViewModelBase> Documents { get; private set; }
private readonly ObservableCollection<ViewModelBase> anchorables;
public ReadOnlyObservableCollection<ViewModelBase> Anchorables { get; private set; }
public ProjectViewModel(String filePath, String serializedLayout)
{
SerializedLayout = serializedLayout;
using (var fileStream = new FileStream(filePath, FileMode.Open))
{
IModelRepository modelRepository = Ioc.DependencyInjectionContainer.DefaultContainer.Resolve<IModelRepository>();
Model = modelRepository.Load(fileStream);
}
documents = new ObservableCollection<ViewModelBase>();
anchorables = new ObservableCollection<ViewModelBase>();
documents.Add(new Workspace());
anchorables.Add(new RiskLimitsViewModel(Model.RiskLimits));
...
Documents = new ReadOnlyObservableCollection<ViewModelBase>(documents);
Anchorables = new ReadOnlyObservableCollection<ViewModelBase>(anchorables);
}
}

Cualquier idea sería muy apreciada. ¡Gracias!

Answer 1

Tuve que agregar esto en XAML ...

...
</ad:DockingManager.Theme>
<ad:DockingManager.LayoutUpdateStrategy>
<views:LayoutUpdateStrategy/>
</ad:DockingManager.LayoutUpdateStrategy>
<ad:DockingManager.LayoutItemTemplateSelector>
...

... y esto en el código subyacente ...

class LayoutUpdateStrategy : ILayoutUpdateStrategy
{
private bool BeforeInsertContent(LayoutRoot layout, LayoutContent anchorableToShow)
{
var viewModel = (ViewModelBase) anchorableToShow.Content;
var layoutContent = layout.Descendents().OfType<LayoutContent>().FirstOrDefault(x => x.ContentId == viewModel.ContentId);
if (layoutContent == null)
return false;
layoutContent.Content = anchorableToShow.Content;
// Add layoutContent to it''s previous container
var layoutContainer = layoutContent.GetType().GetProperty("PreviousContainer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layoutContent, null) as ILayoutContainer;
if (layoutContainer is LayoutAnchorablePane)
(layoutContainer as LayoutAnchorablePane).Children.Add(layoutContent as LayoutAnchorable);
else if (layoutContainer is LayoutDocumentPane)
(layoutContainer as LayoutDocumentPane).Children.Add(layoutContent);
else
throw new NotSupportedException();
return true;
}
public bool BeforeInsertAnchorable(LayoutRoot layout, LayoutAnchorable anchorableToShow, ILayoutContainer destinationContainer)
{
return BeforeInsertContent(layout, anchorableToShow);
}
public void AfterInsertAnchorable(LayoutRoot layout, LayoutAnchorable anchorableShown) {}
public bool BeforeInsertDocument(LayoutRoot layout, LayoutDocument anchorableToShow, ILayoutContainer destinationContainer)
{
return BeforeInsertContent(layout, anchorableToShow);
}
public void AfterInsertDocument(LayoutRoot layout, LayoutDocument anchorableShown) {}
}

Answer 2

Usé esto:

XAML:

<avalonDock:DockingManager
x:Name="dockManager"
AllowMixedOrientation="True"
DocumentClosing="dockManager_DocumentClosing"
AnchorablesSource="{Binding ListUserPanelAnchorable}"
DocumentsSource="{Binding ListUserPanel}"
Theme="{Binding avalondockTheme}">

Modelo:

public ObservableCollection<UserPanel> _ListUserPanelAnchorable;
ReadOnlyObservableCollection<UserPanel> _readonyFiles = null;
public ReadOnlyObservableCollection<UserPanel> ListUserPanelAnchorable
{
get
{
if (_readonyFiles == null)
_readonyFiles = new ReadOnlyObservableCollection<UserPanel>(_ListUserPanelAnchorable);
return _readonyFiles;
}
}

xaml.cs:

private void loadLayout()
{
//dockPanelModel.ListUserPanel.Clear();
//dockPanelModel.ListUserPanelAnchorable.Clear();
var serializer = new XmlLayoutSerializer(dockManager);
serializer = new XmlLayoutSerializer(dockManager);
serializer.LayoutSerializationCallback += (s, args) =>
{
args.Content = userPanel;
dockPanelModel._ListUserPanelAnchorable.Add(userPanel);
}
}
public AvaladonDockPanel()
{
InitializeComponent();
this.Loaded += AvaladonDockPanel_Loaded;
}
void AvaladonDockPanel_Loaded(object sender, RoutedEventArgs e)
{
loadLayout();
}

panel de usuario:

public class UserPanel
{
public string Title { get; set; }
public string ToolTip { get; set; }
public string IconSource { get; set; }
private Guid _contentGuid = Guid.NewGuid();
public Guid ContentId
{
get { return _contentGuid; }
set { _contentGuid = value; }
}
private UserControl _UserInterface;
public UserControl UserInterface { get { return _UserInterface; } set { _UserInterface = value; NotifyPropertyChanged("UserInterface"); } }
public event PropertyChangedEventHandler PropertyChanged;
private void NotifyPropertyChanged(string propertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
Debug.WriteLine(string.Format("PropertyChanged-> {0}", propertyName));
}
}
}

avalon vinculante para el panel de usuario:

<avalonDock:DockingManager.LayoutItemContainerStyle>
<Style TargetType="{x:Type avalonDock:LayoutItem}">
<Setter Property="Title" Value="{Binding Model.Title}"/>
<Setter Property="ToolTip" Value="{Binding Model.ToolTip}"/>
<Setter Property="IconSource" Value="{Binding Model.IconSource}" />
<Setter Property="ContentId" Value="{Binding Model.ContentId}"/>
</Style>
</avalonDock:DockingManager.LayoutItemContainerStyle>
<avalonDock:DockingManager.LayoutItemTemplate >
<DataTemplate >
<ContentPresenter Content="{Binding UserInterface}" />
</DataTemplate>
</avalonDock:DockingManager.LayoutItemTemplate>