Merge pull request #22 from wieslawsoltes/BindingTriggerBehavior

Binding trigger behavior

Author: wieslawsoltes

samples/BehaviorsTestApplication/Views/MainView.axaml

@@ -22,6 +22,9 @@
     <TabItem Header="DataTriggerBehavior">
       <pages:DataTriggerBehaviorView />
     </TabItem>
+    <TabItem Header="BindingTriggerBehavior">
+      <pages:BindingTriggerBehaviorView />
+    </TabItem>
     <TabItem Header="ValueChangedTriggerBehavior">
       <pages:ValueChangedTriggerBehaviorView />
     </TabItem>

samples/BehaviorsTestApplication/Views/Pages/BindingTriggerBehaviorView.axaml

@@ -0,0 +1,47 @@
+<UserControl x:Class="BehaviorsTestApplication.Views.Pages.BindingTriggerBehaviorView"
+             xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:vm="using:BehaviorsTestApplication.ViewModels"
+             x:DataType="vm:MainWindowViewModel"
+             mc:Ignorable="d" d:DesignWidth="600" d:DesignHeight="450">
+  <Design.DataContext>
+    <vm:MainWindowViewModel />
+  </Design.DataContext>
+  <Grid RowDefinitions="*,Auto">
+    <Rectangle Name="DataTriggerRectangle"
+               Grid.Row="0" Margin="5"
+               Fill="{DynamicResource BlueBrush}"
+               Stroke="{DynamicResource GrayBrush}"
+               StrokeThickness="5">
+      <Interaction.Behaviors>
+        <BindingTriggerBehavior Binding="{Binding #Slider.Value}"
+                                ComparisonCondition="GreaterThan"
+                                Value="50">
+          <ChangePropertyAction TargetObject="DataTriggerRectangle"
+                                PropertyName="Fill"
+                                Value="{DynamicResource YellowBrush}" />
+        </BindingTriggerBehavior>
+        <BindingTriggerBehavior Binding="{Binding #Slider.Value}"
+                                ComparisonCondition="LessThanOrEqual"
+                                Value="50">
+          <ChangePropertyAction TargetObject="DataTriggerRectangle"
+                                PropertyName="Fill"
+                                Value="{DynamicResource BlueBrush}" />
+        </BindingTriggerBehavior>
+      </Interaction.Behaviors>
+    </Rectangle>
+    <StackPanel Grid.Row="1"
+                Margin="5,0,5,5"
+                Orientation="Horizontal"
+                HorizontalAlignment="Center"
+                VerticalAlignment="Center">
+      <TextBlock Text="{Binding #Slider.Value}"
+                 VerticalAlignment="Center"
+                 Width="50"
+                 Foreground="{DynamicResource GrayBrush}" />
+      <Slider Name="Slider" Width="400" IsSnapToTickEnabled="True" TickFrequency="1" />
+    </StackPanel>
+  </Grid>
+</UserControl>

samples/BehaviorsTestApplication/Views/Pages/BindingTriggerBehaviorView.axaml.cs

@@ -0,0 +1,17 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace BehaviorsTestApplication.Views.Pages;
+
+public partial class BindingTriggerBehaviorView : UserControl
+{
+    public BindingTriggerBehaviorView()
+    {
+        InitializeComponent();
+    }
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}

src/Avalonia.Xaml.Interactions.Custom/Core/BindingTriggerBehavior.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.Data;
+using Avalonia.Reactive;
+using Avalonia.Xaml.Interactivity;
+
+namespace Avalonia.Xaml.Interactions.Custom;
+
+/// <summary>
+/// A behavior that performs actions when the bound data meets a specified condition.
+/// </summary>
+[RequiresUnreferencedCode("This functionality is not compatible with trimming.")]
+public class BindingTriggerBehavior : StyledElementTrigger
+{
+    /// <summary>
+    /// Identifies the <seealso cref="Binding"/> avalonia property.
+    /// </summary>
+    public static readonly StyledProperty<IBinding?> BindingProperty =
+        AvaloniaProperty.Register<BindingTriggerBehavior, IBinding?>(nameof(Binding));
+
+    /// <summary>
+    /// Identifies the <seealso cref="ComparisonCondition"/> avalonia property.
+    /// </summary>
+    public static readonly StyledProperty<ComparisonConditionType> ComparisonConditionProperty =
+        AvaloniaProperty.Register<BindingTriggerBehavior, ComparisonConditionType>(nameof(ComparisonCondition));
+
+    /// <summary>
+    /// Identifies the <seealso cref="Value"/> avalonia property.
+    /// </summary>
+    public static readonly StyledProperty<object?> ValueProperty =
+        AvaloniaProperty.Register<BindingTriggerBehavior, object?>(nameof(Value));
+
+    private static readonly StyledProperty<object?> BindingValueProperty =
+        AvaloniaProperty.Register<BindingTriggerBehavior, object?>(nameof(BindingValue));
+
+    private IDisposable? _dispose;
+
+    /// <summary>
+    /// Gets or sets the bound object that the <see cref="BindingTriggerBehavior"/> will listen to. This is an avalonia property.
+    /// </summary>
+    [AssignBinding]
+    public IBinding? Binding
+    {
+        get => GetValue(BindingProperty);
+        set => SetValue(BindingProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the type of comparison to be performed between <see cref="BindingTriggerBehavior.Binding"/> and <see cref="BindingTriggerBehavior.Value"/>. This is an avalonia property.
+    /// </summary>
+    public ComparisonConditionType ComparisonCondition
+    {
+        get => GetValue(ComparisonConditionProperty);
+        set => SetValue(ComparisonConditionProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the value to be compared with the value of <see cref="BindingTriggerBehavior.Binding"/>. This is an avalonia property.
+    /// </summary>
+    public object? Value
+    {
+        get => GetValue(ValueProperty);
+        set => SetValue(ValueProperty, value);
+    }
+
+    private object? BindingValue
+    {
+        get => GetValue(BindingValueProperty);
+        set => SetValue(BindingValueProperty, value);
+    }
+    
+    static BindingTriggerBehavior()
+    {
+        ComparisonConditionProperty.Changed.Subscribe(
+            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<ComparisonConditionType>>(OnValueChanged));
+
+        ValueProperty.Changed.Subscribe(
+            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<object?>>(OnValueChanged));
+
+        BindingValueProperty.Changed.Subscribe(
+            new AnonymousObserver<AvaloniaPropertyChangedEventArgs<object?>>(OnValueChanged));
+    }
+
+    /// <inheritdoc />
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == BindingProperty)
+        {
+            _dispose?.Dispose();
+
+            var newValue = change.GetNewValue<IBinding?>();
+            if (newValue is not null)
+            {
+                _dispose = Bind(BindingValueProperty, newValue);
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void OnDetaching()
+    {
+        base.OnDetaching();
+
+        _dispose?.Dispose();
+    }
+
+    private static void OnValueChanged(AvaloniaPropertyChangedEventArgs args)
+    {
+        if (args.Sender is not BindingTriggerBehavior behavior || behavior.AssociatedObject is null)
+        {
+            return;
+        }
+
+        if (!behavior.IsEnabled)
+        {
+            return;
+        }
+
+        // NOTE: In UWP version binding null check is not present but Avalonia throws exception as Bindings are null when first initialized.
+        var binding = behavior.BindingValue;
+        if (binding is not null)
+        {
+            // Some value has changed--either the binding value, reference value, or the comparison condition. Re-evaluate the equation.
+            if (ComparisonConditionTypeHelper.Compare(behavior.BindingValue, behavior.ComparisonCondition,
+                    behavior.Value))
+            {
+                Interaction.ExecuteActions(behavior.AssociatedObject, behavior.Actions, args);
+            }
+        }
+    }
+}

src/Avalonia.Xaml.Interactions/Core/DataTriggerBehavior.cs

@@ -1,6 +1,4 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
 using Avalonia.Reactive;
 using Avalonia.Xaml.Interactivity;
 
@@ -69,95 +67,6 @@ static DataTriggerBehavior()
             new AnonymousObserver<AvaloniaPropertyChangedEventArgs<object?>>(OnValueChanged));
     }
 
-    private static bool Compare(object? leftOperand, ComparisonConditionType operatorType, object? rightOperand)
-    {
-        if (leftOperand is not null && rightOperand is not null)
-        {
-            var value = rightOperand.ToString();
-            var destinationType = leftOperand.GetType();
-            if (value is not null)
-            {
-                rightOperand = TypeConverterHelper.Convert(value, destinationType);
-            }
-        }
-
-        var leftComparableOperand = leftOperand as IComparable;
-        var rightComparableOperand = rightOperand as IComparable;
-        if (leftComparableOperand is not null && rightComparableOperand is not null)
-        {
-            return EvaluateComparable(leftComparableOperand, operatorType, rightComparableOperand);
-        }
-
-        switch (operatorType)
-        {
-            case ComparisonConditionType.Equal:
-                return Equals(leftOperand, rightOperand);
-
-            case ComparisonConditionType.NotEqual:
-                return !Equals(leftOperand, rightOperand);
-
-            case ComparisonConditionType.LessThan:
-            case ComparisonConditionType.LessThanOrEqual:
-            case ComparisonConditionType.GreaterThan:
-            case ComparisonConditionType.GreaterThanOrEqual:
-            {
-                throw leftComparableOperand switch
-                {
-                    null when rightComparableOperand is null => new ArgumentException(string.Format(
-                        CultureInfo.CurrentCulture,
-                        "Binding property of type {0} and Value property of type {1} cannot be used with operator {2}.",
-                        leftOperand?.GetType().Name ?? "null", rightOperand?.GetType().Name ?? "null",
-                        operatorType.ToString())),
-                    null => new ArgumentException(string.Format(CultureInfo.CurrentCulture,
-                        "Binding property of type {0} cannot be used with operator {1}.",
-                        leftOperand?.GetType().Name ?? "null", operatorType.ToString())),
-                    _ => new ArgumentException(string.Format(CultureInfo.CurrentCulture,
-                        "Value property of type {0} cannot be used with operator {1}.",
-                        rightOperand?.GetType().Name ?? "null", operatorType.ToString()))
-                };
-            }
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    /// Evaluates both operands that implement the IComparable interface.
-    /// </summary>
-    private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
-    {
-        object? convertedOperand = null;
-        try
-        {
-            convertedOperand = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
-        }
-        catch (FormatException)
-        {
-            // FormatException: Convert.ChangeType("hello", typeof(double), ...);
-        }
-        catch (InvalidCastException)
-        {
-            // InvalidCastException: Convert.ChangeType(4.0d, typeof(Rectangle), ...);
-        }
-
-        if (convertedOperand is null)
-        {
-            return operatorType == ComparisonConditionType.NotEqual;
-        }
-
-        var comparison = leftOperand.CompareTo((IComparable)convertedOperand);
-        return operatorType switch
-        {
-            ComparisonConditionType.Equal => comparison == 0,
-            ComparisonConditionType.NotEqual => comparison != 0,
-            ComparisonConditionType.LessThan => comparison < 0,
-            ComparisonConditionType.LessThanOrEqual => comparison <= 0,
-            ComparisonConditionType.GreaterThan => comparison > 0,
-            ComparisonConditionType.GreaterThanOrEqual => comparison >= 0,
-            _ => false
-        };
-    }
-
     private static void OnValueChanged(AvaloniaPropertyChangedEventArgs args)
     {
         if (args.Sender is not DataTriggerBehavior behavior || behavior.AssociatedObject is null)
@@ -175,7 +84,7 @@ private static void OnValueChanged(AvaloniaPropertyChangedEventArgs args)
         if (binding is not null)
         {
             // Some value has changed--either the binding value, reference value, or the comparison condition. Re-evaluate the equation.
-            if (Compare(behavior.Binding, behavior.ComparisonCondition, behavior.Value))
+            if (ComparisonConditionTypeHelper.Compare(behavior.Binding, behavior.ComparisonCondition, behavior.Value))
             {
                 Interaction.ExecuteActions(behavior.AssociatedObject, behavior.Actions, args);
             }