Overlays

Dock.slnx

@@ -54,6 +54,7 @@
     <Project Path="samples/DockMvvmSample/DockMvvmSample.csproj" />
     <Project Path="samples/DockPrismSample/DockPrismSample.csproj" />
     <Project Path="samples/DockReactivePropertySample/DockReactivePropertySample.csproj" />
+    <Project Path="samples/DockReactiveUICanonicalSample/DockReactiveUICanonicalSample.csproj" />
     <Project Path="samples/DockReactiveUIDiSample/DockReactiveUIDiSample.csproj" />
     <Project Path="samples/DockReactiveUIRoutingSample/DockReactiveUIRoutingSample.csproj" />
     <Project Path="samples/DockReactiveUISample/DockReactiveUISample.csproj" />
@@ -75,13 +76,13 @@
     <Project Path="src/Dock.MarkupExtension/Dock.MarkupExtension.csproj" />
     <Project Path="src/Dock.Model.Avalonia/Dock.Model.Avalonia.csproj" />
     <Project Path="src/Dock.Model.CaliburMicro/Dock.Model.CaliburMicro.csproj" />
-    <Project Path="src/Dock.Model.Extensions.DependencyInjection/Dock.Model.Extensions.DependencyInjection.csproj" />
     <Project Path="src/Dock.Model.Inpc/Dock.Model.Inpc.csproj" />
     <Project Path="src/Dock.Model.Mvvm/Dock.Model.Mvvm.csproj" />
     <Project Path="src/Dock.Model.Prism/Dock.Model.Prism.csproj" />
     <Project Path="src/Dock.Model.ReactiveProperty/Dock.Model.ReactiveProperty.csproj" />
-    <Project Path="src/Dock.Model.ReactiveUI.Navigation/Dock.Model.ReactiveUI.Navigation.csproj" />
     <Project Path="src/Dock.Model.ReactiveUI/Dock.Model.ReactiveUI.csproj" />
+    <Project Path="src/Dock.Model.ReactiveUI.Services/Dock.Model.ReactiveUI.Services.csproj" />
+    <Project Path="src/Dock.Model.ReactiveUI.Services.Avalonia/Dock.Model.ReactiveUI.Services.Avalonia.csproj" />
     <Project Path="src/Dock.Model/Dock.Model.csproj" />
     <Project Path="src/Dock.Serializer.Newtonsoft/Dock.Serializer.Newtonsoft.csproj" />
     <Project Path="src/Dock.Serializer.Protobuf/Dock.Serializer.Protobuf.csproj" />

README.md

@@ -76,7 +76,6 @@ Model packages:
 - `Dock.Model.Prism` - Prism framework integration
 - `Dock.Model.Inpc` - INotifyPropertyChanged base implementation
 - `Dock.Model.Avalonia` - Avalonia-specific model extensions
-- `Dock.Model.Extensions.DependencyInjection` - .NET DI container integration
 
 Serialization packages:
 - `Dock.Serializer.Newtonsoft` - JSON serialization using Newtonsoft.Json

build-docs.ps1

@@ -3,3 +3,5 @@ dotnet tool restore
 dotnet build -c Release
 dotnet docfx docfx/docfx.json
 rm -rf src/Dock.Model.ReactiveUI/Generated
+rm -rf src/Dock.Model.ReactiveUI.Services/Generated
+rm -rf src/Dock.Model.ReactiveUI.Services.Avalonia/Generated

build-docs.sh

@@ -4,3 +4,5 @@ dotnet build -c Release
 dotnet tool restore
 dotnet docfx docfx/docfx.json
 rm -rf src/Dock.Model.ReactiveUI/Generated
+rm -rf src/Dock.Model.ReactiveUI.Services/Generated
+rm -rf src/Dock.Model.ReactiveUI.Services.Avalonia/Generated

docfx/articles/README.md

@@ -58,6 +58,7 @@ Choose the implementation that matches your MVVM framework:
 - [Programmatic docking](dock-programmatic-docking.md) – Use `DockService` to validate and execute docking operations.
 - [Drag actions and modifiers](dock-drag-actions.md) – How modifier keys map to docking actions.
 - [Styling and theming](dock-styling.md) – Customize the appearance of Dock controls.
+- [Overlay customization](dock-overlay-customization.md) – Customize overlay layers and control themes.
 - [DataTemplates and custom dock types](dock-datatemplates.md) – Create custom dock types with their own visual representation.
 - [Custom themes](dock-custom-theme.md) – Build and apply your own theme.
 - [Context menus](dock-context-menus.md) – Localize or replace built-in menus.
@@ -99,6 +100,7 @@ Choose the implementation that matches your MVVM framework:
 - [Dock settings](dock-settings.md) – Global drag/drop options and thresholds.
 - [Dock properties](dock-properties.md) – Use attached properties to mark drag areas and drop targets.
 - [DockSettings in controls](dock-settings-controls.md) – Apply global drag/drop settings when writing custom controls.
+- [Overlay services and host resolution](dock-overlay-services-reference.md) – Busy/dialog/confirmation services and host lookup flow.
 
 ## Samples and additional resources
 

docfx/articles/dock-dependency-injection.md

@@ -1,16 +1,10 @@
 # Dependency injection
 
-Dock provides an integration library for the default .NET service container. The `Dock.Model.Extensions.DependencyInjection` package exposes an `AddDock` extension for `IServiceCollection`.
+Dock does not ship a dedicated dependency injection helper package. Register the core services manually, or copy the `AddDock` helper from `samples/DockReactiveUIDiSample/ServiceCollectionExtensions.cs` into your application.
 
 ## Installation
 
-First, install the dependency injection package:
-
-```bash
-dotnet add package Dock.Model.Extensions.DependencyInjection
-```
-
-Also install your preferred serializer package:
+Install your preferred serializer package:
 
 ```bash
 # Choose one serializer:
@@ -21,51 +15,52 @@ dotnet add package Dock.Serializer.Xml               # XML
 dotnet add package Dock.Serializer.Yaml              # YAML
 ```
 
+If you are using the default .NET service container, ensure you have the DI package:
+
+```bash
+dotnet add package Microsoft.Extensions.DependencyInjection
+```
+
 ## Register services
 
-Reference the package and register your factory and serializer types during startup:
+Register your factory and serializer types during startup:
 
 ```csharp
-using Dock.Model.Extensions.DependencyInjection;
+using Dock.Model.Core;
 using Dock.Serializer; // or your preferred serializer namespace
+using Microsoft.Extensions.DependencyInjection;
 
-// Register with JSON serializer (Newtonsoft.Json)
-services.AddDock<MyDockFactory, DockSerializer>();
-
-// Or with System.Text.Json serializer
-services.AddDock<MyDockFactory, Dock.Serializer.SystemTextJson.DockSerializer>();
-
-// Or with Protobuf serializer
-services.AddDock<MyDockFactory, ProtobufDockSerializer>();
-
-// Or with XML serializer
-services.AddDock<MyDockFactory, DockXmlSerializer>();
+services.AddSingleton<IDockState, DockState>();
+services.AddSingleton<MyDockFactory>();
+services.AddSingleton<IFactory>(static sp => sp.GetRequiredService<MyDockFactory>());
 
-// Or with YAML serializer  
-services.AddDock<MyDockFactory, DockYamlSerializer>();
+services.AddSingleton<DockSerializer>();
+services.AddSingleton<IDockSerializer>(static sp => sp.GetRequiredService<DockSerializer>());
 ```
 
 This registers `IDockState`, your factory implementation as `IFactory`, and the serializer as `IDockSerializer`.
 
-## Complete example
+If you prefer an `AddDock` helper, copy the sample extension from `samples/DockReactiveUIDiSample/ServiceCollectionExtensions.cs`.
 
-Here's a full example showing how to set up dependency injection with Dock:
+## Complete example
 
 ```csharp
-using Microsoft.Extensions.DependencyInjection;
-using Dock.Model.Extensions.DependencyInjection;
+using Dock.Model.Core;
 using Dock.Serializer;
+using Microsoft.Extensions.DependencyInjection;
 
 public void ConfigureServices(IServiceCollection services)
 {
-    // Register your view models and views
     services.AddTransient<MyDocumentViewModel>();
     services.AddTransient<MyToolViewModel>();
-
-    // Register Dock services
-    services.AddDock<MyDockFactory, DockSerializer>();
-
-    // Register other application services
+
+    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>();
 }
 ```
@@ -82,36 +77,39 @@ public class MainWindowViewModel
     private readonly IDockSerializer _serializer;
 
     public MainWindowViewModel(
-        IFactory factory, 
-        IDockState dockState, 
+        IFactory factory,
+        IDockState dockState,
         IDockSerializer serializer)
     {
         _factory = factory;
         _dockState = dockState;
         _serializer = serializer;
-
-        // Create layout using the factory
+
         Layout = _factory.CreateLayout();
         _factory.InitLayout(Layout);
     }
-    
+
     public IRootDock Layout { get; }
 }
 ```
 
 ## Framework-specific registration
 
-For ReactiveUI applications, you can also register the ReactiveUI-specific factory:
+For ReactiveUI applications, register your ReactiveUI factory in the same way:
 
 ```csharp
-using Dock.Model.Extensions.DependencyInjection;
-using Dock.Model.ReactiveUI;
+using Dock.Model.Core;
+using Dock.Serializer;
+using Microsoft.Extensions.DependencyInjection;
 
-services.AddDock<MyReactiveUIFactory, DockSerializer>();
+services.AddSingleton<IDockState, DockState>();
+services.AddSingleton<MyReactiveUIFactory>();
+services.AddSingleton<IFactory>(static sp => sp.GetRequiredService<MyReactiveUIFactory>());
+
+services.AddSingleton<DockSerializer>();
+services.AddSingleton<IDockSerializer>(static sp => sp.GetRequiredService<DockSerializer>());
 ```
 
 Where `MyReactiveUIFactory` derives from `Dock.Model.ReactiveUI.Factory`.
 
 For an overview of all guides see the [documentation index](README.md).
-
-

docfx/articles/dock-inpc.md

@@ -32,7 +32,7 @@ Follow these instructions to create a minimal INPC-based application using Dock.
    dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
 
    # For dependency injection:
-   dotnet add package Dock.Model.Extensions.DependencyInjection
+   dotnet add package Microsoft.Extensions.DependencyInjection
    ```
 
 3. **Set up View Locator (Required)**

docfx/articles/dock-mvvm.md

@@ -36,7 +36,7 @@ The following steps walk you through creating a very small application that uses
    dotnet add package Dock.Serializer.SystemTextJson    # JSON (System.Text.Json)
 
    # For dependency injection:
-   dotnet add package Dock.Model.Extensions.DependencyInjection
+   dotnet add package Microsoft.Extensions.DependencyInjection
    ```
 
 3. **Set up View Locator (Required)**

docfx/articles/dock-overlay-customization.md

@@ -0,0 +1,131 @@
+# Overlay customization guide
+
+This guide explains how to customize the overlay stack and control themes used by `OverlayHost`, including custom layers, order changes, and template overrides.
+
+## Default overlay stack
+The Fluent theme ships a default layer collection (`DockDefaultOverlayLayers`) that contains:
+- Dialog overlay (ZIndex 10)
+- Confirmation overlay (ZIndex 20)
+- Busy overlay (ZIndex 30)
+
+Each layer uses a style key from `OverlayLayerStyleKeys` so the control theme can be replaced without changing the layer definition.
+
+## Replace the overlay layer stack
+Use a custom `OverlayLayerCollection` to change ordering, input blocking, or the overlay controls used.
+
+```xml
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <OverlayLayerCollection x:Key="MyOverlayLayers" x:Shared="False">
+    <OverlayLayer ZIndex="5"
+                  BlocksInput="False"
+                  StyleKey="{x:Static OverlayLayerStyleKeys.DialogLayerThemeKey}">
+      <DialogOverlayControl DialogService="{Binding Dialogs}"
+                            GlobalDialogService="{Binding GlobalDialogService}" />
+    </OverlayLayer>
+    <OverlayLayer ZIndex="15"
+                  StyleKey="{x:Static OverlayLayerStyleKeys.ConfirmationLayerThemeKey}">
+      <ConfirmationOverlayControl ConfirmationService="{Binding Confirmations}"
+                                  GlobalConfirmationService="{Binding GlobalConfirmationService}" />
+    </OverlayLayer>
+    <OverlayLayer ZIndex="25"
+                  StyleKey="{x:Static OverlayLayerStyleKeys.BusyLayerThemeKey}">
+      <BusyOverlayControl BusyService="{Binding Busy}"
+                          GlobalBusyService="{Binding GlobalBusyService}" />
+    </OverlayLayer>
+  </OverlayLayerCollection>
+
+  <ControlTheme x:Key="{x:Type OverlayHost}" TargetType="OverlayHost">
+    <Setter Property="OverlayLayers" Value="{DynamicResource MyOverlayLayers}" />
+  </ControlTheme>
+</ResourceDictionary>
+```
+
+Notes:
+- Set `x:Shared="False"` for `OverlayLayerCollection` so each host window gets its own instances.
+- `BlocksInput="False"` allows pointer input to pass through when the overlay is visible.
+
+## Add a custom overlay layer
+Create a custom overlay control and insert it into the stack with a new `OverlayLayer`.
+
+```xml
+<OverlayLayerCollection x:Key="MyOverlayLayers" x:Shared="False">
+  <OverlayLayer ZIndex="5" BlocksInput="False">
+    <MyNotificationOverlay IsVisible="{Binding HasNotifications}" />
+  </OverlayLayer>
+  <OverlayLayer ZIndex="10"
+                StyleKey="{x:Static OverlayLayerStyleKeys.DialogLayerThemeKey}">
+    <DialogOverlayControl DialogService="{Binding Dialogs}"
+                          GlobalDialogService="{Binding GlobalDialogService}" />
+  </OverlayLayer>
+  <OverlayLayer ZIndex="20"
+                StyleKey="{x:Static OverlayLayerStyleKeys.ConfirmationLayerThemeKey}">
+    <ConfirmationOverlayControl ConfirmationService="{Binding Confirmations}"
+                                GlobalConfirmationService="{Binding GlobalConfirmationService}" />
+  </OverlayLayer>
+  <OverlayLayer ZIndex="30"
+                StyleKey="{x:Static OverlayLayerStyleKeys.BusyLayerThemeKey}">
+    <BusyOverlayControl BusyService="{Binding Busy}"
+                        GlobalBusyService="{Binding GlobalBusyService}" />
+  </OverlayLayer>
+</OverlayLayerCollection>
+```
+
+## Override overlay control themes
+You can replace the control templates or update visuals via `ControlTheme` resources. The overlay layers reference these keys:
+- `OverlayLayerStyleKeys.BusyLayerThemeKey`
+- `OverlayLayerStyleKeys.DialogLayerThemeKey`
+- `OverlayLayerStyleKeys.ConfirmationLayerThemeKey`
+
+Example: override the busy overlay theme.
+
+```xml
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ControlTheme x:Key="{x:Static OverlayLayerStyleKeys.BusyLayerThemeKey}"
+                TargetType="BusyOverlayControl"
+                BasedOn="{StaticResource {x:Type BusyOverlayControl}}">
+    <Setter Property="Template">
+      <ControlTemplate>
+        <!-- Custom template markup here. -->
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+</ResourceDictionary>
+```
+
+## Replace dialog and confirmation shells
+Dialog overlays use data templates defined in `OverlayDataTemplates.axaml`. Override them by replacing the resource keys:
+- `DockDialogRequestTemplate`
+- `DockConfirmationRequestTemplate`
+
+```xml
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:services="using:Dock.Model.Services">
+  <DataTemplate x:Key="DockDialogRequestTemplate" DataType="services:DialogRequest">
+    <MyDialogShell Title="{Binding Title}" Content="{Binding Content}" />
+  </DataTemplate>
+  <DataTemplate x:Key="DockConfirmationRequestTemplate" DataType="services:ConfirmationRequest">
+    <MyConfirmationShell Title="{Binding Title}" Message="{Binding Message}" />
+  </DataTemplate>
+</ResourceDictionary>
+```
+
+## DI-based overlay layer registration
+If you want to resolve layers from DI, register `IOverlayLayer` or `IOverlayLayerFactory` implementations and set the registry provider:
+
+```csharp
+OverlayLayerRegistry.UseServiceProvider(serviceProvider);
+```
+
+Set `OverlayHost.UseServiceLayers="True"` (default) to include DI-provided layers alongside the local `OverlayLayers` collection.
+
+## Visual tree lifecycle
+Use `VisualTreeLifecycleBehavior.IsEnabled="True"` on the root `OverlayHost` so overlays rebind when windows or dock controls move in the visual tree.
+
+```xml
+<OverlayHost VisualTreeLifecycleBehavior.IsEnabled="True">
+  <DockControl Layout="{Binding}" />
+</OverlayHost>
+```