Keep windows on the displays that exist

When an external display is disconnected, Windows moves its windows onto
the remaining display without shrinking them. A terminal sized for the
larger display then overhangs the laptop panel with its caption buttons
out of reach. A saved position can also point at a display that is gone,
and the window was restored there as-is.

WindowPlacement.Fit takes a window rectangle and the current work areas.
When they cover all of the window it returns it unchanged, so a window
spanning two connected displays stays put. Otherwise it shrinks the
window to fit and moves it inside the work area it overlaps most, or the
nearest one when it overlaps none. Mirrored displays count once.

MainWindow applies it:

- at launch, after restoring a saved position or applying a requested
  one, before maximizing, so the window maximizes on a display that
  exists;
- when Screens.Changed fires, and again a second later, once Windows
  has finished moving windows off a removed display;
- when the window returns to Normal, since the OS restores the bounds
  it remembered from before the change.

A maximized or full-screen window keeps its state; its saved normal
bounds are fitted instead, so un-maximizing and the persisted layout
land on a display that exists. Minimized windows are left alone.

Windows Terminal only checks, at launch, that the window's top-left
corner is on some monitor, and never shrinks a window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: mamoreau-devolutions

src/Devolutions.Terminal.App/Platform/WindowPlacement.cs

@@ -0,0 +1,98 @@
+using Avalonia;
+
+namespace Devolutions.Terminal.App.Platform;
+
+/// <summary>
+/// Keeps a window reachable on the displays that exist now. A display can go
+/// away while the app runs or between runs (a laptop undocked); Windows moves a
+/// window off a removed display without shrinking it, and a restored position
+/// can point at a display that is gone, so a window can end up larger than the
+/// screen or outside it, with its caption buttons out of reach.
+/// </summary>
+public static class WindowPlacement
+{
+    /// <summary>
+    /// Returns <paramref name="bounds"/> unchanged when the work areas cover all of
+    /// it, so a window spanning two connected displays stays put. Otherwise returns
+    /// it shrunk to fit and moved inside the work area it overlaps most, or the
+    /// nearest one when it overlaps none. All values are physical pixels.
+    /// </summary>
+    public static PixelRect Fit(PixelRect bounds, IReadOnlyList<PixelRect> workAreas)
+    {
+        ArgumentNullException.ThrowIfNull(workAreas);
+        if (bounds.Width <= 0 || bounds.Height <= 0)
+        {
+            return bounds;
+        }
+
+        // Mirrored displays report the same work area; count it once.
+        var areas = workAreas.Where(static area => area.Width > 0 && area.Height > 0).Distinct().ToArray();
+        if (areas.Length == 0)
+        {
+            return bounds;
+        }
+
+        long covered = 0;
+        long bestOverlap = 0;
+        var target = areas[0];
+        foreach (var area in areas)
+        {
+            var overlap = OverlapArea(bounds, area);
+            covered += overlap;
+            if (overlap > bestOverlap)
+            {
+                bestOverlap = overlap;
+                target = area;
+            }
+        }
+
+        // Work areas do not overlap one another, so full coverage means every pixel
+        // of the window is on some display.
+        if (covered >= (long)bounds.Width * bounds.Height)
+        {
+            return bounds;
+        }
+
+        if (bestOverlap == 0)
+        {
+            target = Nearest(bounds, areas);
+        }
+
+        var width = Math.Min(bounds.Width, target.Width);
+        var height = Math.Min(bounds.Height, target.Height);
+        return new PixelRect(
+            Math.Clamp(bounds.X, target.X, target.Right - width),
+            Math.Clamp(bounds.Y, target.Y, target.Bottom - height),
+            width,
+            height);
+    }
+
+    private static long OverlapArea(PixelRect a, PixelRect b)
+    {
+        long width = Math.Min(a.Right, b.Right) - Math.Max(a.X, b.X);
+        long height = Math.Min(a.Bottom, b.Bottom) - Math.Max(a.Y, b.Y);
+        return width > 0 && height > 0 ? width * height : 0;
+    }
+
+    // The work area closest to the window's center.
+    private static PixelRect Nearest(PixelRect bounds, PixelRect[] areas)
+    {
+        var centerX = bounds.X + (bounds.Width / 2L);
+        var centerY = bounds.Y + (bounds.Height / 2L);
+        var nearest = areas[0];
+        var nearestDistance = long.MaxValue;
+        foreach (var area in areas)
+        {
+            var dx = centerX - Math.Clamp(centerX, area.X, area.Right);
+            var dy = centerY - Math.Clamp(centerY, area.Y, area.Bottom);
+            var distance = (dx * dx) + (dy * dy);
+            if (distance < nearestDistance)
+            {
+                nearestDistance = distance;
+                nearest = area;
+            }
+        }
+
+        return nearest;
+    }
+}

src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs

@@ -188,6 +188,20 @@ public MainWindow(
             {
                 UpdateFullscreenChrome();
             }
+
+            // Restoring from maximized brings back the bounds the OS remembered,
+            // which may no longer fit the displays.
+            if (args.Property == WindowStateProperty && WindowState == WindowState.Normal)
+            {
+                Dispatcher.UIThread.Post(FitNormalBoundsToScreens, DispatcherPriority.Background);
+            }
+        };
+        Screens.Changed += (_, _) =>
+        {
+            // Windows moves windows off a removed display shortly after reporting
+            // the change; fit again once that has settled.
+            Dispatcher.UIThread.Post(FitNormalBoundsToScreens, DispatcherPriority.Background);
+            DispatcherTimer.RunOnce(FitNormalBoundsToScreens, TimeSpan.FromSeconds(1));
         };
         AddHandler(KeyDownEvent, OnWindowKeyDown, RoutingStrategies.Tunnel);
         AddHandler(TextInputEvent, OnWindowTextInput, RoutingStrategies.Tunnel);
@@ -344,6 +358,12 @@ private void ApplyLaunchOptions(TerminalWindowActivation activation)
             Height = Math.Max(240, (rows * cell.Height) + 16 + titleBarHeight);
         }
 
+        // Without a requested position the OS places the window on a display.
+        if (activation.PositionX is not null && activation.PositionY is not null)
+        {
+            FitNormalBoundsToScreens();
+        }
+
         if (activation.LaunchMode.HasFlag(TerminalWindowLaunchMode.Fullscreen))
         {
             WindowState = WindowState.FullScreen;
@@ -3935,6 +3955,60 @@ private void MainWindow_OnSizeChanged(object? sender, SizeChangedEventArgs e)
         RebuildTabs();
     }
 
+    /// <summary>
+    /// Fits the normal-state bounds to the displays that exist now (see
+    /// <see cref="WindowPlacement.Fit"/>). A normal window moves and shrinks at
+    /// once; a maximized or full-screen one keeps its state, and the saved normal
+    /// bounds it would restore to are fitted instead. Minimized windows sit at an
+    /// off-screen placeholder position and are left alone.
+    /// </summary>
+    private void FitNormalBoundsToScreens()
+    {
+        if (WindowState == WindowState.Minimized)
+        {
+            return;
+        }
+
+        var workAreas = Screens.All.Select(static screen => screen.WorkingArea).ToArray();
+        var normal = WindowState == WindowState.Normal;
+        if (workAreas.Length == 0 || (!normal && _normalPosition is null))
+        {
+            return;
+        }
+
+        var position = normal ? Position : _normalPosition!.Value;
+        var width = normal ? (double.IsNaN(Width) ? Bounds.Width : Width) : _normalSize.Width;
+        var height = normal ? (double.IsNaN(Height) ? Bounds.Height : Height) : _normalSize.Height;
+        var scale = ScalingAt(position);
+        var bounds = new PixelRect(
+            position.X,
+            position.Y,
+            Math.Max(1, (int)Math.Round(width * scale)),
+            Math.Max(1, (int)Math.Round(height * scale)));
+        var fitted = WindowPlacement.Fit(bounds, workAreas);
+        if (fitted == bounds)
+        {
+            return;
+        }
+
+        var fittedScale = ScalingAt(fitted.Position);
+        _normalPosition = fitted.Position;
+        _normalSize = new WindowSizeState
+        {
+            Width = fitted.Width / fittedScale,
+            Height = fitted.Height / fittedScale,
+        };
+        if (normal)
+        {
+            Position = fitted.Position;
+            Width = _normalSize.Width;
+            Height = _normalSize.Height;
+        }
+
+        double ScalingAt(PixelPoint point) =>
+            Screens.ScreenFromPoint(point)?.Scaling ?? Screens.Primary?.Scaling ?? 1;
+    }
+
     private void CaptureNormalWindowBounds()
     {
         if (WindowState != WindowState.Normal)
@@ -4253,6 +4327,14 @@ private void ApplyPersistedWindowState(WindowLayoutState? state)
             Height = _normalSize.Height;
         }
 
+        // A saved position may belong to a display that is gone; fit before
+        // maximizing, so the window maximizes on a display that exists. Without
+        // one the OS places the window on a display.
+        if (_normalPosition is not null)
+        {
+            FitNormalBoundsToScreens();
+        }
+
         switch (state?.LaunchMode)
         {
             case LaunchMode.Maximized:

tests/Devolutions.Terminal.App.Tests/WindowPlacementTests.cs

@@ -0,0 +1,89 @@
+using Avalonia;
+using Devolutions.Terminal.App.Platform;
+using Xunit;
+
+namespace Devolutions.Terminal.App.Tests;
+
+public sealed class WindowPlacementTests
+{
+    // A 1920x1080 laptop panel with a 48-pixel taskbar, and a 2560x1440 external
+    // display to its right.
+    private static readonly PixelRect Laptop = new(0, 0, 1920, 1032);
+    private static readonly PixelRect External = new(1920, 0, 2560, 1392);
+
+    [Fact]
+    public void LeavesWindowInsideOneDisplayAlone()
+    {
+        var bounds = new PixelRect(100, 80, 1200, 800);
+        Assert.Equal(bounds, WindowPlacement.Fit(bounds, [Laptop, External]));
+    }
+
+    [Fact]
+    public void LeavesWindowSpanningConnectedDisplaysAlone()
+    {
+        var bounds = new PixelRect(1500, 100, 1000, 800);
+        Assert.Equal(bounds, WindowPlacement.Fit(bounds, [Laptop, External]));
+    }
+
+    [Fact]
+    public void ShrinksWindowLargerThanTheRemainingDisplay()
+    {
+        // Sized for the external display, then moved onto the laptop panel by
+        // Windows when the external one was disconnected.
+        var bounds = new PixelRect(100, 50, 2400, 1300);
+        Assert.Equal(Laptop, WindowPlacement.Fit(bounds, [Laptop]));
+    }
+
+    [Fact]
+    public void MovesWindowPartlyOffTheEdgeBackInside()
+    {
+        var bounds = new PixelRect(1500, 600, 800, 600);
+        Assert.Equal(new PixelRect(1120, 432, 800, 600), WindowPlacement.Fit(bounds, [Laptop]));
+    }
+
+    [Fact]
+    public void MovesWindowOnARemovedDisplayToTheNearestOne()
+    {
+        // Restored at a position on the external display, which is gone.
+        var bounds = new PixelRect(2500, 200, 1200, 800);
+        Assert.Equal(new PixelRect(720, 200, 1200, 800), WindowPlacement.Fit(bounds, [Laptop]));
+
+        // With a display left of the laptop too, the laptop is still the nearest.
+        var left = new PixelRect(-2560, 0, 2560, 1392);
+        Assert.Equal(new PixelRect(720, 200, 1200, 800), WindowPlacement.Fit(bounds, [left, Laptop]));
+    }
+
+    [Fact]
+    public void FitsIntoTheDisplayItOverlapsMostWhenPartIsOnNoDisplay()
+    {
+        // The external display is taller, so the bottom of a window spanning both
+        // hangs below the laptop panel, where there is no display.
+        var bounds = new PixelRect(1700, 600, 1000, 700);
+        Assert.Equal(new PixelRect(1920, 600, 1000, 700), WindowPlacement.Fit(bounds, [Laptop, External]));
+    }
+
+    [Fact]
+    public void HandlesDisplaysLeftOfAndAbovePrimary()
+    {
+        var left = new PixelRect(-2560, -360, 2560, 1392);
+        var bounds = new PixelRect(-3000, -500, 1000, 700);
+        Assert.Equal(new PixelRect(-2560, -360, 1000, 700), WindowPlacement.Fit(bounds, [left, Laptop]));
+    }
+
+    [Fact]
+    public void CountsMirroredDisplaysOnce()
+    {
+        // Two displays mirroring the same area would otherwise cover the off-screen
+        // half of the window twice over.
+        var bounds = new PixelRect(1400, 100, 1000, 700);
+        Assert.Equal(new PixelRect(920, 100, 1000, 700), WindowPlacement.Fit(bounds, [Laptop, Laptop]));
+    }
+
+    [Fact]
+    public void LeavesBoundsAloneWithoutDisplayInformation()
+    {
+        var bounds = new PixelRect(5000, 5000, 800, 600);
+        Assert.Equal(bounds, WindowPlacement.Fit(bounds, []));
+        Assert.Equal(bounds, WindowPlacement.Fit(bounds, [new PixelRect(0, 0, 0, 0)]));
+    }
+}