fix(quicklayout): account for macOS scaling in overlay and move/resize

Window.Position is physical pixels on Windows but logical points on
macOS, so the quick-layout overlay sized itself from physical bounds
without dividing by the Retina scale factor and rendered ~half-screen,
mislocating click/drag placement and Move/Resize on HiDPI displays.

Add a WindowPositionScaling seam (identity on Windows, /scaling on
macOS) and a shared WindowScreenScaling helper; route every
Window.Position read/write in the quick-layout paths through it. The
overlay now takes the target window's screen scaling explicitly,
dropping the OnOpened/RenderScalingSafe deferral hack. Add debug
logging at each coordinate-space boundary and unit tests for the seam.

Author: zentialEdwardSu

src/YASN.App/PlatformServices/AvaloniaQuickWindowLayoutController.cs

@@ -17,8 +17,10 @@ public sealed class AvaloniaQuickWindowLayoutController : IQuickWindowLayoutCont
         /// <param name="target">The target screen region.</param>
         public void Move(Window window, QuickMoveTarget target)
         {
-            double scaling = GetScaling(window);
-            WindowRect result = QuickWindowLayout.Move(ToPhysicalRect(window, scaling), GetWorkingArea(window), target);
+            double scaling = WindowScreenScaling.Get(window);
+            WindowRect current = ToPhysicalRect(window, scaling);
+            WindowRect result = QuickWindowLayout.Move(current, GetWorkingArea(window), target);
+            AppLogger.Debug($"QuickLayout move: target={target} scaling={scaling} current={current} result={result}");
             Apply(window, result, scaling);
         }
 
@@ -30,14 +32,16 @@ public void Move(Window window, QuickMoveTarget target)
         /// <param name="height">The requested height in logical units.</param>
         public void Resize(Window window, double width, double height)
         {
-            double scaling = GetScaling(window);
+            double scaling = WindowScreenScaling.Get(window);
+            WindowRect current = ToPhysicalRect(window, scaling);
             WindowRect result = QuickWindowLayout.Resize(
-                ToPhysicalRect(window, scaling),
+                current,
                 GetWorkingArea(window),
                 width * scaling,
                 height * scaling,
                 window.MinWidth * scaling,
                 window.MinHeight * scaling);
+            AppLogger.Debug($"QuickLayout resize: requestedDip={width}x{height} scaling={scaling} current={current} result={result}");
             Apply(window, result, scaling);
         }
 
@@ -49,26 +53,26 @@ public void Resize(Window window, double width, double height)
         public void ApplyBounds(Window window, WindowRect bounds)
         {
             // Left/Top arrive in physical pixels (window position space) and Width/Height in DIP
-            // (window size space), so each component is applied to its matching coordinate space.
-            window.Position = new PixelPoint((int)Math.Round(bounds.Left), (int)Math.Round(bounds.Top));
+            // (window size space). Left/Top is mapped through the platform position seam (identity on
+            // Windows, divide-by-scaling on macOS); Width/Height are already DIP and applied directly.
+            double scaling = WindowScreenScaling.Get(window);
+            int left = (int)Math.Round(WindowPositionScaling.PhysicalToPosition(bounds.Left, scaling, WindowPositionScaling.PositionIsLogical));
+            int top = (int)Math.Round(WindowPositionScaling.PhysicalToPosition(bounds.Top, scaling, WindowPositionScaling.PositionIsLogical));
+            window.Position = new PixelPoint(left, top);
             window.Width = Math.Max(window.MinWidth, bounds.Width);
             window.Height = Math.Max(window.MinHeight, bounds.Height);
+            AppLogger.Debug($"QuickLayout applyBounds: bounds={bounds} scaling={scaling} pos=({left},{top}) sizeDip={window.Width}x{window.Height}");
         }
 
-        // Avalonia exposes window position in physical pixels but width/height in logical units,
-        // while screen working areas are physical pixels. Quick-layout math must run in a single
-        // space, so everything is normalized to physical pixels here using the window scaling.
+        // Avalonia exposes window width/height in logical units while screen working areas are physical
+        // pixels, and Window.Position is physical pixels on Windows but logical points on macOS. Quick-
+        // layout math must run in a single space, so everything is normalized to physical pixels here:
+        // the position is mapped through the platform seam and the DIP size is multiplied by scaling.
         private static WindowRect ToPhysicalRect(Window window, double scaling)
         {
-            return new WindowRect(window.Position.X, window.Position.Y, window.Width * scaling, window.Height * scaling);
-        }
-
-        private static double GetScaling(Window window)
-        {
-            Screen? screen = window.Screens.ScreenFromWindow(window) ?? window.Screens.Primary;
-            double scaling = screen?.Scaling ?? window.RenderScaling;
-
-            return scaling <= 0 ? 1.0 : scaling;
+            double left = WindowPositionScaling.PositionToPhysical(window.Position.X, scaling, WindowPositionScaling.PositionIsLogical);
+            double top = WindowPositionScaling.PositionToPhysical(window.Position.Y, scaling, WindowPositionScaling.PositionIsLogical);
+            return new WindowRect(left, top, window.Width * scaling, window.Height * scaling);
         }
 
         private static WindowRect GetWorkingArea(Window window)
@@ -81,9 +85,12 @@ private static WindowRect GetWorkingArea(Window window)
 
         private static void Apply(Window window, WindowRect rect, double scaling)
         {
-            window.Position = new PixelPoint((int)Math.Round(rect.Left), (int)Math.Round(rect.Top));
+            int left = (int)Math.Round(WindowPositionScaling.PhysicalToPosition(rect.Left, scaling, WindowPositionScaling.PositionIsLogical));
+            int top = (int)Math.Round(WindowPositionScaling.PhysicalToPosition(rect.Top, scaling, WindowPositionScaling.PositionIsLogical));
+            window.Position = new PixelPoint(left, top);
             window.Width = rect.Width / scaling;
             window.Height = rect.Height / scaling;
+            AppLogger.Debug($"QuickLayout apply: rect={rect} scaling={scaling} pos=({left},{top}) sizeDip={window.Width}x{window.Height}");
         }
     }
 }

src/YASN.App/PlatformServices/WindowScreenScaling.cs

@@ -0,0 +1,28 @@
+using Avalonia.Controls;
+using Avalonia.Platform;
+
+namespace YASN.PlatformServices
+{
+    /// <summary>
+    /// Resolves the scale factor (physical pixels per logical point) of the screen a window currently
+    /// occupies. Shared by the quick-layout controller and the overlay so both use one definition of
+    /// "the scaling where the note lives" — the overlay can span several monitors, so its own
+    /// <c>RenderScaling</c> is ambiguous; the target window's screen is the authoritative source.
+    /// </summary>
+    public static class WindowScreenScaling
+    {
+        /// <summary>
+        /// Gets the scale factor of the screen the window is on, falling back to the window's render
+        /// scaling and finally to 1.0 when no positive value is available.
+        /// </summary>
+        /// <param name="window">The window whose screen scaling is wanted.</param>
+        /// <returns>The scale factor, always greater than zero.</returns>
+        public static double Get(Window window)
+        {
+            Screen? screen = window.Screens.ScreenFromWindow(window) ?? window.Screens.Primary;
+            double scaling = screen?.Scaling ?? window.RenderScaling;
+
+            return scaling <= 0 ? 1.0 : scaling;
+        }
+    }
+}

src/YASN.App/Views/FloatingNoteWindow.axaml.cs

@@ -642,7 +642,8 @@ private async void HandleQuickLayoutClick(object? sender, RoutedEventArgs e)
         /// </summary>
         public async Task ShowQuickLayoutOverlay()
         {
-            QuickLayoutOverlayWindow overlay = new QuickLayoutOverlayWindow(Width, Height);
+            double scaling = WindowScreenScaling.Get(this);
+            QuickLayoutOverlayWindow overlay = new QuickLayoutOverlayWindow(Width, Height, scaling);
             WindowRect? bounds = await overlay.ShowDialog<WindowRect?>(this).ConfigureAwait(true);
             if (bounds is not null)
             {

src/YASN.App/Views/QuickLayoutOverlayWindow.axaml.cs

@@ -23,7 +23,7 @@ public sealed partial class QuickLayoutOverlayWindow : Window
         private readonly Rectangle selectionRectangle;
         private readonly double currentWidthDip;
         private readonly double currentHeightDip;
-        private readonly PixelRect virtualBounds;
+        private readonly double scaling;
         private readonly PixelPoint virtualOrigin;
 
         private Point? dragStart;
@@ -32,19 +32,25 @@ public sealed partial class QuickLayoutOverlayWindow : Window
         /// Initializes the overlay for the XAML designer.
         /// </summary>
         public QuickLayoutOverlayWindow()
-            : this(640, 400)
+            : this(640, 400, 1.0)
         {
         }
 
         /// <summary>
-        /// Initializes the overlay for a target window of the given current size.
+        /// Initializes the overlay for a target window of the given current size and screen scaling.
         /// </summary>
         /// <param name="currentWidthDip">The target window width, in DIP, used for a click reposition.</param>
         /// <param name="currentHeightDip">The target window height, in DIP, used for a click reposition.</param>
-        public QuickLayoutOverlayWindow(double currentWidthDip, double currentHeightDip)
+        /// <param name="scaling">
+        /// The scale factor of the screen the target window is on (physical pixels per DIP). Passed in
+        /// rather than read from the overlay's own <see cref="TopLevel.RenderScaling"/>, which is
+        /// ambiguous for a window spanning monitors and is not yet valid before the window is shown.
+        /// </param>
+        public QuickLayoutOverlayWindow(double currentWidthDip, double currentHeightDip, double scaling)
         {
             this.currentWidthDip = currentWidthDip;
             this.currentHeightDip = currentHeightDip;
+            this.scaling = scaling <= 0 ? 1.0 : scaling;
             InitializeComponent();
 
             overlayCanvas = this.FindControl<Canvas>("OverlayCanvas")
@@ -53,34 +59,26 @@ public QuickLayoutOverlayWindow(double currentWidthDip, double currentHeightDip)
                 ?? throw new InvalidOperationException("SelectionRectangle was not found.");
 
             PixelRect bounds = GetVirtualDesktopBounds();
-            virtualBounds = bounds;
             virtualOrigin = bounds.Position;
-            Position = bounds.Position;
 
-            // Size is deferred to OnOpened: RenderScaling is only valid once the window is shown.
-            // Computing it here reads an uninitialized scale, which on macOS Retina (where the
-            // primary screen reports Scaling 1.0 despite a 2x render scale) sizes the overlay 2x too
-            // large and breaks the click/drag -> position/size mapping.
+            // The union origin is physical pixels; Window.Position is physical on Windows but logical
+            // points on macOS, so map it through the platform seam. Size is DIP on every platform, so
+            // divide the physical span by scaling. Both use the target window's screen scaling, which
+            // is valid here (no need to defer to OnOpened).
+            Position = new PixelPoint(
+                (int)Math.Round(WindowPositionScaling.PhysicalToPosition(bounds.X, this.scaling, WindowPositionScaling.PositionIsLogical)),
+                (int)Math.Round(WindowPositionScaling.PhysicalToPosition(bounds.Y, this.scaling, WindowPositionScaling.PositionIsLogical)));
+            Width = bounds.Width / this.scaling;
+            Height = bounds.Height / this.scaling;
+
+            AppLogger.Debug($"QuickLayout overlay: positionLogical={WindowPositionScaling.PositionIsLogical} scaling={this.scaling} union={bounds} pos={Position} sizeDip={Width}x{Height}");
 
             overlayCanvas.PointerPressed += HandlePointerPressed;
             overlayCanvas.PointerMoved += HandlePointerMoved;
             overlayCanvas.PointerReleased += HandlePointerReleased;
             KeyDown += HandleKeyDown;
         }
 
-        /// <summary>
-        /// Sizes the overlay to span the virtual desktop once the window is shown and
-        /// <see cref="TopLevel.RenderScaling"/> reports the real scale factor.
-        /// </summary>
-        protected override void OnOpened(EventArgs e)
-        {
-            base.OnOpened(e);
-
-            double scaling = RenderScalingSafe();
-            Width = virtualBounds.Width / scaling;
-            Height = virtualBounds.Height / scaling;
-        }
-
         private void InitializeComponent()
         {
             AvaloniaXamlLoader.Load(this);
@@ -103,17 +101,6 @@ private PixelRect GetVirtualDesktopBounds()
             return union;
         }
 
-        private double RenderScalingSafe()
-        {
-            double scaling = RenderScaling;
-            if (scaling > 0)
-            {
-                return scaling;
-            }
-
-            return Screens.Primary?.Scaling is { } primary and > 0 ? primary : 1.0;
-        }
-
         private void HandlePointerPressed(object? sender, PointerPressedEventArgs e)
         {
             PointerPoint point = e.GetCurrentPoint(overlayCanvas);
@@ -166,13 +153,15 @@ private void HandlePointerReleased(object? sender, PointerReleasedEventArgs e)
             WindowRect result = QuickLayoutSelection.Resolve(
                 start,
                 end,
-                RenderScalingSafe(),
+                scaling,
                 virtualOrigin.X,
                 virtualOrigin.Y,
                 currentWidthDip,
                 currentHeightDip,
                 MinSelectionDip);
 
+            AppLogger.Debug($"QuickLayout release: start={start} end={end} scaling={scaling} origin=({virtualOrigin.X},{virtualOrigin.Y}) result={result}");
+
             Close(result);
         }
 

src/YASN.App/WindowLayout/WindowPositionScaling.cs

@@ -0,0 +1,59 @@
+namespace YASN.WindowLayout
+{
+    /// <summary>
+    /// Converts between screen physical-pixel space and Avalonia's <c>Window.Position</c> space.
+    /// The two spaces differ by platform: on Windows <c>Window.Position</c> is physical pixels, so the
+    /// conversion is the identity; on macOS Avalonia expresses <c>Window.Position</c> in logical points
+    /// (it divides by the desktop scaling factor — see AvaloniaUI/Avalonia#11333), so physical pixels
+    /// must be divided by the scale factor going out and multiplied coming back. Quick-layout geometry
+    /// runs entirely in physical-pixel space (where <c>Screen.Bounds</c>/<c>WorkingArea</c> live); this
+    /// seam is applied only where a value crosses into or out of <c>Window.Position</c>.
+    /// </summary>
+    public static class WindowPositionScaling
+    {
+        /// <summary>
+        /// Whether the current OS expresses <c>Window.Position</c> in logical points (macOS) rather than
+        /// physical pixels (Windows). Read once from the OS; pass it explicitly to the conversion
+        /// methods so they stay pure and unit-testable for both platforms.
+        /// </summary>
+        public static bool PositionIsLogical { get; } = OperatingSystem.IsMacOS();
+
+        /// <summary>
+        /// Converts a physical-pixel coordinate into a <c>Window.Position</c> value for the current
+        /// platform.
+        /// </summary>
+        /// <param name="physical">The coordinate in physical pixels.</param>
+        /// <param name="scaling">The screen scale factor (physical pixels per logical point).</param>
+        /// <param name="positionIsLogical">Whether position space is logical points (macOS).</param>
+        /// <returns>The coordinate in <c>Window.Position</c> space.</returns>
+        public static double PhysicalToPosition(double physical, double scaling, bool positionIsLogical)
+        {
+            if (!positionIsLogical)
+            {
+                return physical;
+            }
+
+            double safeScaling = scaling <= 0 ? 1.0 : scaling;
+            return physical / safeScaling;
+        }
+
+        /// <summary>
+        /// Converts a <c>Window.Position</c> value into a physical-pixel coordinate for the current
+        /// platform.
+        /// </summary>
+        /// <param name="position">The coordinate in <c>Window.Position</c> space.</param>
+        /// <param name="scaling">The screen scale factor (physical pixels per logical point).</param>
+        /// <param name="positionIsLogical">Whether position space is logical points (macOS).</param>
+        /// <returns>The coordinate in physical pixels.</returns>
+        public static double PositionToPhysical(double position, double scaling, bool positionIsLogical)
+        {
+            if (!positionIsLogical)
+            {
+                return position;
+            }
+
+            double safeScaling = scaling <= 0 ? 1.0 : scaling;
+            return position * safeScaling;
+        }
+    }
+}

tests/YASN.Migration.Tests/WindowPositionScalingTests.cs

@@ -0,0 +1,66 @@
+using YASN.WindowLayout;
+
+namespace YASN.Migration.Tests
+{
+    /// <summary>
+    /// Verifies the platform seam mapping physical pixels to and from Avalonia's window-position space.
+    /// The mapping is the source of correct window placement on macOS, where <c>Window.Position</c> is
+    /// logical points, versus Windows, where it is physical pixels — so these tests pin the per-platform
+    /// behaviour the overlay and quick-layout controller depend on.
+    /// </summary>
+    public sealed class WindowPositionScalingTests
+    {
+        /// <summary>
+        /// On Windows, position space is physical pixels, so the conversion is the identity regardless
+        /// of DPI. Both 1.0 and 2.0 scaling must pass through unchanged, proving DPI never alters the
+        /// Windows path (the original, working behaviour must not regress).
+        /// </summary>
+        [Theory]
+        [InlineData(1.0)]
+        [InlineData(2.0)]
+        public void WindowsPositionSpaceIsIdentity(double scaling)
+        {
+            Assert.Equal(400, WindowPositionScaling.PhysicalToPosition(400, scaling, positionIsLogical: false), 3);
+            Assert.Equal(400, WindowPositionScaling.PositionToPhysical(400, scaling, positionIsLogical: false), 3);
+        }
+
+        /// <summary>
+        /// On macOS at 2x, position space is logical points: physical pixels are halved going out and
+        /// doubled coming back. This is exactly the conversion that keeps the overlay full-screen and
+        /// the note placed where the user clicked on Retina.
+        /// </summary>
+        [Fact]
+        public void MacPositionSpaceConvertsByScaling()
+        {
+            Assert.Equal(200, WindowPositionScaling.PhysicalToPosition(400, 2.0, positionIsLogical: true), 3);
+            Assert.Equal(400, WindowPositionScaling.PositionToPhysical(200, 2.0, positionIsLogical: true), 3);
+        }
+
+        /// <summary>
+        /// The two directions must be exact inverses at fractional scaling, or a reposition would drift
+        /// every time it round-trips through the seam (read position -> physical -> write position).
+        /// </summary>
+        [Fact]
+        public void MacRoundTripIsLossless()
+        {
+            const double original = 933;
+            double physical = WindowPositionScaling.PositionToPhysical(original, 1.5, positionIsLogical: true);
+            double back = WindowPositionScaling.PhysicalToPosition(physical, 1.5, positionIsLogical: true);
+
+            Assert.Equal(original, back, 6);
+        }
+
+        /// <summary>
+        /// A non-positive scaling must fall back to identity rather than divide by zero, so a window
+        /// reporting an invalid scale still places sanely instead of throwing or producing infinity.
+        /// </summary>
+        [Theory]
+        [InlineData(0.0)]
+        [InlineData(-1.0)]
+        public void NonPositiveScalingFallsBackToIdentity(double scaling)
+        {
+            Assert.Equal(300, WindowPositionScaling.PhysicalToPosition(300, scaling, positionIsLogical: true), 3);
+            Assert.Equal(300, WindowPositionScaling.PositionToPhysical(300, scaling, positionIsLogical: true), 3);
+        }
+    }
+}