From 1d4a7923f1799934df70175d252881cf316a637f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 25 Nov 2019 22:31:22 +0100
Subject: [PATCH 1/4] Remove OperationsPerInvoke here.

It was incorrect: invoking the method doesn't create 1000 buttons.
---
 .../Base/AvaloniaObjectInitializationBenchmark.cs               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Avalonia.Benchmarks/Base/AvaloniaObjectInitializationBenchmark.cs b/tests/Avalonia.Benchmarks/Base/AvaloniaObjectInitializationBenchmark.cs
index 06716f71023..d2e38850f20 100644
--- a/tests/Avalonia.Benchmarks/Base/AvaloniaObjectInitializationBenchmark.cs
+++ b/tests/Avalonia.Benchmarks/Base/AvaloniaObjectInitializationBenchmark.cs
@@ -6,7 +6,7 @@ namespace Avalonia.Benchmarks.Base
     [MemoryDiagnoser]
     public class AvaloniaObjectInitializationBenchmark
     {
-        [Benchmark(OperationsPerInvoke = 1000)]
+        [Benchmark]
         public Button InitializeButton()
         {
             return new Button();

From 35bd69f23c24878f7534160b1bd6b6b7d4a12612 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 25 Nov 2019 23:01:27 +0100
Subject: [PATCH 2/4] Remove AvaloniaProperty.Initialized.

It was only needed for pseudoclasses. Move pseudoclass registration to an engine that doesn't require `AvaloniaProperty.Initialized`, implemented in `PseudoclassEngine`.
---
 src/Avalonia.Base/AvaloniaObject.cs           |   1 -
 src/Avalonia.Base/AvaloniaProperty.cs         |  39 ------
 src/Avalonia.Base/AvaloniaPropertyRegistry.cs |  45 -------
 src/Avalonia.Base/DirectPropertyBase.cs       |  15 ---
 src/Avalonia.Base/StyledPropertyBase.cs       |  15 ---
 src/Avalonia.Styling/PseudoclassEngine.cs     | 120 ++++++++++++++++++
 src/Avalonia.Styling/StyledElement.cs         |  19 +--
 .../AvaloniaObjectTests_Attached.cs           |  17 ---
 .../AvaloniaObjectTests_Direct.cs             |  16 ---
 .../AvaloniaPropertyTests.cs                  |  23 ----
 .../DirectPropertyTests.cs                    |  22 ----
 11 files changed, 126 insertions(+), 206 deletions(-)
 create mode 100644 src/Avalonia.Styling/PseudoclassEngine.cs

diff --git a/src/Avalonia.Base/AvaloniaObject.cs b/src/Avalonia.Base/AvaloniaObject.cs
index 5bddf956162..e427c649454 100644
--- a/src/Avalonia.Base/AvaloniaObject.cs
+++ b/src/Avalonia.Base/AvaloniaObject.cs
@@ -34,7 +34,6 @@ public class AvaloniaObject : IAvaloniaObject, IAvaloniaObjectDebug, INotifyProp
         public AvaloniaObject()
         {
             VerifyAccess();
-            AvaloniaPropertyRegistry.Instance.NotifyInitialized(this);
         }
 
         /// <summary>
diff --git a/src/Avalonia.Base/AvaloniaProperty.cs b/src/Avalonia.Base/AvaloniaProperty.cs
index 8e5716a5bf6..cd9b40f94a7 100644
--- a/src/Avalonia.Base/AvaloniaProperty.cs
+++ b/src/Avalonia.Base/AvaloniaProperty.cs
@@ -22,7 +22,6 @@ public abstract class AvaloniaProperty : IEquatable<AvaloniaProperty>
         public static readonly object UnsetValue = new UnsetValueType();
 
         private static int s_nextId;
-        private readonly Subject<AvaloniaPropertyChangedEventArgs> _initialized;
         private readonly Subject<AvaloniaPropertyChangedEventArgs> _changed;
         private readonly PropertyMetadata _defaultMetadata;
         private readonly Dictionary<Type, PropertyMetadata> _metadata;
@@ -55,7 +54,6 @@ protected AvaloniaProperty(
                 throw new ArgumentException("'name' may not contain periods.");
             }
 
-            _initialized = new Subject<AvaloniaPropertyChangedEventArgs>();
             _changed = new Subject<AvaloniaPropertyChangedEventArgs>();
             _metadata = new Dictionary<Type, PropertyMetadata>();
 
@@ -83,7 +81,6 @@ protected AvaloniaProperty(
             Contract.Requires<ArgumentNullException>(source != null);
             Contract.Requires<ArgumentNullException>(ownerType != null);
 
-            _initialized = source._initialized;
             _changed = source._changed;
             _metadata = new Dictionary<Type, PropertyMetadata>();
 
@@ -138,22 +135,6 @@ protected AvaloniaProperty(
         /// </summary>
         public virtual bool IsReadOnly => false;
 
-        /// <summary>
-        /// Gets an observable that is fired when this property is initialized on a
-        /// new <see cref="AvaloniaObject"/> instance.
-        /// </summary>
-        /// <remarks>
-        /// This observable is fired each time a new <see cref="AvaloniaObject"/> is constructed
-        /// for all properties registered on the object's type. The default value of the property
-        /// for the object is passed in the args' NewValue (OldValue will always be
-        /// <see cref="UnsetValue"/>.
-        /// </remarks>
-        /// <value>
-        /// An observable that is fired when this property is initialized on a new
-        /// <see cref="AvaloniaObject"/> instance.
-        /// </value>
-        public IObservable<AvaloniaPropertyChangedEventArgs> Initialized => _initialized;
-
         /// <summary>
         /// Gets an observable that is fired when this property changes on any
         /// <see cref="AvaloniaObject"/> instance.
@@ -482,26 +463,6 @@ public override string ToString()
             return Name;
         }
 
-        /// <summary>
-        /// True if <see cref="Initialized"/> has any observers.
-        /// </summary>
-        internal bool HasNotifyInitializedObservers => _initialized.HasObservers;
-
-        /// <summary>
-        /// Notifies the <see cref="Initialized"/> observable.
-        /// </summary>
-        /// <param name="o">The object being initialized.</param>
-        internal abstract void NotifyInitialized(IAvaloniaObject o);
-
-        /// <summary>
-        /// Notifies the <see cref="Initialized"/> observable.
-        /// </summary>
-        /// <param name="e">The observable arguments.</param>
-        internal void NotifyInitialized(AvaloniaPropertyChangedEventArgs e)
-        {
-            _initialized.OnNext(e);
-        }
-
         /// <summary>
         /// Notifies the <see cref="Changed"/> observable.
         /// </summary>
diff --git a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
index 0734b64721f..50ffb515503 100644
--- a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
+++ b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
@@ -407,51 +407,6 @@ public void RegisterAttached(Type type, AvaloniaProperty property)
             _inheritedCache.Clear();
         }
 
-        internal void NotifyInitialized(AvaloniaObject o)
-        {
-            Contract.Requires<ArgumentNullException>(o != null);
-
-            var type = o.GetType();
-
-            if (!_initializedCache.TryGetValue(type, out var initializationData))
-            {
-                var visited = new HashSet<AvaloniaProperty>();
-
-                initializationData = new List<PropertyInitializationData>();
-
-                foreach (AvaloniaProperty property in GetRegistered(type))
-                {
-                    if (property.IsDirect)
-                    {
-                        initializationData.Add(new PropertyInitializationData(property, (IDirectPropertyAccessor)property));
-                    }
-                    else
-                    {
-                        initializationData.Add(new PropertyInitializationData(property, (IStyledPropertyAccessor)property, type));
-                    }
-
-                    visited.Add(property);
-                }
-
-                foreach (AvaloniaProperty property in GetRegisteredAttached(type))
-                {
-                    if (!visited.Contains(property))
-                    {
-                        initializationData.Add(new PropertyInitializationData(property, (IStyledPropertyAccessor)property, type));
-
-                        visited.Add(property);
-                    }
-                }
-
-                _initializedCache.Add(type, initializationData);
-            }
-
-            foreach (PropertyInitializationData data in initializationData)
-            {
-                data.Property.NotifyInitialized(o);
-            }
-        }
-
         private readonly struct PropertyInitializationData
         {
             public AvaloniaProperty Property { get; }
diff --git a/src/Avalonia.Base/DirectPropertyBase.cs b/src/Avalonia.Base/DirectPropertyBase.cs
index 7a0be065eb6..39ed3b084f6 100644
--- a/src/Avalonia.Base/DirectPropertyBase.cs
+++ b/src/Avalonia.Base/DirectPropertyBase.cs
@@ -101,21 +101,6 @@ public TValue GetUnsetValue(Type type)
             return (DirectPropertyMetadata<TValue>)base.GetMetadata(type);
         }
 
-        /// <inheritdoc/>
-        internal override void NotifyInitialized(IAvaloniaObject o)
-        {
-            if (HasNotifyInitializedObservers)
-            {
-                var e = new AvaloniaPropertyChangedEventArgs<TValue>(
-                    o,
-                    this,
-                    default,
-                    InvokeGetter(o),
-                    BindingPriority.Unset);
-                NotifyInitialized(e);
-            }
-        }
-
         /// <inheritdoc/>
         internal override void RouteClearValue(IAvaloniaObject o)
         {
diff --git a/src/Avalonia.Base/StyledPropertyBase.cs b/src/Avalonia.Base/StyledPropertyBase.cs
index 8c4d683ae00..d1f961a567c 100644
--- a/src/Avalonia.Base/StyledPropertyBase.cs
+++ b/src/Avalonia.Base/StyledPropertyBase.cs
@@ -181,21 +181,6 @@ public override string ToString()
         /// <inheritdoc/>
         object IStyledPropertyAccessor.GetDefaultValue(Type type) => GetDefaultBoxedValue(type);
 
-        /// <inheritdoc/>
-        internal override void NotifyInitialized(IAvaloniaObject o)
-        {
-            if (HasNotifyInitializedObservers)
-            {
-                var e = new AvaloniaPropertyChangedEventArgs<TValue>(
-                    o,
-                    this,
-                    default,
-                    o.GetValue(this),
-                    BindingPriority.Unset);
-                NotifyInitialized(e);
-            }
-        }
-
         /// <inheritdoc/>
         internal override void RouteClearValue(IAvaloniaObject o)
         {
diff --git a/src/Avalonia.Styling/PseudoclassEngine.cs b/src/Avalonia.Styling/PseudoclassEngine.cs
new file mode 100644
index 00000000000..6c8f8a832ac
--- /dev/null
+++ b/src/Avalonia.Styling/PseudoclassEngine.cs
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+
+namespace Avalonia
+{
+    internal static class PseudoclassEngine
+    {
+        private static Dictionary<Type, List<IEntry>> _entries = new Dictionary<Type, List<IEntry>>();
+        private static Dictionary<AvaloniaProperty, List<IEntry>> _properties = new Dictionary<AvaloniaProperty, List<IEntry>>();
+        private static Dictionary<Type, List<IEntry>> _cache = new Dictionary<Type, List<IEntry>>();
+
+        public static void Created(StyledElement element)
+        {
+            var t = element.GetType();
+
+            if (!_cache.TryGetValue(t, out var list))
+            {
+                list = new List<IEntry>();
+
+                foreach (var i in _entries)
+                {
+                    if (i.Key.IsAssignableFrom(t))
+                    {
+                        list.AddRange(i.Value);
+                    }
+                }
+
+                _cache.Add(t, list);
+            }
+
+            foreach (var i in list)
+            {
+                i.Update(element);
+            }
+        }
+
+        public static void Register<T>(
+            Type type,
+            AvaloniaProperty<T> property,
+            Func<T, bool> selector,
+            string className)
+        {
+            if (!_entries.TryGetValue(type, out var list))
+            {
+                list = new List<IEntry>();
+                _entries.Add(type, list);
+            }
+
+            var entry = new Entry<T>(type, property, selector, className);
+            list.Add(entry);
+            
+            if (!_properties.TryGetValue(property, out list))
+            {
+                list = new List<IEntry>();
+                _properties.Add(property, list);
+                property.Changed.Subscribe(ValueChanged);
+            }
+
+            list.Add(entry);
+        }
+
+        private static void ValueChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (e.Sender is StyledElement element &&
+                _properties.TryGetValue(e.Property, out var list))
+            {
+                var t = e.Sender.GetType();
+
+                foreach (var i in list)
+                {
+                    if (i.Type.IsAssignableFrom(t))
+                    {
+                        i.Update(element);
+                    }
+                }
+            }
+        }
+
+        private interface IEntry
+        {
+            Type Type { get; }
+            void Update(StyledElement element);
+        }
+
+        private class Entry<T> : IEntry
+        {
+            public Entry(
+                Type type,
+                AvaloniaProperty<T> property,
+                Func<T, bool> selector,
+                string className)
+            {
+                Type = type;
+                Property = property;
+                Selector = selector;
+                ClassName = className;
+            }
+
+            public Type Type { get; }
+            public AvaloniaProperty<T> Property { get; }
+            public Func<T, bool> Selector { get; }
+            public string ClassName { get; }
+
+            public void Update(StyledElement element)
+            {
+                var value = element.GetValue(Property);
+
+                if (Selector(value))
+                {
+                    ((IPseudoClasses)element.Classes).Add(ClassName);
+                }
+                else
+                {
+                    ((IPseudoClasses)element.Classes).Remove(ClassName);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Styling/StyledElement.cs b/src/Avalonia.Styling/StyledElement.cs
index cc7da2b4369..90e1259ce64 100644
--- a/src/Avalonia.Styling/StyledElement.cs
+++ b/src/Avalonia.Styling/StyledElement.cs
@@ -82,6 +82,7 @@ static StyledElement()
         public StyledElement()
         {
             _isAttachedToLogicalTree = this is IStyleRoot;
+            PseudoclassEngine.Created(this);
         }
 
         /// <summary>
@@ -557,19 +558,11 @@ protected static void PseudoClass<TOwner, TProperty>(
                 throw new ArgumentException("Cannot supply an empty className.");
             }
 
-            property.Changed.Merge(property.Initialized)
-                .Where(e => e.Sender is TOwner)
-                .Subscribe(e =>
-                {
-                    if (selector((TProperty)e.NewValue))
-                    {
-                        ((StyledElement)e.Sender).PseudoClasses.Add(className);
-                    }
-                    else
-                    {
-                        ((StyledElement)e.Sender).PseudoClasses.Remove(className);
-                    }
-                });
+            PseudoclassEngine.Register(
+                typeof(TOwner),
+                property,
+                selector,
+                className);
         }
 
         protected virtual void LogicalChildrenCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Attached.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Attached.cs
index 44e2976e038..474ef9abec4 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Attached.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Attached.cs
@@ -16,19 +16,6 @@ public void AddOwnered_Property_Retains_Default_Value()
             Assert.Equal("foodefault", target.GetValue(Class2.FooProperty));
         }
 
-        [Fact]
-        public void AvaloniaProperty_Initialized_Is_Called_For_Attached_Property()
-        {
-            bool raised = false;
-
-            using (Class1.FooProperty.Initialized.Subscribe(x => raised = true))
-            {
-                new Class3();
-            }
-
-            Assert.True(raised);
-        }
-
         private class Base : AvaloniaObject
         {
         }
@@ -46,9 +33,5 @@ private class Class2 : Base
             public static readonly AttachedProperty<string> FooProperty =
                 Class1.FooProperty.AddOwner<Class2>();
         }
-
-        private class Class3 : Base
-        {
-        }
     }
 }
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs
index 4110c3771f7..b1a5b5ae921 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs
@@ -424,22 +424,6 @@ public void Bind_Binds_AddOwnered_Property_Value_NonGeneric()
             Assert.Equal("second", target.Foo);
         }
 
-        [Fact]
-        public void Property_Notifies_Initialized()
-        {
-            bool raised = false;
-
-            Class1.FooProperty.Initialized.Subscribe(e =>
-                raised = e.Property == Class1.FooProperty &&
-                         e.OldValue == AvaloniaProperty.UnsetValue &&
-                         (string)e.NewValue == "initial" &&
-                         e.Priority == BindingPriority.Unset);
-
-            var target = new Class1();
-
-            Assert.True(raised);
-        }
-
         [Fact]
         public void Binding_Error_Reverts_To_Default_Value()
         {
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs
index 90b8bcff63d..6bb8dfe1f5a 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs
@@ -78,24 +78,6 @@ public void OverrideMetadata_Should_Merge_Values()
             Assert.Equal(BindingMode.TwoWay, result.DefaultBindingMode);
         }
 
-        [Fact]
-        public void Initialized_Observable_Fired()
-        {
-            bool invoked = false;
-
-            Class1.FooProperty.Initialized.Subscribe(x =>
-            {
-                Assert.Equal(AvaloniaProperty.UnsetValue, x.OldValue);
-                Assert.Equal("default", x.NewValue);
-                Assert.Equal(BindingPriority.Unset, x.Priority);
-                invoked = true;
-            });
-
-            var target = new Class1();
-
-            Assert.True(invoked);
-        }
-
         [Fact]
         public void Changed_Observable_Fired()
         {
@@ -141,11 +123,6 @@ public void OverrideMetadata<T>(PropertyMetadata metadata)
                 OverrideMetadata(typeof(T), metadata);
             }
 
-            internal override void NotifyInitialized(IAvaloniaObject o)
-            {
-                throw new NotImplementedException();
-            }
-
             internal override IDisposable RouteBind(
                 IAvaloniaObject o,
                 IObservable<BindingValue<object>> source,
diff --git a/tests/Avalonia.Base.UnitTests/DirectPropertyTests.cs b/tests/Avalonia.Base.UnitTests/DirectPropertyTests.cs
index c2a8b03f150..8f62dc91368 100644
--- a/tests/Avalonia.Base.UnitTests/DirectPropertyTests.cs
+++ b/tests/Avalonia.Base.UnitTests/DirectPropertyTests.cs
@@ -1,33 +1,12 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
-using System;
-using System.Reactive.Subjects;
-using Avalonia.Data;
 using Xunit;
 
 namespace Avalonia.Base.UnitTests
 {
     public class DirectPropertyTests
     {
-        [Fact]
-        public void Initialized_Observable_Fired()
-        {
-            bool invoked = false;
-
-            Class1.FooProperty.Initialized.Subscribe(x =>
-            {
-                Assert.Equal(AvaloniaProperty.UnsetValue, x.OldValue);
-                Assert.Equal("foo", x.NewValue);
-                Assert.Equal(BindingPriority.Unset, x.Priority);
-                invoked = true;
-            });
-
-            var target = new Class1();
-
-            Assert.True(invoked);
-        }
-
         [Fact]
         public void IsDirect_Property_Returns_True()
         {
@@ -69,7 +48,6 @@ public void AddOwnered_Properties_Should_Share_Observables()
             var p2 = p1.AddOwner<Class2>(o => null, (o, v) => { });
 
             Assert.Same(p1.Changed, p2.Changed);
-            Assert.Same(p1.Initialized, p2.Initialized);
         }
 
         private class Class1 : AvaloniaObject

From b89305d708ac67a9c31270bfda8e6028d6527e3f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 26 Nov 2019 01:11:10 +0100
Subject: [PATCH 3/4] Set pseudoclasses manually.

It makes creating new controls a _lot_ faster.
---
 src/Avalonia.Controls.DataGrid/DataGrid.cs    |   8 +-
 src/Avalonia.Controls/Button.cs               |  25 +++-
 src/Avalonia.Controls/ButtonSpinner.cs        |  28 +++-
 src/Avalonia.Controls/ControlExtensions.cs    |  20 ---
 src/Avalonia.Controls/Expander.cs             |  41 ++++--
 .../WindowNotificationManager.cs              |  30 ++++-
 src/Avalonia.Controls/Primitives/ScrollBar.cs |  24 +++-
 .../Primitives/ToggleButton.cs                |  21 ++-
 src/Avalonia.Controls/Primitives/Track.cs     |  28 +++-
 src/Avalonia.Controls/ProgressBar.cs          |  44 ++++++-
 src/Avalonia.Controls/Slider.cs               |  24 +++-
 src/Avalonia.Input/InputElement.cs            |  42 +++++-
 .../Controls/PseudoClassesExtensions.cs       |  28 ++++
 src/Avalonia.Styling/PseudoclassEngine.cs     | 120 ------------------
 src/Avalonia.Styling/StyledElement.cs         |  70 ----------
 15 files changed, 302 insertions(+), 251 deletions(-)
 create mode 100644 src/Avalonia.Styling/Controls/PseudoClassesExtensions.cs
 delete mode 100644 src/Avalonia.Styling/PseudoclassEngine.cs

diff --git a/src/Avalonia.Controls.DataGrid/DataGrid.cs b/src/Avalonia.Controls.DataGrid/DataGrid.cs
index 86133d5fdb2..a2b8544787b 100644
--- a/src/Avalonia.Controls.DataGrid/DataGrid.cs
+++ b/src/Avalonia.Controls.DataGrid/DataGrid.cs
@@ -373,7 +373,11 @@ private void OnAreRowGroupHeadersFrozenChanged(AvaloniaPropertyChangedEventArgs
         public bool IsValid
         {
             get { return _isValid; }
-            internal set { SetAndRaise(IsValidProperty, ref _isValid, value); }
+            internal set 
+            { 
+                SetAndRaise(IsValidProperty, ref _isValid, value);
+                PseudoClasses.Set(":invalid", !value);
+            }
         }
 
         public static readonly StyledProperty<double> MaxColumnWidthProperty =
@@ -656,8 +660,6 @@ static DataGrid()
                 HorizontalScrollBarVisibilityProperty,
                 VerticalScrollBarVisibilityProperty);
 
-            PseudoClass<DataGrid, bool>(IsValidProperty, x => !x, ":invalid");
-
             ItemsProperty.Changed.AddClassHandler<DataGrid>((x, e) => x.OnItemsPropertyChanged(e));
             CanUserResizeColumnsProperty.Changed.AddClassHandler<DataGrid>((x, e) => x.OnCanUserResizeColumnsChanged(e));
             ColumnWidthProperty.Changed.AddClassHandler<DataGrid>((x, e) => x.OnColumnWidthChanged(e));
diff --git a/src/Avalonia.Controls/Button.cs b/src/Avalonia.Controls/Button.cs
index 2e115463ac8..1e0fa01cc38 100644
--- a/src/Avalonia.Controls/Button.cs
+++ b/src/Avalonia.Controls/Button.cs
@@ -91,7 +91,11 @@ static Button()
             CommandProperty.Changed.Subscribe(CommandChanged);
             IsDefaultProperty.Changed.Subscribe(IsDefaultChanged);
             IsCancelProperty.Changed.Subscribe(IsCancelChanged);
-            PseudoClass<Button>(IsPressedProperty, ":pressed");
+        }
+
+        public Button()
+        {
+            UpdatePseudoClasses(IsPressed);
         }
 
         /// <summary>
@@ -312,6 +316,20 @@ protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
             IsPressed = false;
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == IsPressedProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<bool>());
+            }
+        }
+
         protected override void UpdateDataValidation<T>(AvaloniaProperty<T> property, BindingValue<T> value)
         {
             base.UpdateDataValidation(property, value);
@@ -474,5 +492,10 @@ private void RootCancelKeyDown(object sender, KeyEventArgs e)
                 OnClick();
             }
         }
+
+        private void UpdatePseudoClasses(bool isPressed)
+        {
+            PseudoClasses.Set(":pressed", isPressed);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/ButtonSpinner.cs b/src/Avalonia.Controls/ButtonSpinner.cs
index d8ea520a56c..6d4e2e33730 100644
--- a/src/Avalonia.Controls/ButtonSpinner.cs
+++ b/src/Avalonia.Controls/ButtonSpinner.cs
@@ -1,5 +1,6 @@
 using System;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 
@@ -34,6 +35,11 @@ public class ButtonSpinner : Spinner
         public static readonly StyledProperty<Location> ButtonSpinnerLocationProperty =
             AvaloniaProperty.Register<ButtonSpinner, Location>(nameof(ButtonSpinnerLocation), Location.Right);
 
+        public ButtonSpinner()
+        {
+            UpdatePseudoClasses(ButtonSpinnerLocation);
+        }
+
         private Button _decreaseButton;
         /// <summary>
         /// Gets or sets the DecreaseButton template part.
@@ -85,8 +91,6 @@ private Button IncreaseButton
         static ButtonSpinner()
         {
             AllowSpinProperty.Changed.Subscribe(AllowSpinChanged);
-            PseudoClass<ButtonSpinner, Location>(ButtonSpinnerLocationProperty, location => location == Location.Left, ":left");
-            PseudoClass<ButtonSpinner, Location>(ButtonSpinnerLocationProperty, location => location == Location.Right, ":right");
         }
 
         /// <summary>
@@ -201,6 +205,20 @@ protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
             }
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == ButtonSpinnerLocationProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<Location>());
+            }
+        }
+
         protected override void OnValidSpinDirectionChanged(ValidSpinDirections oldValue, ValidSpinDirections newValue)
         {
             SetButtonUsage();
@@ -259,5 +277,11 @@ private void OnButtonClick(object sender, RoutedEventArgs e)
                 OnSpin(new SpinEventArgs(SpinEvent, direction));
             }
         }
+
+        private void UpdatePseudoClasses(Location location)
+        {
+            PseudoClasses.Set(":left", location == Location.Left);
+            PseudoClasses.Set(":right", location == Location.Right);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/ControlExtensions.cs b/src/Avalonia.Controls/ControlExtensions.cs
index 3bd222d1321..859fd595480 100644
--- a/src/Avalonia.Controls/ControlExtensions.cs
+++ b/src/Avalonia.Controls/ControlExtensions.cs
@@ -69,26 +69,6 @@ public static T FindControl<T>(this IControl control, string name) where T : cla
             return nameScope.Find<T>(name);
         }
 
-        /// <summary>
-        /// Adds or removes a pseudoclass depending on a boolean value.
-        /// </summary>
-        /// <param name="classes">The pseudoclasses collection.</param>
-        /// <param name="name">The name of the pseudoclass to set.</param>
-        /// <param name="value">True to add the pseudoclass or false to remove.</param>
-        public static void Set(this IPseudoClasses classes, string name, bool value)
-        {
-            Contract.Requires<ArgumentNullException>(classes != null);
-
-            if (value)
-            {
-                classes.Add(name);
-            }
-            else
-            {
-                classes.Remove(name);
-            }
-        }
-
         /// <summary>
         /// Sets a pseudoclass depending on an observable trigger.
         /// </summary>
diff --git a/src/Avalonia.Controls/Expander.cs b/src/Avalonia.Controls/Expander.cs
index b2a442b6cc0..b16159fea0f 100644
--- a/src/Avalonia.Controls/Expander.cs
+++ b/src/Avalonia.Controls/Expander.cs
@@ -1,5 +1,6 @@
 using Avalonia.Animation;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 
 namespace Avalonia.Controls
 {
@@ -30,16 +31,14 @@ public class Expander : HeaderedContentControl
 
         static Expander()
         {
-            PseudoClass<Expander, ExpandDirection>(ExpandDirectionProperty, d => d == ExpandDirection.Down, ":down");
-            PseudoClass<Expander, ExpandDirection>(ExpandDirectionProperty, d => d == ExpandDirection.Up, ":up");
-            PseudoClass<Expander, ExpandDirection>(ExpandDirectionProperty, d => d == ExpandDirection.Left, ":left");
-            PseudoClass<Expander, ExpandDirection>(ExpandDirectionProperty, d => d == ExpandDirection.Right, ":right");
-
-            PseudoClass<Expander>(IsExpandedProperty, ":expanded");
-
             IsExpandedProperty.Changed.AddClassHandler<Expander>((x, e) => x.OnIsExpandedChanged(e));
         }
 
+        public Expander()
+        {
+            UpdatePseudoClasses(ExpandDirection);
+        }
+
         public IPageTransition ContentTransition
         {
             get => GetValue(ContentTransitionProperty);
@@ -55,7 +54,11 @@ public ExpandDirection ExpandDirection
         public bool IsExpanded
         {
             get { return _isExpanded; }
-            set { SetAndRaise(IsExpandedProperty, ref _isExpanded, value); }
+            set 
+            { 
+                SetAndRaise(IsExpandedProperty, ref _isExpanded, value);
+                PseudoClasses.Set(":expanded", value);
+            }
         }
 
         protected virtual void OnIsExpandedChanged(AvaloniaPropertyChangedEventArgs e)
@@ -74,5 +77,27 @@ protected virtual void OnIsExpandedChanged(AvaloniaPropertyChangedEventArgs e)
                 }
             }
         }
+
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == ExpandDirectionProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<ExpandDirection>());
+            }
+        }
+
+        private void UpdatePseudoClasses(ExpandDirection d)
+        {
+            PseudoClasses.Set(":up", d == ExpandDirection.Up);
+            PseudoClasses.Set(":down", d == ExpandDirection.Down);
+            PseudoClasses.Set(":left", d == ExpandDirection.Left);
+            PseudoClasses.Set(":right", d == ExpandDirection.Right);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs b/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
index aa91224572e..ec3bd7d688f 100644
--- a/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
+++ b/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
@@ -7,6 +7,7 @@
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Controls.Notifications
@@ -67,15 +68,12 @@ public WindowNotificationManager(Window host)
                         Install(host);
                     });
             }
+
+            UpdatePseudoClasses(Position);
         }
 
         static WindowNotificationManager()
         {
-            PseudoClass<WindowNotificationManager, NotificationPosition>(PositionProperty, x => x == NotificationPosition.TopLeft, ":topleft");
-            PseudoClass<WindowNotificationManager, NotificationPosition>(PositionProperty, x => x == NotificationPosition.TopRight, ":topright");
-            PseudoClass<WindowNotificationManager, NotificationPosition>(PositionProperty, x => x == NotificationPosition.BottomLeft, ":bottomleft");
-            PseudoClass<WindowNotificationManager, NotificationPosition>(PositionProperty, x => x == NotificationPosition.BottomRight, ":bottomright");
-
             HorizontalAlignmentProperty.OverrideDefaultValue<WindowNotificationManager>(Layout.HorizontalAlignment.Stretch);
             VerticalAlignmentProperty.OverrideDefaultValue<WindowNotificationManager>(Layout.VerticalAlignment.Stretch);
         }
@@ -142,6 +140,20 @@ public async void Show(object content)
             notificationControl.Close();
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == PositionProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<NotificationPosition>());
+            }
+        }
+
         /// <summary>
         /// Installs the <see cref="WindowNotificationManager"/> within the <see cref="AdornerLayer"/>
         /// of the host <see cref="Window"/>.
@@ -159,5 +171,13 @@ private void Install(Window host)
                 adornerLayer.Children.Add(this);
             }
         }
+
+        private void UpdatePseudoClasses(NotificationPosition position)
+        {
+            PseudoClasses.Set(":topleft", position == NotificationPosition.TopLeft);
+            PseudoClasses.Set(":topright", position == NotificationPosition.TopRight);
+            PseudoClasses.Set(":bottomleft", position == NotificationPosition.BottomLeft);
+            PseudoClasses.Set(":bottomright", position == NotificationPosition.BottomRight);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/ScrollBar.cs b/src/Avalonia.Controls/Primitives/ScrollBar.cs
index 4aaff94e447..d7ba899ff38 100644
--- a/src/Avalonia.Controls/Primitives/ScrollBar.cs
+++ b/src/Avalonia.Controls/Primitives/ScrollBar.cs
@@ -55,9 +55,6 @@ public class ScrollBar : RangeBase
         /// </summary>
         static ScrollBar()
         {
-            PseudoClass<ScrollBar, Orientation>(OrientationProperty, o => o == Orientation.Vertical, ":vertical");
-            PseudoClass<ScrollBar, Orientation>(OrientationProperty, o => o == Orientation.Horizontal, ":horizontal");
-
             Thumb.DragDeltaEvent.AddClassHandler<ScrollBar>((x, e) => x.OnThumbDragDelta(e), RoutingStrategies.Bubble);
             Thumb.DragCompletedEvent.AddClassHandler<ScrollBar>((x, e) => x.OnThumbDragComplete(e), RoutingStrategies.Bubble);
         }
@@ -74,6 +71,7 @@ public ScrollBar()
                 this.GetObservable(VisibilityProperty).Select(_ => Unit.Default))
                 .Select(_ => CalculateIsVisible());
             this.Bind(IsVisibleProperty, isVisible, BindingPriority.Style);
+            UpdatePseudoClasses(Orientation);
         }
 
         /// <summary>
@@ -143,6 +141,20 @@ protected override void OnKeyDown(KeyEventArgs e)
             }
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == OrientationProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<Orientation>());
+            }
+        }
+
         protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
         {
             base.OnTemplateApplied(e);
@@ -252,5 +264,11 @@ protected void OnScroll(ScrollEventType scrollEventType)
         {
             Scroll?.Invoke(this, new ScrollEventArgs(scrollEventType, Value));
         }
+
+        private void UpdatePseudoClasses(Orientation o)
+        {
+            PseudoClasses.Set(":vertical", o == Orientation.Vertical);
+            PseudoClasses.Set(":horizontal", o == Orientation.Horizontal);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/ToggleButton.cs b/src/Avalonia.Controls/Primitives/ToggleButton.cs
index e7cd0697a08..1b3cb09c1fd 100644
--- a/src/Avalonia.Controls/Primitives/ToggleButton.cs
+++ b/src/Avalonia.Controls/Primitives/ToggleButton.cs
@@ -1,8 +1,6 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
-using System;
-using Avalonia.Interactivity;
 using Avalonia.Data;
 
 namespace Avalonia.Controls.Primitives
@@ -22,17 +20,19 @@ public class ToggleButton : Button
 
         private bool? _isChecked = false;
 
-        static ToggleButton()
+        public ToggleButton()
         {
-            PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == true, ":checked");
-            PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == false, ":unchecked");
-            PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == null, ":indeterminate");
+            UpdatePseudoClasses(IsChecked);
         }
 
         public bool? IsChecked
         {
             get { return _isChecked; }
-            set { SetAndRaise(IsCheckedProperty, ref _isChecked, value); }
+            set 
+            { 
+                SetAndRaise(IsCheckedProperty, ref _isChecked, value);
+                UpdatePseudoClasses(value);
+            }
         }
 
         public bool IsThreeState
@@ -60,5 +60,12 @@ protected virtual void Toggle()
             else
                 IsChecked = false;
         }
+
+        private void UpdatePseudoClasses(bool? isChecked)
+        {
+            PseudoClasses.Set(":checked", isChecked == true);
+            PseudoClasses.Set(":unchecked", isChecked == false);
+            PseudoClasses.Set(":indeterminate", isChecked == null);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/Track.cs b/src/Avalonia.Controls/Primitives/Track.cs
index 292c65aa06b..e4de6ac00f8 100644
--- a/src/Avalonia.Controls/Primitives/Track.cs
+++ b/src/Avalonia.Controls/Primitives/Track.cs
@@ -4,6 +4,7 @@
 // Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
 
 using System;
+using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Metadata;
@@ -46,14 +47,17 @@ public class Track : Control
 
         static Track()
         {
-            PseudoClass<Track, Orientation>(OrientationProperty, o => o == Orientation.Vertical, ":vertical");
-            PseudoClass<Track, Orientation>(OrientationProperty, o => o == Orientation.Horizontal, ":horizontal");
             ThumbProperty.Changed.AddClassHandler<Track>((x,e) => x.ThumbChanged(e));
             IncreaseButtonProperty.Changed.AddClassHandler<Track>((x, e) => x.ButtonChanged(e));
             DecreaseButtonProperty.Changed.AddClassHandler<Track>((x, e) => x.ButtonChanged(e));
             AffectsArrange<Track>(MinimumProperty, MaximumProperty, ValueProperty, OrientationProperty);
         }
 
+        public Track()
+        {
+            UpdatePseudoClasses(Orientation);
+        }
+
         public double Minimum
         {
             get { return _minimum; }
@@ -276,6 +280,20 @@ protected override Size ArrangeOverride(Size arrangeSize)
             return arrangeSize;
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == OrientationProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<Orientation>());
+            }
+        }
+
         private static void CoerceLength(ref double componentLength, double trackLength)
         {
             if (componentLength < 0)
@@ -433,5 +451,11 @@ private void ShowChildren(bool visible)
                 DecreaseButton.IsVisible = visible;
             }
         }
+
+        private void UpdatePseudoClasses(Orientation o)
+        {
+            PseudoClasses.Set(":vertical", o == Orientation.Vertical);
+            PseudoClasses.Set(":horizontal", o == Orientation.Horizontal);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/ProgressBar.cs b/src/Avalonia.Controls/ProgressBar.cs
index 94898951a97..bfa31e3676a 100644
--- a/src/Avalonia.Controls/ProgressBar.cs
+++ b/src/Avalonia.Controls/ProgressBar.cs
@@ -4,6 +4,7 @@
 
 using System;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 using Avalonia.Layout;
 
 namespace Avalonia.Controls
@@ -35,14 +36,15 @@ public class ProgressBar : RangeBase
 
         static ProgressBar()
         {
-            PseudoClass<ProgressBar, Orientation>(OrientationProperty, o => o == Orientation.Vertical, ":vertical");
-            PseudoClass<ProgressBar, Orientation>(OrientationProperty, o => o == Orientation.Horizontal, ":horizontal");
-            PseudoClass<ProgressBar>(IsIndeterminateProperty, ":indeterminate");
-
             ValueProperty.Changed.AddClassHandler<ProgressBar>((x, e) => x.UpdateIndicatorWhenPropChanged(e));
             IsIndeterminateProperty.Changed.AddClassHandler<ProgressBar>((x, e) => x.UpdateIndicatorWhenPropChanged(e));
         }
 
+        public ProgressBar()
+        {
+            UpdatePseudoClasses(IsIndeterminate, Orientation);
+        }
+
         public bool IsIndeterminate
         {
             get => GetValue(IsIndeterminateProperty);
@@ -75,6 +77,24 @@ protected override Size ArrangeOverride(Size finalSize)
             return base.ArrangeOverride(finalSize);
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == IsIndeterminateProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<bool>(), null);
+            }
+            else if (property == OrientationProperty)
+            {
+                UpdatePseudoClasses(null, newValue.ValueOrDefault<Orientation>());
+            }
+        }
+
         /// <inheritdoc/>
         protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
         {
@@ -121,5 +141,21 @@ private void UpdateIndicatorWhenPropChanged(AvaloniaPropertyChangedEventArgs e)
         {
             UpdateIndicator(Bounds.Size);
         }
+
+        private void UpdatePseudoClasses(
+            bool? isIndeterminate,
+            Orientation? o)
+        {
+            if (isIndeterminate.HasValue)
+            {
+                PseudoClasses.Set(":indeterminate", isIndeterminate.Value);
+            }
+
+            if (o.HasValue)
+            {
+                PseudoClasses.Set(":vertical", o == Orientation.Vertical);
+                PseudoClasses.Set(":horizontal", o == Orientation.Horizontal);
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Slider.cs b/src/Avalonia.Controls/Slider.cs
index f71be8d8363..380dd0dd0e5 100644
--- a/src/Avalonia.Controls/Slider.cs
+++ b/src/Avalonia.Controls/Slider.cs
@@ -3,6 +3,7 @@
 
 using System;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
@@ -43,8 +44,6 @@ public class Slider : RangeBase
         static Slider()
         {
             OrientationProperty.OverrideDefaultValue(typeof(Slider), Orientation.Horizontal);
-            PseudoClass<Slider, Orientation>(OrientationProperty, o => o == Orientation.Vertical, ":vertical");
-            PseudoClass<Slider, Orientation>(OrientationProperty, o => o == Orientation.Horizontal, ":horizontal");
             Thumb.DragStartedEvent.AddClassHandler<Slider>((x, e) => x.OnThumbDragStarted(e), RoutingStrategies.Bubble);
             Thumb.DragDeltaEvent.AddClassHandler<Slider>((x, e) => x.OnThumbDragDelta(e), RoutingStrategies.Bubble);
             Thumb.DragCompletedEvent.AddClassHandler<Slider>((x, e) => x.OnThumbDragCompleted(e), RoutingStrategies.Bubble);
@@ -55,6 +54,7 @@ static Slider()
         /// </summary>
         public Slider()
         {
+            UpdatePseudoClasses(Orientation);
         }
 
         /// <summary>
@@ -137,6 +137,20 @@ private void ChangeValueBy(double by)
             }
         }
 
+        protected override void OnPropertyChanged<T>(
+            AvaloniaProperty<T> property,
+            Optional<T> oldValue,
+            BindingValue<T> newValue,
+            BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == OrientationProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<Orientation>());
+            }
+        }
+
         /// <summary>
         /// Called when user start dragging the <see cref="Thumb"/>.
         /// </summary>
@@ -190,5 +204,11 @@ private double SnapToTick(double value)
 
             return value;
         }
+
+        private void UpdatePseudoClasses(Orientation o)
+        {
+            PseudoClasses.Set(":vertical", o == Orientation.Vertical);
+            PseudoClasses.Set(":horizontal", o == Orientation.Horizontal);
+        }
     }
 }
diff --git a/src/Avalonia.Input/InputElement.cs b/src/Avalonia.Input/InputElement.cs
index 535b930f8bd..59dd6a7d4fb 100644
--- a/src/Avalonia.Input/InputElement.cs
+++ b/src/Avalonia.Input/InputElement.cs
@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Data;
 using Avalonia.Input.GestureRecognizers;
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
@@ -181,10 +183,11 @@ static InputElement()
             PointerReleasedEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerReleased(e));
             PointerCaptureLostEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerCaptureLost(e));
             PointerWheelChangedEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerWheelChanged(e));
+        }
 
-            PseudoClass<InputElement, bool>(IsEffectivelyEnabledProperty, x => !x, ":disabled");
-            PseudoClass<InputElement>(IsFocusedProperty, ":focus");
-            PseudoClass<InputElement>(IsPointerOverProperty, ":pointerover");
+        public InputElement()
+        {
+            UpdatePseudoClasses(IsFocused, IsPointerOver);
         }
 
         /// <summary>
@@ -372,7 +375,11 @@ public bool IsPointerOver
         public bool IsEffectivelyEnabled
         {
             get => _isEffectivelyEnabled;
-            private set => SetAndRaise(IsEffectivelyEnabledProperty, ref _isEffectivelyEnabled, value);
+            private set
+            {
+                SetAndRaise(IsEffectivelyEnabledProperty, ref _isEffectivelyEnabled, value);
+                PseudoClasses.Set(":disabled", !value);
+            }
         }
 
         public List<KeyBinding> KeyBindings { get; } = new List<KeyBinding>();
@@ -522,6 +529,20 @@ protected virtual void OnPointerWheelChanged(PointerWheelEventArgs e)
         {
         }
 
+        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        {
+            base.OnPropertyChanged(property, oldValue, newValue, priority);
+
+            if (property == IsFocusedProperty)
+            {
+                UpdatePseudoClasses(newValue.ValueOrDefault<bool>(), null);
+            }
+            else if (property == IsPointerOverProperty)
+            {
+                UpdatePseudoClasses(null, newValue.ValueOrDefault<bool>());
+            }
+        }
+
         /// <summary>
         /// Updates the <see cref="IsEffectivelyEnabled"/> property value according to the parent
         /// control's enabled state and <see cref="IsEnabledCore"/>.
@@ -578,5 +599,18 @@ private void UpdateIsEffectivelyEnabled(InputElement parent)
                 child?.UpdateIsEffectivelyEnabled(this);
             }
         }
+
+        private void UpdatePseudoClasses(bool? isFocused, bool? isPointerOver)
+        {
+            if (isFocused.HasValue)
+            {
+                PseudoClasses.Set(":focus", isFocused.Value);
+            }
+            
+            if (isPointerOver.HasValue)
+            {
+                PseudoClasses.Set(":pointerover", isPointerOver.Value);
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Styling/Controls/PseudoClassesExtensions.cs b/src/Avalonia.Styling/Controls/PseudoClassesExtensions.cs
new file mode 100644
index 00000000000..7b28d1a9118
--- /dev/null
+++ b/src/Avalonia.Styling/Controls/PseudoClassesExtensions.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace Avalonia.Controls
+{
+    public static class PseudolassesExtensions
+    {
+        /// <summary>
+        /// Adds or removes a pseudoclass depending on a boolean value.
+        /// </summary>
+        /// <param name="classes">The pseudoclasses collection.</param>
+        /// <param name="name">The name of the pseudoclass to set.</param>
+        /// <param name="value">True to add the pseudoclass or false to remove.</param>
+        public static void Set(this IPseudoClasses classes, string name, bool value)
+        {
+            Contract.Requires<ArgumentNullException>(classes != null);
+
+            if (value)
+            {
+                classes.Add(name);
+            }
+            else
+            {
+                classes.Remove(name);
+            }
+        }
+
+    }
+}
diff --git a/src/Avalonia.Styling/PseudoclassEngine.cs b/src/Avalonia.Styling/PseudoclassEngine.cs
deleted file mode 100644
index 6c8f8a832ac..00000000000
--- a/src/Avalonia.Styling/PseudoclassEngine.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Avalonia.Controls;
-
-namespace Avalonia
-{
-    internal static class PseudoclassEngine
-    {
-        private static Dictionary<Type, List<IEntry>> _entries = new Dictionary<Type, List<IEntry>>();
-        private static Dictionary<AvaloniaProperty, List<IEntry>> _properties = new Dictionary<AvaloniaProperty, List<IEntry>>();
-        private static Dictionary<Type, List<IEntry>> _cache = new Dictionary<Type, List<IEntry>>();
-
-        public static void Created(StyledElement element)
-        {
-            var t = element.GetType();
-
-            if (!_cache.TryGetValue(t, out var list))
-            {
-                list = new List<IEntry>();
-
-                foreach (var i in _entries)
-                {
-                    if (i.Key.IsAssignableFrom(t))
-                    {
-                        list.AddRange(i.Value);
-                    }
-                }
-
-                _cache.Add(t, list);
-            }
-
-            foreach (var i in list)
-            {
-                i.Update(element);
-            }
-        }
-
-        public static void Register<T>(
-            Type type,
-            AvaloniaProperty<T> property,
-            Func<T, bool> selector,
-            string className)
-        {
-            if (!_entries.TryGetValue(type, out var list))
-            {
-                list = new List<IEntry>();
-                _entries.Add(type, list);
-            }
-
-            var entry = new Entry<T>(type, property, selector, className);
-            list.Add(entry);
-            
-            if (!_properties.TryGetValue(property, out list))
-            {
-                list = new List<IEntry>();
-                _properties.Add(property, list);
-                property.Changed.Subscribe(ValueChanged);
-            }
-
-            list.Add(entry);
-        }
-
-        private static void ValueChanged(AvaloniaPropertyChangedEventArgs e)
-        {
-            if (e.Sender is StyledElement element &&
-                _properties.TryGetValue(e.Property, out var list))
-            {
-                var t = e.Sender.GetType();
-
-                foreach (var i in list)
-                {
-                    if (i.Type.IsAssignableFrom(t))
-                    {
-                        i.Update(element);
-                    }
-                }
-            }
-        }
-
-        private interface IEntry
-        {
-            Type Type { get; }
-            void Update(StyledElement element);
-        }
-
-        private class Entry<T> : IEntry
-        {
-            public Entry(
-                Type type,
-                AvaloniaProperty<T> property,
-                Func<T, bool> selector,
-                string className)
-            {
-                Type = type;
-                Property = property;
-                Selector = selector;
-                ClassName = className;
-            }
-
-            public Type Type { get; }
-            public AvaloniaProperty<T> Property { get; }
-            public Func<T, bool> Selector { get; }
-            public string ClassName { get; }
-
-            public void Update(StyledElement element)
-            {
-                var value = element.GetValue(Property);
-
-                if (Selector(value))
-                {
-                    ((IPseudoClasses)element.Classes).Add(ClassName);
-                }
-                else
-                {
-                    ((IPseudoClasses)element.Classes).Remove(ClassName);
-                }
-            }
-        }
-    }
-}
diff --git a/src/Avalonia.Styling/StyledElement.cs b/src/Avalonia.Styling/StyledElement.cs
index 90e1259ce64..44cd1c46870 100644
--- a/src/Avalonia.Styling/StyledElement.cs
+++ b/src/Avalonia.Styling/StyledElement.cs
@@ -82,7 +82,6 @@ static StyledElement()
         public StyledElement()
         {
             _isAttachedToLogicalTree = this is IStyleRoot;
-            PseudoclassEngine.Created(this);
         }
 
         /// <summary>
@@ -496,75 +495,6 @@ void ISetInheritanceParent.SetParent(IAvaloniaObject parent)
             InheritanceParent = parent;
         }
 
-        /// <summary>
-        /// Adds a pseudo-class to be set when a property is true.
-        /// </summary>
-        /// <param name="property">The property.</param>
-        /// <param name="className">The pseudo-class.</param>
-        [Obsolete("Use PseudoClass<TOwner> and specify the control type.")]
-        protected static void PseudoClass(AvaloniaProperty<bool> property, string className)
-        {
-            PseudoClass<StyledElement>(property, className);
-        }
-
-        /// <summary>
-        /// Adds a pseudo-class to be set when a property is true.
-        /// </summary>
-        /// <typeparam name="TOwner">The type to apply the pseudo-class to.</typeparam>
-        /// <param name="property">The property.</param>
-        /// <param name="className">The pseudo-class.</param>
-        protected static void PseudoClass<TOwner>(AvaloniaProperty<bool> property, string className)
-            where TOwner : class, IStyledElement
-        {
-            PseudoClass<TOwner, bool>(property, x => x, className);
-        }
-
-        /// <summary>
-        /// Adds a pseudo-class to be set when a property equals a certain value.
-        /// </summary>
-        /// <typeparam name="TProperty">The type of the property.</typeparam>
-        /// <param name="property">The property.</param>
-        /// <param name="selector">Returns a boolean value based on the property value.</param>
-        /// <param name="className">The pseudo-class.</param>
-        [Obsolete("Use PseudoClass<TOwner, TProperty> and specify the control type.")]
-        protected static void PseudoClass<TProperty>(
-            AvaloniaProperty<TProperty> property,
-            Func<TProperty, bool> selector,
-            string className)
-        {
-            PseudoClass<StyledElement, TProperty>(property, selector, className);
-        }
-
-        /// <summary>
-        /// Adds a pseudo-class to be set when a property equals a certain value.
-        /// </summary>
-        /// <typeparam name="TProperty">The type of the property.</typeparam>
-        /// <typeparam name="TOwner">The type to apply the pseudo-class to.</typeparam>
-        /// <param name="property">The property.</param>
-        /// <param name="selector">Returns a boolean value based on the property value.</param>
-        /// <param name="className">The pseudo-class.</param>
-        protected static void PseudoClass<TOwner, TProperty>(
-            AvaloniaProperty<TProperty> property,
-            Func<TProperty, bool> selector,
-            string className)
-                where TOwner : class, IStyledElement
-        {
-            Contract.Requires<ArgumentNullException>(property != null);
-            Contract.Requires<ArgumentNullException>(selector != null);
-            Contract.Requires<ArgumentNullException>(className != null);
-
-            if (string.IsNullOrWhiteSpace(className))
-            {
-                throw new ArgumentException("Cannot supply an empty className.");
-            }
-
-            PseudoclassEngine.Register(
-                typeof(TOwner),
-                property,
-                selector,
-                className);
-        }
-
         protected virtual void LogicalChildrenCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             switch (e.Action)

From 8fed6ed94662523cdc8e4946c7d8936155a1133f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 3 Feb 2020 15:02:36 +0100
Subject: [PATCH 4/4] Moved subscription to static ctor.

---
 src/Avalonia.Controls/Primitives/ToggleButton.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Primitives/ToggleButton.cs b/src/Avalonia.Controls/Primitives/ToggleButton.cs
index c4f1f2c7e7e..83a2d6d9e49 100644
--- a/src/Avalonia.Controls/Primitives/ToggleButton.cs
+++ b/src/Avalonia.Controls/Primitives/ToggleButton.cs
@@ -49,10 +49,14 @@ public class ToggleButton : Button
 
         private bool? _isChecked = false;
 
+        static ToggleButton()
+        {
+            IsCheckedProperty.Changed.AddClassHandler<ToggleButton>((x, e) => x.OnIsCheckedChanged(e));
+        }
+
         public ToggleButton()
         {
             UpdatePseudoClasses(IsChecked);
-            IsCheckedProperty.Changed.AddClassHandler<ToggleButton>((x, e) => x.OnIsCheckedChanged(e));
         }
 
         /// <summary>