Steven Kirk
6 years ago
13 changed files with 4324 additions and 13 deletions
@ -0,0 +1,48 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using System.ComponentModel; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
public interface ISelectionModel : INotifyPropertyChanged |
||||
|
{ |
||||
|
IEnumerable? Source { get; set; } |
||||
|
bool SingleSelect { get; set; } |
||||
|
int SelectedIndex { get; set; } |
||||
|
IReadOnlyList<int> SelectedIndexes { get; } |
||||
|
object? SelectedItem { get; } |
||||
|
IReadOnlyList<object?> SelectedItems { get; } |
||||
|
int AnchorIndex { get; set; } |
||||
|
int Count { get; } |
||||
|
|
||||
|
public event EventHandler<SelectionModelIndexesChangedEventArgs>? IndexesChanged; |
||||
|
public event EventHandler<SelectionModelSelectionChangedEventArgs>? SelectionChanged; |
||||
|
public event EventHandler? LostSelection; |
||||
|
public event EventHandler? SourceReset; |
||||
|
|
||||
|
public void BeginBatchUpdate(); |
||||
|
public void EndBatchUpdate(); |
||||
|
bool IsSelected(int index); |
||||
|
void Select(int index); |
||||
|
void Deselect(int index); |
||||
|
void SelectRange(int start, int end); |
||||
|
void DeselectRange(int start, int end); |
||||
|
void Clear(); |
||||
|
} |
||||
|
|
||||
|
public static class SelectionModelExtensions |
||||
|
{ |
||||
|
public static void SelectAll(this ISelectionModel model) |
||||
|
{ |
||||
|
model.SelectRange(0, int.MaxValue); |
||||
|
} |
||||
|
|
||||
|
public static void SelectRangeFromAnchor(this ISelectionModel model, int to) |
||||
|
{ |
||||
|
model.SelectRange(model.AnchorIndex, to); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,343 @@ |
|||||
|
// This source file is adapted from the WinUI project.
|
||||
|
// (https://github.com/microsoft/microsoft-ui-xaml)
|
||||
|
//
|
||||
|
// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
internal readonly struct IndexRange : IEquatable<IndexRange> |
||||
|
{ |
||||
|
private static readonly IndexRange s_invalid = new IndexRange(int.MinValue, int.MinValue); |
||||
|
|
||||
|
public IndexRange(int index) |
||||
|
{ |
||||
|
Begin = index; |
||||
|
End = index; |
||||
|
} |
||||
|
|
||||
|
public IndexRange(int begin, int end) |
||||
|
{ |
||||
|
// Accept out of order begin/end pairs, just swap them.
|
||||
|
if (begin > end) |
||||
|
{ |
||||
|
int temp = begin; |
||||
|
begin = end; |
||||
|
end = temp; |
||||
|
} |
||||
|
|
||||
|
Begin = begin; |
||||
|
End = end; |
||||
|
} |
||||
|
|
||||
|
public int Begin { get; } |
||||
|
public int End { get; } |
||||
|
public int Count => (End - Begin) + 1; |
||||
|
|
||||
|
public bool Contains(int index) => index >= Begin && index <= End; |
||||
|
|
||||
|
public bool Split(int splitIndex, out IndexRange before, out IndexRange after) |
||||
|
{ |
||||
|
bool afterIsValid; |
||||
|
|
||||
|
before = new IndexRange(Begin, splitIndex); |
||||
|
|
||||
|
if (splitIndex < End) |
||||
|
{ |
||||
|
after = new IndexRange(splitIndex + 1, End); |
||||
|
afterIsValid = true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
after = new IndexRange(); |
||||
|
afterIsValid = false; |
||||
|
} |
||||
|
|
||||
|
return afterIsValid; |
||||
|
} |
||||
|
|
||||
|
public bool Intersects(IndexRange other) |
||||
|
{ |
||||
|
return (Begin <= other.End) && (End >= other.Begin); |
||||
|
} |
||||
|
|
||||
|
public bool Adjacent(IndexRange other) |
||||
|
{ |
||||
|
return Begin == other.End + 1 || End == other.Begin - 1; |
||||
|
} |
||||
|
|
||||
|
public override bool Equals(object? obj) |
||||
|
{ |
||||
|
return obj is IndexRange range && Equals(range); |
||||
|
} |
||||
|
|
||||
|
public bool Equals(IndexRange other) |
||||
|
{ |
||||
|
return Begin == other.Begin && End == other.End; |
||||
|
} |
||||
|
|
||||
|
public override int GetHashCode() |
||||
|
{ |
||||
|
var hashCode = 1903003160; |
||||
|
hashCode = hashCode * -1521134295 + Begin.GetHashCode(); |
||||
|
hashCode = hashCode * -1521134295 + End.GetHashCode(); |
||||
|
return hashCode; |
||||
|
} |
||||
|
|
||||
|
public override string ToString() => $"[{Begin}..{End}]"; |
||||
|
|
||||
|
public static bool operator ==(IndexRange left, IndexRange right) => left.Equals(right); |
||||
|
public static bool operator !=(IndexRange left, IndexRange right) => !(left == right); |
||||
|
|
||||
|
public static bool Contains(IReadOnlyList<IndexRange>? ranges, int index) |
||||
|
{ |
||||
|
if (ranges is null || index < 0) |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
foreach (var range in ranges) |
||||
|
{ |
||||
|
if (range.Contains(index)) |
||||
|
{ |
||||
|
return true; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public static int GetAt(IReadOnlyList<IndexRange> ranges, int index) |
||||
|
{ |
||||
|
var currentIndex = 0; |
||||
|
|
||||
|
foreach (var range in ranges) |
||||
|
{ |
||||
|
var currentCount = range.Count; |
||||
|
|
||||
|
if (index >= currentIndex && index < currentIndex + currentCount) |
||||
|
{ |
||||
|
return range.Begin + (index - currentIndex); |
||||
|
} |
||||
|
|
||||
|
currentIndex += currentCount; |
||||
|
} |
||||
|
|
||||
|
throw new IndexOutOfRangeException("The index was out of range."); |
||||
|
} |
||||
|
|
||||
|
public static int Add( |
||||
|
IList<IndexRange> ranges, |
||||
|
IndexRange range, |
||||
|
IList<IndexRange>? added = null) |
||||
|
{ |
||||
|
var result = 0; |
||||
|
|
||||
|
for (var i = 0; i < ranges.Count && range != s_invalid; ++i) |
||||
|
{ |
||||
|
var existing = ranges[i]; |
||||
|
|
||||
|
if (range.Intersects(existing) || range.Adjacent(existing)) |
||||
|
{ |
||||
|
if (range.Begin < existing.Begin) |
||||
|
{ |
||||
|
var add = new IndexRange(range.Begin, existing.Begin - 1); |
||||
|
ranges[i] = new IndexRange(range.Begin, existing.End); |
||||
|
added?.Add(add); |
||||
|
result += add.Count; |
||||
|
} |
||||
|
|
||||
|
range = range.End <= existing.End ? |
||||
|
s_invalid : |
||||
|
new IndexRange(existing.End + 1, range.End); |
||||
|
} |
||||
|
else if (range.End < existing.Begin) |
||||
|
{ |
||||
|
ranges.Insert(i, range); |
||||
|
added?.Add(range); |
||||
|
result += range.Count; |
||||
|
range = s_invalid; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (range != s_invalid) |
||||
|
{ |
||||
|
ranges.Add(range); |
||||
|
added?.Add(range); |
||||
|
result += range.Count; |
||||
|
} |
||||
|
|
||||
|
MergeRanges(ranges); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static int Add( |
||||
|
IList<IndexRange> destination, |
||||
|
IReadOnlyList<IndexRange> source, |
||||
|
IList<IndexRange>? added = null) |
||||
|
{ |
||||
|
var result = 0; |
||||
|
|
||||
|
foreach (var range in source) |
||||
|
{ |
||||
|
result += Add(destination, range, added); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static int Intersect( |
||||
|
IList<IndexRange> ranges, |
||||
|
IndexRange range, |
||||
|
IList<IndexRange>? removed = null) |
||||
|
{ |
||||
|
var result = 0; |
||||
|
|
||||
|
for (var i = 0; i < ranges.Count && range != s_invalid; ++i) |
||||
|
{ |
||||
|
var existing = ranges[i]; |
||||
|
|
||||
|
if (existing.End < range.Begin || existing.Begin > range.End) |
||||
|
{ |
||||
|
removed?.Add(existing); |
||||
|
ranges.RemoveAt(i--); |
||||
|
result += existing.Count; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (existing.Begin < range.Begin) |
||||
|
{ |
||||
|
var except = new IndexRange(existing.Begin, range.Begin - 1); |
||||
|
removed?.Add(except); |
||||
|
ranges[i] = existing = new IndexRange(range.Begin, existing.End); |
||||
|
result += except.Count; |
||||
|
} |
||||
|
|
||||
|
if (existing.End > range.End) |
||||
|
{ |
||||
|
var except = new IndexRange(range.End + 1, existing.End); |
||||
|
removed?.Add(except); |
||||
|
ranges[i] = new IndexRange(existing.Begin, range.End); |
||||
|
result += except.Count; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
MergeRanges(ranges); |
||||
|
|
||||
|
if (removed is object) |
||||
|
{ |
||||
|
MergeRanges(removed); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static int Remove( |
||||
|
IList<IndexRange>? ranges, |
||||
|
IndexRange range, |
||||
|
IList<IndexRange>? removed = null) |
||||
|
{ |
||||
|
if (ranges is null) |
||||
|
{ |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
var result = 0; |
||||
|
|
||||
|
for (var i = 0; i < ranges.Count; ++i) |
||||
|
{ |
||||
|
var existing = ranges[i]; |
||||
|
|
||||
|
if (range.Intersects(existing)) |
||||
|
{ |
||||
|
if (range.Begin <= existing.Begin && range.End >= existing.End) |
||||
|
{ |
||||
|
ranges.RemoveAt(i--); |
||||
|
removed?.Add(existing); |
||||
|
result += existing.Count; |
||||
|
} |
||||
|
else if (range.Begin > existing.Begin && range.End >= existing.End) |
||||
|
{ |
||||
|
ranges[i] = new IndexRange(existing.Begin, range.Begin - 1); |
||||
|
removed?.Add(new IndexRange(range.Begin, existing.End)); |
||||
|
result += existing.End - (range.Begin - 1); |
||||
|
} |
||||
|
else if (range.Begin > existing.Begin && range.End < existing.End) |
||||
|
{ |
||||
|
ranges[i] = new IndexRange(existing.Begin, range.Begin - 1); |
||||
|
ranges.Insert(++i, new IndexRange(range.End + 1, existing.End)); |
||||
|
removed?.Add(range); |
||||
|
result += range.Count; |
||||
|
} |
||||
|
else if (range.End <= existing.End) |
||||
|
{ |
||||
|
var remove = new IndexRange(existing.Begin, range.End); |
||||
|
ranges[i] = new IndexRange(range.End + 1, existing.End); |
||||
|
removed?.Add(remove); |
||||
|
result += remove.Count; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static int Remove( |
||||
|
IList<IndexRange> destination, |
||||
|
IReadOnlyList<IndexRange> source, |
||||
|
IList<IndexRange>? added = null) |
||||
|
{ |
||||
|
var result = 0; |
||||
|
|
||||
|
foreach (var range in source) |
||||
|
{ |
||||
|
result += Remove(destination, range, added); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static IEnumerable<int> EnumerateIndices(IEnumerable<IndexRange> ranges) |
||||
|
{ |
||||
|
foreach (var range in ranges) |
||||
|
{ |
||||
|
for (var i = range.Begin; i <= range.End; ++i) |
||||
|
{ |
||||
|
yield return i; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static int GetCount(IEnumerable<IndexRange> ranges) |
||||
|
{ |
||||
|
var result = 0; |
||||
|
|
||||
|
foreach (var range in ranges) |
||||
|
{ |
||||
|
result += (range.End - range.Begin) + 1; |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
private static void MergeRanges(IList<IndexRange> ranges) |
||||
|
{ |
||||
|
for (var i = ranges.Count - 2; i >= 0; --i) |
||||
|
{ |
||||
|
var r = ranges[i]; |
||||
|
var r1 = ranges[i + 1]; |
||||
|
|
||||
|
if (r.Intersects(r1) || r.End == r1.Begin - 1) |
||||
|
{ |
||||
|
ranges[i] = new IndexRange(r.Begin, r1.End); |
||||
|
ranges.RemoveAt(i + 1); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,82 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Linq; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
internal class SelectedIndexes<T> : IReadOnlyList<int> |
||||
|
{ |
||||
|
private readonly SelectionModel<T>? _owner; |
||||
|
private readonly IReadOnlyList<IndexRange>? _ranges; |
||||
|
|
||||
|
public SelectedIndexes(SelectionModel<T> owner) => _owner = owner; |
||||
|
public SelectedIndexes(IReadOnlyList<IndexRange> ranges) => _ranges = ranges; |
||||
|
|
||||
|
public int this[int index] |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (index >= Count) |
||||
|
{ |
||||
|
throw new IndexOutOfRangeException("The index was out of range."); |
||||
|
} |
||||
|
|
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
return _owner.SelectedIndex; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return IndexRange.GetAt(Ranges!, index); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int Count |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
return _owner.SelectedIndex == -1 ? 0 : 1; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return IndexRange.GetCount(Ranges!); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private IReadOnlyList<IndexRange> Ranges => _ranges ?? _owner!.Ranges!; |
||||
|
|
||||
|
public IEnumerator<int> GetEnumerator() |
||||
|
{ |
||||
|
IEnumerator<int> SingleSelect() |
||||
|
{ |
||||
|
if (_owner.SelectedIndex >= 0) |
||||
|
{ |
||||
|
yield return _owner.SelectedIndex; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
return SingleSelect(); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return IndexRange.EnumerateIndices(Ranges).GetEnumerator(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static SelectedIndexes<T>? Create(IReadOnlyList<IndexRange>? ranges) |
||||
|
{ |
||||
|
return ranges is object ? new SelectedIndexes<T>(ranges) : null; |
||||
|
} |
||||
|
|
||||
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,121 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
internal class SelectedItems<T> : IReadOnlyList<T> |
||||
|
{ |
||||
|
private readonly SelectionModel<T>? _owner; |
||||
|
private readonly ItemsSourceView<T>? _items; |
||||
|
private readonly IReadOnlyList<IndexRange>? _ranges; |
||||
|
|
||||
|
public SelectedItems(SelectionModel<T> owner) => _owner = owner; |
||||
|
|
||||
|
public SelectedItems(IReadOnlyList<IndexRange> ranges, ItemsSourceView<T>? items) |
||||
|
{ |
||||
|
_ranges = ranges ?? throw new ArgumentNullException(nameof(ranges)); |
||||
|
_items = items; |
||||
|
} |
||||
|
|
||||
|
[MaybeNull] |
||||
|
public T this[int index] |
||||
|
{ |
||||
|
#pragma warning disable CS8766
|
||||
|
get |
||||
|
#pragma warning restore CS8766
|
||||
|
{ |
||||
|
if (index >= Count) |
||||
|
{ |
||||
|
throw new IndexOutOfRangeException("The index was out of range."); |
||||
|
} |
||||
|
|
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
return _owner.SelectedItem; |
||||
|
} |
||||
|
else if (Items is object) |
||||
|
{ |
||||
|
return Items[index]; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return default; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int Count |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
return _owner.SelectedIndex == -1 ? 0 : 1; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return Ranges is object ? IndexRange.GetCount(Ranges) : 0; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private ItemsSourceView<T>? Items => _items ?? _owner?.ItemsView; |
||||
|
private IReadOnlyList<IndexRange>? Ranges => _ranges ?? _owner!.Ranges; |
||||
|
|
||||
|
public IEnumerator<T> GetEnumerator() |
||||
|
{ |
||||
|
if (_owner?.SingleSelect == true) |
||||
|
{ |
||||
|
if (_owner.SelectedIndex >= 0) |
||||
|
{ |
||||
|
#pragma warning disable CS8603
|
||||
|
yield return _owner.SelectedItem; |
||||
|
#pragma warning restore CS8603
|
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var items = Items; |
||||
|
|
||||
|
foreach (var range in Ranges!) |
||||
|
{ |
||||
|
for (var i = range.Begin; i <= range.End; ++i) |
||||
|
{ |
||||
|
#pragma warning disable CS8603
|
||||
|
yield return items is object ? items[i] : default; |
||||
|
#pragma warning restore CS8603
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); |
||||
|
|
||||
|
public static SelectedItems<T>? Create( |
||||
|
IReadOnlyList<IndexRange>? ranges, |
||||
|
ItemsSourceView<T>? items) |
||||
|
{ |
||||
|
return ranges is object ? new SelectedItems<T>(ranges, items) : null; |
||||
|
} |
||||
|
|
||||
|
public class Untyped : IReadOnlyList<object?> |
||||
|
{ |
||||
|
private readonly IReadOnlyList<T> _source; |
||||
|
public Untyped(IReadOnlyList<T> source) => _source = source; |
||||
|
public object? this[int index] => _source[index]; |
||||
|
public int Count => _source.Count; |
||||
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); |
||||
|
public IEnumerator<object?> GetEnumerator() |
||||
|
{ |
||||
|
foreach (var i in _source) |
||||
|
{ |
||||
|
yield return i; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,632 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Collections.Specialized; |
||||
|
using System.ComponentModel; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
using System.Linq; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
public class SelectionModel<T> : SelectionNodeBase<T>, ISelectionModel |
||||
|
{ |
||||
|
private bool _singleSelect = true; |
||||
|
private int _anchorIndex = -1; |
||||
|
private int _selectedIndex = -1; |
||||
|
private Operation? _operation; |
||||
|
private SelectedIndexes<T>? _selectedIndexes; |
||||
|
private SelectedItems<T>? _selectedItems; |
||||
|
private SelectedItems<T>.Untyped? _selectedItemsUntyped; |
||||
|
private EventHandler<SelectionModelSelectionChangedEventArgs>? _untypedSelectionChanged; |
||||
|
|
||||
|
public SelectionModel() |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
public SelectionModel(IEnumerable<T>? source) |
||||
|
{ |
||||
|
Source = source; |
||||
|
} |
||||
|
|
||||
|
public override IEnumerable<T>? Source |
||||
|
{ |
||||
|
get => base.Source; |
||||
|
set |
||||
|
{ |
||||
|
if (base.Source != value) |
||||
|
{ |
||||
|
if (_operation is object) |
||||
|
{ |
||||
|
throw new InvalidOperationException("Cannot change source while update is in progress."); |
||||
|
} |
||||
|
|
||||
|
if (base.Source is object) |
||||
|
{ |
||||
|
Clear(); |
||||
|
} |
||||
|
|
||||
|
base.Source = value; |
||||
|
|
||||
|
using var update = BatchUpdate(); |
||||
|
update.Operation.IsSourceUpdate = true; |
||||
|
TrimInvalidSelections(update.Operation); |
||||
|
RaisePropertyChanged(nameof(Source)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public bool SingleSelect |
||||
|
{ |
||||
|
get => _singleSelect; |
||||
|
set |
||||
|
{ |
||||
|
if (_singleSelect != value) |
||||
|
{ |
||||
|
_singleSelect = value; |
||||
|
RangesEnabled = !value; |
||||
|
|
||||
|
if (RangesEnabled && _selectedIndex >= 0) |
||||
|
{ |
||||
|
CommitSelect(new IndexRange(_selectedIndex)); |
||||
|
} |
||||
|
|
||||
|
RaisePropertyChanged(nameof(SingleSelect)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int SelectedIndex |
||||
|
{ |
||||
|
get => _selectedIndex; |
||||
|
set |
||||
|
{ |
||||
|
using var update = BatchUpdate(); |
||||
|
Clear(); |
||||
|
Select(value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IReadOnlyList<int> SelectedIndexes => _selectedIndexes ??= new SelectedIndexes<T>(this); |
||||
|
|
||||
|
[MaybeNull] |
||||
|
public T SelectedItem => GetItemAt(_selectedIndex); |
||||
|
|
||||
|
public IReadOnlyList<T> SelectedItems => _selectedItems ??= new SelectedItems<T>(this); |
||||
|
|
||||
|
public int AnchorIndex |
||||
|
{ |
||||
|
get => _anchorIndex; |
||||
|
set |
||||
|
{ |
||||
|
using var update = BatchUpdate(); |
||||
|
var index = CoerceIndex(value); |
||||
|
update.Operation.AnchorIndex = index; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public int Count |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (SingleSelect) |
||||
|
{ |
||||
|
return _selectedIndex >= 0 ? 1 : 0; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return IndexRange.GetCount(Ranges); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
IEnumerable? ISelectionModel.Source |
||||
|
{ |
||||
|
get => Source; |
||||
|
set => Source = (IEnumerable<T>?)value; |
||||
|
} |
||||
|
|
||||
|
object? ISelectionModel.SelectedItem => SelectedItem; |
||||
|
|
||||
|
IReadOnlyList<object?> ISelectionModel.SelectedItems |
||||
|
{ |
||||
|
get => _selectedItemsUntyped ??= new SelectedItems<T>.Untyped(SelectedItems); |
||||
|
} |
||||
|
|
||||
|
public event EventHandler<SelectionModelIndexesChangedEventArgs>? IndexesChanged; |
||||
|
public event EventHandler<SelectionModelSelectionChangedEventArgs<T>>? SelectionChanged; |
||||
|
public event EventHandler? LostSelection; |
||||
|
public event EventHandler? SourceReset; |
||||
|
public event PropertyChangedEventHandler? PropertyChanged; |
||||
|
|
||||
|
event EventHandler<SelectionModelSelectionChangedEventArgs>? ISelectionModel.SelectionChanged |
||||
|
{ |
||||
|
add => _untypedSelectionChanged += value; |
||||
|
remove => _untypedSelectionChanged -= value; |
||||
|
} |
||||
|
|
||||
|
public BatchUpdateOperation BatchUpdate() => new BatchUpdateOperation(this); |
||||
|
|
||||
|
public void BeginBatchUpdate() |
||||
|
{ |
||||
|
_operation ??= new Operation(this); |
||||
|
++_operation.UpdateCount; |
||||
|
} |
||||
|
|
||||
|
public void EndBatchUpdate() |
||||
|
{ |
||||
|
if (_operation is null || _operation.UpdateCount == 0) |
||||
|
{ |
||||
|
throw new InvalidOperationException("No batch update in progress."); |
||||
|
} |
||||
|
|
||||
|
if (--_operation.UpdateCount == 0) |
||||
|
{ |
||||
|
// If the collection is currently changing, commit the update when the
|
||||
|
// collection change finishes.
|
||||
|
if (!IsSourceCollectionChanging) |
||||
|
{ |
||||
|
CommitOperation(_operation); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public bool IsSelected(int index) |
||||
|
{ |
||||
|
if (index < 0) |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
else if (SingleSelect) |
||||
|
{ |
||||
|
return _selectedIndex == index; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return IndexRange.Contains(Ranges, index); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Select(int index) => SelectRange(index, index, false, true); |
||||
|
|
||||
|
public void Deselect(int index) => DeselectRange(index, index); |
||||
|
|
||||
|
public void SelectRange(int start, int end) => SelectRange(start, end, false, false); |
||||
|
|
||||
|
public void DeselectRange(int start, int end) |
||||
|
{ |
||||
|
using var update = BatchUpdate(); |
||||
|
var o = update.Operation; |
||||
|
var range = CoerceRange(start, end); |
||||
|
|
||||
|
if (range.Begin == -1) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
var selected = Ranges.ToList(); |
||||
|
var deselected = new List<IndexRange>(); |
||||
|
var operationDeselected = new List<IndexRange>(); |
||||
|
|
||||
|
o.DeselectedRanges ??= new List<IndexRange>(); |
||||
|
IndexRange.Remove(o.SelectedRanges, range, operationDeselected); |
||||
|
IndexRange.Remove(selected, range, deselected); |
||||
|
IndexRange.Add(o.DeselectedRanges, deselected); |
||||
|
|
||||
|
if (IndexRange.Contains(deselected, o.SelectedIndex) || |
||||
|
IndexRange.Contains(operationDeselected, o.SelectedIndex)) |
||||
|
{ |
||||
|
o.SelectedIndex = GetFirstSelectedIndexFromRanges(except: deselected); |
||||
|
} |
||||
|
} |
||||
|
else if(range.Contains(_selectedIndex)) |
||||
|
{ |
||||
|
o.SelectedIndex = -1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Clear() => DeselectRange(0, int.MaxValue); |
||||
|
|
||||
|
protected void RaisePropertyChanged(string propertyName) |
||||
|
{ |
||||
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); |
||||
|
} |
||||
|
|
||||
|
private protected override void OnIndexesChanged(int shiftIndex, int shiftDelta) |
||||
|
{ |
||||
|
IndexesChanged?.Invoke(this, new SelectionModelIndexesChangedEventArgs(shiftIndex, shiftDelta)); |
||||
|
} |
||||
|
|
||||
|
private protected override void OnSourceReset() |
||||
|
{ |
||||
|
_selectedIndex = _anchorIndex = -1; |
||||
|
CommitDeselect(new IndexRange(0, int.MaxValue)); |
||||
|
|
||||
|
if (SourceReset is object) |
||||
|
{ |
||||
|
SourceReset.Invoke(this, EventArgs.Empty); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
//Logger.TryGet(LogEventLevel.Warning, LogArea.Control)?.Log(
|
||||
|
// this,
|
||||
|
// "SelectionModel received Reset but no SourceReset handler was registered to handle it. " +
|
||||
|
// "Selection may be out of sync.",
|
||||
|
// typeof(SelectionModel));
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private protected override void OnSelectionChanged(IReadOnlyList<T> deselectedItems) |
||||
|
{ |
||||
|
if (SelectionChanged is object || _untypedSelectionChanged is object) |
||||
|
{ |
||||
|
var e = new SelectionModelSelectionChangedEventArgs<T>(deselectedItems: deselectedItems); |
||||
|
SelectionChanged?.Invoke(this, e); |
||||
|
_untypedSelectionChanged?.Invoke(this, e); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private protected override CollectionChangeState OnItemsAdded(int index, IList items) |
||||
|
{ |
||||
|
var count = items.Count; |
||||
|
var shifted = SelectedIndex >= index; |
||||
|
var shiftCount = shifted ? count : 0; |
||||
|
|
||||
|
_selectedIndex += shiftCount; |
||||
|
_anchorIndex += shiftCount; |
||||
|
|
||||
|
var baseResult = base.OnItemsAdded(index, items); |
||||
|
shifted |= baseResult.ShiftDelta != 0; |
||||
|
|
||||
|
return new CollectionChangeState |
||||
|
{ |
||||
|
ShiftIndex = index, |
||||
|
ShiftDelta = shifted ? count : 0, |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
private protected override CollectionChangeState OnItemsRemoved(int index, IList items) |
||||
|
{ |
||||
|
var count = items.Count; |
||||
|
var removedRange = new IndexRange(index, index + count - 1); |
||||
|
var shifted = false; |
||||
|
List<T>? removed; |
||||
|
|
||||
|
var baseResult = base.OnItemsRemoved(index, items); |
||||
|
shifted |= baseResult.ShiftDelta != 0; |
||||
|
removed = baseResult.RemovedItems; |
||||
|
|
||||
|
if (removedRange.Contains(SelectedIndex)) |
||||
|
{ |
||||
|
if (SingleSelect) |
||||
|
{ |
||||
|
#pragma warning disable CS8604
|
||||
|
removed = new List<T> { (T)items[SelectedIndex - index] }; |
||||
|
#pragma warning restore CS8604
|
||||
|
} |
||||
|
|
||||
|
_selectedIndex = GetFirstSelectedIndexFromRanges(); |
||||
|
} |
||||
|
else if (SelectedIndex >= index) |
||||
|
{ |
||||
|
_selectedIndex -= count; |
||||
|
shifted = true; |
||||
|
} |
||||
|
|
||||
|
if (removedRange.Contains(AnchorIndex)) |
||||
|
{ |
||||
|
_anchorIndex = GetFirstSelectedIndexFromRanges(); |
||||
|
} |
||||
|
else if (AnchorIndex >= index) |
||||
|
{ |
||||
|
_anchorIndex -= count; |
||||
|
shifted = true; |
||||
|
} |
||||
|
|
||||
|
return new CollectionChangeState |
||||
|
{ |
||||
|
ShiftIndex = index, |
||||
|
ShiftDelta = shifted ? -count : 0, |
||||
|
RemovedItems = removed, |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
private protected override void OnSourceCollectionChanged(NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
if (_operation?.UpdateCount > 0) |
||||
|
{ |
||||
|
throw new InvalidOperationException("Source collection was modified during selection update."); |
||||
|
} |
||||
|
|
||||
|
var oldAnchorIndex = _anchorIndex; |
||||
|
var oldSelectedIndex = _selectedIndex; |
||||
|
|
||||
|
base.OnSourceCollectionChanged(e); |
||||
|
|
||||
|
if (oldSelectedIndex != _selectedIndex) |
||||
|
{ |
||||
|
RaisePropertyChanged(nameof(SelectedIndex)); |
||||
|
} |
||||
|
|
||||
|
if (oldAnchorIndex != _anchorIndex) |
||||
|
{ |
||||
|
RaisePropertyChanged(nameof(AnchorIndex)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected override void OnSourceCollectionChangeFinished() |
||||
|
{ |
||||
|
if (_operation is object) |
||||
|
{ |
||||
|
CommitOperation(_operation); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private int GetFirstSelectedIndexFromRanges(List<IndexRange>? except = null) |
||||
|
{ |
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
var count = IndexRange.GetCount(Ranges); |
||||
|
var index = 0; |
||||
|
|
||||
|
while (index < count) |
||||
|
{ |
||||
|
var result = IndexRange.GetAt(Ranges, index++); |
||||
|
|
||||
|
if (!IndexRange.Contains(except, result)) |
||||
|
{ |
||||
|
return result; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return -1; |
||||
|
} |
||||
|
|
||||
|
private void SelectRange( |
||||
|
int start, |
||||
|
int end, |
||||
|
bool forceSelectedIndex, |
||||
|
bool forceAnchorIndex) |
||||
|
{ |
||||
|
if (SingleSelect && start != end) |
||||
|
{ |
||||
|
throw new InvalidOperationException("Cannot select range with single selection."); |
||||
|
} |
||||
|
|
||||
|
var range = CoerceRange(start, end); |
||||
|
|
||||
|
if (range.Begin == -1) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
using var update = BatchUpdate(); |
||||
|
var o = update.Operation; |
||||
|
var selected = new List<IndexRange>(); |
||||
|
|
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
o.SelectedRanges ??= new List<IndexRange>(); |
||||
|
IndexRange.Remove(o.DeselectedRanges, range); |
||||
|
IndexRange.Add(o.SelectedRanges, range); |
||||
|
IndexRange.Remove(o.SelectedRanges, Ranges); |
||||
|
|
||||
|
if (o.SelectedIndex == -1 || forceSelectedIndex) |
||||
|
{ |
||||
|
o.SelectedIndex = range.Begin; |
||||
|
} |
||||
|
|
||||
|
if (o.AnchorIndex == -1 || forceAnchorIndex) |
||||
|
{ |
||||
|
o.AnchorIndex = range.Begin; |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
o.SelectedIndex = o.AnchorIndex = start; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
[return: MaybeNull] |
||||
|
private T GetItemAt(int index) |
||||
|
{ |
||||
|
if (ItemsView is null || index < 0 || index >= ItemsView.Count) |
||||
|
{ |
||||
|
return default; |
||||
|
} |
||||
|
|
||||
|
return ItemsView.GetAt(index); |
||||
|
} |
||||
|
|
||||
|
private int CoerceIndex(int index) |
||||
|
{ |
||||
|
index = Math.Max(index, -1); |
||||
|
|
||||
|
if (ItemsView is object && index >= ItemsView.Count) |
||||
|
{ |
||||
|
index = -1; |
||||
|
} |
||||
|
|
||||
|
return index; |
||||
|
} |
||||
|
|
||||
|
private IndexRange CoerceRange(int start, int end) |
||||
|
{ |
||||
|
var max = ItemsView is object ? ItemsView.Count - 1 : int.MaxValue; |
||||
|
|
||||
|
if (start > max || (start < 0 && end < 0)) |
||||
|
{ |
||||
|
return new IndexRange(-1); |
||||
|
} |
||||
|
|
||||
|
start = Math.Max(start, 0); |
||||
|
end = Math.Min(end, max); |
||||
|
|
||||
|
return new IndexRange(start, end); |
||||
|
} |
||||
|
|
||||
|
private void TrimInvalidSelections(Operation operation) |
||||
|
{ |
||||
|
if (ItemsView is null) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var max = ItemsView.Count - 1; |
||||
|
|
||||
|
if (operation.SelectedIndex > max) |
||||
|
{ |
||||
|
operation.SelectedIndex = GetFirstSelectedIndexFromRanges(); |
||||
|
} |
||||
|
|
||||
|
if (operation.AnchorIndex > max) |
||||
|
{ |
||||
|
operation.AnchorIndex = GetFirstSelectedIndexFromRanges(); |
||||
|
} |
||||
|
|
||||
|
if (RangesEnabled && Ranges.Count > 0) |
||||
|
{ |
||||
|
var selected = Ranges.ToList(); |
||||
|
|
||||
|
if (max < 0) |
||||
|
{ |
||||
|
operation.DeselectedRanges = selected; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var valid = new IndexRange(0, max); |
||||
|
var removed = new List<IndexRange>(); |
||||
|
IndexRange.Intersect(selected, valid, removed); |
||||
|
operation.DeselectedRanges = removed; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void CommitOperation(Operation operation) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
var oldAnchorIndex = _anchorIndex; |
||||
|
var oldSelectedIndex = _selectedIndex; |
||||
|
var indexesChanged = false; |
||||
|
|
||||
|
if (operation.SelectedIndex == -1 && LostSelection is object) |
||||
|
{ |
||||
|
operation.UpdateCount++; |
||||
|
LostSelection?.Invoke(this, EventArgs.Empty); |
||||
|
} |
||||
|
|
||||
|
_selectedIndex = operation.SelectedIndex; |
||||
|
_anchorIndex = operation.AnchorIndex; |
||||
|
|
||||
|
if (operation.SelectedRanges is object) |
||||
|
{ |
||||
|
indexesChanged |= CommitSelect(operation.SelectedRanges) > 0; |
||||
|
} |
||||
|
|
||||
|
if (operation.DeselectedRanges is object) |
||||
|
{ |
||||
|
indexesChanged |= CommitDeselect(operation.DeselectedRanges) > 0; |
||||
|
} |
||||
|
|
||||
|
if (SelectionChanged is object || _untypedSelectionChanged is object) |
||||
|
{ |
||||
|
IReadOnlyList<IndexRange>? deselected = operation.DeselectedRanges; |
||||
|
IReadOnlyList<IndexRange>? selected = operation.SelectedRanges; |
||||
|
|
||||
|
if (SingleSelect && oldSelectedIndex != _selectedIndex) |
||||
|
{ |
||||
|
if (oldSelectedIndex != -1) |
||||
|
{ |
||||
|
deselected = new[] { new IndexRange(oldSelectedIndex) }; |
||||
|
} |
||||
|
|
||||
|
if (_selectedIndex != -1) |
||||
|
{ |
||||
|
selected = new[] { new IndexRange(_selectedIndex) }; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (deselected?.Count > 0 || selected?.Count > 0) |
||||
|
{ |
||||
|
var deselectedSource = operation.IsSourceUpdate ? null : ItemsView; |
||||
|
var e = new SelectionModelSelectionChangedEventArgs<T>( |
||||
|
SelectedIndexes<T>.Create(deselected), |
||||
|
SelectedIndexes<T>.Create(selected), |
||||
|
SelectedItems<T>.Create(deselected, deselectedSource), |
||||
|
SelectedItems<T>.Create(selected, ItemsView)); |
||||
|
SelectionChanged?.Invoke(this, e); |
||||
|
_untypedSelectionChanged?.Invoke(this, e); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (oldSelectedIndex != _selectedIndex) |
||||
|
{ |
||||
|
indexesChanged = true; |
||||
|
RaisePropertyChanged(nameof(SelectedIndex)); |
||||
|
RaisePropertyChanged(nameof(SelectedItem)); |
||||
|
} |
||||
|
|
||||
|
if (oldAnchorIndex != _anchorIndex) |
||||
|
{ |
||||
|
indexesChanged = true; |
||||
|
RaisePropertyChanged(nameof(AnchorIndex)); |
||||
|
} |
||||
|
|
||||
|
if (indexesChanged) |
||||
|
{ |
||||
|
RaisePropertyChanged(nameof(SelectedIndexes)); |
||||
|
RaisePropertyChanged(nameof(SelectedItems)); |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
_operation = null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public struct BatchUpdateOperation : IDisposable |
||||
|
{ |
||||
|
private readonly SelectionModel<T> _owner; |
||||
|
private bool _isDisposed; |
||||
|
|
||||
|
public BatchUpdateOperation(SelectionModel<T> owner) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
_isDisposed = false; |
||||
|
owner.BeginBatchUpdate(); |
||||
|
} |
||||
|
|
||||
|
internal Operation Operation => _owner._operation!; |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
if (!_isDisposed) |
||||
|
{ |
||||
|
_owner?.EndBatchUpdate(); |
||||
|
_isDisposed = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal class Operation |
||||
|
{ |
||||
|
public Operation(SelectionModel<T> owner) |
||||
|
{ |
||||
|
AnchorIndex = owner.AnchorIndex; |
||||
|
SelectedIndex = owner.SelectedIndex; |
||||
|
} |
||||
|
|
||||
|
public int UpdateCount { get; set; } |
||||
|
public bool IsSourceUpdate { get; set; } |
||||
|
public int AnchorIndex { get; set; } |
||||
|
public int SelectedIndex { get; set; } |
||||
|
public List<IndexRange>? SelectedRanges { get; set; } |
||||
|
public List<IndexRange>? DeselectedRanges { get; set; } |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,18 @@ |
|||||
|
using System; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
public class SelectionModelIndexesChangedEventArgs : EventArgs |
||||
|
{ |
||||
|
public SelectionModelIndexesChangedEventArgs(int startIndex, int delta) |
||||
|
{ |
||||
|
StartIndex = startIndex; |
||||
|
Delta = delta; |
||||
|
} |
||||
|
|
||||
|
public int StartIndex { get; } |
||||
|
public int Delta { get; } |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,85 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using Avalonia.Controls.Selection; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
public abstract class SelectionModelSelectionChangedEventArgs : EventArgs |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Gets the indexes of the items that were removed from the selection.
|
||||
|
/// </summary>
|
||||
|
public abstract IReadOnlyList<int> DeselectedIndexes { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the indexes of the items that were added to the selection.
|
||||
|
/// </summary>
|
||||
|
public abstract IReadOnlyList<int> SelectedIndexes { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the items that were removed from the selection.
|
||||
|
/// </summary>
|
||||
|
public IReadOnlyList<object?> DeselectedItems => GetUntypedDeselectedItems(); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the items that were added to the selection.
|
||||
|
/// </summary>
|
||||
|
public IReadOnlyList<object?> SelectedItems => GetUntypedSelectedItems(); |
||||
|
|
||||
|
protected abstract IReadOnlyList<object?> GetUntypedDeselectedItems(); |
||||
|
protected abstract IReadOnlyList<object?> GetUntypedSelectedItems(); |
||||
|
} |
||||
|
|
||||
|
public class SelectionModelSelectionChangedEventArgs<T> : SelectionModelSelectionChangedEventArgs |
||||
|
{ |
||||
|
private IReadOnlyList<object?>? _deselectedItems; |
||||
|
private IReadOnlyList<object?>? _selectedItems; |
||||
|
|
||||
|
public SelectionModelSelectionChangedEventArgs( |
||||
|
IReadOnlyList<int>? deselectedIndices = null, |
||||
|
IReadOnlyList<int>? selectedIndices = null, |
||||
|
IReadOnlyList<T>? deselectedItems = null, |
||||
|
IReadOnlyList<T>? selectedItems = null) |
||||
|
{ |
||||
|
DeselectedIndexes = deselectedIndices ?? Array.Empty<int>(); |
||||
|
SelectedIndexes = selectedIndices ?? Array.Empty<int>(); |
||||
|
DeselectedItems = deselectedItems ?? Array.Empty<T>(); |
||||
|
SelectedItems = selectedItems ?? Array.Empty<T>(); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the indexes of the items that were removed from the selection.
|
||||
|
/// </summary>
|
||||
|
public override IReadOnlyList<int> DeselectedIndexes { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the indexes of the items that were added to the selection.
|
||||
|
/// </summary>
|
||||
|
public override IReadOnlyList<int> SelectedIndexes { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the items that were removed from the selection.
|
||||
|
/// </summary>
|
||||
|
public new IReadOnlyList<T> DeselectedItems { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the items that were added to the selection.
|
||||
|
/// </summary>
|
||||
|
public new IReadOnlyList<T> SelectedItems { get; } |
||||
|
|
||||
|
protected override IReadOnlyList<object?> GetUntypedDeselectedItems() |
||||
|
{ |
||||
|
return _deselectedItems ??= (DeselectedItems as IReadOnlyList<object?>) ?? |
||||
|
new SelectedItems<T>.Untyped(DeselectedItems); |
||||
|
} |
||||
|
|
||||
|
protected override IReadOnlyList<object?> GetUntypedSelectedItems() |
||||
|
{ |
||||
|
return _selectedItems ??= (SelectedItems as IReadOnlyList<object?>) ?? |
||||
|
new SelectedItems<T>.Untyped(SelectedItems); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,286 @@ |
|||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Collections.Specialized; |
||||
|
using Avalonia.Controls.Utils; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Selection |
||||
|
{ |
||||
|
public abstract class SelectionNodeBase<T> : ICollectionChangedListener |
||||
|
{ |
||||
|
private IEnumerable<T>? _source; |
||||
|
private bool _rangesEnabled; |
||||
|
private List<IndexRange>? _ranges; |
||||
|
private int _collectionChanging; |
||||
|
|
||||
|
public virtual IEnumerable<T>? Source |
||||
|
{ |
||||
|
get => _source; |
||||
|
set |
||||
|
{ |
||||
|
if (_source != value) |
||||
|
{ |
||||
|
ItemsView?.RemoveListener(this); |
||||
|
_source = value; |
||||
|
ItemsView = value is object ? ItemsSourceView<T>.GetOrCreate(value) : null; |
||||
|
ItemsView?.AddListener(this); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected bool IsSourceCollectionChanging => _collectionChanging > 0; |
||||
|
|
||||
|
protected bool RangesEnabled |
||||
|
{ |
||||
|
get => _rangesEnabled; |
||||
|
set |
||||
|
{ |
||||
|
if (_rangesEnabled != value) |
||||
|
{ |
||||
|
_rangesEnabled = value; |
||||
|
|
||||
|
if (!_rangesEnabled) |
||||
|
{ |
||||
|
_ranges = null; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal ItemsSourceView<T>? ItemsView { get; set; } |
||||
|
|
||||
|
internal IReadOnlyList<IndexRange> Ranges |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (!RangesEnabled) |
||||
|
{ |
||||
|
throw new InvalidOperationException("Ranges not enabled."); |
||||
|
} |
||||
|
|
||||
|
return _ranges ??= new List<IndexRange>(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void ICollectionChangedListener.PreChanged(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
++_collectionChanging; |
||||
|
} |
||||
|
|
||||
|
void ICollectionChangedListener.Changed(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
OnSourceCollectionChanged(e); |
||||
|
} |
||||
|
|
||||
|
void ICollectionChangedListener.PostChanged(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
if (--_collectionChanging == 0) |
||||
|
{ |
||||
|
OnSourceCollectionChangeFinished(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected abstract void OnSourceCollectionChangeFinished(); |
||||
|
|
||||
|
private protected abstract void OnIndexesChanged(int shiftIndex, int shiftDelta); |
||||
|
|
||||
|
private protected abstract void OnSourceReset(); |
||||
|
|
||||
|
private protected abstract void OnSelectionChanged(IReadOnlyList<T> deselectedItems); |
||||
|
|
||||
|
private protected int CommitSelect(IndexRange range) |
||||
|
{ |
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
_ranges ??= new List<IndexRange>(); |
||||
|
return IndexRange.Add(_ranges, range); |
||||
|
} |
||||
|
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
private protected int CommitSelect(IReadOnlyList<IndexRange> ranges) |
||||
|
{ |
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
_ranges ??= new List<IndexRange>(); |
||||
|
return IndexRange.Add(_ranges, ranges); |
||||
|
} |
||||
|
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
private protected int CommitDeselect(IndexRange range) |
||||
|
{ |
||||
|
if (RangesEnabled) |
||||
|
{ |
||||
|
_ranges ??= new List<IndexRange>(); |
||||
|
return IndexRange.Remove(_ranges, range); |
||||
|
} |
||||
|
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
private protected int CommitDeselect(IReadOnlyList<IndexRange> ranges) |
||||
|
{ |
||||
|
if (RangesEnabled && _ranges is object) |
||||
|
{ |
||||
|
return IndexRange.Remove(_ranges, ranges); |
||||
|
} |
||||
|
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
private protected virtual CollectionChangeState OnItemsAdded(int index, IList items) |
||||
|
{ |
||||
|
var count = items.Count; |
||||
|
var shifted = false; |
||||
|
|
||||
|
if (_ranges is object) |
||||
|
{ |
||||
|
List<IndexRange>? toAdd = null; |
||||
|
|
||||
|
for (var i = 0; i < Ranges!.Count; ++i) |
||||
|
{ |
||||
|
var range = Ranges[i]; |
||||
|
|
||||
|
// The range is after the inserted items, need to shift the range right
|
||||
|
if (range.End >= index) |
||||
|
{ |
||||
|
int begin = range.Begin; |
||||
|
|
||||
|
// If the index left of newIndex is inside the range,
|
||||
|
// Split the range and remember the left piece to add later
|
||||
|
if (range.Contains(index - 1)) |
||||
|
{ |
||||
|
range.Split(index - 1, out var before, out _); |
||||
|
(toAdd ??= new List<IndexRange>()).Add(before); |
||||
|
begin = index; |
||||
|
} |
||||
|
|
||||
|
// Shift the range to the right
|
||||
|
_ranges[i] = new IndexRange(begin + count, range.End + count); |
||||
|
shifted = true; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (toAdd is object) |
||||
|
{ |
||||
|
foreach (var range in toAdd) |
||||
|
{ |
||||
|
IndexRange.Add(_ranges, range); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return new CollectionChangeState |
||||
|
{ |
||||
|
ShiftIndex = index, |
||||
|
ShiftDelta = shifted ? count : 0, |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
private protected virtual CollectionChangeState OnItemsRemoved(int index, IList items) |
||||
|
{ |
||||
|
var count = items.Count; |
||||
|
var removedRange = new IndexRange(index, index + count - 1); |
||||
|
bool shifted = false; |
||||
|
List<T>? removed = null; |
||||
|
|
||||
|
if (_ranges is object) |
||||
|
{ |
||||
|
var deselected = new List<IndexRange>(); |
||||
|
|
||||
|
if (IndexRange.Remove(_ranges, removedRange, deselected) > 0) |
||||
|
{ |
||||
|
removed = new List<T>(); |
||||
|
|
||||
|
foreach (var range in deselected) |
||||
|
{ |
||||
|
for (var i = range.Begin; i <= range.End; ++i) |
||||
|
{ |
||||
|
#pragma warning disable CS8604
|
||||
|
removed.Add((T)items[i - index]); |
||||
|
#pragma warning restore CS8604
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (var i = 0; i < Ranges!.Count; ++i) |
||||
|
{ |
||||
|
var existing = Ranges[i]; |
||||
|
|
||||
|
if (existing.End > removedRange.Begin) |
||||
|
{ |
||||
|
_ranges[i] = new IndexRange(existing.Begin - count, existing.End - count); |
||||
|
shifted = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return new CollectionChangeState |
||||
|
{ |
||||
|
ShiftIndex = index, |
||||
|
ShiftDelta = shifted ? -count : 0, |
||||
|
RemovedItems = removed, |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
private protected virtual void OnSourceCollectionChanged(NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
var shiftDelta = 0; |
||||
|
var shiftIndex = -1; |
||||
|
List<T>? removed = null; |
||||
|
|
||||
|
switch (e.Action) |
||||
|
{ |
||||
|
case NotifyCollectionChangedAction.Add: |
||||
|
{ |
||||
|
var change = OnItemsAdded(e.NewStartingIndex, e.NewItems); |
||||
|
shiftIndex = change.ShiftIndex; |
||||
|
shiftDelta = change.ShiftDelta; |
||||
|
break; |
||||
|
} |
||||
|
case NotifyCollectionChangedAction.Remove: |
||||
|
{ |
||||
|
var change = OnItemsRemoved(e.OldStartingIndex, e.OldItems); |
||||
|
shiftIndex = change.ShiftIndex; |
||||
|
shiftDelta = change.ShiftDelta; |
||||
|
removed = change.RemovedItems; |
||||
|
break; |
||||
|
} |
||||
|
case NotifyCollectionChangedAction.Replace: |
||||
|
{ |
||||
|
var removeChange = OnItemsRemoved(e.OldStartingIndex, e.OldItems); |
||||
|
var addChange = OnItemsAdded(e.NewStartingIndex, e.NewItems); |
||||
|
shiftIndex = removeChange.ShiftIndex; |
||||
|
shiftDelta = removeChange.ShiftDelta + addChange.ShiftDelta; |
||||
|
removed = removeChange.RemovedItems; |
||||
|
} |
||||
|
break; |
||||
|
case NotifyCollectionChangedAction.Reset: |
||||
|
OnSourceReset(); |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
if (shiftDelta != 0) |
||||
|
{ |
||||
|
OnIndexesChanged(shiftIndex, shiftDelta); |
||||
|
} |
||||
|
|
||||
|
if (removed is object) |
||||
|
{ |
||||
|
OnSelectionChanged(removed); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private protected struct CollectionChangeState |
||||
|
{ |
||||
|
public int ShiftIndex; |
||||
|
public int ShiftDelta; |
||||
|
public List<T>? RemovedItems; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,135 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Collections.Specialized; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using Avalonia.Threading; |
||||
|
using Avalonia.Utilities; |
||||
|
|
||||
|
#nullable enable |
||||
|
|
||||
|
namespace Avalonia.Controls.Utils |
||||
|
{ |
||||
|
internal interface ICollectionChangedListener |
||||
|
{ |
||||
|
void PreChanged(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e); |
||||
|
void Changed(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e); |
||||
|
void PostChanged(INotifyCollectionChanged sender, NotifyCollectionChangedEventArgs e); |
||||
|
} |
||||
|
|
||||
|
internal class CollectionChangedEventManager : IWeakSubscriber<NotifyCollectionChangedEventArgs> |
||||
|
{ |
||||
|
public static CollectionChangedEventManager Instance { get; } = new CollectionChangedEventManager(); |
||||
|
|
||||
|
private ConditionalWeakTable<INotifyCollectionChanged, List<WeakReference<ICollectionChangedListener>>> _entries = |
||||
|
new ConditionalWeakTable<INotifyCollectionChanged, List<WeakReference<ICollectionChangedListener>>>(); |
||||
|
|
||||
|
private CollectionChangedEventManager() |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
public void AddListener(INotifyCollectionChanged collection, ICollectionChangedListener listener) |
||||
|
{ |
||||
|
collection = collection ?? throw new ArgumentNullException(nameof(collection)); |
||||
|
listener = listener ?? throw new ArgumentNullException(nameof(listener)); |
||||
|
Dispatcher.UIThread.VerifyAccess(); |
||||
|
|
||||
|
if (!_entries.TryGetValue(collection, out var listeners)) |
||||
|
{ |
||||
|
listeners = new List<WeakReference<ICollectionChangedListener>>(); |
||||
|
_entries.Add(collection, listeners); |
||||
|
WeakSubscriptionManager.Subscribe( |
||||
|
collection, |
||||
|
nameof(INotifyCollectionChanged.CollectionChanged), |
||||
|
this); |
||||
|
} |
||||
|
|
||||
|
//if (listeners.Contains(listener))
|
||||
|
//{
|
||||
|
// throw new InvalidOperationException(
|
||||
|
// "Collection listener already added for this collection/listener combination.");
|
||||
|
//}
|
||||
|
|
||||
|
listeners.Add(new WeakReference<ICollectionChangedListener>(listener)); |
||||
|
} |
||||
|
|
||||
|
public void RemoveListener(INotifyCollectionChanged collection, ICollectionChangedListener listener) |
||||
|
{ |
||||
|
collection = collection ?? throw new ArgumentNullException(nameof(collection)); |
||||
|
listener = listener ?? throw new ArgumentNullException(nameof(listener)); |
||||
|
Dispatcher.UIThread.VerifyAccess(); |
||||
|
|
||||
|
if (_entries.TryGetValue(collection, out var listeners)) |
||||
|
{ |
||||
|
for (var i = 0; i < listeners.Count; ++i) |
||||
|
{ |
||||
|
if (listeners[i].TryGetTarget(out var target) && target == listener) |
||||
|
{ |
||||
|
listeners.RemoveAt(i); |
||||
|
|
||||
|
if (listeners.Count == 0) |
||||
|
{ |
||||
|
WeakSubscriptionManager.Unsubscribe( |
||||
|
collection, |
||||
|
nameof(INotifyCollectionChanged.CollectionChanged), |
||||
|
this); |
||||
|
_entries.Remove(collection); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
throw new InvalidOperationException( |
||||
|
"Collection listener not registered for this collection/listener combination."); |
||||
|
} |
||||
|
|
||||
|
void IWeakSubscriber<NotifyCollectionChangedEventArgs>.OnEvent(object sender, NotifyCollectionChangedEventArgs e) |
||||
|
{ |
||||
|
static void Notify( |
||||
|
INotifyCollectionChanged incc, |
||||
|
NotifyCollectionChangedEventArgs args, |
||||
|
List<WeakReference<ICollectionChangedListener>> listeners) |
||||
|
{ |
||||
|
foreach (var l in listeners) |
||||
|
{ |
||||
|
if (l.TryGetTarget(out var target)) |
||||
|
{ |
||||
|
target.PreChanged(incc, args); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
foreach (var l in listeners) |
||||
|
{ |
||||
|
if (l.TryGetTarget(out var target)) |
||||
|
{ |
||||
|
target.Changed(incc, args); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
foreach (var l in listeners) |
||||
|
{ |
||||
|
if (l.TryGetTarget(out var target)) |
||||
|
{ |
||||
|
target.PostChanged(incc, args); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (sender is INotifyCollectionChanged incc && _entries.TryGetValue(incc, out var listeners)) |
||||
|
{ |
||||
|
if (Dispatcher.UIThread.CheckAccess()) |
||||
|
{ |
||||
|
Notify(incc, e, listeners); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var inccCapture = incc; |
||||
|
var eCapture = e; |
||||
|
var listenersCapture = listeners; |
||||
|
Dispatcher.UIThread.Post(() => Notify(inccCapture, eCapture, listenersCapture)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
File diff suppressed because it is too large
File diff suppressed because it is too large
Loading…
Reference in new issue