private void UpdateListViewSelection(ListViewBase view, NavMenuItem menuItem)
{
var selectedContainer = view.ContainerFromItem(menuItem) as ListViewItem;
if (selectedContainer != null)
{
selectedContainer.IsTabStop = false;
}
var index = -1;
if (selectedContainer != null)
{
index = view.IndexFromContainer(selectedContainer);
}
for (var i = 0; i < view.Items.Count; i++)
{
var container = view.ContainerFromIndex(i) as ListViewItem;
if (container == null)
{
continue;
}
container.IsSelected = i == index;
}
if (selectedContainer != null)
{
selectedContainer.IsTabStop = true;
}
}
public static async Task SmoothScrollIntoViewAsync(
this ListViewBase listViewBase,
int index,
ItemPosition itemPosition = ItemPosition.Default,
bool disableAnimation = false)
{
bool isVirtualizing = false;
double previousXOffset = default(double);
double previousYOffset = default(double);
ScrollViewer scrollViewer = listViewBase.GetScrollViewer();
var selectorItem = listViewBase.ContainerFromIndex(index) as SelectorItem;
if (selectorItem == null)
{
isVirtualizing = true;
previousXOffset = scrollViewer.HorizontalOffset;
previousYOffset = scrollViewer.VerticalOffset;
var tcs = new TaskCompletionSource <bool>();
void OnViewChanged(object sender, ScrollViewerViewChangedEventArgs args)
{
scrollViewer.ViewChanged -= OnViewChanged;
tcs.SetResult(true);
}
scrollViewer.ViewChanged += OnViewChanged;
listViewBase.ScrollIntoView(listViewBase.Items[index], ScrollIntoViewAlignment.Leading);
await tcs.Task;
selectorItem = (SelectorItem)listViewBase.ContainerFromIndex(index);
}
await ScrollIntoView(listViewBase,
scrollViewer,
selectorItem,
isVirtualizing,
previousXOffset,
previousYOffset,
itemPosition,
disableAnimation);
}
public async static Task ScrollToIndex(this ListViewBase listViewBase, int index)
{
bool isVirtualizing = default(bool);
double previousHorizontalOffset = default(double), previousVerticalOffset = default(double);
// get the ScrollViewer withtin the ListView/GridView
//var scrollViewer = listViewBase.GetScrollViewer();
var scrollViewer = listViewBase.GetChildOfType <ScrollViewer>();
// get the SelectorItem to scroll to
var selectorItem = listViewBase.ContainerFromIndex(index) as SelectorItem;
// when it's null, means virtualization is on and the item hasn't been realized yet
if (selectorItem == null)
{
isVirtualizing = true;
previousHorizontalOffset = scrollViewer.HorizontalOffset;
previousVerticalOffset = scrollViewer.VerticalOffset;
// call task-based ScrollIntoViewAsync to realize the item
await listViewBase.ScrollIntoViewAsync(listViewBase.Items[index]);
// this time the item shouldn't be null again
selectorItem = (SelectorItem)listViewBase.ContainerFromIndex(index);
}
// calculate the position object in order to know how much to scroll to
var transform = selectorItem.TransformToVisual((UIElement)scrollViewer.Content);
var position = transform.TransformPoint(new Point(0, 0));
// when virtualized, scroll back to previous position without animation
if (isVirtualizing)
{
await scrollViewer.ChangeViewAsync(previousHorizontalOffset, previousVerticalOffset, true);
}
// scroll to desired position with animation!
scrollViewer.ChangeView(position.X, position.Y, null);
}
private static bool FocusIndex(ListViewBase listViewBase, int i)
{
var newContainer = listViewBase.ContainerFromIndex(i) as Control;
if (newContainer == null)
{
return(false);
}
newContainer.Focus(FocusState.Keyboard);
listViewBase.ScrollIntoView(newContainer);
return(true);
}
public void LoadVisibleItems(bool intermediate)
{
if (!Services.SettingsService.Current.Stickers.PlayStickers || !Services.SettingsService.Current.Diagnostics.AnimateStickersInPanel)
{
return;
}
if (intermediate && _old.Count < 1)
{
return;
}
int lastVisibleIndex;
int firstVisibleIndex;
if (_listView.ItemsPanelRoot is ItemsStackPanel stack)
{
lastVisibleIndex = stack.LastVisibleIndex;
firstVisibleIndex = stack.FirstVisibleIndex;
}
else if (_listView.ItemsPanelRoot is ItemsWrapGrid wrap)
{
lastVisibleIndex = wrap.LastVisibleIndex;
firstVisibleIndex = wrap.FirstVisibleIndex;
}
else
{
return;
}
if (lastVisibleIndex < firstVisibleIndex || firstVisibleIndex < 0)
{
UnloadVisibleItems();
return;
}
var animations = new List <(SelectorItem, T)>(lastVisibleIndex - firstVisibleIndex);
for (int i = firstVisibleIndex; i <= lastVisibleIndex; i++)
{
var container = _listView.ContainerFromIndex(i) as SelectorItem;
if (container == null)
{
continue;
}
var item = _listView.ItemFromContainer(container);
if (item is StickerViewModel viewModel && viewModel.IsAnimated)
{
animations.Add((container, (T)(object)viewModel));
}
internal static void JumpToIndexAsync(ListViewBase list, int index, ScrollToPosition scrollToPosition)
{
var scrollViewer = list.GetFirstDescendant <ScrollViewer>();
var con = list.ContainerFromIndex(index);
if (con is UIElement uIElement)
{
var width = uIElement.DesiredSize.Width;
var current = scrollViewer.HorizontalOffset;
var delta = (index * width) - current;
scrollViewer.ChangeView(current + delta, scrollViewer.VerticalOffset, scrollViewer.ZoomFactor, true);
}
}
public void LoadVisibleItems(bool intermediate)
{
if (intermediate && _prev.Count < 1)
{
return;
}
int lastVisibleIndex;
int firstVisibleIndex;
if (_listView.ItemsPanelRoot is ItemsStackPanel stack)
{
lastVisibleIndex = stack.LastVisibleIndex;
firstVisibleIndex = stack.FirstVisibleIndex;
}
else if (_listView.ItemsPanelRoot is ItemsWrapGrid wrap)
{
lastVisibleIndex = wrap.LastVisibleIndex;
firstVisibleIndex = wrap.FirstVisibleIndex;
}
else
{
return;
}
if (lastVisibleIndex < firstVisibleIndex || firstVisibleIndex < 0)
{
UnloadVisibleItems();
return;
}
var next = new Dictionary <long, IPlayerView>();
for (int i = firstVisibleIndex; i <= lastVisibleIndex; i++)
{
var container = _listView.ContainerFromIndex(i) as SelectorItem;
if (container == null)
{
continue;
}
File file = null;
var item = _listView.ItemFromContainer(container);
if (item is StickerViewModel viewModel && viewModel.IsAnimated)
{
file = viewModel.StickerValue;
}
public async static Task ScrollToIndex(this ListViewBase listViewBase, int index)
{
bool isVerticalScrolling, isVirtualizing = default(bool);
double previousOffset = default(double);
// if it's a ListView, then we assume the scrolling is vertical
if (listViewBase is ListView)
{
isVerticalScrolling = true;
}
// if it's a GridView, then we assume the scrolling is horizontal
else if (listViewBase is GridView)
{
isVerticalScrolling = false;
}
else
{
throw new ArgumentException("The control needs to inherit from ListViewBase!");
}
// get the ScrollViewer withtin the ListView/GridView
var scrollViewer = listViewBase.GetScrollViewer();
// get the SelectorItem to scroll to
var selectorItem = listViewBase.ContainerFromIndex(index) as SelectorItem;
// when it's null, means virtualization is on and the item hasn't been realized yet
if (selectorItem == null)
{
isVirtualizing = true;
previousOffset = isVerticalScrolling ? scrollViewer.VerticalOffset : scrollViewer.HorizontalOffset;
// call ScrollIntoView to realize the item
listViewBase.ScrollIntoView(listViewBase.Items[index], ScrollIntoViewAlignment.Leading);
await Task.Delay(1);
selectorItem = (SelectorItem)listViewBase.ContainerFromIndex(index);
}
// calculate the position object in order to know how much to scroll to
var transform = selectorItem.TransformToVisual((UIElement)scrollViewer.Content);
var position = transform.TransformPoint(new Point(0, 0));
// when virtualized, scroll backward/forward a little bit (listViewBase.ActualHeight * 2) to allow animation to be at least visible
if (isVirtualizing)
{
if (isVerticalScrolling)
{
scrollViewer.ChangeView(null, position.Y + (position.Y > previousOffset ? -1 : 1) * listViewBase.ActualHeight * 2, null, true);
}
else
{
scrollViewer.ChangeView(position.X + (position.X > previousOffset ? -1 : 1) * listViewBase.ActualWidth * 2, null, null, true);
}
}
// do the scrolling
if (isVerticalScrolling)
{
scrollViewer.ChangeView(null, position.Y, null);
}
else
{
scrollViewer.ChangeView(position.X, null, null);
}
}
/// <summary>
///
/// </summary>
/// <param name="listViewBase"></param>
/// <param name="index"></param>
/// <param name="offset"></param>
/// <returns></returns>
public async static Task ScrollToIndex(this ListViewBase listViewBase, int index, ScrollPosition s)
{
try
{
bool isVirtualizing = default(bool);
double previousHorizontalOffset = default(double), previousVerticalOffset = default(double);
// get the ScrollViewer withtin the ListView/GridView
var scrollViewer = listViewBase.GetScrollViewer();
// get the SelectorItem to scroll to
var selectorItem = listViewBase.ContainerFromIndex(index) as UIElement;
// when it's null, means virtualization is on and the item hasn't been realized yet
if (selectorItem == null)
{
isVirtualizing = true;
previousHorizontalOffset = scrollViewer.HorizontalOffset;
previousVerticalOffset = scrollViewer.VerticalOffset;
// call task-based ScrollIntoViewAsync to realize the item
await listViewBase.ScrollIntoViewAsync(listViewBase.Items[index]);
// this time the item shouldn't be null again
selectorItem = (UIElement)listViewBase.ContainerFromIndex(index);
}
// calculate the position object in order to know how much to scroll to
var transform = selectorItem.TransformToVisual((UIElement)scrollViewer.Content);
// offset : positivie down, negative up
Point position;
switch (s)
{
case ScrollPosition.Top:
position = transform.TransformPoint(new Point(0, 0));
break;
case ScrollPosition.Center:
position = transform.TransformPoint(new Point(0, 0 - (listViewBase.ActualHeight - (selectorItem as ListViewItem).ActualHeight) / 2));
break;
case ScrollPosition.Bottom:
position = transform.TransformPoint(new Point(0, 0 - listViewBase.ActualHeight + (selectorItem as ListViewItem).ActualHeight));
break;
default:
position = transform.TransformPoint(new Point(0, 0));
break;
}
// when virtualized, scroll back to previous position without animation
if (isVirtualizing)
{
await scrollViewer.ChangeViewAsync(previousHorizontalOffset, previousVerticalOffset, true);
}
// scroll to desired position with animation!
scrollViewer.ChangeView(position.X, position.Y, null);
}
catch (Exception)
{
}
}
