Allow binding to classes with Classes.ClassName

src/Avalonia.Styling/ClassBindingManager.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Data;
+
+namespace Avalonia
+{
+    internal static class ClassBindingManager
+    {
+        private static readonly Dictionary<string, AvaloniaProperty> s_RegisteredProperties =
+            new Dictionary<string, AvaloniaProperty>();
+        
+        public static IDisposable Bind(IStyledElement target, string className, IBinding source, object anchor)
+        {
+            if (!s_RegisteredProperties.TryGetValue(className, out var prop))
+                s_RegisteredProperties[className] = prop = RegisterClassProxyProperty(className);
+            return target.Bind(prop, source, anchor);
+        }
+
+        private static AvaloniaProperty RegisterClassProxyProperty(string className)
+        {
+            var prop = AvaloniaProperty.Register<StyledElement, bool>("__AvaloniaReserved::Classes::" + className);
+            prop.Changed.Subscribe(args =>
+            {
+                var enable = args.NewValue.GetValueOrDefault();
+                var classes = ((IStyledElement)args.Sender).Classes;
+                if (enable)
+                {
+                    if (!classes.Contains(className))
+                        classes.Add(className);
+                }
+                else
+                    classes.Remove(className);
+            });
+            
+            return prop;
+        }
+    }
+}

src/Avalonia.Styling/Controls/Classes.cs

@@ -265,5 +265,26 @@ namespace Avalonia.Controls
                     $"The pseudoclass '{name}' may only be {operation} by the control itself.");
             }
         }
+
+        /// <summary>
+        /// Adds a or removes a  style class to/from the collection.
+        /// </summary>
+        /// <param name="name">The class names.</param>
+        /// <param name="value">If true adds the class, if false, removes it.</param>
+        /// <remarks>
+        /// Only standard classes may be added or removed via this method. To add pseudoclasses (classes
+        /// beginning with a ':' character) use the protected <see cref="StyledElement.PseudoClasses"/>
+        /// property.
+        /// </remarks>
+        public void Set(string name, bool value)
+        {
+            if (value)
+            {
+                if (!Contains(name))
+                    Add(name);
+            }
+            else
+                Remove(name);
+        }
     }
 }

src/Avalonia.Styling/StyledElementExtensions.cs

@@ -0,0 +1,11 @@
+using System;
+using Avalonia.Data;
+
+namespace Avalonia
+{
+    public static class StyledElementExtensions
+    {
+        public static IDisposable BindClass(this IStyledElement target, string className, IBinding source, object anchor) =>
+            ClassBindingManager.Bind(target, className, source, anchor);
+    }
+}

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

@@ -41,10 +41,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             
             // Targeted
             InsertBefore<PropertyReferenceResolver>(
+                new AvaloniaXamlIlResolveClassesPropertiesTransformer(),
                 new AvaloniaXamlIlTransformInstanceAttachedProperties(),
                 new AvaloniaXamlIlTransformSyntheticCompiledBindingMembers());
             InsertAfter<PropertyReferenceResolver>(
-                new AvaloniaXamlIlAvaloniaPropertyResolver());
+                new AvaloniaXamlIlAvaloniaPropertyResolver(),
+                new AvaloniaXamlIlReorderClassesPropertiesTransformer()
+            );
 
             InsertBefore<ContentConvertTransformer>(                
                 new AvaloniaXamlIlBindingPathParser(),

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

@@ -0,0 +1,97 @@
+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 AvaloniaXamlIlResolveClassesPropertiesTransformer : IXamlAstTransformer
+    {
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
+        {
+            if (node is XamlAstNamePropertyReference prop
+                && prop.TargetType is XamlAstClrTypeReference targetRef
+                && prop.DeclaringType is XamlAstClrTypeReference declaringRef)
+            {
+                var types = context.GetAvaloniaTypes();
+                if (types.StyledElement.IsAssignableFrom(targetRef.Type)
+                    && types.Classes.Equals(declaringRef.Type))
+                {
+                    return new XamlAstClrProperty(node, "class:" + prop.Name, types.Classes,
+                        null)
+                    {
+                        Setters = { new ClassValueSetter(types, prop.Name), new ClassBindingSetter(types, prop.Name) }
+                    };
+                }
+            }
+            return node;
+        }
+
+       
+        class ClassValueSetter :  IXamlEmitablePropertySetter<IXamlILEmitter>
+        {
+            private readonly AvaloniaXamlIlWellKnownTypes _types;
+            private readonly string _className;
+
+            public ClassValueSetter(AvaloniaXamlIlWellKnownTypes types, string className)
+            {
+                _types = types;
+                _className = className;
+                Parameters = new[] { types.XamlIlTypes.Boolean };
+            }
+            
+            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)));
+                }
+            }
+
+            public IXamlType TargetType => _types.StyledElement;
+
+            public PropertySetterBinderParameters BinderParameters { get; } =
+                new PropertySetterBinderParameters { AllowXNull = false };
+            public IReadOnlyList<IXamlType> Parameters { get; }
+        }
+
+        class ClassBindingSetter : IXamlEmitablePropertySetter<IXamlILEmitter>
+        {
+            private readonly AvaloniaXamlIlWellKnownTypes _types;
+            private readonly string _className;
+
+            public ClassBindingSetter(AvaloniaXamlIlWellKnownTypes types, string className)
+            {
+                _types = types;
+                _className = className;
+                Parameters = new[] {types.IBinding};
+            }
+            
+            public void Emit(IXamlILEmitter emitter)
+            {
+                using (var bloc = emitter.LocalsPool.GetLocal(_types.IBinding))
+                    emitter
+                        .Stloc(bloc.Local)
+                        .Ldstr(_className)
+                        .Ldloc(bloc.Local)
+                        // TODO: provide anchor?
+                        .Ldnull();
+                emitter.EmitCall(_types.ClassesBindMethod, true);
+            }
+
+            public IXamlType TargetType => _types.StyledElement;
+
+            public PropertySetterBinderParameters BinderParameters { get; } =
+                new PropertySetterBinderParameters { AllowXNull = false };
+            public IReadOnlyList<IXamlType> Parameters { get; }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+using XamlX.Ast;
+using XamlX.Transform;
+
+namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
+{
+    class AvaloniaXamlIlReorderClassesPropertiesTransformer : IXamlAstTransformer
+    {
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
+        {
+            if (node is XamlAstObjectNode obj)
+            {
+                IXamlAstNode classesNode = null;
+                IXamlAstNode firstSingleClassNode = null;
+                var types = context.GetAvaloniaTypes();
+                foreach (var child in obj.Children)
+                {
+                    if (child is XamlAstXamlPropertyValueNode propValue
+                        && propValue.Property is XamlAstClrProperty prop)
+                    {
+                        if (prop.DeclaringType.Equals(types.Classes))
+                        {
+                            if (firstSingleClassNode == null)
+                                firstSingleClassNode = child;
+                        }
+                        else if (prop.Name == "Classes" && prop.DeclaringType.Equals(types.StyledElement))
+                            classesNode = child;
+                    }
+                }
+
+                if (classesNode != null && firstSingleClassNode != null)
+                {
+                    obj.Children.Remove(classesNode);
+                    obj.Children.Insert(obj.Children.IndexOf(firstSingleClassNode), classesNode);
+                }
+            }
+
+            return node;
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         public IXamlType AssignBindingAttribute { get; }
         public IXamlType UnsetValueType { get; }
         public IXamlType StyledElement { get; }
+        public IXamlType IStyledElement { get; }
         public IXamlType NameScope { get; }
         public IXamlMethod NameScopeSetNameScope { get; }
         public IXamlType INameScope { get; }
@@ -78,6 +79,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         public IXamlType ColumnDefinition { get; }
         public IXamlType ColumnDefinitions { get; }
         public IXamlType Classes { get; }
+        public IXamlMethod ClassesBindMethod { get; }
+        public IXamlProperty StyledElementClassesProperty { get; set; }
 
         public AvaloniaXamlIlWellKnownTypes(TransformerConfiguration cfg)
         {
@@ -97,6 +100,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 IBinding, cfg.WellKnownTypes.Object);
             UnsetValueType = cfg.TypeSystem.GetType("Avalonia.UnsetValueType");
             StyledElement = cfg.TypeSystem.GetType("Avalonia.StyledElement");
+            IStyledElement = cfg.TypeSystem.GetType("Avalonia.IStyledElement");
             INameScope = cfg.TypeSystem.GetType("Avalonia.Controls.INameScope");
             INameScopeRegister = INameScope.GetMethod(
                 new FindMethodMethodSignature("Register", XamlIlTypes.Void,
@@ -168,6 +172,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             RowDefinition = cfg.TypeSystem.GetType("Avalonia.Controls.RowDefinition");
             RowDefinitions = cfg.TypeSystem.GetType("Avalonia.Controls.RowDefinitions");
             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")
+                .FindMethod( "BindClass", IDisposable, false, IStyledElement,
+                cfg.WellKnownTypes.String,
+                IBinding, cfg.WellKnownTypes.Object);
         }
     }
 

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

@@ -377,5 +377,37 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             public string Greeting1 { get; set; } = "Hello";
             public string Greeting2 { get; set; } = "World";
         }
+        
+        [Fact]
+        public void Binding_Classes_Works()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                // Note, this test also checks `Classes` reordering, so it should be kept AFTER the last single class
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Button Name='button' Classes.MyClass='{Binding Foo}' Classes.MySecondClass='True' Classes='foo bar'/>
+</Window>";
+                var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
+                var button = window.FindControl<Button>("button");
+
+                button.DataContext = new { Foo = true };
+                window.ApplyTemplate();
+
+                Assert.True(button.Classes.Contains("MyClass"));
+                Assert.True(button.Classes.Contains("MySecondClass"));
+                Assert.True(button.Classes.Contains("foo"));
+                Assert.True(button.Classes.Contains("bar"));
+
+                button.DataContext = new { Foo = false };
+                
+                Assert.False(button.Classes.Contains("MyClass"));
+                Assert.True(button.Classes.Contains("MySecondClass"));
+                Assert.True(button.Classes.Contains("foo"));
+                Assert.True(button.Classes.Contains("bar"));
+            }
+        }
     }
 }