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));
}
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));
}
public void MeasureOrder4()
{
TestPanel.Width = 500;
TestPanel.Height = 500;
MyGrid grid = new MyGrid();
grid.AddRows(new GridLength(1, GridUnitType.Star), new GridLength(1, GridUnitType.Auto), new GridLength(50));
grid.AddColumns(new GridLength(1, GridUnitType.Star), new GridLength(1, GridUnitType.Auto), new GridLength(50));
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
grid.AddChild(ContentControlWithChild(), i, j, 1, 1);
}
}
CreateAsyncTest(grid, () => {
grid.CheckMeasureOrder("#1", 4, 5, 7, 8, 1, 3, 6, 1, 0, 2);
grid.CheckMeasureArgs("#2", new Size(inf, inf), new Size(50, inf), new Size(inf, 50),
new Size(50, 50), new Size(inf, inf), new Size(400, inf),
new Size(400, 50), new Size(inf, 400), new Size(400, 400), new Size(50, 400));
grid.ReverseChildren();
grid.Reset();
}, () => {
grid.CheckMeasureOrder("#3", 0, 1, 3, 4, 7, 2, 5, 7, 6, 8);
grid.CheckMeasureArgs("#4", new Size(50, 50), new Size(inf, 50), new Size(50, inf),
new Size(inf, inf), new Size(inf, inf), new Size(400, 50),
new Size(400, inf), new Size(inf, 400), new Size(50, 400), new Size(400, 400));
});
}
public void MeasureOrder7()
{
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid {
Name = "TESTER", Width = 100, Height = 210
};
grid.AddRows(new GridLength(1, star), new GridLength(2, star), new GridLength(30), new GridLength(30));
grid.AddChild(new MyContentControl(50, 50), 0, 0, 0, 0);
grid.AddChild(new MyContentControl(50, 80), 2, 0, 2, 0);
CreateAsyncTest(grid,
() => { },
() => {
grid.CheckFinalMeasureArg("#1", new Size(100, 50), new Size(100, 60));
grid.CheckRowHeights("#2", 50, 100, 30, 30);
grid.CheckMeasureOrder("#3", 1, 0);
grid.CheckMeasureArgs("#4", new Size(100, 60), new Size(100, 50));
});
}
public void MeasureOrder6()
{
TestPanel.Width = 500;
TestPanel.Height = 500;
MyGrid grid = new MyGrid();
grid.AddRows(new GridLength(1, GridUnitType.Star), new GridLength(1, GridUnitType.Auto), new GridLength(50), new GridLength(1, GridUnitType.Star), GridLength.Auto);
grid.AddColumns(new GridLength(1, GridUnitType.Star), new GridLength(1, GridUnitType.Auto), new GridLength(1, GridUnitType.Star), new GridLength(50), GridLength.Auto);
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
grid.AddChild(ContentControlWithChild(), i, j, 1, 1);
}
}
CreateAsyncTest(grid, () => {
grid.CheckMeasureOrder("#1", 6, 8, 9, 11, 13, 14, 21, 23, 24, 1, 4, 16, 19, 5, 7, 10, 12, 20, 22, 1, 4, 16, 19, 0, 2, 3, 15, 17, 18);
grid.CheckMeasureArgs("#2",
new Size(inf, inf), new Size(50, inf), new Size(inf, inf), new Size(inf, 50), new Size(50, 50),
new Size(inf, 50), new Size(inf, inf), new Size(50, inf), new Size(inf, inf), new Size(inf, inf),
new Size(inf, inf), new Size(inf, inf), new Size(inf, inf), new Size(175, inf), new Size(175, inf),
new Size(175, 50), new Size(175, 50), new Size(175, inf), new Size(175, inf), new Size(inf, 175),
new Size(inf, 175), new Size(inf, 175), new Size(inf, 175), new Size(175, 175), new Size(175, 175),
new Size(50, 175), new Size(175, 175), new Size(175, 175), new Size(50, 175));
grid.ReverseChildren();
grid.Reset();
}, () => {
grid.CheckMeasureOrder("#3", 0, 1, 3, 10, 11, 13, 15, 16, 18, 5,
8, 20, 23, 2, 4, 12, 14, 17, 19, 5,
8, 20, 23, 6, 7, 9, 21, 22, 24);
grid.CheckMeasureArgs("#4",
new Size(inf, inf), new Size(50, inf), new Size(inf, inf), new Size(inf, 50), new Size(50, 50),
new Size(inf, 50), new Size(inf, inf), new Size(50, inf), new Size(inf, inf), new Size(inf, inf),
new Size(inf, inf), new Size(inf, inf), new Size(inf, inf), new Size(175, inf), new Size(175, inf),
new Size(175, 50), new Size(175, 50), new Size(175, inf), new Size(175, inf), new Size(inf, 175),
new Size(inf, 175), new Size(inf, 175), new Size(inf, 175), new Size(50, 175), new Size(175, 175),
new Size(175, 175), new Size(50, 175), new Size(175, 175), new Size(175, 175));
});
}
public void MeasureOrder7b()
{
// Items which have no star row/col are measured first. Rowspan/Colspan is taken into account
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid {
Name = "TESTER", Width = 230, Height = 230
};
grid.AddRows(new GridLength(1, star), new GridLength(30));
grid.AddColumns(new GridLength(30), new GridLength(1, star));
// Create a 2x2 grid containing a child for every valid combination
// of row, column, rowspan and colspan
for (int row = 0; row < 2; row++)
{
for (int col = 0; col < 2; col++)
{
for (int rowspan = row + 1; rowspan <= 2; rowspan++)
{
for (int colspan = col + 1; colspan <= 2; colspan++)
{
grid.AddChild(ContentControlWithChild(), row, col, rowspan, colspan);
}
}
}
}
var o = grid.Children [6];
grid.Children.RemoveAt(6);
grid.Children.Add(o);
CreateAsyncTest(grid, () => {
grid.CheckMeasureOrder("#1", 8, 6, 7, 0, 1, 2, 3, 4, 5);
grid.CheckMeasureArgs("#2",
new Size(30, 30), new Size(230, 30), new Size(200, 30),
new Size(30, 200), new Size(230, 200), new Size(30, 230),
new Size(230, 230), new Size(200, 200), new Size(200, 230));
});
}
public void MeasureOrder8b()
{
// Items which have no star row/col are measured first. Rowspan/Colspan is taken into account
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid {
Name = "TESTER", Width = 230, Height = 230
};
grid.AddRows(GridLength.Auto, new GridLength(1, star));
grid.AddColumns(new GridLength(1, star), GridLength.Auto);
// Create a 2x2 grid containing a child for every valid combination
// of row, column, rowspan and colspan
for (int row = 0; row < grid.RowDefinitions.Count; row++)
{
for (int col = 0; col < grid.ColumnDefinitions.Count; col++)
{
for (int rowspan = 1; (row + rowspan) <= grid.RowDefinitions.Count; rowspan++)
{
for (int colspan = 1; (col + colspan) <= grid.ColumnDefinitions.Count; colspan++)
{
grid.AddChild(ContentControlWithChild(), row, col, rowspan, colspan);
}
}
}
}
CreateAsyncTest(grid, () => {
grid.CheckMeasureOrder("#1", 4, 5, 8, 0, 1, 5, 8, 2, 3, 6, 7);
grid.CheckMeasureArgs("#2",
new Size(inf, inf), new Size(inf, inf), new Size(inf, inf),
new Size(180, inf), new Size(230, inf), new Size(inf, 230),
new Size(inf, 180), new Size(180, 230), new Size(230, 230),
new Size(180, 180), new Size(230, 180));
});
}
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 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 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");
}
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 MeasureOrder6 ()
{
TestPanel.Width = 500;
TestPanel.Height = 500;
MyGrid grid = new MyGrid ();
grid.AddRows (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Auto), new GridLength (50), new GridLength (1, GridUnitType.Star), GridLength.Auto);
grid.AddColumns (new GridLength (1, GridUnitType.Star), new GridLength (1, GridUnitType.Auto), new GridLength (1, GridUnitType.Star), new GridLength (50), GridLength.Auto);
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
grid.AddChild (ContentControlWithChild (), i, j, 1, 1);
CreateAsyncTest (grid, () => {
grid.CheckMeasureOrder ("#1", 6, 8, 9, 11, 13, 14, 21, 23, 24, 1, 4, 16, 19, 5, 7, 10, 12, 20, 22, 1, 4, 16, 19, 0, 2, 3, 15, 17, 18);
grid.CheckMeasureArgs ("#2",
new Size (inf, inf), new Size (50, inf), new Size (inf, inf), new Size (inf, 50), new Size (50, 50),
new Size (inf, 50), new Size (inf, inf), new Size (50, inf), new Size (inf, inf), new Size (inf, inf),
new Size (inf, inf), new Size (inf, inf), new Size (inf, inf), new Size (175, inf), new Size (175, inf),
new Size (175, 50), new Size (175, 50), new Size (175, inf), new Size (175, inf), new Size (inf, 175),
new Size (inf, 175), new Size (inf, 175), new Size (inf, 175), new Size (175, 175), new Size (175, 175),
new Size (50, 175), new Size (175, 175), new Size (175, 175), new Size (50, 175));
grid.ReverseChildren ();
grid.Reset ();
}, () => {
grid.CheckMeasureOrder ("#3", 0, 1, 3, 10, 11, 13, 15, 16, 18, 5,
8, 20, 23, 2, 4, 12, 14, 17, 19, 5,
8, 20, 23, 6, 7, 9, 21, 22, 24);
grid.CheckMeasureArgs ("#4",
new Size (inf, inf), new Size (50, inf), new Size (inf, inf), new Size (inf, 50), new Size (50, 50),
new Size (inf, 50), new Size (inf, inf), new Size (50, inf), new Size (inf, inf), new Size (inf, inf),
new Size (inf, inf), new Size (inf, inf), new Size (inf, inf), new Size (175, inf), new Size (175, inf),
new Size (175, 50), new Size (175, 50), new Size (175, inf), new Size (175, inf), new Size (inf, 175),
new Size (inf, 175), new Size (inf, 175), new Size (inf, 175), new Size (50, 175), new Size (175, 175),
new Size (175, 175), new Size (50, 175), new Size (175, 175), new Size (175, 175));
});
}
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));
}
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 MeasureOrder7 ()
{
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid { Name = "TESTER", Width = 100, Height = 210 };
grid.AddRows (new GridLength (1, star), new GridLength (2, star), new GridLength (30), new GridLength (30));
grid.AddChild (new MyContentControl (50, 50), 0, 0, 0, 0);
grid.AddChild (new MyContentControl (50, 80), 2, 0, 2, 0);
CreateAsyncTest (grid,
() => { },
() => {
grid.CheckFinalMeasureArg ("#1", new Size (100, 50), new Size (100, 60));
grid.CheckRowHeights ("#2", 50, 100, 30, 30);
grid.CheckMeasureOrder ("#3", 1, 0);
grid.CheckMeasureArgs ("#4", new Size (100, 60), new Size (100, 50));
});
}
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);
}
);
}
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 MeasureOrder7b ()
{
// Items which have no star row/col are measured first. Rowspan/Colspan is taken into account
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid { Name = "TESTER", Width = 230, Height = 230 };
grid.AddRows (new GridLength (1, star), new GridLength (30));
grid.AddColumns (new GridLength (30), new GridLength (1, star));
// Create a 2x2 grid containing a child for every valid combination
// of row, column, rowspan and colspan
for (int row = 0; row < 2; row++)
for (int col = 0; col < 2; col++)
for (int rowspan = row + 1; rowspan <= 2; rowspan++)
for (int colspan = col + 1; colspan <= 2; colspan++)
grid.AddChild (ContentControlWithChild (), row, col, rowspan, colspan);
var o = grid.Children [6];
grid.Children.RemoveAt (6);
grid.Children.Add (o);
CreateAsyncTest (grid, () => {
grid.CheckMeasureOrder ("#1", 8, 6, 7, 0, 1, 2, 3, 4, 5);
grid.CheckMeasureArgs ("#2",
new Size (30, 30), new Size (230, 30), new Size (200, 30),
new Size (30, 200), new Size (230, 200), new Size (30, 230),
new Size (230, 230), new Size (200, 200), new Size (200, 230));
});
}
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 MeasureOrder8b ()
{
// Items which have no star row/col are measured first. Rowspan/Colspan is taken into account
GridUnitType star = GridUnitType.Star;
MyGrid grid = new MyGrid { Name = "TESTER", Width = 230, Height = 230 };
grid.AddRows (GridLength.Auto, new GridLength (1, star));
grid.AddColumns (new GridLength (1, star), GridLength.Auto);
// Create a 2x2 grid containing a child for every valid combination
// of row, column, rowspan and colspan
for (int row = 0; row < grid.RowDefinitions.Count; row++)
for (int col = 0; col < grid.ColumnDefinitions.Count; col++)
for (int rowspan = 1; (row + rowspan) <= grid.RowDefinitions.Count; rowspan++)
for (int colspan = 1; (col + colspan) <= grid.ColumnDefinitions.Count; colspan++)
grid.AddChild (ContentControlWithChild (), row, col, rowspan, colspan);
CreateAsyncTest (grid, () => {
grid.CheckMeasureOrder ("#1", 4, 5, 8, 0, 1, 5, 8, 2, 3, 6, 7);
grid.CheckMeasureArgs ("#2",
new Size (inf, inf), new Size (inf, inf), new Size (inf, inf),
new Size (180, inf), new Size (230, inf), new Size (inf, 230),
new Size (inf, 180), new Size (180, 230), new Size (230, 230),
new Size (180, 180), new Size (230, 180));
});
}
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));
}
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 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 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 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 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 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));
}
);
}
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 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 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 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 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 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 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);
}
