Added support for Classes="{Binding StringValue}" (#18068)

Author: Athari

src/Avalonia.Base/ClassBindingManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Avalonia.Data;
 using Avalonia.Reactive;
 
@@ -12,7 +13,44 @@ internal static class ClassBindingManager
         private static readonly Dictionary<string, AvaloniaProperty> s_RegisteredProperties =
             new Dictionary<string, AvaloniaProperty>();
 
-        public static IDisposable Bind(StyledElement target, string className, IBinding source, object anchor)
+        public static readonly AttachedProperty<string> ClassesProperty =
+            AvaloniaProperty.RegisterAttached<StyledElement, string>(
+                "Classes", typeof(ClassBindingManager), "");
+
+        public static void SetClasses(StyledElement element, string value)
+        {
+            _ = element ?? throw new ArgumentNullException(nameof(element));
+            element.SetValue(ClassesProperty, value);
+        }
+
+        public static string GetClasses(StyledElement element)
+        {
+            _ = element ?? throw new ArgumentNullException(nameof(element));
+            return element.GetValue(ClassesProperty);
+        }
+
+        static ClassBindingManager()
+        {
+            ClassesProperty.Changed.AddClassHandler<StyledElement, string>(ClassesPropertyChanged);
+        }
+
+        private static void ClassesPropertyChanged(StyledElement sender, AvaloniaPropertyChangedEventArgs<string> e)
+        {
+            var newValue = e.GetNewValue<string?>() ?? "";
+            var newValues = newValue.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            var currentValues = sender.Classes.Where(c => !c.StartsWith(":", StringComparison.Ordinal));
+            if (currentValues.SequenceEqual(newValues))
+                return;
+
+            sender.Classes.Replace(newValues);
+        }
+
+        public static IDisposable BindClasses(StyledElement target, IBinding source, object anchor)
+        {
+            return target.Bind(ClassesProperty, source);
+        }
+
+        public static IDisposable BindClass(StyledElement target, string className, IBinding source, object anchor)
         {
             var prop = GetClassProperty(className);
             return target.Bind(prop, source);

src/Avalonia.Base/StyledElementExtensions.cs

@@ -6,8 +6,14 @@ namespace Avalonia
 {
     public static class StyledElementExtensions
     {
+        public static IDisposable BindClasses(this StyledElement target, IBinding source, object anchor) =>
+            ClassBindingManager.BindClasses(target, source, anchor);
+
+        public static void SetClasses(this StyledElement target, string classNames) =>
+            ClassBindingManager.SetClasses(target, classNames);
+
         public static IDisposable BindClass(this StyledElement target, string className, IBinding source, object anchor) =>
-            ClassBindingManager.Bind(target, className, source, anchor);
+            ClassBindingManager.BindClass(target, className, source, anchor);
 
         public static AvaloniaProperty GetClassProperty(string className) =>
             ClassBindingManager.GetClassProperty(className);

src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/AvaloniaXamlIlCompiler.cs

@@ -45,6 +45,7 @@ void InsertBeforeMany(Type[] types, params IXamlAstTransformer[] t)
             // Targeted
             InsertBefore<PropertyReferenceResolver>(
                 new AvaloniaXamlIlResolveClassesPropertiesTransformer(),
+                new AvaloniaXamlIlResolveClassesPropertyTransformer(),
                 new AvaloniaXamlIlTransformInstanceAttachedProperties(),
                 new AvaloniaXamlIlTransformSyntheticCompiledBindingMembers());
             InsertAfter<PropertyReferenceResolver>(

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

@@ -86,7 +86,7 @@ public void Emit(IXamlILEmitter emitter)
                         .Ldloc(bloc.Local)
                         // TODO: provide anchor?
                         .Ldnull();
-                emitter.EmitCall(_types.ClassesBindMethod, true);
+                emitter.EmitCall(_types.BindClassMethod, true);
             }
 
             public IXamlType TargetType => _types.StyledElement;

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

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using XamlX.Ast;
+using XamlX.Emit;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
+
+namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
+{
+    class AvaloniaXamlIlResolveClassesPropertyTransformer : IXamlAstTransformer
+    {
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
+        {
+            var types = context.GetAvaloniaTypes();
+            if (node is XamlAstNamePropertyReference prop &&
+                prop.Name == "Classes" &&
+                prop.TargetType is XamlAstClrTypeReference targetRef &&
+                prop.DeclaringType is XamlAstClrTypeReference declaringRef &&
+                types.StyledElement.IsAssignableFrom(targetRef.Type) &&
+                types.StyledElement.IsAssignableFrom(declaringRef.Type)
+                )
+            {
+                return new XamlAstClrProperty(node, prop.Name, types.StyledElement, null)
+                {
+                    Setters = { new ClassesValueSetter(types), new ClassesBindingSetter(types) }
+                };
+            }
+            return node;
+        }
+
+        abstract class ClassesSetter : IXamlEmitablePropertySetter<IXamlILEmitter>
+        {
+            protected readonly AvaloniaXamlIlWellKnownTypes _types;
+
+            protected ClassesSetter(AvaloniaXamlIlWellKnownTypes types, IXamlType parameter)
+            {
+                _types = types;
+                Parameters = [parameter];
+            }
+
+            public abstract void Emit(IXamlILEmitter emitter);
+
+            public IXamlType TargetType => _types.StyledElement;
+            public PropertySetterBinderParameters BinderParameters { get; } = new() { AllowXNull = false };
+            public IReadOnlyList<IXamlType> Parameters { get; }
+            public IReadOnlyList<IXamlCustomAttribute> CustomAttributes => Array.Empty<IXamlCustomAttribute>();
+        }
+
+        class ClassesValueSetter(AvaloniaXamlIlWellKnownTypes types) : ClassesSetter(types, types.XamlIlTypes.String)
+        {
+            public override void Emit(IXamlILEmitter emitter)
+            {
+                using (var value = emitter.LocalsPool.GetLocal(Parameters[0]))
+                    emitter
+                        .Stloc(value.Local)
+                        .Ldloc(value.Local);
+                emitter.EmitCall(_types.SetClassesMethod, true);
+            }
+        }
+
+        class ClassesBindingSetter(AvaloniaXamlIlWellKnownTypes types) : ClassesSetter(types, types.IBinding)
+        {
+            public override void Emit(IXamlILEmitter emitter)
+            {
+                using (var value = emitter.LocalsPool.GetLocal(Parameters[0]))
+                    emitter
+                        .Stloc(value.Local)
+                        .Ldloc(value.Local)
+                        // TODO: provide anchor?
+                        .Ldnull();
+                emitter.EmitCall(_types.BindClassesMethod, true);
+            }
+        }
+    }
+}

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

@@ -100,7 +100,9 @@ sealed class AvaloniaXamlIlWellKnownTypes
         public IXamlType ColumnDefinition { get; }
         public IXamlType ColumnDefinitions { get; }
         public IXamlType Classes { get; }
-        public IXamlMethod ClassesBindMethod { get; }
+        public IXamlMethod BindClassMethod { get; }
+        public IXamlMethod BindClassesMethod { get; }
+        public IXamlMethod SetClassesMethod { get; }
         public IXamlProperty StyledElementClassesProperty { get; }
         public IXamlType IBrush { get; }
         public IXamlType ImmutableSolidColorBrush { get; }
@@ -296,10 +298,16 @@ public AvaloniaXamlIlWellKnownTypes(TransformerConfiguration cfg)
             Classes = cfg.TypeSystem.GetType("Avalonia.Controls.Classes");
             StyledElementClassesProperty =
                 StyledElement.Properties.First(x => x.Name == "Classes" && x.PropertyType.Equals(Classes));
-            ClassesBindMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
+            BindClassMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
                 .GetMethod("BindClass", IDisposable, false, StyledElement,
                 cfg.WellKnownTypes.String,
                 IBinding, cfg.WellKnownTypes.Object);
+            BindClassesMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
+                .GetMethod("BindClasses", IDisposable, false, StyledElement,
+                IBinding, cfg.WellKnownTypes.Object);
+            SetClassesMethod = cfg.TypeSystem.GetType("Avalonia.StyledElementExtensions")
+                .GetMethod("SetClasses", cfg.WellKnownTypes.Void, false, StyledElement,
+                cfg.WellKnownTypes.String);
 
             IBrush = cfg.TypeSystem.GetType("Avalonia.Media.IBrush");
             ImmutableSolidColorBrush = cfg.TypeSystem.GetType("Avalonia.Media.Immutable.ImmutableSolidColorBrush");