Fixed Classes="{Binding StringValue}" overwriting Classes.Foo="True" and Classes.Foo="{Binding}" (#18068)

Author: Athari

src/Avalonia.Base/ClassBindingManager.cs

@@ -17,6 +17,10 @@ internal static class ClassBindingManager
             AvaloniaProperty.RegisterAttached<StyledElement, string>(
                 "Classes", typeof(ClassBindingManager), "");
 
+        public static readonly AttachedProperty<HashSet<string>?> BoundClassesProperty =
+            AvaloniaProperty.RegisterAttached<StyledElement, HashSet<string>?>(
+                "BoundClasses", typeof(ClassBindingManager));
+
         public static void SetClasses(StyledElement element, string value)
         {
             _ = element ?? throw new ArgumentNullException(nameof(element));
@@ -29,29 +33,63 @@ public static string GetClasses(StyledElement element)
             return element.GetValue(ClassesProperty);
         }
 
+        public static void SetBoundClasses(StyledElement element, HashSet<string>? value)
+        {
+            _ = element ?? throw new ArgumentNullException(nameof(element));
+            element.SetValue(BoundClassesProperty, value);
+        }
+
+        public static HashSet<string>? GetBoundClasses(StyledElement element)
+        {
+            _ = element ?? throw new ArgumentNullException(nameof(element));
+            return element.GetValue(BoundClassesProperty);
+        }
+
         static ClassBindingManager()
         {
             ClassesProperty.Changed.AddClassHandler<StyledElement, string>(ClassesPropertyChanged);
         }
 
         private static void ClassesPropertyChanged(StyledElement sender, AvaloniaPropertyChangedEventArgs<string> e)
         {
+            var boundClasses = GetBoundClasses(sender);
+
             var newValue = e.GetNewValue<string?>() ?? "";
             var newValues = newValue.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-            var currentValues = sender.Classes.Where(c => !c.StartsWith(":", StringComparison.Ordinal));
+            var currentValues = sender.Classes
+                .Where(c => !c.StartsWith(":", StringComparison.Ordinal) && boundClasses?.Contains(c) != true)
+                .ToList();
             if (currentValues.SequenceEqual(newValues))
                 return;
 
-            sender.Classes.Replace(newValues);
+            sender.Classes.Replace(currentValues, newValues);
+        }
+
+        private static void AddBoundClass(StyledElement target, string className)
+        {
+            var boundClasses = GetBoundClasses(target);
+            if (boundClasses == null)
+            {
+                boundClasses = [];
+                SetBoundClasses(target, boundClasses);
+            }
+            boundClasses.Add(className);
         }
 
         public static IDisposable BindClasses(StyledElement target, IBinding source, object anchor)
         {
             return target.Bind(ClassesProperty, source);
         }
 
+        public static void SetClass(StyledElement target, string className, bool value)
+        {
+            AddBoundClass(target, className);
+            target.Classes.Set(className, value);
+        }
+
         public static IDisposable BindClass(StyledElement target, string className, IBinding source, object anchor)
         {
+            AddBoundClass(target, className);
             var prop = GetClassProperty(className);
             return target.Bind(prop, source);
         }
@@ -63,8 +101,8 @@ private static AvaloniaProperty RegisterClassProxyProperty(string className)
             var prop = AvaloniaProperty.Register<StyledElement, bool>(ClassPropertyPrefix + className);
             prop.Changed.Subscribe(args =>
             {
-                var classes = ((StyledElement)args.Sender).Classes;
-                classes.Set(className, args.NewValue.GetValueOrDefault());
+                var sender = (StyledElement)args.Sender;
+                SetClass(sender, className, args.NewValue.GetValueOrDefault());
             });
 
             return prop;

src/Avalonia.Base/StyledElementExtensions.cs

@@ -15,6 +15,9 @@ public static void SetClasses(this StyledElement target, string classNames) =>
         public static IDisposable BindClass(this StyledElement target, string className, IBinding source, object anchor) =>
             ClassBindingManager.BindClass(target, className, source, anchor);
 
+        public static void SetClass(this StyledElement target, string className, bool value) =>
+            ClassBindingManager.SetClass(target, className, value);
+
         public static AvaloniaProperty GetClassProperty(string className) =>
             ClassBindingManager.GetClassProperty(className);
 

src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AvaloniaXamlIlClassesPropertyResolver.cs

@@ -46,15 +46,11 @@ public ClassValueSetter(AvaloniaXamlIlWellKnownTypes types, string className)
             public void Emit(IXamlILEmitter emitter)
             {
                 using (var value = emitter.LocalsPool.GetLocal(_types.XamlIlTypes.Boolean))
-                {
                     emitter
                         .Stloc(value.Local)
-                        .EmitCall(_types.StyledElementClassesProperty.Getter!)
                         .Ldstr(_className)
-                        .Ldloc(value.Local)
-                        .EmitCall(_types.Classes.GetMethod(new FindMethodMethodSignature("Set",
-                        _types.XamlIlTypes.Void, _types.XamlIlTypes.String, _types.XamlIlTypes.Boolean)));
-                }
+                        .Ldloc(value.Local);
+                emitter.EmitCall(_types.SetClassMethod);
             }
 
             public IXamlType TargetType => _types.StyledElement;

src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AvaloniaXamlIlResolveClassesPropertyTransformer.cs

@@ -49,7 +49,7 @@ public override void Emit(IXamlILEmitter emitter)
                     emitter
                         .Stloc(value.Local)
                         .Ldloc(value.Local);
-                emitter.EmitCall(Types.SetClassesMethod, true);
+                emitter.EmitCall(Types.SetClassesMethod);
             }
         }
 

src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs

@@ -101,6 +101,7 @@ sealed class AvaloniaXamlIlWellKnownTypes
         public IXamlType ColumnDefinitions { get; }
         public IXamlType Classes { get; }
         public IXamlMethod BindClassMethod { get; }
+        public IXamlMethod SetClassMethod { get; }
         public IXamlMethod BindClassesMethod { get; }
         public IXamlMethod SetClassesMethod { get; }
         public IXamlProperty StyledElementClassesProperty { get; }
@@ -300,8 +301,10 @@ public AvaloniaXamlIlWellKnownTypes(TransformerConfiguration cfg)
                 StyledElement.Properties.First(x => x.Name == "Classes" && x.PropertyType.Equals(Classes));
             BindClassMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
                 .GetMethod("BindClass", IDisposable, false, StyledElement,
-                cfg.WellKnownTypes.String,
-                IBinding, cfg.WellKnownTypes.Object);
+                cfg.WellKnownTypes.String, IBinding, cfg.WellKnownTypes.Object);
+            SetClassMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
+                .GetMethod("SetClass", cfg.WellKnownTypes.Void, false, StyledElement,
+                cfg.WellKnownTypes.String, cfg.WellKnownTypes.Boolean);
             BindClassesMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
                 .GetMethod("BindClasses", IDisposable, false, StyledElement,
                 IBinding, cfg.WellKnownTypes.Object);