public void ArrangeChild_ColSpan2_2Columns_constSize_and_1Star_1Row_constSize()
{
MyGrid g = new MyGrid();
g.AddRows(new GridLength(200));
g.AddColumns(new GridLength(200), new GridLength(2, GridUnitType.Star));
g.Margin = new Thickness(5);
MyContentControl mc = new MyContentControl {
Content = new Canvas {
Width = 400, Height = 400
}
};
Grid.SetRow(mc, 0);
Grid.SetColumn(mc, 0);
Grid.SetColumnSpan(mc, 2);
g.Children.Add(mc);
TestPanel.Width = 500;
TestPanel.Height = 500;
CreateAsyncTest(g,
() => {
g.CheckMeasureArgs("#MeasureOverrideArg", new Size(490, 200));
g.CheckRowHeights("#RowHeights", 200);
g.CheckColWidths("#ColWidths", 200, 290);
TestPanel.Width = 100;
TestPanel.Height = 100;
g.Reset();
}, () => {
g.CheckMeasureArgs("#MeasureOverrideArg 2", new Size(200, 200));
g.CheckRowHeights("#RowHeights 2", 200);
g.CheckColWidths("#ColWidths 2", 200, 0);
}
);
}
public void ArrangeTest()
{
MyGrid g = new MyGrid();
RowDefinition rdef;
ColumnDefinition cdef;
rdef = new RowDefinition();
rdef.Height = new GridLength(50);
g.RowDefinitions.Add(rdef);
cdef = new ColumnDefinition();
cdef.Width = new GridLength(100);
g.ColumnDefinitions.Add(cdef);
g.Margin = new Thickness(5);
var r = new Border();
MyContentControl mc = new MyContentControl {
Content = r
};
Grid.SetRow(mc, 0);
Grid.SetColumn(mc, 0);
g.Children.Add(mc);
g.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
g.CheckMeasureArgs("#MeasureOverrideArg", new Size(100, 50));
g.Reset();
Assert.AreEqual(new Size(0, 0), new Size(r.ActualWidth, r.ActualHeight), "r actual after measure");
Assert.AreEqual(new Size(0, 0), new Size(g.ActualWidth, g.ActualHeight), "g actual after measure");
g.Arrange(new Rect(0, 0, g.DesiredSize.Width, g.DesiredSize.Height));
g.CheckRowHeights("#RowHeights", 50);
Assert.AreEqual(new Size(0, 0), r.DesiredSize, "r desired 0");
Assert.AreEqual(new Size(110, 60), g.DesiredSize, "g desired 1");
Assert.AreEqual(new Rect(0, 0, 100, 50).ToString(), LayoutInformation.GetLayoutSlot(r).ToString(), "slot");
Assert.AreEqual(new Size(100, 50), new Size(r.ActualWidth, r.ActualHeight), "r actual after arrange");
Assert.AreEqual(new Size(100, 50), new Size(g.ActualWidth, g.ActualHeight), "g actual after arrange");
}
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 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 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 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");
});
}
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 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 ArrangeTest ()
{
MyGrid g = new MyGrid ();
RowDefinition rdef;
ColumnDefinition cdef;
rdef = new RowDefinition ();
rdef.Height = new GridLength (50);
g.RowDefinitions.Add (rdef);
cdef = new ColumnDefinition ();
cdef.Width = new GridLength (100);
g.ColumnDefinitions.Add (cdef);
g.Margin = new Thickness (5);
var r = new Border ();
MyContentControl mc = new MyContentControl { Content = r };
Grid.SetRow (mc, 0);
Grid.SetColumn (mc, 0);
g.Children.Add (mc);
g.Measure (new Size (Double.PositiveInfinity, Double.PositiveInfinity));
g.CheckMeasureArgs ("#MeasureOverrideArg", new Size (100, 50));
g.Reset ();
Assert.AreEqual (new Size (0,0), new Size (r.ActualWidth, r.ActualHeight), "r actual after measure");
Assert.AreEqual (new Size (0,0), new Size (g.ActualWidth, g.ActualHeight), "g actual after measure");
g.Arrange (new Rect (0,0,g.DesiredSize.Width,g.DesiredSize.Height));
g.CheckRowHeights ("#RowHeights", 50);
Assert.AreEqual (new Size (0,0), r.DesiredSize, "r desired 0");
Assert.AreEqual (new Size (110,60), g.DesiredSize, "g desired 1");
Assert.AreEqual (new Rect (0,0,100,50).ToString (), LayoutInformation.GetLayoutSlot (r).ToString(), "slot");
Assert.AreEqual (new Size (100,50), new Size (r.ActualWidth, r.ActualHeight), "r actual after arrange");
Assert.AreEqual (new Size (100,50), new Size (g.ActualWidth, g.ActualHeight), "g actual after arrange");
}
public void ArrangeChild_ColSpan2_2Columns_constSize_and_1Star_1Row_constSize ()
{
MyGrid g = new MyGrid ();
g.AddRows (new GridLength (200));
g.AddColumns (new GridLength (200), new GridLength (2, GridUnitType.Star));
g.Margin = new Thickness (5);
MyContentControl mc = new MyContentControl {
Content = new Canvas { Width = 400, Height = 400 }
};
Grid.SetRow (mc, 0);
Grid.SetColumn (mc, 0);
Grid.SetColumnSpan (mc, 2);
g.Children.Add (mc);
TestPanel.Width = 500;
TestPanel.Height = 500;
CreateAsyncTest (g,
() => {
g.CheckMeasureArgs ("#MeasureOverrideArg", new Size (490, 200));
g.CheckRowHeights ("#RowHeights", 200);
g.CheckColWidths ("#ColWidths", 200, 290);
TestPanel.Width = 100;
TestPanel.Height = 100;
g.Reset ();
}, () => {
g.CheckMeasureArgs ("#MeasureOverrideArg 2", new Size (200, 200));
g.CheckRowHeights ("#RowHeights 2", 200);
g.CheckColWidths ("#ColWidths 2", 200, 0);
}
);
}
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 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 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 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 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 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 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_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 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 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 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 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 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 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");
});
}
