Dock

https://github.com/wieslawsoltes/dock
Admin
Dock is a docking layout system for Avalonia applications that provides flexible window management,...
Tokens:92,721
Snippets:1,240
Trust Score:7.2
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Complete Service Configuration Example

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-dependency-injection.md

A full example of configuring services within a ConfigureServices method.

```csharp
using Dock.Model.Core;
using Dock.Serializer;
using Microsoft.Extensions.DependencyInjection;

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<MyDocumentViewModel>();
    services.AddTransient<MyToolViewModel>();

    services.AddSingleton<IDockState, DockState>();
    services.AddSingleton<MyDockFactory>();
    services.AddSingleton<IFactory>(static sp => sp.GetRequiredService<MyDockFactory>());

    services.AddSingleton<DockSerializer>();
    services.AddSingleton<IDockSerializer>(static sp => sp.GetRequiredService<DockSerializer>());

    services.AddSingleton<MyApplicationService>();
}
```

--------------------------------

### Install Dock Serializer and DI Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-dependency-injection.md

Commands to install the required serializer and dependency injection packages via the .NET CLI.

```bash
# Choose one serializer:
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
dotnet add package Dock.Serializer.Protobuf          # Binary
dotnet add package Dock.Serializer.Xml               # XML  
dotnet add package Dock.Serializer.Yaml              # YAML
```

```bash
dotnet add package Microsoft.Extensions.DependencyInjection
```

--------------------------------

### Install optional serializers

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-code-only.md

Select a serializer package for saving and loading dock layouts.

```bash
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
dotnet add package Dock.Serializer.Protobuf          # Binary
dotnet add package Dock.Serializer.Xml               # XML
dotnet add package Dock.Serializer.Yaml              # YAML
```

--------------------------------

### Install Pre-release Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/README.md

Installs the necessary Dock pre-release packages via the NuGet Package Manager console.

```powershell
Install-Package Dock.Avalonia -Pre
Install-Package Dock.Model.Mvvm -Pre
Install-Package Dock.Serializer.Newtonsoft -Pre
Install-Package Dock.Avalonia.Themes.Fluent -Pre
Install-Package Dock.Avalonia.Themes.Browser -Pre
```

--------------------------------

### Install Dock packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-code-only.md

Add the necessary Dock NuGet packages to the project.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.Avalonia
dotnet add package Dock.Avalonia.Themes.Fluent
# or use Dock.Avalonia.Themes.Simple
```

--------------------------------

### Install Dock Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/quick-start.md

Install core Dock packages and optional dependencies for serialization, dependency injection, or diagnostics.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Avalonia.Themes.Fluent
# or use Dock.Avalonia.Themes.Simple
```

```bash
# Option A (code-first factory)
dotnet add package Dock.Model.Mvvm

# Option B (XAML layout, ItemsSource, DocumentTemplate)
dotnet add package Dock.Model.Avalonia
```

```bash
# For serialization (choose one):
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json) 
dotnet add package Dock.Serializer.Protobuf          # Binary (protobuf-net)
dotnet add package Dock.Serializer.Xml               # XML
dotnet add package Dock.Serializer.Yaml              # YAML

# For dependency injection:
dotnet add package Microsoft.Extensions.DependencyInjection

# For diagnostics and debugging:
dotnet add package Dock.Avalonia.Diagnostics
```

--------------------------------

### Install Dock and ReactiveProperty packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactive-property.md

Add the required core packages for Dock and ReactiveProperty integration.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.ReactiveProperty
dotnet add package Dock.Avalonia.Themes.Fluent
dotnet add package ReactiveProperty
```

--------------------------------

### Install NuGet Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/README.md

Install the required Dock packages via the NuGet Package Manager console.

```powershell
Install-Package Dock.Avalonia
Install-Package Dock.Model.Mvvm
Install-Package Dock.Serializer.Newtonsoft
Install-Package Dock.Avalonia.Themes.Fluent
Install-Package Dock.Avalonia.Themes.Browser
Install-Package Dock.Controls.DeferredContentControl
```

--------------------------------

### Setup MainViewModel

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-itemssource.md

Define a ViewModel containing an ObservableCollection and commands to manage document lifecycle.

```csharp
public class MainViewModel : INotifyPropertyChanged
{
    public ObservableCollection<FileDocument> Documents { get; } = new();
    
    public ICommand AddDocumentCommand { get; }
    public ICommand RemoveDocumentCommand { get; }
    
    public MainViewModel()
    {
        AddDocumentCommand = new RelayCommand(AddDocument);
        RemoveDocumentCommand = new RelayCommand<FileDocument>(RemoveDocument);
        
        // Add some initial documents
        Documents.Add(new FileDocument 
        { 
            Title = "Welcome.txt",
            Content = "Welcome to the application!"
        });
    }
    
    private void AddDocument()
    {
        Documents.Add(new FileDocument 
        { 
            Title = $"Document {Documents.Count + 1}.txt",
            Content = "New document content"
        });
    }
    
    private void RemoveDocument(FileDocument document)
    {
        Documents.Remove(document);
    }
}
```

--------------------------------

### Install StaticViewLocator package

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-inpc.md

Add the StaticViewLocator package for the recommended view locator approach.

```bash
dotnet add package StaticViewLocator
```

--------------------------------

### Install optional Dock packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-inpc.md

Add optional packages for serialization or dependency injection.

```bash
# For serialization (choose one):
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)

# For dependency injection:
dotnet add package Microsoft.Extensions.DependencyInjection
```

--------------------------------

### Install Dock.Model.Inpc package

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-custom-model.md

Use this command to add the lightweight INotifyPropertyChanged implementation package to your project.

```bash
dotnet add package Dock.Model.Inpc
```

--------------------------------

### Install Required Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui-di.md

Add necessary Dock, ReactiveUI, and Dependency Injection NuGet packages to the project.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.ReactiveUI
dotnet add package Dock.Avalonia.Themes.Fluent
dotnet add package Microsoft.Extensions.DependencyInjection
dotnet add package Microsoft.Extensions.Hosting
dotnet add package ReactiveUI.Avalonia
```

--------------------------------

### Install Dock packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-complex-layouts.md

Commands to initialize a new Avalonia project and add necessary Dock dependencies.

```bash
dotnet new avalonia.app -o MultiDockApp
cd MultiDockApp
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.Mvvm
dotnet add package Dock.Serializer.Newtonsoft
# or use Dock.Serializer.SystemTextJson / Dock.Serializer.Protobuf / Dock.Serializer.Xml / Dock.Serializer.Yaml
```

--------------------------------

### Install Serialization Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-caliburn-micro.md

Optional packages for serializing dock layouts using various formats.

```bash
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
dotnet add package Dock.Serializer.Protobuf          # Binary (protobuf-net)
dotnet add package Dock.Serializer.Xml               # XML
dotnet add package Dock.Serializer.Yaml              # YAML
```

--------------------------------

### Install NuGet Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-guide.md

Required NuGet packages for Dock framework integration.

```xml
<PackageReference Include="Dock.Avalonia" />
<PackageReference Include="Dock.Model.Avalonia" />
<PackageReference Include="Dock.Avalonia.Themes.Fluent" />
```

--------------------------------

### Install Optional Serialization Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui-di.md

Add optional packages for JSON serialization support.

```bash
# For serialization (choose one):
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
```

--------------------------------

### Install Required NuGet Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui-routing.md

Commands to add necessary Dock and ReactiveUI dependencies to the project.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.ReactiveUI
dotnet add package Dock.Model.ReactiveUI.Services
dotnet add package Dock.Avalonia.Themes.Fluent
dotnet add package ReactiveUI.Avalonia
```

--------------------------------

### Add a document at runtime

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-mvvm.md

Example of adding a new document instance to an existing DocumentDock.

```csharp
// Example: add a new document at runtime
var newDoc = new DocumentViewModel { Id = "Doc2", Title = "Another" };
documentDock.AddDocument(newDoc);
```

--------------------------------

### Minimal MVVM Setup for Dockables

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-control-recycling.md

Implement DockableBase to create dockable view models that support recycling.

```csharp
public class DocumentViewModel : Dock.Model.Mvvm.Controls.DockableBase
{
    public DocumentViewModel(string id, string title)
    {
        Id = id;
        Title = title;
    }
}
```

--------------------------------

### Install Dock ReactiveUI Packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Required NuGet packages for integrating Dock with ReactiveUI and Avalonia.

```powershell
Install-Package Dock.Avalonia
Install-Package Dock.Model.ReactiveUI
Install-Package Dock.Avalonia.Themes.Fluent
```

--------------------------------

### Install Dock NuGet packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-mvvm.md

Required packages for integrating Dock with Avalonia and the MVVM model.

```powershell
Install-Package Dock.Avalonia
Install-Package Dock.Model.Mvvm
Install-Package Dock.Avalonia.Themes.Fluent
```

--------------------------------

### Migrate Wrapper Pattern to ItemsSource

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-wrapper-pattern.md

Comparison of the manual wrapper setup versus the simplified ItemsSource collection manipulation.

```csharp
// Complex wrapper setup
var dockDoc = new Document
{
    Title = sceneDoc.Name,
    Context = sceneDoc,
    Content = DocumentsPane.DocumentTemplate?.Content
};
DocumentsPane.AddDocument(dockDoc);
```

```csharp
// Simple collection manipulation
SceneDocuments.Add(sceneDoc); // Automatically creates and adds document
```

--------------------------------

### Add Deferred Content Package

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-deferred-content.md

Install the required NuGet package to enable deferred content functionality.

```bash
dotnet add package Dock.Controls.DeferredContentControl
```

--------------------------------

### Install optional Dock packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactive-property.md

Add optional packages for serialization, dependency injection, or extended validation features.

```bash
# For serialization (choose one):
dotnet add package Dock.Serializer.Newtonsoft        # JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)

# For dependency injection:
dotnet add package Microsoft.Extensions.DependencyInjection

# Additional ReactiveProperty features:
dotnet add package ReactiveProperty.WPF               # For validation attributes
```

--------------------------------

### Install Dock NuGet packages

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/index.md

Use the .NET CLI to add the necessary Dock packages to your Avalonia project.

```bash
dotnet add package Dock.Avalonia
dotnet add package Dock.Controls.DeferredContentControl
dotnet add package Dock.Model.Mvvm
dotnet add package Dock.Avalonia.Themes.Fluent
dotnet add package Dock.Avalonia.Themes.Browser
```

--------------------------------

### Create a ReactiveCommand for Docking

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Example of using ReactiveCommand to trigger docking operations like adding a new document.

```csharp
// Example: create a command that opens a new document
OpenDocument = ReactiveCommand.Create(() =>
{
    var doc = new DocumentViewModel { Id = Guid.NewGuid().ToString(), Title = "New" };
    documentDock.AddDocument(doc);
});
```

--------------------------------

### Inject Services into View Models

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-dependency-injection.md

Example of injecting registered Dock services into a view model constructor.

```csharp
public class MainWindowViewModel
{
    private readonly IFactory _factory;
    private readonly IDockState _dockState;
    private readonly IDockSerializer _serializer;

    public MainWindowViewModel(
        IFactory factory,
        IDockState dockState,
        IDockSerializer serializer)
    {
        _factory = factory;
        _dockState = dockState;
        _serializer = serializer;

        Layout = _factory.CreateLayout();
        _factory.InitLayout(Layout);
    }

    public IRootDock Layout { get; }
}
```

--------------------------------

### Install Dock packages via PowerShell

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-xaml.md

Use these commands to add the necessary Dock libraries to your Avalonia project.

```powershell
Install-Package Dock.Avalonia
Install-Package Dock.Model.Avalonia
Install-Package Dock.Serializer.Newtonsoft
Install-Package Dock.Serializer.Protobuf
Install-Package Dock.Avalonia.Themes.Fluent
```

--------------------------------

### Implement IDockCommandBarProvider

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-command-bars.md

Provide command bar definitions by implementing IDockCommandBarProvider on a document or tool. This example uses RelayCommand from the CommunityToolkit.Mvvm.Input library.

```csharp
using System;
using System.Collections.Generic;
using System.Windows.Input;
using Dock.Model.CommandBars;
using Dock.Model.Mvvm.Controls;

public class EditorDocument : Document, IDockCommandBarProvider
{
    public event EventHandler? CommandBarsChanged;

    public ICommand SaveCommand { get; } = new RelayCommand(() => { /* save */ });

    public IReadOnlyList<DockCommandBarDefinition> GetCommandBars()
    {
        return new[]
        {
            new DockCommandBarDefinition("EditorMenu", DockCommandBarKind.Menu)
            {
                MergeMode = DockCommandBarMergeMode.Append,
                Items = new[]
                {
                    new DockCommandBarItem("_File")
                    {
                        Items = new[]
                        {
                            new DockCommandBarItem("_Save") { Command = SaveCommand },
                            new DockCommandBarItem(null) { IsSeparator = true },
                            new DockCommandBarItem("E_xit")
                        }
                    }
                }
            }
        };
    }

    private void RaiseBarsChanged() => CommandBarsChanged?.Invoke(this, EventArgs.Empty);
}
```

--------------------------------

### Build and Run the Sample

Source: https://github.com/wieslawsoltes/dock/blob/master/samples/DockControlPanelsSample/README.md

Commands to compile and execute the dock control panels sample application.

```bash
dotnet build
dotnet run
```

--------------------------------

### Build the project and solution

Source: https://github.com/wieslawsoltes/dock/blob/master/samples/BrowserTabTheme/README.md

Compiles the sample project and the main solution.

```bash
dotnet build samples/BrowserTabTheme/BrowserTabTheme.csproj
dotnet build Dock.slnx
```

--------------------------------

### Build the Sample and Theme Projects

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-theme-browser-sample.md

Build the theme library and the sample application to verify the project structure.

```bash
dotnet build src/Dock.Avalonia.Themes.Browser/Dock.Avalonia.Themes.Browser.csproj
dotnet build samples/BrowserTabTheme/BrowserTabTheme.csproj
```

--------------------------------

### Configure MainWindow

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui-routing.md

Sets up the main window and initializes the Dock layout.

```csharp
using Avalonia.Controls;
using Dock.Avalonia.Controls;
using MyDockApp.ViewModels;
using ReactiveUI;

namespace MyDockApp;

public partial class MainWindow : Window, IScreen
{
    public RoutingState Router { get; } = new RoutingState();

    public MainWindow()
    {
        InitializeComponent();
        InitializeDock();
    }

    private void InitializeDock()
    {
        var factory = new DockFactory(this);
        var layout = factory.CreateLayout();
        factory.InitLayout(layout);
        
        var dockControl = this.Find<DockControl>("Dock");
        if (dockControl != null)
        {
            dockControl.Layout = layout;
        }
    }
}
```

```xaml
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="MyDockApp.MainWindow"
        Title="Dock with ReactiveUI Routing">
  <DockControl x:Name="Dock" />
</Window>
```

--------------------------------

### Run the Sample Project

Source: https://github.com/wieslawsoltes/dock/blob/master/samples/DockQuickStartSample/README.md

Command to execute the sample application from the repository root.

```bash
dotnet run --project samples/DockQuickStartSample/DockQuickStartSample.csproj
```

--------------------------------

### Run the BrowserTabTheme Sample

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-theme-browser-sample.md

Execute the sample project using the .NET CLI.

```bash
dotnet run --project samples/BrowserTabTheme/BrowserTabTheme.csproj
```

--------------------------------

### Run the Dock Prism Sample

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-prism.md

Commands to build the project and execute the sample application using the .NET CLI.

```bash
cd path/to/Dock
./build.sh            # optional: restore, build, test everything
# or run the sample directly
DOTNET_CLI_TELEMETRY_OPTOUT=1 dotnet run --project samples/DockPrismSample/DockPrismSample.csproj
```

--------------------------------

### PinnedBounds JSON Serialization

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/pinned-dock-inline-display.md

Example of the JSON payload structure for serialized PinnedBounds data.

```json
{
  "PinnedBounds": {
    "X": 0,
    "Y": 0,
    "Width": 280,
    "Height": 600
  }
}
```

--------------------------------

### Run the Deferred Content Sample

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-deferred-content-sample.md

Execute the sample project using the .NET CLI.

```bash
dotnet run --project samples/DockDeferredContentSample/DockDeferredContentSample.csproj
```

--------------------------------

### Create a new Avalonia project

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-code-only.md

Initialize a new Avalonia application via the command line.

```bash
dotnet new avalonia.app -o MinimalDockApp
cd MinimalDockApp
```

--------------------------------

### Initialize and Present a HostAdapter

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-adapters.md

Instantiate a HostAdapter for a dock window and present it as a non-dialog window.

```csharp
var hostAdapter = new HostAdapter(dockWindow);
hostAdapter.Present(isDialog: false);
```

--------------------------------

### Run the application

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-code-only.md

Execute the application using the .NET CLI.

```bash
dotnet run
```

--------------------------------

### Create a layout manually using Factory

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reference.md

Demonstrates the manual construction of a root dock and document dock using the MVVM factory implementation.

```csharp
var factory = new Dock.Model.Mvvm.Factory();
var root = factory.CreateRootDock();
var docDock = factory.CreateDocumentDock();
root.VisibleDockables = factory.CreateList<IDockable>(docDock);
factory.InitLayout(root);
```

--------------------------------

### Initialize Dock Factory and Layout

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-api-scenarios.md

Standard initialization sequence for setting up a factory and assigning it to a DockControl.

```csharp
var factory = new Dock.Model.Mvvm.Factory();
var layout = factory.CreateLayout();
factory.InitLayout(layout);
dockControl.Factory = factory;
dockControl.Layout = layout;
```

--------------------------------

### Enable diagnostics logging globally

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-diagnostics-logging.md

Set the global flag to true to start capturing diagnostic messages.

```csharp
using Dock.Settings;

DockSettings.EnableDiagnosticsLogging = true;
```

--------------------------------

### Create a MainWindow ViewModel

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/quick-start.md

Expose a collection of documents to be bound to the Dock control.

```csharp
using System.Collections.ObjectModel;

public class MainWindowViewModel
{
    public ObservableCollection<FileDocument> Documents { get; } = new()
    {
        new FileDocument { Title = "Document 1", Content = "Content of document 1" },
        new FileDocument { Title = "Document 2", Content = "Content of document 2" }
    };
}
```

--------------------------------

### Navigate with NavigateAdapter

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-adapters.md

Create a navigation adapter for a root dock and perform a navigation action with snapshotting enabled.

```csharp
var adapter = new NavigateAdapter(rootDock);
adapter.Navigate(document, bSnapshot: true);
```

--------------------------------

### Add Documents Programmatically

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-guide.md

Demonstrates how to instantiate and add a document to the dock factory, including logic to check for existing instances.

```csharp
private void AddNewDocument()
{
    var existing = DocumentsPane.VisibleDockables
        ?.OfType<TextDocumentViewModel>()
        ?.FirstOrDefault(d => d.Id == "specific-id");
    
    if (existing != null)
    {
        DocumentsPane.ActiveDockable = existing;
        return;
    }

    // Create the document view model
    var document = new TextDocumentViewModel
    {
        Title = "My Document",
        Text = "Initial content"
    };

    // Add to dock
    _factory?.AddDockable(DocumentsPane, document);
    _factory?.SetActiveDockable(document);
    _factory?.SetFocusedDockable(DocumentsPane, document);
}
```

--------------------------------

### Reset DockState

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-state.md

Clear cached content and templates by calling Reset when starting a new layout or discarding existing state.

```csharp
_dockState.Reset();
```

--------------------------------

### Define Local Docking Compatibility Rules

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-docking-groups.md

Examples of local docking scenarios including same-group, null-group, different-group, and mixed-state constraints.

```csharp
// These can dock together locally
var tool1 = new Tool { DockGroup = "GroupA" };
var tool2 = new Tool { DockGroup = "GroupA" };
```

```csharp
// These can dock together locally
var flexibleTool1 = new Tool { DockGroup = null };
var flexibleTool2 = new Tool { DockGroup = "" };
```

```csharp
// These CANNOT dock together locally
var toolA = new Tool { DockGroup = "GroupA" };
var toolB = new Tool { DockGroup = "GroupB" };
```

```csharp
// These CANNOT dock together locally
var groupedTool = new Tool { DockGroup = "GroupA" };
var ungroupedTool = new Tool { DockGroup = null };
```

--------------------------------

### Build with .NET Core

Source: https://github.com/wieslawsoltes/dock/blob/master/README.md

Build a specific project using the .NET CLI.

```bash
dotnet build src/Dock.Avalonia/Dock.Avalonia.csproj -c Release -f net10.0
```

--------------------------------

### Initialize Navigation Commands in Factory

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Wires up navigation commands between document and tool view models. Ensures each instance has access to the host screen for routing operations.

```csharp
var document1 = new DocumentViewModel(this) { Id = "Doc1", Title = "Document 1" };
var document2 = new DocumentViewModel(this) { Id = "Doc2", Title = "Document 2" };
var tool1 = new ToolViewModel(this) { Id = "Tool1", Title = "Tool 1" };
var tool2 = new ToolViewModel(this) { Id = "Tool2", Title = "Tool 2" };

document1.InitNavigation(document2, tool1, tool2);
document2.InitNavigation(document1, tool1, tool2);
tool1.InitNavigation(document1, document2, tool2);
tool2.InitNavigation(document1, document2, tool1);
```

--------------------------------

### Create layout using out var overloads

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-fluent-extensions.md

Constructs a dock layout using a single fluent chain with out-parameter overloads to capture instances as they are created.

```csharp
using Dock.Avalonia.Controls;
using Dock.Model;
using Dock.Model.Controls;
using Dock.Model.Core;
using Dock.Model.Mvvm;

var factory = new Dock.Model.Mvvm.Factory();

factory
    .Document(out var document, d => d.WithId("Document1").WithTitle("Document 1"))
    .Tool(out var tool, t => t.WithId("Tool1").WithTitle("Tool 1"))
    .DocumentDock(out var documentDock, d => d
        .WithId("Documents")
        .WithTitle("Documents")
        .AppendDocument(document)
        .WithActiveDockable(document)
        .WithProportion(0.75))
    .ToolDock(out var toolDock, Alignment.Left, t => t
        .WithId("Tools")
        .WithTitle("Tools")
        .AppendTool(tool)
        .WithActiveDockable(tool)
        .WithProportion(0.25))
    .ProportionalDockSplitter(out var splitter)
    .ProportionalDock(out var mainLayout, Orientation.Horizontal, p => p
        .WithId("MainLayout")
        .Add(toolDock, splitter, documentDock))
    .RootDock(out var rootDock, r => r
        .WithId("Root")
        .WithTitle("Root")
        .Add(mainLayout)
        .WithActiveDockable(mainLayout));

var dockControl = new DockControl
{
    Factory = factory,
    Layout = rootDock,
    InitializeFactory = true,
    InitializeLayout = true
};
```

--------------------------------

### Configure Program.cs for ReactiveUI

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Initializes ReactiveUI within the Avalonia application builder.

```csharp
using System;
using Avalonia;
using ReactiveUI.Avalonia;

namespace MyDockApp;

internal static class Program
{
    [STAThread]
    public static void Main(string[] args) =>
        BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);

    public static AppBuilder BuildAvaloniaApp() =>
        AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .WithInterFont()
            .UseReactiveUI(static _ => { });
}
```

--------------------------------

### Initialize the layout

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-user-viewmodel.md

Apply the created layout to the dock control in the application.

```csharp
var factory = new DockFactory();
var layout = factory.CreateLayout();
factory.InitLayout(layout);
dockControl.Layout = layout;
```

--------------------------------

### Create a minimal dockable base class

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-custom-model.md

Implement IDockable and INotifyPropertyChanged to create a custom base class for dockable items.

```csharp
public abstract class MyDockableBase : IDockable, INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    protected void Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
    {
        if (!EqualityComparer<T>.Default.Equals(field, value))
        {
            field = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }
    }

    // Implement IDockable members here or copy from Dock.Model.Inpc.Core.DockableBase.
}
```

--------------------------------

### Apply IDE Preset with Simple Theme

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-theme-simple.md

Combine the theme configuration with an IDE preset resource dictionary.

```xaml
<Application.Styles>
  <SimpleTheme />
  <dockSimple:DockSimpleTheme DensityStyle="Compact" />
</Application.Styles>
<Application.Resources>
  <ResourceDictionary>
    <ResourceDictionary.MergedDictionaries>
      <ResourceInclude Source="avares://Dock.Avalonia.Themes.Simple/Presets/Ide/RiderLight.axaml" />
    </ResourceDictionary.MergedDictionaries>
  </ResourceDictionary>
</Application.Resources>
```

--------------------------------

### Configure Dock Capability Policies and Overrides

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-capability-policies.md

Demonstrates setting capability policies at the root and dock levels, and applying an override to a specific tool.

```csharp
var root = factory.CreateRootDock();
root.RootDockCapabilityPolicy = new DockCapabilityPolicy
{
    CanFloat = false
};

var tools = factory.CreateToolDock();
tools.DockCapabilityPolicy = new DockCapabilityPolicy
{
    CanFloat = true
};

var explorer = factory.CreateTool();
explorer.DockCapabilityOverrides = new DockCapabilityOverrides
{
    CanFloat = false
};
```

--------------------------------

### Implementing a custom dock

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-datatemplates.md

Create a concrete implementation of the custom dock interface by inheriting from DockBase.

```csharp
public class CustomTabDock : DockBase, ICustomTabDock
{
    public string TabStyle { get; set; } = "Default";
    public bool ShowTabIcons { get; set; } = true;
}
```

--------------------------------

### Initialize Layout in MainViewModel and XAML

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-caliburn-micro.md

Configure the MainViewModel to hold the factory and layout, then bind them to the DockControl in XAML.

```csharp
public sealed class MainViewModel
{
    public MainViewModel()
    {
        Factory = new DockFactory();
        Layout = Factory.CreateLayout();
    }

    public IFactory Factory { get; }
    public IRootDock Layout { get; }
```

```xaml
<DockControl Layout="{Binding Layout}"
             Factory="{Binding Factory}"
             InitializeFactory="True"
             InitializeLayout="True" />
```

--------------------------------

### Create Dynamic Content with C#

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-guide.md

Use a Func delegate to instantiate views dynamically, allowing for dependency injection integration within the document content.

```csharp
private void AddDocumentWithFunction()
{
    var document = new Document
    {
        Id = Guid.NewGuid().ToString(),
        Title = "Function Document",
        CanClose = true,
        // Content is a function that creates the view
        Content = new Func<IServiceProvider, object>(_ => 
        {
            // You can use DI container here if needed
            var view = new TextDocumentView();
            view.DataContext = new TextDocumentViewModel { Text = "Hello World" };
            return view;
        })
    };

    _factory?.AddDockable(DocumentsPane, document);
    _factory?.SetActiveDockable(document);
}
```

--------------------------------

### Initialize DockState instance

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-state.md

Create a persistent DockState instance to hold content and templates between save and restore operations.

```csharp
private readonly DockState _dockState = new DockState();
```

--------------------------------

### Initialize layout in ViewModel

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-mvvm.md

Instantiate the factory and initialize the layout to resolve locators and assign owners.

```csharp
_factory = new DockFactory();
Layout = _factory.CreateLayout();
_factory.InitLayout(Layout);
```

--------------------------------

### Initialize Layout for Traditional MVVM

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/quick-start.md

Configures the DockFactory and layout within the MainWindow code-behind.

```csharp
public partial class MainWindow : Window
{
    private readonly DockFactory _factory = new();

    public MainWindow()
    {
        InitializeComponent();
        var layout = _factory.CreateLayout();
        _factory.InitLayout(layout);
        Dock.Layout = layout;
    }
}
```

--------------------------------

### Initialize Dock Layout in MainWindow

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-inpc.md

Configure the dock layout within the main window code-behind and XAML.

```csharp
using Avalonia.Controls;
using Dock.Avalonia.Controls;
using MyDockApp.ViewModels;

namespace MyDockApp;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        InitializeDock();
    }

    private void InitializeDock()
    {
        var factory = new DockFactory();
        var layout = factory.CreateLayout();
        factory.InitLayout(layout);
        
        // Assuming you have a DockControl named "Dock" in MainWindow.axaml
        var dockControl = this.Find<DockControl>("Dock");
        if (dockControl != null)
        {
            dockControl.Layout = layout;
        }
    }
}
```

```xaml
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="MyDockApp.MainWindow"
        Title="My Dock App">
  <DockControl x:Name="Dock" />
</Window>
```

--------------------------------

### Implement DocumentWrapper via Composition

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-wrapper-pattern.md

A cleaner approach using composition to wrap application documents within the Dock system.

```csharp
public class DocumentWrapper : Document
{
    private AppDocument? _appDocument;
    
    public AppDocument? AppDocument
    {
        get => _appDocument;
        set
        {
            _appDocument = value;
            if (value != null)
            {
                Title = value.Name;
                Content = value.Content;
            }
        }
    }
}
```

```csharp
var wrapper = new DocumentWrapper
{
    AppDocument = new SceneDocument { Name = "My Scene" }
};

DocumentsPane.AddDocument(wrapper);
```

--------------------------------

### Load plugins

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-complex-layouts.md

Reflection-based logic to load assemblies and instantiate dockables from plugins.

```csharp
var assembly = Assembly.LoadFrom(path);
var plugins = assembly
    .GetTypes()
    .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract)
    .Select(t => (IPlugin)Activator.CreateInstance(t)!);
foreach (var plugin in plugins)
{
    var dockable = plugin.CreateDockable();
    factory.AddDockable(rootLayout, dockable);
}
```

--------------------------------

### Configure Mixed Content with Flexible Docking Areas

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-docking-groups.md

Demonstrates how to assign specific DockGroup strings to restrict items to certain areas, or set DockGroup to null to allow an item to dock anywhere.

```csharp
// Create areas with specific purposes
var codeEditorsGroup = "CodeEditors";
var designersGroup = "Designers"; 
var debuggingGroup = "Debugging";

// Code editors - only code-related content
var codeEditor1 = new Document 
{ 
    Id = "Code1", 
    Title = "Program.cs", 
    DockGroup = codeEditorsGroup 
};

var codeEditor2 = new Document 
{ 
    Id = "Code2", 
    Title = "MainWindow.cs", 
    DockGroup = codeEditorsGroup 
};

// Designers - only design-related content  
var xamlDesigner = new Document 
{ 
    Id = "Designer1", 
    Title = "MainWindow.xaml", 
    DockGroup = designersGroup 
};

var formDesigner = new Document 
{ 
    Id = "Designer2", 
    Title = "Form1.cs[Design]", 
    DockGroup = designersGroup 
};

// Debugging tools - only debugging content
var debugOutput = new Tool 
{ 
    Id = "DebugOutput", 
    Title = "Debug Output", 
    DockGroup = debuggingGroup 
};

var watchWindow = new Tool 
{ 
    Id = "Watch", 
    Title = "Watch", 
    DockGroup = debuggingGroup 
};

// Flexible tools - can dock anywhere
var searchResults = new Tool 
{ 
    Id = "Search", 
    Title = "Search Results", 
    DockGroup = null // Flexible
};
```

--------------------------------

### Configure DockFactory with routing

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui-routing.md

Implement a custom Factory to initialize the layout and configure cross-navigation between view models.

```csharp
using Dock.Model.Core;
using Dock.Model.ReactiveUI;
using Dock.Model.ReactiveUI.Controls;
using Dock.Model.ReactiveUI.Navigation.Controls;
using MyDockApp.ViewModels.Documents;
using ReactiveUI;

namespace MyDockApp.ViewModels;

public class DockFactory : Factory
{
    private readonly IScreen _host;

    public DockFactory(IScreen host)
    {
        _host = host;
    }

    public override IRootDock CreateLayout()
    {
        var document1 = new DocumentViewModel(_host) { Id = "Doc1", Title = "Document 1" };
        var document2 = new DocumentViewModel(_host) { Id = "Doc2", Title = "Document 2" };
        var tool1 = new ToolViewModel(_host) { Id = "Tool1", Title = "Tool 1" };
        var tool2 = new ToolViewModel(_host) { Id = "Tool2", Title = "Tool 2" };

        // Set up cross-navigation between view models
        document1.InitNavigation(document2, tool1, tool2);
        document2.InitNavigation(document1, tool1, tool2);
        tool1.InitNavigation(document1, document2, tool2);
        tool2.InitNavigation(document1, document2, tool1);

        var documentDock = new DocumentDock
        {
            Id = "Documents",
            VisibleDockables = CreateList<IDockable>(document1, document2),
            ActiveDockable = document1
        };

        var toolDock = new ToolDock
        {
            Id = "Tools",
            VisibleDockables = CreateList<IDockable>(tool1, tool2),
            ActiveDockable = tool1
        };

        var proportionalDock = CreateProportionalDock();
        proportionalDock.Orientation = Orientation.Horizontal;
        proportionalDock.VisibleDockables = CreateList<IDockable>(
            documentDock,
            CreateProportionalDockSplitter(),
            toolDock
        );

        var root = CreateRootDock();
        root.VisibleDockables = CreateList<IDockable>(proportionalDock);
        root.ActiveDockable = proportionalDock;
        root.DefaultDockable = proportionalDock;

        return root;
    }
}
```

--------------------------------

### Add Documents to Dock

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-content-wrapper-pattern.md

Instantiate the domain model and wrap it within a Dock Document for insertion into the pane.

```csharp
private void AddSceneDocument()
{
    // Create your domain model
    var sceneDoc = new SceneDocument
    {
        Name = "New Scene",
        Content = new SceneView() // Set the view as content
    };

    // Wrap it in a Dock Document
    var dockDoc = new Dock.Model.Avalonia.Controls.Document
    {
        Id = Guid.NewGuid().ToString(),
        Title = sceneDoc.Name,
        Context = sceneDoc, // Your domain model becomes the Context
        Content = DocumentsPane.DocumentTemplate?.Content // Use the template
    };

    DocumentsPane.AddDocument(dockDoc);
}
```

--------------------------------

### Execute Build Script

Source: https://github.com/wieslawsoltes/dock/blob/master/README.md

Run the repository build script to restore, build, and test all projects.

```bash
./build.sh       # or .\build.cmd on Windows
```

--------------------------------

### Create a Dock Factory

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Define a custom factory by inheriting from Dock.Model.ReactiveUI.Factory to manage layout creation.

```csharp
public class DockFactory : Factory
{
    public override IRootDock CreateLayout()
    {
        var doc = new DocumentViewModel { Id = "Doc1", Title = "Document" };
        var tool = new Tool1ViewModel { Id = "Tool1", Title = "Tool1" };

        var root = CreateRootDock();
        root.VisibleDockables = CreateList<IDockable>(
            new DocumentDock
            {
                VisibleDockables = CreateList<IDockable>(doc),
                ActiveDockable = doc
            },
            new ToolDock
            {
                VisibleDockables = CreateList<IDockable>(tool),
                ActiveDockable = tool
            });
        return root;
    }
}
```

--------------------------------

### Implement MainWindowViewModel with Prism

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-prism.md

Derive from BindableBase and use DelegateCommand for layout reset functionality.

```csharp
// MainWindowViewModel.cs
public class MainWindowViewModel : BindableBase
{
    private readonly IEventAggregator _eventAggregator;
    private readonly IFactory? _factory;
    private IRootDock? _layout;

    public IRootDock? Layout
    {
        get => _layout;
        set => SetProperty(ref _layout, value);
    }

    public ICommand NewLayout { get; }

    public MainWindowViewModel()
    {
        _eventAggregator = new EventAggregator();
        _factory = new DockFactory(new DemoData(), _eventAggregator);

        var layout = _factory?.CreateLayout();
        if (layout is not null)
        {
            _factory?.InitLayout(layout);
        }

        Layout = layout;
        if (Layout is { } root)
        {
            root.Navigate.Execute("Home");
        }

        NewLayout = new DelegateCommand(ResetLayout);
    }

    private void ResetLayout()
    {
        if (Layout?.Close.CanExecute(null) == true)
        {
            Layout.Close.Execute(null);
        }

        var layout = _factory?.CreateLayout();
        if (layout is not null)
        {
            _factory.InitLayout(layout);
            Layout = layout;
        }
    }
}
```

--------------------------------

### Create a Dock Layout

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-reactiveui.md

Implementation of the CreateLayout method to define the initial dockable structure.

```csharp
public override IRootDock CreateLayout()
{
    var document1 = new DocumentViewModel { Id = "Document1", Title = "Doc1" };
    var tool1 = new Tool1ViewModel { Id = "Tool1", Title = "Tool1" };

    var root = CreateRootDock();
    root.VisibleDockables = CreateList<IDockable>(
        new DocumentDock
        {
            VisibleDockables = CreateList<IDockable>(document1),
            ActiveDockable = document1
        },
        new ToolDock
        {
            VisibleDockables = CreateList<IDockable>(tool1),
            ActiveDockable = tool1,
            Alignment = Alignment.Left
        }
    );
    return root;
}
```

--------------------------------

### Apply Simple IDE Presets

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-theme-ide-presets.md

Configure the application styles and resources to use specific Simple IDE presets.

```xaml
<Application.Styles>
  <SimpleTheme />
  <dockSimple:DockSimpleTheme DensityStyle="Normal" />
</Application.Styles>
<Application.Resources>
  <ResourceDictionary>
    <ResourceDictionary.MergedDictionaries>
      <ResourceInclude Source="avares://Dock.Avalonia.Themes.Simple/Presets/Ide/Default.axaml" />
    </ResourceDictionary.MergedDictionaries>
  </ResourceDictionary>
</Application.Resources>
```

```xaml
<Application.Styles>
  <SimpleTheme />
  <dockSimple:DockSimpleTheme DensityStyle="Compact" />
</Application.Styles>
<Application.Resources>
  <ResourceDictionary>
    <ResourceDictionary.MergedDictionaries>
      <ResourceInclude Source="avares://Dock.Avalonia.Themes.Simple/Presets/Ide/VsCodeDark.axaml" />
    </ResourceDictionary.MergedDictionaries>
  </ResourceDictionary>
</Application.Resources>
```

```xaml
<Application.Styles>
  <SimpleTheme />
  <dockSimple:DockSimpleTheme DensityStyle="Compact" />
</Application.Styles>
<Application.Resources>
  <ResourceDictionary>
    <ResourceDictionary.MergedDictionaries>
      <ResourceInclude Source="avares://Dock.Avalonia.Themes.Simple/Presets/Ide/RiderDark.axaml" />
    </ResourceDictionary.MergedDictionaries>
  </ResourceDictionary>
</Application.Resources>
```

--------------------------------

### Subscribe to Dock Events in C#

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-events.md

Attach event handlers to a Factory instance before initializing the layout to monitor dockable and window state changes.

```csharp
var factory = new Factory();

factory.ActiveDockableChanged += (_, args) =>
    Console.WriteLine($"Active dockable: {args.Dockable?.Title} (root={args.RootDock?.Id}, window={args.Window?.Id})");
factory.GlobalDockTrackingChanged += (_, args) =>
    Console.WriteLine($"Global context: {args.Current.Dockable?.Title} / {args.Current.RootDock?.Id} / {args.Current.Window?.Id}");
factory.DockableAdded += (_, args) =>
    Console.WriteLine($"Added: {args.Dockable?.Title}");
factory.DockableDocked += (_, args) =>
    Console.WriteLine($"Docked: {args.Dockable?.Title} via {args.Operation}");
factory.DockableUndocked += (_, args) =>
    Console.WriteLine($"Undocked: {args.Dockable?.Title}");
factory.WindowOpened += (_, args) =>
    Console.WriteLine($"Window opened: {args.Window?.Title}");

var layout = factory.CreateLayout();
factory.InitLayout(layout);
```

--------------------------------

### Clone the Repository

Source: https://github.com/wieslawsoltes/dock/blob/master/README.md

Use this command to download the source code from GitHub.

```bash
git clone https://github.com/wieslawsoltes/Dock.git
```

--------------------------------

### Configure a SplitViewDock

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-layout-panels.md

Sets up a collapsible pane and main content area with specific display and placement modes.

```csharp
var splitView = new SplitViewDock
{
    PaneDockable = new ToolDock(),
    ContentDockable = new DocumentDock(),
    DisplayMode = SplitViewDisplayMode.CompactInline,
    PanePlacement = SplitViewPanePlacement.Left,
    IsPaneOpen = true
};
```

--------------------------------

### Implementing CustomDocumentDock with Prism Commands

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-prism.md

Demonstrates extending DocumentDock to include a DelegateCommand for creating new documents via an IEventAggregator.

```csharp
// CustomDocumentDock.cs
public class CustomDocumentDock : DocumentDock
{
    private readonly IEventAggregator _eventAggregator;

    public CustomDocumentDock(IEventAggregator eventAggregator)
    {
        _eventAggregator = eventAggregator;
        CreateDocument = new DelegateCommand(CreateNewDocument);
    }

    private void CreateNewDocument()
    {
        if (!CanCreateDocument)
        {
            return;
        }

        var index = VisibleDockables?.Count + 1 ?? 1;
        var document = new DocumentViewModel(_eventAggregator)
        {
            Id = $"Document{index}",
            Title = $"Document{index}"
        };

        Factory?.AddDockable(this, document);
        Factory?.SetActiveDockable(document);
        Factory?.SetFocusedDockable(this, document);
    }
}
```

--------------------------------

### Implement minimal code-only application

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-code-only.md

Configure the Avalonia application and define the dock layout programmatically in Program.cs.

```csharp
using System;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Styling;
using Avalonia.Themes.Fluent;
using Dock.Avalonia.Controls;
using Dock.Avalonia.Themes.Fluent;
using Dock.Model.Avalonia;
using Dock.Model.Avalonia.Controls;
using Dock.Model.Core;

namespace MinimalDockApp;

internal class Program
{
    [STAThread]
    private static void Main(string[] args)
    {
        BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
    }

    private static AppBuilder BuildAvaloniaApp()
        => AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace();
}

public class App : Application
{
    public override void OnFrameworkInitializationCompleted()
    {
        Styles.Add(new FluentTheme());
        Styles.Add(new DockFluentTheme());
        RequestedThemeVariant = ThemeVariant.Dark;

        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
        {
            var dockControl = new DockControl();
            var factory = new Factory();

            var documentDock = new DocumentDock
            {
                Id = "Documents",
                IsCollapsable = false,
                CanCreateDocument = true
            };

            documentDock.DocumentFactory = () =>
            {
                var index = documentDock.VisibleDockables?.Count ?? 0;
                return new Document
                {
                    Id = $"Doc{index + 1}",
                    Title = $"Document {index + 1}",
                    Content = new TextBox { Text = $"Document {index + 1}", AcceptsReturn = true }
                };
            };

            var document = new Document
            {
                Id = "Doc1",
                Title = "Document 1",
                // Content = new TextBox { Text = "Document 1", AcceptsReturn = true }
            };

            documentDock.VisibleDockables = factory.CreateList<IDockable>(document);
            documentDock.ActiveDockable = document;

            var leftTool = new Tool { Id = "Tool1", Title = "Tool 1" };
            var bottomTool = new Tool { Id = "Tool2", Title = "Output" };

            var mainLayout = new ProportionalDock
            {
                Orientation = Orientation.Horizontal,
                VisibleDockables = factory.CreateList<IDockable>(
                    new ToolDock
                    {
                        Id = "LeftPane",
                        Alignment = Alignment.Left,
                        Proportion = 0.25,
                        VisibleDockables = factory.CreateList<IDockable>(leftTool),
                        ActiveDockable = leftTool
                    },
                    new ProportionalDockSplitter(),
                    documentDock,
                    new ProportionalDockSplitter(),
                    new ToolDock
                    {
                        Id = "BottomPane",
                        Alignment = Alignment.Bottom,
                        Proportion = 0.25,
                        VisibleDockables = factory.CreateList<IDockable>(bottomTool),
                        ActiveDockable = bottomTool
                    })
            };

            var root = factory.CreateRootDock();
            root.VisibleDockables = factory.CreateList<IDockable>(mainLayout);
            root.DefaultDockable = mainLayout;

            factory.InitLayout(root);
            dockControl.Factory = factory;
            dockControl.Layout = root;

            desktop.MainWindow = new Window
            {
                Width = 800,
                Height = 600,
                Content = dockControl
            };
        }

        base.OnFrameworkInitializationCompleted();
    }
}
```

--------------------------------

### Instantiate custom view models in a factory

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-user-viewmodel.md

Use the custom view model within a Factory implementation to build the docking layout.

```csharp
public class DockFactory : Factory
{
    public override IRootDock CreateLayout()
    {
        var file = new FileViewModel { Id = "File1", Title = "File" };

        var root = CreateRootDock();
        root.VisibleDockables = CreateList<IDockable>(
            new DocumentDock
            {
                VisibleDockables = CreateList<IDockable>(file),
                ActiveDockable = file
            });
        root.DefaultDockable = root.VisibleDockables[0];
        return root;
    }
}
```

--------------------------------

### Configure Drag Preview Settings

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-managed-windows-howto.md

Adjust the visibility and opacity of dockable previews during drag operations.

```csharp
DockSettings.ShowDockablePreviewOnDrag = true;
DockSettings.DragPreviewOpacity = 0.7;
```

--------------------------------

### Initialize Newtonsoft.Json Serializer

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-serialization.md

Basic initialization of the Newtonsoft.Json serializer.

```csharp
using Dock.Serializer;

var serializer = new DockSerializer();
```

--------------------------------

### Implement Convention-Based View Locator

Source: https://github.com/wieslawsoltes/dock/blob/master/docfx/articles/dock-inpc.md

Create a view locator that maps view models to views based on naming conventions.

```csharp
using System;
using System.ComponentModel;
using Avalonia.Controls;
using Avalonia.Controls.Templates;
using Dock.Model.Core;

namespace MyDockApp;

public class ViewLocator : IDataTemplate
{
    public Control? Build(object? data)
    {
        if (data is null)
            return null;

        var name = data.GetType().FullName!.Replace("ViewModel", "View");
        var type = Type.GetType(name);

        if (type != null)
            return (Control)Activator.CreateInstance(type)!;

        return new TextBlock { Text = "Not Found: " + name };
    }

    public bool Match(object? data)
    {
        if (data is null)
        {
            return false;
        }

        if (data is IDockable)
        {
            return true;
        }

        var name = data.GetType().FullName?.Replace("ViewModel", "View");
        return Type.GetType(name) is not null;
    }
}
```
Tokens:
Raw