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);
}
public void TestArrangeCollapsed()
{
// reset state
ResetElementState();
// set margins
Margin = new Thickness(11,12,13,14,15,16);
// set the callbacks
onCollapsedOverride = () => collaspedHasBeenCalled = true;
onArrageOverride = size => { arrangeOverridedHasBeenCalled = true; return base.ArrangeOverride(size); };
// check with the parent
PertubArrangeResultValues();
ArrangeAndPerformsCollapsedStateTests(true);
// check with current element collapsed
Visibility = Visibility.Collapsed;
PertubArrangeResultValues();
ArrangeAndPerformsCollapsedStateTests(false);
}
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));
}
