fix(grid): stop double-subtracting a cell child's margin (Auto-cell truncation)

GridLayout applied a cell child's own Margin twice: once when sizing/placing
the child (it subtracted childMargin to form the pass-2 re-measure width and
the arrange alignment box) and again inside the control's own paint (e.g.
MarkupControl insets its content by Margin). The result was content measured
and arranged at cellWidth - 2*margin, which truncated a tight Auto-cell label
("Animation" -> "Animati") and could force needless wrapping.

The framework convention (VerticalStackLayout / WindowContentLayout) is that
the container hands the child its full content box — border and container
padding removed — and the CONTROL owns its own margin. GridLayout now follows
it:

- pass-2 re-measure: add the child margin back onto the measure width
  (innerW already excludes it; the control re-subtracts it), and
- arrange: align DesiredSize within the full content box without pre-
  insetting by the child margin.

Update GridArrangeTests.CellChildMargin_InsetsWithinCell, which encoded the
old double-inset (it expected the child's bounds inset by its margin); it now
asserts full-cell bounds, matching every other layout. Add a regression test
(AutoColumn_MarginedMarkup_DoesNotWrap) and drop the Cells() workaround in the
GridDashboard Settings page (natural Auto tracks now render correctly).

Full suite green; AOT clean.

Author: nickprotop

Examples/GridDashboard/Pages.cs

@@ -263,8 +263,8 @@ public static GridControl BuildLogsGrid(DashboardRefs refs)
 	public static GridControl BuildSettingsGrid()
 	{
 		var grid = FillGrid()
-			.Columns(GridLength.Cells(16), GridLength.Star(1))
-			.Rows(GridLength.Cells(2), GridLength.Cells(2), GridLength.Cells(3), GridLength.Star(1))
+			.Columns(GridLength.Auto(), GridLength.Star(1))
+			.Rows(GridLength.Auto(), GridLength.Auto(), GridLength.Auto(), GridLength.Star(1))
 			.RowGap(1)
 			.ColumnGap(2)
 			.WithPadding(2, 2, 2, 2)

SharpConsoleUI.Tests/Controls/GridAutoMarginMeasureTests.cs

@@ -0,0 +1,44 @@
+// -----------------------------------------------------------------------
+// ConsoleEx - GridControl Auto-track margin double-subtraction regression
+// -----------------------------------------------------------------------
+using SharpConsoleUI;
+using SharpConsoleUI.Controls;
+using SharpConsoleUI.Layout;
+using SharpConsoleUI.Tests.Infrastructure;
+using Xunit;
+using CB = SharpConsoleUI.Builders.Controls;
+using Color = SharpConsoleUI.Color;
+
+namespace SharpConsoleUI.Tests.Controls;
+
+public class GridAutoMarginMeasureTests
+{
+	// An Auto column whose content is a Markup WITH a horizontal margin must size to the content's
+	// FULL width (incl. its margin) and NOT force the content to wrap. Previously the grid subtracted
+	// the child margin to compute the pass-2 re-measure width, and the control's own MeasureDOM
+	// subtracted the margin AGAIN — so content got (colWidth - 2*margin) and a single-line label
+	// like "Animation" wrapped to two lines.
+	[Fact]
+	public void AutoColumn_MarginedMarkup_DoesNotWrap()
+	{
+		var label = CB.Markup("Animation").WithMargin(1, 0, 1, 0).Build();
+		var grid = CB.Grid()
+			.Columns(GridLength.Auto(), GridLength.Star(1))
+			.Rows(GridLength.Star(1))
+			.Place(label, 0, 0)
+			.Place(CB.Markup("value").Build(), 0, 1)
+			.WithAlignment(HorizontalAlignment.Stretch)
+			.WithVerticalAlignment(VerticalAlignment.Fill)
+			.Build();
+
+		var system = TestWindowSystemBuilder.CreateTestSystem(60, 10);
+		var window = new Window(system) { Title = "T", Left = 0, Top = 0, Width = 60, Height = 10 };
+		window.AddControl(grid);
+		system.AddWindow(window);
+		system.Render.UpdateDisplay();
+		system.Render.UpdateDisplay();
+
+		// "Animation" is 9 columns; on one line the label height stays 1. A wrapped label is 2+ rows.
+		Assert.Equal(1, label.ActualHeight);
+	}
+}

SharpConsoleUI.Tests/Layout/GridArrangeTests.cs

@@ -144,11 +144,15 @@ public void CellChildMargin_InsetsWithinCell()
 		MeasureArrange(layout, node, 40, 10);
 
 		var child = node.Children[0];
-		// Cell is the full 40x10; child margin insets by 1 on each side.
-		Assert.Equal(1, child.Bounds.X);
-		Assert.Equal(1, child.Bounds.Y);
-		Assert.Equal(40 - 2, child.Bounds.Width);
-		Assert.Equal(10 - 2, child.Bounds.Height);
+		// The grid arranges the child into the FULL cell content box and does NOT pre-inset by the child's
+		// own margin — the control applies its margin itself during paint (its leftInset/topInset). This
+		// matches VerticalStackLayout/WindowContentLayout (the framework convention) and avoids the
+		// double-subtraction that truncated tight Auto-cell labels. So the child's bounds span the whole
+		// cell; the margin shows up as the control's own internal inset, not a smaller arranged rect.
+		Assert.Equal(0, child.Bounds.X);
+		Assert.Equal(0, child.Bounds.Y);
+		Assert.Equal(40, child.Bounds.Width);
+		Assert.Equal(10, child.Bounds.Height);
 	}
 
 	[Fact]

SharpConsoleUI/Layout/GridLayout.cs

@@ -345,12 +345,21 @@ private bool RemeasureCellsAgainstCellExtent(
 				continue;
 			}
 
+			// Add the child's own margin back onto the measure width. CellInnerExtent already subtracted
+			// the child margin (it is the alignment box used by arrange), but a control's MeasureDOM treats
+			// constraints.MaxWidth as its TOTAL allocation and subtracts its margin again internally. Passing
+			// innerW directly would double-subtract the margin, starving the content by 2*margin and forcing
+			// a single-line label (e.g. "Animation" in an Auto column) to wrap. Re-add it so the control's
+			// content gets exactly cellWidth - border - cellPadding - margin, matching pass 1 and arrange.
+			Margin childMargin = child.Control?.Margin ?? default;
+			int measureW = innerW + childMargin.Left + childMargin.Right;
+
 			// Constrain WIDTH to the cell's inner width so a wrapping control reflows to its column, but
 			// leave HEIGHT unbounded: the goal is to discover the wrapped height. Clamping height to the
 			// pass-1 row size would cap the reported height at the single-line measure and prevent an Auto
 			// row from growing. Fixed/Star rows ignore the reported height (only Auto rows size to content),
 			// and arrange clips each cell to its track, so an over-tall report is harmless for those rows.
-			child.Measure(LayoutConstraints.Loose(innerW, int.MaxValue));
+			child.Measure(LayoutConstraints.Loose(measureW, int.MaxValue));
 			anyReflow = true;
 		}
 
@@ -572,18 +581,18 @@ public void ArrangeChildren(LayoutNode node, LayoutRect finalRect)
 			var cellRect = new LayoutRect(contentX, contentY, contentW, contentH);
 			_cellRects[child] = cellRect;
 
-			// Inset the content area by the child's own margin to form the alignment box.
-			Margin childMargin = child.Control?.Margin ?? default;
-			int innerX = contentX + childMargin.Left;
-			int innerY = contentY + childMargin.Top;
-			int innerW = Math.Max(0, contentW - childMargin.Left - childMargin.Right);
-			int innerH = Math.Max(0, contentH - childMargin.Top - childMargin.Bottom);
-
+			// Align the child within the cell's CONTENT box (border + cell-padding already removed). Do NOT
+			// pre-subtract the child's own margin here: the control's own paint (its leftInset/topInset)
+			// already accounts for its margin, and its DesiredSize already includes it. Subtracting the
+			// margin to form the alignment box AND letting the control subtract it again in paint would
+			// double-subtract — starving the content by 2*margin and truncating a tight Auto-cell label
+			// (e.g. "Animation" -> "Animati"). The grid reserves border + cell-padding; the control owns
+			// its margin.
 			HorizontalAlignment hAlign = child.Control?.HorizontalAlignment ?? HorizontalAlignment.Stretch;
 			VerticalAlignment vAlign = child.Control?.VerticalAlignment ?? VerticalAlignment.Fill;
 
-			(int childX, int childW) = AlignHorizontal(hAlign, innerX, innerW, child.DesiredSize.Width);
-			(int childY, int childH) = AlignVertical(vAlign, innerY, innerH, child.DesiredSize.Height);
+			(int childX, int childW) = AlignHorizontal(hAlign, contentX, contentW, child.DesiredSize.Width);
+			(int childY, int childH) = AlignVertical(vAlign, contentY, contentH, child.DesiredSize.Height);
 
 			child.Arrange(new LayoutRect(childX, childY, childW, childH));
 		}