public void AnchoringAtRepeaterMiddle()
{
using (ScrollerTestHooksHelper scrollerTestHooksHelper = new ScrollerTestHooksHelper())
{
using (PrivateLoggingHelper privateLoggingHelper = new PrivateLoggingHelper("Scroller"))
{
Scroller scroller = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollerViewChangedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
scroller = new Scroller();
SetupRepeaterAnchoringUI(scroller, scrollerLoadedEvent);
scroller.HorizontalAnchorRatio = double.NaN;
scroller.VerticalAnchorRatio = 0.5;
});
WaitForEvent("Waiting for Loaded event", scrollerLoadedEvent);
ChangeZoomFactor(scroller, 2.0f, 0.0f, 0.0f, ScrollerViewKind.Absolute, ScrollerViewChangeKind.AllowAnimation);
ChangeOffsets(scroller, 0.0, 250.0, ScrollerViewKind.Absolute, ScrollerViewChangeKind.AllowAnimation, ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints, false /*hookViewChanged*/);
ItemsRepeater repeater = null;
TestDataSource dataSource = null;
RunOnUIThread.Execute(() =>
{
repeater = (scroller.Content as Border).Child as ItemsRepeater;
dataSource = repeater.ItemsSource as TestDataSource;
scroller.ViewChanged += delegate(Scroller sender, object args) {
scrollerViewChangedEvent.Set();
};
Log.Comment("Inserting items at the beginning");
dataSource.Insert(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for Scroller.ViewChanged event", scrollerViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroller offset change expected");
Verify.AreEqual(scroller.VerticalOffset, 520.0);
});
RunOnUIThread.Execute(() =>
{
scrollerViewChangedEvent.Reset();
Log.Comment("Removing items from the beginning");
dataSource.Remove(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for Scroller.ViewChanged event", scrollerViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroller offset change expected");
Verify.AreEqual(scroller.VerticalOffset, 250.0);
});
}
}
}
private void OnScrollerViewChanged(Scroller sender, object args)
{
}
public void ChangeOffsetsWithAdditionalVelocityAndAttachedScrollControllers()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
CompositionScrollController horizontalScrollController = null;
CompositionScrollController verticalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollCompletedEvent = new AutoResetEvent(false);
int hOffsetChangeId = -1;
int vOffsetChangeId = -1;
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
horizontalScrollController = new CompositionScrollController();
verticalScrollController = new CompositionScrollController();
horizontalScrollController.Orientation = Orientation.Horizontal;
horizontalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
verticalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = horizontalScrollController;
scroller.VerticalScrollController = verticalScrollController;
SetupUIWithScrollControllers(
scroller,
rectangleScrollerContent,
horizontalScrollController,
verticalScrollController,
loadedEvent);
horizontalScrollController.OffsetChangeCompleted += (CompositionScrollController sender, CompositionScrollControllerOffsetChangeCompletedEventArgs args) =>
{
Log.Comment("ChangeOffset completed. OffsetChangeId=" + args.OffsetChangeId);
Log.Comment("Setting completion event");
scrollCompletedEvent.Set();
};
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("HorizontalScrollController size={0}, {1}", horizontalScrollController.ActualWidth, horizontalScrollController.ActualHeight);
Log.Comment("VerticalScrollController size={0}, {1}", verticalScrollController.ActualWidth, verticalScrollController.ActualHeight);
});
Log.Comment("Jump to zoomFactor 0.75");
ZoomTo(
scroller,
0.75f,
0.0f,
0.0f,
AnimationMode.Disabled,
SnapPointsMode.Ignore);
RunOnUIThread.Execute(() =>
{
Log.Comment("Adding velocity to horizontal offset, with default inertia decay rate");
hOffsetChangeId = horizontalScrollController.ScrollFrom(
100.0f /*offsetVelocity*/, null /*inertiaDecayRate*/);
Log.Comment("Adding velocity to vertical offset, with default inertia decay rate");
vOffsetChangeId = verticalScrollController.ScrollFrom(
100.0f /*offsetVelocity*/, null /*inertiaDecayRate*/);
Verify.AreEqual(hOffsetChangeId, vOffsetChangeId);
});
WaitForEvent("Waiting for operation completion", scrollCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.IsTrue(scroller.HorizontalOffset > 20.0);
Verify.IsTrue(scroller.VerticalOffset > 20.0);
Log.Comment("Adding negative velocity to horizontal offset, with custom inertia decay rate");
hOffsetChangeId = horizontalScrollController.ScrollFrom(
-50.0f /*offsetVelocity*/, 0.9f /*inertiaDecayRate*/);
Log.Comment("Adding negative velocity to vertical offset, with custom inertia decay rate");
vOffsetChangeId = verticalScrollController.ScrollFrom(
-50.0f /*offsetVelocity*/, 0.9f /*inertiaDecayRate*/);
Verify.AreEqual(hOffsetChangeId, vOffsetChangeId);
scrollCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", scrollCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.IsTrue(scroller.HorizontalOffset < 20.0);
Verify.IsTrue(scroller.VerticalOffset < 20.0);
Log.Comment("Adding velocity to horizontal offset, with no inertia decay rate");
hOffsetChangeId = horizontalScrollController.ScrollFrom(
200.0f /*offsetVelocity*/, 0.0f /*inertiaDecayRate*/);
Log.Comment("Adding velocity to vertical offset, with no inertia decay rate");
vOffsetChangeId = verticalScrollController.ScrollFrom(
200.0f /*offsetVelocity*/, 0.0f /*inertiaDecayRate*/);
Verify.AreEqual(hOffsetChangeId, vOffsetChangeId);
scrollCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", scrollCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.AreEqual(scroller.HorizontalOffset, 600.0);
Verify.AreEqual(scroller.VerticalOffset, 250.0);
});
}
public void ValidateTwoScrollersScenario()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone5))
{
Log.Warning("Skipping since version is less than RS5 and effective viewport feature is not available below RS5");
return;
}
var realizationRects = new List <Rect>();
Scroller horizontalScroller = null;
Scroller verticalScroller = null;
var horizontalScrollCompletedEvent = new AutoResetEvent(false);
var verticalScrollCompletedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
var repeater = new ItemsRepeater()
{
Layout = GetMonitoringLayout(new Size(500, 500), realizationRects),
HorizontalCacheLength = 0.0,
VerticalCacheLength = 0.0
};
horizontalScroller = new Scroller
{
Content = repeater,
ContentOrientation = ContentOrientation.Horizontal
};
// Placing a Grid in between two Scroller controls to avoid
// unsupported combined use of facades and ElementCompositionPreview.
var grid = new Grid();
grid.Children.Add(horizontalScroller);
verticalScroller = new Scroller
{
Content = grid,
Width = 200,
Height = 200,
ContentOrientation = ContentOrientation.Vertical
};
Content = verticalScroller;
Content.UpdateLayout();
Verify.AreEqual(2, realizationRects.Count);
Verify.AreEqual(new Rect(0, 0, 0, 0), realizationRects[0]);
Verify.AreEqual(new Rect(0, 0, 200, 200), realizationRects[1]);
realizationRects.Clear();
horizontalScroller.ScrollCompleted += (Scroller sender, ScrollCompletedEventArgs args) =>
{
horizontalScrollCompletedEvent.Set();
};
verticalScroller.ScrollCompleted += (Scroller sender, ScrollCompletedEventArgs args) =>
{
verticalScrollCompletedEvent.Set();
};
});
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
verticalScroller.ScrollTo(0.0, 100.0, new ScrollOptions(AnimationMode.Disabled, SnapPointsMode.Ignore));
});
Verify.IsTrue(verticalScrollCompletedEvent.WaitOne(DefaultWaitTimeInMS));
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(new Rect(0, 100, 200, 200), realizationRects.Last());
realizationRects.Clear();
// Max viewport offset is (300, 300). Horizontal viewport offset
// is expected to get coerced from 400 to 300.
horizontalScroller.ScrollTo(400.0, 100.0, new ScrollOptions(AnimationMode.Disabled, SnapPointsMode.Ignore));
});
Verify.IsTrue(horizontalScrollCompletedEvent.WaitOne(DefaultWaitTimeInMS));
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(new Rect(300, 100, 200, 200), realizationRects.Last());
realizationRects.Clear();
});
}
public void CanBringIntoViewElements()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone5))
{
// Note that UIElement.BringIntoViewRequested was added in RS4, and effective viewport was added in RS5
Log.Warning("Skipping since version is less than RS5 and effective viewport feature is not available below RS5");
return;
}
Scroller scroller = null;
ItemsRepeater repeater = null;
var rootLoadedEvent = new AutoResetEvent(initialState: false);
var viewChangedEvent = new AutoResetEvent(initialState: false);
var waitingForIndex = -1;
var indexRealized = new AutoResetEvent(initialState: false);
var viewChangedOffsets = new List <double>();
RunOnUIThread.Execute(() =>
{
var lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam laoreet erat vel massa rutrum, eget mollis massa vulputate. Vivamus semper augue leo, eget faucibus nulla mattis nec. Donec scelerisque lacus at dui ultricies, eget auctor ipsum placerat. Integer aliquet libero sed nisi eleifend, nec rutrum arcu lacinia. Sed a sem et ante gravida congue sit amet ut augue. Donec quis pellentesque urna, non finibus metus. Proin sed ornare tellus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam laoreet erat vel massa rutrum, eget mollis massa vulputate. Vivamus semper augue leo, eget faucibus nulla mattis nec. Donec scelerisque lacus at dui ultricies, eget auctor ipsum placerat. Integer aliquet libero sed nisi eleifend, nec rutrum arcu lacinia. Sed a sem et ante gravida congue sit amet ut augue. Donec quis pellentesque urna, non finibus metus. Proin sed ornare tellus.";
var root = (Grid)XamlReader.Load(TestUtilities.ProcessTestXamlForRepo(
@"<Grid xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
xmlns:controls='using:Microsoft.UI.Xaml.Controls'
xmlns:primitives='using:Microsoft.UI.Xaml.Controls.Primitives'>
<Grid.Resources>
<controls:StackLayout x:Name='VerticalStackLayout' />
<controls:RecyclingElementFactory x:Key='ElementFactory'>
<controls:RecyclingElementFactory.RecyclePool>
<controls:RecyclePool />
</controls:RecyclingElementFactory.RecyclePool>
<DataTemplate x:Key='ItemTemplate'>
<Border Background='LightGray' Margin ='5'>
<TextBlock Text='{Binding}' TextWrapping='WrapWholeWords' />
</Border>
</DataTemplate>
</controls:RecyclingElementFactory>
</Grid.Resources>
<primitives:Scroller x:Name='Scroller' Width='400' Height='600' ContentOrientation='Vertical' Background='Gray'>
<controls:ItemsRepeater
x:Name='ItemsRepeater'
ItemTemplate='{StaticResource ElementFactory}'
Layout='{StaticResource VerticalStackLayout}'
HorizontalCacheLength='0'
VerticalCacheLength='0' />
</primitives:Scroller>
</Grid>"));
var elementFactory = (RecyclingElementFactory)root.Resources["ElementFactory"];
scroller = (Scroller)root.FindName("Scroller");
repeater = (ItemsRepeater)root.FindName("ItemsRepeater");
repeater.ElementPrepared += (sender, args) =>
{
if (args.Index == waitingForIndex)
{
indexRealized.Set();
}
};
var items = Enumerable.Range(0, 400).Select(i => string.Format("{0}: {1}", i, lorem.Substring(0, 250)));
repeater.ItemsSource = items;
scroller.ViewChanged += (o, e) =>
{
Log.Comment("Scroller.ViewChanged: VerticalOffset=" + scroller.VerticalOffset);
viewChangedOffsets.Add(scroller.VerticalOffset);
viewChangedEvent.Set();
};
scroller.BringingIntoView += (o, e) =>
{
Log.Comment("Scroller.BringingIntoView:");
Log.Comment("TargetVerticalOffset=" + e.TargetVerticalOffset);
Log.Comment("RequestEventArgs.AnimationDesired=" + e.RequestEventArgs.AnimationDesired);
Log.Comment("RequestEventArgs.Handled=" + e.RequestEventArgs.Handled);
Log.Comment("RequestEventArgs.VerticalAlignmentRatio=" + e.RequestEventArgs.VerticalAlignmentRatio);
Log.Comment("RequestEventArgs.VerticalOffset=" + e.RequestEventArgs.VerticalOffset);
Log.Comment("RequestEventArgs.TargetRect=" + e.RequestEventArgs.TargetRect);
};
scroller.EffectiveViewportChanged += (o, args) =>
{
Log.Comment("Scroller.EffectiveViewportChanged: VerticalOffset=" + scroller.VerticalOffset);
};
root.Loaded += delegate {
rootLoadedEvent.Set();
};
Content = root;
});
Verify.IsTrue(rootLoadedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
waitingForIndex = 101;
indexRealized.Reset();
repeater.GetOrCreateElement(100).StartBringIntoView();
repeater.UpdateLayout();
});
Verify.IsTrue(viewChangedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
Verify.AreEqual(1, viewChangedOffsets.Count);
viewChangedOffsets.Clear();
Verify.IsTrue(indexRealized.WaitOne(DefaultWaitTimeInMS));
ValidateRealizedRange(repeater, 99, 106);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroll into view item 105 (already realized) w/ animation.");
repeater.TryGetElement(105).StartBringIntoView(new BringIntoViewOptions
{
VerticalAlignmentRatio = 0.5,
AnimationDesired = true
});
repeater.UpdateLayout();
});
Verify.IsTrue(viewChangedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
Verify.IsLessThanOrEqual(1, viewChangedOffsets.Count);
viewChangedOffsets.Clear();
ValidateRealizedRange(repeater, 99, 106);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroll item 0 to the top w/ animation and 0.5 vertical alignment.");
waitingForIndex = 1;
indexRealized.Reset();
repeater.GetOrCreateElement(0).StartBringIntoView(new BringIntoViewOptions
{
VerticalAlignmentRatio = 0.5,
AnimationDesired = true
});
});
Verify.IsTrue(viewChangedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
viewChangedOffsets.Clear();
Verify.IsTrue(indexRealized.WaitOne(DefaultWaitTimeInMS));
// Test Reliability fix. If offset is not 0 yet, give
// some more time for the animation to settle down.
double verticalOffset = 0;
RunOnUIThread.Execute(() =>
{
verticalOffset = scroller.VerticalOffset;
});
if (verticalOffset != 0)
{
Verify.IsTrue(viewChangedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
viewChangedOffsets.Clear();
}
ValidateRealizedRange(repeater, 0, 6);
RunOnUIThread.Execute(() =>
{
// You can't align the first group in the middle obviously.
Verify.AreEqual(0, scroller.VerticalOffset);
Log.Comment("Scroll to item 20.");
waitingForIndex = 21;
indexRealized.Reset();
repeater.GetOrCreateElement(20).StartBringIntoView(new BringIntoViewOptions
{
VerticalAlignmentRatio = 0.0
});
repeater.UpdateLayout();
});
Verify.IsTrue(viewChangedEvent.WaitOne(DefaultWaitTimeInMS));
IdleSynchronizer.Wait();
Verify.IsTrue(indexRealized.WaitOne(DefaultWaitTimeInMS));
ValidateRealizedRange(repeater, 19, 26);
}
public void BasicMargin()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping test on RS1.");
return;
}
const double c_Margin = 50.0;
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
SetupDefaultUI(scroller, rectangleScrollerContent, scrollerLoadedEvent);
});
WaitForEvent("Waiting for Loaded event", scrollerLoadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("Adding positive Margin to Scroller.Content");
rectangleScrollerContent.Margin = new Thickness(c_Margin);
});
// Try to jump beyond maximum offsets
ChangeOffsets(
scroller,
c_defaultUIScrollerContentWidth + 2 * c_Margin - c_defaultUIScrollerWidth + 10.0,
c_defaultUIScrollerContentHeight + 2 * c_Margin - c_defaultUIScrollerHeight + 10.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints,
true /*hookViewChanged*/,
c_defaultUIScrollerContentWidth + 2 * c_Margin - c_defaultUIScrollerWidth,
c_defaultUIScrollerContentHeight + 2 * c_Margin - c_defaultUIScrollerHeight);
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
Log.Comment("Adding negative Margin to Scroller.Content");
rectangleScrollerContent.Margin = new Thickness(-c_Margin);
});
// Try to jump beyond maximum offsets
ChangeOffsets(
scroller,
c_defaultUIScrollerContentWidth - 2 * c_Margin - c_defaultUIScrollerWidth + 10.0,
c_defaultUIScrollerContentHeight - 2 * c_Margin - c_defaultUIScrollerHeight + 10.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints,
false /*hookViewChanged*/,
c_defaultUIScrollerContentWidth - 2 * c_Margin - c_defaultUIScrollerWidth,
c_defaultUIScrollerContentHeight - 2 * c_Margin - c_defaultUIScrollerHeight);
}
public List <ExpressionAnimationStatusChange> GetExpressionAnimationStatusChanges(Scroller scroller)
{
if (m_expressionAnimationStatusChanges.ContainsKey(scroller))
{
return(m_expressionAnimationStatusChanges[scroller]);
}
else
{
return(null);
}
}
private void SetupUIWithBiDirectionalScrollController(
Scroller scroller,
Rectangle rectangleScrollerContent,
BiDirectionalScrollController biDirectionalScrollController,
AutoResetEvent loadedEvent)
{
Log.Comment("Setting up UI with Scroller and bi-directional scroll controller" + (rectangleScrollerContent == null ? "" : " and Rectangle"));
LinearGradientBrush twoColorLGB = new LinearGradientBrush()
{
StartPoint = new Point(0, 0), EndPoint = new Point(1, 1)
};
GradientStop brownGS = new GradientStop()
{
Color = Colors.Brown, Offset = 0.0
};
twoColorLGB.GradientStops.Add(brownGS);
GradientStop orangeGS = new GradientStop()
{
Color = Colors.Orange, Offset = 1.0
};
twoColorLGB.GradientStops.Add(orangeGS);
if (rectangleScrollerContent != null)
{
rectangleScrollerContent.Width = c_defaultUIScrollerContentWidth;
rectangleScrollerContent.Height = c_defaultUIScrollerContentHeight;
rectangleScrollerContent.Fill = twoColorLGB;
}
Verify.IsNotNull(scroller);
scroller.Width = c_defaultUIScrollerWidth;
scroller.Height = c_defaultUIScrollerHeight;
if (rectangleScrollerContent != null)
{
scroller.Content = rectangleScrollerContent;
}
biDirectionalScrollController.Width = c_defaultUIScrollerHeight;
biDirectionalScrollController.Height = c_defaultUIScrollerHeight;
StackPanel horizontalStackPanel = new StackPanel();
horizontalStackPanel.Orientation = Orientation.Horizontal;
horizontalStackPanel.Children.Add(scroller);
horizontalStackPanel.Children.Add(biDirectionalScrollController);
if (loadedEvent != null)
{
horizontalStackPanel.Loaded += (object sender, RoutedEventArgs e) =>
{
Log.Comment("Loaded event handler");
loadedEvent.Set();
};
}
Log.Comment("Setting window content");
MUXControlsTestApp.App.TestContentRoot = horizontalStackPanel;
}
private void ScrollerTestHooks_AnchorEvaluated(Scroller sender, ScrollerTestHooksAnchorEvaluatedEventArgs args)
{
string anchorName;
Border newAnchor = null;
if (args.AnchorElement == null)
{
anchorName = "null";
}
else
{
if (args.AnchorElement is FrameworkElement)
{
FrameworkElement anchorElementAsFE = args.AnchorElement as FrameworkElement;
if (string.IsNullOrWhiteSpace(anchorElementAsFE.Name))
{
anchorName = "unnamed-FE";
}
else
{
anchorName = anchorElementAsFE.Name;
}
newAnchor = anchorElementAsFE as Border;
}
else
{
anchorName = "UIE";
}
}
if (newAnchor != currentAnchor)
{
if (currentAnchor != null)
{
currentAnchor.BorderBrush = new SolidColorBrush(Colors.Chartreuse);
}
if (newAnchor != null)
{
newAnchor.BorderBrush = new SolidColorBrush(Colors.Orange);
}
currentAnchor = newAnchor;
}
if (double.IsNaN(args.ViewportAnchorPointHorizontalOffset) && double.IsNaN(args.ViewportAnchorPointVerticalOffset))
{
cnsAnchorPoint.Visibility = Visibility.Collapsed;
}
else
{
cnsAnchorPoint.Visibility = Visibility.Visible;
if (double.IsNaN(args.ViewportAnchorPointHorizontalOffset))
{
rectAnchorPoint.Width = scroller.Width;
Canvas.SetLeft(rectAnchorPoint, 0);
}
else
{
rectAnchorPoint.Width = double.IsNaN(args.ViewportAnchorPointVerticalOffset) ? 2 : 4;
Canvas.SetLeft(rectAnchorPoint, args.ViewportAnchorPointHorizontalOffset * scroller.ZoomFactor - scroller.HorizontalOffset - rectAnchorPoint.Width / 2);
}
if (double.IsNaN(args.ViewportAnchorPointVerticalOffset))
{
rectAnchorPoint.Height = scroller.Height;
Canvas.SetTop(rectAnchorPoint, 0);
}
else
{
rectAnchorPoint.Height = double.IsNaN(args.ViewportAnchorPointHorizontalOffset) ? 2 : 4;
Canvas.SetTop(rectAnchorPoint, args.ViewportAnchorPointVerticalOffset * scroller.ZoomFactor - scroller.VerticalOffset - rectAnchorPoint.Height / 2);
}
}
if (chkLogScrollerAnchorNotifications.IsChecked == true)
{
AppendAsyncEventMessage(" AnchorEvaluated: s:" + sender.Name + ", a:" + anchorName + ", ap:(" + (int)args.ViewportAnchorPointHorizontalOffset + ", " + (int)args.ViewportAnchorPointVerticalOffset + ")");
}
}
public void ChangeOffsetsWithAdditionalVelocityAndAttachedBiDirectionalScrollController()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
BiDirectionalScrollController biDirectionalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
AutoResetEvent viewChangeCompletedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
biDirectionalScrollController = new BiDirectionalScrollController();
biDirectionalScrollController.LogMessage += (BiDirectionalScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = biDirectionalScrollController.HorizontalScrollController;
scroller.VerticalScrollController = biDirectionalScrollController.VerticalScrollController;
SetupUIWithBiDirectionalScrollController(
scroller,
rectangleScrollerContent,
biDirectionalScrollController,
loadedEvent);
biDirectionalScrollController.ViewChangeCompleted += (BiDirectionalScrollController sender, BiDirectionalScrollControllerViewChangeCompletedEventArgs args) =>
{
Log.Comment("ChangeOffsetsWithAdditionalVelocity completed. ViewChangeId=" + args.ViewChangeId + ", Result=" + args.Result);
Log.Comment("Setting completion event");
viewChangeCompletedEvent.Set();
};
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("BiDirectionalScrollController size={0}, {1}", biDirectionalScrollController.ActualWidth, biDirectionalScrollController.ActualHeight);
});
Log.Comment("Jump to zoomFactor 0.75");
ChangeZoomFactor(
scroller,
0.75f,
0.0f,
0.0f,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation);
RunOnUIThread.Execute(() =>
{
Log.Comment("Adding velocity to offsets, with default inertia decay rates");
biDirectionalScrollController.ChangeOffsetsWithAdditionalVelocity(
new ScrollerChangeOffsetsWithAdditionalVelocityOptions(new Vector2(100.0f) /*additionalVelocity*/, null /*inertiaDecayRate*/));
});
WaitForEvent("Waiting for operation completion", viewChangeCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.IsTrue(scroller.HorizontalOffset > 20.0);
Verify.IsTrue(scroller.VerticalOffset > 20.0);
Log.Comment("Adding negative velocity to offsets, with custom inertia decay rates");
biDirectionalScrollController.ChangeOffsetsWithAdditionalVelocity(
new ScrollerChangeOffsetsWithAdditionalVelocityOptions(new Vector2(-50.0f) /*additionalVelocity*/, new Vector2(0.9f) /*inertiaDecayRate*/));
viewChangeCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", viewChangeCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.IsTrue(scroller.HorizontalOffset < 20.0);
Verify.IsTrue(scroller.VerticalOffset < 20.0);
Log.Comment("Adding velocity to offsets, with no inertia decay rates");
biDirectionalScrollController.ChangeOffsetsWithAdditionalVelocity(
new ScrollerChangeOffsetsWithAdditionalVelocityOptions(new Vector2(200.0f) /*additionalVelocity*/, new Vector2(0.0f) /*inertiaDecayRate*/));
viewChangeCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", viewChangeCompletedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("scroller.HorizontalOffset={0}", scroller.HorizontalOffset);
Log.Comment("scroller.VerticalOffset={0}", scroller.VerticalOffset);
Verify.AreEqual(scroller.HorizontalOffset, 600.0);
Verify.AreEqual(scroller.VerticalOffset, 250.0);
});
}
public void ChangeOffsetsWhileScrollControllersAreAttached()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
CompositionScrollController horizontalScrollController = null;
CompositionScrollController verticalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
horizontalScrollController = new CompositionScrollController();
verticalScrollController = new CompositionScrollController();
horizontalScrollController.Orientation = Orientation.Horizontal;
horizontalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
verticalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = horizontalScrollController;
scroller.VerticalScrollController = verticalScrollController;
SetupUIWithScrollControllers(
scroller,
rectangleScrollerContent,
horizontalScrollController,
verticalScrollController,
loadedEvent);
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("HorizontalScrollController size={0}, {1}", horizontalScrollController.ActualWidth, horizontalScrollController.ActualHeight);
Log.Comment("VerticalScrollController size={0}, {1}", verticalScrollController.ActualWidth, verticalScrollController.ActualHeight);
});
IdleSynchronizer.Wait();
Log.Comment("Jump to offsets");
ChangeOffsets(
scroller,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 2.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 2.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints,
true /*hookViewChanged*/,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 2.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 2.0);
Log.Comment("Animate to offsets");
ChangeOffsets(
scroller,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 4.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 4.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.AllowAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints,
false /*hookViewChanged*/,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 4.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 4.0);
Log.Comment("Jump to zoomFactor 2.0");
ChangeZoomFactor(
scroller,
2.0f,
0.0f,
0.0f,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation,
false /*hookViewChanged*/);
Log.Comment("Animate to zoomFactor 1.5");
ChangeZoomFactor(
scroller,
1.5f,
0.0f,
0.0f,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.AllowAnimation,
false /*hookViewChanged*/);
}
public void ChangeOffsetsWithAttachedBiDirectionalScrollController()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
BiDirectionalScrollController biDirectionalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
AutoResetEvent viewChangeCompletedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
biDirectionalScrollController = new BiDirectionalScrollController();
biDirectionalScrollController.LogMessage += (BiDirectionalScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = biDirectionalScrollController.HorizontalScrollController;
scroller.VerticalScrollController = biDirectionalScrollController.VerticalScrollController;
SetupUIWithBiDirectionalScrollController(
scroller,
rectangleScrollerContent,
biDirectionalScrollController,
loadedEvent);
biDirectionalScrollController.ViewChangeCompleted += (BiDirectionalScrollController sender, BiDirectionalScrollControllerViewChangeCompletedEventArgs args) =>
{
Log.Comment("ChangeOffset completed. ViewChangeId=" + args.ViewChangeId + ", Result=" + args.Result);
Log.Comment("Setting completion event");
viewChangeCompletedEvent.Set();
};
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("BiDirectionalScrollController size={0}, {1}", biDirectionalScrollController.ActualWidth, biDirectionalScrollController.ActualHeight);
});
Log.Comment("Jump to zoomFactor 0.75");
ChangeZoomFactor(
scroller,
0.75f,
0.0f,
0.0f,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation);
RunOnUIThread.Execute(() =>
{
Log.Comment("Jumping to offsets");
biDirectionalScrollController.ChangeOffsets(
new ScrollerChangeOffsetsOptions(
(c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 4.0,
(c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 4.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.DisableAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints));
});
WaitForEvent("Waiting for operation completion", viewChangeCompletedEvent);
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(scroller.HorizontalOffset, (c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 4.0);
Verify.AreEqual(scroller.VerticalOffset, (c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 4.0);
Log.Comment("Animating to offsets");
biDirectionalScrollController.ChangeOffsets(
new ScrollerChangeOffsetsOptions(
(c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 2.0,
(c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 2.0,
ScrollerViewKind.Absolute,
ScrollerViewChangeKind.AllowAnimation,
ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints));
viewChangeCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", viewChangeCompletedEvent);
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(scroller.HorizontalOffset, (c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 2.0);
Verify.AreEqual(scroller.VerticalOffset, (c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 2.0);
});
}
private void SetupUIWithScrollControllers(
Scroller scroller,
Rectangle rectangleScrollerContent,
CompositionScrollController horizontalScrollController,
CompositionScrollController verticalScrollController,
AutoResetEvent loadedEvent)
{
Log.Comment("Setting up UI with Scroller and scroll controlllers" + (rectangleScrollerContent == null ? "" : " and Rectangle"));
LinearGradientBrush twoColorLGB = new LinearGradientBrush()
{
StartPoint = new Point(0, 0), EndPoint = new Point(1, 1)
};
GradientStop brownGS = new GradientStop()
{
Color = Colors.Brown, Offset = 0.0
};
twoColorLGB.GradientStops.Add(brownGS);
GradientStop orangeGS = new GradientStop()
{
Color = Colors.Orange, Offset = 1.0
};
twoColorLGB.GradientStops.Add(orangeGS);
if (rectangleScrollerContent != null)
{
rectangleScrollerContent.Width = c_defaultUIScrollerContentWidth;
rectangleScrollerContent.Height = c_defaultUIScrollerContentHeight;
rectangleScrollerContent.Fill = twoColorLGB;
}
Verify.IsNotNull(scroller);
scroller.Width = c_defaultUIScrollerWidth;
scroller.Height = c_defaultUIScrollerHeight;
if (rectangleScrollerContent != null)
{
scroller.Content = rectangleScrollerContent;
}
horizontalScrollController.Width = c_defaultUIScrollerWidth;
horizontalScrollController.HorizontalAlignment = HorizontalAlignment.Left;
StackPanel horizontalStackPanel = new StackPanel();
horizontalStackPanel.Orientation = Orientation.Horizontal;
horizontalStackPanel.Children.Add(scroller);
horizontalStackPanel.Children.Add(verticalScrollController);
StackPanel verticalStackPanel = new StackPanel();
verticalStackPanel.Children.Add(horizontalStackPanel);
verticalStackPanel.Children.Add(horizontalScrollController);
verticalStackPanel.Width = c_defaultUIScrollerWidth + c_defaultUIScrollControllerThickness;
if (loadedEvent != null)
{
verticalStackPanel.Loaded += (object sender, RoutedEventArgs e) =>
{
Log.Comment("Loaded event handler");
loadedEvent.Set();
};
}
Log.Comment("Setting window content");
Content = verticalStackPanel;
}
private void SetupRepeaterAnchoringUI(
Scroller scroller,
AutoResetEvent scrollerLoadedEvent)
{
Log.Comment("Setting up ItemsRepeater anchoring UI with Scroller and ItemsRepeater");
TestDataSource dataSource = new TestDataSource(
Enumerable.Range(0, c_defaultAnchoringUIRepeaterChildrenCount).Select(i => string.Format("Item #{0}", i)).ToList());
RecyclingElementFactory elementFactory = new RecyclingElementFactory();
elementFactory.RecyclePool = new RecyclePool();
elementFactory.Templates["Item"] = XamlReader.Load(
@"<DataTemplate xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>
<Border BorderThickness='3' BorderBrush='Chartreuse' Width='100' Height='100' Margin='3' Background='BlanchedAlmond'>
<TextBlock Text='{Binding}' HorizontalAlignment='Center' VerticalAlignment='Center'/>
</Border>
</DataTemplate>") as DataTemplate;
ItemsRepeater repeater = new ItemsRepeater()
{
Name = "repeater",
ItemsSource = dataSource,
#if BUILD_WINDOWS
ItemTemplate = (Windows.UI.Xaml.IElementFactory)elementFactory,
#else
ItemTemplate = elementFactory,
#endif
Layout = new UniformGridLayout()
{
MinItemWidth = 125,
MinItemHeight = 125,
MinRowSpacing = 10,
MinColumnSpacing = 10
},
Margin = new Thickness(30)
};
Border border = new Border()
{
Name = "border",
BorderThickness = new Thickness(3),
BorderBrush = new SolidColorBrush(Colors.Chartreuse),
Margin = new Thickness(15),
Background = new SolidColorBrush(Colors.Beige),
Child = repeater
};
Verify.IsNotNull(scroller);
scroller.Name = "scroller";
scroller.ContentOrientation = ContentOrientation.Vertical;
scroller.Width = 400;
scroller.Height = 600;
scroller.Background = new SolidColorBrush(Colors.AliceBlue);
scroller.Content = border;
if (scrollerLoadedEvent != null)
{
scroller.Loaded += (object sender, RoutedEventArgs e) =>
{
Log.Comment("Scroller.Loaded event handler");
scrollerLoadedEvent.Set();
};
}
scroller.AnchorRequested += (Scroller sender, ScrollerAnchorRequestedEventArgs args) =>
{
Log.Comment("Scroller.AnchorRequested event handler");
Verify.IsNull(args.AnchorElement);
Verify.IsGreaterThan(args.AnchorCandidates.Count, 0);
};
Log.Comment("Setting window content");
MUXControlsTestApp.App.TestContentRoot = scroller;
}
private void MarkupScroller_StateChanged(Scroller sender, object args)
{
this.txtScrollerState.Text = this.markupScroller.State.ToString();
}
private void Scroller_ExtentChanged(Scroller sender, object args)
{
AppendAsyncEventMessage("ExtentChanged Scroller=" + sender.Name + ", ExtentWidth=" + sender.ExtentWidth.ToString() + ", ExtentHeight=" + sender.ExtentHeight.ToString());
}
public void BasicMarginAndAlignment()
{
if (PlatformConfiguration.IsOsVersionGreaterThan(OSVersion.Redstone4))
{
//BUGBUG Bug 19277312: MUX Scroller tests fail on RS5_Release
return;
}
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
// Skipping this test on pre-RS2 since it uses Visual's Translation property.
return;
}
const float c_smallZoomFactor = 0.15f;
const double c_Margin = 40.0;
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
float horizontalOffset = 0.0f;
float verticalOffset = 0.0f;
float zoomFactor = 1.0f;
Compositor compositor = null;
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
SetupDefaultUI(scroller, rectangleScrollerContent, scrollerLoadedEvent);
Log.Comment("Adding positive Margin to Scroller.Content");
rectangleScrollerContent.Margin = new Thickness(c_Margin);
compositor = Window.Current.Compositor;
});
WaitForEvent("Waiting for Loaded event", scrollerLoadedEvent);
// Jump to absolute small zoomFactor to make the content smaller than the viewport.
ChangeZoomFactor(scroller, c_smallZoomFactor, 0.0f, 0.0f, ScrollerViewKind.Absolute, ScrollerViewChangeKind.DisableAnimation);
RunOnUIThread.Execute(() =>
{
Log.Comment("Covering Stretch/Strech alignments");
Verify.AreEqual(rectangleScrollerContent.HorizontalAlignment, HorizontalAlignment.Stretch);
Verify.AreEqual(rectangleScrollerContent.VerticalAlignment, VerticalAlignment.Stretch);
});
SpyTranslationAndScale(scroller, compositor, out horizontalOffset, out verticalOffset, out zoomFactor);
Verify.IsTrue(Math.Abs(horizontalOffset - 20.0f) < c_defaultOffsetResultTolerance);
Verify.IsTrue(Math.Abs(verticalOffset - 15.0f) < c_defaultOffsetResultTolerance);
Verify.AreEqual(zoomFactor, c_smallZoomFactor);
RunOnUIThread.Execute(() =>
{
Log.Comment("Covering Left/Top alignments");
rectangleScrollerContent.HorizontalAlignment = HorizontalAlignment.Left;
rectangleScrollerContent.VerticalAlignment = VerticalAlignment.Top;
});
SpyTranslationAndScale(scroller, compositor, out horizontalOffset, out verticalOffset, out zoomFactor);
Verify.IsTrue(Math.Abs(horizontalOffset + 34.0f) < c_defaultOffsetResultTolerance);
Verify.IsTrue(Math.Abs(verticalOffset + 34.0f) < c_defaultOffsetResultTolerance);
Verify.AreEqual(zoomFactor, c_smallZoomFactor);
RunOnUIThread.Execute(() =>
{
Log.Comment("Covering Right/Bottom alignments");
rectangleScrollerContent.HorizontalAlignment = HorizontalAlignment.Right;
rectangleScrollerContent.VerticalAlignment = VerticalAlignment.Bottom;
});
SpyTranslationAndScale(scroller, compositor, out horizontalOffset, out verticalOffset, out zoomFactor);
Verify.IsTrue(Math.Abs(horizontalOffset - 74.0f) < c_defaultOffsetResultTolerance);
Verify.IsTrue(Math.Abs(verticalOffset - 64.0f) < c_defaultOffsetResultTolerance);
Verify.AreEqual(zoomFactor, c_smallZoomFactor);
RunOnUIThread.Execute(() =>
{
Log.Comment("Covering Center/Center alignments");
rectangleScrollerContent.HorizontalAlignment = HorizontalAlignment.Center;
rectangleScrollerContent.VerticalAlignment = VerticalAlignment.Center;
});
SpyTranslationAndScale(scroller, compositor, out horizontalOffset, out verticalOffset, out zoomFactor);
Verify.IsTrue(Math.Abs(horizontalOffset - 20.0f) < c_defaultOffsetResultTolerance);
Verify.IsTrue(Math.Abs(verticalOffset - 15.0f) < c_defaultOffsetResultTolerance);
Verify.AreEqual(zoomFactor, c_smallZoomFactor);
}
private void Scroller_StateChanged(Scroller sender, object args)
{
AppendAsyncEventMessage("StateChanged Scroller=" + sender.Name + ", State=" + sender.State.ToString());
}
public void ImageWithConstrainedHeight()
{
if (PlatformConfiguration.IsOsVersionGreaterThan(OSVersion.Redstone4))
{
//BUGBUG Bug 19277312: MUX Scroller tests fail on RS5_Release
return;
}
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
// Skipping this test on pre-RS2 since it uses Visual's Translation property.
return;
}
const float c_smallZoomFactor = 0.5f;
const float c_largeZoomFactor = 2.0f;
const double c_imageWidth = 250.0;
const double c_topMargin = 40.0;
const double c_bottomMargin = 10.0;
Scroller scroller = null;
Image imageScrollerContent = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
Compositor compositor = null;
RunOnUIThread.Execute(() =>
{
imageScrollerContent = new Image();
scroller = new Scroller();
Uri uri = new Uri("ms-appx:/Assets/ingredient3.png");
Verify.IsNotNull(uri);
imageScrollerContent.Source = new BitmapImage(uri);
imageScrollerContent.Margin = new Thickness(0, c_topMargin, 0, c_bottomMargin);
scroller.Content = imageScrollerContent;
scroller.Background = new Media.SolidColorBrush(Colors.Chartreuse);
SetupDefaultUI(scroller, rectangleScrollerContent: null, scrollerLoadedEvent: scrollerLoadedEvent);
// Constraining the Image height and making the Scroller smaller than the Image
imageScrollerContent.Width = c_imageWidth;
scroller.ContentOrientation = ContentOrientation.Horizontal;
compositor = Window.Current.Compositor;
});
WaitForEvent("Waiting for Loaded event", scrollerLoadedEvent);
// Jump to absolute small zoomFactor to make the content smaller than the viewport.
ChangeZoomFactor(scroller, c_smallZoomFactor, 0.0f, 0.0f, ScrollerViewKind.Absolute, ScrollerViewChangeKind.DisableAnimation);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Stretch,
expectedHorizontalOffset: (float)(c_defaultUIScrollerWidth - c_imageWidth * c_smallZoomFactor) / 2.0f, // 87.5
expectedMinPosition: (float)(-c_defaultUIScrollerHeight * c_smallZoomFactor / 2.0), // -50
expectedZoomFactor: c_smallZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Top,
expectedHorizontalOffset: (float)(c_defaultUIScrollerWidth - c_imageWidth * c_smallZoomFactor) / 2.0f, // 87.5
expectedMinPosition: 0.0f,
expectedZoomFactor: c_smallZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Bottom,
expectedHorizontalOffset: (float)(c_defaultUIScrollerWidth - c_imageWidth * c_smallZoomFactor) / 2.0f, // 87.5
expectedMinPosition: (float)(-c_defaultUIScrollerHeight * c_smallZoomFactor), // -100
expectedZoomFactor: c_smallZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Center,
expectedHorizontalOffset: (float)(c_defaultUIScrollerWidth - c_imageWidth * c_smallZoomFactor) / 2.0f, // 87.5
expectedMinPosition: (float)(-c_defaultUIScrollerHeight * c_smallZoomFactor / 2.0), // -50
expectedZoomFactor: c_smallZoomFactor);
// Jump to absolute large zoomFactor to make the content larger than the viewport.
ChangeZoomFactor(scroller, c_largeZoomFactor, 0.0f, 0.0f, ScrollerViewKind.Absolute, ScrollerViewChangeKind.DisableAnimation);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Stretch,
expectedHorizontalOffset: 0.0f,
expectedMinPosition: 0.0f,
expectedZoomFactor: c_largeZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Top,
expectedHorizontalOffset: 0.0f,
expectedMinPosition: 0.0f,
expectedZoomFactor: c_largeZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Bottom,
expectedHorizontalOffset: 0.0f,
expectedMinPosition: 0.0f,
expectedZoomFactor: c_largeZoomFactor);
ValidateContentWithConstrainedHeight(
compositor,
scroller,
content: imageScrollerContent,
verticalAlignment: VerticalAlignment.Center,
expectedHorizontalOffset: 0.0f,
expectedMinPosition: 0.0f,
expectedZoomFactor: c_largeZoomFactor);
}
private void Scroller_ViewChanged(Scroller sender, object args)
{
AppendAsyncEventMessage("ViewChanged Scroller=" + sender.Name + ", H=" + sender.HorizontalOffset.ToString() + ", V=" + sender.VerticalOffset.ToString() + ", ZF=" + sender.ZoomFactor.ToString());
}
private void ScrollerTestHooks_AnchorEvaluated(Scroller sender, ScrollerTestHooksAnchorEvaluatedEventArgs args)
{
string anchorName = (args.AnchorElement is FrameworkElement) ? (args.AnchorElement as FrameworkElement).Name : string.Empty;
Log.Comment(" AnchorEvaluated: s:" + sender.Name + ", a:" + anchorName + ", ap:(" + args.ViewportAnchorPointHorizontalOffset + "," + args.ViewportAnchorPointVerticalOffset + ")");
}
private void Scroller_ScrollCompleted(Scroller sender, ScrollCompletedEventArgs args)
{
ScrollerViewChangeResult result = ScrollerTestHooks.GetScrollCompletedResult(args);
AppendAsyncEventMessage("ScrollCompleted Scroller=" + sender.Name + ", OffsetsChangeId=" + args.ScrollInfo.OffsetsChangeId + ", Result=" + result);
}
public void CanGrowCacheBuffer()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone5))
{
Log.Warning("Skipping since version is less than RS5 and effective viewport feature is not available below RS5");
return;
}
Scroller scroller = null;
ItemsRepeater repeater = null;
var measureRealizationRects = new List <Rect>();
var arrangeRealizationRects = new List <Rect>();
var fullCacheEvent = new ManualResetEvent(initialState: false);
RunOnUIThread.Execute(() =>
{
Log.Comment("Preparing the visual tree...");
scroller = new Scroller
{
Width = 400,
Height = 400
};
var layout = new MockVirtualizingLayout
{
MeasureLayoutFunc = (availableSize, context) =>
{
var ctx = (VirtualizingLayoutContext)context;
measureRealizationRects.Add(ctx.RealizationRect);
return(new Size(1000, 2000));
},
ArrangeLayoutFunc = (finalSize, context) =>
{
var ctx = (VirtualizingLayoutContext)context;
arrangeRealizationRects.Add(ctx.RealizationRect);
if (ctx.RealizationRect.Height == scroller.Height * (repeater.VerticalCacheLength + 1))
{
fullCacheEvent.Set();
}
return(finalSize);
}
};
repeater = new ItemsRepeater()
{
Layout = layout
};
scroller.Content = repeater;
Content = scroller;
});
if (!fullCacheEvent.WaitOne(500000))
{
Verify.Fail("Cache full size never reached.");
}
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
var cacheLength = repeater.VerticalCacheLength;
var expectedRealizationWindow = new Rect(
-cacheLength / 2 * scroller.Width,
-cacheLength / 2 * scroller.Height,
(1 + cacheLength) * scroller.Width,
(1 + cacheLength) * scroller.Height);
Log.Comment("Validate that the realization window reached full size.");
Verify.AreEqual(expectedRealizationWindow, measureRealizationRects.Last());
Log.Comment("Validate that the realization window grew by 40 pixels each time during the process.");
for (int i = 2; i < measureRealizationRects.Count; ++i)
{
Verify.AreEqual(-40, measureRealizationRects[i].X - measureRealizationRects[i - 1].X);
Verify.AreEqual(-40, measureRealizationRects[i].Y - measureRealizationRects[i - 1].Y);
Verify.AreEqual(80, measureRealizationRects[i].Width - measureRealizationRects[i - 1].Width);
Verify.AreEqual(80, measureRealizationRects[i].Height - measureRealizationRects[i - 1].Height);
Verify.AreEqual(-40, arrangeRealizationRects[i].X - arrangeRealizationRects[i - 1].X);
Verify.AreEqual(-40, arrangeRealizationRects[i].Y - arrangeRealizationRects[i - 1].Y);
Verify.AreEqual(80, arrangeRealizationRects[i].Width - arrangeRealizationRects[i - 1].Width);
Verify.AreEqual(80, arrangeRealizationRects[i].Height - arrangeRealizationRects[i - 1].Height);
}
});
}
private void BtnStartBringIntoView_Click(object sender, RoutedEventArgs e)
{
try
{
txtInnerStockOffsetsChangeDuration.Text = string.Empty;
txtOuterStockOffsetsChangeDuration.Text = string.Empty;
FrameworkElement targetElement = null;
ItemsRepeater repeater = null;
switch (cmbNestingCombination.SelectedIndex)
{
case 0: //ScrollerInScroller (1)
repeater = repeater1;
break;
case 2: //ScrollerInScrollViewer
repeater = repeater2;
break;
case 3: //ScrollViewerInScroller
repeater = repeater3;
break;
case 4: //ScrollViewerInScrollViewer
repeater = repeater4;
break;
}
Border border = null;
if (repeater != null)
{
border = repeater.TryGetElement(Convert.ToInt16(txtTargetElement.Text)) as Border;
}
else
{
// case ScrollerInScroller (2)
border = (innerScroller3.Content as StackPanel).Children[Convert.ToInt16(txtTargetElement.Text)] as Border;
}
if (border != null)
{
targetElement = border.Child as FrameworkElement;
if (targetElement != null)
{
BringIntoViewOptions options = new BringIntoViewOptions();
options.AnimationDesired = cmbAnimationDesired.SelectedIndex == 0;
options.HorizontalAlignmentRatio = Convert.ToDouble(txtHorizontalAlignmentRatio.Text);
options.VerticalAlignmentRatio = Convert.ToDouble(txtVerticalAlignmentRatio.Text);
options.HorizontalOffset = Convert.ToDouble(txtHorizontalOffset.Text);
options.VerticalOffset = Convert.ToDouble(txtVerticalOffset.Text);
if (chkIgnoreSnapPoints.IsChecked == false)
{
Scroller scroller1 = null;
Scroller scroller2 = null;
switch (cmbNestingCombination.SelectedIndex)
{
case 0: //ScrollerInScroller (1)
scroller1 = outerScroller;
scroller2 = innerScroller;
break;
case 1: //ScrollerInScroller (2)
scroller1 = outerScroller3;
scroller2 = innerScroller3;
break;
case 2: //ScrollerInScrollViewer
scroller1 = innerScroller2;
break;
case 3: //ScrollViewerInScroller
scroller1 = outerScroller2;
break;
}
if (scroller1 != null)
{
RefreshSnapPoints(scroller1, scroller1.Content as StackPanel);
}
if (scroller2 != null)
{
RefreshSnapPoints(scroller2, scroller2.Content as StackPanel);
}
}
if (chkLogBringIntoViewRequestedEvents.IsChecked == true)
{
AppendAsyncEventMessage("Invoking StartBringIntoView on " + targetElement.Name);
}
targetElement.StartBringIntoView(options);
}
}
if (targetElement == null && chkLogBringIntoViewRequestedEvents.IsChecked == true)
{
AppendAsyncEventMessage("TargetElement not found");
}
}
catch (Exception ex)
{
txtExceptionReport.Text = ex.ToString();
lstScrollerEvents.Items.Add(ex.ToString());
}
}
public void ValidateOneScrollerScenario()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone5))
{
Log.Warning("Skipping since version is less than RS5 and effective viewport feature is not available below RS5");
return;
}
var realizationRects = new List <Rect>();
Scroller scroller = null;
var scrollCompletedEvent = new AutoResetEvent(false);
var zoomCompletedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
var repeater = new ItemsRepeater()
{
Layout = GetMonitoringLayout(new Size(500, 600), realizationRects),
HorizontalCacheLength = 0.0,
VerticalCacheLength = 0.0
};
scroller = new Scroller
{
Content = repeater,
Width = 200,
Height = 300
};
Content = scroller;
Content.UpdateLayout();
Verify.AreEqual(2, realizationRects.Count);
Verify.AreEqual(new Rect(0, 0, 0, 0), realizationRects[0]);
Verify.AreEqual(new Rect(0, 0, 200, 300), realizationRects[1]);
realizationRects.Clear();
scroller.ScrollCompleted += (Scroller sender, ScrollCompletedEventArgs args) =>
{
scrollCompletedEvent.Set();
};
scroller.ZoomCompleted += (Scroller sender, ZoomCompletedEventArgs args) =>
{
zoomCompletedEvent.Set();
};
});
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
scroller.ScrollTo(0.0, 100.0, new ScrollOptions(AnimationMode.Disabled, SnapPointsMode.Ignore));
});
Verify.IsTrue(scrollCompletedEvent.WaitOne(DefaultWaitTimeInMS));
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(new Rect(0, 100, 200, 300), realizationRects.Last());
realizationRects.Clear();
scroller.ZoomTo(2.0f, Vector2.Zero, new ZoomOptions(AnimationMode.Disabled, SnapPointsMode.Ignore));
});
Verify.IsTrue(zoomCompletedEvent.WaitOne(DefaultWaitTimeInMS));
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(
new Rect(0, 100, 100, 150),
realizationRects.Last());
realizationRects.Clear();
});
}
private void RefreshSnapPoints(Scroller scroller, StackPanel stackPanel)
{
if (scroller != null && stackPanel != null && stackPanel.Children.Count > 0)
{
AppendAsyncEventMessage("Populating snap points for " + scroller.Name + ":");
ScrollSnapPoint scrollSnapPoint;
GeneralTransform gt = stackPanel.TransformToVisual(scroller.Content);
Point stackPanelOriginPoint = new Point();
stackPanelOriginPoint = gt.TransformPoint(stackPanelOriginPoint);
if (stackPanel.Orientation == Orientation.Horizontal)
{
scroller.HorizontalSnapPoints.Clear();
scrollSnapPoint = new ScrollSnapPoint(stackPanelOriginPoint.X, ScrollSnapPointsAlignment.Near);
AppendAsyncEventMessage("Adding horizontal snap point to " + scroller.Name + " at value " + stackPanelOriginPoint.X);
scroller.HorizontalSnapPoints.Add(scrollSnapPoint);
}
else
{
scroller.VerticalSnapPoints.Clear();
scrollSnapPoint = new ScrollSnapPoint(stackPanelOriginPoint.Y, ScrollSnapPointsAlignment.Near);
AppendAsyncEventMessage("Adding vertical snap point to " + scroller.Name + " at value " + stackPanelOriginPoint.Y);
scroller.VerticalSnapPoints.Add(scrollSnapPoint);
}
foreach (UIElement child in stackPanel.Children)
{
FrameworkElement childAsFE = child as FrameworkElement;
if (childAsFE != null)
{
gt = childAsFE.TransformToVisual(stackPanel);
Point childOriginPoint = new Point();
childOriginPoint = gt.TransformPoint(childOriginPoint);
double snapPointValue = 0.0;
Thickness margin = childAsFE.Margin;
if (stackPanel.Orientation == Orientation.Horizontal)
{
snapPointValue = margin.Right + childAsFE.ActualWidth + childOriginPoint.X;
if (snapPointValue <= scroller.ScrollableWidth)
{
scrollSnapPoint = new ScrollSnapPoint(snapPointValue, ScrollSnapPointsAlignment.Near);
AppendAsyncEventMessage("Adding horizontal snap point to " + scroller.Name + " at value " + snapPointValue);
scroller.HorizontalSnapPoints.Add(scrollSnapPoint);
}
else
{
break;
}
}
else
{
snapPointValue = margin.Bottom + childAsFE.ActualHeight + childOriginPoint.Y;
if (snapPointValue <= scroller.ScrollableHeight)
{
scrollSnapPoint = new ScrollSnapPoint(snapPointValue, ScrollSnapPointsAlignment.Near);
AppendAsyncEventMessage("Adding vertical snap point to " + scroller.Name + " at value " + snapPointValue);
scroller.VerticalSnapPoints.Add(scrollSnapPoint);
}
else
{
break;
}
}
}
RefreshSnapPoints(scroller, child as StackPanel);
}
}
}
public void ChangeOffsetsWithAttachedScrollControllers()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
CompositionScrollController horizontalScrollController = null;
CompositionScrollController verticalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollCompletedEvent = new AutoResetEvent(false);
int hOffsetChangeId = -1;
int vOffsetChangeId = -1;
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
horizontalScrollController = new CompositionScrollController();
verticalScrollController = new CompositionScrollController();
horizontalScrollController.Orientation = Orientation.Horizontal;
horizontalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
verticalScrollController.LogMessage += (CompositionScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = horizontalScrollController;
scroller.VerticalScrollController = verticalScrollController;
SetupUIWithScrollControllers(
scroller,
rectangleScrollerContent,
horizontalScrollController,
verticalScrollController,
loadedEvent);
horizontalScrollController.OffsetChangeCompleted += (CompositionScrollController sender, CompositionScrollControllerOffsetChangeCompletedEventArgs args) =>
{
Log.Comment("ChangeOffset completed (horizontal). OffsetChangeId=" + args.OffsetChangeId);
Log.Comment("Setting completion event");
scrollCompletedEvent.Set();
};
verticalScrollController.OffsetChangeCompleted += (CompositionScrollController sender, CompositionScrollControllerOffsetChangeCompletedEventArgs args) =>
{
Log.Comment("ChangeOffset completed (vertical). OffsetChangeId=" + args.OffsetChangeId);
};
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("HorizontalScrollController size={0}, {1}", horizontalScrollController.ActualWidth, horizontalScrollController.ActualHeight);
Log.Comment("VerticalScrollController size={0}, {1}", verticalScrollController.ActualWidth, verticalScrollController.ActualHeight);
});
Log.Comment("Jump to zoomFactor 0.75");
ZoomTo(
scroller,
0.75f,
0.0f,
0.0f,
AnimationMode.Disabled,
SnapPointsMode.Ignore);
RunOnUIThread.Execute(() =>
{
Log.Comment("Jumping to horizontal offset");
hOffsetChangeId = horizontalScrollController.ScrollTo(
(c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 4.0,
AnimationMode.Disabled);
Log.Comment("Jumping to vertical offset");
vOffsetChangeId = verticalScrollController.ScrollTo(
(c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 4.0,
AnimationMode.Disabled);
Verify.AreEqual(hOffsetChangeId, vOffsetChangeId);
});
WaitForEvent("Waiting for operation completion", scrollCompletedEvent);
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(scroller.HorizontalOffset, (c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 4.0);
Verify.AreEqual(scroller.VerticalOffset, (c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 4.0);
Log.Comment("Animating to horizontal offset");
hOffsetChangeId = horizontalScrollController.ScrollTo(
(c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 2.0,
AnimationMode.Enabled);
Log.Comment("Animating to vertical offset");
vOffsetChangeId = verticalScrollController.ScrollTo(
(c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 2.0,
AnimationMode.Enabled);
Verify.AreEqual(hOffsetChangeId, vOffsetChangeId);
scrollCompletedEvent.Reset();
});
WaitForEvent("Waiting for operation completion", scrollCompletedEvent);
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(scroller.HorizontalOffset, (c_defaultUIScrollerContentWidth * 0.75 - c_defaultUIScrollerWidth) / 2.0);
Verify.AreEqual(scroller.VerticalOffset, (c_defaultUIScrollerContentHeight * 0.75 - c_defaultUIScrollerHeight) / 2.0);
});
}
private void MarkupScroller_ViewChanged(Scroller sender, object args)
{
this.txtScrollerOffset.Text = this.markupScroller.VerticalOffset.ToString();
this.txtScrollerZoomFactor.Text = this.markupScroller.ZoomFactor.ToString();
}
public void ChangeOffsetsWhileBiDirectionalScrollControllerIsAttached()
{
if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone2))
{
Log.Comment("Skipping failing test on RS1.");
return;
}
Scroller scroller = null;
Rectangle rectangleScrollerContent = null;
BiDirectionalScrollController biDirectionalScrollController = null;
AutoResetEvent loadedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
rectangleScrollerContent = new Rectangle();
scroller = new Scroller();
biDirectionalScrollController = new BiDirectionalScrollController();
biDirectionalScrollController.LogMessage += (BiDirectionalScrollController sender, string args) =>
{
Log.Comment(args);
};
scroller.HorizontalScrollController = biDirectionalScrollController.HorizontalScrollController;
scroller.VerticalScrollController = biDirectionalScrollController.VerticalScrollController;
SetupUIWithBiDirectionalScrollController(
scroller,
rectangleScrollerContent,
biDirectionalScrollController,
loadedEvent);
});
WaitForEvent("Waiting for Loaded event", loadedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("BiDirectionalScrollController size={0}, {1}", biDirectionalScrollController.ActualWidth, biDirectionalScrollController.ActualHeight);
});
IdleSynchronizer.Wait();
Log.Comment("Jump to offsets");
ScrollTo(
scroller,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 2.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 2.0,
AnimationMode.Disabled,
SnapPointsMode.Ignore,
hookViewChanged: true,
isAnimationsEnabledOverride: null,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 2.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 2.0);
Log.Comment("Animate to offsets");
ScrollTo(
scroller,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 4.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 4.0,
AnimationMode.Enabled,
SnapPointsMode.Ignore,
hookViewChanged: false,
isAnimationsEnabledOverride: null,
(c_defaultUIScrollerContentWidth - c_defaultUIScrollerWidth) / 4.0,
(c_defaultUIScrollerContentHeight - c_defaultUIScrollerHeight) / 4.0);
Log.Comment("Jump to zoomFactor 2.0");
ZoomTo(
scroller,
2.0f,
0.0f,
0.0f,
AnimationMode.Disabled,
SnapPointsMode.Ignore,
hookViewChanged: false);
Log.Comment("Animate to zoomFactor 1.5");
ZoomTo(
scroller,
1.5f,
0.0f,
0.0f,
AnimationMode.Enabled,
SnapPointsMode.Ignore,
hookViewChanged: false);
}
private void AnchoringWithOffsetCoercion(bool reduceAnchorOffset)
{
using (ScrollerTestHooksHelper scrollerTestHooksHelper = new ScrollerTestHooksHelper())
{
Scroller scroller = null;
Border anchorElement = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollerViewChangedEvent = new AutoResetEvent(false);
AutoResetEvent scrollerAnchorRequestedEvent = new AutoResetEvent(false);
// This test validates that the Scroller accounts for maximum vertical offset (based on viewport and content extent)
// when calculating the vertical offset shift for anchoring. The vertical offset cannot exceed content extent - viewport.
RunOnUIThread.Execute(() =>
{
Log.Comment("Visual tree setup");
anchorElement = new Border
{
Width = 100,
Height = 100,
Background = new SolidColorBrush(Colors.Red),
Margin = new Thickness(0, 600, 0, 0),
VerticalAlignment = VerticalAlignment.Top
};
Grid grid = new Grid();
grid.Children.Add(anchorElement);
grid.Width = 200;
grid.Height = 1000;
grid.Background = new SolidColorBrush(Colors.Gray);
scroller = new Scroller
{
Content = grid,
Width = 200,
Height = 200
};
scroller.Loaded += (object sender, RoutedEventArgs e) =>
{
Log.Comment("Scroller.Loaded event handler");
scrollerLoadedEvent.Set();
};
scroller.ViewChanged += delegate(Scroller sender, object args)
{
Log.Comment("ViewChanged - HorizontalOffset={0}, VerticalOffset={1}, ZoomFactor={2}",
sender.HorizontalOffset, sender.VerticalOffset, sender.ZoomFactor);
if ((reduceAnchorOffset && sender.VerticalOffset == 400) ||
(!reduceAnchorOffset && sender.VerticalOffset == 500))
{
scrollerViewChangedEvent.Set();
}
};
scroller.AnchorRequested += delegate(Scroller sender, ScrollerAnchorRequestedEventArgs args)
{
Log.Comment("Scroller.AnchorRequested event handler. Forcing the red Border to be the Scroller anchor.");
args.AnchorElement = anchorElement;
scrollerAnchorRequestedEvent.Set();
};
Log.Comment("Setting window content");
MUXControlsTestApp.App.TestContentRoot = scroller;
});
WaitForEvent("Waiting for Scroller.Loaded event", scrollerLoadedEvent);
IdleSynchronizer.Wait();
ChangeOffsets(scroller, 0.0, 600.0, ScrollerViewKind.Absolute, ScrollerViewChangeKind.DisableAnimation, ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints);
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(600, scroller.VerticalOffset);
Log.Comment("Scroller.Content height is reduced by 300px. Scroller.VerticalOffset is expected to be reduced by 100px (600 -> 500).");
(scroller.Content as Grid).Height = 700;
if (reduceAnchorOffset)
{
Log.Comment("Tracked element is shifted up by 200px within the Scroller.Content (600 -> 400). Anchoring is expected to reduce the VerticalOffset by half of that (500 -> 400).");
anchorElement.Margin = new Thickness(0, 400, 0, 0);
}
scrollerViewChangedEvent.Reset();
});
WaitForEvent("Waiting for Scroller.ViewChanged event", scrollerViewChangedEvent);
WaitForEvent("Waiting for Scroller.AnchorRequested event", scrollerAnchorRequestedEvent);
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
Verify.AreEqual(reduceAnchorOffset ? 400 : 500, scroller.VerticalOffset);
});
}
}
