add ICollectionView changes handling

Author: w-ahmad

src/ItemsSource/CollectionView.Properties.cs

@@ -1,7 +1,6 @@
 using Microsoft.UI.Xaml.Data;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using Windows.Foundation.Collections;
 using WinUI.TableView.Extensions;
 
@@ -19,17 +18,15 @@ public IEnumerable Source
         {
             if (_source == value) return;
 
-            if (_source is not null) DetachPropertyChangedHandlers(_source);
+            DetachCollectionChangedHandlers(_source);
+            DetachPropertyChangedHandlers(_source);
 
             _source = value;
-            AttachPropertyChangedHandlers(_source);
 
-            _collectionChangedListener?.Detach();
+            AttachCollectionChangedHandlers(_source);
+            AttachPropertyChangedHandlers(_source);
 
-            if (_source is INotifyCollectionChanged sourceNcc)
-            {
-                _collectionChangedListener = new(this, sourceNcc, OnSourceCollectionChanged);
-            }
+            CreateItemsCopy(_source);
 
             HandleSourceChanged();
             OnPropertyChanged();

src/ItemsSource/CollectionView.cs

@@ -9,7 +9,6 @@
 using Windows.Foundation;
 using Windows.Foundation.Collections;
 using WinUI.TableView.Extensions;
-using WinUI.TableView.Helpers;
 
 namespace WinUI.TableView;
 
@@ -19,11 +18,11 @@ namespace WinUI.TableView;
 internal partial class CollectionView : ICollectionView, ISupportIncrementalLoading, INotifyPropertyChanged, IComparer<object?>
 {
     private IEnumerable _source = new List<object>();
+    private object[] _itemsCopy = []; // In case the source is ICollection, keep a copy of the items to keep track of removed items.
     private bool _allowLiveShaping;
     private readonly List<object?> _view = [];
     private readonly ObservableCollection<FilterDescription> _filterDescriptions = [];
     private readonly ObservableCollection<SortDescription> _sortDescriptions = [];
-    private CollectionChangedListener<CollectionView>? _collectionChangedListener;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CollectionView"/> class.
@@ -65,6 +64,36 @@ private void OnSortDescriptionsCollectionChanged(object? sender, NotifyCollectio
             HandleSortChanged();
     }
 
+    /// <summary>
+    /// Attaches collection changed handlers to the source collection.
+    /// </summary>
+    private void AttachCollectionChangedHandlers(IEnumerable source)
+    {
+        if (source is INotifyCollectionChanged sourceNcc)
+        {
+            sourceNcc.CollectionChanged += OnSourceCollectionChanged;
+        }
+        else if (source is ICollectionView sourceCV)
+        {
+            sourceCV.VectorChanged += OnSourceVectorChanged;
+        }
+    }
+
+    /// <summary>
+    /// Detaches collection changed handlers from the source collection.
+    /// </summary>
+    private void DetachCollectionChangedHandlers(IEnumerable source)
+    {
+        if (source is INotifyCollectionChanged sourceNcc)
+        {
+            sourceNcc.CollectionChanged -= OnSourceCollectionChanged;
+        }
+        else if (source is ICollectionView sourceCV)
+        {
+            sourceCV.VectorChanged -= OnSourceVectorChanged;
+        }
+    }
+
     /// <summary>
     /// Attaches property changed handlers to the items in the collection.
     /// </summary>
@@ -93,6 +122,75 @@ private void DetachPropertyChangedHandlers(IEnumerable? items)
         }
     }
 
+    /// <summary>
+    /// Handles changes to the source vector.
+    /// </summary>
+    private void OnSourceVectorChanged(IObservableVector<object> sender, IVectorChangedEventArgs args)
+    {
+        var index = (int)args.Index;
+
+        switch (args.CollectionChange)
+        {
+            case CollectionChange.ItemInserted:
+                if (_deferCounter <= 0)
+                {
+                    if (index < Count)
+                    {
+                        var item = sender[index];
+                        AttachPropertyChangedHandlers(new object[] { item });
+                        HandleItemAdded(index, item);
+                    }
+                    else
+                    {
+                        HandleSourceChanged();
+                    }
+                }
+
+                break;
+            case CollectionChange.ItemRemoved:
+                if (_deferCounter <= 0)
+                {
+                    if (index < _itemsCopy.Length)
+                    {
+                        var item = _itemsCopy[index];
+                        DetachPropertyChangedHandlers(new object[] { item });
+                        HandleItemRemoved(index, item);
+                    }
+                    else
+                    {
+                        HandleSourceChanged();
+                    }
+                }
+
+                break;
+            case CollectionChange.ItemChanged:
+            case CollectionChange.Reset:
+                if (_deferCounter <= 0)
+                {
+                    HandleSourceChanged();
+                }
+
+                DetachPropertyChangedHandlers(_itemsCopy);
+                AttachPropertyChangedHandlers(_source);
+
+                break;
+        }
+
+        CreateItemsCopy(_source);
+    }
+
+    /// <summary>
+    /// Creates a copy of the items from the collection if it implements ICollectionView.
+    /// </summary>
+    private void CreateItemsCopy(IEnumerable source)
+    {
+        if (source is ICollectionView collectionView)
+        {
+            _itemsCopy = new object[collectionView.Count];
+            collectionView.CopyTo(_itemsCopy, 0);
+        }
+    }
+
     /// <summary>
     /// Handles changes to the source collection.
     /// </summary>
@@ -138,6 +236,9 @@ private void OnSourceCollectionChanged(object? arg1, NotifyCollectionChangedEven
                     HandleSourceChanged();
                 }
 
+                DetachPropertyChangedHandlers(e.OldItems);
+                AttachPropertyChangedHandlers(_source);
+
                 break;
         }
     }