Merge remote-tracking branch 'origin/master' into fixes/ios-build

src/Avalonia.Controls/Selection/SelectionModel.cs

@@ -436,6 +436,29 @@ namespace Avalonia.Controls.Selection
             }
         }
 
+        private protected override bool IsValidCollectionChange(NotifyCollectionChangedEventArgs e)
+        {
+            if (!base.IsValidCollectionChange(e))
+            {
+                return false;
+            }
+
+            if (ItemsView is object && e.Action == NotifyCollectionChangedAction.Add)
+            {
+                if (e.NewStartingIndex <= _selectedIndex)
+                {
+                    return _selectedIndex + e.NewItems.Count < ItemsView.Count;
+                }
+
+                if (e.NewStartingIndex <= _anchorIndex)
+                {
+                    return _anchorIndex + e.NewItems.Count < ItemsView.Count;
+                }
+            }
+
+            return true;
+        }
+
         protected override void OnSourceCollectionChangeFinished()
         {
             if (_operation is object)

src/Avalonia.Controls/Selection/SelectionNodeBase.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Linq;
 using Avalonia.Controls.Utils;
 
 #nullable enable
@@ -234,6 +235,11 @@ namespace Avalonia.Controls.Selection
             var shiftIndex = -1;
             List<T>? removed = null;
 
+            if (!IsValidCollectionChange(e))
+            {
+                return;
+            }
+
             switch (e.Action)
             {
                 case NotifyCollectionChangedAction.Add:
@@ -276,6 +282,34 @@ namespace Avalonia.Controls.Selection
             }
         }
 
+        private protected virtual bool IsValidCollectionChange(NotifyCollectionChangedEventArgs e)
+        {
+            // If the selection is modified in a CollectionChanged handler before the selection
+            // model's CollectionChanged handler has had chance to run then we can end up with
+            // a selected index that refers to the *new* state of the Source intermixed with
+            // indexes that reference an old state of the source.
+            //
+            // There's not much we can do in this situation, so detect whether shifting the
+            // current selected indexes would result in an invalid index in the source, and if
+            // so bail.
+            //
+            // See unit test Handles_Selection_Made_In_CollectionChanged for more details.
+            if (ItemsView is object &&
+                RangesEnabled &&
+                Ranges.Count > 0 &&
+                e.Action == NotifyCollectionChangedAction.Add)
+            {
+                var lastIndex = Ranges.Last().End;
+
+                if (e.NewStartingIndex <= lastIndex)
+                {
+                    return lastIndex + e.NewItems.Count < ItemsView.Count;
+                }
+            }
+
+            return true;
+        }
+
         private protected struct CollectionChangeState
         {
             public int ShiftIndex;

src/Avalonia.Diagnostics/Diagnostics/ViewModels/ControlDetailsViewModel.cs

@@ -12,12 +12,13 @@ namespace Avalonia.Diagnostics.ViewModels
         private readonly IVisual _control;
         private readonly IDictionary<object, List<PropertyViewModel>> _propertyIndex;
         private AvaloniaPropertyViewModel _selectedProperty;
-        private string _propertyFilter;
 
-        public ControlDetailsViewModel(IVisual control, string propertyFilter)
+        public ControlDetailsViewModel(TreePageViewModel treePage, IVisual control)
         {
             _control = control;
 
+            TreePage = treePage;
+
             var properties = GetAvaloniaProperties(control)
                 .Concat(GetClrProperties(control))
                 .OrderBy(x => x, PropertyComparer.Instance)
@@ -25,7 +26,6 @@ namespace Avalonia.Diagnostics.ViewModels
                 .ToList();
 
             _propertyIndex = properties.GroupBy(x => x.Key).ToDictionary(x => x.Key, x => x.ToList());
-            _propertyFilter = propertyFilter;
 
             var view = new DataGridCollectionView(properties);
             view.GroupDescriptions.Add(new DataGridPathGroupDescription(nameof(AvaloniaPropertyViewModel.Group)));
@@ -43,19 +43,9 @@ namespace Avalonia.Diagnostics.ViewModels
             }
         }
 
-        public DataGridCollectionView PropertiesView { get; }
+        public TreePageViewModel TreePage { get; }
 
-        public string PropertyFilter
-        {
-            get => _propertyFilter;
-            set
-            {
-                if (RaiseAndSetIfChanged(ref _propertyFilter, value))
-                {
-                    PropertiesView.Refresh();
-                }
-            }
-        }
+        public DataGridCollectionView PropertiesView { get; }
 
         public AvaloniaPropertyViewModel SelectedProperty
         {
@@ -137,9 +127,14 @@ namespace Avalonia.Diagnostics.ViewModels
 
         private bool FilterProperty(object arg)
         {
-            if (!string.IsNullOrWhiteSpace(PropertyFilter) && arg is PropertyViewModel property)
+            if (!string.IsNullOrWhiteSpace(TreePage.PropertyFilter) && arg is PropertyViewModel property)
             {
-                return property.Name.IndexOf(PropertyFilter, StringComparison.OrdinalIgnoreCase) != -1;
+                if (TreePage.UseRegexFilter)
+                {
+                    return TreePage.FilterRegex?.IsMatch(property.Name) ?? true;
+                }
+
+                return property.Name.IndexOf(TreePage.PropertyFilter, StringComparison.OrdinalIgnoreCase) != -1;
             }
 
             return true;

src/Avalonia.Diagnostics/Diagnostics/ViewModels/TreePageViewModel.cs

@@ -1,15 +1,20 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text.RegularExpressions;
 using Avalonia.Controls;
-using Avalonia.Controls.Selection;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Diagnostics.ViewModels
 {
-    internal class TreePageViewModel : ViewModelBase, IDisposable
+    internal class TreePageViewModel : ViewModelBase, IDisposable, INotifyDataErrorInfo
     {
+        private readonly Dictionary<string, string> _errors = new Dictionary<string, string>();
         private TreeNode _selectedNode;
         private ControlDetailsViewModel _details;
-        private string _propertyFilter;
+        private string _propertyFilter = string.Empty;
+        private bool _useRegexFilter;
 
         public TreePageViewModel(MainViewModel mainView, TreeNode[] nodes)
         {
@@ -26,15 +31,10 @@ namespace Avalonia.Diagnostics.ViewModels
             get => _selectedNode;
             private set
             {
-                if (Details != null)
-                {
-                    _propertyFilter = Details.PropertyFilter;
-                }
-
                 if (RaiseAndSetIfChanged(ref _selectedNode, value))
                 {
                     Details = value != null ?
-                        new ControlDetailsViewModel(value.Visual, _propertyFilter) :
+                        new ControlDetailsViewModel(this, value.Visual) :
                         null;
                 }
             }
@@ -54,6 +54,63 @@ namespace Avalonia.Diagnostics.ViewModels
             }
         }
 
+        public Regex FilterRegex { get; set; }
+
+        private void UpdateFilterRegex()
+        {
+            void ClearError()
+            {
+                if (_errors.Remove(nameof(PropertyFilter)))
+                {
+                    ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(PropertyFilter)));
+                }
+            }
+
+            if (UseRegexFilter)
+            {
+                try
+                {
+                    FilterRegex = new Regex(PropertyFilter, RegexOptions.Compiled);
+                    ClearError();
+                }
+                catch (Exception exception)
+                {
+                    _errors[nameof(PropertyFilter)] = exception.Message;
+                    ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(PropertyFilter)));
+                }
+            }
+            else
+            {
+                ClearError();
+            }
+        }
+
+        public string PropertyFilter
+        {
+            get => _propertyFilter;
+            set
+            {
+                if (RaiseAndSetIfChanged(ref _propertyFilter, value))
+                {
+                    UpdateFilterRegex();
+                    Details.PropertiesView.Refresh();
+                }
+            }
+        }
+
+        public bool UseRegexFilter
+        {
+            get => _useRegexFilter;
+            set
+            {
+                if (RaiseAndSetIfChanged(ref _useRegexFilter, value))
+                {
+                    UpdateFilterRegex();
+                    Details.PropertiesView.Refresh();
+                }
+            }
+        }
+
         public void Dispose()
         {
             foreach (var node in Nodes)
@@ -130,5 +187,17 @@ namespace Avalonia.Diagnostics.ViewModels
 
             return null;
         }
+
+        public IEnumerable GetErrors(string propertyName)
+        {
+            if (_errors.TryGetValue(propertyName, out var error))
+            {
+                yield return error;
+            }
+        }
+
+        public bool HasErrors => _errors.Count > 0;
+
+        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
     }
 }

src/Avalonia.Diagnostics/Diagnostics/Views/ControlDetailsView.xaml

@@ -2,24 +2,31 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:conv="clr-namespace:Avalonia.Diagnostics.Converters"
              x:Class="Avalonia.Diagnostics.Views.ControlDetailsView">
-  <Grid ColumnDefinitions="*">
-    <DockPanel Grid.Column="0">
-      <TextBox DockPanel.Dock="Top"
-               BorderThickness="0"
-               Text="{Binding PropertyFilter}"
-               Watermark="Filter properties"/>
-      <DataGrid Items="{Binding PropertiesView}"
-                BorderThickness="0"
-                RowBackground="Transparent"
-                SelectedItem="{Binding SelectedProperty, Mode=TwoWay}"
-                CanUserResizeColumns="true">
-        <DataGrid.Columns>
-          <DataGridTextColumn Header="Property" Binding="{Binding Name}" IsReadOnly="True"/>
-          <DataGridTextColumn Header="Value" Binding="{Binding Value}"/>
-          <DataGridTextColumn Header="Type" Binding="{Binding Type}"/>
-          <DataGridTextColumn Header="Priority" Binding="{Binding Priority}" IsReadOnly="True"/>
-        </DataGrid.Columns>
-      </DataGrid>
-    </DockPanel>
+  <Grid ColumnDefinitions="*,Auto" RowDefinitions="Auto,*">
+
+    <TextBox Grid.Row="0" Grid.Column="0"
+             BorderThickness="0"
+             Text="{Binding TreePage.PropertyFilter}"
+             Watermark="Filter properties" />
+
+    <CheckBox Grid.Row="0" 
+              Grid.Column="1" 
+              Content="Regex" 
+              IsChecked="{Binding TreePage.UseRegexFilter}"/>
+
+    <DataGrid Items="{Binding PropertiesView}"
+              Grid.Row="1" Grid.ColumnSpan="2"
+              BorderThickness="0"
+              RowBackground="Transparent"
+              SelectedItem="{Binding SelectedProperty, Mode=TwoWay}"
+              CanUserResizeColumns="true">
+      <DataGrid.Columns>
+        <DataGridTextColumn Header="Property" Binding="{Binding Name}" IsReadOnly="True" />
+        <DataGridTextColumn Header="Value" Binding="{Binding Value}" />
+        <DataGridTextColumn Header="Type" Binding="{Binding Type}" />
+        <DataGridTextColumn Header="Priority" Binding="{Binding Priority}" IsReadOnly="True" />
+      </DataGrid.Columns>
+    </DataGrid>
+
   </Grid>
 </UserControl>

tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs

@@ -1335,6 +1335,47 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.False(model.SingleSelect);
         }
 
+        [Fact]
+        public void Does_The_Best_It_Can_With_AutoSelecting_ViewModel()
+        {
+            // Tests the following scenario:
+            //
+            // - Items changes from empty to having 1 item
+            // - ViewModel auto-selects item 0 in CollectionChanged
+            // - SelectionModel receives CollectionChanged
+            // - And so adjusts the selected item from 0 to 1, which is past the end of the items.
+            //
+            // There's not much we can do about this situation because the order in which
+            // CollectionChanged handlers are called can't be known (the problem also exists with
+            // WPF). The best we can do is not select an invalid index.
+            var vm = new SelectionViewModel();
+
+            vm.Items.CollectionChanged += (s, e) =>
+            {
+                if (vm.SelectedIndex == -1 && vm.Items.Count > 0)
+                {
+                    vm.SelectedIndex = 0;
+                }
+            };
+
+            var target = new ListBox
+            {
+                [!ListBox.ItemsProperty] = new Binding("Items"),
+                [!ListBox.SelectedIndexProperty] = new Binding("SelectedIndex"),
+                DataContext = vm,
+            };
+
+            Prepare(target);
+
+            vm.Items.Add("foo");
+            vm.Items.Add("bar");
+
+            Assert.Equal(0, target.SelectedIndex);
+            Assert.Equal(new[] { 0 }, target.Selection.SelectedIndexes);
+            Assert.Equal("foo", target.SelectedItem);
+            Assert.Equal(new[] { "foo" }, target.SelectedItems);
+        }
+
         private static void Prepare(SelectingItemsControl target)
         {
             var root = new TestRoot
@@ -1397,6 +1438,28 @@ namespace Avalonia.Controls.UnitTests.Primitives
             public int SelectedIndex { get; set; }
         }
 
+        private class SelectionViewModel : NotifyingBase
+        {
+            private int _selectedIndex = -1;
+
+            public SelectionViewModel()
+            {
+                Items = new ObservableCollection<string>();
+            }
+
+            public int SelectedIndex
+            {
+                get => _selectedIndex;
+                set
+                {
+                    _selectedIndex = value;
+                    RaisePropertyChanged();
+                }
+            }
+
+            public ObservableCollection<string> Items { get; }
+        }
+
         private class RootWithItems : TestRoot
         {
             public List<string> Items { get; set; } = new List<string>() { "a", "b", "c", "d", "e" };

tests/Avalonia.Controls.UnitTests/Selection/SelectionModelTests_Multiple.cs

@@ -1230,6 +1230,38 @@ namespace Avalonia.Controls.UnitTests.Selection
                 Assert.Equal(1, resetRaised);
                 Assert.Equal(1, selectedIndexRaised);
             }
+
+            [Fact]
+            public void Handles_Selection_Made_In_CollectionChanged()
+            {
+                // Tests the following scenario:
+                //
+                // - Items changes from empty to having 2 items
+                // - ViewModel auto-selects range 0..1 in CollectionChanged
+                // - SelectionModel receives CollectionChanged
+                // - And so adjusts the selected item from 0..1 to 2..4, which is past the end of
+                //   the items.
+                //
+                // There's not much we can do about this situation because the order in which
+                // CollectionChanged handlers are called can't be known (the problem also exists with
+                // WPF). The best we can do is not select an invalid index.
+                var target = CreateTarget(createData: false);
+                var data = new AvaloniaList<string>();
+
+                data.CollectionChanged += (s, e) =>
+                {
+                    target.SelectRange(0, 1);
+                };
+
+                target.Source = data;
+                data.AddRange(new[] { "foo", "bar" });
+
+                Assert.Equal(0, target.SelectedIndex);
+                Assert.Equal(new[] { 0, 1 }, target.SelectedIndexes);
+                Assert.Equal("foo", target.SelectedItem);
+                Assert.Equal(new[] { "foo", "bar" }, target.SelectedItems);
+                Assert.Equal(0, target.AnchorIndex);
+            }
         }
 
         public class BatchUpdate

tests/Avalonia.Controls.UnitTests/Selection/SelectionModelTests_Single.cs

@@ -1052,6 +1052,37 @@ namespace Avalonia.Controls.UnitTests.Selection
                 Assert.Equal(1, resetRaised);
                 Assert.Equal(1, selectedIndexRaised);
             }
+
+            [Fact]
+            public void Handles_Selection_Made_In_CollectionChanged()
+            {
+                // Tests the following scenario:
+                //
+                // - Items changes from empty to having 1 item
+                // - ViewModel auto-selects item 0 in CollectionChanged
+                // - SelectionModel receives CollectionChanged
+                // - And so adjusts the selected item from 0 to 1, which is past the end of the items.
+                //
+                // There's not much we can do about this situation because the order in which
+                // CollectionChanged handlers are called can't be known (the problem also exists with
+                // WPF). The best we can do is not select an invalid index.
+                var target = CreateTarget(createData: false);
+                var data = new AvaloniaList<string>();
+
+                data.CollectionChanged += (s, e) =>
+                {
+                    target.Select(0);
+                };
+
+                target.Source = data;
+                data.Add("foo");
+
+                Assert.Equal(0, target.SelectedIndex);
+                Assert.Equal(new[] { 0 }, target.SelectedIndexes);
+                Assert.Equal("foo", target.SelectedItem);
+                Assert.Equal(new[] { "foo" }, target.SelectedItems);
+                Assert.Equal(0, target.AnchorIndex);
+            }
         }
 
         public class BatchUpdate