public void VerifyClearingItemsSourceClearsElements()
{
var data = new ObservableCollection <string>(Enumerable.Range(0, 4).Select(i => "Item #" + i));
var mapping = (List <ContentControl>)null;
RunOnUIThread.Execute(() =>
{
mapping = Enumerable.Range(0, data.Count).Select(i => new ContentControl {
Width = 40, Height = 40
}).ToList();
var dataSource = MockItemsSource.CreateDataSource(data, supportsUniqueIds: false);
var elementFactory = MockElementFactory.CreateElementFactory(mapping);
ItemsRepeater repeater = new ItemsRepeater();
repeater.ItemsSource = dataSource;
repeater.ItemTemplate = elementFactory;
// This was an issue only for NonVirtualizing layouts
repeater.Layout = new MyCustomNonVirtualizingStackLayout();
Content = repeater;
Content.UpdateLayout();
repeater.ItemsSource = null;
});
foreach (var item in mapping)
{
Verify.IsNull(item.Parent);
}
}
public void ValidateChildrenPeers()
{
RunOnUIThread.Execute(() =>
{
var data = new ObservableCollection <string>(Enumerable.Range(0, 3).Select(i => string.Format("Item #{0}", i)));
var dataSource = MockItemsSource.CreateDataSource(data, supportsUniqueIds: false);
// StackPanel doesn't have an automation peer, but we still need
// to report its children's peer.
var group = new StackPanel();
group.Children.Add(new ListViewItem());
group.Children.Add(new ListViewItem());
var mapping = new Dictionary <int, UIElement>
{
{ 0, new ListViewItem() },
{ 1, new ListViewItem() },
{ 2, group },
};
var elementFactory = MockElementFactory.CreateElementFactory(mapping);
var layout = new MockVirtualizingLayout
{
MeasureLayoutFunc = (availableSize, context) =>
{
var ctx = (VirtualizingLayoutContext)context;
// Realize elements 0, 1, 2 in a random order.
ctx.GetOrCreateElementAt(2);
ctx.GetOrCreateElementAt(0);
var element1 = ctx.GetOrCreateElementAt(1);
// Clear element 1 because we will be validating
// that we ignore unrealized elements.
ctx.RecycleElement(element1);
return(default(Size));
}
};
var repeater = CreateRepeater(dataSource, elementFactory, layout);
Content = repeater;
repeater.UpdateLayout();
var peer = FrameworkElementAutomationPeer.CreatePeerForElement(repeater);
var children = peer.GetChildren().Select(p => ((FrameworkElementAutomationPeer)p).Owner).ToList();
Verify.AreEqual(3, children.Count);
Verify.AreEqual(mapping[0], children[0]);
Verify.AreEqual(group.Children[0], children[1]);
Verify.AreEqual(group.Children[1], children[2]);
});
}
public void CanQueryElementFactory()
{
RunOnUIThread.Execute(() =>
{
var data = new ObservableCollection <string>();
var dataSource = MockItemsSource.CreateDataSource(data, supportsUniqueIds: false);
var elementFactory = MockElementFactory.CreateElementFactory(new List <UIElement> {
new ContentControl()
});
var repeater = CreateRepeater(dataSource, elementFactory);
Content = repeater;
repeater.UpdateLayout();
// Our layout will query the size though once for every layout pass.
// The first layout pass is a bit special because we don't have a viewport and
// we will invalidate measure when we get one after the first arrange pass.
dataSource.ValidateGetSizeCalls(1); // GetSize calls are cached by ItemsSourceView.
elementFactory.ValidateRecycleElementCalls();
data.Add("Item #1");
repeater.UpdateLayout();
var item1 = (UIElement)VisualTreeHelper.GetChild(repeater, 0);
// One GetSize invocation from the layout, another one from the view manager.
dataSource.ValidateGetSizeCalls(1 /* No invocation from the view manager on WPF */); // GetSize calls are cached by ItemsSourceView
dataSource.ValidateGetAtCalls(new MockItemsSource.GetAtCallInfo(0));
elementFactory.ValidateGetElementCalls(new MockElementFactory.GetElementCallInfo(0, repeater));
elementFactory.ValidateRecycleElementCalls();
Verify.AreEqual(item1, repeater.TryGetElement(0));
data.RemoveAt(0);
repeater.UpdateLayout();
dataSource.ValidateGetAtCalls();
dataSource.ValidateGetSizeCalls(1); // GetSize calls are cached by ItemsSourceView
// Whenever we get an element from the view generator, we call HasKeyIndexMapping to see if we should
// store its unique id or not.
dataSource.ValidateGetItemIdCalls();
elementFactory.ValidateGetElementCalls();
elementFactory.ValidateRecycleElementCalls(new MockElementFactory.RecycleElementCallInfo(item1, repeater));
});
}
// Why does this test work?
// When the elements get created from the RecyclingElementFactory, we get already "existing" data templates.
// However, the reason for the crash in #2384 is that those "empty" data templates actually still had their data context
// If that data context is not null, that means it did not get cleared when the element was recycled, which is the wrong behavior.
// To check if the clearing is working correctly, we are checking this inside the ElementFactory's RecycleElement function.
public void ValidateElementClearingClearsDataContext()
{
ItemsRepeater repeater = null;
MockElementFactory elementFactory = null;
int elementClearingRaisedCount = 0;
Log.Comment("Initialize ItemsRepeater");
RunOnUIThread.Execute(() =>
{
elementFactory = new MockElementFactory()
{
GetElementFunc = delegate(int index, UIElement owner) {
return(new Button()
{
Content = index
});
},
ClearElementFunc = delegate(UIElement element, UIElement owner) {
elementClearingRaisedCount++;
Verify.IsNull((element as FrameworkElement).DataContext);
}
};
repeater = CreateRepeater(Enumerable.Range(0, 100),
elementFactory);
repeater.Layout = new StackLayout();
Content = repeater;
repeater.UpdateLayout();
repeater.ItemsSource = null;
Log.Comment("Verify ItemsRepeater cleared data contexts correctly");
Verify.IsTrue(elementClearingRaisedCount > 0, "ItemsRepeater should have cleared some elements");
});
}
// [TestMethod] Issue #1018
public void CanPinFocusedElements()
{
// Setup a grouped repeater scenario with two groups each containing two items.
var data = new ObservableCollection <ObservableCollection <string> >(Enumerable
.Range(0, 2)
.Select(i => new ObservableCollection <string>(Enumerable
.Range(0, 2)
.Select(j => string.Format("Item #{0}.{1}", i, j)))));
List <ContentControl>[] itemElements = null;
ItemsRepeater[] innerRepeaters = null;
List <StackPanel> groupElements = null;
ItemsRepeater rootRepeater = null;
var gotFocus = new ManualResetEvent(false);
RunOnUIThread.Execute(() =>
{
itemElements = new[] {
Enumerable.Range(0, 2).Select(i => new ContentControl()).ToList(),
Enumerable.Range(0, 2).Select(i => new ContentControl()).ToList()
};
itemElements[0][0].GotFocus += delegate { gotFocus.Set(); };
innerRepeaters = Enumerable.Range(0, 2).Select(i => CreateRepeater(
MockItemsSource.CreateDataSource(data[i], supportsUniqueIds: false),
MockElementFactory.CreateElementFactory(itemElements[i]))).ToArray();
groupElements = Enumerable.Range(0, 2).Select(i =>
{
var panel = new StackPanel();
panel.Children.Add(new ContentControl());
panel.Children.Add(innerRepeaters[i]);
return(panel);
}).ToList();
rootRepeater = CreateRepeater(
MockItemsSource.CreateDataSource(data, supportsUniqueIds: false),
MockElementFactory.CreateElementFactory(groupElements));
Content = rootRepeater;
rootRepeater.UpdateLayout();
itemElements[0][0].Focus();
});
Verify.IsTrue(gotFocus.WaitOne(DefaultWaitTimeInMS), "Waiting for focus event on the first element of the first group.");
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
Log.Comment("Recycle focused element 0.0 and validate it's still realized because it is pinned.");
{
var ctx = (VirtualizingLayoutContext)innerRepeaters[0].Tag;
ctx.RecycleElement(itemElements[0][0]);
Verify.AreEqual(0, innerRepeaters[0].GetElementIndex(itemElements[0][0]));
}
Log.Comment("Recycle element 0.1 and validate it's no longer realized because it is not pinned.");
{
var ctx = (VirtualizingLayoutContext)innerRepeaters[0].Tag;
ctx.RecycleElement(itemElements[0][1]);
Verify.AreEqual(-1, innerRepeaters[0].GetElementIndex(itemElements[0][1]));
}
Log.Comment("Recycle group 0 and validate it's still realized because one of its items is pinned.");
{
var ctx = (VirtualizingLayoutContext)rootRepeater.Tag;
ctx.RecycleElement(groupElements[0]);
Verify.AreEqual(0, rootRepeater.GetElementIndex(groupElements[0]));
}
itemElements[1][1].GotFocus += delegate { gotFocus.Set(); };
itemElements[1][1].Focus();
});
Verify.IsTrue(gotFocus.WaitOne(DefaultWaitTimeInMS), "Waiting for focus event on the second element of the second group.");
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
Log.Comment(@"Move focus to item 1.1 and validate item 0.0 and group 0 are recycled because
the only thing keeping them around is the fact that item 0.0 was focus pinned");
{
((VirtualizingLayoutContext)rootRepeater.Tag).RecycleElement(groupElements[0]);
((VirtualizingLayoutContext)innerRepeaters[0].Tag).RecycleElement(itemElements[0][0]);
Verify.AreEqual(-1, rootRepeater.GetElementIndex(groupElements[0]));
Verify.AreEqual(-1, innerRepeaters[0].GetElementIndex(itemElements[0][0]));
Verify.AreEqual(1, innerRepeaters[0].GetElementIndex(itemElements[1][1]));
}
Log.Comment(@"Delete item 1.1 from the data. This will force the element to get recycled even if it's pinned.");
{
data[1].RemoveAt(1);
rootRepeater.UpdateLayout();
Verify.AreEqual(-1, innerRepeaters[1].GetElementIndex(itemElements[1][1]));
}
});
}
// [TestMethod] Issue 1018
public void CanReuseElementsDuringUniqueIdReset()
{
var data = new WinRTCollection(Enumerable.Range(0, 2).Select(i => string.Format("Item #{0}", i)));
List <UIElement> mapping = null;
ItemsRepeater repeater = null;
MockElementFactory elementFactory = null;
ContentControl focusedElement = null;
RunOnUIThread.Execute(() =>
{
mapping = new List <UIElement> {
new ContentControl(), new ContentControl()
};
repeater = CreateRepeater(
MockItemsSource.CreateDataSource(data, supportsUniqueIds: true),
MockElementFactory.CreateElementFactory(mapping));
elementFactory = (MockElementFactory)repeater.ItemTemplate;
Content = repeater;
repeater.UpdateLayout();
focusedElement = (ContentControl)repeater.TryGetElement(1);
focusedElement.Focus();
});
IdleSynchronizer.Wait();
RunOnUIThread.Execute(() =>
{
elementFactory.ValidateGetElementCalls(
new MockElementFactory.GetElementCallInfo(0, repeater),
new MockElementFactory.GetElementCallInfo(1, repeater));
elementFactory.ValidateRecycleElementCalls();
data.ResetWith(new[] { data[0], "New item" });
Verify.AreEqual(0, repeater.GetElementIndex(mapping[0]));
Verify.AreEqual(1, repeater.GetElementIndex(mapping[1]));
Verify.IsNull(repeater.TryGetElement(0));
Verify.IsNull(repeater.TryGetElement(1));
elementFactory.ValidateGetElementCalls(/* GetElement should not be called */);
elementFactory.ValidateRecycleElementCalls(/* RecycleElement should not be called */);
mapping[1] = new ContentControl(); // For "New Item"
repeater.UpdateLayout();
Verify.AreEqual(0, repeater.GetElementIndex(mapping[0]));
Verify.AreEqual(1, repeater.GetElementIndex(mapping[1]));
Verify.AreEqual(mapping[0], repeater.TryGetElement(0));
Verify.AreEqual(mapping[1], repeater.TryGetElement(1));
elementFactory.ValidateGetElementCalls(
new MockElementFactory.GetElementCallInfo(1, repeater));
elementFactory.ValidateRecycleElementCalls(
new MockElementFactory.RecycleElementCallInfo(focusedElement, repeater));
// If the focused element survived the reset, we will keep focus on it. If not, we
// try to find one based on the index. In this case, the focused element (index 1)
// got recycled, and we still have index 1 after the stable reset, so the new index 1
// will get focused. Note that recycling the elements to view generator in the case of
// stable reset happens during the arrange, so by that time we will have pulled elements
// from the stable reset pool and maybe created some new elements as well.
int index = repeater.GetElementIndex(focusedElement);
Log.Comment("focused index " + index);
Verify.AreEqual(mapping[1], Keyboard.FocusedElement);
});
}
private void RunElementTrackingTestRoutine(Action <
ObservableCollection <ObservableCollection <string> > /* data */,
TestScrollingSurface[] /* scrollers */,
ItemsRepeater /* rootRepeater */> testRoutine)
{
// Base setup for our element tracking tests.
// We have 4 fake scrollers in series, initially in a non scrollable configuration.
// Under them we have a group repeater tree (2 groups with 3 items each).
// The group UI is a StackPanel with a TextBlock "header" and an inner ItemsRepeater.
RunOnUIThread.Execute(() =>
{
int groupCount = 2;
int itemsPerGroup = 3;
var data = new ObservableCollection <ObservableCollection <string> >(
Enumerable.Range(0, groupCount).Select(i => new ObservableCollection <string>(
Enumerable.Range(0, itemsPerGroup).Select(j => string.Format("Item #{0}.{1}", i, j)))));
var itemElements = Enumerable.Range(0, groupCount).Select(i =>
Enumerable.Range(0, itemsPerGroup).Select(j => new Border {
Tag = data[i][j], Width = 50, Height = 50, Background = new SolidColorBrush(Colors.Red)
}).ToList()).ToArray();
var headerElements = Enumerable.Range(0, groupCount).Select(i => new TextBlock {
Text = "Header #" + i
}).ToList();
var groupRepeaters = Enumerable.Range(0, groupCount).Select(i => new ItemsRepeater
{
Tag = "ItemsRepeater #" + i,
ItemsSource = data[i],
ItemTemplate = MockElementFactory.CreateElementFactory(itemElements[i]),
Layout = new TestGridLayout {
Orientation = Orientation.Horizontal, MinItemWidth = 50, MinItemHeight = 50, MinRowSpacing = 10, MinColumnSpacing = 10
}
}).ToList();
var groupElement = Enumerable.Range(0, groupCount).Select(i =>
{
var panel = new StackPanel();
panel.Tag = "Group #" + i;
panel.Children.Add(headerElements[i]);
panel.Children.Add(groupRepeaters[i]);
return(panel);
}).ToList();
var rootRepeater = new ItemsRepeater
{
Tag = "Root ItemsRepeater",
ItemsSource = data,
ItemTemplate = MockElementFactory.CreateElementFactory(groupElement),
Layout = new TestStackLayout {
Orientation = Orientation.Vertical
}
};
var scrollers = new TestScrollingSurface[4];
for (int i = 0; i < scrollers.Length; ++i)
{
scrollers[i] = new TestScrollingSurface()
{
Tag = "S" + i,
Content = i > 0 ? (UIElement)scrollers[i - 1] : rootRepeater
};
}
var resetScrollers = (Action)(() =>
{
foreach (var scroller in scrollers)
{
scroller.IsHorizontallyScrollable = false;
scroller.IsVerticallyScrollable = false;
scroller.RegisterAnchorCandidateFunc = null;
scroller.UnregisterAnchorCandidateFunc = null;
scroller.GetRelativeViewportFunc = null;
}
});
var outerScroller = scrollers.Last();
outerScroller.Width = 200.0;
outerScroller.Height = 2000.0;
Content = outerScroller;
Content.UpdateLayout();
testRoutine(data, scrollers, rootRepeater);
});
}
