public void AutoAndFixedRows3 () { Grid grid = new Grid { Width = 10, Height = 10 }; grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (new GridLength (20), new GridLength (20)); grid.AddChild (new MyContentControl (50, 50), 0, 1, 2, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 20, 20); grid.RowDefinitions.Insert (0, new RowDefinition { Height = GridLength.Auto }); }, () => { grid.CheckRowHeights ("#2", 0, 50, 20); grid.RowDefinitions [1].MaxHeight = 35; }, () => { grid.CheckRowHeights ("#3", 15, 35, 20); grid.RowDefinitions [1].MaxHeight = 20; grid.ChangeRowSpan (0, 4); }, () => { grid.CheckRowHeights ("#4", 0, 20, 30); grid.AddRows (new GridLength (20)); }, () => { grid.CheckRowHeights ("#5", 0, 20, 20, 20); } ); }
public void AutoRows4 () { // See how rowspan = 3 affects this with 5 rows. Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto); // Give first child a rowspan of 2 grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 1, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 0, 1, 3, 1); CreateAsyncTest (grid, () => { // If an element spans across multiple rows and one of those rows // is already large enough to contain that element, it puts itself // entirely inside that row grid.CheckRowHeights ("#1", 53.33, 3.33, 3.33, 0, 0); grid.ChangeRow (1, 1); }, () => { // An 'auto' row which has no children whose rowspan/colspan // *ends* in that row has a height of zero grid.CheckRowHeights ("#2", 50, 20, 20, 20, 0); grid.ChangeRow (1, 2); }, () => { // If an element which spans multiple rows is the only element in // the rows it spans, it divides evenly between the rows it spans grid.CheckRowHeights ("#3", 50, 0, 20, 20, 20); grid.ChangeRow (1, 0); grid.ChangeRow (0, 1); }, () => { // If there are two auto rows beside each other and an element spans those // two rows, the total height is averaged between the two rows. grid.CheckRowHeights ("#4", 3.33, 53.33, 3.33, 0, 0); } ); }
public void AutoRows5 () { Grid grid = new Grid (); grid.AddColumns (new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 3, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 1, 0, 3, 1); // When calculating the heights of automatic rows, the children added to the grid // distribute their height in the opposite order in which they were added. CreateAsyncTest (grid, () => { // Here the element with height 60 distributes its height first grid.CheckRowHeights ("#1", 3.33, 23.33, 23.33, 20, 0); grid.ChangeRow (1, 1); grid.ChangeRow (0, 1); grid.ChangeRow (1, 0); }, () => { // Reversing the rows does not stop the '60' element from // Distributing its height first grid.CheckRowHeights ("#2", 20, 23.33, 23.33, 3.33, 0); // Now reverse the order in which the elements are added so that // the '50' element distributes first. grid.Children.Clear (); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 1, 0, 3, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 3, 1); }, () => { grid.CheckRowHeights ("#3", 16.66, 25.55, 25.55, 8.88, 0); grid.ChangeRow (1, 1); grid.ChangeRow (0, 1); grid.ChangeRow (1, 0); }, () => { grid.CheckRowHeights ("#4", 16.66, 25.55, 25.55, 8.88, 0); } ); }
public void ExpandStarsInStackPanel2 () { Grid grid = new Grid (); grid.AddRows (Auto); grid.AddColumns (Auto); var parent = new StackPanel (); for (int i = 0; i < 4; i++) { MyGrid g = new MyGrid { Name = "Grid" + i }; g.AddRows (Star); g.AddColumns (Star); g.Children.Add (new MyContentControl { Content = new Rectangle { RadiusX = 4, RadiusY = 4, StrokeThickness = 2, Fill = new SolidColorBrush (Colors.Red), Stroke = new SolidColorBrush (Colors.Black) } }); g.Children.Add (new MyContentControl { Content = new Rectangle { Fill = new SolidColorBrush (Colors.Blue), HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Height = 17, Width = 20 + i * 20 } }); parent.Children.Add (g); } grid.Children.Add (parent); CreateAsyncTest (grid, () => { for (int i = 0 ;i < parent.Children.Count; i++) { MyGrid g = (MyGrid)parent.Children[i]; Assert.AreEqual (new Size (20 + i * 20, 17), g.DesiredSize, "#1." + i); Assert.AreEqual (new Size (80, 17), g.RenderSize, "#2." + i); g.CheckMeasureArgs ("#3", Infinity, Infinity); g.CheckMeasureResult ("#4", new Size (0, 0), new Size (20 + i * 20, 17)); g.CheckRowHeights ("#5", 17); g.CheckColWidths ("#6", 80); g.CheckArrangeArgs ("#7", new Size (80, 17), new Size (80, 17)); g.CheckArrangeResult ("#8", new Size (80, 17), new Size (80, 17)); } }); }
public void AutoRows3 () { // Start off with two elements in the first row with the larger element having rowspan = 2 // and see how rowspan affects the rendering. Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 1, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 0, 1, 2, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 55, 5, 0); grid.ChangeRow (1, 1); }, () => { grid.CheckRowHeights ("#2", 50, 30, 30); grid.ChangeRow (1, 2); }, () => { grid.CheckRowHeights ("#3", 50, 0, 60); grid.ChangeRow (1, 0); grid.ChangeRow (0, 1); }, () => { grid.CheckRowHeights ("#3", 5, 55, 0); } ); }
public void StarRowsWithChild2_NoSpan_ExplicitSize () { // Check what happens when there are two explicit rows and no explicit column Grid grid = new Grid { Width = 75, Height = 75, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom, }; grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); grid.CheckRowHeights ("#2", 0, 0); // After measure grid.Measure (Infinity); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#3"); grid.CheckRowHeights ("#4", 37.5, 37.5); // Measure again grid.Measure (new Size (100, 100)); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#5"); grid.CheckRowHeights ("#6", 37.5, 37.5); }
public void StarRowsWithChild2_InTree () { // Check what happens when there are two explicit rows and no explicit column Grid grid = new Grid (); var poker = new SettablePanel { Grid = grid, MeasureArg = Infinity, }; grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); CreateAsyncTest (poker, () => { Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#1"); grid.CheckRowHeights ("#2", 50, 0); poker.MeasureArg = new Size (100, 100); poker.InvalidateSubtree (); }, () => { Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#3"); grid.CheckRowHeights ("#4", 50, 0); } ); }
public void MeasureStarRowsNoChild () { // Measuring the rows initialises the sizes to Infinity for 'star' elements double inf = double.PositiveInfinity; Grid grid = new Grid (); grid.AddRows (new GridLength (1, GridUnitType.Star)); grid.AddColumns (new GridLength (1, GridUnitType.Star)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#2"); Assert.AreEqual (0, grid.ColumnDefinitions [0].ActualWidth, "#3"); // After measure grid.Measure (Infinity); Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#4"); Assert.AreEqual (inf, grid.RowDefinitions [0].ActualHeight, "#5"); Assert.AreEqual (inf, grid.ColumnDefinitions [0].ActualWidth, "#6"); // Measure again grid.Measure (new Size (100, 100)); Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#7"); Assert.AreEqual (inf, grid.RowDefinitions [0].ActualHeight, "#8"); Assert.AreEqual (inf, grid.ColumnDefinitions [0].ActualWidth, "#9"); }
public void RowspanAutoTest () { // This test demonstrates the following rules: // 1) Elements with RowSpan/ColSpan == 1 distribute their height first // 2) The rest of the elements distribute height in LIFO order Grid grid = new Grid (); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddColumns (new GridLength (50)); var child50 = new MyContentControl (50, 50); var child60 = new MyContentControl (50, 60); grid.AddChild (child50, 0, 0, 1, 1); grid.AddChild (child60, 0, 0, 1, 1); CreateAsyncTest (grid, () => { // Check the initial values grid.CheckRowHeights ("#1", 60, 0, 0); // Now make the smaller element use rowspan = 2 Grid.SetRowSpan (child50, 2); }, () => { grid.CheckRowHeights ("#2", 60, 0, 0); // Then make the larger element us rowspan = 2 Grid.SetRowSpan (child50, 1); Grid.SetRowSpan (child60, 2); }, () => { grid.CheckRowHeights ("#3", 55, 5, 0); // Swap the order in which they are added to the grid grid.Children.Clear (); grid.AddChild (child60, 0, 0, 2, 0); grid.AddChild (child50, 0, 0, 1, 0); }, () => { // Swapping the order has no effect here grid.CheckRowHeights ("#4", 55, 5, 0); // Then give both rowspan = 2 Grid.SetRowSpan (child50, 2); }, () => { grid.CheckRowHeights ("#5", 30, 30, 0); // Finally give the larger element rowspan = 3 Grid.SetRowSpan (child60, 3); }, () => { grid.CheckRowHeights ("#6", 28.333, 28.333, 3.333); // Swap the order in which the elements are added again grid.Children.Clear (); grid.AddChild (child50, 0, 0, 2, 0); grid.AddChild (child60, 0, 0, 3, 0); }, () => { grid.CheckRowHeights ("#7", 25, 25, 20); } ); }
public void MeasureAutoAndFixedRows () { Grid grid = new Grid { }; grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (new GridLength (20), new GridLength (20)); grid.AddChild (new MyContentControl (50, 50), 0, 1, 2, 1); grid.Measure (Infinity); grid.CheckRowHeights ("#1", 20, 20); grid.CheckMeasureSizes ("#2", new Size (50, 40)); Assert.AreEqual (new Size (100, 40), grid.DesiredSize, "#3"); grid.RowDefinitions [0].Height = new GridLength (30); grid.Measure (Infinity); grid.CheckRowHeights ("#4", 30, 20); grid.CheckMeasureSizes ("#5", new Size (50, 50)); Assert.AreEqual (new Size (100, 50), grid.DesiredSize, "#6"); grid.RowDefinitions.Insert (0, new RowDefinition { Height = GridLength.Auto }); grid.Measure (Infinity); grid.CheckRowHeights ("#7", double.PositiveInfinity, 30, 20); grid.CheckMeasureSizes ("#8", new Size (50, double.PositiveInfinity)); Assert.AreEqual (new Size (100, 70), grid.DesiredSize, "#9"); grid.Children.Clear (); grid.AddChild (new MyContentControl (50, 150), 0, 1, 2, 1); grid.Measure (Infinity); grid.CheckDesired ("#13", new Size (50, 150)); grid.CheckRowHeights ("#10", double.PositiveInfinity, 30, 20); grid.CheckMeasureSizes ("#11", new Size (50, double.PositiveInfinity)); grid.CheckMeasureResult ("#12", new Size (50, 150)); Assert.AreEqual (new Size (100, 170), grid.DesiredSize, "#12"); }
public void UnfixedGridAllStar () { // Check the widths/heights of the rows/cols without specifying a size for the grid // Measuring the rows initialises the sizes to Infinity for 'star' elements Grid grid = new Grid (); grid.AddRows (new GridLength (1, GridUnitType.Star)); grid.AddColumns (new GridLength (1, GridUnitType.Star)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#2"); Assert.AreEqual (0, grid.ColumnDefinitions [0].ActualWidth, "#3"); // After measure grid.Measure (Infinity); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#4"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#5"); Assert.AreEqual (0, grid.ColumnDefinitions [0].ActualWidth, "#6"); // Measure again grid.Measure (new Size (100, 100)); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#7"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#8"); Assert.AreEqual (0, grid.ColumnDefinitions [0].ActualWidth, "#9"); }
public void MeasureAutoRows4 () { Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 30), 0, 1, 3, 1); grid.AddChild (new MyContentControl (50, 90), 0, 1, 1, 1); grid.AddChild (new MyContentControl (50, 50), 0, 1, 2, 1); grid.AddChild (new MyContentControl (50, 70), 1, 1, 4, 1); grid.AddChild (new MyContentControl (50, 120), 1, 1, 2, 1); grid.AddChild (new MyContentControl (50, 30), 2, 1, 3, 1); grid.AddChild (new MyContentControl (50, 10), 3, 1, 1, 1); grid.AddChild (new MyContentControl (50, 50), 3, 1, 2, 1); grid.AddChild (new MyContentControl (50, 80), 3, 1, 2, 1); grid.AddChild (new MyContentControl (50, 20), 4, 1, 1, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 90, 60, 60, 35, 45); }); }
public void MeasureAutoRows3 () { Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 50), 0, 1, 2, 1); grid.AddChild (new MyContentControl (50, 60), 1, 1, 1, 1); grid.AddChild (new MyContentControl (50, 70), 0, 1, 3, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 3.33, 63.33, 3.33); }); }
public void MeasureMaxAndMin3 () { Grid g = new Grid (); var child = new MyContentControl (50, 50); g.AddColumns (new GridLength (50)); g.AddRows (new GridLength (20), new GridLength (20)); g.AddChild (child, 0, 0, 2, 2); g.RowDefinitions [0].MaxHeight = 5; g.RowDefinitions [1].MaxHeight = 30; CreateAsyncTest (g, () => { var arg = child.MeasureOverrideArg; Assert.AreEqual (25, arg.Height, "#1"); g.RowDefinitions [0].MaxHeight = 10; }, () => { var arg = child.MeasureOverrideArg; Assert.AreEqual (30, arg.Height, "#2"); g.RowDefinitions [0].MaxHeight = 20; }, () => { var arg = child.MeasureOverrideArg; Assert.AreEqual (40, arg.Height, "#3"); } ); }
public void StarRowsWithChild_NoSpan_ExplicitSize () { // Check what happens if there is no explicit ColumnDefinition added Grid grid = new Grid { Width = 75, Height = 75, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom, }; grid.AddRows (new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#2"); // After measure grid.Measure (Infinity); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#4"); Assert.AreEqual (75, grid.RowDefinitions [0].ActualHeight, "#5"); // Measure again grid.Measure (new Size (100, 100)); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#7"); Assert.AreEqual (75, grid.RowDefinitions [0].ActualHeight, "#8"); }
public void MeasureStarRowsWithChild () { // Check what happens if there is no explicit ColumnDefinition added Grid grid = new Grid (); grid.AddRows (new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); Assert.AreEqual (0, grid.RowDefinitions [0].ActualHeight, "#2"); // After measure grid.Measure (Infinity); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#4"); Assert.AreEqual (inf, grid.RowDefinitions [0].ActualHeight, "#5"); // Measure again grid.Measure (new Size (100, 100)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#7"); Assert.AreEqual (100, grid.RowDefinitions [0].ActualHeight, "#8"); }
public void StarRowsWithChild2 () { // Check what happens when there are two explicit rows and no explicit column Grid grid = new Grid (); grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); // Initial values Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#1"); grid.CheckRowHeights ("#2", 0, 0); // After measure grid.Measure (Infinity); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#3"); grid.CheckRowHeights ("#4", 50, 0); // Measure again grid.Measure (new Size (100, 100)); grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#5"); grid.CheckRowHeights ("#6", 50, 0); }
public void AutoRows () { // This checks that rows expand to be large enough to hold the largest child Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto); grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 1, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 0, 1, 1, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 60, 0); Grid.SetRow ((FrameworkElement) grid.Children [1], 1); }, () => { grid.CheckRowHeights ("#2", 50, 60); } ); }
public void StarRowsWithChild_NoSpan_ExplicitSize_InTree () { // Check what happens if there is no explicit ColumnDefinition added Grid grid = new Grid { Width = 75, Height = 75, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom, }; var poker = new SettablePanel { Grid = grid, MeasureArg = Infinity }; grid.AddRows (new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); CreateAsyncTest (poker, () => { Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#1"); Assert.AreEqual (75, grid.RowDefinitions [0].ActualHeight, "#2"); poker.MeasureArg = new Size (100, 100); poker.InvalidateSubtree (); }, () => { Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#3"); Assert.AreEqual (75, grid.RowDefinitions [0].ActualHeight, "#4"); } ); }
public void AutoRows2 () { // Start off with two elements in the first row with the smaller element having rowspan = 2 // and see how rowspan affects the rendering. Grid grid = new Grid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new LayoutPoker { Width = 50, Height = 50 }, 0, 0, 2, 1); grid.AddChild (new LayoutPoker { Width = 50, Height = 60 }, 0, 1, 1, 1); // Start off with both elements at row 1, and the smaller element having rowspan = 2 CreateAsyncTest (grid, () => { // If an element spans across multiple rows and one of those rows // is already large enough to contain that element, it puts itself // entirely inside that row grid.CheckRowHeights ("#1", 60, 0, 0); grid.ChangeRow (1, 1); }, () => { // An 'auto' row which has no children whose rowspan/colspan // *ends* in that row has a height of zero grid.CheckRowHeights ("#2", 0, 60, 0); grid.ChangeRow (1, 2); }, () => { // If an element which spans multiple rows is the only element in // the rows it spans, it divides evenly between the rows it spans grid.CheckRowHeights ("#2", 25, 25, 60); grid.ChangeRow (1, 0); grid.ChangeRow (0, 1); }, () => { grid.CheckRowHeights ("#2", 60, 25, 25); } ); }
public void StarRowsWithChild2_NoSpan_ExplicitSize_InTree () { // Check what happens when there are two explicit rows and no explicit column Grid grid = new Grid { Width = 75, Height = 75, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Bottom, }; var poker = new SettablePanel { Grid = grid, MeasureArg = Infinity }; grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Star)); grid.Children.Add (new MyContentControl (50, 50)); CreateAsyncTest (poker, () => { Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#1"); grid.CheckRowHeights ("#2", 37.5, 37.5); poker.MeasureArg = new Size (100, 100); poker.InvalidateSubtree (); }, () => { Assert.AreEqual (new Size (75, 75), grid.DesiredSize, "#3"); grid.CheckRowHeights ("#4", 37.5, 37.5); } ); }
public void ExpandStarsInGrid () { MyGrid grid = CreateGridWithChildren (); var parent = new Grid (); parent.AddRows (new GridLength (75)); parent.AddColumns (new GridLength (75)); parent.AddChild (grid, 0, 0, 1, 1); TestPanel.Width = 75; TestPanel.Height = 75; CreateAsyncTest (parent, () => { grid.CheckMeasureArgs ("#1a", new Size (12, 12), new Size (25, 12), new Size (38, 12), new Size (12, 25), new Size (25, 25), new Size (38, 25), new Size (12, 38), new Size (25, 38), new Size (38, 38)); grid.CheckRowHeights ("#1", 12, 25, 38); grid.HorizontalAlignment = HorizontalAlignment.Left; grid.VerticalAlignment = VerticalAlignment.Center; parent.InvalidateSubtree (); grid.Reset (); }, () => { grid.CheckMeasureArgs ("#2a", new Size (12, 12), new Size (25, 12), new Size (38, 12), new Size (12, 25), new Size (25, 25), new Size (38, 25), new Size (12, 38), new Size (25, 38), new Size (38, 38)); grid.CheckRowHeights ("#2", 12, 15, 15); grid.Width = 50; grid.Height = 50; parent.InvalidateSubtree (); grid.Reset (); }, () => { grid.CheckMeasureArgs ("#3a", new Size (8, 8), new Size (17, 8), new Size (25, 8), new Size (8, 17), new Size (17, 17), new Size (25, 17), new Size (8, 25), new Size (17, 25), new Size (25, 25)); grid.CheckRowHeights ("#3", 8, 17, 25); grid.ClearValue (Grid.HorizontalAlignmentProperty); grid.ClearValue (Grid.VerticalAlignmentProperty); parent.InvalidateSubtree (); grid.Reset (); }, () => { grid.CheckMeasureArgs ("#4a", new Size (8, 8), new Size (17, 8), new Size (25, 8), new Size (8, 17), new Size (17, 17), new Size (25, 17), new Size (8, 25), new Size (17, 25), new Size (25, 25)); grid.CheckRowHeights ("#4", 8, 17, 25); } ); }