Merge branch 'main' into fix/parallels-vulkan-fallback

Author: orisson003

src/Avalonia.Base/Data/Core/BindingExpression.cs

@@ -221,6 +221,18 @@ internal void OnNodeValueChanged(int nodeIndex, object? value, Exception? dataVa
                 var forceUpdate = _mode == BindingMode.OneWay || _updateTargetDepth > 0;
                 ConvertAndPublishValue(value, error, forceUpdate);
             }
+            else if (IsDataValidationEnabled)
+            {
+                // In OneWayToSource mode the value must not be published to the target, but any
+                // data validation error produced when writing to the source still has to be
+                // published (or cleared) so that it can be displayed (issue #8235). Publishing
+                // UnchangedValue leaves the target's value untouched.
+                var error = dataValidationError is not null ?
+                    new BindingError(dataValidationError, BindingErrorType.DataValidationError) :
+                    null;
+
+                PublishValue(UnchangedValue, error);
+            }
         }
         else if (_mode == BindingMode.OneWayToSource && nodeIndex == _nodes.Count - 2 && value is not null)
         {

src/Avalonia.Base/Data/Core/ExpressionNodes/StreamNode.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Text;
 using Avalonia.Data.Core.Plugins;
+using Avalonia.Reactive;
 
 namespace Avalonia.Data.Core.ExpressionNodes;
 
@@ -30,7 +31,7 @@ protected override void OnSourceChanged(object? source, Exception? dataValidatio
 
         if (_plugin.Start(new(source)) is { } accessor)
         {
-            _subscription = accessor.Subscribe(this);
+            _subscription = WeakObserverSubscription<object?>.Subscribe(accessor, this);
         }
         else
         {

src/Avalonia.Base/Data/Core/UntypedObservableBindingExpression.cs

@@ -1,4 +1,5 @@
 using System;
+using Avalonia.Reactive;
 
 namespace Avalonia.Data.Core;
 
@@ -19,7 +20,7 @@ public UntypedObservableBindingExpression(
 
     protected override void StartCore()
     {
-        _subscription = _observable.Subscribe(this);
+        _subscription = WeakObserverSubscription<object?>.Subscribe(_observable, this);
     }
 
     protected override void StopCore()

src/Avalonia.Base/Reactive/WeakObserverSubscription.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Avalonia.Reactive;
+
+/// <summary>
+/// Subscribes an <see cref="IObserver{T}"/> to an <see cref="IObservable{T}"/> such that the
+/// observable holds only a weak reference to the observer, disposing the subscription once the
+/// observer has been collected.
+/// </summary>
+/// <typeparam name="T">The type of the elements in the sequence.</typeparam>
+internal sealed class WeakObserverSubscription<T> : IObserver<T>, IDisposable
+{
+    private readonly WeakReference<IObserver<T>> _observer;
+    private IDisposable? _subscription;
+
+    private WeakObserverSubscription(IObserver<T> observer)
+    {
+        _observer = new WeakReference<IObserver<T>>(observer);
+    }
+
+    /// <summary>
+    /// Subscribes <paramref name="observer"/> to <paramref name="observable"/> via a weak reference.
+    /// </summary>
+    /// <returns>
+    /// A disposable which unsubscribes from the observable when disposed. The caller must keep it
+    /// alive for as long as the subscription is required.
+    /// </returns>
+    public static IDisposable Subscribe(IObservable<T> observable, IObserver<T> observer)
+    {
+        var subscription = new WeakObserverSubscription<T>(observer);
+        subscription._subscription = observable.Subscribe(subscription);
+        return subscription;
+    }
+
+    public void OnCompleted()
+    {
+        if (TryGetObserver(out var observer))
+            observer.OnCompleted();
+    }
+
+    public void OnError(Exception error)
+    {
+        if (TryGetObserver(out var observer))
+            observer.OnError(error);
+    }
+
+    public void OnNext(T value)
+    {
+        if (TryGetObserver(out var observer))
+            observer.OnNext(value);
+    }
+
+    public void Dispose()
+    {
+        _subscription?.Dispose();
+        _subscription = null;
+    }
+
+    private bool TryGetObserver([NotNullWhen(true)] out IObserver<T>? observer)
+    {
+        if (_observer.TryGetTarget(out observer))
+            return true;
+
+        // The observer has been collected; unsubscribe from the observable.
+        Dispose();
+        return false;
+    }
+}

src/Avalonia.Controls/SelectableTextBlock.cs

@@ -539,9 +539,28 @@ private void OnTextOrInlinesChanged()
 
         private void UpdateCommandStates()
         {
-            var text = GetSelection();
+            CanCopy = HasSelection();
+        }
+
+        /// <summary>
+        /// Reports the same emptiness conditions as <see cref="GetSelection"/>, without building
+        /// the selected string.
+        /// </summary>
+        private bool HasSelection()
+        {
+            var selectionStart = SelectionStart;
+            var selectionEnd = SelectionEnd;
+            var start = Math.Min(selectionStart, selectionEnd);
+            var end = Math.Max(selectionStart, selectionEnd);
+
+            if (start == end)
+            {
+                return false;
+            }
+
+            var textLength = (HasComplexContent ? Inlines?.Text : Text)?.Length ?? 0;
 
-            CanCopy = !string.IsNullOrEmpty(text);
+            return textLength > 0 && end <= textLength;
         }
 
         private string GetSelection()

src/Avalonia.Controls/TextBox.cs

@@ -1112,10 +1112,9 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
 
         private void UpdateCommandStates()
         {
-            var text = GetSelection();
-            var isSelectionNullOrEmpty = string.IsNullOrEmpty(text);
-            CanCopy = !IsPasswordBox && !isSelectionNullOrEmpty;
-            CanCut = !IsPasswordBox && !isSelectionNullOrEmpty && !IsReadOnly;
+            var hasSelection = HasSelection();
+            CanCopy = !IsPasswordBox && hasSelection;
+            CanCut = !IsPasswordBox && hasSelection && !IsReadOnly;
             CanPaste = !IsReadOnly;
         }
 
@@ -2450,6 +2449,24 @@ internal bool DeleteSelection()
             return false;
         }
 
+        /// <summary>
+        /// Reports the same emptiness conditions as <see cref="GetSelection"/>, without building
+        /// the selected string.
+        /// </summary>
+        private bool HasSelection()
+        {
+            var (start, end) = GetSelectionRange();
+
+            if (start == end)
+            {
+                return false;
+            }
+
+            var textLength = Text?.Length ?? 0;
+
+            return textLength > 0 && end <= textLength;
+        }
+
         private string GetSelection()
         {
             var text = Text;

tests/Avalonia.Base.UnitTests/Data/Core/BindingExpressionTests.DataValidation.cs

@@ -271,6 +271,102 @@ public void Indei_Validation_Updates_Data_Validation_When_Writing_To_Source()
         GC.KeepAlive(data);
     }
 
+    [Fact]
+    public void Indei_Validation_Updates_Data_Validation_When_Writing_To_Source_OneWayToSource()
+    {
+        // Issue #8235: validation errors should be displayed for OneWayToSource bindings.
+        var data = new IndeiViewModel();
+        var target = CreateTargetWithSource(
+            data,
+            o => o.MustBePositive,
+            enableDataValidation: true,
+            mode: BindingMode.OneWayToSource);
+
+        Assert.Equal(0, data.MustBePositive);
+        AssertNoError(target, TargetClass.IntProperty);
+
+        target.Int = 5;
+
+        Assert.Equal(5, data.MustBePositive);
+        AssertNoError(target, TargetClass.IntProperty);
+
+        target.Int = -5;
+
+        Assert.Equal(-5, data.MustBePositive);
+        AssertBindingError(target, TargetClass.IntProperty, new DataValidationException("Must be positive"), BindingErrorType.DataValidationError);
+
+        target.Int = 5;
+
+        Assert.Equal(5, data.MustBePositive);
+        AssertNoError(target, TargetClass.IntProperty);
+
+        GC.KeepAlive(data);
+    }
+
+    [Fact]
+    public void DataAnnotations_Validation_Updates_Data_Validation_When_Writing_To_Source_OneWayToSource()
+    {
+        // Issue #8235: validation attributes should be displayed for OneWayToSource bindings.
+        if (!BindingPlugins.DataValidators.Any(x => x is DataAnnotationsValidationPlugin))
+            BindingPlugins.DataValidators.Insert(0, new DataAnnotationsValidationPlugin());
+
+        var data = new DataAnnotationsViewModel();
+        var target = CreateTargetWithSource(
+            data,
+            o => o.MaxLengthString,
+            enableDataValidation: true,
+            mode: BindingMode.OneWayToSource);
+
+        target.String = "1234";
+
+        Assert.Equal("1234", data.MaxLengthString);
+        AssertNoError(target, TargetClass.StringProperty);
+
+        target.String = "123456";
+
+        Assert.Equal("123456", data.MaxLengthString);
+        AssertBindingError(
+            target,
+            TargetClass.StringProperty,
+            new DataValidationException("Too long!"),
+            BindingErrorType.DataValidationError);
+
+        GC.KeepAlive(data);
+    }
+
+    [Fact]
+    public void Conversion_Error_Is_Cleared_When_Value_Becomes_Valid_OneWayToSource()
+    {
+        // Issue #15378.
+        var data = new ViewModel();
+        var target = CreateTargetWithSource(
+            data,
+            o => o.DoubleValue,
+            targetProperty: TargetClass.ObjectProperty,
+            enableDataValidation: true,
+            mode: BindingMode.OneWayToSource);
+
+        target.Object = 5.0;
+
+        Assert.Equal(5.0, data.DoubleValue);
+        AssertNoError(target, TargetClass.ObjectProperty);
+
+        target.Object = null;
+
+        AssertBindingError(
+            target,
+            TargetClass.ObjectProperty,
+            new InvalidCastException("Could not convert '(null)' (null) to System.Double."),
+            BindingErrorType.DataValidationError);
+
+        target.Object = 5.0;
+
+        Assert.Equal(5.0, data.DoubleValue);
+        AssertNoError(target, TargetClass.ObjectProperty);
+
+        GC.KeepAlive(data);
+    }
+
     [Fact]
     public void Does_Not_Subscribe_To_Indei_Of_Intermediate_Object_In_Chain()
     {
@@ -445,6 +541,15 @@ public string? RequiredString
             get { return _requiredString; }
             set { _requiredString = value; RaisePropertyChanged(); }
         }
+
+        private string? _maxLengthString;
+
+        [MaxLength(5, ErrorMessage = "Too long!")]
+        public string? MaxLengthString
+        {
+            get { return _maxLengthString; }
+            set { _maxLengthString = value; RaisePropertyChanged(); }
+        }
     }
 
     private class IndeiDataAnnotationsViewModel : IndeiBase