Deliver mac drags past the view edge, add diagonal resize cursors, and harden window drags

- MacSystemWindow: deliver dragged/up events outside the content view while a
  button pressed inside is held (OutOfViewMouseCapture); ignore MouseExited
  events whose location is still inside the view (AppKit posts them when
  cursor rects are rebuilt mid-drag) and never turn one into the leave sentinel
  while a drag is in flight.
- MacSystemWindow: map SizeNWSE/SizeNESW to the private NSCursor diagonal
  resize cursors behind a respondsToSelector probe (arrow fallback), SizeAll to
  openHandCursor, and install an AggMacContentView with resetCursorRects so
  the requested cursor persists; skip the cursor set/invalidate when unchanged.
- GrabControl/WindowWidget: track resize drags in screen space from a
  mouse-down snapshot and place the window absolutely; end the drag on any move
  that lacks the pressed button, so the (-10,-10) leave sentinel and a lost
  mouse up can no longer collapse the window to its minimum size.
- TitleBarWidget: same pressed-button guard, so the sentinel cannot throw the
  window off screen.
- ScrollableWidget: set the scroll-area margin through SetScrollAreaMargin
  instead of a raw VerticalScrollBar.Width that was double-scaled on Retina.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: larsbrubaker

Gui/ScrollableWidget/ScrollableWidget.cs

@@ -177,7 +177,10 @@ public ScrollableWidget(double width, double height, bool autoScroll = false)
 				SetScrollAreaMargin();
 			};
 
-			scrollArea.Margin = scrollArea.Margin.Clone(right: VerticalScrollBar.Width);
+			// through the same helper the VisibleChanged and SizeChanged handlers use - Margin is in design units
+			// and layout multiplies it by DeviceScale, so assigning the bar's already scaled Width here made the
+			// gap twice as wide as the bar on any display with a scale above 1
+			SetScrollAreaMargin();
 
 			base.AddChild(scrollArea);
 			base.AddChild(VerticalScrollBar);

Gui/WindowWidget/GrabControl.cs

@@ -1,9 +1,9 @@
-using MatterHackers.VectorMath;
+using MatterHackers.VectorMath;
 using System;
 
 //----------------------------------------------------------------------------
 // Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2007 Lars Brubaker
+// Copyright (C) 2026 Lars Brubaker
 //                  larsbrubaker@gmail.com
 //
 // Permission to copy, use, modify, sell and distribute this software
@@ -15,23 +15,65 @@
 
 namespace MatterHackers.Agg.UI
 {
+	/// <summary>
+	/// One edge or corner handle of a <see cref="WindowWidget"/>. It does no resizing itself - it tracks the
+	/// drag and hands <see cref="AdjustParent"/> everything needed to place the window absolutely.
+	/// </summary>
 	public class GrabControl : GuiWidget
 	{
-		public Vector2 downPosition;
-		internal Action<GrabControl, MouseEventArgs> AdjustParent;
+		/// <summary>
+		/// Called on every move of a drag. It takes only the handle, because everything a resize needs -
+		/// how far the mouse has moved and where the window started - is read from it.
+		/// </summary>
+		internal Action<GrabControl> AdjustParent;
 		private Cursors cursor;
 		private bool mouseIsDown = false;
+		private MouseButtons dragButton = MouseButtons.None;
+		private Vector2 downScreenPosition;
 		private GuiWidget perviousParent;
 
 		public GrabControl(Cursors cursor)
 		{
 			this.cursor = cursor;
 		}
 
+		/// <summary>
+		/// How far the mouse has travelled since the press that started the drag, in screen space.
+		/// </summary>
+		/// <remarks>
+		/// Screen space, and measured from the press rather than from the previous move, because the handle is
+		/// edge anchored: it slides out from under the mouse as the window resizes, so its local coordinates
+		/// are a reference frame that moves with what is being measured.
+		/// </remarks>
+		public Vector2 DragDelta { get; private set; }
+
+		/// <summary>
+		/// The size the parent had when the drag started. Handlers size the window from this rather than from
+		/// its current size, so a move that arrives out of order, twice, or after a skipped one still lands the
+		/// window exactly where the mouse is.
+		/// </summary>
+		public Vector2 ParentSizeAtMouseDown { get; private set; }
+
+		/// <summary>
+		/// The position the parent had when the drag started - the other half of what an absolute placement
+		/// needs, for the handles that move the window's left or bottom edge.
+		/// </summary>
+		public Vector2 ParentPositionAtMouseDown { get; private set; }
+
 		public override void OnMouseDown(MouseEventArgs mouseEvent)
 		{
-			mouseIsDown = true;
-			downPosition = mouseEvent.Position;
+			// Which button started the drag is remembered so OnMouseMove can tell a real drag from a move with
+			// nothing held down, and a press with no button at all starts no drag.
+			dragButton = mouseEvent.Button;
+			mouseIsDown = dragButton != MouseButtons.None;
+
+			if (mouseIsDown)
+			{
+				downScreenPosition = this.TransformToScreenSpace(mouseEvent.Position);
+				DragDelta = Vector2.Zero;
+				ParentSizeAtMouseDown = Parent == null ? Vector2.Zero : Parent.Size;
+				ParentPositionAtMouseDown = Parent == null ? Vector2.Zero : Parent.Position;
+			}
 
 			base.OnMouseDown(mouseEvent);
 		}
@@ -40,9 +82,18 @@ public override void OnMouseMove(MouseEventArgs mouseEvent)
 		{
 			if (mouseIsDown)
 			{
-				if (Parent?.Resizable == true)
+				if (mouseEvent.Button != dragButton)
+				{
+					// The drag is over even though no mouse up reached us. Both platform sinks report the pointer
+					// leaving the window as a buttonless move to (-10, -10), and a mouse up that lands outside the
+					// window can be dropped before it ever gets here - taking either for a drag snapped the window
+					// to its minimum size and then had it chase the pointer around with no button held.
+					mouseIsDown = false;
+				}
+				else if (Parent?.Resizable == true)
 				{
-					AdjustParent?.Invoke(this, mouseEvent);
+					DragDelta = this.TransformToScreenSpace(mouseEvent.Position) - downScreenPosition;
+					AdjustParent?.Invoke(this);
 				}
 			}
 
@@ -85,4 +136,4 @@ private void PerviousParent_ResizeableChanged(object sender, EventArgs e)
 			}
 		}
 	}
-}
+}

Gui/WindowWidget/TitleBarWidget.cs

@@ -1,6 +1,6 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 // Anti-Grain Geometry - Version 2.4
-// Copyright (C) 2007 Lars Brubaker
+// Copyright (C) 2026 Lars Brubaker
 //                  larsbrubaker@gmail.com
 //
 // Permission to copy, use, modify, sell and distribute this software
@@ -15,10 +15,17 @@
 
 namespace MatterHackers.Agg.UI
 {
+	/// <summary>
+	/// The bar across the top of a <see cref="WindowWidget"/>. Dragging it moves the window.
+	/// </summary>
 	public class TitleBarWidget : GuiWidget
 	{
 		private Vector2 DownPosition;
 		private bool mouseDownOnBar = false;
+
+		// which button started the drag, so a move arriving without it can be told from one that is part of it
+		private MouseButtons dragButton = MouseButtons.None;
+
 		GuiWidget windowToDrag;
 
 		public TitleBarWidget(GuiWidget windowToDrag)
@@ -36,7 +43,11 @@ protected bool MouseDownOnBar
 
 		public override void OnMouseDown(MouseEventArgs mouseEvent)
 		{
-			if (PositionWithinLocalBounds(mouseEvent.X, mouseEvent.Y))
+			// a press with no button at all starts no drag - the same rule GrabControl follows
+			dragButton = mouseEvent.Button;
+
+			if (dragButton != MouseButtons.None
+				&& PositionWithinLocalBounds(mouseEvent.X, mouseEvent.Y))
 			{
 				MouseDownOnBar = true;
 				Vector2 mouseRelClient = new Vector2(mouseEvent.X, mouseEvent.Y);
@@ -52,6 +63,16 @@ public override void OnMouseDown(MouseEventArgs mouseEvent)
 
 		public override void OnMouseMove(MouseEventArgs mouseEvent)
 		{
+			if (MouseDownOnBar
+				&& mouseEvent.Button != dragButton)
+			{
+				// The drag is over even though no mouse up reached us. Both platform sinks report the pointer
+				// leaving the window as a buttonless move to (-10, -10), and a mouse up that lands outside the
+				// window can be dropped before it ever gets here - taking either for a drag threw the window at
+				// the corner of the screen, or had it follow the pointer around with nothing held down.
+				MouseDownOnBar = false;
+			}
+
 			if (MouseDownOnBar)
 			{
 				Vector2 mousePosition = new Vector2(mouseEvent.X, mouseEvent.Y);
@@ -83,6 +104,7 @@ public override void OnMouseMove(MouseEventArgs mouseEvent)
 		public override void OnMouseUp(MouseEventArgs mouseEvent)
 		{
 			MouseDownOnBar = false;
+			dragButton = MouseButtons.None;
 			base.OnMouseUp(mouseEvent);
 		}
 	}

Gui/WindowWidget/WindowWidget.cs

@@ -227,6 +227,17 @@ public override void OnDrawBackground(Graphics2D graphics2D)
 			}
 		}
 
+		/// <summary>
+		/// Adds the eight edge and corner handles that resize the window.
+		/// </summary>
+		/// <remarks>
+		/// Every handler places the window absolutely - the size and position the window had when the drag
+		/// started, plus how far the mouse has moved since, in screen space. Nothing is accumulated from the
+		/// previous move, because the handle is anchored to the edge it drags: it slides out from under the
+		/// mouse on every resize, so a delta measured in its own coordinates is measured against a moving
+		/// reference frame. Position is always derived from the size the window actually took, so the minimum
+		/// size clamp stops the moving edge instead of sliding the whole window.
+		/// </remarks>
 		private void AddGrabControls()
 		{
 			// this is for debugging
@@ -241,13 +252,13 @@ private void AddGrabControls()
 				VAnchor = VAnchor.Stretch,
                 Margin = new BorderDouble(0, deviceGrabWidth, 0, deviceGrabWidth),
                 Size = new Vector2(deviceGrabWidth, 0),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					delta.Y = 0;
-					var startSize = Size;
-					Size = new Vector2(Size.X - delta.X, Size.Y);
-					Position += startSize - Size;
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X - s.DragDelta.X, startSize.Y);
+					// from the size that was actually taken, not the one asked for, so a drag past the minimum
+					// width stops the left edge rather than walking the whole window across the screen
+					Position = new Vector2(s.ParentPositionAtMouseDown.X + (startSize.X - Size.X), s.ParentPositionAtMouseDown.Y);
 				}
 			});
 
@@ -259,13 +270,11 @@ private void AddGrabControls()
 				VAnchor = VAnchor.Bottom,
                 Margin = new BorderDouble(deviceGrabWidth, 0, deviceGrabWidth, 0),
                 Size = new Vector2(0, deviceGrabWidth),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					delta.X = 0;
-					var startSize = Size;
-					Size = new Vector2(Size.X, Size.Y - delta.Y);
-					Position = Position + startSize - Size;
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X, startSize.Y - s.DragDelta.Y);
+					Position = new Vector2(s.ParentPositionAtMouseDown.X, s.ParentPositionAtMouseDown.Y + (startSize.Y - Size.Y));
 				}
 			});
 
@@ -276,12 +285,11 @@ private void AddGrabControls()
 				HAnchor = HAnchor.Left,
 				VAnchor = VAnchor.Bottom,
 				Size = new Vector2(deviceGrabWidth, deviceGrabWidth),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					var startSize = Size;
-					Size -= delta;
-					Position = Position + startSize - Size;
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = startSize - s.DragDelta;
+					Position = s.ParentPositionAtMouseDown + startSize - Size;
 				}
 			});
 
@@ -292,12 +300,11 @@ private void AddGrabControls()
 				HAnchor = HAnchor.Left,
 				VAnchor = VAnchor.Top,
 				Size = new Vector2(deviceGrabWidth, deviceGrabWidth),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					var startSize = Size;
-					Size = new Vector2(Size.X - delta.X, Size.Y + delta.Y);
-                    Position += new Vector2(startSize.X - Size.X, 0);
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X - s.DragDelta.X, startSize.Y + s.DragDelta.Y);
+					Position = new Vector2(s.ParentPositionAtMouseDown.X + (startSize.X - Size.X), s.ParentPositionAtMouseDown.Y);
                 }
 			});
 
@@ -309,10 +316,10 @@ private void AddGrabControls()
 				HAnchor = HAnchor.Right,
                 Margin = new BorderDouble(0, deviceGrabWidth, 0, deviceGrabWidth),
                 Size = new Vector2(deviceGrabWidth, 0),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					Size = new Vector2(Size.X + delta.X, Size.Y);
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X + s.DragDelta.X, startSize.Y);
 				}
 			});
 
@@ -323,10 +330,9 @@ private void AddGrabControls()
                 HAnchor = HAnchor.Right,
                 VAnchor = VAnchor.Top,
                 Size = new Vector2(deviceGrabWidth, deviceGrabWidth),
-                AdjustParent = (s, e) =>
+                AdjustParent = (s) =>
                 {
-                    var delta = e.Position - s.downPosition;
-                    Size = new Vector2(Size.X + delta.X, Size.Y + delta.Y);
+                    Size = s.ParentSizeAtMouseDown + s.DragDelta;
                 }
             });
 
@@ -338,10 +344,10 @@ private void AddGrabControls()
 				VAnchor = VAnchor.Top,
                 Margin = new BorderDouble(deviceGrabWidth, 0, deviceGrabWidth, 0),
                 Size = new Vector2(0, deviceGrabWidth),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					Size = new Vector2(Size.X, Size.Y + delta.Y);
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X, startSize.Y + s.DragDelta.Y);
 				}
 			});
 
@@ -352,12 +358,11 @@ private void AddGrabControls()
 				HAnchor = HAnchor.Right,
 				VAnchor = VAnchor.Bottom,
 				Size = new Vector2(deviceGrabWidth, deviceGrabWidth),
-				AdjustParent = (s, e) =>
+				AdjustParent = (s) =>
 				{
-					var delta = e.Position - s.downPosition;
-					var startSize = Size;
-					Size = new Vector2(Size.X + delta.X, Size.Y - delta.Y);
-					Position = new Vector2(Position.X, Position.Y + (startSize.Y - Size.Y));
+					var startSize = s.ParentSizeAtMouseDown;
+					Size = new Vector2(startSize.X + s.DragDelta.X, startSize.Y - s.DragDelta.Y);
+					Position = new Vector2(s.ParentPositionAtMouseDown.X, s.ParentPositionAtMouseDown.Y + (startSize.Y - Size.Y));
 				}
 			});
 		}