From 853d4140a301f09cfa4bc4727c086459de903169 Mon Sep 17 00:00:00 2001
From: robloo <robloo@users.noreply.github.com>
Date: Tue, 25 Jan 2022 20:02:40 -0500
Subject: [PATCH] Move more Button property changed handling into
 OnPropertyChanged override

---
 src/Avalonia.Controls/Button.cs               | 142 +++++++-----------
 .../SplitButton/SplitButton.cs                |   4 +-
 2 files changed, 57 insertions(+), 89 deletions(-)

diff --git a/src/Avalonia.Controls/Button.cs b/src/Avalonia.Controls/Button.cs
index 770eb63266..3735e6c010 100644
--- a/src/Avalonia.Controls/Button.cs
+++ b/src/Avalonia.Controls/Button.cs
@@ -59,13 +59,13 @@ namespace Avalonia.Controls
             AvaloniaProperty.Register<Button, object>(nameof(CommandParameter));
 
         /// <summary>
-        /// Defines the <see cref="IsDefaultProperty"/> property.
+        /// Defines the <see cref="IsDefault"/> property.
         /// </summary>
         public static readonly StyledProperty<bool> IsDefaultProperty =
             AvaloniaProperty.Register<Button, bool>(nameof(IsDefault));
 
         /// <summary>
-        /// Defines the <see cref="IsCancelProperty"/> property.
+        /// Defines the <see cref="IsCancel"/> property.
         /// </summary>
         public static readonly StyledProperty<bool> IsCancelProperty =
             AvaloniaProperty.Register<Button, bool>(nameof(IsCancel));
@@ -98,10 +98,6 @@ namespace Avalonia.Controls
         static Button()
         {
             FocusableProperty.OverrideDefaultValue(typeof(Button), true);
-            CommandProperty.Changed.Subscribe(CommandChanged);
-            CommandParameterProperty.Changed.Subscribe(CommandParameterChanged);
-            IsDefaultProperty.Changed.Subscribe(IsDefaultChanged);
-            IsCancelProperty.Changed.Subscribe(IsCancelChanged);
             AccessKeyHandler.AccessKeyPressedEvent.AddClassHandler<Button>((lbl, args) => lbl.OnAccessKey(args));
         }
 
@@ -390,116 +386,88 @@ namespace Avalonia.Controls
         {
             base.OnPropertyChanged(change);
 
-            if (change.Property == IsPressedProperty)
+            if (change.Property == CommandProperty)
             {
-                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<bool>());
-            }
-            else if (change.Property == FlyoutProperty)
-            {
-                // If flyout is changed while one is already open, make sure we 
-                // close the old one first
-                if (change.OldValue.GetValueOrDefault() is FlyoutBase oldFlyout &&
-                    oldFlyout.IsOpen)
+                if (((ILogical)this).IsAttachedToLogicalTree)
                 {
-                    oldFlyout.Hide();
+                    if (change.OldValue.GetValueOrDefault() is ICommand oldCommand)
+                    {
+                        oldCommand.CanExecuteChanged -= CanExecuteChanged;
+                    }
+
+                    if (change.NewValue.GetValueOrDefault() is ICommand newCommand)
+                    {
+                        newCommand.CanExecuteChanged += CanExecuteChanged;
+                    }
                 }
-            }
-        }
 
-        /// <inheritdoc/>
-        protected override void UpdateDataValidation<T>(AvaloniaProperty<T> property, BindingValue<T> value)
-        {
-            base.UpdateDataValidation(property, value);
-            if (property == CommandProperty)
+                CanExecuteChanged(this, EventArgs.Empty);
+            }
+            else if (change.Property == CommandParameterProperty)
             {
-                if (value.Type == BindingValueType.BindingError)
+                CanExecuteChanged(this, EventArgs.Empty);
+            }
+            else if (change.Property == IsCancelProperty)
+            {
+                var isCancel = change.NewValue.GetValueOrDefault<bool>();
+
+                if (VisualRoot is IInputElement inputRoot)
                 {
-                    if (_commandCanExecute)
+                    if (isCancel)
                     {
-                        _commandCanExecute = false;
-                        UpdateIsEffectivelyEnabled();
+                        ListenForCancel(inputRoot);
+                    }
+                    else
+                    {
+                        StopListeningForCancel(inputRoot);
                     }
                 }
             }
-        }
-
-        /// <summary>
-        /// Called when the <see cref="Command"/> property changes.
-        /// </summary>
-        /// <param name="e">The event args.</param>
-        private static void CommandChanged(AvaloniaPropertyChangedEventArgs e)
-        {
-            if (e.Sender is Button button)
+            else if (change.Property == IsDefaultProperty)
             {
-                if (((ILogical)button).IsAttachedToLogicalTree)
+                var isDefault = change.NewValue.GetValueOrDefault<bool>();
+
+                if (VisualRoot is IInputElement inputRoot)
                 {
-                    if (e.OldValue is ICommand oldCommand)
+                    if (isDefault)
                     {
-                        oldCommand.CanExecuteChanged -= button.CanExecuteChanged;
+                        ListenForDefault(inputRoot);
                     }
-
-                    if (e.NewValue is ICommand newCommand)
+                    else
                     {
-                        newCommand.CanExecuteChanged += button.CanExecuteChanged;
+                        StopListeningForDefault(inputRoot);
                     }
                 }
-
-                button.CanExecuteChanged(button, EventArgs.Empty);
             }
-        }
-
-        /// <summary>
-        /// Called when the <see cref="CommandParameter"/> property changes.
-        /// </summary>
-        /// <param name="e">The event args.</param>
-        private static void CommandParameterChanged(AvaloniaPropertyChangedEventArgs e)
-        {
-            if (e.Sender is Button button)
+            else if (change.Property == IsPressedProperty)
             {
-                button.CanExecuteChanged(button, EventArgs.Empty);
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<bool>());
             }
-        }
-
-        /// <summary>
-        /// Called when the <see cref="IsDefault"/> property changes.
-        /// </summary>
-        /// <param name="e">The event args.</param>
-        private static void IsDefaultChanged(AvaloniaPropertyChangedEventArgs e)
-        {
-            var button = e.Sender as Button;
-            var isDefault = (bool)e.NewValue;
-
-            if (button?.VisualRoot is IInputElement inputRoot)
+            else if (change.Property == FlyoutProperty)
             {
-                if (isDefault)
-                {
-                    button.ListenForDefault(inputRoot);
-                }
-                else
+                // If flyout is changed while one is already open, make sure we 
+                // close the old one first
+                if (change.OldValue.GetValueOrDefault() is FlyoutBase oldFlyout &&
+                    oldFlyout.IsOpen)
                 {
-                    button.StopListeningForDefault(inputRoot);
+                    oldFlyout.Hide();
                 }
             }
         }
 
-        /// <summary>
-        /// Called when the <see cref="IsCancel"/> property changes.
-        /// </summary>
-        /// <param name="e">The event args.</param>
-        private static void IsCancelChanged(AvaloniaPropertyChangedEventArgs e)
+        /// <inheritdoc/>
+        protected override void UpdateDataValidation<T>(AvaloniaProperty<T> property, BindingValue<T> value)
         {
-            var button = e.Sender as Button;
-            var isCancel = (bool)e.NewValue;
-
-            if (button?.VisualRoot is IInputElement inputRoot)
+            base.UpdateDataValidation(property, value);
+            if (property == CommandProperty)
             {
-                if (isCancel)
-                {
-                    button.ListenForCancel(inputRoot);
-                }
-                else
+                if (value.Type == BindingValueType.BindingError)
                 {
-                    button.StopListeningForCancel(inputRoot);
+                    if (_commandCanExecute)
+                    {
+                        _commandCanExecute = false;
+                        UpdateIsEffectivelyEnabled();
+                    }
                 }
             }
         }
diff --git a/src/Avalonia.Controls/SplitButton/SplitButton.cs b/src/Avalonia.Controls/SplitButton/SplitButton.cs
index ceff577eda..5c75a8d09d 100644
--- a/src/Avalonia.Controls/SplitButton/SplitButton.cs
+++ b/src/Avalonia.Controls/SplitButton/SplitButton.cs
@@ -515,12 +515,12 @@ namespace Avalonia.Controls
                 if (_isAttachedToLogicalTree)
                 {
                     // Must unregister events here while a reference to the old command still exists
-                    if (e.OldValue is ICommand oldCommand)
+                    if (e.OldValue.GetValueOrDefault() is ICommand oldCommand)
                     {
                         oldCommand.CanExecuteChanged -= CanExecuteChanged;
                     }
 
-                    if (e.NewValue is ICommand newCommand)
+                    if (e.NewValue.GetValueOrDefault() is ICommand newCommand)
                     {
                         newCommand.CanExecuteChanged += CanExecuteChanged;
                     }