public void Only_Calls_LayoutManager_InvalidateArrange_Once()
{
var target = new Mock <ILayoutManager>();
var control = new Decorator();
var root = new LayoutTestRoot
{
Child = control,
LayoutManager = target.Object,
};
root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize));
target.ResetCalls();
control.InvalidateArrange();
control.InvalidateArrange();
target.Verify(x => x.InvalidateArrange(control), Times.Once());
}
public void Doesnt_Measure_Non_Invalidated_Root()
{
var control = new LayoutTestControl();
var root = new LayoutTestRoot {
Child = control
};
root.LayoutManager.ExecuteInitialLayoutPass(root);
root.Measured = root.Arranged = false;
control.Measured = control.Arranged = false;
control.InvalidateMeasure();
root.LayoutManager.ExecuteLayoutPass();
Assert.False(root.Measured);
Assert.False(root.Arranged);
Assert.True(control.Measured);
Assert.True(control.Arranged);
}
public void Arranges_InvalidateArranged_Control()
{
var target = new LayoutManager();
using (Start(target))
{
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root);
control.Measured = control.Arranged = false;
control.InvalidateArrange();
target.ExecuteLayoutPass();
Assert.False(control.Measured);
Assert.True(control.Arranged);
}
}
public void Doesnt_Measure_Removed_Control()
{
var target = new LayoutManager();
using (Start(target))
{
var control = new LayoutTestControl();
var root = new LayoutTestRoot { Child = control };
target.ExecuteInitialLayoutPass(root);
control.Measured = control.Arranged = false;
control.InvalidateMeasure();
root.Child = null;
target.ExecuteLayoutPass();
Assert.False(control.Measured);
Assert.False(control.Arranged);
}
}
public void Measures_Parent_Of_Newly_Added_Control()
{
var target = new LayoutManager();
using (Start(target))
{
var control = new LayoutTestControl();
var root = new LayoutTestRoot();
target.ExecuteInitialLayoutPass(root);
root.Child = control;
root.Measured = root.Arranged = false;
target.ExecuteLayoutPass();
Assert.True(root.Measured);
Assert.True(root.Arranged);
Assert.True(control.Measured);
Assert.True(control.Arranged);
}
}
public void LayoutManager_Should_Properly_Arrange_Visuals_Even_When_There_Are_Issues_With_Previous_Arranged()
{
var nonArrageableTargets = Enumerable.Range(1, 10).Select(_ => new LayoutTestControl()).ToArray();
var targets = Enumerable.Range(1, 10).Select(_ => new LayoutTestControl()).ToArray();
StackPanel panel;
var root = new LayoutTestRoot
{
Child = panel = new StackPanel()
};
panel.Children.AddRange(nonArrageableTargets);
panel.Children.AddRange(targets);
root.LayoutManager.ExecuteInitialLayoutPass(root);
foreach (var c in panel.Children.OfType <LayoutTestControl>())
{
c.Measured = c.Arranged = false;
c.InvalidateMeasure();
}
foreach (var c in nonArrageableTargets)
{
c.DoArrangeOverride = (l, s) =>
{
//emulate a problem in the logic of a control that triggers
//invalidate measure during arrange
c.InvalidateMeasure();
return(new Size(100, 100));
};
}
root.LayoutManager.ExecuteLayoutPass();
//altough nonArrageableTargets has rubbish logic and can't be measured/arranged properly
//layoutmanager should process properly other visuals
Assert.All(targets, c => Assert.True(c.Arranged));
}
public void Measures_In_Correct_Order()
{
var target = new LayoutManager();
using (Start(target))
{
LayoutTestControl control1;
LayoutTestControl control2;
var root = new LayoutTestRoot
{
Child = control1 = new LayoutTestControl
{
Child = control2 = new LayoutTestControl(),
}
};
var order = new List <ILayoutable>();
Size MeasureOverride(ILayoutable control, Size size)
{
order.Add(control);
return(new Size(10, 10));
}
root.DoMeasureOverride = MeasureOverride;
control1.DoMeasureOverride = MeasureOverride;
control2.DoMeasureOverride = MeasureOverride;
target.ExecuteInitialLayoutPass(root);
control2.InvalidateMeasure();
control1.InvalidateMeasure();
root.InvalidateMeasure();
order.Clear();
target.ExecuteLayoutPass();
Assert.Equal(new ILayoutable[] { root, control1, control2 }, order);
}
}
public void Measures_Root_With_Infinity()
{
var target = new LayoutManager();
using (Start(target))
{
var root = new LayoutTestRoot();
var availableSize = default(Size);
// Should not measure with this size.
root.MaxClientSize = new Size(123, 456);
root.DoMeasureOverride = (_, s) =>
{
availableSize = s;
return new Size(100, 100);
};
target.ExecuteInitialLayoutPass(root);
Assert.Equal(Size.Infinity, availableSize);
}
}
public void Arranges_Root_With_DesiredSize()
{
var root = new LayoutTestRoot
{
Width = 100,
Height = 100,
};
var arrangeSize = default(Size);
root.DoArrangeOverride = (_, s) =>
{
arrangeSize = s;
return(s);
};
root.LayoutManager.ExecuteInitialLayoutPass(root);
Assert.Equal(new Size(100, 100), arrangeSize);
root.Width = 120;
root.LayoutManager.ExecuteLayoutPass();
Assert.Equal(new Size(120, 100), arrangeSize);
}