Dock

https://wieslawsoltes.github.io/Dock/articles/
Admin
Dock is a docking layout system for Avalonia that provides document and tool panes, floating...
Tokens:147,547
Snippets:1,319
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Optional Dock Dependency Injection Package

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Installs the Microsoft.Extensions.DependencyInjection package for integrating dependency injection into your Dock application.

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

```

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

### Install Optional Dock Serialization Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Installs optional NuGet packages for data serialization within Dock applications. Supports JSON serialization using either Newtonsoft.Json or System.Text.Json.

```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 Dock Serialization Packages (Optional)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Installs optional packages for JSON serialization using either Newtonsoft.Json or System.Text.Json. These packages are used for serializing and deserializing Dock-related data.

```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 Dock and ReactiveProperty Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Installs the core Dock Avalonia package, the ReactiveProperty model integration, the Fluent theme, and the ReactiveProperty library using the .NET CLI. These packages are essential for using Dock with ReactiveProperty.

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

```

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

### Install Dock and ReactiveUI Packages with .NET CLI

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Installs the necessary NuGet packages for Dock, ReactiveUI, and dependency injection into an Avalonia project. These packages provide the core functionalities for docking, reactive programming, and service management.

```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
```

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

### C# ReactiveProperty Validation Setup

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Demonstrates how to set up validation for ReactiveProperty properties in a C# ViewModel using data annotations. It shows the initialization of reactive properties and a reactive command with validation-based execution logic.

```csharp
public class DocumentViewModel : Document
{
    private readonly CompositeDisposable _disposables = new();

    public ReactiveProperty<string> Title { get; }
    public ReactiveProperty<string> Content { get; }
    public ReactiveCommand SaveCommand { get; }

    public DocumentViewModel()
    {
        Title = new ReactiveProperty<string>()
            .SetValidateAttribute(() => Title)  // Use data annotations
            .AddTo(_disposables);

        Content = new ReactiveProperty<string>("Document content...")
            .AddTo(_disposables);

        SaveCommand = new ReactiveCommand(
            Title.ObserveHasErrors.Select(x => !x))  // Enable when no validation errors
            .WithSubscribe(() => Save())
            .AddTo(_disposables);
    }

    private void Save()
    {
        // Save logic
    }
}
```

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

### Building Avalonia App with Dependency Injection

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Sets up the Avalonia application builder, integrating the provided service provider and configuring essential Avalonia and ReactiveUI features. This method ensures the application starts with the DI container ready.

```csharp
public static AppBuilder BuildAvaloniaApp(IServiceProvider provider)
            => AppBuilder.Configure(() => provider.GetRequiredService<App>())
                .UsePlatformDetect()
                .WithInterFont()
                .UseReactiveUI()
                .LogToTrace();
```

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

### Program.cs - Dependency Injection Setup

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Sets up the dependency injection container for the Avalonia application. It configures services, registers view models, views, and data services required by the application.

```csharp
using System;
using Avalonia;
using ReactiveUI.Avalonia;
using Dock.Model.Core;
using Dock.Serializer;
using MyDockApp.Models;
using MyDockApp.ViewModels;
using MyDockApp.ViewModels.Documents;
using MyDockApp.ViewModels.Tools;
using MyDockApp.Views;
using MyDockApp.Views.Documents;
using MyDockApp.Views.Tools;
using ReactiveUI;
using Microsoft.Extensions.DependencyInjection;

namespace MyDockApp;

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

    private static ServiceProvider Initialize()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        return services.BuildServiceProvider();
    }

    private static void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<App>();
        services.AddSingleton<IViewLocator, ViewLocator>();

        // Register data services
        services.AddSingleton<DemoData>();
        services.AddSingleton<IDataService, DataService>();

        // Register view models

```

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

### Create Avalonia Project

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Initializes a new Avalonia application project using the .NET CLI. This command sets up the basic structure for an Avalonia application.

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

```

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

### Create a Factory with Dependency Injection (C#)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

This snippet indicates the start of a factory implementation that will leverage dependency injection. The full implementation would typically involve registering Dock services and creating dock layouts.

```csharp
using System;
using System.Collections.Generic;
using Dock.Model.Core;

```

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

### Install Dock and ReactiveUI Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Installs necessary NuGet packages for integrating Dock with ReactiveUI in an Avalonia application. This includes core Dock packages, ReactiveUI integration, and Fluent theme.

```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

```

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

### Create Factory with Routing Setup (C#)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Implements a `DockFactory` that inherits from `Factory` to create the application's root dock layout. It initializes various document and tool view models, sets up cross-navigation between them, and arranges them within `DocumentDock` and `ToolDock` containers using a `ProportionalDock` for layout.

```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;
    }
}
```

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

### Running the Application

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Command to execute the Avalonia application. This is typically run from the project's root directory in the terminal.

```bash
dotnet run
```

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

### Install Dock Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Installs the core Dock Avalonia, Dock Model INPC, and Dock Avalonia Themes Fluent packages. These packages provide the necessary components for using Dock's INPC features within an Avalonia application.

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

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

### Add Dock Serialization Packages (dotnet CLI)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Installs the necessary packages for Dock serialization using either Newtonsoft.Json or System.Text.Json. Choose one based on your JSON serialization preference.

```bash
dotnet add package Dock.Serializer.Newtonsoft
dotnet add package Dock.Serializer.SystemTextJson
```

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

### Registering Services for Dock Application

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Configures the dependency injection container by registering various ViewModels, Views, and Dock-specific services. This setup is crucial for managing service lifetimes and enabling DI throughout the application.

```csharp
services.AddTransient<DocumentViewModel>();
        services.AddTransient<ToolViewModel>();
        services.AddSingleton<MainWindowViewModel>();

        // Register views
        services.AddTransient<IViewFor<DocumentViewModel>, DocumentView>();
        services.AddTransient<IViewFor<ToolViewModel>, ToolView>();
        services.AddTransient<IViewFor<MainWindowViewModel>, MainWindow>();

        // Register Dock services
        services.AddSingleton<IDockState, DockState>();
        services.AddSingleton<DockFactory>();
        services.AddSingleton<IFactory>(static sp => sp.GetRequiredService<DockFactory>());
        services.AddSingleton<DockSerializer>();
        services.AddSingleton<IDockSerializer>(static sp => sp.GetRequiredService<DockSerializer>());
```

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

### Add StaticViewLocator Package for View Resolution

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Installs the StaticViewLocator package, which facilitates view model to view mapping using source generators. This is the recommended approach for view location.

```csharp
dotnet add package StaticViewLocator
```

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

### Install Dock.Avalonia Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui.html

Installs the necessary Dock.Avalonia packages, including the core library, ReactiveUI integration, and Fluent theme.

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

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

### Create Avalonia Application

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Creates a new Avalonia application project and navigates into the project directory. This is the initial step for setting up a Dock INPC-based application.

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

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

### MainWindow Initialization with DockFactory

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Initializes the main window and sets up the docking layout using DockFactory. It finds the DockControl by name and assigns the created layout to it. This code is part of the MainWindow's constructor.

```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; }

    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;
        }
    }
}
```

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

### Create Custom DockFactory and View Models (C#)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Defines a custom `DockFactory` inheriting from `Factory` and demonstrates creating `DocumentViewModel` and `ToolViewModel` classes. These view models utilize `ReactivePropertySlim` for data binding and `ReactiveCommand` for actions, integrating with `Dock.Model.ReactiveProperty`.

```csharp
using System.Collections.Generic;
using System.Reactive.Disposables;
using Dock.Model.Core;
using Dock.Model.ReactiveProperty;
using Dock.Model.ReactiveProperty.Controls;
using Reactive.Bindings;
using Reactive.Bindings.Extensions;

namespace MyDockApp.ViewModels;

public class DockFactory : Factory
{
    public override IRootDock CreateLayout()
    {
        var doc = new DocumentViewModel { Id = "Doc1", Title = "Document" };
        var tool = new ToolViewModel { 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;
    }
}

// Example document view model using ReactiveProperty
public class DocumentViewModel : Document
{
    private readonly CompositeDisposable _disposables = new();

    public ReactivePropertySlim<string> Content { get; }
    public ReactiveCommand SaveCommand { get; }

    public DocumentViewModel()
    {
        Content = new ReactivePropertySlim<string>("Document content here...")
            .AddTo(_disposables);

        SaveCommand = new ReactiveCommand()
            .WithSubscribe(() => 
            {
                // Save logic here
                System.Diagnostics.Debug.WriteLine($"Saving document: {Title}");
            })
            .AddTo(_disposables);
    }
}

// Example tool view model using ReactiveProperty
public class ToolViewModel : Tool
{
    private readonly CompositeDisposable _disposables = new();

    public ReactivePropertySlim<string> Status { get; }
    public ReactiveCommand RefreshCommand { get; }

    public ToolViewModel()
    {
        Status = new ReactivePropertySlim<string>("Ready")
            .AddTo(_disposables);

        RefreshCommand = new ReactiveCommand()
            .WithSubscribe(() => 
            {

```

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

### App Initialization with Dependency Injection

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Initializes the Avalonia application, loads XAML, and sets up the view locator. It specifically handles the desktop application lifetime by resolving the main window ViewModel and its corresponding View from the DI container.

```csharp
public override void Initialize()
            {
                AvaloniaXamlLoader.Load(this);
                DataTemplates.Insert(0, (IDataTemplate)_viewLocator);
            }

            public override void OnFrameworkInitializationCompleted()
            {
                if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop && ServiceProvider != null)
                {
                    var viewModel = ServiceProvider.GetRequiredService<MainWindowViewModel>();
                    var view = ServiceProvider.GetRequiredService<IViewFor<MainWindowViewModel>>();
                    view.ViewModel = viewModel;
                    if (view is Window window)
                    {
                        desktop.MainWindow = window;
                    }
                }

                base.OnFrameworkInitializationCompleted();
            }
```

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

### Create View Models with Dependency Injection (C#)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Demonstrates creating view models (DocumentViewModel and ToolViewModel) that utilize dependency injection to access services like IDataService. These view models use ReactiveUI for property management and subscriptions.

```csharp
using System.Reactive.Disposables;
using ReactiveUI;
using Dock.Model.ReactiveUI.Controls;
using MyDockApp.Models;

namespace MyDockApp.ViewModels.Documents
{
    public class DocumentViewModel : Document
    {
        private readonly IDataService _dataService;
        private readonly CompositeDisposable _disposables = new();

        public DocumentViewModel(IDataService dataService)
        {
            _dataService = dataService;

            var data = _dataService.GetData();
            Content = data.Message;

            // Set up reactive properties and commands as needed
            this.WhenAnyValue(x => x.Content)
                .Subscribe(content => 
                {
                    var updatedData = new DemoData { Message = content };
                    _dataService.UpdateData(updatedData);
                })
                .DisposeWith(_disposables);
        }

        private string _content = string.Empty;
        public string Content
        {
            get => _content;
            set => this.RaiseAndSetIfChanged(ref _content, value);
        }
    }
}

namespace MyDockApp.ViewModels.Tools
{
    public class ToolViewModel : Tool
    {
        private readonly IDataService _dataService;

        public ToolViewModel(IDataService dataService)
        {
            _dataService = dataService;
            RefreshData();
        }

        private string _status = string.Empty;
        public string Status
        {
            get => _status;
            set => this.RaiseAndSetIfChanged(ref _status, value);
        }

        private void RefreshData()
        {
            var data = _dataService.GetData();
            Status = $"Last updated: {data.LastUpdated:HH:mm:ss}";
        }
    }
}
```

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

### Complete DI Configuration Example

Source: https://wieslawsoltes.github.io/Dock/articles/dock-dependency-injection.html

A comprehensive example demonstrating the registration of various Dock and application-specific services within the 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>();
}
```

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

### Create a basic Dock layout using the Factory API

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reference.html

Demonstrates the minimal steps to create a root dock and a document dock using the Factory API. This involves instantiating the Factory, creating the necessary dock structures, initializing the layout, and setting the visible dockables.

```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);

```

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

### Subscribing to Events

Source: https://wieslawsoltes.github.io/Dock/articles/dock-events.html

Demonstrates how to create a factory instance and attach event handlers before initializing the layout.

```APIDOC
## Subscribing to Events

Create a factory instance and attach handlers before initializing the layout:

```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);
```

Some events allow the operation to be cancelled by setting the `Cancel` property on the event args instance.
```

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

### Create Avalonia Project

Source: https://wieslawsoltes.github.io/Dock/articles/quick-start.html

Creates a new Avalonia application project using the dotnet CLI. This is the first step in setting up Dock for Avalonia.

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

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

### Add ReactiveProperty.WPF Package

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Installs the ReactiveProperty.WPF NuGet package, which provides validation attributes and other features necessary for ReactiveProperty integration in WPF applications.

```bash
dotnet add package ReactiveProperty.WPF
```

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

### Run BrowserTabTheme Sample Project

Source: https://wieslawsoltes.github.io/Dock/articles/dock-theme-browser-sample.html

Command to execute the BrowserTabTheme sample application. This command requires the .NET SDK to be installed and the project file path to be correct.

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

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

### Avalonia Dock Control Setup

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

Defines a DockControl in XAML to host the docking layout. This control is named 'Dock' and will be referenced in the C# code for initialization.

```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>
```

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

### Create Avalonia Project and Install Dock Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-xaml.html

Initializes a new Avalonia project and adds necessary Dock-related packages for Avalonia integration, model, and themes. This sets up the foundational structure for the Dock application.

```bash
dotnet new avalonia.app -o MyDockApp
cd MyDockApp
dotnet add package Dock.Avalonia
dotnet add package Dock.Model.Avalonia
dotnet add package Dock.Avalonia.Themes.Fluent
```

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

### Install Optional Dock Serialization Packages

Source: https://wieslawsoltes.github.io/Dock/articles/quick-start.html

Installs optional packages for serializing Dock layouts. Choose one based on your preferred serialization format: Newtonsoft.Json, System.Text.Json, protobuf-net, XML, or YAML.

```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
```

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

### Wire Up Navigation Commands in Factory

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui.html

Illustrates how to initialize navigation commands for documents and tools within the factory. This allows different dockables to navigate to each other.

```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);
```

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

### Subscribe to Dock Events in C#

Source: https://wieslawsoltes.github.io/Dock/articles/dock-events.html

Demonstrates how to create a factory instance and subscribe to various Dock events like ActiveDockableChanged, GlobalDockTrackingChanged, DockableAdded, DockableDocked, DockableUndocked, and WindowOpened. It shows how to initialize the layout after setting up event handlers.

```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);
```

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

### Add DockControl to MainWindow.axaml

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Defines the `DockControl` within the `MainWindow.axaml` file, naming it 'Dock' to be referenced in the C# code-behind for layout initialization.

```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>
```

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

### Initialize Dock Layout in MainWindow

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Initializes the Dock layout in the MainWindow of the Avalonia application. It creates a DockFactory, generates a layout, and assigns it to the DockControl.

```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;
        }
    }
}
```

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

### Install Optional Dock Serialization Packages

Source: https://wieslawsoltes.github.io/Dock/articles/dock-xaml.html

Installs optional packages for serializing Dock layouts, supporting formats like JSON (Newtonsoft and System.Text.Json), Protobuf, XML, and YAML. Choose one based on your serialization needs.

```bash
# JSON (Newtonsoft.Json)
dotnet add package Dock.Serializer.Newtonsoft

# JSON (System.Text.Json)
dotnet add package Dock.Serializer.SystemTextJson

# Binary
dotnet add package Dock.Serializer.Protobuf

# XML
dotnet add package Dock.Serializer.Xml

# YAML
dotnet add package Dock.Serializer.Yaml
```

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

### Tool View C# Code-Behind

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Provides the C# code-behind for the ToolView. It inherits from ReactiveUserControl and is strongly typed to ToolViewModel, initializing the component.

```csharp
using ReactiveUI.Avalonia;
using MyDockApp.ViewModels.Tools;

namespace MyDockApp.Views.Tools;

public partial class ToolView : ReactiveUserControl<ToolViewModel>
{
    public ToolView()
    {
        InitializeComponent();
    }
}
```

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

### Document View C# Code-Behind

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Provides the C# code-behind for the DocumentView. It inherits from ReactiveUserControl and is strongly typed to DocumentViewModel, initializing the component.

```csharp
using ReactiveUI.Avalonia;
using MyDockApp.ViewModels.Documents;

namespace MyDockApp.Views.Documents;

public partial class DocumentView : ReactiveUserControl<DocumentViewModel>
{
    public DocumentView()
    {
        InitializeComponent();
    }
}
```

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

### Create Project and Install Dock Packages (dotnet CLI)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-complex-layouts.html

Initializes a new Avalonia application project and installs necessary Dock.Avalonia packages. It also shows alternative serializer packages that can be used.

```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 Optional Dock ReactiveUI Services Package

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui.html

Installs an optional package for Dock that provides navigation helpers and overlay services specifically for ReactiveUI integration.

```bash
# For navigation helpers and overlay services:
dotnet add package Dock.Model.ReactiveUI.Services

```

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

### Register View Models with ReactiveUI's Locator

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

This C# code snippet demonstrates how to register view model to view mappings within the `App.axaml.cs` file. It uses `Splat`'s `Locator.CurrentMutable.Register` method to associate specific view models (e.g., `DocumentViewModel`) with their corresponding views (e.g., `DocumentView`). This setup is crucial for ReactiveUI's dependency injection and view resolution.

```csharp
using ReactiveUI;
using Splat;

private void RegisterViews()
{
    Locator.CurrentMutable.Register<IViewFor<DocumentViewModel>>(() => new DocumentView());
    Locator.CurrentMutable.Register<IViewFor<ToolViewModel>>(() => new ToolView());
    Locator.CurrentMutable.Register<IViewFor<Page1ViewModel>>(() => new Page1View());
    Locator.CurrentMutable.Register<IViewFor<Page2ViewModel>>(() => new Page2View());
    Locator.CurrentMutable.Register<IViewFor<InnerViewModel>>(() => new InnerView());
}
```

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

### Document View XAML

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Defines the UI for the Document view using Avalonia XAML. It consists of a TextBox that is bound to the 'Content' property of its ViewModel.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.Documents.DocumentView">
  <TextBox Text="{Binding Content}" AcceptsReturn="True" />
</UserControl>
```

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

### Using the MVVM Library

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reference.html

Guidance on using the `Dock.Model.Mvvm` library for MVVM-based implementations, including creating custom factories and view models.

```APIDOC
## Using the MVVM library

`Dock.Model.Mvvm` provides base classes that implement property change notification via `INotifyPropertyChanged`. Create a custom `Factory` derived from `Dock.Model.Mvvm.Factory` and override `CreateLayout` to build your docks. View models should derive from the MVVM versions of `Dockable`, `Tool` and `Document`.

The MVVM sample demonstrates how to subscribe to factory events and update the UI through commands.
```

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

### Define Tool View in Avalonia

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Defines the UI for a tool view using Avalonia XAML. It displays status information and a refresh button, bound to ViewModel properties.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.ToolView">
  <StackPanel Margin="5">
    <TextBlock Text="Tool Panel" FontWeight="Bold" Margin="0,0,0,10" />
    <TextBlock Text="{Binding Status.Value}" Margin="0,0,0,5" />
    <Button Content="Refresh" Command="{Binding RefreshCommand}" />
  </StackPanel>
</UserControl>
```

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

### Install Dock Packages (dotnet)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-caliburn-micro.html

Installs the necessary Dock packages and a theme using the dotnet CLI. This includes the core Dock packages, Caliburn.Micro integration, and a Fluent theme for Avalonia.

```dotnet
dotnet add package Dock.Avalonia
 dotnet add package Dock.Model.CaliburMicro
 dotnet add package Dock.Avalonia.Themes.Fluent
```

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

### Initialize DockControl in MainWindow

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Initializes the docking layout by creating a `DockFactory`, generating a layout, and assigning it to the `DockControl` in the `MainWindow`. Assumes a `DockControl` named 'Dock' exists in `MainWindow.axaml`.

```csharp
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;
        }
    }
}
```

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

### Create DocumentView for ViewModel (XAML)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Defines the XAML for `DocumentView`, which is a user control designed to display the content of a `DocumentViewModel`. It uses a `TextBox` to show and edit the `Content` property.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.DocumentView">
  <TextBox Text="{Binding Content}" AcceptsReturn="True" />
</UserControl>
```

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

### Implement Routable Tool View Model with Navigation Commands

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-routing.html

This C# code defines a `ToolViewModel` inheriting from `RoutableTool`, incorporating ReactiveUI routing. It includes commands (`GoToDocument1`, `GoToDocument2`, `GoToNextTool`) to navigate between documents and other tools. The `InitNavigation` method configures these commands based on provided `IRoutableViewModel` instances, facilitating inter-tool and tool-to-document navigation.

```csharp
using System;
using System.Reactive;
using System.Reactive.Disposables;
using Dock.Model.ReactiveUI.Navigation.Controls;
using ReactiveUI;

namespace MyDockApp.ViewModels.Tools
{
    public class ToolViewModel : RoutableTool
    {
        public ReactiveCommand<Unit, IDisposable>? GoToDocument1 { get; set; }
        public ReactiveCommand<Unit, IDisposable>? GoToDocument2 { get; set; }
        public ReactiveCommand<Unit, IDisposable>? GoToNextTool { get; set; }

        public ToolViewModel(IScreen host) : base(host)
        {
            Router.Navigate.Execute(new InnerViewModel(this, "Tool Home"));
        }

        public void InitNavigation(
            IRoutableViewModel? document1,
            IRoutableViewModel? document2,
            IRoutableViewModel? nextTool)
        {
            if (document1 is not null)
            {
                GoToDocument1 = ReactiveCommand.Create(() =>
                    HostScreen.Router.Navigate.Execute(document1).Subscribe(_ => { }));
            }

            if (document2 is not null)
            {
                GoToDocument2 = ReactiveCommand.Create(() =>
                    HostScreen.Router.Navigate.Execute(document2).Subscribe(_ => { }));
            }

            if (nextTool is not null)
            {

```

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

### Initialize Layout in MainWindow (C#)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Provides the C# code snippet for initializing the layout in the main window of the Avalonia application. It imports necessary namespaces for controls and the custom `DockFactory`.

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

namespace MyDockApp;

```

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

### Install Optional Dock Dependency Injection Package

Source: https://wieslawsoltes.github.io/Dock/articles/quick-start.html

Installs the Microsoft.Extensions.DependencyInjection package, which is optional and used for scenarios involving dependency injection with Dock.

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

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

### Tool View XAML

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactiveui-di.html

Defines the UI for the Tool view using Avalonia XAML. It includes a TextBlock for a title and another TextBlock bound to the 'Status' property of its ViewModel.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.Tools.ToolView">
  <StackPanel Margin="5">
    <TextBlock Text="Tool Panel" FontWeight="Bold" />
    <TextBlock Text="{Binding Status}" />
  </StackPanel>
</UserControl>
```

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

### Define Document View in Avalonia

Source: https://wieslawsoltes.github.io/Dock/articles/dock-reactive-property.html

Defines the UI for a document view using Avalonia XAML. It includes a save button and a text box for content editing, bound to ViewModel properties.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.DocumentView">
  <DockPanel>
    <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Margin="5">
      <Button Content="Save" Command="{Binding SaveCommand}" />
    </StackPanel>
    <TextBox Text="{Binding Content.Value}" AcceptsReturn="True" />
  </DockPanel>
</UserControl>
```

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

### Create ToolView for ViewModel (XAML)

Source: https://wieslawsoltes.github.io/Dock/articles/dock-inpc.html

Defines the XAML for `ToolView`, a user control intended for `ToolViewModel`. It displays a header and the current `Status` of the tool using `TextBlock` elements within a `StackPanel`.

```xml
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="MyDockApp.Views.ToolView">
  <StackPanel>
    <TextBlock Text="Tool Panel" FontWeight="Bold" />
    <TextBlock Text="{Binding Status}" />
  </StackPanel>
</UserControl>
```
Tokens:
Raw