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