public NativeViewWrapper(FrameworkElement nativeElement, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
GetDesiredSizeDelegate = getDesiredSizeDelegate;
ArrangeOverrideDelegate = arrangeOverrideDelegate;
MeasureOverrideDelegate = measureOverrideDelegate;
NativeElement = nativeElement;
}
public NativeViewWrapper(FrameworkElement nativeElement, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
GetDesiredSizeDelegate = getDesiredSizeDelegate;
ArrangeOverrideDelegate = arrangeOverrideDelegate;
MeasureOverrideDelegate = measureOverrideDelegate;
NativeElement = nativeElement;
}
public NativeViewWrapper(FrameworkElement nativeElement, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
GetDesiredSizeDelegate = getDesiredSizeDelegate;
ArrangeOverrideDelegate = arrangeOverrideDelegate;
MeasureOverrideDelegate = measureOverrideDelegate;
NativeElement = nativeElement;
nativeElement.TransferbindablePropertiesToWrapper(this);
}
public static View ToView(this FrameworkElement view, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
return(new NativeViewWrapper(view, getDesiredSizeDelegate, arrangeOverrideDelegate, measureOverrideDelegate));
}
public static void Add(this IList <View> children, FrameworkElement view, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
children.Add(view.ToView(getDesiredSizeDelegate, arrangeOverrideDelegate, measureOverrideDelegate));
}
private void TestInvalidationSystemCore(bool parentIsCollapsed, ReturnBoolDelegate getArrangeHasBeenCalledVal)
{
var worldMatrix = Matrix.Zero;
ResetElementState();
onMeasureOverride += SetMeasureOverrideToCalled;
onArrageOverride += SetArrangeOverrideToCalled;
onCollapsedOverride += SetCollapseOverrideToCalled;
Measure(Vector3.Zero);
Arrange(Vector3.Zero, parentIsCollapsed);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
measureOverrideHasBeenCalled = false;
arrangeOverrideHasBeenCalled = false;
collapseOverrideHasBeenCalled = false;
InvalidateMeasure();
Assert.IsFalse(IsMeasureValid);
Assert.IsFalse(IsArrangeValid);
Measure(Vector3.Zero);
Assert.IsTrue(IsMeasureValid);
Assert.IsFalse(IsArrangeValid);
Assert.IsTrue(measureOverrideHasBeenCalled);
Arrange(Vector3.Zero, parentIsCollapsed);
Assert.IsTrue(IsArrangeValid);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(getArrangeHasBeenCalledVal());
worldMatrix.M11 = 2;
UpdateWorldMatrix(ref worldMatrix, false); // check that invalidation of arrange force the update of the world matrix
Assert.AreEqual(worldMatrix.M11, WorldMatrix.M11);
measureOverrideHasBeenCalled = false;
arrangeOverrideHasBeenCalled = false;
collapseOverrideHasBeenCalled = false;
InvalidateArrange();
Assert.IsTrue(IsMeasureValid);
Assert.IsFalse(IsArrangeValid);
Measure(Vector3.Zero);
Assert.IsTrue(IsMeasureValid);
Assert.IsFalse(IsArrangeValid);
Assert.IsFalse(measureOverrideHasBeenCalled);
Arrange(Vector3.Zero, parentIsCollapsed);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsTrue(getArrangeHasBeenCalledVal());
worldMatrix.M11 = 3;
UpdateWorldMatrix(ref worldMatrix, false); // check that invalidation of arrange force the update of the world matrix
Assert.AreEqual(worldMatrix.M11, WorldMatrix.M11);
measureOverrideHasBeenCalled = false;
arrangeOverrideHasBeenCalled = false;
collapseOverrideHasBeenCalled = false;
Measure(Vector3.Zero);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsFalse(measureOverrideHasBeenCalled);
Arrange(Vector3.Zero, parentIsCollapsed);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsFalse(getArrangeHasBeenCalledVal());
worldMatrix.M11 = 4;
UpdateWorldMatrix(ref worldMatrix, false); // check that the world matrix is not re-calculated if the arrangement is not invalidated
Assert.AreEqual(3, WorldMatrix.M11);
measureOverrideHasBeenCalled = false;
arrangeOverrideHasBeenCalled = false;
collapseOverrideHasBeenCalled = false;
Measure(Vector3.One); // check that measuring with a new value force the re-measurement but not re-arrangement
Assert.IsTrue(IsMeasureValid);
Assert.IsFalse(IsArrangeValid);
Assert.IsTrue(measureOverrideHasBeenCalled);
Arrange(Vector3.Zero, parentIsCollapsed);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsFalse(getArrangeHasBeenCalledVal());
measureOverrideHasBeenCalled = false;
arrangeOverrideHasBeenCalled = false;
collapseOverrideHasBeenCalled = false;
Measure(Vector3.One);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsFalse(measureOverrideHasBeenCalled);
Arrange(Vector3.One, parentIsCollapsed); // check that arranging with a new value force the re-arrangement
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsTrue(getArrangeHasBeenCalledVal());
Measure(Vector3.One);
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsFalse(measureOverrideHasBeenCalled);
Arrange(Vector3.One, !parentIsCollapsed); // check that arranging with a new value of the parent collapse state force the re-arrangement
Assert.IsTrue(IsMeasureValid);
Assert.IsTrue(IsArrangeValid);
Assert.IsTrue(getArrangeHasBeenCalledVal());
}
private void TestArrangeNotCollapsedCore(HorizontalAlignment alignX)
{
// reset state
ResetElementState();
// set the alignments
HorizontalAlignment = alignX;
switch (alignX)
{
case HorizontalAlignment.Left:
VerticalAlignment = VerticalAlignment.Top;
DepthAlignment = DepthAlignment.Back;
break;
case HorizontalAlignment.Center:
VerticalAlignment = VerticalAlignment.Center;
DepthAlignment = DepthAlignment.Center;
break;
case HorizontalAlignment.Right:
VerticalAlignment = VerticalAlignment.Bottom;
DepthAlignment = DepthAlignment.Front;
break;
case HorizontalAlignment.Stretch:
VerticalAlignment = VerticalAlignment.Stretch;
DepthAlignment = DepthAlignment.Stretch;
break;
default:
throw new ArgumentOutOfRangeException("alignX");
}
// check that the element is measured if necessary
InvalidateMeasure();
Measure(Vector3.Zero);
Arrange(Vector3.Zero, false);
Assert.AreEqual(true, IsMeasureValid);
// set the default callbacks
var desiredSize = 1000 * rand.NextVector3();
onMeasureOverride = _ => desiredSize;
onCollapsedOverride = () => collaspedHasBeenCalled = true;
onArrageOverride = delegate(Vector3 size)
{
Assert.AreEqual(expectedProvidedSizeInMeasureOverride, size);
arrangeOverridedHasBeenCalled = true;
return base.ArrangeOverride(size);
};
// check size and offset when size is fixed
Width = 100 * rand.NextFloat();
Height = 100 * rand.NextFloat();
Depth = 100 * rand.NextFloat();
PertubArrangeResultValues();
expectedProvidedSizeInMeasureOverride = new Vector3(Width, Height, Depth);
ArrangeAndPerformsNotCollapsedStateTests(1000 * rand.NextVector3(), expectedProvidedSizeInMeasureOverride);
// revert fixed size
Width = float.NaN;
Height = float.NaN;
Depth = float.NaN;
// check size and offset when size is not fixed
PertubArrangeResultValues();
var providedSpace = 1000 * rand.NextVector3();
var providedWithoutMargins = CalculateSizeWithoutThickness(ref providedSpace, ref MarginInternal);
if (HorizontalAlignment == HorizontalAlignment.Stretch && VerticalAlignment == VerticalAlignment.Stretch && DepthAlignment == DepthAlignment.Stretch)
{
expectedProvidedSizeInMeasureOverride = providedWithoutMargins;
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, providedWithoutMargins);
}
else
{
Measure(providedSpace);
expectedProvidedSizeInMeasureOverride = new Vector3(
Math.Min(DesiredSize.X, providedWithoutMargins.X),
Math.Min(DesiredSize.Y, providedWithoutMargins.Y),
Math.Min(DesiredSize.Z, providedWithoutMargins.Z));
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, expectedProvidedSizeInMeasureOverride);
}
// check the size if extrema values are set
PertubArrangeResultValues();
var extremum = new Vector3(21, 22, 23);
MinimumWidth = extremum.X;
MinimumHeight = extremum.Y;
MinimumDepth = extremum.Z;
MaximumWidth = extremum.X;
MaximumHeight = extremum.Y;
MaximumDepth = extremum.Z;
expectedProvidedSizeInMeasureOverride = extremum;
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, extremum);
// revert extrema values
MinimumWidth = 0;
MinimumHeight = 0;
MinimumDepth = 0;
MaximumWidth = float.PositiveInfinity;
MaximumHeight =float.PositiveInfinity;
MaximumDepth = float.PositiveInfinity;
// check blend of above cases
PertubArrangeResultValues();
MinimumWidth = extremum.X;
MaximumWidth = extremum.X;
Height = 100 * rand.NextFloat();
providedWithoutMargins = CalculateSizeWithoutThickness(ref providedSpace, ref MarginInternal);
if (HorizontalAlignment == HorizontalAlignment.Stretch && VerticalAlignment == VerticalAlignment.Stretch && DepthAlignment == DepthAlignment.Stretch)
{
expectedProvidedSizeInMeasureOverride = new Vector3(extremum.X, Height, providedWithoutMargins.Z);
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, expectedProvidedSizeInMeasureOverride);
}
else
{
expectedProvidedSizeInMeasureOverride = new Vector3(extremum.X, Height, Math.Min(desiredSize.Z, providedWithoutMargins.Z));
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, expectedProvidedSizeInMeasureOverride);
}
// check that the size returned by ArrangeOverride override the previous calculated size for RenderSize
PertubArrangeResultValues();
var onArrangeOverrideSize = new Vector3(10000, 20000, 30000);
onArrageOverride = delegate { arrangeOverridedHasBeenCalled = true; return onArrangeOverrideSize; };
ArrangeAndPerformsNotCollapsedStateTests(providedSpace, onArrangeOverrideSize);
}
private void TestMeasureNotCollapsedWithMinAndMax(Vector3 min, Vector3 max)
{
// reset state of the element
ResetElementState();
DepthAlignment = DepthAlignment.Stretch;
// set the min and max values
MinimumWidth = min.X;
MinimumHeight = min.Y;
MinimumDepth = min.Z;
MaximumWidth = max.X;
MaximumHeight = max.Y;
MaximumDepth = max.Z;
// check with fixed size
Width = 1000 * rand.NextFloat();
Height = 1000 * rand.NextFloat();
Depth = 1000 * rand.NextFloat();
Margin = rand.NextThickness(10, 20, 30, 40, 50, 60);
MeasuredAndCheckThatDesiredSizesAreCorrect(100 * rand.NextVector3(), new Vector3(Width, Height, Depth), min, max);
// reset fixed size
Width = float.NaN;
Height = float.NaN;
Depth = float.NaN;
// check with MeasureOverride
var onMeasureOverrideSize = new Vector3(10, 20, 30);
onMeasureOverride += _ => onMeasureOverrideSize;
MeasuredAndCheckThatDesiredSizesAreCorrect(100 * rand.NextVector3(), onMeasureOverrideSize, min, max);
// check size given to MeasureOverride
onMeasureOverride = availableSize => availableSize / 2;
var providedSize = 100 * rand.NextVector3();
var providedSizeWithoutMargin = CalculateSizeWithoutThickness(ref providedSize, ref MarginInternal);
var expectedSize = new Vector3(Math.Min(providedSizeWithoutMargin.X, max.X), Math.Min(providedSizeWithoutMargin.Y, max.Y), Math.Min(providedSizeWithoutMargin.Z, max.Z)) / 2;
MeasuredAndCheckThatDesiredSizesAreCorrect(providedSize, expectedSize, min, max);
// check default values
expectedSize = new Vector3(40, 50, 60);
onMeasureOverride = _ => new Vector3(float.NaN, float.NaN, float.NaN);
DefaultWidth = expectedSize.X;
DefaultHeight = expectedSize.Y;
DefaultDepth = expectedSize.Z;
MeasuredAndCheckThatDesiredSizesAreCorrect(100 * rand.NextVector3(), expectedSize, min, max);
// check blend of all
onMeasureOverride = _ => new Vector3(0, onMeasureOverrideSize.Y, float.NaN);
Width = 100 * rand.NextFloat();
expectedSize = new Vector3(Width, onMeasureOverrideSize.Y, DefaultDepth);
MeasuredAndCheckThatDesiredSizesAreCorrect(100 * rand.NextVector3(), expectedSize, min, max);
}
public void TestMeasureCollapsed()
{
// reset state of the element and set it to collapsed
ResetElementState();
Visibility = Visibility.Collapsed;
// Test that DesiredSize and DesiredSizeWithMargin are null by default
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// Test that DesiredSize and DesiredSizeWithMargin are null with non null margins
Margin = rand.NextThickness(10, 20, 30, 40, 50, 60);
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// set minimum size and test again
MinimumWidth = 1000*rand.NextFloat();
MinimumHeight = 1000*rand.NextFloat();
MinimumDepth = 1000 * rand.NextFloat();
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// set maximum size and test again
MaximumWidth = 1000 * rand.NextFloat();
MaximumHeight = 1000 * rand.NextFloat();
MaximumDepth = 1000 * rand.NextFloat();
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// set fixed size and test again
Width = 1000 * rand.NextFloat();
Height = 1000 * rand.NextFloat();
Depth = 1000 * rand.NextFloat();
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// set default size and test again
DefaultWidth = 1000 * rand.NextFloat();
DefaultHeight = 1000 * rand.NextFloat();
DefaultDepth = 1000 * rand.NextFloat();
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
// set the MeasureOverred function and try again
onMeasureOverride += size => new Vector3(1, 2, 3);
MeasuredWithRandomSizeAndCheckThatDesiredSizesAreNull();
}
public static View ToView(this FrameworkElement view, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
return new NativeViewWrapper(view, getDesiredSizeDelegate, arrangeOverrideDelegate, measureOverrideDelegate);
}
public static void Add(this IList<View> children, FrameworkElement view, GetDesiredSizeDelegate getDesiredSizeDelegate = null, ArrangeOverrideDelegate arrangeOverrideDelegate = null,
MeasureOverrideDelegate measureOverrideDelegate = null)
{
children.Add(view.ToView(getDesiredSizeDelegate, arrangeOverrideDelegate, measureOverrideDelegate));
}
