public void SizeDistributionOrder () { MyGrid grid = new MyGrid (); grid.AddRows (Auto, Star, Auto); grid.AddColumns (Star, Auto, Star); // Auto/Auto grid.AddChild (ContentControlWithChild (), 0, 1, 1, 1); // Star/Auto grid.AddChild (ContentControlWithChild (), 1, 1, 1, 1); // If there is no spanning involved, the heights do not get distributed grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#1", 0, 1); grid.CheckMeasureArgs ("#2", Infinity, new Size (inf, 150)); // Span the Star/Auto down into the Auto/Auto segment too. grid.ChangeRowSpan (1, 2); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#3", 0, 1); grid.CheckMeasureArgs ("#4", Infinity, new Size (inf, 150)); // Add in an Auto/Star to see what happens grid.AddChild (ContentControlWithChild (), 2, 0, 1, 1); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#5", 0, 1, 2, 1); grid.CheckMeasureArgs ("#6", Infinity, new Size (inf, inf), new Size (75, inf), new Size (inf, 150)); }
void MeasureOrder5Impl (bool checkOrder) { TestPanel.Width = 500; TestPanel.Height = 500; MyContentControl star = ContentControlWithChild (); MyContentControl pixel = ContentControlWithChild (); MyContentControl auto = ContentControlWithChild (); MyGrid grid = new MyGrid (); grid.AddRows (new GridLength (1, GridUnitType.Star), GridLength.Auto, new GridLength (30, GridUnitType.Pixel), new GridLength (30, GridUnitType.Pixel)); grid.AddColumns (new GridLength (50, GridUnitType.Pixel)); CreateAsyncTest (grid, () => { grid.AddChild (star, 0, 0, 1, 1); grid.AddChild (auto, 1, 0, 1, 1); grid.AddChild (pixel, 2, 0, 1, 1); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#1", 1, 2, 0); grid.CheckMeasureArgs ("#a", new Size (50, inf), new Size (50, 30), new Size (50, 390)); } grid.CheckFinalMeasureArg ("#a2", new Size (50, 390), new Size (50, inf), new Size (50, 30)); grid.CheckRowHeights ("#b", 390, 50, 30, 30); grid.Children.Clear (); grid.AddChild (star, 0, 0, 1, 1); grid.AddChild (pixel, 2, 0, 1, 1); grid.AddChild (auto, 1, 0, 1, 1); grid.Reset (); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#2", 1, 2, 0); grid.CheckMeasureArgs ("#c", new Size (50, 30), new Size (50, inf), new Size (50, 390)); } grid.CheckFinalMeasureArg ("#c2", new Size (50, 390), new Size (50, 30), new Size (50, inf)); grid.CheckRowHeights ("#d", 390, 50, 30, 30); grid.Children.Clear (); grid.AddChild (pixel, 2, 0, 1, 1); grid.AddChild (star, 0, 0, 1, 1); grid.AddChild (auto, 1, 0, 1, 1); grid.Reset (); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#3", 0, 2, 1); grid.CheckMeasureArgs ("#e", new Size (50, 30), new Size (50, inf), new Size (50, 390)); } grid.CheckFinalMeasureArg ("#e2", new Size (50, 30), new Size (50, 390), new Size (50, inf)); grid.CheckRowHeights ("#f", 390, 50, 30, 30); grid.Children.Clear (); grid.AddChild (pixel, 2, 0, 1, 1); grid.AddChild (auto, 1, 0, 1, 1); grid.AddChild (star, 0, 0, 1, 1); grid.Reset (); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#4", 0, 1, 2); grid.CheckMeasureArgs ("#g", new Size (50, 30), new Size (50, inf), new Size (50, 390)); } grid.CheckFinalMeasureArg ("#g2", new Size (50, 30), new Size (50, inf), new Size (50, 390)); grid.CheckRowHeights ("#h", 390, 50, 30, 30); grid.Children.Clear (); grid.AddChild (auto, 1, 0, 1, 1); grid.AddChild (pixel, 2, 0, 1, 1); grid.AddChild (star, 0, 0, 1, 1); grid.Reset (); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#5", 0, 1, 2); grid.CheckMeasureArgs ("#i", new Size (50, inf), new Size (50, 30), new Size (50, 390)); } grid.CheckFinalMeasureArg ("#i2", new Size (50, inf), new Size (50, 30), new Size (50, 390)); grid.CheckRowHeights ("#j", 390, 50, 30, 30); grid.Children.Clear (); grid.AddChild (auto, 1, 0, 1, 1); grid.AddChild (star, 0, 0, 1, 1); grid.AddChild (pixel, 2, 0, 1, 1); grid.Reset (); }, () => { if (checkOrder) { grid.CheckMeasureOrder ("#6", 0, 2, 1); grid.CheckMeasureArgs ("#k", new Size (50, inf), new Size (50, 30), new Size (50, 390)); } grid.CheckRowHeights ("#l", 390, 50, 30, 30); } ); }
public void AutoAndStarRows () { TestPanel.MaxHeight = 160; MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, new GridLength (1, GridUnitType.Star), GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 50), 0, 0, 3, 1); grid.AddChild (new MyContentControl (50, 60), 1, 0, 3, 1); // Elements will put themselves entirely inside a 'star' row if they ca CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 0, 0, 160, 0, 0); grid.CheckMeasureArgs ("#1b", new Size (50, 160), new Size (50, 160)); grid.CheckMeasureOrder ("#1c", 0, 1); // Forcing a maximum height on the star row doesn't spread // remaining height among the auto rows. grid.RowDefinitions [2].MaxHeight = 15; grid.Reset (); }, () => { grid.CheckRowHeights ("#2", 0, 0, 15, 0, 0); grid.CheckMeasureArgs ("#2b", new Size (50, 15), new Size (50, 15)); grid.CheckMeasureOrder ("#2c", 0, 1); grid.RowDefinitions.Clear (); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, new GridLength (1, GridUnitType.Star), GridLength.Auto); grid.Reset (); }, () => { grid.CheckRowHeights ("#3", 16.66, 16.66, 16.66, 110, 0); grid.CheckMeasureArgs ("#3b", new Size (50, inf), new Size (50, 143.333)); grid.CheckMeasureOrder ("#3c", 0, 1); grid.RowDefinitions [3].MaxHeight = 15; grid.Reset (); }, () => { grid.CheckRowHeights ("#4", 16.66, 16.66, 16.66, 15, 0); grid.CheckMeasureArgs ("#4b", new Size (50, 48.333)); grid.CheckMeasureOrder ("#4c", 1); } ); }
public void AutoAndFixedRows () { MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, new GridLength (15), GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 50), 0, 0, 3, 1); grid.AddChild (new MyContentControl (50, 60), 1, 0, 3, 1); // If an element spans multiple rows and one of them is *not* auto, it attempts to put itself // entirely inside that row CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 0, 0, 60, 0, 0); grid.CheckMeasureArgs ("#1b", new Size (50, inf), new Size (50, inf)); grid.CheckMeasureOrder ("#1c", 0, 1); // Forcing a maximum height on the fixed row makes it distribute // remaining height among the 'auto' rows. grid.RowDefinitions [2].MaxHeight = 15; grid.Reset (); }, () => { // Nothing needs to get re-measured, but the heights are redistributed as expected. grid.CheckRowHeights ("#2", 6.25, 28.75, 15, 22.5, 0); grid.CheckMeasureArgs ("#2b"); grid.CheckMeasureOrder ("#2c"); grid.RowDefinitions.Clear (); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, new GridLength (15), GridLength.Auto); grid.Reset (); }, () => { // Once again there's no remeasuring, just redistributing. grid.CheckRowHeights ("#3", 16.66, 16.66, 16.66, 60, 0); grid.CheckMeasureArgs ("#3b"); grid.CheckMeasureOrder ("#3c"); } ); }
public void StarRows3b () { var canvas = new Canvas { Width = 120, Height = 120 }; PanelPoker poker = new PanelPoker (); MyGrid grid = new MyGrid (); grid.AddRows (Star, Star, Star); grid.AddColumns (Star, Star, Star); canvas.Children.Add (poker); poker.Grid = grid; grid.AddChild (new MyContentControl (100, 100), 1, 1, 1, 1); CreateAsyncTest (canvas, () => { }, () => { Assert.AreEqual (Infinity, poker.MeasureArgs [0], "#1"); Assert.AreEqual (new Size (100, 100), poker.MeasureResults [0], "#2"); Assert.AreEqual (new Size (100, 100), poker.ArrangeArgs [0], "#3"); Assert.AreEqual (new Size (100, 100), poker.ArrangeResults [0], "#4"); grid.CheckRowHeights ("#5", 0, 100, 0); grid.CheckColWidths ("#6", 0, 100, 0); grid.CheckMeasureArgs ("#7", Infinity); grid.CheckMeasureResult ("#8", new Size (100, 100)); grid.CheckArrangeArgs ("#9", new Size (100, 100)); grid.CheckArrangeResult ("#10", new Size (100, 100)); } ); }
public void StarRows2 () { GridUnitType star = GridUnitType.Star; MyGrid grid = new MyGrid { Width = 100, Height = 210 }; grid.AddRows (new GridLength (1, star), new GridLength (2, star)); grid.AddChild (new MyContentControl (50, 50), 0, 0, 0, 0); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 70, 140); grid.CheckMeasureArgs ("#1b", new Size (100, 70)); grid.AddRows (GridLength.Auto); grid.Reset (); }, () => { grid.CheckRowHeights ("#2", 70, 140, 0); grid.CheckMeasureArgs ("#2b"); // MeasureOverride isn't called // Add a child to the fixed row grid.AddChild (new MyContentControl (50, 80), 2, 0, 0, 0); grid.Reset (); }, () => { grid.CheckRowHeights ("#3", 43, 87, 80); grid.CheckMeasureArgs ("#3b", new Size (100, inf), new Size (100, 43)); grid.CheckMeasureOrder ("#3c", 1, 0); // Make the child span the last two rows grid.ChangeRow (1, 1); grid.ChangeRowSpan (1, 2); grid.Reset (); }, () => { grid.CheckRowHeights ("#4", 70, 140, 0); grid.CheckMeasureArgs ("#4b", new Size (100, 70), new Size (100, 140)); grid.CheckMeasureOrder ("#4c", 0, 1); // Add another fixed row and move the large child to span both grid.AddRows (GridLength.Auto); grid.ChangeRow (1, 2); grid.Reset (); }, () => { grid.CheckRowHeights ("#5", 43, 87, 40, 40); grid.CheckMeasureArgs ("#5b", new Size (100, inf), new Size (100, 43)); grid.CheckMeasureOrder ("#5c", 1, 0); } ); }
public void StarAutoIsNotInfinite () { var child1 =new MyContentControl { }; var child2 = new MyContentControl { }; MyGrid grid = new MyGrid (); grid.AddRows (Auto, Auto, Auto, Star); grid.AddColumns (Auto, Star); grid.AddChild (child1, 0, 0, 1, 1); grid.AddChild (child2, 0, 0, 4, 2); grid.Measure (new Size (100, 100)); Assert.AreEqual (Infinity, child1.MeasureOverrideArg, "#1"); Assert.AreEqual (new Size (100, 100), child2.MeasureOverrideArg, "#2"); }
public void FixedGridAllStar () { // Specify the width/height on the grid and measure the widths/heights of the rows/cols GridLength oneStar = new GridLength (1, GridUnitType.Star); GridLength twoStar = new GridLength (2, GridUnitType.Star); GridLength threeStar = new GridLength (3, GridUnitType.Star); MyGrid g = new MyGrid { Name="Ted", ShowGridLines = true, Width = 240, Height = 240 }; g.AddColumns (twoStar, oneStar, twoStar, oneStar); g.AddRows (oneStar, threeStar, oneStar, oneStar); CreateAsyncTest (g, () => { g.CheckRowHeights ("#1", 40, 120, 40, 40); g.CheckColWidths ("#2", 80, 40, 80, 40); Assert.AreEqual (new Size (240, 240), g.DesiredSize, "#3"); }); }
public void AutoStarInfiniteChildren () { Grid holder = new Grid { Width = 500, Height = 500 }; MyGrid g = new MyGrid { Name = "Ted!" }; g.AddRows (new GridLength (1, GridUnitType.Star), GridLength.Auto); g.AddColumns (new GridLength (1, GridUnitType.Star), GridLength.Auto); g.AddChild (CreateInfiniteChild (), 0, 0, 1, 1); g.AddChild (CreateInfiniteChild (), 0, 1, 1, 1); g.AddChild (CreateInfiniteChild (), 1, 0, 1, 1); g.AddChild (CreateInfiniteChild (), 1, 1, 1, 1); // FIXME: I think this fails because the first time the ScrollViewer measures it calculates // the visibility of the Horizontal/Vertical scroll bar incorrectly. It's desired size on the // first measure is (327, 327) whereas it should be (327, 310). A few measure cycles later and // it will be correct, but chews up much more CPU than it should. holder.Children.Add (g); CreateAsyncTest (holder, () => { g.CheckMeasureOrder ("#1", 3, 1, 2, 1, 0); g.CheckMeasureArgs ("#2", Infinity, Infinity, new Size (173, inf), new Size (inf, 190), new Size (173, 190)); g.CheckMeasureResult ("#3", new Size (173, 190), new Size (327, 190), new Size (173, 310), new Size (327, 310), new Size (173, 310)); g.CheckRowHeights ("#4", 190, 310); g.CheckColWidths ("#5", 173, 327); Assert.AreEqual (new Size (500, 500), g.DesiredSize, "#5"); }); }
public void ExpandInArrange () { // Measure with infinity and check results. MyGrid grid = new MyGrid (); grid.AddRows (Star); grid.AddColumns (Star); grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); grid.Measure (Infinity); grid.CheckMeasureArgs ("#1", Infinity); grid.CheckMeasureResult ("#2", new Size (50, 50)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#3"); // Check that everything is as expected when we pass in DesiredSize as the argument to Arrange grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); grid.CheckArrangeArgs ("#4", grid.DesiredSize); grid.CheckArrangeResult ("#5", grid.DesiredSize); grid.CheckRowHeights ("#6", grid.DesiredSize.Height); grid.CheckColWidths ("#7", grid.DesiredSize.Width); grid.Reset (); grid.Arrange (new Rect (0, 0, 100, 100)); grid.CheckMeasureArgs ("#8"); // No remeasures grid.CheckArrangeArgs ("#9", new Size (100, 100)); grid.CheckArrangeResult ("#10", new Size (100, 100)); grid.CheckRowHeights ("#11", 100); grid.CheckColWidths ("#12", 100); }
public void StarRows3d () { var poker = new MyContentControl { Width = 120, Height = 120 }; MyGrid grid = new MyGrid (); grid.AddRows (Star, Star, Star); grid.AddColumns (Star, Star, Star); poker.Content = grid; grid.AddChild (new MyContentControl (100, 100), 1, 1, 1, 1); CreateAsyncTest (poker, () => { }, () => { Assert.AreEqual (new Size (120, 120), poker.MeasureOverrideArg, "#1"); Assert.AreEqual (new Size (40, 40), poker.MeasureOverrideResult, "#2"); Assert.AreEqual (new Size (40, 40), grid.DesiredSize, "#2b"); Assert.AreEqual (new Size (120, 120), poker.DesiredSize, "#2c"); Assert.AreEqual (new Size (120, 120), poker.ArrangeOverrideArg, "#3"); Assert.AreEqual (new Size (120, 120), poker.ArrangeOverrideResult, "#4"); grid.CheckColWidths ("#5", 0, 40, 0); grid.CheckRowHeights ("#6", 0, 40, 0); grid.CheckMeasureArgs ("#7", new Size (40, 40)); grid.CheckMeasureResult ("#8", new Size (40, 40)); grid.CheckArrangeArgs ("#9", new Size (40, 40)); grid.CheckArrangeResult ("#10", new Size (40, 40)); } ); }
public void ExpandStars_FixedSize () { // If a width/height is set on the grid, it expands stars. var canvas = new Canvas { Width = 120, Height = 120 }; PanelPoker poker = new PanelPoker { Width = 120, Height = 120 }; MyGrid grid = new MyGrid { Name = "Griddy" }; grid.AddRows (Star, Star, Star); grid.AddColumns (Star, Star, Star); canvas.Children.Add (poker); poker.Grid = grid; grid.AddChild (new MyContentControl (100, 100), 1, 1, 1, 1); CreateAsyncTest (canvas, () => { Assert.AreEqual (new Size (120, 120), poker.MeasureArgs [0], "#1"); Assert.AreEqual (new Size (40, 40), poker.MeasureResults [0], "#2"); Assert.AreEqual (new Size (120, 120), poker.ArrangeArgs [0], "#3"); Assert.AreEqual (new Size (120, 120), poker.ArrangeResults [0], "#4"); grid.CheckRowHeights ("#5", 40, 40, 40); grid.CheckColWidths ("#6", 40, 40, 40); grid.CheckMeasureArgs ("#7", new Size (40, 40)); grid.CheckMeasureResult ("#8", new Size (40, 40)); grid.CheckArrangeArgs ("#9", new Size (40, 40)); grid.CheckArrangeResult ("#10", new Size (40, 40)); } ); }
public void ExpandStars_UnfixedSize () { // If a width/height is *not* set on the grid, it doesn't expand stars. var canvas = new Canvas { Width = 120, Height = 120 }; PanelPoker poker = new PanelPoker (); MyGrid grid = new MyGrid { Name = "TEDDY" }; grid.AddRows (Star, Star, Star); grid.AddColumns (Star, Star, Star); canvas.Children.Add (poker); poker.Grid = grid; grid.AddChild (new MyContentControl (100, 100), 1, 1, 1, 1); CreateAsyncTest (canvas, () => { Assert.AreEqual (Infinity, poker.MeasureArgs [0], "#1"); Assert.AreEqual (new Size (100, 100), poker.MeasureResults [0], "#2"); Assert.AreEqual (new Size (100, 100), poker.ArrangeArgs [0], "#3"); Assert.AreEqual (new Size (100, 100), poker.ArrangeResults [0], "#4"); grid.CheckRowHeights ("#5", 0, 100, 0); grid.CheckColWidths ("#6", 0, 100, 0); grid.CheckMeasureArgs ("#7", Infinity); grid.CheckMeasureResult ("#8", new Size (100, 100)); grid.CheckArrangeArgs ("#9", new Size (100, 100)); grid.CheckArrangeResult ("#10", new Size (100, 100)); // Do not expand if we already consume 100 px grid.Reset (); grid.Arrange (new Rect (0, 0, 100, 100)); grid.CheckArrangeArgs ("#11"); // If we give extra space, we expand the rows. grid.Arrange (new Rect (0, 0, 500, 500)); grid.CheckRowHeights ("#12", 167, 167, 166); grid.CheckColWidths ("#13", 167, 167, 166); grid.CheckArrangeArgs ("#14", new Size (167, 167)); grid.CheckArrangeResult ("#15", new Size (167, 167)); } ); }
public void ExpandInArrange_CanvasParent () { // Measure with infinity and check results. MyGrid grid = new MyGrid (); grid.AddRows (Star); grid.AddColumns (Star); grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); var parent = new Canvas (); parent.Children.Add (grid); CreateAsyncTest (parent, () => { grid.Reset (); TestPanel.Measure (Infinity); // Nothing is measured as the grid always uses (Inf, Inf) to measure children. grid.CheckMeasureArgs ("#1"); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#3"); grid.Reset (); grid.Arrange (new Rect (0, 0, 100, 100)); grid.CheckMeasureArgs ("#8"); // No remeasures grid.CheckArrangeArgs ("#9", new Size (100, 100)); grid.CheckArrangeResult ("#10", new Size (100, 100)); grid.CheckRowHeights ("#11", 100); grid.CheckColWidths ("#12", 100); // If we measure with a finite size, the rows/cols still expand // to consume the available space grid.Reset (); grid.Measure (new Size (1000, 1000)); grid.CheckMeasureArgs ("#13", new Size (1000, 1000)); grid.CheckMeasureResult ("#14", new Size (50, 50)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#15"); // When we pass in the desired size as the arrange arg, // the rows/cols use that as their height/width grid.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); grid.CheckArrangeArgs ("#16", grid.DesiredSize); grid.CheckArrangeResult ("#17", grid.DesiredSize); grid.CheckRowHeights ("#18", grid.DesiredSize.Height); grid.CheckColWidths ("#19", grid.DesiredSize.Width); // If we pass in twice the desired size, the rows/cols consume that too grid.Reset (); grid.Arrange (new Rect (0, 0, 100, 100)); grid.CheckMeasureArgs ("#20"); // No remeasures grid.CheckArrangeArgs ("#21", new Size (100, 100)); grid.CheckArrangeResult ("#22", new Size (100, 100)); grid.CheckRowHeights ("#23", 100); grid.CheckColWidths ("#24", 100); }); }
public void AutoStarPriority () { // Test a bunch of combinations of auto/star with/without span to see // which order things are measured in. MyGrid grid = new MyGrid { Width = 200, Height = 200 }; grid.AddRows (Auto, Auto, Star, Auto, Star); grid.AddColumns (Auto, Star, Auto, Star, Auto); // Two auto-autos and one star-star grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); grid.AddChild (ContentControlWithChild (), 4, 3, 1, 1); // Measured in-order. star-star is last. grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#1", 0, 1, 2); grid.CheckMeasureArgs ("#1b", Infinity, Infinity, new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#2", 1, 2, 0); grid.CheckMeasureArgs ("#2b", Infinity, Infinity, new Size (75, 75)); // Span > 1 does not affect measure order. star-star is last. grid.ReverseChildren (); grid.ChangeRowSpan (0, 2); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#3", 0, 1, 2); grid.CheckMeasureArgs ("#3b", Infinity, Infinity, new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#4", 1, 2, 0); grid.CheckMeasureArgs ("#4b", Infinity, Infinity, new Size (75, 75)); // Elements which do not span a star row are measured first. star-star is last. grid.ReverseChildren (); grid.ChangeRowSpan (0, 3); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#5", 1, 0, 2); grid.CheckMeasureArgs ("#5b", Infinity, new Size (inf, 125), new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#6", 1, 2, 0); grid.CheckMeasureArgs ("#6b", Infinity, new Size (inf, 125), new Size (75, 75)); // Elements which do not span a star col are measured first. star-star is last. grid.ReverseChildren (); grid.ChangeRowSpan (0, 1); grid.ChangeColSpan (0, 2); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#7", 1, 0, 2); grid.CheckMeasureArgs ("#7b", Infinity, new Size (125, inf), new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#8", 1, 2, 0); grid.CheckMeasureArgs ("#8b", Infinity, new Size (125, inf), new Size (75, 75)); // Elements which span a Star row are measured before ones spanning a Star col. star-star is last. grid.ReverseChildren (); grid.ChangeRowSpan (1, 3); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#9", 1, 0, 1, 2); grid.CheckMeasureArgs ("#9b", Infinity, new Size (125, inf), new Size (inf, 125), new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#10", 1, 2, 1, 0); grid.CheckMeasureArgs ("#10b", Infinity, new Size (125, inf), new Size (inf, 125), new Size (75, 75)); // Auto/Auto is measured before all. star-star is last. grid.ReverseChildren (); grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#11", 3, 1, 0, 1, 2); grid.CheckMeasureArgs ("#11b", Infinity, Infinity, new Size (125, inf), new Size (inf, 125), new Size (75, 75)); grid.ReverseChildren (); grid.ResetAndInvalidate (); grid.Measure (new Size (200, 200)); grid.CheckMeasureOrder ("#12", 0, 2, 3, 2, 1); grid.CheckMeasureArgs ("#12b", Infinity, Infinity, new Size (125, inf), new Size (inf, 125), new Size (75, 75)); }
public void ChangingGridPropertiesInvalidates () { // Normally remeasuring with the same width/height does not result in MeasureOverride // being called, but if we change a grid property, it does. MyGrid g = new MyGrid (); g.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); g.AddColumns (GridLength.Auto, GridLength.Auto, GridLength.Auto); g.AddChild (ContentControlWithChild (), 0, 0, 1, 1); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#1", new Size (inf, inf)); g.Reset (); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#2"); g.ChangeRowSpan (0, 2); g.Reset (); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#3", new Size (inf, inf)); g.ChangeColSpan (0, 2); g.Reset (); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#4", new Size (inf, inf)); g.ChangeRow (0, 1); g.Reset (); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#5", new Size (inf, inf)); g.ChangeCol (0, 1); g.Reset (); g.Measure (new Size (50, 50)); g.CheckMeasureArgs ("#6", new Size (inf, inf)); }
public void MeasureAutoAndStarRows () { MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, new GridLength (1, GridUnitType.Star), GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 50), 0, 0, 3, 1); grid.AddChild (new MyContentControl (50, 60), 1, 0, 3, 1); grid.Measure (new Size (100, 100)); grid.CheckRowHeights ("#1", inf, inf, 100, inf, inf); grid.CheckMeasureArgs ("#2", new Size (50, 100), new Size (50, 100)); grid.CheckMeasureOrder ("#3", 0, 1); Assert.AreEqual (new Size (50, 60), grid.DesiredSize, "#4"); grid.RowDefinitions [2].MaxHeight = 15; grid.Reset (); grid.Measure (new Size (100, 100)); grid.CheckRowHeights ("#5", inf, inf, 15, inf, inf); grid.CheckMeasureArgs ("#6", new Size (50, 15), new Size (50, 15)); Assert.AreEqual (new Size (50, 15), grid.DesiredSize, "#7"); grid.RowDefinitions.Clear (); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto, new GridLength (1, GridUnitType.Star), GridLength.Auto); grid.Reset (); grid.Measure (new Size (100, 100)); grid.CheckRowHeights ("#8", inf, inf, inf, 50, inf); grid.CheckMeasureArgs ("#9", new Size (50, inf), new Size (50, 83.33)); Assert.AreEqual (new Size (50, 77), grid.DesiredSize, "#10"); grid.RowDefinitions [3].MaxHeight = 15; grid.Reset (); grid.Measure (new Size (100, 100)); grid.CheckRowHeights ("#11", inf, inf, inf, 15, inf); grid.CheckMeasureArgs ("#12", new Size (50, 48.8)); grid.CheckMeasureOrder ("#13", 1); Assert.AreEqual (new Size (50, 65), grid.DesiredSize, "#12"); }
public void ChildInvalidatesGrid2 () { var child = new MyContentControl (50, 50); MyGrid grid = new MyGrid (); grid.Children.Add (child); grid.Measure (new Size (100, 100)); Assert.AreEqual (1, grid.MeasuredElements.Count, "#1"); child.InvalidateMeasure (); grid.Measure (new Size (100, 100)); Assert.AreEqual (2, grid.MeasuredElements.Count, "#2"); }
public void StarAutoConstrainedGrid2 () { MyGrid g = new MyGrid { Width = 170, Height = 170 }; g.AddRows (GridLength.Auto, new GridLength (1, GridUnitType.Star)); g.AddColumns (GridLength.Auto, new GridLength (1, GridUnitType.Star)); g.AddChild (ContentControlWithChild (), 0, 1, 1, 1); g.AddChild (ContentControlWithChild (), 1, 0, 1, 1); g.AddChild (ContentControlWithChild (), 1, 1, 1, 1); g.AddChild (ContentControlWithChild (), 0, 0, 1, 1); foreach (MyContentControl child in g.Children) { Assert.AreEqual (0, child.ActualHeight, "height"); Assert.AreEqual (0, child.ActualWidth, "height"); Rectangle content = (Rectangle)child.Content; Assert.AreEqual (50, content.ActualHeight, "content height"); Assert.AreEqual (50, content.ActualWidth, "content width"); } g.Measure (new Size (170, 170)); g.CheckFinalMeasureArg ("#1", new Size (120, inf), new Size (inf, 120), new Size (120, 120), new Size (inf, inf)); }
public void ChildInvalidatesGrid3 () { var child = new MyContentControl (50, 50); MyGrid grid = new MyGrid (); grid.Children.Add (child); grid.Measure (new Size (100, 100)); Assert.AreEqual (1, grid.MeasuredElements.Count, "#1"); // Note that invalidating the measure of the content does // not invalidate the grid. ((FrameworkElement) child.Content).InvalidateMeasure (); grid.Measure (new Size (100, 100)); Assert.AreEqual (1, grid.MeasuredElements.Count, "#2"); }
public void StarRows () { GridUnitType star = GridUnitType.Star; MyGrid grid = new MyGrid { Name = "TESTER", Width = 100, Height = 210 }; grid.AddRows (new GridLength (1, star), new GridLength (2, star)); grid.AddChild (new MyContentControl (50, 50), 0, 0, 0, 0); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 70, 140); grid.CheckMeasureArgs ("#1a", new Size (100, 70)); grid.AddRows (new GridLength (30)); grid.Reset (); }, () => { grid.CheckRowHeights ("#2", 60, 120, 30); grid.CheckMeasureArgs ("#2a", new Size (100, 60)); grid.Reset (); // Add a child to the fixed row grid.AddChild (new MyContentControl (50, 80), 2, 0, 0, 0); }, () => { grid.CheckRowHeights ("#3", 60, 120, 30); grid.CheckMeasureArgs ("#3a", new Size (100, 30)); grid.Reset (); // Make the child span the last two rows grid.ChangeRow (1, 1); grid.ChangeRowSpan (1, 2); }, () => { grid.CheckRowHeights ("#4", 60, 120, 30); grid.CheckMeasureArgs ("#4a", new Size (100, 150)); grid.Reset (); // Add another fixed row and move the large child to span both grid.AddRows (new GridLength (30)); grid.ChangeRow (1, 2); }, () => { grid.CheckFinalMeasureArg ("#MeasureArgs", new Size (100, 50), new Size (100, 60)); grid.CheckRowHeights ("#5", 50, 100, 30, 30); } ); }
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 StarRows3 () { GridLength oneStar = new GridLength (1, GridUnitType.Star); MyGrid grid = new MyGrid (); grid.AddRows (oneStar, oneStar, oneStar); grid.AddColumns (oneStar, oneStar, oneStar); Canvas canvas = new Canvas { Width = 120, Height = 120 }; canvas.Children.Add (grid); grid.AddChild (new MyContentControl (100, 100), 1, 1, 1, 1); CreateAsyncTest (canvas, () => { }, () => { grid.CheckRowHeights ("#3", 0, 100, 0); grid.CheckMeasureArgs ("#1", Infinity); grid.CheckMeasureResult ("#2", new Size (100, 100)); grid.CheckRowHeights ("#3", 0, 100, 0); grid.CheckArrangeArgs ("#4", new Size (100, 100)); grid.CheckArrangeResult ("#5", new Size (100, 100)); } ); }
static MyGrid CreateGridWithChildren () { MyGrid grid = new MyGrid { Name = "GridUnderTest" }; grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (2, GridUnitType.Star), new GridLength (3, GridUnitType.Star)); grid.AddColumns (new GridLength (1, GridUnitType.Star), new GridLength (2, GridUnitType.Star), new GridLength (3, GridUnitType.Star)); for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) grid.AddChild (new MyContentControl { Content = new Rectangle { Fill = new SolidColorBrush (Colors.Red), MinWidth = 15, MinHeight = 15 } }, i, j, 1, 1); return grid; }
public void StarRows5 () { GridLength oneStar = new GridLength (1, GridUnitType.Star); MyGrid grid = new MyGrid { HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center }; grid.AddRows (oneStar, oneStar, oneStar); grid.AddColumns (oneStar, oneStar, oneStar); grid.AddChild (new MyContentControl (240, 240), 0, 0, 3, 3); grid.AddChild (new MyContentControl (150, 150), 0, 0, 1, 1); TestPanel.Children.Add (grid); grid.Measure (new Size (240, 240)); grid.Arrange (new Rect (0, 0, 120, 120)); grid.CheckRowHeights ("#1", 80, 80, 80); grid.CheckMeasureArgs ("#2", new Size (240, 240), new Size (80, 80)); grid.CheckMeasureResult ("#3", new Size (240, 240), new Size (80, 80)); grid.CheckDesired ("#4", new Size (240, 240), new Size (80, 80)); grid.CheckMeasureOrder ("#5", 0, 1); }
public void MeasureMaxAndMin2 () { MyGrid g = new MyGrid (); var child = new MyContentControl (50, 50); g.AddColumns (new GridLength (50)); g.AddRows (new GridLength (50), new GridLength (50)); g.AddChild (child, 0, 0, 1, 1); CreateAsyncTest (g, () => { g.CheckMeasureArgs ("#1", new Size (50, 50)); g.CheckRowHeights ("#2", 50, 50); g.Reset (); g.InvalidateSubtree (); g.RowDefinitions [0].MaxHeight = 20; }, () => { g.CheckMeasureArgs ("#3", new Size (50, 20)); g.CheckRowHeights ("#4", 20, 50); } ); }
public void AutoAndFixedRows2 () { TestPanel.Width = 200; TestPanel.Height = 1000; MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50), new GridLength (50), new GridLength (50)); grid.AddRows (new GridLength (30), new GridLength (40), GridLength.Auto, new GridLength (50)); grid.AddChild (new MyContentControl (600, 600), 0, 0, 4, 4); grid.AddChild (new MyContentControl (80, 70), 0, 1, 1, 1); grid.AddChild (new MyContentControl (50, 60), 1, 0, 1, 1); grid.AddChild (new MyContentControl (10, 500), 1, 1, 1, 1); CreateAsyncTest (grid, () => { grid.CheckRowHeights ("#1", 190, 200, 0, 210); grid.CheckMeasureArgs ("#2", new Size (150, double.PositiveInfinity), new Size (50, 30), new Size (50, 40), new Size (50, 40)); grid.CheckMeasureOrder ("#3", 0, 1, 2, 3); }); }
public void MeasureAutoRows () { MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); grid.AddChild (new MyContentControl (50, 50), 0, 0, 2, 1); grid.AddChild (new MyContentControl (50, 60), 0, 1, 1, 1); grid.Measure (new Size (0, 0)); grid.CheckMeasureArgs ("#1", new Size (50, inf), new Size (50, inf)); grid.Reset (); Assert.AreEqual (new Size (0, 0), grid.DesiredSize, "#2"); grid.Measure (new Size (50, 40)); grid.CheckMeasureSizes ("#3", new Size (50, inf), new Size (50, inf)); grid.Reset (); Assert.AreEqual (new Size (50, 40), grid.DesiredSize, "#4"); grid.Measure (new Size (500, 400)); grid.CheckMeasureSizes ("#5", new Size (50, inf), new Size (50, inf)); grid.Reset (); Assert.AreEqual (new Size (100, 60), grid.DesiredSize, "#6"); }
public void ExpandInArrange_OutsideTree_GridParent_UnfixedSize () { // We always expand star rows if we're not in the live tree // with a parent var parent = new Grid (); // Measure with infinity and check results. MyGrid grid = new MyGrid (); grid.AddRows (Star); grid.AddColumns (Star); grid.AddChild (ContentControlWithChild (), 0, 0, 1, 1); parent.Children.Add (grid); parent.Measure (Infinity); grid.CheckMeasureArgs ("#1", Infinity); grid.CheckMeasureResult ("#2", new Size (50, 50)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#3"); // When we pass in the desired size as the arrange arg, // the rows/cols use that as their height/width parent.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); grid.CheckArrangeArgs ("#4", grid.DesiredSize); grid.CheckArrangeResult ("#5", grid.DesiredSize); grid.CheckRowHeights ("#6", grid.DesiredSize.Height); grid.CheckColWidths ("#7", grid.DesiredSize.Width); // If we pass in twice the desired size, the rows/cols consume that too grid.Reset (); parent.Arrange (new Rect (0, 0, 100, 100)); grid.CheckMeasureArgs ("#8"); // No remeasures grid.CheckArrangeArgs ("#9", new Size (100, 100)); grid.CheckArrangeResult ("#10", new Size (100, 100)); grid.CheckRowHeights ("#11", 100); grid.CheckColWidths ("#12", 100); // If we measure with a finite size, the rows/cols still expand // to consume the available space grid.Reset (); parent.Measure (new Size (1000, 1000)); grid.CheckMeasureArgs ("#13", new Size (1000, 1000)); grid.CheckMeasureResult ("#14", new Size (50, 50)); Assert.AreEqual (new Size (50, 50), grid.DesiredSize, "#15"); // When we pass in the desired size as the arrange arg, // the rows/cols use that as their height/width parent.Arrange (new Rect (0, 0, grid.DesiredSize.Width, grid.DesiredSize.Height)); grid.CheckArrangeArgs ("#16", grid.DesiredSize); grid.CheckArrangeResult ("#17", grid.DesiredSize); grid.CheckRowHeights ("#18", grid.DesiredSize.Height); grid.CheckColWidths ("#19", grid.DesiredSize.Width); // If we pass in twice the desired size, the rows/cols consume that too grid.Reset (); parent.Arrange (new Rect (0, 0, 100, 100)); grid.CheckMeasureArgs ("#20"); // No remeasures grid.CheckArrangeArgs ("#21", new Size (100, 100)); grid.CheckArrangeResult ("#22", new Size (100, 100)); grid.CheckRowHeights ("#23", 100); grid.CheckColWidths ("#24", 100); }
public void MeasureAutoRows2 () { double inf = double.PositiveInfinity; MyGrid grid = new MyGrid (); grid.AddColumns (new GridLength (50), new GridLength (50)); grid.AddRows (GridLength.Auto, GridLength.Auto, GridLength.Auto); MyContentControl c = new MyContentControl (50, 50); grid.AddChild (c, 0, 0, 2, 1); grid.AddChild (new MyContentControl (50, 60), 0, 1, 1, 1); grid.AddChild (new MyContentControl (50, 20), 0, 1, 1, 1); grid.Measure (new Size (500, 400)); grid.CheckMeasureArgs ("#1", new Size (50, inf), new Size (50, inf), new Size (50, inf)); grid.CheckMeasureOrder ("#2", 0, 1, 2); Assert.AreEqual (new Size (100, 60), grid.DesiredSize, "#2"); grid.ChangeRow (2, 1); grid.Reset (); grid.Measure (new Size (500, 400)); grid.CheckMeasureArgs ("#3", new Size (50, inf)); grid.CheckMeasureOrder ("#4", 2); Assert.AreEqual (new Size (100, 80), grid.DesiredSize, "#4"); grid.InvalidateSubtree (); ((FrameworkElement) c.Content).Height = 100; grid.Reset (); grid.Measure (new Size (500, 400)); grid.CheckMeasureArgs ("#5", new Size (50, inf), new Size (50, inf), new Size (50, inf)); Assert.AreEqual (new Size (100, 100), grid.DesiredSize, "#6"); grid.Reset (); grid.ChangeRow (2, 2); grid.Measure (new Size (500, 400)); grid.CheckMeasureArgs ("#7", new Size (50, inf)); grid.CheckMeasureOrder ("#8", 2); Assert.AreEqual (new Size (100, 120), grid.DesiredSize, "#8"); }