Allow to bind to converter parameter

Author: pr8x

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

@@ -1,6 +1,5 @@
 using System;
 using System.Globalization;
-using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using Avalonia.Data.Converters;
 using Avalonia.Logging;
@@ -20,8 +19,10 @@ public class BindingExpression : LightweightObservableBase<object?>, ISubject<ob
         private readonly object? _fallbackValue;
         private readonly object? _targetNullValue;
         private readonly BindingPriority _priority;
-        InnerListener? _innerListener;
-        WeakReference<object>? _value;
+        private readonly IDisposable? _converterParameterSubscription;
+        private WeakReference<object?>? _converterParameter; 
+        private InnerListener? _innerListener;
+        private WeakReference<object>? _value;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ExpressionObserver"/> class.
@@ -84,11 +85,36 @@ public BindingExpression(
 
             _inner = inner;
             _targetType = targetType;
-            Converter = converter;
-            ConverterParameter = converterParameter;
             _fallbackValue = fallbackValue;
             _targetNullValue = targetNullValue;
             _priority = priority;
+
+            Converter = converter;
+
+            if (converterParameter is InstancedBinding binding)
+            {
+                if (binding.Mode == BindingMode.TwoWay)
+                {
+                    throw new InvalidOperationException("Two way binding to converter parameter is not supported");
+                }
+
+                _converterParameterSubscription = binding.Observable?.Subscribe(cp =>
+                {
+                    _converterParameter = new WeakReference<object?>(cp);
+
+                    if (_value != null &&
+                        _value.TryGetTarget(out var currentValue))
+                    {
+                        //Force update binding to use new converter parameter
+                        _innerListener?.OnNext(currentValue);
+                    }
+
+                });
+            }
+            else
+            {
+                _converterParameter = new WeakReference<object?>(converterParameter);
+            }
         }
 
         /// <summary>
@@ -99,7 +125,19 @@ public BindingExpression(
         /// <summary>
         /// Gets a parameter to pass to <see cref="Converter"/>.
         /// </summary>
-        public object? ConverterParameter { get; }
+        public object? ConverterParameter
+        {
+            get
+            {
+                if (_converterParameter != null && 
+                    _converterParameter.TryGetTarget(out var cp))
+                {
+                    return cp;
+                }
+
+                return null;
+            }
+        }
 
         /// <inheritdoc/>
         string? IDescription.Description => _inner.Expression;
@@ -182,8 +220,17 @@ public void OnNext(object? value)
             }
         }
 
-        protected override void Initialize() => _innerListener = new InnerListener(this);
-        protected override void Deinitialize() => _innerListener?.Dispose();
+        protected override void Initialize()
+        {
+            _innerListener = new InnerListener(this);
+        }
+
+        protected override void Deinitialize()
+        {
+            _innerListener?.Dispose();
+
+            _converterParameterSubscription?.Dispose();
+        }
 
         protected override void Subscribed(IObserver<object> observer, bool first)
         {

src/Markup/Avalonia.Markup/Data/BindingBase.cs

@@ -118,13 +118,23 @@ protected abstract ExpressionObserver CreateExpressionObserver(
                 converter = new StringFormatValueConverter(StringFormat!, converter);
             }
 
+            var converterParameter = ConverterParameter;
+
+            if (ConverterParameter is BindingBase converterParameterBinding)
+            {
+                converterParameter = converterParameterBinding.Initiate(
+                    target, 
+                    null, 
+                    anchor);
+            }
+
             var subject = new BindingExpression(
                 observer,
                 targetType,
                 fallback,
                 TargetNullValue,
                 converter ?? DefaultValueConverter.Instance,
-                ConverterParameter,
+                converterParameter,
                 Priority);
 
             return new InstancedBinding(subject, Mode, Priority);

tests/Avalonia.Markup.UnitTests/Data/BindingTests.cs

@@ -372,6 +372,34 @@ public void Should_Pass_ConverterParameter_To_Supplied_Converter()
             Assert.Same("foo", ((BindingExpression)result).ConverterParameter);
         }
 
+
+        [Fact]
+        public void Should_Pass_ConverterParameter_Binding_To_Supplied_Converter()
+        {
+            var target = new TextBlock();
+            var converter = new Mock<IValueConverter>();
+
+            var source = new Source { Foo = "foo" };
+
+            var binding = new Binding
+            {
+                Converter = converter.Object,
+                ConverterParameter = new Binding(nameof(source.Foo))
+                {
+                    Source = source
+                },
+                Path = "Bar",
+            };
+
+            var result = binding.Initiate(target, TextBox.TextProperty).Subject;
+
+            Assert.Same("foo", ((BindingExpression)result).ConverterParameter);
+
+            source.Foo = "foo2";
+
+            Assert.Same("foo2", ((BindingExpression)result).ConverterParameter);
+        }
+
         [Fact]
         public void Should_Return_FallbackValue_When_Path_Not_Resolved()
         {