Compute LayoutConstraints on new *StackLayout and Grid (#28931)

Author: albyrock87

src/Controls/src/Core/Layout/Grid.cs

@@ -9,6 +9,9 @@ namespace Microsoft.Maui.Controls
 	[ContentProperty(nameof(Children))]
 	public class Grid : Layout, IGridLayout
 	{
+		static readonly ColumnDefinitionCollection DefaultColumnDefinitions = new(new ColumnDefinition { Width = GridLength.Star });
+		static readonly RowDefinitionCollection DefaultRowDefinitions = new(new RowDefinition { Height = GridLength.Star });
+
 		readonly Dictionary<IView, GridInfo> _viewInfo = new();
 
 		/// <summary>Bindable property for <see cref="ColumnDefinitions"/>.</summary>
@@ -354,6 +357,83 @@ protected override void OnBindingContextChanged()
 			UpdateRowColumnBindingContexts();
 		}
 
+		internal override void ComputeConstraintForView(View view)
+		{
+			var result = LayoutConstraint.None;
+
+			if (view.VerticalOptions.Alignment == LayoutAlignment.Fill && ViewHasFixedHeightDefinition(view))
+			{
+				result |= LayoutConstraint.VerticallyFixed;
+			}
+			
+			if (view.HorizontalOptions.Alignment == LayoutAlignment.Fill && ViewHasFixedWidthDefinition(view))
+			{
+				result |= LayoutConstraint.HorizontallyFixed;
+			}
+
+			view.ComputedConstraint = result;
+		}
+
+		bool ViewHasFixedHeightDefinition(BindableObject view)
+		{
+			var gridHasFixedHeight = (Constraint & LayoutConstraint.VerticallyFixed) != 0;
+
+			var row = GetRow(view);
+			var rowSpan = GetRowSpan(view);
+			var rowDefinitions = RowDefinitions;
+			if (rowDefinitions?.Count is not > 0)
+			{
+				rowDefinitions = DefaultRowDefinitions;
+			}
+
+			for (int i = row; i < row + rowSpan && i < rowDefinitions.Count; i++)
+			{
+				GridLength height = rowDefinitions[i].Height;
+
+				if (height.IsAuto)
+				{
+					return false;
+				}
+
+				if (!gridHasFixedHeight && height.IsStar)
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		bool ViewHasFixedWidthDefinition(BindableObject view)
+		{
+			var gridHasFixedWidth = (Constraint & LayoutConstraint.HorizontallyFixed) != 0;
+
+			var col = GetColumn(view);
+			var colSpan = GetColumnSpan(view);
+			var columnDefinitions = ColumnDefinitions;
+			if (columnDefinitions?.Count is not > 0)
+			{
+				columnDefinitions = DefaultColumnDefinitions;
+			}
+
+			for (int i = col; i < col + colSpan && i < columnDefinitions.Count; i++)
+			{
+				GridLength width = columnDefinitions[i].Width;
+
+				if (width.IsAuto)
+				{
+					return false;
+				}
+
+				if (!gridHasFixedWidth && width.IsStar)
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+
 		void UpdateRowColumnBindingContexts()
 		{
 			var bindingContext = BindingContext;

src/Controls/src/Core/Layout/HorizontalStackLayout.cs

@@ -7,5 +7,17 @@ namespace Microsoft.Maui.Controls
 	public class HorizontalStackLayout : StackBase
 	{
 		protected override ILayoutManager CreateLayoutManager() => new HorizontalStackLayoutManager(this);
+
+		internal override void ComputeConstraintForView(View view)
+		{
+			if ((Constraint & LayoutConstraint.VerticallyFixed) != 0 && view.VerticalOptions.Alignment == LayoutAlignment.Fill)
+			{
+				view.ComputedConstraint = LayoutConstraint.VerticallyFixed;
+			}
+			else
+			{
+				view.ComputedConstraint = LayoutConstraint.None;
+			}
+		}
 	}
 }

src/Controls/src/Core/Layout/StackLayout.cs

@@ -36,5 +36,31 @@ protected override ILayoutManager CreateLayoutManager()
 		{
 			return new StackLayoutManager(this);
 		}
+
+		internal override void ComputeConstraintForView(View view)
+		{
+			if (Orientation == StackOrientation.Horizontal)
+			{
+				if ((Constraint & LayoutConstraint.VerticallyFixed) != 0 && view.VerticalOptions.Alignment == LayoutAlignment.Fill)
+				{
+					view.ComputedConstraint = LayoutConstraint.VerticallyFixed;
+				}
+				else
+				{
+					view.ComputedConstraint = LayoutConstraint.None;
+				}
+			}
+			else
+			{
+				if ((Constraint & LayoutConstraint.HorizontallyFixed) != 0 && view.HorizontalOptions.Alignment == LayoutAlignment.Fill)
+				{
+					view.ComputedConstraint = LayoutConstraint.HorizontallyFixed;
+				}
+				else
+				{
+					view.ComputedConstraint = LayoutConstraint.None;
+				}
+			}
+		}
 	}
 }

src/Controls/src/Core/Layout/VerticalStackLayout.cs

@@ -7,5 +7,17 @@ namespace Microsoft.Maui.Controls
 	public class VerticalStackLayout : StackBase
 	{
 		protected override ILayoutManager CreateLayoutManager() => new VerticalStackLayoutManager(this);
+
+		internal override void ComputeConstraintForView(View view)
+		{
+			if ((Constraint & LayoutConstraint.HorizontallyFixed) != 0 && view.HorizontalOptions.Alignment == LayoutAlignment.Fill)
+			{
+				view.ComputedConstraint = LayoutConstraint.HorizontallyFixed;
+			}
+			else
+			{
+				view.ComputedConstraint = LayoutConstraint.None;
+			}
+		}
 	}
 }

src/Controls/src/Core/Properties/AssemblyInfo.cs

@@ -13,6 +13,7 @@
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Compatibility.Tizen")]
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Core.Design")]
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Core.UnitTests")]
+[assembly: InternalsVisibleTo("Microsoft.Maui.UnitTests")]
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Android.UnitTests")]
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Compatibility.Android.UnitTests")]
 [assembly: InternalsVisibleTo("Microsoft.Maui.Controls.Compatibility.UAP.UnitTests")]

src/Core/tests/UnitTests/Layouts/GridTests.cs

@@ -0,0 +1,120 @@
+using Microsoft.Maui.Controls;
+using Xunit;
+
+namespace Microsoft.Maui.UnitTests.Layouts
+{
+	[Category(TestCategory.Core, TestCategory.Layout)]
+	public class GridTests
+	{
+		[Fact]
+		public void GridConstrainsViewsVerticallyWhenPossible()
+		{
+			// While testing vertical constraints, make sure to avoid setting the horizontal one
+			var grid = new Grid { HorizontalOptions = LayoutOptions.Center };
+
+			grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(50) });
+			grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Star });
+			grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+			grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(50) });
+
+			var f50 = grid.Add(0, 0);
+			var f50star = grid.Add(0, 0, rowSpan: 2);
+			var star = grid.Add(1, 0);
+			var starAuto = grid.Add(1, 0, rowSpan: 2);
+			var auto = grid.Add(2, 0);
+			var autof50 = grid.Add(2, 0, rowSpan: 2);
+
+			Assert.Equal(LayoutConstraint.VerticallyFixed, f50.Constraint);
+			Assert.Equal(LayoutConstraint.None, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.None, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+			Assert.Equal(LayoutConstraint.None, autof50.Constraint);
+
+			// Now set a fixed height on the grid
+			grid.HeightRequest = 100;
+			
+			Assert.Equal(LayoutConstraint.VerticallyFixed, f50.Constraint);
+			Assert.Equal(LayoutConstraint.VerticallyFixed, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.VerticallyFixed, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+			Assert.Equal(LayoutConstraint.None, autof50.Constraint);
+
+			// Now change children vertical options to center so we can see `VerticallyFixed` is not applied anymore
+			f50.VerticalOptions = LayoutOptions.Center;
+			f50star.VerticalOptions = LayoutOptions.Center;
+			star.VerticalOptions = LayoutOptions.Center;
+			starAuto.VerticalOptions = LayoutOptions.Center;
+			auto.VerticalOptions = LayoutOptions.Center;
+			autof50.VerticalOptions = LayoutOptions.Center;
+
+			Assert.Equal(LayoutConstraint.None, f50.Constraint);
+			Assert.Equal(LayoutConstraint.None, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.None, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+			Assert.Equal(LayoutConstraint.None, autof50.Constraint);
+		}
+
+		[Fact]
+		public void GridConstrainsViewsHorizontallyWhenPossible()
+		{
+			// While testing horizontal constraints, make sure to avoid setting the vertical one
+			var grid = new Grid { VerticalOptions = LayoutOptions.Center };
+
+			grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(50) });
+			grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Star });
+			grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+			grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(50) });
+
+			var f50 = grid.Add(0, 0);
+			var f50star = grid.Add(0, 0, columnSpan: 2);
+			var star = grid.Add(0, 1);
+			var starAuto = grid.Add(0, 1, columnSpan: 2);
+			var auto = grid.Add(0, 2);
+			var autof50 = grid.Add(0, 2, columnSpan: 2);
+
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, f50.Constraint);
+			Assert.Equal(LayoutConstraint.None, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.None, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+			Assert.Equal(LayoutConstraint.None, autof50.Constraint);
+
+			// Now set a fixed width on the grid
+			grid.WidthRequest = 100;
+
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, f50.Constraint);
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+			Assert.Equal(LayoutConstraint.None, autof50.Constraint);
+
+			// Now change children horizontal options to center so we can see `HorizontallyFixed` is not applied anymore
+			f50.HorizontalOptions = LayoutOptions.Center;
+			f50star.HorizontalOptions = LayoutOptions.Center;
+			star.HorizontalOptions = LayoutOptions.Center;
+			starAuto.HorizontalOptions = LayoutOptions.Center;
+			auto.HorizontalOptions = LayoutOptions.Center;
+			autof50.HorizontalOptions = LayoutOptions.Center;
+
+			Assert.Equal(LayoutConstraint.None, f50.Constraint);
+			Assert.Equal(LayoutConstraint.None, f50star.Constraint);
+			Assert.Equal(LayoutConstraint.None, star.Constraint);
+			Assert.Equal(LayoutConstraint.None, starAuto.Constraint);
+			Assert.Equal(LayoutConstraint.None, auto.Constraint);
+		}
+
+		[Fact]
+		public void GridCompletelyConstrainsViewsWhenPossible()
+		{
+			var grid = new Grid { WidthRequest = 100, HeightRequest = 100 };
+
+			var child = grid.Add(0, 0);
+
+			Assert.Equal(LayoutConstraint.Fixed, child.Constraint);
+		}
+	}
+}

src/Core/tests/UnitTests/Layouts/HorizontalStackLayoutTests.cs

@@ -0,0 +1,29 @@
+using Microsoft.Maui.Controls;
+using Xunit;
+
+namespace Microsoft.Maui.UnitTests.Layouts
+{
+	[Category(TestCategory.Core, TestCategory.Layout)]
+	public class HorizontalStackLayoutTests
+	{
+		[Fact]
+		public void ConstrainsViewsVerticallyWhenConstrained()
+		{
+			var layout = new HorizontalStackLayout();
+			var child = new ContentView();
+			layout.Add(child);
+
+			Assert.Equal(LayoutConstraint.None, child.Constraint);
+
+			layout.HeightRequest = 100;
+			Assert.Equal(LayoutConstraint.VerticallyFixed, child.Constraint);
+
+			child.WidthRequest = 50;
+			Assert.Equal(LayoutConstraint.Fixed, child.Constraint);
+
+			layout.VerticalOptions = LayoutOptions.Center;
+			layout.HeightRequest = -1;
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, child.Constraint);
+		}
+	}
+}

src/Core/tests/UnitTests/Layouts/LayoutTestHelpers.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Microsoft.Maui.Controls;
 using Microsoft.Maui.Graphics;
 using NSubstitute;
 using NSubstitute.Core;
@@ -135,5 +136,19 @@ public static IView CreateHeightDominatedView(double unconstrainedWidth, double
 
 			return view;
 		}
+
+		public static View Add(this Grid grid, int row, int column, int rowSpan = 1, int columnSpan = 1)
+		{
+			var child = new ContentView();
+
+			Grid.SetRow(child, row);
+			Grid.SetColumn(child, column);
+			Grid.SetRowSpan(child, rowSpan);
+			Grid.SetColumnSpan(child, columnSpan);
+
+			grid.Add(child);
+
+			return child;
+		}
 	}
 }

src/Core/tests/UnitTests/Layouts/StackLayoutTests.cs

@@ -0,0 +1,49 @@
+using Microsoft.Maui.Controls;
+using Xunit;
+
+namespace Microsoft.Maui.UnitTests.Layouts
+{
+	[Category(TestCategory.Core, TestCategory.Layout)]
+	public class StackLayoutTests
+	{
+		[Fact]
+		public void VerticalOrientationConstrainsViewsHorizontallyWhenConstrained()
+		{
+			var layout = new StackLayout { Orientation = StackOrientation.Vertical };
+			var child = new ContentView();
+			layout.Add(child);
+
+			Assert.Equal(LayoutConstraint.None, child.Constraint);
+
+			layout.WidthRequest = 100;
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, child.Constraint);
+
+			child.HeightRequest = 50;
+			Assert.Equal(LayoutConstraint.Fixed, child.Constraint);
+
+			layout.HorizontalOptions = LayoutOptions.Center;
+			layout.WidthRequest = -1;
+			Assert.Equal(LayoutConstraint.VerticallyFixed, child.Constraint);
+		}
+
+		[Fact]
+		public void HorizontalOrientationConstrainsViewsVerticallyWhenConstrained()
+		{
+			var layout = new StackLayout { Orientation = StackOrientation.Horizontal };
+			var child = new ContentView();
+			layout.Add(child);
+
+			Assert.Equal(LayoutConstraint.None, child.Constraint);
+
+			layout.HeightRequest = 100;
+			Assert.Equal(LayoutConstraint.VerticallyFixed, child.Constraint);
+
+			child.WidthRequest = 50;
+			Assert.Equal(LayoutConstraint.Fixed, child.Constraint);
+
+			layout.VerticalOptions = LayoutOptions.Center;
+			layout.HeightRequest = -1;
+			Assert.Equal(LayoutConstraint.HorizontallyFixed, child.Constraint);
+		}
+	}
+}