SelectionItemsRepeater.cs

SelectionItemsRepeater.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;

using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.Selection;
using Avalonia.Input;
using Avalonia.Interactivity;
using Avalonia.VisualTree;

namespace Controls
{
    public class SelectionItemsRepeater : ItemsRepeater
    {
        public static readonly DirectProperty<SelectionItemsRepeater, ObservableCollection<object?>?> SelectedItemsProperty =
            AvaloniaProperty.RegisterDirect<SelectionItemsRepeater, ObservableCollection<object?>?>(
                nameof(SelectedItems),
                o => o.SelectedItems,
                (o, v) => o.SelectedItems = v);

        private ObservableCollection<object?>? selectedItems;
        private bool ignoreSelectedItemsChanged;

        public SelectionItemsRepeater()
        {
            selectedItems = new ObservableCollection<object?>();
            Selection = new SelectionModel<object?>
            {
                SingleSelect = false
            };
            Selection.SelectionChanged += SelectionModel_SelectionChanged;
            Selection.SourceReset += Selection_SourceReset;
            Selection.LostSelection += Selection_LostSelection;
            ElementPrepared += SelectionItemsRepeater_ElementPrepared;
            ElementIndexChanged += SelectionItemsRepeater_ElementIndexChanged;
            ElementClearing += SelectionItemsRepeater_ElementClearing;
        }

        public SelectionModel<object?> Selection { get; }

        public ObservableCollection<object?>? SelectedItems
        {
            get => selectedItems;
            set => SetAndRaise(SelectedItemsProperty, ref selectedItems, value);
        }

        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
        {
            base.OnPropertyChanged(change);

            if (change.Property == ItemsProperty)
            {
                var newItems = change.NewValue.GetValueOrDefault<IEnumerable>();
                Selection.Source = newItems as IEnumerable<object?> ?? newItems?.OfType<object?>().ToArray();
            }
            else if (change.Property == SelectedItemsProperty
                && !ignoreSelectedItemsChanged)
            {
                ignoreSelectedItemsChanged = true;
                using (Selection.BatchUpdate())
                {
                    if (change.OldValue.GetValueOrDefault<ObservableCollection<object?>>() is { } oldValue)
                    {
                        oldValue.CollectionChanged -= SelectedItems_CollectionChanged;
                        Selection.Clear();
                    }
                    if (change.NewValue.GetValueOrDefault<ObservableCollection<object?>>() is { } newValue)
                    {
                        newValue.CollectionChanged += SelectedItems_CollectionChanged;
                        foreach (var item in newValue)
                        {
                            var index = ItemsSourceView?.IndexOf(item);
                            if (index >= 0)
                            {
                                Selection.Select(index.Value);
                            }
                        }
                    }
                }
                ignoreSelectedItemsChanged = false;
            }
        }

        private void SelectedItems_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            if (ignoreSelectedItemsChanged)
            {
                return;
            }

            ignoreSelectedItemsChanged = true;

            var selectedItems = (ICollection<object>)sender!;
            if (selectedItems.Count == 0)
            {
                Selection.Clear();
            }
            else if (selectedItems.Count == ItemsSourceView?.Count
                && Selection.Source is not null)
            {
                Selection.SelectAll();
            }
            else
            {
                using (Selection.BatchUpdate())
                {
                    if (e.Action == NotifyCollectionChangedAction.Reset)
                    {
                        Selection.DeselectRange(0, Selection.Count);
                        foreach (var item in (IList)sender!)
                        {
                            var index = ItemsSourceView?.IndexOf(item);
                            if (index >= 0 && !Selection.IsSelected(index.Value))
                            {
                                Selection.Select(index.Value);
                            }
                        }
                    }
                    if (e.OldItems != null)
                    {
                        foreach (var item in e.OldItems)
                        {
                            var index = ItemsSourceView?.IndexOf(item);
                            if (index >= 0 && Selection.IsSelected(index.Value))
                            {
                                Selection.Deselect(index.Value);
                            }
                        }
                    }
                    if (e.NewItems != null)
                    {
                        foreach (var item in e.NewItems)
                        {
                            var index = ItemsSourceView?.IndexOf(item);
                            if (index >= 0 && !Selection.IsSelected(index.Value))
                            {
                                Selection.Select(index.Value);
                            }
                        }
                    }
                }
            }
            ignoreSelectedItemsChanged = false;
        }

        private void Selection_LostSelection(object? sender, EventArgs e)
        {
            if (!ignoreSelectedItemsChanged
                && SelectedItems != null)
            {
                ignoreSelectedItemsChanged = true;
                SelectedItems.Clear();
                ignoreSelectedItemsChanged = false;
            }
        }

        private void Selection_SourceReset(object? sender, EventArgs e)
        {
            if (!ignoreSelectedItemsChanged
                && SelectedItems != null)
            {
                ignoreSelectedItemsChanged = true;
                SelectedItems.Clear();
                ignoreSelectedItemsChanged = false;
            }
        }

        private void SelectionModel_SelectionChanged(object? sender, SelectionModelSelectionChangedEventArgs<object?> e)
        {
            if (!ignoreSelectedItemsChanged
                && SelectedItems != null)
            {
                ignoreSelectedItemsChanged = true;
                foreach (var item in e.DeselectedItems)
                {
                    SelectedItems.Remove(item);
                }
                foreach (var item in e.SelectedItems.Except(SelectedItems).Distinct())
                {
                    SelectedItems.Add(item);
                }
                ignoreSelectedItemsChanged = false;
            }

            foreach (var index in e.SelectedIndexes)
            {
                if (TryGetElement(index) is IControl control)
                {
                    control.Classes.Set("selected", true);
                }
            }
            foreach (var index in e.DeselectedIndexes)
            {
                if (TryGetElement(index) is IControl control)
                {
                    control.Classes.Set("selected", false);
                }
            }
        }

        private void SelectionItemsRepeater_ElementClearing(object? sender, ItemsRepeaterElementClearingEventArgs e)
        {
            var element = e.Element;
            UpdateContainerSelection(-1, element);
        }

        private void SelectionItemsRepeater_ElementIndexChanged(object? sender, ItemsRepeaterElementIndexChangedEventArgs e)
        {
            var index = e.NewIndex;
            var element = e.Element;
            UpdateContainerSelection(index, element);
        }

        private void SelectionItemsRepeater_ElementPrepared(object? sender, ItemsRepeaterElementPreparedEventArgs e)
        {
            var index = e.Index;
            var element = e.Element;
            UpdateContainerSelection(index, element);
        }

        private void UpdateContainerSelection(int index, IControl element)
        {
            if (element != null)
            {
                var isSelected = index != -1 && Selection.IsSelected(index);
                element.Classes.Set("selected", isSelected);
            }
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (e.Handled
                || (e.Source is IControl source && GetElementIndex(source) < 0))
            {
                return;
            }

            var focus = FocusManager.Instance!;
            var currentFocus = focus.Current;

            if (e.Key == Key.Space)
            {
                e.Handled = UpdateSelectionFromEventSource(currentFocus, true, false, true);
            }
            else
            {
                var direction = e.Key.ToNavigationDirection();

                if (focus.Current == null
                    || direction == null
                    || !direction.Value.IsDirectional())
                {
                    return;
                }

                var from = currentFocus is IControl control && GetElementIndex(control) > 0 ? control
                    : Selection.SelectedIndex is int index && index != -1 ? GetOrCreateElement(index)
                    : TryGetElement(0);

                if (FindNextElement(direction.Value, from) is IControl next)
                {
                    e.Handled = true;
                    focus.Focus(next, NavigationMethod.Directional, e.KeyModifiers);

                    var multi = (e.KeyModifiers & KeyModifiers.Shift) != 0;
                    var toggle = (e.KeyModifiers & KeyModifiers.Control) != 0;

                    if (!toggle || multi)
                    {
                        _ = UpdateSelectionFromEventSource(next, true, multi, toggle);
                    }

                    next.BringIntoView();
                }
            }

            base.OnKeyUp(e);
        }

        protected override void OnPointerPressed(PointerPressedEventArgs e)
        {
            base.OnPointerPressed(e);

            if (e.Source is IVisual source)
            {
                var point = e.GetCurrentPoint(source);

                if (point.Properties.IsLeftButtonPressed || point.Properties.IsRightButtonPressed)
                {
                    e.Handled = UpdateSelectionFromEventSource(
                        e.Source,
                        true,
                        (e.KeyModifiers & KeyModifiers.Shift) != 0,
                        (e.KeyModifiers & KeyModifiers.Control) != 0,
                        point.Properties.IsRightButtonPressed);
                }
            }
        }

        private (int, bool) lastSingleSelectionIsSelected = (0, false);

        private bool UpdateSelectionFromEventSource(
            IInteractive? eventSource,
            bool select = true,
            bool rangeModifier = false,
            bool toggleModifier = false,
            bool rightButton = false)
        {
            var index = GetContainerIndexFromEventSource(eventSource);

            if (index < 0 || index >= ItemsSourceView?.Count)
            {
                return false;
            }

            var mode = SelectionMode.Multiple;
            var multi = (mode & SelectionMode.Multiple) != 0;
            var toggle = (toggleModifier || (mode & SelectionMode.Toggle) != 0);
            var range = multi && rangeModifier;

            if (!select)
            {
                Selection.Deselect(index);
                lastSingleSelectionIsSelected = (index, false);
            }
            else if (rightButton)
            {
                if (Selection.IsSelected(index) == false)
                {
                    using var operation = Selection.BatchUpdate();
                    Selection.Clear();
                    Selection.Select(index);
                    lastSingleSelectionIsSelected = (index, true);
                }
            }
            else if (range)
            {
                using var operation = Selection.BatchUpdate();
                var (anchorIndex, isSelected) = lastSingleSelectionIsSelected;
                if (anchorIndex < 0)
                {
                    anchorIndex = Selection.AnchorIndex;
                }
                if (!toggle)
                {
                    Selection.Clear();
                    Selection.SelectRange(anchorIndex, index);
                }
                else
                {
                    if (isSelected)
                    {
                        Selection.SelectRange(anchorIndex, index);
                    }
                    else
                    {
                        Selection.DeselectRange(anchorIndex, index);
                    }
                }
            }
            else if (multi && toggle)
            {
                if (Selection.IsSelected(index) == true)
                {
                    Selection.Deselect(index);
                    lastSingleSelectionIsSelected = (index, false);
                }
                else
                {
                    Selection.Select(index);
                    lastSingleSelectionIsSelected = (index, true);
                }
            }
            else
            {
                using var operation = Selection.BatchUpdate();
                Selection.Clear();
                Selection.Select(index);
                lastSingleSelectionIsSelected = (index, true);
            }

            return true;
        }

        protected int GetContainerIndexFromEventSource(IInteractive? eventSource)
        {
            for (var current = eventSource as IVisual; current != null; current = current.VisualParent)
            {
                if (current is IControl control
                    && control.LogicalParent == this
                    && GetElementIndex(control) is var index
                    && index >= 0)
                {
                    return index;
                }
            }

            return -1;
        }

        /// <summary>
        /// Retrieves the element that should receive focus based on the specified navigation direction.
        /// </summary>
        /// <param name="direction">The direction to move in.</param>
        /// <returns>The next element, or null if no element was found.</returns>
        public static IInputElement? FindNextElement(NavigationDirection direction, IInputElement current)
        {
            var container = current.VisualParent;

            if (container is null)
            {
                return null;
            }

            if (container is ICustomKeyboardNavigation custom)
            {
                var (handled, next) = custom.GetNext(current, direction);

                if (handled)
                {
                    return next;
                }
            }

            static IInputElement? GetFirst(IVisual container)
            {
                for (var i = 0; i < container.VisualChildren.Count; ++i)
                {
                    if (container.VisualChildren[i] is IInputElement ie && ie.CanFocus())
                    {
                        return ie;
                    }
                }

                return null;
            }

            static IInputElement? GetLast(IVisual container)
            {
                for (var i = container.VisualChildren.Count - 1; i >= 0; --i)
                {
                    if (container.VisualChildren[i] is IInputElement ie && ie.CanFocus())
                    {
                        return ie;
                    }
                }

                return null;
            }

            return direction switch
            {
                NavigationDirection.Next => TabNavigation.GetNextInTabOrder(current, direction),
                NavigationDirection.Previous => TabNavigation.GetNextInTabOrder(current, direction),
                NavigationDirection.First => GetFirst(container),
                NavigationDirection.Last => GetLast(container),
                NavigationDirection.PageDown => null,
                NavigationDirection.PageUp => null,
                _ => FindInDirection(container, current, direction),
            };
        }

        private static IInputElement? FindInDirection(
            IVisual container,
            IInputElement from,
            NavigationDirection direction)
        {
            static double Distance(NavigationDirection direction, IInputElement from, IInputElement to)
            {
                return direction switch
                {
                    NavigationDirection.Left => from.Bounds.Right - to.Bounds.Right,
                    NavigationDirection.Right => to.Bounds.X - from.Bounds.X,
                    NavigationDirection.Up => from.Bounds.Bottom - to.Bounds.Bottom,
                    NavigationDirection.Down => to.Bounds.Y - from.Bounds.Y,
                    _ => throw new NotSupportedException("direction must be Up, Down, Left or Right"),
                };
            }

            IInputElement? result = null;
            var resultDistance = double.MaxValue;

            foreach (var visual in container.VisualChildren)
            {
                if (visual is IInputElement child && child != from && child.CanFocus())
                {
                    var distance = Distance(direction, from, child);

                    if (distance > 0 && distance < resultDistance)
                    {
                        result = child;
                        resultDistance = distance;
                    }
                }
            }

            return result;
        }

    }

    /// <summary>
    /// The implementation for default tab navigation.
    /// </summary>
    internal static class TabNavigation
    {
        /// <summary>
        /// Gets the next control in the specified tab direction.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="direction">The tab direction. Must be Next or Previous.</param>
        /// <param name="outsideElement">
        /// If true will not descend into <paramref name="element"/> to find next control.
        /// </param>
        /// <returns>
        /// The next element in the specified direction, or null if <paramref name="element"/>
        /// was the last in the requested direction.
        /// </returns>
        public static IInputElement? GetNextInTabOrder(
            IInputElement element,
            NavigationDirection direction,
            bool outsideElement = false)
        {
            element = element ?? throw new ArgumentNullException(nameof(element));

            if (direction != NavigationDirection.Next && direction != NavigationDirection.Previous)
            {
                throw new ArgumentException("Invalid direction: must be Next or Previous.");
            }

            var container = element.GetVisualParent<IInputElement>();

            if (container != null)
            {
                var mode = KeyboardNavigation.GetTabNavigation((InputElement)container);

                return mode switch
                {
                    KeyboardNavigationMode.Continue =>
                        GetNextInContainer(element, container, direction, outsideElement)
                        ?? GetFirstInNextContainer(element, element, direction),
                    KeyboardNavigationMode.Cycle =>
                        GetNextInContainer(element, container, direction, outsideElement)
                        ?? GetFocusableDescendant(container, direction),
                    KeyboardNavigationMode.Contained => GetNextInContainer(element, container, direction, outsideElement),
                    _ => GetFirstInNextContainer(element, container, direction),
                };
            }
            else
            {
                return GetFocusableDescendants(element, direction).FirstOrDefault();
            }
        }

        /// <summary>
        /// Gets the first or last focusable descendant of the specified element.
        /// </summary>
        /// <param name="container">The element.</param>
        /// <param name="direction">The direction to search.</param>
        /// <returns>The element or null if not found.##</returns>
        private static IInputElement? GetFocusableDescendant(IInputElement container, NavigationDirection direction)
        {
            return direction == NavigationDirection.Next ?
                GetFocusableDescendants(container, direction).FirstOrDefault() :
                GetFocusableDescendants(container, direction).LastOrDefault();
        }

        /// <summary>
        /// Gets the focusable descendants of the specified element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="direction">The tab direction. Must be Next or Previous.</param>
        /// <returns>The element's focusable descendants.</returns>
        private static IEnumerable<IInputElement> GetFocusableDescendants(IInputElement element,
            NavigationDirection direction)
        {
            var mode = KeyboardNavigation.GetTabNavigation((InputElement)element);

            if (mode == KeyboardNavigationMode.None)
            {
                yield break;
            }

            var children = element.GetVisualChildren().OfType<IInputElement>();

            if (mode == KeyboardNavigationMode.Once)
            {
                var active = KeyboardNavigation.GetTabOnceActiveElement((InputElement)element);

                if (active != null)
                {
                    yield return active;
                    yield break;
                }
                else
                {
                    children = children.Take(1);
                }
            }

            foreach (var child in children)
            {
                var (handled, next) = GetCustomNext(child, direction);

                if (handled)
                {
                    yield return next!;
                }
                else
                {
                    if (child.CanFocus() && KeyboardNavigation.GetIsTabStop((InputElement)child))
                    {
                        yield return child;
                    }

                    if (child.CanFocusDescendants())
                    {
                        foreach (var descendant in GetFocusableDescendants(child, direction))
                        {
                            if (KeyboardNavigation.GetIsTabStop((InputElement)descendant))
                            {
                                yield return descendant;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets the next item that should be focused in the specified container.
        /// </summary>
        /// <param name="element">The starting element/</param>
        /// <param name="container">The container.</param>
        /// <param name="direction">The direction.</param>
        /// <param name="outsideElement">
        /// If true will not descend into <paramref name="element"/> to find next control.
        /// </param>
        /// <returns>The next element, or null if the element is the last.</returns>
        private static IInputElement? GetNextInContainer(
            IInputElement element,
            IInputElement container,
            NavigationDirection direction,
            bool outsideElement)
        {
            IInputElement? e = element;

            if (direction == NavigationDirection.Next && !outsideElement)
            {
                var descendant = GetFocusableDescendants(element, direction).FirstOrDefault();

                if (descendant != null)
                {
                    return descendant;
                }
            }

            if (container != null)
            {
                // TODO: Do a spatial search here if the container doesn't implement
                // INavigableContainer.
                if (container is INavigableContainer navigable)
                {
                    while (e != null)
                    {
                        e = navigable.GetControl(direction, e, false);

                        if (e != null &&
                            e.CanFocus() &&
                            KeyboardNavigation.GetIsTabStop((InputElement)e))
                        {
                            break;
                        }
                    }
                }
                else
                {
                    // TODO: Do a spatial search here if the container doesn't implement
                    // INavigableContainer.
                    e = null;
                }

                if (e != null && direction == NavigationDirection.Previous)
                {
                    var descendant = GetFocusableDescendants(e, direction).LastOrDefault();

                    if (descendant != null)
                    {
                        return descendant;
                    }
                }

                return e;
            }

            return null;
        }

        /// <summary>
        /// Gets the first item that should be focused in the next container.
        /// </summary>
        /// <param name="element">The element being navigated away from.</param>
        /// <param name="container">The container.</param>
        /// <param name="direction">The direction of the search.</param>
        /// <returns>The first element, or null if there are no more elements.</returns>
        private static IInputElement? GetFirstInNextContainer(
            IInputElement element,
            IInputElement container,
            NavigationDirection direction)
        {
            var parent = container.GetVisualParent<IInputElement>();
            IInputElement? next = null;

            if (parent != null)
            {
                if (direction == NavigationDirection.Previous &&
                    parent.CanFocus() &&
                    KeyboardNavigation.GetIsTabStop((InputElement)parent))
                {
                    return parent;
                }

                var allSiblings = parent.GetVisualChildren()
                    .OfType<IInputElement>()
                    .Where(FocusExtensions.CanFocusDescendants);
                var siblings = direction == NavigationDirection.Next ?
                    allSiblings.SkipWhile(x => x != container).Skip(1) :
                    allSiblings.TakeWhile(x => x != container).Reverse();

                foreach (var sibling in siblings)
                {
                    var customNext = GetCustomNext(sibling, direction);
                    if (customNext.handled)
                    {
                        return customNext.next;
                    }

                    if (sibling.CanFocus() && KeyboardNavigation.GetIsTabStop((InputElement)sibling))
                    {
                        return sibling;
                    }

                    next = direction == NavigationDirection.Next ?
                        GetFocusableDescendants(sibling, direction).FirstOrDefault() :
                        GetFocusableDescendants(sibling, direction).LastOrDefault();

                    if (next != null)
                    {
                        return next;
                    }
                }

                next = GetFirstInNextContainer(element, parent, direction);
            }
            else
            {
                next = direction == NavigationDirection.Next ?
                    GetFocusableDescendants(container, direction).FirstOrDefault() :
                    GetFocusableDescendants(container, direction).LastOrDefault();
            }

            return next;
        }

        private static (bool handled, IInputElement? next) GetCustomNext(IInputElement element,
            NavigationDirection direction)
        {
            if (element is ICustomKeyboardNavigation custom)
            {
                return custom.GetNext(element, direction);
            }

            return (false, null);
        }
    }

    internal static class FocusExtensions
    {
        /// <summary>
        /// Checks if the specified element can be focused.
        /// </summary>
        /// <param name="e">The element.</param>
        /// <returns>True if the element can be focused.</returns>
        public static bool CanFocus(this IInputElement e)
        {
            return e.Focusable && e.IsEffectivelyEnabled && e.IsVisible;
        }

        /// <summary>
        /// Checks if descendants of the specified element can be focused.
        /// </summary>
        /// <param name="e">The element.</param>
        /// <returns>True if descendants of the element can be focused.</returns>
        public static bool CanFocusDescendants(this IInputElement e)
        {
            return e.IsEffectivelyEnabled && e.IsVisible;
        }
    }
}