diff --git a/samples/DockMvvmSample/ViewModels/DockFactory.cs b/samples/DockMvvmSample/ViewModels/DockFactory.cs
index 9098cce70..b04e16bfb 100644
--- a/samples/DockMvvmSample/ViewModels/DockFactory.cs
+++ b/samples/DockMvvmSample/ViewModels/DockFactory.cs
@@ -137,6 +137,17 @@ public override IRootDock CreateLayout()
         return rootDock;
     }
 
+    public override IDockWindow? CreateWindowFrom(IDockable dockable)
+    {
+        var window = base.CreateWindowFrom(dockable);
+
+        if (window != null)
+        {
+            window.Title = "Dock Avalonia Demo";
+        }
+        return window;
+    }
+
     public override void InitLayout(IDockable layout)
     {
         ContextLocator = new Dictionary<string, Func<object?>>
diff --git a/src/Dock.Avalonia/Controls/HostWindow.axaml b/src/Dock.Avalonia/Controls/HostWindow.axaml
index d64af0d17..cab9c7213 100644
--- a/src/Dock.Avalonia/Controls/HostWindow.axaml
+++ b/src/Dock.Avalonia/Controls/HostWindow.axaml
@@ -6,6 +6,8 @@
     <HostWindow IsToolWindow="False" Width="300" Height="400" />
   </Design.PreviewWith>
 
+  <IntLessThanConverter x:Key="LessThan2" TrueIfLessThan="2" />
+
   <ControlTheme x:Key="{x:Type HostWindow}" TargetType="HostWindow">
 
     <Setter Property="Background" Value="{DynamicResource DockThemeBackgroundBrush}" />
@@ -17,7 +19,8 @@
     <Setter Property="Title" Value="{Binding ActiveDockable.Title}" />
     <Setter Property="Topmost" Value="{Binding Window.Topmost}" x:DataType="controls:IRootDock" />
     <Setter Property="SystemDecorations" Value="Full" />
-    <Setter Property="ExtendClientAreaToDecorationsHint" Value="True" />
+    <Setter Property="ToolChromeControlsWholeWindow" Value="{CompiledBinding OpenedDockablesCount, Converter={StaticResource LessThan2}}" x:DataType="controls:IRootDock" />
+    <Setter Property="ExtendClientAreaToDecorationsHint" Value="False" />
     <Setter Property="ExtendClientAreaChromeHints" Value="PreferSystemChrome" />
 
     <Setter Property="Template">
@@ -56,10 +59,13 @@
     <Style Selector="^:toolwindow">
 
       <Setter Property="SystemDecorations" Value="Full" />
-      <Setter Property="ExtendClientAreaToDecorationsHint" Value="True" />
-      <Setter Property="ExtendClientAreaChromeHints" Value="NoChrome" />
       <Setter Property="ExtendClientAreaTitleBarHeightHint" Value="0" />
 
+      <Style Selector="^:toolchromecontrolswindow">
+        <Setter Property="ExtendClientAreaToDecorationsHint" Value="True" />
+        <Setter Property="ExtendClientAreaChromeHints" Value="NoChrome" />
+      </Style>
+
       <Setter Property="Template">
         <ControlTemplate>
           <Panel>
diff --git a/src/Dock.Avalonia/Controls/HostWindow.axaml.cs b/src/Dock.Avalonia/Controls/HostWindow.axaml.cs
index a1ebff1df..f929318f7 100644
--- a/src/Dock.Avalonia/Controls/HostWindow.axaml.cs
+++ b/src/Dock.Avalonia/Controls/HostWindow.axaml.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia;
@@ -6,10 +7,12 @@
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.Styling;
 using Avalonia.VisualTree;
 using Dock.Avalonia.Internal;
 using Dock.Model;
+using Dock.Model.Controls;
 using Dock.Model.Core;
 
 namespace Dock.Avalonia.Controls;
@@ -22,7 +25,7 @@ public class HostWindow : Window, IHostWindow
 {
     private readonly DockManager _dockManager;
     private readonly HostWindowState _hostWindowState;
-    private Control? _chromeGrip;
+    private List<Control> _chromeGrips = new();
     private HostWindowTitleBar? _hostWindowTitleBar;
     private bool _mouseDown, _draggingWindow;
 
@@ -32,6 +35,12 @@ public class HostWindow : Window, IHostWindow
     public static readonly StyledProperty<bool> IsToolWindowProperty = 
         AvaloniaProperty.Register<HostWindow, bool>(nameof(IsToolWindow));
 
+    /// <summary>
+    /// Define <see cref="ToolChromeControlsWholeWindow"/> property.
+    /// </summary>
+    public static readonly StyledProperty<bool> ToolChromeControlsWholeWindowProperty =
+        AvaloniaProperty.Register<HostWindow, bool>(nameof(ToolChromeControlsWholeWindow));
+
     /// <inheritdoc/>
     protected override Type StyleKeyOverride => typeof(HostWindow);
 
@@ -44,6 +53,15 @@ public bool IsToolWindow
         set => SetValue(IsToolWindowProperty, value);
     }
 
+    /// <summary>
+    /// Gets or sets if the tool chrome controls the whole window.
+    /// </summary>
+    public bool ToolChromeControlsWholeWindow
+    {
+        get => GetValue(ToolChromeControlsWholeWindowProperty);
+        set => SetValue(ToolChromeControlsWholeWindowProperty, value);
+    }
+
     /// <inheritdoc/>
     public IDockManager DockManager => _dockManager;
 
@@ -66,7 +84,7 @@ public HostWindow()
 
         _dockManager = new DockManager();
         _hostWindowState = new HostWindowState(_dockManager, this);
-        UpdatePseudoClasses(IsToolWindow);
+        UpdatePseudoClasses(IsToolWindow, ToolChromeControlsWholeWindow);
     }
 
     /// <inheritdoc/>
@@ -99,6 +117,9 @@ private PixelPoint ClientPointToScreenRelativeToWindow(Point clientPoint)
 
     private void MoveDrag(PointerPressedEventArgs e)
     {
+        if (!ToolChromeControlsWholeWindow)
+            return;
+
         if (Window?.Factory?.OnWindowMoveDragBegin(Window) != true)
         {
             return;
@@ -127,7 +148,7 @@ protected override void OnPointerPressed(PointerPressedEventArgs e)
     {
         base.OnPointerPressed(e);
 
-        if (_chromeGrip is { } && _chromeGrip.IsPointerOver)
+        if (_chromeGrips.Any(grip => grip.IsPointerOver))
         {
             if (e.GetCurrentPoint(this).Properties.IsLeftButtonPressed)
             {
@@ -177,14 +198,35 @@ public void AttachGrip(ToolChromeControl chromeControl)
     {
         if (chromeControl.CloseButton is not null)
         {
-            chromeControl.CloseButton.Click += (_, _) => Exit();
+            chromeControl.CloseButton.Click += ChromeCloseClick;
+        }
+
+        if (chromeControl.Grip is { } grip)
+        {
+            _chromeGrips.Add(grip);
         }
 
-        _chromeGrip = chromeControl.Grip;
         ((IPseudoClasses)chromeControl.Classes).Add(":floating");
         IsToolWindow = true;
     }
 
+    /// <summary>
+    /// Detaches grip to chrome.
+    /// </summary>
+    /// <param name="chromeControl">The chrome control.</param>
+    public void DetachGrip(ToolChromeControl chromeControl)
+    {
+        if (chromeControl.Grip is { } grip)
+        {
+            _chromeGrips.Remove(grip);
+        }
+
+        if (chromeControl.CloseButton is not null)
+        {
+            chromeControl.CloseButton.Click -= ChromeCloseClick;
+        }
+    }
+
     /// <inheritdoc/>
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
@@ -192,13 +234,36 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
 
         if (change.Property == IsToolWindowProperty)
         {
-            UpdatePseudoClasses(change.GetNewValue<bool>());
+            UpdatePseudoClasses(change.GetNewValue<bool>(), ToolChromeControlsWholeWindow);
+        }
+        else if (change.Property == ToolChromeControlsWholeWindowProperty)
+        {
+            UpdatePseudoClasses(IsToolWindow, change.GetNewValue<bool>());
         }
     }
 
-    private void UpdatePseudoClasses(bool isToolWindow)
+    private void UpdatePseudoClasses(bool isToolWindow, bool toolChromeControlsWholeWindow)
     {
         PseudoClasses.Set(":toolwindow", isToolWindow);
+        PseudoClasses.Set(":toolchromecontrolswindow", toolChromeControlsWholeWindow);
+    }
+
+    private int CountVisibleToolsAndDocuments(IDockable? dockable)
+    {
+        switch (dockable)
+        {
+            case ITool: return 1;
+            case IDocument: return 1;
+            case IDock dock:
+                return dock.VisibleDockables?.Sum(CountVisibleToolsAndDocuments) ?? 0;
+            default: return 0;
+        }
+    }
+
+    private void ChromeCloseClick(object? sender, RoutedEventArgs e)
+    {
+        if (CountVisibleToolsAndDocuments(DataContext as IRootDock) <= 1)
+            Exit();
     }
 
     /// <inheritdoc/>
@@ -282,6 +347,8 @@ public void Present(bool isDialog)
                 var ownerDockControl = Window?.Layout?.Factory?.DockControls.FirstOrDefault();
                 if (ownerDockControl is Control control && control.GetVisualRoot() is Window parentWindow)
                 {
+                    Title = parentWindow.Title;
+                    Icon = parentWindow.Icon;
                     Show(parentWindow);
                 }
                 else
diff --git a/src/Dock.Avalonia/Controls/ToolChromeControl.axaml b/src/Dock.Avalonia/Controls/ToolChromeControl.axaml
index f871bceb5..b4a8a9a35 100644
--- a/src/Dock.Avalonia/Controls/ToolChromeControl.axaml
+++ b/src/Dock.Avalonia/Controls/ToolChromeControl.axaml
@@ -178,7 +178,7 @@
     </Style>
 
     <Style Selector="^:floating /template/ Grid#PART_Grip">
-      <Setter Property="(DockProperties.IsDragArea)" Value="False" />
+      <Setter Property="(DockProperties.IsDragArea)" Value="{Binding $parent[HostWindow].ToolChromeControlsWholeWindow, Mode=OneWay, Converter={x:Static BoolConverters.Not}}" />
     </Style>
 
     <Style Selector="^:active /template/ Grid#PART_Grip">
diff --git a/src/Dock.Avalonia/Controls/ToolChromeControl.axaml.cs b/src/Dock.Avalonia/Controls/ToolChromeControl.axaml.cs
index 1b86f3534..fb47f61e7 100644
--- a/src/Dock.Avalonia/Controls/ToolChromeControl.axaml.cs
+++ b/src/Dock.Avalonia/Controls/ToolChromeControl.axaml.cs
@@ -15,6 +15,8 @@ namespace Dock.Avalonia.Controls;
 [PseudoClasses(":floating", ":active", ":pinned", ":maximized")]
 public class ToolChromeControl : ContentControl
 {
+    private HostWindow? _attachedWindow;
+
     /// <summary>
     /// Define <see cref="Title"/> property.
     /// </summary>
@@ -106,9 +108,20 @@ public bool IsActive
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnAttachedToVisualTree(e);
-        AddHandler(PointerPressedEvent, PressedHandler, RoutingStrategies.Tunnel);
+        AttachToWindow();
+    }
+
+    /// <inheritdoc/>
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnDetachedFromVisualTree(e);
+        if (_attachedWindow != null)
+        {
+            _attachedWindow.DetachGrip(this);
+            _attachedWindow = null;
+        }
     }
-        
+
     private void PressedHandler(object? sender, PointerPressedEventArgs e)
     {
         if (DataContext is IDock {Factory: { } factory} dock && dock.ActiveDockable is { })
@@ -124,15 +137,23 @@ private void PressedHandler(object? sender, PointerPressedEventArgs e)
     protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
     {
         base.OnApplyTemplate(e);
+        Grip = e.NameScope.Find<Control>("PART_Grip");
+        CloseButton = e.NameScope.Find<Button>("PART_CloseButton");
+        AddHandler(PointerPressedEvent, PressedHandler, RoutingStrategies.Tunnel);
+        AttachToWindow();
+    }
+
+    private void AttachToWindow()
+    {
+        if (Grip == null)
+            return;
 
         //On linux we dont attach to the HostWindow because of inconsistent drag behaviour
-        if (VisualRoot is HostWindow window 
+        if (VisualRoot is HostWindow window
             && (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)))
         {
-            Grip = e.NameScope.Find<Control>("PART_Grip");
-            CloseButton = e.NameScope.Find<Button>("PART_CloseButton");
-
             window.AttachGrip(this);
+            _attachedWindow = window;
 
             SetCurrentValue(IsFloatingProperty, true);
         }
diff --git a/src/Dock.Avalonia/Converters/IntLessThanConverter.cs b/src/Dock.Avalonia/Converters/IntLessThanConverter.cs
new file mode 100644
index 000000000..89e6ceb1a
--- /dev/null
+++ b/src/Dock.Avalonia/Converters/IntLessThanConverter.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Globalization;
+using Avalonia.Data.Converters;
+
+namespace Dock.Avalonia.Converters;
+
+internal class IntLessThanConverter : IValueConverter
+{
+    public int TrueIfLessThan { get; set; }
+
+    public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is int intValue)
+        {
+            return intValue < TrueIfLessThan;
+        }
+        return false;
+    }
+
+    public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/src/Dock.Avalonia/Internal/DockControlState.cs b/src/Dock.Avalonia/Internal/DockControlState.cs
index cc0ccfad8..809ae3d45 100644
--- a/src/Dock.Avalonia/Internal/DockControlState.cs
+++ b/src/Dock.Avalonia/Internal/DockControlState.cs
@@ -247,14 +247,8 @@ public void Process(Point point, Vector delta, EventType eventType, DragAction d
                     Visual? targetDockControl = null;
                     Control? dropControl = null;
 
-                    foreach (var dockControl in dockControls)
+                    foreach (var inputDockControl in dockControls.GetZOrderedDockControls())
                     {
-                        if (dockControl is not Visual inputDockControl ||
-                            inputDockControl == inputActiveDockControl)
-                        {
-                            continue;
-                        }
-
                         if (inputActiveDockControl.GetVisualRoot() is null)
                         {
                             continue;
diff --git a/src/Dock.Avalonia/Internal/Extensions.cs b/src/Dock.Avalonia/Internal/Extensions.cs
new file mode 100644
index 000000000..bd272f465
--- /dev/null
+++ b/src/Dock.Avalonia/Internal/Extensions.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+using Dock.Avalonia.Controls;
+using Dock.Model.Core;
+
+namespace Dock.Avalonia.Internal;
+
+internal static class Extensions
+{
+    public static IEnumerable<DockControl> GetZOrderedDockControls(this IList<IDockControl> dockControls)
+    {
+        // Note: we should traverse the dock controls in their windows' z-order.
+        // However there is no way to get the z-order of a window in Avalonia.
+        // Uncomment once this PR is merged and a new Avalonia version is released
+        // https://github.com/AvaloniaUI/Avalonia/pull/14909
+        // return dockControls
+        //     .OfType<DockControl>()
+        //     .Select(dock => (dock, order: (dock.GetVisualRoot() as Window)?.WindowZOrder ?? IntPtr.Zero))
+        //     .OrderByDescending(x => x.order)
+        //     .Select(pair => pair.dock);
+
+        // For now, as a workaround, iterating in the reverse order of the dock controls is better then the regular order,
+        // because the main window dock control is always at index 0 and all the other windows are always
+        // on top of the main window.
+        return dockControls
+            .OfType<DockControl>()
+            .Reverse();
+    }
+}
diff --git a/src/Dock.Avalonia/Internal/HostWindowState.cs b/src/Dock.Avalonia/Internal/HostWindowState.cs
index 6806ac21a..792087b0b 100644
--- a/src/Dock.Avalonia/Internal/HostWindowState.cs
+++ b/src/Dock.Avalonia/Internal/HostWindowState.cs
@@ -121,7 +121,7 @@ private bool Validate(Point point, DockOperation operation, DragAction dragActio
 
         var layout = _hostWindow.Window?.Layout;
 
-        if (layout?.ActiveDockable is { } sourceDockable && _state.TargetDropControl.DataContext is IDockable targetDockable)
+        if (layout?.FocusedDockable is { } sourceDockable && _state.TargetDropControl.DataContext is IDockable targetDockable)
         {
             DockManager.Position = DockHelpers.ToDockPoint(point);
 
@@ -232,9 +232,9 @@ public void Process(PixelPoint point, EventType eventType)
                     break;
                 }
 
-                foreach (var visual in factory.DockControls)
+                foreach (var dockControl in factory.DockControls.GetZOrderedDockControls())
                 {
-                    if (visual is not DockControl dockControl || dockControl.Layout == _hostWindow.Window?.Layout)
+                    if (dockControl.Layout == _hostWindow.Window?.Layout)
                     {
                         continue;
                     }
@@ -284,15 +284,6 @@ public void Process(PixelPoint point, EventType eventType)
                             break;
                         }
                     }
-                    else
-                    {
-                        Leave();
-                        _state.TargetDockControl = null;
-                        _state.TargetPoint = default;
-                        _state.TargetDropControl = null;
-                        _state.DragAction = DragAction.Move;
-                        break;
-                    }
                 }
 
                 break;
diff --git a/src/Dock.Model.Avalonia/Core/DockBase.cs b/src/Dock.Model.Avalonia/Core/DockBase.cs
index 9ddedc477..d08ee14e4 100644
--- a/src/Dock.Model.Avalonia/Core/DockBase.cs
+++ b/src/Dock.Model.Avalonia/Core/DockBase.cs
@@ -74,6 +74,12 @@ public abstract class DockBase : DockableBase, IDock
     public static readonly DirectProperty<DockBase, bool> IsEmptyProperty =
         AvaloniaProperty.RegisterDirect<DockBase, bool>(nameof(IsEmpty), o => o.IsEmpty, (o, v) => o.IsEmpty = v);
 
+    /// <summary>
+    /// Defines the <see cref="OpenedDockablesCount"/> property.
+    /// </summary>
+    public static readonly DirectProperty<DockBase, int> OpenedDockablesCountProperty =
+        AvaloniaProperty.RegisterDirect<DockBase, int>(nameof(OpenedDockablesCount), o => o.OpenedDockablesCount, (o, v) => o.OpenedDockablesCount = v);
+
     /// <summary>
     /// Defines the <see cref="IsCollapsable"/> property.
     /// </summary>
@@ -104,6 +110,7 @@ public abstract class DockBase : DockableBase, IDock
     private bool _isCollapsable = true;
     private bool _canGoBack;
     private bool _canGoForward;
+    private int _openedDockablesCount;
 
     /// <summary>
     /// Initializes new instance of the <see cref="DockBase"/> class.
@@ -204,6 +211,15 @@ public bool IsEmpty
         set => SetAndRaise(IsEmptyProperty, ref _isEmpty, value);
     }
 
+    /// <inheritdoc/>
+    [DataMember(IsRequired = false, EmitDefaultValue = true)]
+    [JsonIgnore]
+    public int OpenedDockablesCount
+    {
+        get => _openedDockablesCount;
+        set => SetAndRaise(OpenedDockablesCountProperty, ref _openedDockablesCount, value);
+    }
+
     /// <inheritdoc/>
     [DataMember(IsRequired = false, EmitDefaultValue = true)]
     [JsonPropertyName("IsCollapsable")]
diff --git a/src/Dock.Model.Mvvm/Core/DockBase.cs b/src/Dock.Model.Mvvm/Core/DockBase.cs
index 42cdc928d..e14d9684c 100644
--- a/src/Dock.Model.Mvvm/Core/DockBase.cs
+++ b/src/Dock.Model.Mvvm/Core/DockBase.cs
@@ -21,6 +21,7 @@ public abstract class DockBase : DockableBase, IDock
     private double _proportion = double.NaN;
     private DockMode _dock = DockMode.Center;
     private bool _isCollapsable = true;
+    private int _openedDockablesCount = 0;
     private bool _isActive;
     private bool _isEmpty;
 
@@ -118,6 +119,14 @@ public bool IsCollapsable
         set => SetProperty(ref _isCollapsable, value);
     }
 
+    /// <inheritdoc/>
+    [DataMember(IsRequired = false, EmitDefaultValue = true)]
+    public int OpenedDockablesCount
+    {
+        get => _openedDockablesCount;
+        set => SetProperty(ref _openedDockablesCount, value);
+    }
+
     /// <inheritdoc/>
     [IgnoreDataMember]
     public bool CanGoBack => _navigateAdapter.CanGoBack;
diff --git a/src/Dock.Model.ReactiveUI/Core/DockBase.cs b/src/Dock.Model.ReactiveUI/Core/DockBase.cs
index 683895752..3be43ca0a 100644
--- a/src/Dock.Model.ReactiveUI/Core/DockBase.cs
+++ b/src/Dock.Model.ReactiveUI/Core/DockBase.cs
@@ -23,6 +23,7 @@ public abstract class DockBase : DockableBase, IDock
     private bool _isCollapsable = true;
     private bool _isActive;
     private bool _isEmpty;
+    private int _openedDockablesCount;
 
     /// <summary>
     /// Initializes new instance of the <see cref="DockBase"/> class.
@@ -110,6 +111,14 @@ public bool IsEmpty
         set => this.RaiseAndSetIfChanged(ref _isEmpty, value);
     }
 
+    /// <inheritdoc/>
+    [DataMember(IsRequired = false, EmitDefaultValue = true)]
+    public int OpenedDockablesCount
+    {
+        get => _openedDockablesCount;
+        set => this.RaiseAndSetIfChanged(ref _openedDockablesCount, value);
+    }
+
     /// <inheritdoc/>
     [DataMember(IsRequired = false, EmitDefaultValue = true)]
     public bool IsCollapsable
diff --git a/src/Dock.Model/Core/IDock.cs b/src/Dock.Model/Core/IDock.cs
index bfc6553a5..9901c7c07 100644
--- a/src/Dock.Model/Core/IDock.cs
+++ b/src/Dock.Model/Core/IDock.cs
@@ -53,6 +53,11 @@ public interface IDock : IDockable
     /// </summary>
     bool IsCollapsable { get; set; }
 
+    /// <summary>
+    /// Gets the number of currently opened and visible dockables
+    /// </summary>
+    int OpenedDockablesCount { get; set; }
+
     /// <summary>
     /// Gets a value that indicates whether there is at least one entry in back navigation history.
     /// </summary>
diff --git a/src/Dock.Model/DockManager.cs b/src/Dock.Model/DockManager.cs
index c830f060e..08a211c45 100644
--- a/src/Dock.Model/DockManager.cs
+++ b/src/Dock.Model/DockManager.cs
@@ -423,6 +423,25 @@ public bool ValidateDock(IDock sourceDock, IDockable targetDockable, DragAction
         };
     }
 
+    private bool ValidateProportionalDock(IProportionalDock sourceDock, IDockable targetDockable, DragAction action, DockOperation operation, bool bExecute)
+    {
+        if (sourceDock.VisibleDockables == null ||
+            sourceDock.VisibleDockables.Count == 0)
+            return false;
+
+        bool all = true;
+        for (int i = sourceDock.VisibleDockables.Count - 1; i >= 0; --i)
+        {
+            var dockable = sourceDock.VisibleDockables[i];
+            if (dockable is not IDock dock)
+                continue;
+
+            all &= ValidateDockable(dock, targetDockable, action, operation, bExecute);
+        }
+
+        return all;
+    }
+
     /// <inheritdoc/>
     public bool ValidateDockable(IDockable sourceDockable, IDockable targetDockable, DragAction action, DockOperation operation, bool bExecute)
     {
@@ -432,6 +451,7 @@ public bool ValidateDockable(IDockable sourceDockable, IDockable targetDockable,
             IDocumentDock documentDock => ValidateDock(documentDock, targetDockable, action, operation, bExecute),
             ITool tool => ValidateTool(tool, targetDockable, action, operation, bExecute),
             IDocument document => ValidateDocument(document, targetDockable, action, operation, bExecute),
+            IProportionalDock proportionalDock => ValidateProportionalDock(proportionalDock, targetDockable, action, operation, bExecute),
             _ => false
         };
     }
diff --git a/src/Dock.Model/FactoryBase.Dockable.cs b/src/Dock.Model/FactoryBase.Dockable.cs
index c987ef63b..b0b634c52 100644
--- a/src/Dock.Model/FactoryBase.Dockable.cs
+++ b/src/Dock.Model/FactoryBase.Dockable.cs
@@ -763,5 +763,28 @@ private void UpdateIsEmpty(IDock dock)
             if (dock.Owner is IDock parent)
                 UpdateIsEmpty(parent);
         }
+
+        UpdateOpenedDockablesCount(dock);
+    }
+
+    private void UpdateOpenedDockablesCount(IDockable dockable)
+    {
+        switch (dockable)
+        {
+            case IProportionalDock proportionalDock:
+                proportionalDock.OpenedDockablesCount = proportionalDock.VisibleDockables?.Sum(x => (x as IDock)?.OpenedDockablesCount ?? 0) ?? 0;
+                break;
+            case IRootDock rootDock:
+                rootDock.OpenedDockablesCount = rootDock.VisibleDockables?.Sum(x => (x as IDock)?.OpenedDockablesCount ?? 0) ?? 0;
+                break;
+            case IDock dock:
+                dock.OpenedDockablesCount = 1;
+                break;
+            default:
+                break;
+        }
+
+        if (dockable.Owner != null)
+            UpdateOpenedDockablesCount(dockable.Owner);
     }
 }