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");
}
