Merge branch 'master' into fixes/prevent-invalid-draw-operation-bounds

src/Avalonia.Animation/Animatable.cs

@@ -1,10 +1,10 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.Collections.Specialized;
-using System.Reactive.Linq;
-using Avalonia.Collections;
 using Avalonia.Data;
-using Avalonia.Animation.Animators;
+
+#nullable enable
 
 namespace Avalonia.Animation
 {
@@ -13,9 +13,24 @@ namespace Avalonia.Animation
     /// </summary>
     public class Animatable : AvaloniaObject
     {
+        /// <summary>
+        /// Defines the <see cref="Clock"/> property.
+        /// </summary>
         public static readonly StyledProperty<IClock> ClockProperty =
             AvaloniaProperty.Register<Animatable, IClock>(nameof(Clock), inherits: true);
 
+        /// <summary>
+        /// Defines the <see cref="Transitions"/> property.
+        /// </summary>
+        public static readonly StyledProperty<Transitions?> TransitionsProperty =
+            AvaloniaProperty.Register<Animatable, Transitions?>(nameof(Transitions));
+
+        private bool _transitionsEnabled = true;
+        private Dictionary<ITransition, TransitionState>? _transitionState;
+
+        /// <summary>
+        /// Gets or sets the clock which controls the animations on the control.
+        /// </summary>
         public IClock Clock
         {
             get => GetValue(ClockProperty);
@@ -23,72 +38,194 @@ namespace Avalonia.Animation
         }
 
         /// <summary>
-        /// Defines the <see cref="Transitions"/> property.
+        /// Gets or sets the property transitions for the control.
         /// </summary>
-        public static readonly DirectProperty<Animatable, Transitions> TransitionsProperty =
+        public Transitions? Transitions
-            AvaloniaProperty.RegisterDirect<Animatable, Transitions>(
+        {
-                nameof(Transitions),
+            get => GetValue(TransitionsProperty);
-                o => o.Transitions,
+            set => SetValue(TransitionsProperty, value);
-                (o, v) => o.Transitions = v);
+        }
 
-        private Transitions _transitions;
+        /// <summary>
+        /// Enables transitions for the control.
+        /// </summary>
+        /// <remarks>
+        /// This method should not be called from user code, it will be called automatically by the framework
+        /// when a control is added to the visual tree.
+        /// </remarks>
+        protected void EnableTransitions()
+        {
+            if (!_transitionsEnabled)
+            {
+                _transitionsEnabled = true;
 
-        private Dictionary<AvaloniaProperty, IDisposable> _previousTransitions;
+                if (Transitions is object)
+                {
+                    AddTransitions(Transitions);
+                }
+            }
+        }
 
         /// <summary>
-        /// Gets or sets the property transitions for the control.
+        /// Disables transitions for the control.
         /// </summary>
-        public Transitions Transitions
+        /// <remarks>
+        /// This method should not be called from user code, it will be called automatically by the framework
+        /// when a control is added to the visual tree.
+        /// </remarks>
+        protected void DisableTransitions()
+        {
+            if (_transitionsEnabled)
+            {
+                _transitionsEnabled = false;
+
+                if (Transitions is object)
+                {
+                    RemoveTransitions(Transitions);
+                }
+            }
+        }
+
+        protected sealed override void OnPropertyChangedCore<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            get
+            if (change.Property == TransitionsProperty && change.IsEffectiveValueChange)
             {
-                if (_transitions is null)
+                var oldTransitions = change.OldValue.GetValueOrDefault<Transitions>();
-                    _transitions = new Transitions();
+                var newTransitions = change.NewValue.GetValueOrDefault<Transitions>();
 
-                if (_previousTransitions is null)
+                if (oldTransitions is object)
-                    _previousTransitions = new Dictionary<AvaloniaProperty, IDisposable>();
+                {
+                    oldTransitions.CollectionChanged -= TransitionsCollectionChanged;
+                    RemoveTransitions(oldTransitions);
+                }
 
-                return _transitions;
+                if (newTransitions is object)
+                {
+                    newTransitions.CollectionChanged += TransitionsCollectionChanged;
+                    AddTransitions(newTransitions);
+                }
             }
-            set
+            else if (_transitionsEnabled &&
+                     Transitions is object &&
+                     _transitionState is object &&
+                     !change.Property.IsDirect &&
+                     change.Priority > BindingPriority.Animation)
             {
-                if (value is null)
+                foreach (var transition in Transitions)
-                    return;
+                {
+                    if (transition.Property == change.Property)
+                    {
+                        var state = _transitionState[transition];
+                        var oldValue = state.BaseValue;
+                        var newValue = GetAnimationBaseValue(transition.Property);
 
-                if (_previousTransitions is null)
+                        if (!Equals(oldValue, newValue))
-                    _previousTransitions = new Dictionary<AvaloniaProperty, IDisposable>();
+                        {
+                            state.BaseValue = newValue;
 
-                SetAndRaise(TransitionsProperty, ref _transitions, value);
+                            // We need to transition from the current animated value if present,
+                            // instead of the old base value.
+                            var animatedValue = GetValue(transition.Property);
+
+                            if (!Equals(newValue, animatedValue))
+                            {
+                                oldValue = animatedValue;
+                            }
+
+                            state.Instance?.Dispose();
+                            state.Instance = transition.Apply(
+                                this,
+                                Clock ?? AvaloniaLocator.Current.GetService<IGlobalClock>(),
+                                oldValue,
+                                newValue);
+                            return;
+                        }
+                    }
+                }
+            }
+
+            base.OnPropertyChangedCore(change);
+        }
+
+        private void TransitionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (!_transitionsEnabled)
+            {
+                return;
+            }
+
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    AddTransitions(e.NewItems);
+                    break;
+                case NotifyCollectionChangedAction.Remove:
+                    RemoveTransitions(e.OldItems);
+                    break;
+                case NotifyCollectionChangedAction.Replace:
+                    RemoveTransitions(e.OldItems);
+                    AddTransitions(e.NewItems);
+                    break;
+                case NotifyCollectionChangedAction.Reset:
+                    throw new NotSupportedException("Transitions collection cannot be reset.");
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        private void AddTransitions(IList items)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            if (_transitions is null || _previousTransitions is null || priority == BindingPriority.Animation)
+            if (!_transitionsEnabled)
+            {
                 return;
+            }
+
+            _transitionState ??= new Dictionary<ITransition, TransitionState>();
 
-            // PERF-SENSITIVE: Called on every property change. Don't use LINQ here (too many allocations).
+            for (var i = 0; i < items.Count; ++i)
-            foreach (var transition in _transitions)
             {
-                if (transition.Property == property)
+                var t = (ITransition)items[i];
+
+                _transitionState.Add(t, new TransitionState
                 {
-                    if (_previousTransitions.TryGetValue(property, out var dispose))
+                    BaseValue = GetAnimationBaseValue(t.Property),
-                        dispose.Dispose();
+                });
+            }
+        }
 
-                    var instance = transition.Apply(
+        private void RemoveTransitions(IList items)
-                        this,
+        {
-                        Clock ?? Avalonia.Animation.Clock.GlobalClock,
+            if (_transitionState is null)
-                        oldValue.GetValueOrDefault(),
+            {
-                        newValue.GetValueOrDefault());
+                return;
+            }
 
-                    _previousTransitions[property] = instance;
+            for (var i = 0; i < items.Count; ++i)
-                    return;
+            {
+                var t = (ITransition)items[i];
+
+                if (_transitionState.TryGetValue(t, out var state))
+                {
+                    state.Instance?.Dispose();
+                    _transitionState.Remove(t);
                 }
             }
         }
+
+        private object GetAnimationBaseValue(AvaloniaProperty property)
+        {
+            var value = this.GetBaseValue(property, BindingPriority.LocalValue);
+
+            if (value == AvaloniaProperty.UnsetValue)
+            {
+                value = GetValue(property);
+            }
+
+            return value;
+        }
+
+        private class TransitionState
+        {
+            public IDisposable? Instance { get; set; }
+            public object? BaseValue { get; set; }
+        }
     }
 }

src/Avalonia.Animation/TransitionInstance.cs

@@ -19,6 +19,8 @@ namespace Avalonia.Animation
 
         public TransitionInstance(IClock clock, TimeSpan Duration)
         {
+            clock = clock ?? throw new ArgumentNullException(nameof(clock));
+
             _duration = Duration;
             _baseClock = clock;
         }

src/Avalonia.Animation/Transitions.cs

@@ -1,4 +1,6 @@
+using System;
 using Avalonia.Collections;
+using Avalonia.Threading;
 
 namespace Avalonia.Animation
 {
@@ -13,6 +15,17 @@ namespace Avalonia.Animation
         public Transitions()
         {
             ResetBehavior = ResetBehavior.Remove;
+            Validate = ValidateTransition;
+        }
+
+        private void ValidateTransition(ITransition obj)
+        {
+            Dispatcher.UIThread.VerifyAccess();
+
+            if (obj.Property.IsDirect)
+            {
+                throw new InvalidOperationException("Cannot animate a direct property.");
+            }
         }
     }
 }

src/Avalonia.Base/AvaloniaObject.cs

@@ -259,6 +259,21 @@ namespace Avalonia
             return registered.InvokeGetter(this);
         }
 
+        /// <inheritdoc/>
+        public Optional<T> GetBaseValue<T>(StyledPropertyBase<T> property, BindingPriority maxPriority)
+        {
+            property = property ?? throw new ArgumentNullException(nameof(property));
+            VerifyAccess();
+
+            if (_values is object &&
+                _values.TryGetValue(property, maxPriority, out var value))
+            {
+                return value;
+            }
+
+            return default;
+        }
+
         /// <summary>
         /// Checks whether a <see cref="AvaloniaProperty"/> is animating.
         /// </summary>
@@ -458,29 +473,43 @@ namespace Avalonia
             return _propertyChanged?.GetInvocationList();
         }
 
-        void IValueSink.ValueChanged<T>(
+        void IValueSink.ValueChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            StyledPropertyBase<T> property,
-            BindingPriority priority,
-            Optional<T> oldValue,
-            BindingValue<T> newValue)
         {
-            oldValue = oldValue.HasValue ? oldValue : GetInheritedOrDefault(property);
+            var property = (StyledPropertyBase<T>)change.Property;
-            newValue = newValue.HasValue ? newValue : newValue.WithValue(GetInheritedOrDefault(property));
 
-            LogIfError(property, newValue);
+            LogIfError(property, change.NewValue);
 
-            if (!EqualityComparer<T>.Default.Equals(oldValue.Value, newValue.Value))
+            // If the change is to the effective value of the property and no old/new value is set
+            // then fill in the old/new value from property inheritance/default value. We don't do
+            // this for non-effective value changes because these are only needed for property
+            // transitions, where knowing e.g. that an inherited value is active at an arbitrary
+            // priority isn't of any use and would introduce overhead.
+            if (change.IsEffectiveValueChange && !change.OldValue.HasValue)
             {
-                RaisePropertyChanged(property, oldValue, newValue, priority);
+                change.SetOldValue(GetInheritedOrDefault<T>(property));
+            }
 
-                Logger.TryGet(LogEventLevel.Verbose)?.Log(
+            if (change.IsEffectiveValueChange && !change.NewValue.HasValue)
-                    LogArea.Property,
+            {
-                    this,
+                change.SetNewValue(GetInheritedOrDefault(property));
-                    "{Property} changed from {$Old} to {$Value} with priority {Priority}",
+            }
-                    property,
+
-                    oldValue,
+            if (!change.IsEffectiveValueChange ||
-                    newValue,
+                !EqualityComparer<T>.Default.Equals(change.OldValue.Value, change.NewValue.Value))
-                    (BindingPriority)priority);
+            {
+                RaisePropertyChanged(change);
+
+                if (change.IsEffectiveValueChange)
+                {
+                    Logger.TryGet(LogEventLevel.Verbose)?.Log(
+                        LogArea.Property,
+                        this,
+                        "{Property} changed from {$Old} to {$Value} with priority {Priority}",
+                        property,
+                        change.OldValue,
+                        change.NewValue,
+                        change.Priority);
+                }
             }
         }
 
@@ -489,7 +518,13 @@ namespace Avalonia
             IPriorityValueEntry entry,
             Optional<T> oldValue) 
         {
-            ((IValueSink)this).ValueChanged(property, BindingPriority.Unset, oldValue, default);
+            var change = new AvaloniaPropertyChangedEventArgs<T>(
+                this,
+                property,
+                oldValue,
+                default,
+                BindingPriority.Unset);
+            ((IValueSink)this).ValueChanged(change);
         }
 
         /// <summary>
@@ -575,15 +610,20 @@ namespace Avalonia
         /// <summary>
         /// Called when a avalonia property changes on the object.
         /// </summary>
-        /// <param name="property">The property whose value has changed.</param>
+        /// <param name="change">The property change details.</param>
-        /// <param name="oldValue">The old value of the property.</param>
+        protected virtual void OnPropertyChangedCore<T>(AvaloniaPropertyChangedEventArgs<T> change)
-        /// <param name="newValue">The new value of the property.</param>
+        {
-        /// <param name="priority">The priority of the new value.</param>
+            if (change.IsEffectiveValueChange)
-        protected virtual void OnPropertyChanged<T>(
+            {
-            AvaloniaProperty<T> property,
+                OnPropertyChanged(change);
-            Optional<T> oldValue,
+            }
-            BindingValue<T> newValue,
+        }
-            BindingPriority priority)
+
+        /// <summary>
+        /// Called when a avalonia property changes on the object.
+        /// </summary>
+        /// <param name="change">The property change details.</param>
+        protected virtual void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
         }
 
@@ -600,57 +640,12 @@ namespace Avalonia
             BindingValue<T> newValue,
             BindingPriority priority = BindingPriority.LocalValue)
         {
-            property = property ?? throw new ArgumentNullException(nameof(property));
+            RaisePropertyChanged(new AvaloniaPropertyChangedEventArgs<T>(
-
+                this,
-            VerifyAccess();
+                property,
-
+                oldValue,
-            property.Notifying?.Invoke(this, true);
+                newValue,
-
+                priority));
-            try
-            {
-                AvaloniaPropertyChangedEventArgs<T> e = null;
-                var hasChanged = property.HasChangedSubscriptions;
-
-                if (hasChanged || _propertyChanged != null)
-                {
-                    e = new AvaloniaPropertyChangedEventArgs<T>(
-                        this,
-                        property,
-                        oldValue,
-                        newValue,
-                        priority);
-                }
-
-                OnPropertyChanged(property, oldValue, newValue, priority);
-
-                if (hasChanged)
-                {
-                    property.NotifyChanged(e);
-                }
-
-                _propertyChanged?.Invoke(this, e);
-
-                if (_inpcChanged != null)
-                {
-                    var inpce = new PropertyChangedEventArgs(property.Name);
-                    _inpcChanged(this, inpce);
-                }
-
-                if (property.Inherits && _inheritanceChildren != null)
-                {
-                    foreach (var child in _inheritanceChildren)
-                    {
-                        child.InheritedPropertyChanged(
-                            property,
-                            oldValue,
-                            newValue.ToOptional());
-                    }
-                }
-            }
-            finally
-            {
-                property.Notifying?.Invoke(this, false);
-            }
         }
 
         /// <summary>
@@ -689,7 +684,9 @@ namespace Avalonia
             return property.GetDefaultValue(GetType());
         }
 
-        private T GetValueOrInheritedOrDefault<T>(StyledPropertyBase<T> property)
+        private T GetValueOrInheritedOrDefault<T>(
+            StyledPropertyBase<T> property,
+            BindingPriority maxPriority = BindingPriority.Animation)
         {
             var o = this;
             var inherits = property.Inherits;
@@ -699,7 +696,7 @@ namespace Avalonia
             {
                 var values = o._values;
 
-                if (values?.TryGetValue(property, out value) == true)
+                if (values?.TryGetValue(property, maxPriority, out value) == true)
                 {
                     return value;
                 }
@@ -715,6 +712,51 @@ namespace Avalonia
             return property.GetDefaultValue(GetType());
         }
 
+        protected internal void RaisePropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
+        {
+            VerifyAccess();
+
+            if (change.IsEffectiveValueChange)
+            {
+                change.Property.Notifying?.Invoke(this, true);
+            }
+
+            try
+            {
+                OnPropertyChangedCore(change);
+
+                if (change.IsEffectiveValueChange)
+                {
+                    change.Property.NotifyChanged(change);
+                    _propertyChanged?.Invoke(this, change);
+
+                    if (_inpcChanged != null)
+                    {
+                        var inpce = new PropertyChangedEventArgs(change.Property.Name);
+                        _inpcChanged(this, inpce);
+                    }
+
+                    if (change.Property.Inherits && _inheritanceChildren != null)
+                    {
+                        foreach (var child in _inheritanceChildren)
+                        {
+                            child.InheritedPropertyChanged(
+                                change.Property,
+                                change.OldValue,
+                                change.NewValue.ToOptional());
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (change.IsEffectiveValueChange)
+                {
+                    change.Property.Notifying?.Invoke(this, false);
+                }
+            }
+        }
+
         /// <summary>
         /// Sets the value of a direct property.
         /// </summary>

src/Avalonia.Base/AvaloniaObjectExtensions.cs

@@ -448,6 +448,65 @@ namespace Avalonia
             };
         }
 
+        /// <summary>
+        /// Gets an <see cref="AvaloniaProperty"/> base value.
+        /// </summary>
+        /// <param name="target">The object.</param>
+        /// <param name="property">The property.</param>
+        /// <param name="maxPriority">The maximum priority for the value.</param>
+        /// <remarks>
+        /// For styled properties, gets the value of the property if set on the object with a
+        /// priority equal or lower to <paramref name="maxPriority"/>, otherwise
+        /// <see cref="AvaloniaProperty.UnsetValue"/>. Note that this method does not return
+        /// property values that come from inherited or default values.
+        /// 
+        /// For direct properties returns <see cref="GetValue(IAvaloniaObject, AvaloniaProperty)"/>.
+        /// </remarks>
+        public static object GetBaseValue(
+            this IAvaloniaObject target,
+            AvaloniaProperty property,
+            BindingPriority maxPriority)
+        {
+            target = target ?? throw new ArgumentNullException(nameof(target));
+            property = property ?? throw new ArgumentNullException(nameof(property));
+
+            return property.RouteGetBaseValue(target, maxPriority);
+        }
+
+        /// <summary>
+        /// Gets an <see cref="AvaloniaProperty"/> base value.
+        /// </summary>
+        /// <param name="target">The object.</param>
+        /// <param name="property">The property.</param>
+        /// <param name="maxPriority">The maximum priority for the value.</param>
+        /// <remarks>
+        /// For styled properties, gets the value of the property if set on the object with a
+        /// priority equal or lower to <paramref name="maxPriority"/>, otherwise
+        /// <see cref="Optional{T}.Empty"/>. Note that this method does not return property values
+        /// that come from inherited or default values.
+        /// 
+        /// For direct properties returns
+        /// <see cref="IAvaloniaObject.GetValue{T}(DirectPropertyBase{T})"/>.
+        /// </remarks>
+        public static Optional<T> GetBaseValue<T>(
+            this IAvaloniaObject target,
+            AvaloniaProperty<T> property,
+            BindingPriority maxPriority)
+        {
+            target = target ?? throw new ArgumentNullException(nameof(target));
+            property = property ?? throw new ArgumentNullException(nameof(property));
+
+            target = target ?? throw new ArgumentNullException(nameof(target));
+            property = property ?? throw new ArgumentNullException(nameof(property));
+
+            return property switch
+            {
+                StyledPropertyBase<T> styled => target.GetBaseValue(styled, maxPriority),
+                DirectPropertyBase<T> direct => target.GetValue(direct),
+                _ => throw new NotSupportedException("Unsupported AvaloniaProperty type.")
+            };
+        }
+
         /// <summary>
         /// Sets a <see cref="AvaloniaProperty"/> value.
         /// </summary>

src/Avalonia.Base/AvaloniaProperty.cs

@@ -496,6 +496,13 @@ namespace Avalonia
         /// <param name="o">The object instance.</param>
         internal abstract object RouteGetValue(IAvaloniaObject o);
 
+        /// <summary>
+        /// Routes an untyped GetBaseValue call to a typed call.
+        /// </summary>
+        /// <param name="o">The object instance.</param>
+        /// <param name="maxPriority">The maximum priority for the value.</param>
+        internal abstract object RouteGetBaseValue(IAvaloniaObject o, BindingPriority maxPriority);
+
         /// <summary>
         /// Routes an untyped SetValue call to a typed call.
         /// </summary>

src/Avalonia.Base/AvaloniaPropertyChangedEventArgs.cs

@@ -16,6 +16,7 @@ namespace Avalonia
         {
             Sender = sender;
             Priority = priority;
+            IsEffectiveValueChange = true;
         }
 
         /// <summary>
@@ -35,19 +36,11 @@ namespace Avalonia
         /// <summary>
         /// Gets the old value of the property.
         /// </summary>
-        /// <value>
-        /// The old value of the property or <see cref="AvaloniaProperty.UnsetValue"/> if the
-        /// property previously had no value.
-        /// </value>
         public object? OldValue => GetOldValue();
 
         /// <summary>
         /// Gets the new value of the property.
         /// </summary>
-        /// <value>
-        /// The new value of the property or <see cref="AvaloniaProperty.UnsetValue"/> if the
-        /// property previously had no value.
-        /// </value>
         public object? NewValue => GetNewValue();
 
         /// <summary>
@@ -58,6 +51,20 @@ namespace Avalonia
         /// </value>
         public BindingPriority Priority { get; private set; }
 
+        /// <summary>
+        /// Gets a value indicating whether the change represents a change to the effective value of
+        /// the property.
+        /// </summary>
+        /// <remarks>
+        /// This will usually be true, except in
+        /// <see cref="AvaloniaObject.OnPropertyChangedCore{T}(AvaloniaPropertyChangedEventArgs{T})"/>
+        /// which recieves notifications for all changes to property values, whether a value with a higher
+        /// priority is present or not. When this property is false, the change that is being signalled
+        /// has not resulted in a change to the property value on the object.
+        /// </remarks>
+        public bool IsEffectiveValueChange { get; private set; }
+
+        internal void MarkNonEffectiveValue() => IsEffectiveValueChange = false;
         protected abstract AvaloniaProperty GetProperty();
         protected abstract object? GetOldValue();
         protected abstract object? GetNewValue();

src/Avalonia.Base/AvaloniaPropertyChangedEventArgs`1.cs

@@ -1,4 +1,3 @@
-using System;
 using Avalonia.Data;
 
 #nullable enable
@@ -6,7 +5,7 @@ using Avalonia.Data;
 namespace Avalonia
 {
     /// <summary>
-    /// Provides information for a avalonia property change.
+    /// Provides information for an Avalonia property change.
     /// </summary>
     public class AvaloniaPropertyChangedEventArgs<T> : AvaloniaPropertyChangedEventArgs
     {
@@ -42,19 +41,28 @@ namespace Avalonia
         /// <summary>
         /// Gets the old value of the property.
         /// </summary>
-        /// <value>
+        /// <remarks>
-        /// The old value of the property.
+        /// When <see cref="AvaloniaPropertyChangedEventArgs.IsEffectiveValueChange"/> is true, returns the
-        /// </value>
+        /// old value of the property on the object. 
+        /// When <see cref="AvaloniaPropertyChangedEventArgs.IsEffectiveValueChange"/> is false, returns
+        /// <see cref="Optional{T}.Empty"/>.
+        /// </remarks>
         public new Optional<T> OldValue { get; private set; }
 
         /// <summary>
         /// Gets the new value of the property.
         /// </summary>
-        /// <value>
+        /// <remarks>
-        /// The new value of the property.
+        /// When <see cref="AvaloniaPropertyChangedEventArgs.IsEffectiveValueChange"/> is true, returns the
-        /// </value>
+        /// value of the property on the object.
+        /// When <see cref="AvaloniaPropertyChangedEventArgs.IsEffectiveValueChange"/> is false returns the
+        /// changed value, or <see cref="Optional{T}.Empty"/> if the value was removed.
+        /// </remarks>
         public new BindingValue<T> NewValue { get; private set; }
 
+        internal void SetOldValue(Optional<T> value) => OldValue = value;
+        internal void SetNewValue(BindingValue<T> value) => NewValue = value;
+
         protected override AvaloniaProperty GetProperty() => Property;
 
         protected override object? GetOldValue() => OldValue.GetValueOrDefault(AvaloniaProperty.UnsetValue);

src/Avalonia.Base/Data/BindingValue.cs

@@ -348,8 +348,8 @@ namespace Avalonia.Data
 
             return new BindingValue<T>(
                 fallbackValue.HasValue ?
-                    BindingValueType.DataValidationError :
+                    BindingValueType.DataValidationErrorWithFallback :
-                    BindingValueType.DataValidationErrorWithFallback,
+                    BindingValueType.DataValidationError,
                 fallbackValue.HasValue ? fallbackValue.Value : default,
                 e);
         }

src/Avalonia.Base/DirectPropertyBase.cs

@@ -120,6 +120,11 @@ namespace Avalonia
             return o.GetValue<TValue>(this);
         }
 
+        internal override object RouteGetBaseValue(IAvaloniaObject o, BindingPriority maxPriority)
+        {
+            return o.GetValue<TValue>(this);
+        }
+
         /// <inheritdoc/>
         internal override IDisposable? RouteSetValue(
             IAvaloniaObject o,

src/Avalonia.Base/IAvaloniaObject.cs

@@ -41,6 +41,19 @@ namespace Avalonia
         /// <returns>The value.</returns>
         T GetValue<T>(DirectPropertyBase<T> property);
 
+        /// <summary>
+        /// Gets an <see cref="AvaloniaProperty"/> base value.
+        /// </summary>
+        /// <typeparam name="T">The type of the property.</typeparam>
+        /// <param name="property">The property.</param>
+        /// <param name="maxPriority">The maximum priority for the value.</param>
+        /// <remarks>
+        /// Gets the value of the property, if set on this object with a priority equal or lower to
+        /// <paramref name="maxPriority"/>, otherwise <see cref="Optional{T}.Empty"/>. Note that
+        /// this method does not return property values that come from inherited or default values.
+        /// </remarks>
+        Optional<T> GetBaseValue<T>(StyledPropertyBase<T> property, BindingPriority maxPriority);
+
         /// <summary>
         /// Checks whether a <see cref="AvaloniaProperty"/> is animating.
         /// </summary>

src/Avalonia.Base/PropertyStore/BindingEntry.cs

@@ -22,6 +22,7 @@ namespace Avalonia.PropertyStore
         private readonly IAvaloniaObject _owner;
         private IValueSink _sink;
         private IDisposable? _subscription;
+        private Optional<T> _value;
 
         public BindingEntry(
             IAvaloniaObject owner,
@@ -40,18 +41,21 @@ namespace Avalonia.PropertyStore
         public StyledPropertyBase<T> Property { get; }
         public BindingPriority Priority { get; }
         public IObservable<BindingValue<T>> Source { get; }
-        public Optional<T> Value { get; private set; }
+        Optional<object> IValue.GetValue() => _value.ToObject();
-        Optional<object> IValue.Value => Value.ToObject();
+
-        BindingPriority IValue.ValuePriority => Priority;
+        public Optional<T> GetValue(BindingPriority maxPriority)
+        {
+            return Priority >= maxPriority ? _value : Optional<T>.Empty;
+        }
 
         public void Dispose()
         {
             _subscription?.Dispose();
             _subscription = null;
-            _sink.Completed(Property, this, Value);
+            _sink.Completed(Property, this, _value);
         }
 
-        public void OnCompleted() => _sink.Completed(Property, this, Value);
+        public void OnCompleted() => _sink.Completed(Property, this, _value);
 
         public void OnError(Exception error)
         {
@@ -94,14 +98,14 @@ namespace Avalonia.PropertyStore
                 return;
             }
 
-            var old = Value;
+            var old = _value;
 
             if (value.Type != BindingValueType.DataValidationError)
             {
-                Value = value.ToOptional();
+                _value = value.ToOptional();
             }
 
-            _sink.ValueChanged(Property, Priority, old, value);
+            _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>(_owner, Property, old, value, Priority));
         }
     }
 }

src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs

@@ -13,6 +13,7 @@ namespace Avalonia.PropertyStore
     internal class ConstantValueEntry<T> : IPriorityValueEntry<T>, IDisposable
     {
         private IValueSink _sink;
+        private Optional<T> _value;
 
         public ConstantValueEntry(
             StyledPropertyBase<T> property,
@@ -21,18 +22,21 @@ namespace Avalonia.PropertyStore
             IValueSink sink)
         {
             Property = property;
-            Value = value;
+            _value = value;
             Priority = priority;
             _sink = sink;
         }
 
         public StyledPropertyBase<T> Property { get; }
         public BindingPriority Priority { get; }
-        public Optional<T> Value { get; }
+        Optional<object> IValue.GetValue() => _value.ToObject();
-        Optional<object> IValue.Value => Value.ToObject();
-        BindingPriority IValue.ValuePriority => Priority;
 
-        public void Dispose() => _sink.Completed(Property, this, Value);
+        public Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation)
+        {
+            return Priority >= maxPriority ? _value : Optional<T>.Empty;
+        }
+
+        public void Dispose() => _sink.Completed(Property, this, _value);
         public void Reparent(IValueSink sink) => _sink = sink;
     }
 }

src/Avalonia.Base/PropertyStore/IValue.cs

@@ -9,8 +9,8 @@ namespace Avalonia.PropertyStore
     /// </summary>
     internal interface IValue
     {
-        Optional<object> Value { get; }
+        Optional<object> GetValue();
-        BindingPriority ValuePriority { get; }
+        BindingPriority Priority { get; }
     }
 
     /// <summary>
@@ -19,6 +19,6 @@ namespace Avalonia.PropertyStore
     /// <typeparam name="T">The property type.</typeparam>
     internal interface IValue<T> : IValue
     {
-        new Optional<T> Value { get; }
+        Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation);
     }
 }

src/Avalonia.Base/PropertyStore/IValueSink.cs

@@ -9,11 +9,7 @@ namespace Avalonia.PropertyStore
     /// </summary>
     internal interface IValueSink
     {
-        void ValueChanged<T>(
+        void ValueChanged<T>(AvaloniaPropertyChangedEventArgs<T> change);
-            StyledPropertyBase<T> property,
-            BindingPriority priority,
-            Optional<T> oldValue,
-            BindingValue<T> newValue);
 
         void Completed<T>(
             StyledPropertyBase<T> property,

src/Avalonia.Base/PropertyStore/LocalValueEntry.cs

@@ -14,9 +14,14 @@ namespace Avalonia.PropertyStore
         private T _value;
 
         public LocalValueEntry(T value) => _value = value;
-        public Optional<T> Value => _value;
+        public BindingPriority Priority => BindingPriority.LocalValue;
-        public BindingPriority ValuePriority => BindingPriority.LocalValue;
+        Optional<object> IValue.GetValue() => new Optional<object>(_value);
-        Optional<object> IValue.Value => Value.ToObject();
+        
+        public Optional<T> GetValue(BindingPriority maxPriority)
+        {
+            return BindingPriority.LocalValue >= maxPriority ? _value : Optional<T>.Empty;
+        }
+
         public void SetValue(T value) => _value = value;
     }
 }

src/Avalonia.Base/PropertyStore/PriorityValue.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using Avalonia.Data;
 
 #nullable enable
@@ -24,6 +25,7 @@ namespace Avalonia.PropertyStore
         private readonly List<IPriorityValueEntry<T>> _entries = new List<IPriorityValueEntry<T>>();
         private readonly Func<IAvaloniaObject, T, T>? _coerceValue;
         private Optional<T> _localValue;
+        private Optional<T> _value;
 
         public PriorityValue(
             IAvaloniaObject owner,
@@ -50,11 +52,13 @@ namespace Avalonia.PropertyStore
         {
             existing.Reparent(this);
             _entries.Add(existing);
+
+            var v = existing.GetValue();
             
-            if (existing.Value.HasValue)
+            if (v.HasValue)
             {
-                Value = existing.Value;
+                _value = v;
-                ValuePriority = existing.Priority;
+                Priority = existing.Priority;
             }
         }
 
@@ -65,18 +69,39 @@ namespace Avalonia.PropertyStore
             LocalValueEntry<T> existing)
             : this(owner, property, sink)
         {
-            _localValue = existing.Value;
+            _value = _localValue = existing.GetValue(BindingPriority.LocalValue);
-            Value = _localValue;
+            Priority = BindingPriority.LocalValue;
-            ValuePriority = BindingPriority.LocalValue;
         }
 
         public StyledPropertyBase<T> Property { get; }
-        public Optional<T> Value { get; private set; }
+        public BindingPriority Priority { get; private set; } = BindingPriority.Unset;
-        public BindingPriority ValuePriority { get; private set; }
         public IReadOnlyList<IPriorityValueEntry<T>> Entries => _entries;
-        Optional<object> IValue.Value => Value.ToObject();
+        Optional<object> IValue.GetValue() => _value.ToObject();
+
+        public void ClearLocalValue()
+        {
+            UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>(
+                _owner,
+                Property,
+                default,
+                default,
+                BindingPriority.LocalValue));
+        }
+
+        public Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation)
+        {
+            if (Priority == BindingPriority.Unset)
+            {
+                return default;
+            }
 
-        public void ClearLocalValue() => UpdateEffectiveValue();
+            if (Priority >= maxPriority)
+            {
+                return _value;
+            }
+
+            return CalculateValue(maxPriority).Item1;
+        }
 
         public IDisposable? SetValue(T value, BindingPriority priority)
         {
@@ -94,7 +119,13 @@ namespace Avalonia.PropertyStore
                 result = entry;
             }
 
-            UpdateEffectiveValue();
+            UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>(
+                _owner,
+                Property,
+                default,
+                value,
+                priority));
+
             return result;
         }
 
@@ -106,20 +137,19 @@ namespace Avalonia.PropertyStore
             return binding;
         }
 
-        public void CoerceValue() => UpdateEffectiveValue();
+        public void CoerceValue() => UpdateEffectiveValue(null);
 
-        void IValueSink.ValueChanged<TValue>(
+        void IValueSink.ValueChanged<TValue>(AvaloniaPropertyChangedEventArgs<TValue> change)
-            StyledPropertyBase<TValue> property,
-            BindingPriority priority,
-            Optional<TValue> oldValue,
-            BindingValue<TValue> newValue)
         {
-            if (priority == BindingPriority.LocalValue)
+            if (change.Priority == BindingPriority.LocalValue)
             {
                 _localValue = default;
             }
 
-            UpdateEffectiveValue();
+            if (change is AvaloniaPropertyChangedEventArgs<T> c)
+            {
+                UpdateEffectiveValue(c);
+            }
         }
 
         void IValueSink.Completed<TValue>(
@@ -128,7 +158,16 @@ namespace Avalonia.PropertyStore
             Optional<TValue> oldValue)
         {
             _entries.Remove((IPriorityValueEntry<T>)entry);
-            UpdateEffectiveValue();
+
+            if (oldValue is Optional<T> o)
+            {
+                UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>(
+                    _owner,
+                    Property,
+                    o,
+                    default,
+                    entry.Priority));
+            }
         }
 
         private int FindInsertPoint(BindingPriority priority)
@@ -147,53 +186,73 @@ namespace Avalonia.PropertyStore
             return result;
         }
 
-        private void UpdateEffectiveValue()
+        public (Optional<T>, BindingPriority) CalculateValue(BindingPriority maxPriority)
         {
             var reachedLocalValues = false;
-            var value = default(Optional<T>);
 
-            if (_entries.Count > 0)
+            for (var i = _entries.Count - 1; i >= 0; --i)
             {
-                for (var i = _entries.Count - 1; i >= 0; --i)
+                var entry = _entries[i];
+
+                if (entry.Priority < maxPriority)
+                {
+                    continue;
+                }
+
+                if (!reachedLocalValues &&
+                    entry.Priority >= BindingPriority.LocalValue &&
+                    maxPriority <= BindingPriority.LocalValue &&
+                    _localValue.HasValue)
+                {
+                    return (_localValue, BindingPriority.LocalValue);
+                }
+
+                var entryValue = entry.GetValue();
+
+                if (entryValue.HasValue)
                 {
-                    var entry = _entries[i];
+                    return (entryValue, entry.Priority);
-
-                    if (!reachedLocalValues && entry.Priority >= BindingPriority.LocalValue)
-                    {
-                        reachedLocalValues = true;
-
-                        if (_localValue.HasValue)
-                        {
-                            value = _localValue;
-                            ValuePriority = BindingPriority.LocalValue;
-                            break;
-                        }
-                    }
-
-                    if (entry.Value.HasValue)
-                    {
-                        value = entry.Value;
-                        ValuePriority = entry.Priority;
-                        break;
-                    }
                 }
             }
-            else if (_localValue.HasValue)
+
+            if (!reachedLocalValues &&
+                maxPriority <= BindingPriority.LocalValue &&
+                _localValue.HasValue)
             {
-                value = _localValue;
+                return (_localValue, BindingPriority.LocalValue);
-                ValuePriority = BindingPriority.LocalValue;
             }
 
+            return (default, BindingPriority.Unset);
+        }
+
+        private void UpdateEffectiveValue(AvaloniaPropertyChangedEventArgs<T>? change)
+        {
+            var (value, priority) = CalculateValue(BindingPriority.Animation);
+
             if (value.HasValue && _coerceValue != null)
             {
                 value = _coerceValue(_owner, value.Value);
             }
 
-            if (value != Value)
+            Priority = priority;
+
+            if (value != _value)
+            {
+                var old = _value;
+                _value = value;
+
+                _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>(
+                    _owner,
+                    Property,
+                    old,
+                    value,
+                    Priority));
+            }
+            else if (change is object)
             {
-                var old = Value;
+                change.MarkNonEffectiveValue();
-                Value = value;
+                change.SetOldValue(default);
-                _sink.ValueChanged(Property, ValuePriority, old, value);
+                _sink.ValueChanged(change);
             }
         }
     }

src/Avalonia.Base/StyledPropertyBase.cs

@@ -197,6 +197,13 @@ namespace Avalonia
             return o.GetValue<TValue>(this);
         }
 
+        /// <inheritdoc/>
+        internal override object RouteGetBaseValue(IAvaloniaObject o, BindingPriority maxPriority)
+        {
+            var value = o.GetBaseValue<TValue>(this, maxPriority);
+            return value.HasValue ? value.Value : AvaloniaProperty.UnsetValue;
+        }
+
         /// <inheritdoc/>
         internal override IDisposable RouteSetValue(
             IAvaloniaObject o,

src/Avalonia.Base/ValueStore.cs

@@ -37,7 +37,7 @@ namespace Avalonia
         {
             if (_values.TryGetValue(property, out var slot))
             {
-                return slot.ValuePriority < BindingPriority.LocalValue;
+                return slot.Priority < BindingPriority.LocalValue;
             }
 
             return false;
@@ -47,21 +47,24 @@ namespace Avalonia
         {
             if (_values.TryGetValue(property, out var slot))
             {
-                return slot.Value.HasValue;
+                return slot.GetValue().HasValue;
             }
 
             return false;
         }
 
-        public bool TryGetValue<T>(StyledPropertyBase<T> property, out T value)
+        public bool TryGetValue<T>(
+            StyledPropertyBase<T> property,
+            BindingPriority maxPriority,
+            out T value)
         {
             if (_values.TryGetValue(property, out var slot))
             {
-                var v = (IValue<T>)slot;
+                var v = ((IValue<T>)slot).GetValue(maxPriority);
 
-                if (v.Value.HasValue)
+                if (v.HasValue)
                 {
-                    value = v.Value.Value;
+                    value = v.Value;
                     return true;
                 }
             }
@@ -90,17 +93,22 @@ namespace Avalonia
                 _values.AddValue(property, entry);
                 result = entry.SetValue(value, priority);
             }
-            else if (priority == BindingPriority.LocalValue)
-            {
-                _values.AddValue(property, new LocalValueEntry<T>(value));
-                _sink.ValueChanged(property, priority, default, value);
-            }
             else
             {
-                var entry = new ConstantValueEntry<T>(property, value, priority, this);
+                var change = new AvaloniaPropertyChangedEventArgs<T>(_owner, property, default, value, priority);
-                _values.AddValue(property, entry);
+
-                _sink.ValueChanged(property, priority, default, value);
+                if (priority == BindingPriority.LocalValue)
-                result = entry;
+                {
+                    _values.AddValue(property, new LocalValueEntry<T>(value));
+                    _sink.ValueChanged(change);
+                }
+                else
+                {
+                    var entry = new ConstantValueEntry<T>(property, value, priority, this);
+                    _values.AddValue(property, entry);
+                    _sink.ValueChanged(change);
+                    result = entry;
+                }
             }
 
             return result;
@@ -149,13 +157,14 @@ namespace Avalonia
 
                     if (remove)
                     {
-                        var old = TryGetValue(property, out var value) ? value : default;
+                        var old = TryGetValue(property, BindingPriority.LocalValue, out var value) ? value : default;
                         _values.Remove(property);
-                        _sink.ValueChanged(
+                        _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>(
+                            _owner,
                             property,
-                            BindingPriority.Unset,
                             old,
-                            BindingValue<T>.Unset);
+                            default,
+                            BindingPriority.Unset));
                     }
                 }
             }
@@ -176,23 +185,20 @@ namespace Avalonia
         {
             if (_values.TryGetValue(property, out var slot))
             {
+                var slotValue = slot.GetValue();
                 return new Diagnostics.AvaloniaPropertyValue(
                     property,
-                    slot.Value.HasValue ? slot.Value.Value : AvaloniaProperty.UnsetValue,
+                    slotValue.HasValue ? slotValue.Value : AvaloniaProperty.UnsetValue,
-                    slot.ValuePriority,
+                    slot.Priority,
                     null);
             }
 
             return null;
         }
 
-        void IValueSink.ValueChanged<T>(
+        void IValueSink.ValueChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            StyledPropertyBase<T> property,
-            BindingPriority priority,
-            Optional<T> oldValue,
-            BindingValue<T> newValue)
         {
-            _sink.ValueChanged(property, priority, oldValue, newValue);
+            _sink.ValueChanged(change);
         }
 
         void IValueSink.Completed<T>(
@@ -232,9 +238,14 @@ namespace Avalonia
             {
                 if (priority == BindingPriority.LocalValue)
                 {
-                    var old = l.Value;
+                    var old = l.GetValue(BindingPriority.LocalValue);
                     l.SetValue(value);
-                    _sink.ValueChanged(property, priority, old, value);
+                    _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>(
+                        _owner,
+                        property,
+                        old,
+                        value,
+                        priority));
                 }
                 else
                 {

src/Avalonia.Controls.DataGrid/DataGrid.cs

@@ -1,5 +1,4 @@
-// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
-// This source is subject to the Microsoft Public License (Ms-PL).
 // Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
 // All other rights reserved. 
 
@@ -767,7 +766,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// ItemsProperty property changed handler.
         /// </summary>
-        /// <param name="e">AvaloniaPropertyChangedEventArgs.</param>
+        /// <param name="e">The event arguments.</param>
         private void OnItemsPropertyChanged(AvaloniaPropertyChangedEventArgs e)
         {
             if (!_areHandlersSuspended)

src/Avalonia.Controls/Button.cs

@@ -313,17 +313,13 @@ namespace Avalonia.Controls
             IsPressed = false;
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == IsPressedProperty)
+            if (change.Property == IsPressedProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<bool>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<bool>());
             }
         }
 

src/Avalonia.Controls/ButtonSpinner.cs

@@ -205,17 +205,13 @@ namespace Avalonia.Controls
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == ButtonSpinnerLocationProperty)
+            if (change.Property == ButtonSpinnerLocationProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<Location>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<Location>());
             }
         }
 

src/Avalonia.Controls/Calendar/DatePicker.cs

@@ -510,17 +510,13 @@ namespace Avalonia.Controls
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == SelectedDateProperty)
+            if (change.Property == SelectedDateProperty)
             {
-                DataValidationErrors.SetError(this, newValue.Error);
+                DataValidationErrors.SetError(this, change.NewValue.Error);
             }
         }
 

src/Avalonia.Controls/Expander.cs

@@ -78,17 +78,13 @@ namespace Avalonia.Controls
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == ExpandDirectionProperty)
+            if (change.Property == ExpandDirectionProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<ExpandDirection>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<ExpandDirection>());
             }
         }
 

src/Avalonia.Controls/Notifications/WindowNotificationManager.cs

@@ -136,17 +136,13 @@ namespace Avalonia.Controls.Notifications
             notificationControl.Close();
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == PositionProperty)
+            if (change.Property == PositionProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<NotificationPosition>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<NotificationPosition>());
             }
         }
 

src/Avalonia.Controls/Presenters/TextPresenter.cs

@@ -75,6 +75,9 @@ namespace Avalonia.Controls.Presenters
         static TextPresenter()
         {
             AffectsRender<TextPresenter>(SelectionBrushProperty);
+            AffectsMeasure<TextPresenter>(TextProperty, PasswordCharProperty, 
+                TextAlignmentProperty, TextWrappingProperty, TextBlock.FontSizeProperty,
+                TextBlock.FontStyleProperty, TextBlock.FontWeightProperty, TextBlock.FontFamilyProperty);
 
             Observable.Merge(TextProperty.Changed, TextBlock.ForegroundProperty.Changed,
                 TextAlignmentProperty.Changed, TextWrappingProperty.Changed,
@@ -284,8 +287,6 @@ namespace Avalonia.Controls.Presenters
         protected void InvalidateFormattedText()
         {
             _formattedText = null;
-
-            InvalidateMeasure();
         }
 
         /// <summary>
@@ -301,13 +302,15 @@ namespace Avalonia.Controls.Presenters
                 context.FillRectangle(background, new Rect(Bounds.Size));
             }
 
-            FormattedText.Constraint = Bounds.Size;
-
             context.DrawText(Foreground, new Point(), FormattedText);
         }
 
         public override void Render(DrawingContext context)
         {
+            FormattedText.Constraint = Bounds.Size;
+
+            _constraint = Bounds.Size;
+
             var selectionStart = SelectionStart;
             var selectionEnd = SelectionEnd;
 
@@ -316,10 +319,6 @@ namespace Avalonia.Controls.Presenters
                 var start = Math.Min(selectionStart, selectionEnd);
                 var length = Math.Max(selectionStart, selectionEnd) - start;
 
-                // issue #600: set constraint before any FormattedText manipulation
-                //             see base.Render(...) implementation
-                FormattedText.Constraint = _constraint;
-
                 var rects = FormattedText.HitTestTextRange(start, length);
 
                 foreach (var rect in rects)

src/Avalonia.Controls/Primitives/ScrollBar.cs

@@ -123,24 +123,20 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == OrientationProperty)
+            if (change.Property == OrientationProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<Orientation>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<Orientation>());
             }
             else
             {
-                if (property == MinimumProperty ||
+                if (change.Property == MinimumProperty ||
-                    property == MaximumProperty || 
+                    change.Property == MaximumProperty ||
-                    property == ViewportSizeProperty ||
+                    change.Property == ViewportSizeProperty ||
-                    property == VisibilityProperty)
+                    change.Property == VisibilityProperty)
                 {
                     UpdateIsVisible();
                 }

src/Avalonia.Controls/Primitives/SelectingItemsControl.cs

@@ -455,13 +455,13 @@ namespace Avalonia.Controls.Primitives
             InternalEndInit();
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == SelectionModeProperty)
+            if (change.Property == SelectionModeProperty)
             {
-                var mode = newValue.GetValueOrDefault<SelectionMode>();
+                var mode = change.NewValue.GetValueOrDefault<SelectionMode>();
                 Selection.SingleSelect = !mode.HasFlagCustom(SelectionMode.Multiple);
                 Selection.AutoSelect = mode.HasFlagCustom(SelectionMode.AlwaysSelected);
             }

src/Avalonia.Controls/Primitives/Track.cs

@@ -280,17 +280,13 @@ namespace Avalonia.Controls.Primitives
             return arrangeSize;
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == OrientationProperty)
+            if (change.Property == OrientationProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<Orientation>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<Orientation>());
             }
         }
 

src/Avalonia.Controls/ProgressBar.cs

@@ -83,21 +83,17 @@ namespace Avalonia.Controls
             return base.ArrangeOverride(finalSize);
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == IsIndeterminateProperty)
+            if (change.Property == IsIndeterminateProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<bool>(), null);
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<bool>(), null);
             }
-            else if (property == OrientationProperty)
+            else if (change.Property == OrientationProperty)
             {
-                UpdatePseudoClasses(null, newValue.GetValueOrDefault<Orientation>());
+                UpdatePseudoClasses(null, change.NewValue.GetValueOrDefault<Orientation>());
             }
         }
 

src/Avalonia.Controls/Repeater/ItemsRepeater.cs

@@ -376,12 +376,12 @@ namespace Avalonia.Controls
             _viewportManager.ResetScrollers();
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            if (property == ItemsProperty)
+            if (change.Property == ItemsProperty)
             {
-                var oldEnumerable = oldValue.GetValueOrDefault<IEnumerable>();
+                var oldEnumerable = change.OldValue.GetValueOrDefault<IEnumerable>();
-                var newEnumerable = newValue.GetValueOrDefault<IEnumerable>();
+                var newEnumerable = change.NewValue.GetValueOrDefault<IEnumerable>();
 
                 if (oldEnumerable != newEnumerable)
                 {
@@ -394,24 +394,28 @@ namespace Avalonia.Controls
                     OnDataSourcePropertyChanged(ItemsSourceView, newDataSource);
                 }
             }
-            else if (property == ItemTemplateProperty)
+            else if (change.Property == ItemTemplateProperty)
             {
-                OnItemTemplateChanged(oldValue.GetValueOrDefault<IDataTemplate>(), newValue.GetValueOrDefault<IDataTemplate>());
+                OnItemTemplateChanged(
+                    change.OldValue.GetValueOrDefault<IDataTemplate>(),
+                    change.NewValue.GetValueOrDefault<IDataTemplate>());
             }
-            else if (property == LayoutProperty)
+            else if (change.Property == LayoutProperty)
             {
-                OnLayoutChanged(oldValue.GetValueOrDefault<AttachedLayout>(), newValue.GetValueOrDefault<AttachedLayout>());
+                OnLayoutChanged(
+                    change.OldValue.GetValueOrDefault<AttachedLayout>(),
+                    change.NewValue.GetValueOrDefault<AttachedLayout>());
             }
-            else if (property == HorizontalCacheLengthProperty)
+            else if (change.Property == HorizontalCacheLengthProperty)
             {
-                _viewportManager.HorizontalCacheLength = newValue.GetValueOrDefault<double>();
+                _viewportManager.HorizontalCacheLength = change.NewValue.GetValueOrDefault<double>();
             }
-            else if (property == VerticalCacheLengthProperty)
+            else if (change.Property == VerticalCacheLengthProperty)
             {
-                _viewportManager.VerticalCacheLength = newValue.GetValueOrDefault<double>();
+                _viewportManager.VerticalCacheLength = change.NewValue.GetValueOrDefault<double>();
             }
 
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
         }
 
         internal IControl GetElementImpl(int index, bool forceCreate, bool supressAutoRecycle)

src/Avalonia.Controls/Slider.cs

@@ -134,17 +134,13 @@ namespace Avalonia.Controls
             }
         }
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == OrientationProperty)
+            if (change.Property == OrientationProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<Orientation>());
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<Orientation>());
             }
         }
 

src/Avalonia.Controls/TreeView.cs

@@ -486,13 +486,13 @@ namespace Avalonia.Controls
             }
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == SelectionModeProperty)
+            if (change.Property == SelectionModeProperty)
             {
-                var mode = newValue.GetValueOrDefault<SelectionMode>();
+                var mode = change.NewValue.GetValueOrDefault<SelectionMode>();
                 Selection.SingleSelect = !mode.HasFlagCustom(SelectionMode.Multiple);
                 Selection.AutoSelect = mode.HasFlagCustom(SelectionMode.AlwaysSelected);
             }

src/Avalonia.Controls/Window.cs

@@ -751,19 +751,15 @@ namespace Avalonia.Controls
         /// </remarks>
         protected virtual void OnClosing(CancelEventArgs e) => Closing?.Invoke(this, e);
 
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            if (property == SystemDecorationsProperty)
+            if (change.Property == SystemDecorationsProperty)
             {
-                var typedNewValue = newValue.GetValueOrDefault<SystemDecorations>();
+                var typedNewValue = change.NewValue.GetValueOrDefault<SystemDecorations>();
 
                 PlatformImpl?.SetSystemDecorations(typedNewValue);
 
-                var o = oldValue.GetValueOrDefault<SystemDecorations>() == SystemDecorations.Full;
+                var o = change.OldValue.GetValueOrDefault<SystemDecorations>() == SystemDecorations.Full;
                 var n = typedNewValue == SystemDecorations.Full;
 
                 if (o != n)

src/Avalonia.Input/InputElement.cs

@@ -526,17 +526,17 @@ namespace Avalonia.Input
         {
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == IsFocusedProperty)
+            if (change.Property == IsFocusedProperty)
             {
-                UpdatePseudoClasses(newValue.GetValueOrDefault<bool>(), null);
+                UpdatePseudoClasses(change.NewValue.GetValueOrDefault<bool>(), null);
             }
-            else if (property == IsPointerOverProperty)
+            else if (change.Property == IsPointerOverProperty)
             {
-                UpdatePseudoClasses(null, newValue.GetValueOrDefault<bool>());
+                UpdatePseudoClasses(null, change.NewValue.GetValueOrDefault<bool>());
             }
         }
 

src/Avalonia.Layout/StackLayout.cs

@@ -312,11 +312,11 @@ namespace Avalonia.Layout
             InvalidateLayout();
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            if (property == OrientationProperty)
+            if (change.Property == OrientationProperty)
             {
-                var orientation = newValue.GetValueOrDefault<Orientation>();
+                var orientation = change.NewValue.GetValueOrDefault<Orientation>();
 
                 //Note: For StackLayout Vertical Orientation means we have a Vertical ScrollOrientation.
                 //Horizontal Orientation means we have a Horizontal ScrollOrientation.

src/Avalonia.Layout/UniformGridLayout.cs

@@ -464,45 +464,44 @@ namespace Avalonia.Layout
             gridState.ClearElementOnDataSourceChange(context, args);
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            if (property == OrientationProperty)
+            if (change.Property == OrientationProperty)
             {
-                var orientation = newValue.GetValueOrDefault<Orientation>();
+                var orientation = change.NewValue.GetValueOrDefault<Orientation>();
 
                 //Note: For UniformGridLayout Vertical Orientation means we have a Horizontal ScrollOrientation. Horizontal Orientation means we have a Vertical ScrollOrientation.
                 //i.e. the properties are the inverse of each other.
                 var scrollOrientation = (orientation == Orientation.Horizontal) ? ScrollOrientation.Vertical : ScrollOrientation.Horizontal;
                 _orientation.ScrollOrientation = scrollOrientation;
             }
-            else if (property == MinColumnSpacingProperty)
+            else if (change.Property == MinColumnSpacingProperty)
             {
-                _minColumnSpacing = newValue.GetValueOrDefault<double>();
+                _minColumnSpacing = change.NewValue.GetValueOrDefault<double>();
             }
-            else if (property == MinRowSpacingProperty)
+            else if (change.Property == MinRowSpacingProperty)
             {
-                _minRowSpacing = newValue.GetValueOrDefault<double>();
+                _minRowSpacing = change.NewValue.GetValueOrDefault<double>();
             }
-            else if (property == ItemsJustificationProperty)
+            else if (change.Property == ItemsJustificationProperty)
             {
-                _itemsJustification = newValue.GetValueOrDefault<UniformGridLayoutItemsJustification>();
+                _itemsJustification = change.NewValue.GetValueOrDefault<UniformGridLayoutItemsJustification>();
-                ;
             }
-            else if (property == ItemsStretchProperty)
+            else if (change.Property == ItemsStretchProperty)
             {
-                _itemsStretch = newValue.GetValueOrDefault<UniformGridLayoutItemsStretch>();
+                _itemsStretch = change.NewValue.GetValueOrDefault<UniformGridLayoutItemsStretch>();
             }
-            else if (property == MinItemWidthProperty)
+            else if (change.Property == MinItemWidthProperty)
             {
-                _minItemWidth = newValue.GetValueOrDefault<double>();
+                _minItemWidth = change.NewValue.GetValueOrDefault<double>();
             }
-            else if (property == MinItemHeightProperty)
+            else if (change.Property == MinItemHeightProperty)
             {
-                _minItemHeight = newValue.GetValueOrDefault<double>();
+                _minItemHeight = change.NewValue.GetValueOrDefault<double>();
             }
-            else if (property == MaximumRowsOrColumnsProperty)
+            else if (change.Property == MaximumRowsOrColumnsProperty)
             {
-                _maximumRowsOrColumns = newValue.GetValueOrDefault<int>();
+                _maximumRowsOrColumns = change.NewValue.GetValueOrDefault<int>();
             }
 
             InvalidateLayout();

src/Avalonia.Styling/Styling/PropertySetterBindingInstance.cs

@@ -160,7 +160,7 @@ namespace Avalonia.Styling
 
         private void ConvertAndPublishNext(object? value)
         {
-            _value = value is T v ? v : BindingValue<object>.FromUntyped(value).Convert<T>();
+            _value = value is T v ? v : BindingValue<T>.FromUntyped(value);
 
             if (_isActive)
             {

src/Avalonia.Visuals/Media/DrawingImage.cs

@@ -63,15 +63,11 @@ namespace Avalonia.Media
         }
 
         /// <inheritdoc/>
-        protected override void OnPropertyChanged<T>(
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
-            AvaloniaProperty<T> property,
-            Optional<T> oldValue,
-            BindingValue<T> newValue,
-            BindingPriority priority)
         {
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
 
-            if (property == DrawingProperty)
+            if (change.Property == DrawingProperty)
             {
                 RaiseInvalidated(EventArgs.Empty);
             }

src/Avalonia.Visuals/Visual.cs

@@ -114,6 +114,9 @@ namespace Avalonia
         /// </summary>
         public Visual()
         {
+            // Disable transitions until we're added to the visual tree.
+            DisableTransitions();
+
             var visualChildren = new AvaloniaList<IVisual>();
             visualChildren.ResetBehavior = ResetBehavior.Remove;
             visualChildren.Validate = visual => ValidateVisualChild(visual);
@@ -393,6 +396,7 @@ namespace Avalonia
                 RenderTransform.Changed += RenderTransformChanged;
             }
 
+            EnableTransitions();
             OnAttachedToVisualTree(e);
             AttachedToVisualTree?.Invoke(this, e);
             InvalidateVisual();
@@ -429,6 +433,7 @@ namespace Avalonia
                 RenderTransform.Changed -= RenderTransformChanged;
             }
 
+            DisableTransitions();
             OnDetachedFromVisualTree(e);
             DetachedFromVisualTree?.Invoke(this, e);
             e.Root?.Renderer?.AddDirty(this);

tests/Avalonia.Animation.UnitTests/AnimatableTests.cs

@@ -0,0 +1,339 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Layout;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Animation.UnitTests
+{
+    public class AnimatableTests
+    {
+        [Fact]
+        public void Transition_Is_Not_Applied_When_Not_Attached_To_Visual_Tree()
+        {
+            var target = CreateTarget();
+            var control = new Control
+            {
+                Transitions = new Transitions { target.Object },
+            };
+
+            control.Opacity = 0.5;
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                1.0,
+                0.5),
+                Times.Never);
+        }
+
+        [Fact]
+        public void Transition_Is_Not_Applied_To_Initial_Style()
+        {
+            using (UnitTestApplication.Start(TestServices.RealStyler))
+            {
+                var target = CreateTarget();
+                var control = new Control
+                {
+                    Transitions = new Transitions { target.Object },
+                };
+
+                var root = new TestRoot
+                {
+                    Styles =
+                    {
+                        new Style(x => x.OfType<Control>())
+                        {
+                            Setters =
+                            {
+                                new Setter(Visual.OpacityProperty, 0.8),
+                            }
+                        }
+                    }
+                };
+
+                root.Child = control;
+
+                Assert.Equal(0.8, control.Opacity);
+
+                target.Verify(x => x.Apply(
+                    It.IsAny<Control>(),
+                    It.IsAny<IClock>(),
+                    It.IsAny<object>(),
+                    It.IsAny<object>()),
+                    Times.Never);
+            }
+        }
+
+        [Fact]
+        public void Transition_Is_Applied_When_Local_Value_Changes()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+
+            control.Opacity = 0.5;
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                1.0,
+                0.5));
+        }
+
+        [Fact]
+        public void Transition_Is_Not_Applied_When_Animated_Value_Changes()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+
+            control.SetValue(Visual.OpacityProperty, 0.5, BindingPriority.Animation);
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                1.0,
+                0.5),
+                Times.Never);
+        }
+
+        [Fact]
+        public void Transition_Is_Not_Applied_When_StyleTrigger_Changes_With_LocalValue_Present()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+
+            control.SetValue(Visual.OpacityProperty, 0.5);
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                1.0,
+                0.5));
+            target.ResetCalls();
+
+            control.SetValue(Visual.OpacityProperty, 0.8, BindingPriority.StyleTrigger);
+
+            target.Verify(x => x.Apply(
+                It.IsAny<Control>(),
+                It.IsAny<IClock>(),
+                It.IsAny<object>(),
+                It.IsAny<object>()),
+                Times.Never);
+        }
+
+        [Fact]
+        public void Transition_Is_Disposed_When_Local_Value_Changes()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+            var sub = new Mock<IDisposable>();
+
+            target.Setup(x => x.Apply(control, It.IsAny<IClock>(), 1.0, 0.5)).Returns(sub.Object);
+
+            control.Opacity = 0.5;
+            sub.ResetCalls();
+            control.Opacity = 0.4;
+
+            sub.Verify(x => x.Dispose());
+        }
+
+        [Fact]
+        public void New_Transition_Is_Applied_When_Local_Value_Changes()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+
+            target.Setup(x => x.Property).Returns(Visual.OpacityProperty);
+            target.Setup(x => x.Apply(control, It.IsAny<IClock>(), 1.0, 0.5))
+                .Callback(() =>
+                {
+                    control.SetValue(Visual.OpacityProperty, 0.9, BindingPriority.Animation);
+                })
+                .Returns(Mock.Of<IDisposable>());
+
+            control.Opacity = 0.5;
+
+            Assert.Equal(0.9, control.Opacity);
+            target.ResetCalls();
+
+            control.Opacity = 0.4;
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                0.9,
+                0.4));
+        }
+
+        [Fact]
+        public void Transition_Is_Not_Applied_When_Removed_From_Visual_Tree()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+
+            control.Opacity = 0.5;
+
+            target.Verify(x => x.Apply(
+                control,
+                It.IsAny<IClock>(),
+                1.0,
+                0.5));
+            target.ResetCalls();
+
+            var root = (TestRoot)control.Parent;
+            root.Child = null;
+            control.Opacity = 0.8;
+
+            target.Verify(x => x.Apply(
+                It.IsAny<Control>(),
+                It.IsAny<IClock>(),
+                It.IsAny<object>(),
+                It.IsAny<object>()),
+                Times.Never);
+        }
+
+        [Fact]
+        public void Animation_Is_Cancelled_When_Transition_Removed()
+        {
+            var target = CreateTarget();
+            var control = CreateControl(target.Object);
+            var sub = new Mock<IDisposable>();
+
+            target.Setup(x => x.Apply(
+                It.IsAny<Animatable>(),
+                It.IsAny<IClock>(),
+                It.IsAny<object>(),
+                It.IsAny<object>())).Returns(sub.Object);
+
+            control.Opacity = 0.5;
+            control.Transitions.RemoveAt(0);
+
+            sub.Verify(x => x.Dispose());
+        }
+
+        [Fact]
+        public void Animation_Is_Cancelled_When_New_Style_Activates()
+        {
+            using (UnitTestApplication.Start(TestServices.RealStyler))
+            {
+                var target = CreateTarget();
+                var control = CreateStyledControl(target.Object);
+                var sub = new Mock<IDisposable>();
+
+                target.Setup(x => x.Apply(
+                    control,
+                    It.IsAny<IClock>(),
+                    1.0,
+                    0.5)).Returns(sub.Object);
+
+                control.Opacity = 0.5;
+
+                target.Verify(x => x.Apply(
+                    control,
+                    It.IsAny<Clock>(),
+                    1.0,
+                    0.5),
+                    Times.Once);
+
+                control.Classes.Add("foo");
+
+                sub.Verify(x => x.Dispose());
+            }
+        }
+
+        [Fact]
+        public void Transition_From_Style_Trigger_Is_Applied()
+        {
+            using (UnitTestApplication.Start(TestServices.RealStyler))
+            {
+                var target = CreateTransition(Control.WidthProperty);
+                var control = CreateStyledControl(transition2: target.Object);
+                var sub = new Mock<IDisposable>();
+
+                control.Classes.Add("foo");
+                control.Width = 100;
+
+                target.Verify(x => x.Apply(
+                    control,
+                    It.IsAny<Clock>(),
+                    double.NaN,
+                    100.0),
+                    Times.Once);
+            }
+        }
+
+        private static Mock<ITransition> CreateTarget()
+        {
+            return CreateTransition(Visual.OpacityProperty);
+        }
+
+        private static Control CreateControl(ITransition transition)
+        {
+            var control = new Control
+            {
+                Transitions = new Transitions { transition },
+            };
+
+            var root = new TestRoot(control);
+            return control;
+        }
+
+        private static Control CreateStyledControl(
+            ITransition transition1 = null,
+            ITransition transition2 = null)
+        {
+            transition1 = transition1 ?? CreateTarget().Object;
+            transition2 = transition2 ?? CreateTransition(Control.WidthProperty).Object;
+
+            var control = new Control
+            {
+                Styles =
+                {
+                    new Style(x => x.OfType<Control>())
+                    {
+                        Setters =
+                        {
+                            new Setter
+                            {
+                                Property = Control.TransitionsProperty,
+                                Value = new Transitions { transition1 },
+                            }
+                        }
+                    },
+                    new Style(x => x.OfType<Control>().Class("foo"))
+                    {
+                        Setters =
+                        {
+                            new Setter
+                            {
+                                Property = Control.TransitionsProperty,
+                                Value = new Transitions { transition2 },
+                            }
+                        }
+                    }
+                }
+            };
+
+            var root = new TestRoot(control);
+            return control;
+        }
+
+        private static Mock<ITransition> CreateTransition(AvaloniaProperty property)
+        {
+            var target = new Mock<ITransition>();
+            var sub = new Mock<IDisposable>();
+
+            target.Setup(x => x.Property).Returns(property);
+            target.Setup(x => x.Apply(
+                It.IsAny<Animatable>(),
+                It.IsAny<IClock>(),
+                It.IsAny<object>(),
+                It.IsAny<object>())).Returns(sub.Object);
+
+            return target;
+        }
+    }
+}

tests/Avalonia.Animation.UnitTests/TransitionsTests.cs

@@ -16,7 +16,7 @@ namespace Avalonia.Animation.UnitTests
             {
                 var border = new Border
                 {
-                    Transitions =
+                    Transitions = new Transitions
                     {
                         new DoubleTransition
                         {
@@ -44,7 +44,7 @@ namespace Avalonia.Animation.UnitTests
             {
                 var border = new Border
                 {
-                    Transitions =
+                    Transitions = new Transitions
                     {
                         new DoubleTransition
                         {

tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_GetValue.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Reactive.Subjects;
+using Avalonia.Data;
 using Xunit;
 
 namespace Avalonia.Base.UnitTests
@@ -63,6 +64,56 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("foodefault", target.GetValue(Class1.FooProperty));
         }
 
+        [Fact]
+        public void GetBaseValue_LocalValue_Ignores_Default_Value()
+        {
+            var target = new Class3();
+
+            target.SetValue(Class1.FooProperty, "animated", BindingPriority.Animation);
+            Assert.False(target.GetBaseValue(Class1.FooProperty, BindingPriority.LocalValue).HasValue);
+        }
+
+        [Fact]
+        public void GetBaseValue_LocalValue_Returns_Local_Value()
+        {
+            var target = new Class3();
+
+            target.SetValue(Class1.FooProperty, "local");
+            target.SetValue(Class1.FooProperty, "animated", BindingPriority.Animation);
+            Assert.Equal("local", target.GetBaseValue(Class1.FooProperty, BindingPriority.LocalValue).Value);
+        }
+
+        [Fact]
+        public void GetBaseValue_LocalValue_Returns_Style_Value()
+        {
+            var target = new Class3();
+
+            target.SetValue(Class1.FooProperty, "style", BindingPriority.Style);
+            target.SetValue(Class1.FooProperty, "animated", BindingPriority.Animation);
+            Assert.Equal("style", target.GetBaseValue(Class1.FooProperty, BindingPriority.LocalValue).Value);
+        }
+
+        [Fact]
+        public void GetBaseValue_Style_Ignores_LocalValue_Animated_Value()
+        {
+            var target = new Class3();
+
+            target.Bind(Class1.FooProperty, new BehaviorSubject<string>("animated"), BindingPriority.Animation);
+            target.SetValue(Class1.FooProperty, "local");
+            Assert.False(target.GetBaseValue(Class1.FooProperty, BindingPriority.Style).HasValue);
+        }
+
+        [Fact]
+        public void GetBaseValue_Style_Returns_Style_Value()
+        {
+            var target = new Class3();
+
+            target.SetValue(Class1.FooProperty, "local");
+            target.SetValue(Class1.FooProperty, "style", BindingPriority.Style);
+            target.Bind(Class1.FooProperty, new BehaviorSubject<string>("animated"), BindingPriority.Animation);
+            Assert.Equal("style", target.GetBaseValue(Class1.FooProperty, BindingPriority.Style));
+        }
+
         private class Class1 : AvaloniaObject
         {
             public static readonly StyledProperty<string> FooProperty =

tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_OnPropertyChanged.cs

@@ -0,0 +1,142 @@
+// 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.Collections.Generic;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using Avalonia.Data;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests
+{
+    public class AvaloniaObjectTests_OnPropertyChanged
+    {
+        [Fact]
+        public void OnPropertyChangedCore_Is_Called_On_Property_Change()
+        {
+            var target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "newvalue");
+
+            Assert.Equal(1, target.CoreChanges.Count);
+
+            var change = (AvaloniaPropertyChangedEventArgs<string>)target.CoreChanges[0];
+
+            Assert.Equal("newvalue", change.NewValue.Value);
+            Assert.Equal("foodefault", change.OldValue.Value);
+            Assert.Equal(BindingPriority.LocalValue, change.Priority);
+            Assert.True(change.IsEffectiveValueChange);
+        }
+
+        [Fact]
+        public void OnPropertyChangedCore_Is_Called_On_Non_Effective_Property_Value_Change()
+        {
+            var target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "newvalue");
+            target.SetValue(Class1.FooProperty, "styled", BindingPriority.Style);
+
+            Assert.Equal(2, target.CoreChanges.Count);
+
+            var change = (AvaloniaPropertyChangedEventArgs<string>)target.CoreChanges[1];
+
+            Assert.Equal("styled", change.NewValue.Value);
+            Assert.False(change.OldValue.HasValue);
+            Assert.Equal(BindingPriority.Style, change.Priority);
+            Assert.False(change.IsEffectiveValueChange);
+        }
+
+        [Fact]
+        public void OnPropertyChangedCore_Is_Called_On_All_Binding_Property_Changes()
+        {
+            var target = new Class1();
+            var style = new Subject<BindingValue<string>>();
+            var animation = new Subject<BindingValue<string>>();
+            var templatedParent = new Subject<BindingValue<string>>();
+
+            target.Bind(Class1.FooProperty, style, BindingPriority.Style);
+            target.Bind(Class1.FooProperty, animation, BindingPriority.Animation);
+            target.Bind(Class1.FooProperty, templatedParent, BindingPriority.TemplatedParent);
+
+            style.OnNext("style1");
+            templatedParent.OnNext("tp1");
+            animation.OnNext("a1");
+            templatedParent.OnNext("tp2");
+            templatedParent.OnCompleted();
+            animation.OnNext("a2");
+            style.OnNext("style2");
+            style.OnCompleted();
+            animation.OnCompleted();
+
+            var changes = target.CoreChanges.Cast<AvaloniaPropertyChangedEventArgs<string>>();
+
+            Assert.Equal(
+                new[] { true, true, true, false, false, true, false, false, true },
+                changes.Select(x => x.IsEffectiveValueChange).ToList());
+            Assert.Equal(
+                new[] { "style1", "tp1", "a1", "tp2", "$unset", "a2", "style2", "$unset", "foodefault" },
+                changes.Select(x => x.NewValue.GetValueOrDefault("$unset")).ToList());
+            Assert.Equal(
+                new[] { "foodefault", "style1", "tp1", "$unset", "$unset", "a1", "$unset", "$unset", "a2" },
+                changes.Select(x => x.OldValue.GetValueOrDefault("$unset")).ToList());
+        }
+
+        [Fact]
+        public void OnPropertyChanged_Is_Called_Only_For_Effective_Value_Changes()
+        {
+            var target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "newvalue");
+            target.SetValue(Class1.FooProperty, "styled", BindingPriority.Style);
+
+            Assert.Equal(1, target.Changes.Count);
+            Assert.Equal(2, target.CoreChanges.Count);
+        }
+
+        private class Class1 : AvaloniaObject
+        {
+            public static readonly StyledProperty<string> FooProperty =
+                AvaloniaProperty.Register<Class1, string>("Foo", "foodefault");
+
+            public Class1()
+            {
+                Changes = new List<AvaloniaPropertyChangedEventArgs>();
+                CoreChanges = new List<AvaloniaPropertyChangedEventArgs>();
+            }
+
+            public List<AvaloniaPropertyChangedEventArgs> Changes { get; }
+            public List<AvaloniaPropertyChangedEventArgs> CoreChanges { get; }
+
+            protected override void OnPropertyChangedCore<T>(AvaloniaPropertyChangedEventArgs<T> change)
+            {
+                CoreChanges.Add(Clone(change));
+                base.OnPropertyChangedCore(change);
+            }
+
+            protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
+            {
+                Changes.Add(Clone(change));
+                base.OnPropertyChanged(change);
+            }
+
+            private static AvaloniaPropertyChangedEventArgs<T> Clone<T>(AvaloniaPropertyChangedEventArgs<T> change)
+            {
+                var result = new AvaloniaPropertyChangedEventArgs<T>(
+                    change.Sender,
+                    change.Property,
+                    change.OldValue,
+                    change.NewValue,
+                    change.Priority);
+
+                if (!change.IsEffectiveValueChange)
+                {
+                    result.MarkNonEffectiveValue();
+                }
+
+                return result;
+            }
+        }
+    }
+}

tests/Avalonia.Base.UnitTests/AvaloniaPropertyTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Avalonia.Data;
 using Avalonia.Utilities;
 using Xunit;
@@ -88,6 +89,30 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("newvalue", value);
         }
 
+        [Fact]
+        public void Changed_Observable_Fired_Only_On_Effective_Value_Change()
+        {
+            var target = new Class1();
+            var result = new List<string>();
+
+            Class1.FooProperty.Changed.Subscribe(x => result.Add((string)x.NewValue));
+            target.SetValue(Class1.FooProperty, "animated", BindingPriority.Animation);
+            target.SetValue(Class1.FooProperty, "local");
+
+            Assert.Equal(new[] { "animated" }, result);
+        }
+
+        [Fact]
+        public void Notify_Fired_Only_On_Effective_Value_Change()
+        {
+            var target = new Class1();
+
+            target.SetValue(Class1.FooProperty, "animated", BindingPriority.Animation);
+            target.SetValue(Class1.FooProperty, "local");
+
+            Assert.Equal(2, target.NotifyCount);
+        }
+
         [Fact]
         public void Property_Equals_Should_Handle_Null()
         {
@@ -144,6 +169,11 @@ namespace Avalonia.Base.UnitTests
                 throw new NotImplementedException();
             }
 
+            internal override object RouteGetBaseValue(IAvaloniaObject o, BindingPriority maxPriority)
+            {
+                throw new NotImplementedException();
+            }
+
             internal override void RouteInheritanceParentChanged(AvaloniaObject o, IAvaloniaObject oldParent)
             {
                 throw new NotImplementedException();
@@ -161,7 +191,14 @@ namespace Avalonia.Base.UnitTests
         private class Class1 : AvaloniaObject
         {
             public static readonly StyledProperty<string> FooProperty =
-                AvaloniaProperty.Register<Class1, string>("Foo", "default");
+                AvaloniaProperty.Register<Class1, string>("Foo", "default", notifying: FooNotifying);
+
+            public int NotifyCount { get; private set; }
+
+            private static void FooNotifying(IAvaloniaObject o, bool n)
+            {
+                ++((Class1)o).NotifyCount;
+            }
         }
 
         private class Class2 : Class1

tests/Avalonia.Base.UnitTests/PriorityValueTests.cs

@@ -10,7 +10,7 @@ namespace Avalonia.Base.UnitTests
 {
     public class PriorityValueTests
     {
-        private static readonly IValueSink NullSink = Mock.Of<IValueSink>();
+        private static readonly IValueSink NullSink = new MockSink();
         private static readonly IAvaloniaObject Owner = Mock.Of<IAvaloniaObject>();
         private static readonly StyledProperty<string> TestProperty = new StyledProperty<string>(
             "Test",
@@ -30,8 +30,28 @@ namespace Avalonia.Base.UnitTests
                     BindingPriority.StyleTrigger,
                     NullSink));
 
-            Assert.Equal("1", target.Value.Value);
+            Assert.Equal("1", target.GetValue().Value);
-            Assert.Equal(BindingPriority.StyleTrigger, target.ValuePriority);
+            Assert.Equal(BindingPriority.StyleTrigger, target.Priority);
+        }
+
+        [Fact]
+        public void GetValue_Should_Respect_MaxPriority()
+        {
+            var target = new PriorityValue<string>(
+                Owner,
+                TestProperty,
+                NullSink);
+
+            target.SetValue("animation", BindingPriority.Animation);
+            target.SetValue("local", BindingPriority.LocalValue);
+            target.SetValue("styletrigger", BindingPriority.StyleTrigger);
+            target.SetValue("style", BindingPriority.Style);
+
+            Assert.Equal("animation", target.GetValue(BindingPriority.Animation));
+            Assert.Equal("local", target.GetValue(BindingPriority.LocalValue));
+            Assert.Equal("styletrigger", target.GetValue(BindingPriority.StyleTrigger));
+            Assert.Equal("style", target.GetValue(BindingPriority.TemplatedParent));
+            Assert.Equal("style", target.GetValue(BindingPriority.Style));
         }
 
         [Fact]
@@ -61,12 +81,31 @@ namespace Avalonia.Base.UnitTests
 
             var result = target.Entries
                 .OfType<ConstantValueEntry<string>>()
-                .Select(x => x.Value.Value)
+                .Select(x => x.GetValue().Value)
                 .ToList();
 
             Assert.Equal(new[] { "1", "2" }, result);
         }
 
+        [Fact]
+        public void Priority_Should_Be_Set()
+        {
+            var target = new PriorityValue<string>(
+                Owner,
+                TestProperty,
+                NullSink);
+
+            Assert.Equal(BindingPriority.Unset, target.Priority);
+            target.SetValue("style", BindingPriority.Style);
+            Assert.Equal(BindingPriority.Style, target.Priority);
+            target.SetValue("local", BindingPriority.LocalValue);
+            Assert.Equal(BindingPriority.LocalValue, target.Priority);
+            target.SetValue("animation", BindingPriority.Animation);
+            Assert.Equal(BindingPriority.Animation, target.Priority);
+            target.SetValue("local2", BindingPriority.LocalValue);
+            Assert.Equal(BindingPriority.Animation, target.Priority);
+        }
+
         [Fact]
         public void Binding_With_Same_Priority_Should_Be_Appended()
         {
@@ -184,7 +223,7 @@ namespace Avalonia.Base.UnitTests
             target.AddBinding(source2, BindingPriority.Style).Start();
             target.AddBinding(source3, BindingPriority.Style).Start();
 
-            Assert.Equal("1", target.Value.Value);
+            Assert.Equal("1", target.GetValue().Value);
         }
 
         [Fact]
@@ -196,7 +235,7 @@ namespace Avalonia.Base.UnitTests
             target.AddBinding(source1, BindingPriority.LocalValue).Start();
             target.SetValue("2", BindingPriority.LocalValue);
 
-            Assert.Equal("2", target.Value.Value);
+            Assert.Equal("2", target.GetValue().Value);
         }
 
         [Fact]
@@ -208,7 +247,7 @@ namespace Avalonia.Base.UnitTests
             target.AddBinding(source1, BindingPriority.Style).Start();
             target.SetValue("2", BindingPriority.LocalValue);
 
-            Assert.Equal("2", target.Value.Value);
+            Assert.Equal("2", target.GetValue().Value);
         }
 
         [Fact]
@@ -220,7 +259,39 @@ namespace Avalonia.Base.UnitTests
             target.AddBinding(source1, BindingPriority.Animation).Start();
             target.SetValue("2", BindingPriority.LocalValue);
 
-            Assert.Equal("1", target.Value.Value);
+            Assert.Equal("1", target.GetValue().Value);
+        }
+
+        [Fact]
+        public void NonAnimated_Value_Should_Be_Correct_1()
+        {
+            var target = new PriorityValue<string>(Owner, TestProperty, NullSink);
+            var source1 = new Source("1");
+            var source2 = new Source("2");
+            var source3 = new Source("3");
+
+            target.AddBinding(source1, BindingPriority.LocalValue).Start();
+            target.AddBinding(source2, BindingPriority.Style).Start();
+            target.AddBinding(source3, BindingPriority.Animation).Start();
+
+            Assert.Equal("3", target.GetValue().Value);
+            Assert.Equal("1", target.GetValue(BindingPriority.LocalValue).Value);
+        }
+
+        [Fact]
+        public void NonAnimated_Value_Should_Be_Correct_2()
+        {
+            var target = new PriorityValue<string>(Owner, TestProperty, NullSink);
+            var source1 = new Source("1");
+            var source2 = new Source("2");
+            var source3 = new Source("3");
+
+            target.AddBinding(source1, BindingPriority.Animation).Start();
+            target.AddBinding(source2, BindingPriority.Style).Start();
+            target.AddBinding(source3, BindingPriority.Style).Start();
+
+            Assert.Equal("1", target.GetValue().Value);
+            Assert.Equal("3", target.GetValue(BindingPriority.LocalValue).Value);
         }
 
         private class Source : IObservable<BindingValue<string>>
@@ -239,5 +310,16 @@ namespace Avalonia.Base.UnitTests
 
             public void OnCompleted() => _observer.OnCompleted();
         }
+
+        private class MockSink : IValueSink
+        {
+            public void Completed<T>(StyledPropertyBase<T> property, IPriorityValueEntry entry, Optional<T> oldValue)
+            {
+            }
+
+            public void ValueChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
+            {
+            }
+        }
     }
 }

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

@@ -18,10 +18,10 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             base.OnAttachedToLogicalTree(e);
         }
 
-        protected override void OnPropertyChanged<T>(AvaloniaProperty<T> property, Optional<T> oldValue, BindingValue<T> newValue, BindingPriority priority)
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {
-            Order.Add($"Property {property.Name} Changed");
+            Order.Add($"Property {change.Property.Name} Changed");
-            base.OnPropertyChanged(property, oldValue, newValue, priority);
+            base.OnPropertyChanged(change);
         }
 
         void ISupportInitialize.BeginInit()

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

@@ -337,5 +337,50 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(Brushes.Red, listBox.Background);
             }
         }
+
+        [Fact]
+        public void Transitions_Can_Be_Styled()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+             xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <Window.Styles>
+        <Style Selector='Border'>
+            <Setter Property='Transitions'>
+                <Transitions>
+                    <DoubleTransition Property='Width' Duration='0:0:1'/>
+                </Transitions>
+            </Setter>
+        </Style>
+        <Style Selector='Border.foo'>
+            <Setter Property='Transitions'>
+                <Transitions>
+                    <DoubleTransition Property='Height' Duration='0:0:1'/>
+                </Transitions>
+            </Setter>
+        </Style>
+    </Window.Styles>
+    <Border/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var border = (Border)window.Content;
+
+                Assert.Equal(1, border.Transitions.Count);
+                Assert.Equal(Border.WidthProperty, border.Transitions[0].Property);
+
+                border.Classes.Add("foo");
+
+                Assert.Equal(1, border.Transitions.Count);
+                Assert.Equal(Border.HeightProperty, border.Transitions[0].Property);
+
+                border.Classes.Remove("foo");
+
+                Assert.Equal(1, border.Transitions.Count);
+                Assert.Equal(Border.WidthProperty, border.Transitions[0].Property);
+            }
+        }
     }
 }

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

@@ -34,9 +34,11 @@ namespace Avalonia.Markup.Xaml.UnitTests
             var parsed = (Grid)AvaloniaXamlLoader.Parse(@"
 <Grid xmlns='https://github.com/avaloniaui' >
   <Grid.Transitions>
-    <DoubleTransition Property='Opacity'
+    <Transitions>
-       Easing='CircularEaseIn'
+      <DoubleTransition Property='Opacity'
-       Duration='0:0:0.5' />
+        Easing='CircularEaseIn'
+        Duration='0:0:0.5' />
+    </Transitions>
   </Grid.Transitions>
 </Grid>");
             Assert.Equal(1, parsed.Transitions.Count);

tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests.cs

@@ -36,7 +36,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering
             }
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/moq/moq4/issues/988")]
         public void AddDirty_With_RenderTransform_Call_RenderRoot_Invalidate()
         {
             using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
@@ -59,7 +59,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering
             }
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/moq/moq4/issues/988")]
         public void AddDirty_For_Child_Moved_Should_Invalidate_Previous_Bounds()
         {
             using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
@@ -111,7 +111,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering
             }
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/moq/moq4/issues/988")]
         public void Should_Render_Child_In_Parent_With_RenderTransform()
         {
             using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
@@ -145,7 +145,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering
             }
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/moq/moq4/issues/988")]
         public void Should_Render_Child_In_Parent_With_RenderTransform2()
         {
             using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))