Max Katz
4 years ago
committed by
GitHub
GitHub
250 changed files with 12786 additions and 7579 deletions
@ -1,7 +1,7 @@ |
|||||
using Avalonia; |
using Avalonia; |
||||
using Avalonia.Web.Blazor; |
using Avalonia.Browser.Blazor; |
||||
|
|
||||
namespace ControlCatalog.Blazor.Web; |
namespace ControlCatalog.Browser.Blazor; |
||||
|
|
||||
public partial class App |
public partial class App |
||||
{ |
{ |
||||
@ -1,5 +1,5 @@ |
|||||
@page "/" |
@page "/" |
||||
|
|
||||
@using Avalonia.Web.Blazor |
@using Avalonia.Browser.Blazor |
||||
|
|
||||
<AvaloniaView /> |
<AvaloniaView /> |
||||
|
Before Width: | Height: | Size: 172 KiB After Width: | Height: | Size: 172 KiB |
@ -1,11 +1,11 @@ |
|||||
using System; |
using System; |
||||
using System.Runtime.InteropServices.JavaScript; |
using System.Runtime.InteropServices.JavaScript; |
||||
using Avalonia.Platform; |
using Avalonia.Platform; |
||||
using Avalonia.Web; |
using Avalonia.Browser; |
||||
|
|
||||
using ControlCatalog.Pages; |
using ControlCatalog.Pages; |
||||
|
|
||||
namespace ControlCatalog.Web; |
namespace ControlCatalog.Browser; |
||||
|
|
||||
public class EmbedSampleWeb : INativeDemoControl |
public class EmbedSampleWeb : INativeDemoControl |
||||
{ |
{ |
||||
|
Before Width: | Height: | Size: 1.2 KiB After Width: | Height: | Size: 1.2 KiB |
@ -1,8 +1,8 @@ |
|||||
using System.Runtime.Versioning; |
using System.Runtime.Versioning; |
||||
using Avalonia; |
using Avalonia; |
||||
using Avalonia.Web; |
using Avalonia.Browser; |
||||
using ControlCatalog; |
using ControlCatalog; |
||||
using ControlCatalog.Web; |
using ControlCatalog.Browser; |
||||
|
|
||||
[assembly:SupportedOSPlatform("browser")] |
[assembly:SupportedOSPlatform("browser")] |
||||
|
|
||||
|
Before Width: | Height: | Size: 172 KiB After Width: | Height: | Size: 172 KiB |
@ -0,0 +1,32 @@ |
|||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
|
||||
|
namespace System; |
||||
|
|
||||
|
#if !NET6_0_OR_GREATER
|
||||
|
internal static class CollectionCompatibilityExtensions |
||||
|
{ |
||||
|
public static bool Remove<TKey, TValue>( |
||||
|
this Dictionary<TKey, TValue> o, |
||||
|
TKey key, |
||||
|
[MaybeNullWhen(false)] out TValue value) |
||||
|
where TKey : notnull |
||||
|
{ |
||||
|
if (o.TryGetValue(key, out value)) |
||||
|
return o.Remove(key); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public static bool TryAdd<TKey, TValue>(this Dictionary<TKey, TValue> o, TKey key, TValue value) |
||||
|
where TKey : notnull |
||||
|
{ |
||||
|
if (!o.ContainsKey(key)) |
||||
|
{ |
||||
|
o.Add(key, value); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
#endif
|
||||
@ -0,0 +1,25 @@ |
|||||
|
using System.Collections.Generic; |
||||
|
using Avalonia.Utilities; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal static class AvaloniaPropertyDictionaryPool<TValue> |
||||
|
{ |
||||
|
private const int MaxPoolSize = 4; |
||||
|
private static readonly Stack<AvaloniaPropertyDictionary<TValue>> _pool = new(); |
||||
|
|
||||
|
public static AvaloniaPropertyDictionary<TValue> Get() |
||||
|
{ |
||||
|
return _pool.Count == 0 ? new() : _pool.Pop(); |
||||
|
} |
||||
|
|
||||
|
public static void Release(AvaloniaPropertyDictionary<TValue> dictionary) |
||||
|
{ |
||||
|
if (_pool.Count < MaxPoolSize) |
||||
|
{ |
||||
|
dictionary.Clear(); |
||||
|
_pool.Push(dictionary); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,154 +0,0 @@ |
|||||
using System; |
|
||||
using Avalonia.Data; |
|
||||
using Avalonia.Threading; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents an untyped interface to <see cref="BindingEntry{T}"/>.
|
|
||||
/// </summary>
|
|
||||
internal interface IBindingEntry : IBatchUpdate, IPriorityValueEntry, IDisposable |
|
||||
{ |
|
||||
void Start(bool ignoreBatchUpdate); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Stores a binding in a <see cref="ValueStore"/> or <see cref="PriorityValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
internal class BindingEntry<T> : IBindingEntry, IPriorityValueEntry<T>, IObserver<BindingValue<T>> |
|
||||
{ |
|
||||
private readonly AvaloniaObject _owner; |
|
||||
private ValueOwner<T> _sink; |
|
||||
private IDisposable? _subscription; |
|
||||
private bool _isSubscribed; |
|
||||
private bool _batchUpdate; |
|
||||
private Optional<T> _value; |
|
||||
|
|
||||
public BindingEntry( |
|
||||
AvaloniaObject owner, |
|
||||
StyledPropertyBase<T> property, |
|
||||
IObservable<BindingValue<T>> source, |
|
||||
BindingPriority priority, |
|
||||
ValueOwner<T> sink) |
|
||||
{ |
|
||||
_owner = owner; |
|
||||
Property = property; |
|
||||
Source = source; |
|
||||
Priority = priority; |
|
||||
_sink = sink; |
|
||||
} |
|
||||
|
|
||||
public StyledPropertyBase<T> Property { get; } |
|
||||
public BindingPriority Priority { get; private set; } |
|
||||
public IObservable<BindingValue<T>> Source { get; } |
|
||||
Optional<object?> IValue.GetValue() => _value.ToObject(); |
|
||||
|
|
||||
public void BeginBatchUpdate() => _batchUpdate = true; |
|
||||
|
|
||||
public void EndBatchUpdate() |
|
||||
{ |
|
||||
_batchUpdate = false; |
|
||||
|
|
||||
if (_sink.IsValueStore) |
|
||||
Start(); |
|
||||
} |
|
||||
|
|
||||
public Optional<T> GetValue(BindingPriority maxPriority) |
|
||||
{ |
|
||||
return Priority >= maxPriority ? _value : Optional<T>.Empty; |
|
||||
} |
|
||||
|
|
||||
public void Dispose() |
|
||||
{ |
|
||||
_subscription?.Dispose(); |
|
||||
_subscription = null; |
|
||||
OnCompleted(); |
|
||||
} |
|
||||
|
|
||||
public void OnCompleted() |
|
||||
{ |
|
||||
var oldValue = _value; |
|
||||
_value = default; |
|
||||
Priority = BindingPriority.Unset; |
|
||||
_isSubscribed = false; |
|
||||
_sink.Completed(Property, this, oldValue); |
|
||||
} |
|
||||
|
|
||||
public void OnError(Exception error) |
|
||||
{ |
|
||||
throw new NotImplementedException("BindingEntry.OnError is not implemented", error); |
|
||||
} |
|
||||
|
|
||||
public void OnNext(BindingValue<T> value) |
|
||||
{ |
|
||||
if (Dispatcher.UIThread.CheckAccess()) |
|
||||
{ |
|
||||
UpdateValue(value); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
// To avoid allocating closure in the outer scope we need to capture variables
|
|
||||
// locally. This allows us to skip most of the allocations when on UI thread.
|
|
||||
var instance = this; |
|
||||
var newValue = value; |
|
||||
|
|
||||
Dispatcher.UIThread.Post(() => instance.UpdateValue(newValue)); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public void Start() => Start(false); |
|
||||
|
|
||||
public void Start(bool ignoreBatchUpdate) |
|
||||
{ |
|
||||
// We can't use _subscription to check whether we're subscribed because it won't be set
|
|
||||
// until Subscribe has finished, which will be too late to prevent reentrancy. In addition
|
|
||||
// don't re-subscribe to completed/disposed bindings (indicated by Unset priority).
|
|
||||
if (!_isSubscribed && |
|
||||
Priority != BindingPriority.Unset && |
|
||||
(!_batchUpdate || ignoreBatchUpdate)) |
|
||||
{ |
|
||||
_isSubscribed = true; |
|
||||
_subscription = Source.Subscribe(this); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public void Reparent(PriorityValue<T> parent) => _sink = new(parent); |
|
||||
|
|
||||
public void RaiseValueChanged( |
|
||||
AvaloniaObject owner, |
|
||||
AvaloniaProperty property, |
|
||||
Optional<object?> oldValue, |
|
||||
Optional<object?> newValue) |
|
||||
{ |
|
||||
owner.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
owner, |
|
||||
(AvaloniaProperty<T>)property, |
|
||||
oldValue.Cast<T>(), |
|
||||
newValue.Cast<T>(), |
|
||||
Priority)); |
|
||||
} |
|
||||
|
|
||||
private void UpdateValue(BindingValue<T> value) |
|
||||
{ |
|
||||
if (value.HasValue && Property.ValidateValue?.Invoke(value.Value) == false) |
|
||||
{ |
|
||||
value = Property.GetDefaultValue(_owner.GetType()); |
|
||||
} |
|
||||
|
|
||||
if (value.Type == BindingValueType.DoNothing) |
|
||||
{ |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
var old = _value; |
|
||||
|
|
||||
if (value.Type != BindingValueType.DataValidationError) |
|
||||
{ |
|
||||
_value = value.ToOptional(); |
|
||||
} |
|
||||
|
|
||||
_sink.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>(_owner, Property, old, value, Priority)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,148 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Reactive.Disposables; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal abstract class BindingEntryBase<TValue, TSource> : IValueEntry<TValue>, |
||||
|
IObserver<TSource>, |
||||
|
IObserver<BindingValue<TSource>>, |
||||
|
IDisposable |
||||
|
{ |
||||
|
private static readonly IDisposable s_creating = Disposable.Empty; |
||||
|
private static readonly IDisposable s_creatingQuiet = Disposable.Create(() => { }); |
||||
|
private IDisposable? _subscription; |
||||
|
private bool _hasValue; |
||||
|
private TValue? _value; |
||||
|
|
||||
|
protected BindingEntryBase( |
||||
|
ValueFrame frame, |
||||
|
AvaloniaProperty property, |
||||
|
IObservable<BindingValue<TSource>> source) |
||||
|
{ |
||||
|
Frame = frame; |
||||
|
Source = source; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
protected BindingEntryBase( |
||||
|
ValueFrame frame, |
||||
|
AvaloniaProperty property, |
||||
|
IObservable<TSource> source) |
||||
|
{ |
||||
|
Frame = frame; |
||||
|
Source = source; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public bool HasValue |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
Start(produceValue: false); |
||||
|
return _hasValue; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public bool IsSubscribed => _subscription is not null; |
||||
|
public AvaloniaProperty Property { get; } |
||||
|
AvaloniaProperty IValueEntry.Property => Property; |
||||
|
protected ValueFrame Frame { get; } |
||||
|
protected object Source { get; } |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
Unsubscribe(); |
||||
|
BindingCompleted(); |
||||
|
} |
||||
|
|
||||
|
public TValue GetValue() |
||||
|
{ |
||||
|
Start(produceValue: false); |
||||
|
if (!_hasValue) |
||||
|
throw new AvaloniaInternalException("The binding entry has no value."); |
||||
|
return _value!; |
||||
|
} |
||||
|
|
||||
|
public void Start() => Start(true); |
||||
|
|
||||
|
public void OnCompleted() => BindingCompleted(); |
||||
|
public void OnError(Exception error) => BindingCompleted(); |
||||
|
public void OnNext(TSource value) => SetValue(ConvertAndValidate(value)); |
||||
|
public void OnNext(BindingValue<TSource> value) => SetValue(ConvertAndValidate(value)); |
||||
|
|
||||
|
public virtual void Unsubscribe() |
||||
|
{ |
||||
|
_subscription?.Dispose(); |
||||
|
_subscription = null; |
||||
|
} |
||||
|
|
||||
|
object? IValueEntry.GetValue() |
||||
|
{ |
||||
|
Start(produceValue: false); |
||||
|
if (!_hasValue) |
||||
|
throw new AvaloniaInternalException("The BindingEntry<T> has no value."); |
||||
|
return _value!; |
||||
|
} |
||||
|
|
||||
|
protected abstract BindingValue<TValue> ConvertAndValidate(TSource value); |
||||
|
protected abstract BindingValue<TValue> ConvertAndValidate(BindingValue<TSource> value); |
||||
|
|
||||
|
protected virtual void Start(bool produceValue) |
||||
|
{ |
||||
|
if (_subscription is not null) |
||||
|
return; |
||||
|
|
||||
|
_subscription = produceValue ? s_creating : s_creatingQuiet; |
||||
|
_subscription = Source switch |
||||
|
{ |
||||
|
IObservable<BindingValue<TSource>> bv => bv.Subscribe(this), |
||||
|
IObservable<TSource> b => b.Subscribe(this), |
||||
|
_ => throw new AvaloniaInternalException("Unexpected binding source."), |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
private void ClearValue() |
||||
|
{ |
||||
|
if (_hasValue) |
||||
|
{ |
||||
|
_hasValue = false; |
||||
|
_value = default; |
||||
|
if (_subscription is not null) |
||||
|
Frame.Owner?.OnBindingValueCleared(Property, Frame.Priority); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void SetValue(BindingValue<TValue> value) |
||||
|
{ |
||||
|
if (Frame.Owner is null) |
||||
|
return; |
||||
|
|
||||
|
LoggingUtils.LogIfNecessary(Frame.Owner.Owner, Property, value); |
||||
|
|
||||
|
if (value.HasValue) |
||||
|
{ |
||||
|
if (!_hasValue || !EqualityComparer<TValue>.Default.Equals(_value, value.Value)) |
||||
|
{ |
||||
|
_value = value.Value; |
||||
|
_hasValue = true; |
||||
|
if (_subscription is not null && _subscription != s_creatingQuiet) |
||||
|
Frame.Owner?.OnBindingValueChanged(this, Frame.Priority); |
||||
|
} |
||||
|
} |
||||
|
else if (value.Type != BindingValueType.DoNothing) |
||||
|
{ |
||||
|
ClearValue(); |
||||
|
if (_subscription is not null && _subscription != s_creatingQuiet) |
||||
|
Frame.Owner?.OnBindingValueCleared(Property, Frame.Priority); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void BindingCompleted() |
||||
|
{ |
||||
|
_subscription = null; |
||||
|
Frame.OnBindingCompleted(this); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,82 +0,0 @@ |
|||||
using System; |
|
||||
using System.Diagnostics.CodeAnalysis; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents an untyped interface to <see cref="ConstantValueEntry{T}"/>.
|
|
||||
/// </summary>
|
|
||||
internal interface IConstantValueEntry : IPriorityValueEntry, IDisposable |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Stores a value with a priority in a <see cref="ValueStore"/> or
|
|
||||
/// <see cref="PriorityValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
internal class ConstantValueEntry<T> : IPriorityValueEntry<T>, IConstantValueEntry |
|
||||
{ |
|
||||
private ValueOwner<T> _sink; |
|
||||
private Optional<T> _value; |
|
||||
|
|
||||
public ConstantValueEntry( |
|
||||
StyledPropertyBase<T> property, |
|
||||
T value, |
|
||||
BindingPriority priority, |
|
||||
ValueOwner<T> sink) |
|
||||
{ |
|
||||
Property = property; |
|
||||
_value = value; |
|
||||
Priority = priority; |
|
||||
_sink = sink; |
|
||||
} |
|
||||
|
|
||||
public ConstantValueEntry( |
|
||||
StyledPropertyBase<T> property, |
|
||||
Optional<T> value, |
|
||||
BindingPriority priority, |
|
||||
ValueOwner<T> sink) |
|
||||
{ |
|
||||
Property = property; |
|
||||
_value = value; |
|
||||
Priority = priority; |
|
||||
_sink = sink; |
|
||||
} |
|
||||
|
|
||||
public StyledPropertyBase<T> Property { get; } |
|
||||
public BindingPriority Priority { get; private set; } |
|
||||
Optional<object?> IValue.GetValue() => _value.ToObject(); |
|
||||
|
|
||||
public Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation) |
|
||||
{ |
|
||||
return Priority >= maxPriority ? _value : Optional<T>.Empty; |
|
||||
} |
|
||||
|
|
||||
public void Dispose() |
|
||||
{ |
|
||||
var oldValue = _value; |
|
||||
_value = default; |
|
||||
Priority = BindingPriority.Unset; |
|
||||
_sink.Completed(Property, this, oldValue); |
|
||||
} |
|
||||
|
|
||||
public void Reparent(PriorityValue<T> sink) => _sink = new(sink); |
|
||||
public void Start() { } |
|
||||
|
|
||||
public void RaiseValueChanged( |
|
||||
AvaloniaObject owner, |
|
||||
AvaloniaProperty property, |
|
||||
Optional<object?> oldValue, |
|
||||
Optional<object?> newValue) |
|
||||
{ |
|
||||
owner.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
owner, |
|
||||
(AvaloniaProperty<T>)property, |
|
||||
oldValue.Cast<T>(), |
|
||||
newValue.Cast<T>(), |
|
||||
Priority)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,76 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
using Avalonia.Threading; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class DirectBindingObserver<T> : IObserver<T>, |
||||
|
IObserver<BindingValue<T>>, |
||||
|
IDisposable |
||||
|
{ |
||||
|
private readonly ValueStore _owner; |
||||
|
private IDisposable? _subscription; |
||||
|
|
||||
|
public DirectBindingObserver(ValueStore owner, DirectPropertyBase<T> property) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public DirectPropertyBase<T> Property { get;} |
||||
|
|
||||
|
public void Start(IObservable<T> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Start(IObservable<BindingValue<T>> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_subscription?.Dispose(); |
||||
|
_subscription = null; |
||||
|
_owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
} |
||||
|
|
||||
|
public void OnCompleted() => _owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
public void OnError(Exception error) => OnCompleted(); |
||||
|
|
||||
|
public void OnNext(T value) |
||||
|
{ |
||||
|
if (Dispatcher.UIThread.CheckAccess()) |
||||
|
{ |
||||
|
_owner.Owner.SetDirectValueUnchecked<T>(Property, value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// To avoid allocating closure in the outer scope we need to capture variables
|
||||
|
// locally. This allows us to skip most of the allocations when on UI thread.
|
||||
|
var instance = _owner.Owner; |
||||
|
var property = Property; |
||||
|
var newValue = value; |
||||
|
Dispatcher.UIThread.Post(() => instance.SetDirectValueUnchecked(property, newValue)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void OnNext(BindingValue<T> value) |
||||
|
{ |
||||
|
if (Dispatcher.UIThread.CheckAccess()) |
||||
|
{ |
||||
|
_owner.Owner.SetDirectValueUnchecked<T>(Property, value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// To avoid allocating closure in the outer scope we need to capture variables
|
||||
|
// locally. This allows us to skip most of the allocations when on UI thread.
|
||||
|
var instance = _owner.Owner; |
||||
|
var property = Property; |
||||
|
var newValue = value; |
||||
|
Dispatcher.UIThread.Post(() => instance.SetDirectValueUnchecked(property, newValue)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,55 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
using Avalonia.Threading; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class DirectUntypedBindingObserver<T> : IObserver<object?>, |
||||
|
IDisposable |
||||
|
{ |
||||
|
private readonly ValueStore _owner; |
||||
|
private IDisposable? _subscription; |
||||
|
|
||||
|
public DirectUntypedBindingObserver(ValueStore owner, DirectPropertyBase<T> property) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public DirectPropertyBase<T> Property { get;} |
||||
|
|
||||
|
public void Start(IObservable<object?> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_subscription?.Dispose(); |
||||
|
_subscription = null; |
||||
|
_owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
} |
||||
|
|
||||
|
public void OnCompleted() => _owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
public void OnError(Exception error) => OnCompleted(); |
||||
|
|
||||
|
public void OnNext(object? value) |
||||
|
{ |
||||
|
var typed = BindingValue<T>.FromUntyped(value); |
||||
|
|
||||
|
if (Dispatcher.UIThread.CheckAccess()) |
||||
|
{ |
||||
|
_owner.Owner.SetDirectValueUnchecked<T>(Property, typed); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// To avoid allocating closure in the outer scope we need to capture variables
|
||||
|
// locally. This allows us to skip most of the allocations when on UI thread.
|
||||
|
var instance = _owner.Owner; |
||||
|
var property = Property; |
||||
|
var newValue = value; |
||||
|
Dispatcher.UIThread.Post(() => instance.SetDirectValueUnchecked(property, typed)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,168 @@ |
|||||
|
using System.Diagnostics; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Represents the active value for a property in a <see cref="ValueStore"/>.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// This class is an abstract base for the generic <see cref="EffectiveValue{T}"/>.
|
||||
|
/// </remarks>
|
||||
|
internal abstract class EffectiveValue |
||||
|
{ |
||||
|
private IValueEntry? _valueEntry; |
||||
|
private IValueEntry? _baseValueEntry; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the current effective value as a boxed value.
|
||||
|
/// </summary>
|
||||
|
public object? Value => GetBoxedValue(); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the priority of the current effective value.
|
||||
|
/// </summary>
|
||||
|
public BindingPriority Priority { get; protected set; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the priority of the current base value.
|
||||
|
/// </summary>
|
||||
|
public BindingPriority BasePriority { get; protected set; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Begins a reevaluation pass on the effective value.
|
||||
|
/// </summary>
|
||||
|
/// <param name="clearLocalValue">
|
||||
|
/// Determines whether any current local value should be cleared.
|
||||
|
/// </param>
|
||||
|
/// <remarks>
|
||||
|
/// This method resets the <see cref="Priority"/> and <see cref="BasePriority"/> properties
|
||||
|
/// to Unset, pending reevaluation.
|
||||
|
/// </remarks>
|
||||
|
public void BeginReevaluation(bool clearLocalValue = false) |
||||
|
{ |
||||
|
if (clearLocalValue || Priority != BindingPriority.LocalValue) |
||||
|
Priority = BindingPriority.Unset; |
||||
|
if (clearLocalValue || BasePriority != BindingPriority.LocalValue) |
||||
|
BasePriority = BindingPriority.Unset; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Ends a reevaluation pass on the effective value.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// This method unsubscribes from any unused value entries.
|
||||
|
/// </remarks>
|
||||
|
public void EndReevaluation() |
||||
|
{ |
||||
|
if (Priority == BindingPriority.Unset) |
||||
|
{ |
||||
|
_valueEntry?.Unsubscribe(); |
||||
|
_valueEntry = null; |
||||
|
} |
||||
|
|
||||
|
if (BasePriority == BindingPriority.Unset) |
||||
|
{ |
||||
|
_baseValueEntry?.Unsubscribe(); |
||||
|
_baseValueEntry = null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Sets the value and base value for a non-LocalValue priority, raising
|
||||
|
/// <see cref="AvaloniaObject.PropertyChanged"/> where necessary.
|
||||
|
/// </summary>
|
||||
|
/// <param name="owner">The associated value store.</param>
|
||||
|
/// <param name="value">The new value of the property.</param>
|
||||
|
/// <param name="priority">The priority of the new value.</param>
|
||||
|
public abstract void SetAndRaise( |
||||
|
ValueStore owner, |
||||
|
IValueEntry value, |
||||
|
BindingPriority priority); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Raises <see cref="AvaloniaObject.PropertyChanged"/> in response to an inherited value
|
||||
|
/// change.
|
||||
|
/// </summary>
|
||||
|
/// <param name="owner">The owner object.</param>
|
||||
|
/// <param name="property">The property being changed.</param>
|
||||
|
/// <param name="oldValue">The old value of the property.</param>
|
||||
|
/// <param name="newValue">The new value of the property.</param>
|
||||
|
public abstract void RaiseInheritedValueChanged( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
EffectiveValue? oldValue, |
||||
|
EffectiveValue? newValue); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Removes the current animation value and reverts to the base value, raising
|
||||
|
/// <see cref="AvaloniaObject.PropertyChanged"/> where necessary.
|
||||
|
/// </summary>
|
||||
|
/// <param name="owner">The associated value store.</param>
|
||||
|
/// <param name="property">The property being changed.</param>
|
||||
|
public abstract void RemoveAnimationAndRaise(ValueStore owner, AvaloniaProperty property); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Coerces the property value.
|
||||
|
/// </summary>
|
||||
|
/// <param name="owner">The associated value store.</param>
|
||||
|
/// <param name="property">The property to coerce.</param>
|
||||
|
public abstract void CoerceValue(ValueStore owner, AvaloniaProperty property); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Disposes the effective value, raising <see cref="AvaloniaObject.PropertyChanged"/>
|
||||
|
/// where necessary.
|
||||
|
/// </summary>
|
||||
|
/// <param name="owner">The associated value store.</param>
|
||||
|
/// <param name="property">The property being cleared.</param>
|
||||
|
public abstract void DisposeAndRaiseUnset(ValueStore owner, AvaloniaProperty property); |
||||
|
|
||||
|
protected abstract object? GetBoxedValue(); |
||||
|
|
||||
|
protected void UpdateValueEntry(IValueEntry? entry, BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority != BindingPriority.LocalValue); |
||||
|
|
||||
|
if (priority <= BindingPriority.Animation) |
||||
|
{ |
||||
|
// If we've received an animation value and the current value is a non-animation
|
||||
|
// value, then the current entry becomes our base entry.
|
||||
|
if (Priority > BindingPriority.LocalValue && Priority < BindingPriority.Inherited) |
||||
|
{ |
||||
|
Debug.Assert(_valueEntry is not null); |
||||
|
_baseValueEntry = _valueEntry; |
||||
|
_valueEntry = null; |
||||
|
} |
||||
|
|
||||
|
if (_valueEntry != entry) |
||||
|
{ |
||||
|
_valueEntry?.Unsubscribe(); |
||||
|
_valueEntry = entry; |
||||
|
} |
||||
|
} |
||||
|
else if (Priority <= BindingPriority.Animation) |
||||
|
{ |
||||
|
// We've received a non-animation value and have an active animation value, so the
|
||||
|
// new entry becomes our base entry.
|
||||
|
if (_baseValueEntry != entry) |
||||
|
{ |
||||
|
_baseValueEntry?.Unsubscribe(); |
||||
|
_baseValueEntry = entry; |
||||
|
} |
||||
|
} |
||||
|
else if (_valueEntry != entry) |
||||
|
{ |
||||
|
// Both the current value and the new value are non-animation values, so the new
|
||||
|
// entry replaces the existing entry.
|
||||
|
_valueEntry?.Unsubscribe(); |
||||
|
_valueEntry = entry; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected void UnsubscribeValueEntries() |
||||
|
{ |
||||
|
_valueEntry?.Unsubscribe(); |
||||
|
_baseValueEntry?.Unsubscribe(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,270 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Represents the active value for a property in a <see cref="ValueStore"/>.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// Stores the active value in an <see cref="AvaloniaObject"/>'s <see cref="ValueStore"/>
|
||||
|
/// for a single property, when the value is not inherited or unset/default.
|
||||
|
/// </remarks>
|
||||
|
internal sealed class EffectiveValue<T> : EffectiveValue |
||||
|
{ |
||||
|
private readonly StyledPropertyMetadata<T> _metadata; |
||||
|
private T? _baseValue; |
||||
|
private UncommonFields? _uncommon; |
||||
|
|
||||
|
public EffectiveValue(AvaloniaObject owner, StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
Priority = BindingPriority.Unset; |
||||
|
BasePriority = BindingPriority.Unset; |
||||
|
_metadata = property.GetMetadata(owner.GetType()); |
||||
|
|
||||
|
var value = _metadata.DefaultValue; |
||||
|
|
||||
|
if (property.HasCoercion && _metadata.CoerceValue is { } coerce) |
||||
|
{ |
||||
|
_uncommon = new() |
||||
|
{ |
||||
|
_coerce = coerce, |
||||
|
_uncoercedValue = value, |
||||
|
_uncoercedBaseValue = value, |
||||
|
}; |
||||
|
|
||||
|
Value = coerce(owner, value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
Value = value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the current effective value.
|
||||
|
/// </summary>
|
||||
|
public new T Value { get; private set; } |
||||
|
|
||||
|
public override void SetAndRaise( |
||||
|
ValueStore owner, |
||||
|
IValueEntry value, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority != BindingPriority.LocalValue); |
||||
|
UpdateValueEntry(value, priority); |
||||
|
|
||||
|
SetAndRaiseCore(owner, (StyledPropertyBase<T>)value.Property, GetValue(value), priority); |
||||
|
} |
||||
|
|
||||
|
public void SetLocalValueAndRaise( |
||||
|
ValueStore owner, |
||||
|
StyledPropertyBase<T> property, |
||||
|
T value) |
||||
|
{ |
||||
|
SetAndRaiseCore(owner, property, value, BindingPriority.LocalValue); |
||||
|
} |
||||
|
|
||||
|
public bool TryGetBaseValue([MaybeNullWhen(false)] out T value) |
||||
|
{ |
||||
|
value = _baseValue!; |
||||
|
return BasePriority != BindingPriority.Unset; |
||||
|
} |
||||
|
|
||||
|
public override void RaiseInheritedValueChanged( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
EffectiveValue? oldValue, |
||||
|
EffectiveValue? newValue) |
||||
|
{ |
||||
|
Debug.Assert(oldValue is not null || newValue is not null); |
||||
|
|
||||
|
var p = (StyledPropertyBase<T>)property; |
||||
|
var o = oldValue is not null ? ((EffectiveValue<T>)oldValue).Value : _metadata.DefaultValue; |
||||
|
var n = newValue is not null ? ((EffectiveValue<T>)newValue).Value : _metadata.DefaultValue; |
||||
|
var priority = newValue is not null ? BindingPriority.Inherited : BindingPriority.Unset; |
||||
|
|
||||
|
if (!EqualityComparer<T>.Default.Equals(o, n)) |
||||
|
{ |
||||
|
owner.RaisePropertyChanged(p, o, n, priority, true); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public override void RemoveAnimationAndRaise(ValueStore owner, AvaloniaProperty property) |
||||
|
{ |
||||
|
Debug.Assert(Priority != BindingPriority.Animation); |
||||
|
Debug.Assert(BasePriority != BindingPriority.Unset); |
||||
|
UpdateValueEntry(null, BindingPriority.Animation); |
||||
|
SetAndRaiseCore(owner, (StyledPropertyBase<T>)property, _baseValue!, BasePriority); |
||||
|
} |
||||
|
|
||||
|
public override void CoerceValue(ValueStore owner, AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_uncommon is null) |
||||
|
return; |
||||
|
SetAndRaiseCore( |
||||
|
owner, |
||||
|
(StyledPropertyBase<T>)property, |
||||
|
_uncommon._uncoercedValue!, |
||||
|
Priority, |
||||
|
_uncommon._uncoercedBaseValue!, |
||||
|
BasePriority); |
||||
|
} |
||||
|
|
||||
|
public override void DisposeAndRaiseUnset(ValueStore owner, AvaloniaProperty property) |
||||
|
{ |
||||
|
UnsubscribeValueEntries(); |
||||
|
DisposeAndRaiseUnset(owner, (StyledPropertyBase<T>)property); |
||||
|
} |
||||
|
|
||||
|
public void DisposeAndRaiseUnset(ValueStore owner, StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
BindingPriority priority; |
||||
|
T oldValue; |
||||
|
|
||||
|
if (property.Inherits && owner.TryGetInheritedValue(property, out var i)) |
||||
|
{ |
||||
|
oldValue = ((EffectiveValue<T>)i).Value; |
||||
|
priority = BindingPriority.Inherited; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
oldValue = _metadata.DefaultValue; |
||||
|
priority = BindingPriority.Unset; |
||||
|
} |
||||
|
|
||||
|
if (!EqualityComparer<T>.Default.Equals(oldValue, Value)) |
||||
|
{ |
||||
|
owner.Owner.RaisePropertyChanged(property, Value, oldValue, priority, true); |
||||
|
if (property.Inherits) |
||||
|
owner.OnInheritedEffectiveValueDisposed(property, Value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected override object? GetBoxedValue() => Value; |
||||
|
|
||||
|
private static T GetValue(IValueEntry entry) |
||||
|
{ |
||||
|
if (entry is IValueEntry<T> typed) |
||||
|
return typed.GetValue(); |
||||
|
else |
||||
|
return (T)entry.GetValue()!; |
||||
|
} |
||||
|
|
||||
|
private void SetAndRaiseCore( |
||||
|
ValueStore owner, |
||||
|
StyledPropertyBase<T> property, |
||||
|
T value, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority < BindingPriority.Inherited); |
||||
|
|
||||
|
var oldValue = Value; |
||||
|
var valueChanged = false; |
||||
|
var baseValueChanged = false; |
||||
|
var v = value; |
||||
|
|
||||
|
if (_uncommon?._coerce is { } coerce) |
||||
|
v = coerce(owner.Owner, value); |
||||
|
|
||||
|
if (priority <= Priority) |
||||
|
{ |
||||
|
valueChanged = !EqualityComparer<T>.Default.Equals(Value, v); |
||||
|
Value = v; |
||||
|
Priority = priority; |
||||
|
if (_uncommon is not null) |
||||
|
_uncommon._uncoercedValue = value; |
||||
|
} |
||||
|
|
||||
|
if (priority <= BasePriority && priority >= BindingPriority.LocalValue) |
||||
|
{ |
||||
|
baseValueChanged = !EqualityComparer<T>.Default.Equals(_baseValue, v); |
||||
|
_baseValue = v; |
||||
|
BasePriority = priority; |
||||
|
if (_uncommon is not null) |
||||
|
_uncommon._uncoercedBaseValue = value; |
||||
|
} |
||||
|
|
||||
|
if (valueChanged) |
||||
|
{ |
||||
|
using var notifying = PropertyNotifying.Start(owner.Owner, property); |
||||
|
owner.Owner.RaisePropertyChanged(property, oldValue, Value, Priority, true); |
||||
|
if (property.Inherits) |
||||
|
owner.OnInheritedEffectiveValueChanged(property, oldValue, this); |
||||
|
} |
||||
|
else if (baseValueChanged) |
||||
|
{ |
||||
|
owner.Owner.RaisePropertyChanged(property, default, _baseValue!, BasePriority, false); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void SetAndRaiseCore( |
||||
|
ValueStore owner, |
||||
|
StyledPropertyBase<T> property, |
||||
|
T value, |
||||
|
BindingPriority priority, |
||||
|
T baseValue, |
||||
|
BindingPriority basePriority) |
||||
|
{ |
||||
|
Debug.Assert(priority < BindingPriority.Inherited); |
||||
|
Debug.Assert(basePriority > BindingPriority.Animation); |
||||
|
Debug.Assert(priority <= basePriority); |
||||
|
|
||||
|
var oldValue = Value; |
||||
|
var valueChanged = false; |
||||
|
var baseValueChanged = false; |
||||
|
var v = value; |
||||
|
var bv = baseValue; |
||||
|
|
||||
|
if (_uncommon?._coerce is { } coerce) |
||||
|
{ |
||||
|
v = coerce(owner.Owner, value); |
||||
|
bv = coerce(owner.Owner, baseValue); |
||||
|
} |
||||
|
|
||||
|
if (priority != BindingPriority.Unset && !EqualityComparer<T>.Default.Equals(Value, v)) |
||||
|
{ |
||||
|
Value = v; |
||||
|
valueChanged = true; |
||||
|
if (_uncommon is not null) |
||||
|
_uncommon._uncoercedValue = value; |
||||
|
} |
||||
|
|
||||
|
if (priority != BindingPriority.Unset && |
||||
|
(BasePriority == BindingPriority.Unset || |
||||
|
!EqualityComparer<T>.Default.Equals(_baseValue, bv))) |
||||
|
{ |
||||
|
_baseValue = v; |
||||
|
baseValueChanged = true; |
||||
|
if (_uncommon is not null) |
||||
|
_uncommon._uncoercedValue = baseValue; |
||||
|
} |
||||
|
|
||||
|
Priority = priority; |
||||
|
BasePriority = basePriority; |
||||
|
|
||||
|
if (valueChanged) |
||||
|
{ |
||||
|
using var notifying = PropertyNotifying.Start(owner.Owner, property); |
||||
|
owner.Owner.RaisePropertyChanged(property, oldValue, Value, Priority, true); |
||||
|
if (property.Inherits) |
||||
|
owner.OnInheritedEffectiveValueChanged(property, oldValue, this); |
||||
|
} |
||||
|
|
||||
|
if (baseValueChanged) |
||||
|
{ |
||||
|
owner.Owner.RaisePropertyChanged(property, default, _baseValue!, BasePriority, false); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private class UncommonFields |
||||
|
{ |
||||
|
public Func<IAvaloniaObject, T, T>? _coerce; |
||||
|
public T? _uncoercedValue; |
||||
|
public T? _uncoercedBaseValue; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,8 +0,0 @@ |
|||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
internal interface IBatchUpdate |
|
||||
{ |
|
||||
void BeginBatchUpdate(); |
|
||||
void EndBatchUpdate(); |
|
||||
} |
|
||||
} |
|
||||
@ -1,18 +0,0 @@ |
|||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents an untyped interface to <see cref="IPriorityValueEntry{T}"/>.
|
|
||||
/// </summary>
|
|
||||
internal interface IPriorityValueEntry : IValue |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Represents an object that can act as an entry in a <see cref="PriorityValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
internal interface IPriorityValueEntry<T> : IPriorityValueEntry, IValue<T> |
|
||||
{ |
|
||||
void Reparent(PriorityValue<T> parent); |
|
||||
} |
|
||||
} |
|
||||
@ -1,28 +0,0 @@ |
|||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents an untyped interface to <see cref="IValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
internal interface IValue |
|
||||
{ |
|
||||
BindingPriority Priority { get; } |
|
||||
Optional<object?> GetValue(); |
|
||||
void Start(); |
|
||||
void RaiseValueChanged( |
|
||||
AvaloniaObject owner, |
|
||||
AvaloniaProperty property, |
|
||||
Optional<object?> oldValue, |
|
||||
Optional<object?> newValue); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Represents an object that can act as an entry in a <see cref="ValueStore"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
internal interface IValue<T> : IValue |
|
||||
{ |
|
||||
Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation); |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,30 @@ |
|||||
|
using System; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Represents an untyped value entry in a <see cref="ValueFrame"/>.
|
||||
|
/// </summary>
|
||||
|
internal interface IValueEntry |
||||
|
{ |
||||
|
bool HasValue { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the property that this value applies to.
|
||||
|
/// </summary>
|
||||
|
AvaloniaProperty Property { get; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the value associated with the entry.
|
||||
|
/// </summary>
|
||||
|
/// <exception cref="AvaloniaInternalException">
|
||||
|
/// The entry has no value.
|
||||
|
/// </exception>
|
||||
|
object? GetValue(); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called when the value entry is removed from the value store.
|
||||
|
/// </summary>
|
||||
|
void Unsubscribe(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,16 @@ |
|||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Represents a typed value entry in a <see cref="ValueFrame"/>.
|
||||
|
/// </summary>
|
||||
|
internal interface IValueEntry<T> : IValueEntry |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Gets the value associated with the entry.
|
||||
|
/// </summary>
|
||||
|
/// <exception cref="AvaloniaInternalException">
|
||||
|
/// The entry has no value.
|
||||
|
/// </exception>
|
||||
|
new T GetValue(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,31 @@ |
|||||
|
using System; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class ImmediateValueEntry<T> : IValueEntry<T>, IDisposable |
||||
|
{ |
||||
|
private readonly ImmediateValueFrame _owner; |
||||
|
private readonly T _value; |
||||
|
|
||||
|
public ImmediateValueEntry( |
||||
|
ImmediateValueFrame owner, |
||||
|
StyledPropertyBase<T> property, |
||||
|
T value) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
_value = value; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public StyledPropertyBase<T> Property { get; } |
||||
|
public bool HasValue => true; |
||||
|
AvaloniaProperty IValueEntry.Property => Property; |
||||
|
|
||||
|
public void Unsubscribe() { } |
||||
|
|
||||
|
public void Dispose() => _owner.OnEntryDisposed(this); |
||||
|
|
||||
|
object? IValueEntry.GetValue() => _value; |
||||
|
T IValueEntry<T>.GetValue() => _value; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,63 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Holds values in a <see cref="ValueStore"/> set by one of the SetValue or AddBinding
|
||||
|
/// overloads with non-LocalValue priority.
|
||||
|
/// </summary>
|
||||
|
internal class ImmediateValueFrame : ValueFrame |
||||
|
{ |
||||
|
public ImmediateValueFrame(BindingPriority priority) |
||||
|
{ |
||||
|
Priority = priority; |
||||
|
} |
||||
|
|
||||
|
public TypedBindingEntry<T> AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<BindingValue<T>> source) |
||||
|
{ |
||||
|
var e = new TypedBindingEntry<T>(this, property, source); |
||||
|
Add(e); |
||||
|
return e; |
||||
|
} |
||||
|
|
||||
|
public TypedBindingEntry<T> AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<T> source) |
||||
|
{ |
||||
|
var e = new TypedBindingEntry<T>(this, property, source); |
||||
|
Add(e); |
||||
|
return e; |
||||
|
} |
||||
|
|
||||
|
public SourceUntypedBindingEntry<T> AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<object?> source) |
||||
|
{ |
||||
|
var e = new SourceUntypedBindingEntry<T>(this, property, source); |
||||
|
Add(e); |
||||
|
return e; |
||||
|
} |
||||
|
|
||||
|
public ImmediateValueEntry<T> AddValue<T>(StyledPropertyBase<T> property, T value) |
||||
|
{ |
||||
|
var e = new ImmediateValueEntry<T>(this, property, value); |
||||
|
Add(e); |
||||
|
return e; |
||||
|
} |
||||
|
|
||||
|
public void OnEntryDisposed(IValueEntry value) |
||||
|
{ |
||||
|
Remove(value.Property); |
||||
|
Owner?.OnValueEntryRemoved(this, value.Property); |
||||
|
} |
||||
|
|
||||
|
protected override bool GetIsActive(out bool hasChanged) |
||||
|
{ |
||||
|
hasChanged = false; |
||||
|
return true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,59 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class LocalValueBindingObserver<T> : IObserver<T>, |
||||
|
IObserver<BindingValue<T>>, |
||||
|
IDisposable |
||||
|
{ |
||||
|
private readonly ValueStore _owner; |
||||
|
private IDisposable? _subscription; |
||||
|
|
||||
|
public LocalValueBindingObserver(ValueStore owner, StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public StyledPropertyBase<T> Property { get;} |
||||
|
|
||||
|
public void Start(IObservable<T> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Start(IObservable<BindingValue<T>> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_subscription?.Dispose(); |
||||
|
_subscription = null; |
||||
|
_owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
} |
||||
|
|
||||
|
public void OnCompleted() => _owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
public void OnError(Exception error) => OnCompleted(); |
||||
|
|
||||
|
public void OnNext(T value) |
||||
|
{ |
||||
|
if (Property.ValidateValue?.Invoke(value) != false) |
||||
|
_owner.SetValue(Property, value, BindingPriority.LocalValue); |
||||
|
else |
||||
|
_owner.ClearLocalValue(Property); |
||||
|
} |
||||
|
|
||||
|
public void OnNext(BindingValue<T> value) |
||||
|
{ |
||||
|
LoggingUtils.LogIfNecessary(_owner.Owner, Property, value); |
||||
|
|
||||
|
if (value.HasValue) |
||||
|
_owner.SetValue(Property, value.Value, BindingPriority.LocalValue); |
||||
|
else if (value.Type != BindingValueType.DataValidationError) |
||||
|
_owner.ClearLocalValue(Property); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,41 +0,0 @@ |
|||||
using System.Diagnostics.CodeAnalysis; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Stores a value with local value priority in a <see cref="ValueStore"/> or
|
|
||||
/// <see cref="PriorityValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
internal class LocalValueEntry<T> : IValue<T> |
|
||||
{ |
|
||||
private T _value; |
|
||||
|
|
||||
public LocalValueEntry(T value) => _value = value; |
|
||||
public BindingPriority Priority => BindingPriority.LocalValue; |
|
||||
Optional<object?> IValue.GetValue() => new Optional<object?>(_value); |
|
||||
|
|
||||
public Optional<T> GetValue(BindingPriority maxPriority) |
|
||||
{ |
|
||||
return BindingPriority.LocalValue >= maxPriority ? _value : Optional<T>.Empty; |
|
||||
} |
|
||||
|
|
||||
public void SetValue(T value) => _value = value; |
|
||||
public void Start() { } |
|
||||
|
|
||||
public void RaiseValueChanged( |
|
||||
AvaloniaObject owner, |
|
||||
AvaloniaProperty property, |
|
||||
Optional<object?> oldValue, |
|
||||
Optional<object?> newValue) |
|
||||
{ |
|
||||
owner.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
owner, |
|
||||
(AvaloniaProperty<T>)property, |
|
||||
oldValue.Cast<T>(), |
|
||||
newValue.Cast<T>(), |
|
||||
BindingPriority.LocalValue)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,62 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class LocalValueUntypedBindingObserver<T> : IObserver<object?>, |
||||
|
IDisposable |
||||
|
{ |
||||
|
private readonly ValueStore _owner; |
||||
|
private IDisposable? _subscription; |
||||
|
|
||||
|
public LocalValueUntypedBindingObserver(ValueStore owner, StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
_owner = owner; |
||||
|
Property = property; |
||||
|
} |
||||
|
|
||||
|
public StyledPropertyBase<T> Property { get; } |
||||
|
|
||||
|
public void Start(IObservable<object?> source) |
||||
|
{ |
||||
|
_subscription = source.Subscribe(this); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_subscription?.Dispose(); |
||||
|
_subscription = null; |
||||
|
_owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
} |
||||
|
|
||||
|
public void OnCompleted() => _owner.OnLocalValueBindingCompleted(Property, this); |
||||
|
public void OnError(Exception error) => OnCompleted(); |
||||
|
|
||||
|
public void OnNext(object? value) |
||||
|
{ |
||||
|
if (value is BindingNotification n) |
||||
|
{ |
||||
|
value = n.Value; |
||||
|
LoggingUtils.LogIfNecessary(_owner.Owner, Property, n); |
||||
|
} |
||||
|
|
||||
|
if (value == AvaloniaProperty.UnsetValue) |
||||
|
{ |
||||
|
_owner.ClearLocalValue(Property); |
||||
|
} |
||||
|
else if (value == BindingOperations.DoNothing) |
||||
|
{ |
||||
|
// Do nothing!
|
||||
|
} |
||||
|
else if (UntypedValueUtils.TryConvertAndValidate(Property, value, out var typedValue)) |
||||
|
{ |
||||
|
_owner.SetValue(Property, typedValue, BindingPriority.LocalValue); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
_owner.ClearLocalValue(Property); |
||||
|
LoggingUtils.LogInvalidValue(_owner.Owner, Property, typeof(T), value); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,82 @@ |
|||||
|
using System; |
||||
|
using System.Reflection; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal static class LoggingUtils |
||||
|
{ |
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static void LogIfNecessary( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
BindingNotification value) |
||||
|
{ |
||||
|
if (value.ErrorType != BindingErrorType.None) |
||||
|
Log(owner, property, value.Error!); |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
public static void LogIfNecessary<T>( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
BindingValue<T> value) |
||||
|
{ |
||||
|
if (value.HasError) |
||||
|
Log(owner, property, value.Error!); |
||||
|
} |
||||
|
|
||||
|
public static void LogInvalidValue( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
Type expectedType, |
||||
|
object? value) |
||||
|
{ |
||||
|
if (value is not null) |
||||
|
{ |
||||
|
owner.GetBindingWarningLogger(property, null)?.Log( |
||||
|
owner, |
||||
|
"Error in binding to {Target}.{Property}: expected {ExpectedType}, got {Value} ({ValueType})", |
||||
|
owner, |
||||
|
property, |
||||
|
expectedType, |
||||
|
value, |
||||
|
value.GetType()); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
owner.GetBindingWarningLogger(property, null)?.Log( |
||||
|
owner, |
||||
|
"Error in binding to {Target}.{Property}: expected {ExpectedType}, got null", |
||||
|
owner, |
||||
|
property, |
||||
|
expectedType); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void Log( |
||||
|
AvaloniaObject owner, |
||||
|
AvaloniaProperty property, |
||||
|
Exception e) |
||||
|
{ |
||||
|
if (e is TargetInvocationException t) |
||||
|
e = t.InnerException!; |
||||
|
|
||||
|
if (e is AggregateException a) |
||||
|
{ |
||||
|
foreach (var i in a.InnerExceptions) |
||||
|
Log(owner, property, i); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
owner.GetBindingWarningLogger(property, e)?.Log( |
||||
|
owner, |
||||
|
"Error in binding to {Target}.{Property}: {Message}", |
||||
|
owner, |
||||
|
property, |
||||
|
e.Message); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,326 +0,0 @@ |
|||||
using System; |
|
||||
using System.Collections.Generic; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents an untyped interface to <see cref="PriorityValue{T}"/>.
|
|
||||
/// </summary>
|
|
||||
interface IPriorityValue : IValue |
|
||||
{ |
|
||||
void UpdateEffectiveValue(); |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Stores a set of prioritized values and bindings in a <see cref="ValueStore"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The property type.</typeparam>
|
|
||||
/// <remarks>
|
|
||||
/// When more than a single value or binding is applied to a property in an
|
|
||||
/// <see cref="AvaloniaObject"/>, the entry in the <see cref="ValueStore"/> is converted into
|
|
||||
/// a <see cref="PriorityValue{T}"/>. This class holds any number of
|
|
||||
/// <see cref="IPriorityValueEntry{T}"/> entries (sorted first by priority and then in the order
|
|
||||
/// they were added) plus a local value.
|
|
||||
/// </remarks>
|
|
||||
internal class PriorityValue<T> : IPriorityValue, IValue<T>, IBatchUpdate |
|
||||
{ |
|
||||
private readonly AvaloniaObject _owner; |
|
||||
private readonly ValueStore _store; |
|
||||
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; |
|
||||
private bool _isCalculatingValue; |
|
||||
private bool _batchUpdate; |
|
||||
|
|
||||
public PriorityValue( |
|
||||
AvaloniaObject owner, |
|
||||
StyledPropertyBase<T> property, |
|
||||
ValueStore store) |
|
||||
{ |
|
||||
_owner = owner; |
|
||||
Property = property; |
|
||||
_store = store; |
|
||||
|
|
||||
if (property.HasCoercion) |
|
||||
{ |
|
||||
var metadata = property.GetMetadata(owner.GetType()); |
|
||||
_coerceValue = metadata.CoerceValue; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public PriorityValue( |
|
||||
AvaloniaObject owner, |
|
||||
StyledPropertyBase<T> property, |
|
||||
ValueStore store, |
|
||||
IPriorityValueEntry<T> existing) |
|
||||
: this(owner, property, store) |
|
||||
{ |
|
||||
existing.Reparent(this); |
|
||||
_entries.Add(existing); |
|
||||
|
|
||||
if (existing is IBindingEntry binding && |
|
||||
existing.Priority == BindingPriority.LocalValue) |
|
||||
{ |
|
||||
// Bit of a special case here: if we have a local value binding that is being
|
|
||||
// promoted to a priority value we need to make sure the binding is subscribed
|
|
||||
// even if we've got a batch operation in progress because otherwise we don't know
|
|
||||
// whether the binding or a subsequent SetValue with local priority will win. A
|
|
||||
// notification won't be sent during batch update anyway because it will be
|
|
||||
// caught and stored for later by the ValueStore.
|
|
||||
binding.Start(ignoreBatchUpdate: true); |
|
||||
} |
|
||||
|
|
||||
var v = existing.GetValue(); |
|
||||
|
|
||||
if (v.HasValue) |
|
||||
{ |
|
||||
_value = v; |
|
||||
Priority = existing.Priority; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public PriorityValue( |
|
||||
AvaloniaObject owner, |
|
||||
StyledPropertyBase<T> property, |
|
||||
ValueStore sink, |
|
||||
LocalValueEntry<T> existing) |
|
||||
: this(owner, property, sink) |
|
||||
{ |
|
||||
_value = _localValue = existing.GetValue(BindingPriority.LocalValue); |
|
||||
Priority = BindingPriority.LocalValue; |
|
||||
} |
|
||||
|
|
||||
public StyledPropertyBase<T> Property { get; } |
|
||||
public BindingPriority Priority { get; private set; } = BindingPriority.Unset; |
|
||||
public IReadOnlyList<IPriorityValueEntry<T>> Entries => _entries; |
|
||||
Optional<object?> IValue.GetValue() => _value.ToObject(); |
|
||||
|
|
||||
public void BeginBatchUpdate() |
|
||||
{ |
|
||||
_batchUpdate = true; |
|
||||
|
|
||||
foreach (var entry in _entries) |
|
||||
{ |
|
||||
(entry as IBatchUpdate)?.BeginBatchUpdate(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public void EndBatchUpdate() |
|
||||
{ |
|
||||
_batchUpdate = false; |
|
||||
|
|
||||
foreach (var entry in _entries) |
|
||||
{ |
|
||||
(entry as IBatchUpdate)?.EndBatchUpdate(); |
|
||||
} |
|
||||
|
|
||||
UpdateEffectiveValue(null); |
|
||||
} |
|
||||
|
|
||||
public void ClearLocalValue() |
|
||||
{ |
|
||||
_localValue = default; |
|
||||
UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
_owner, |
|
||||
Property, |
|
||||
default, |
|
||||
default, |
|
||||
BindingPriority.LocalValue)); |
|
||||
} |
|
||||
|
|
||||
public Optional<T> GetValue(BindingPriority maxPriority = BindingPriority.Animation) |
|
||||
{ |
|
||||
if (Priority == BindingPriority.Unset) |
|
||||
{ |
|
||||
return default; |
|
||||
} |
|
||||
|
|
||||
if (Priority >= maxPriority) |
|
||||
{ |
|
||||
return _value; |
|
||||
} |
|
||||
|
|
||||
return CalculateValue(maxPriority).Item1; |
|
||||
} |
|
||||
|
|
||||
public IDisposable? SetValue(T value, BindingPriority priority) |
|
||||
{ |
|
||||
IDisposable? result = null; |
|
||||
|
|
||||
if (priority == BindingPriority.LocalValue) |
|
||||
{ |
|
||||
_localValue = value; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
var insert = FindInsertPoint(priority); |
|
||||
var entry = new ConstantValueEntry<T>(Property, value, priority, new ValueOwner<T>(this)); |
|
||||
_entries.Insert(insert, entry); |
|
||||
result = entry; |
|
||||
} |
|
||||
|
|
||||
UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
_owner, |
|
||||
Property, |
|
||||
default, |
|
||||
value, |
|
||||
priority)); |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
public BindingEntry<T> AddBinding(IObservable<BindingValue<T>> source, BindingPriority priority) |
|
||||
{ |
|
||||
var binding = new BindingEntry<T>(_owner, Property, source, priority, new(this)); |
|
||||
var insert = FindInsertPoint(binding.Priority); |
|
||||
_entries.Insert(insert, binding); |
|
||||
|
|
||||
if (_batchUpdate) |
|
||||
{ |
|
||||
binding.BeginBatchUpdate(); |
|
||||
|
|
||||
if (priority == BindingPriority.LocalValue) |
|
||||
{ |
|
||||
binding.Start(ignoreBatchUpdate: true); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return binding; |
|
||||
} |
|
||||
|
|
||||
public void UpdateEffectiveValue() => UpdateEffectiveValue(null); |
|
||||
public void Start() => UpdateEffectiveValue(null); |
|
||||
|
|
||||
public void RaiseValueChanged( |
|
||||
AvaloniaObject owner, |
|
||||
AvaloniaProperty property, |
|
||||
Optional<object?> oldValue, |
|
||||
Optional<object?> newValue) |
|
||||
{ |
|
||||
owner.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
owner, |
|
||||
(AvaloniaProperty<T>)property, |
|
||||
oldValue.Cast<T>(), |
|
||||
newValue.Cast<T>(), |
|
||||
Priority)); |
|
||||
} |
|
||||
|
|
||||
public void ValueChanged<TValue>(AvaloniaPropertyChangedEventArgs<TValue> change) |
|
||||
{ |
|
||||
if (change.Priority == BindingPriority.LocalValue) |
|
||||
{ |
|
||||
_localValue = default; |
|
||||
} |
|
||||
|
|
||||
if (!_isCalculatingValue && change is AvaloniaPropertyChangedEventArgs<T> c) |
|
||||
{ |
|
||||
UpdateEffectiveValue(c); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public void Completed(IPriorityValueEntry entry, Optional<T> oldValue) |
|
||||
{ |
|
||||
_entries.Remove((IPriorityValueEntry<T>)entry); |
|
||||
UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
_owner, |
|
||||
Property, |
|
||||
oldValue, |
|
||||
default, |
|
||||
entry.Priority)); |
|
||||
} |
|
||||
|
|
||||
private int FindInsertPoint(BindingPriority priority) |
|
||||
{ |
|
||||
var result = _entries.Count; |
|
||||
|
|
||||
for (var i = 0; i < _entries.Count; ++i) |
|
||||
{ |
|
||||
if (_entries[i].Priority < priority) |
|
||||
{ |
|
||||
result = i; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
public (Optional<T>, BindingPriority) CalculateValue(BindingPriority maxPriority) |
|
||||
{ |
|
||||
_isCalculatingValue = true; |
|
||||
|
|
||||
try |
|
||||
{ |
|
||||
for (var i = _entries.Count - 1; i >= 0; --i) |
|
||||
{ |
|
||||
var entry = _entries[i]; |
|
||||
|
|
||||
if (entry.Priority < maxPriority) |
|
||||
{ |
|
||||
continue; |
|
||||
} |
|
||||
|
|
||||
entry.Start(); |
|
||||
|
|
||||
if (entry.Priority >= BindingPriority.LocalValue && |
|
||||
maxPriority <= BindingPriority.LocalValue && |
|
||||
_localValue.HasValue) |
|
||||
{ |
|
||||
return (_localValue, BindingPriority.LocalValue); |
|
||||
} |
|
||||
|
|
||||
var entryValue = entry.GetValue(); |
|
||||
|
|
||||
if (entryValue.HasValue) |
|
||||
{ |
|
||||
return (entryValue, entry.Priority); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (maxPriority <= BindingPriority.LocalValue && _localValue.HasValue) |
|
||||
{ |
|
||||
return (_localValue, BindingPriority.LocalValue); |
|
||||
} |
|
||||
|
|
||||
return (default, BindingPriority.Unset); |
|
||||
} |
|
||||
finally |
|
||||
{ |
|
||||
_isCalculatingValue = false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
private void UpdateEffectiveValue(AvaloniaPropertyChangedEventArgs<T>? change) |
|
||||
{ |
|
||||
var (value, priority) = CalculateValue(BindingPriority.Animation); |
|
||||
|
|
||||
if (value.HasValue && _coerceValue != null) |
|
||||
{ |
|
||||
value = _coerceValue(_owner, value.Value); |
|
||||
} |
|
||||
|
|
||||
Priority = priority; |
|
||||
|
|
||||
if (value != _value) |
|
||||
{ |
|
||||
var old = _value; |
|
||||
_value = value; |
|
||||
|
|
||||
_store.ValueChanged(new AvaloniaPropertyChangedEventArgs<T>( |
|
||||
_owner, |
|
||||
Property, |
|
||||
old, |
|
||||
value, |
|
||||
Priority)); |
|
||||
} |
|
||||
else if (change is object) |
|
||||
{ |
|
||||
change.MarkNonEffectiveValue(); |
|
||||
change.SetOldValue(default); |
|
||||
_store.ValueChanged(change); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,35 @@ |
|||||
|
using System; |
||||
|
using System.Diagnostics; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Raises <see cref="AvaloniaProperty.Notifying"/> where necessary.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// Uses the disposable pattern to ensure that the closing Notifying call is made even in the
|
||||
|
/// presence of exceptions.
|
||||
|
/// </remarks>
|
||||
|
internal readonly struct PropertyNotifying : IDisposable |
||||
|
{ |
||||
|
private readonly AvaloniaObject _owner; |
||||
|
private readonly AvaloniaProperty _property; |
||||
|
|
||||
|
private PropertyNotifying(AvaloniaObject owner, AvaloniaProperty property) |
||||
|
{ |
||||
|
Debug.Assert(property.Notifying is not null); |
||||
|
_owner = owner; |
||||
|
_property = property; |
||||
|
_property.Notifying!(owner, true); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() => _property.Notifying!(_owner, false); |
||||
|
|
||||
|
public static PropertyNotifying? Start(AvaloniaObject owner, AvaloniaProperty property) |
||||
|
{ |
||||
|
if (property.Notifying is null) |
||||
|
return null; |
||||
|
return new PropertyNotifying(owner, property); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,35 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// An <see cref="IValueEntry"/> that holds a binding whose source observable is untyped and
|
||||
|
/// target property is typed.
|
||||
|
/// </summary>
|
||||
|
internal sealed class SourceUntypedBindingEntry<TTarget> : BindingEntryBase<TTarget, object?> |
||||
|
{ |
||||
|
private readonly Func<TTarget, bool>? _validate; |
||||
|
|
||||
|
public SourceUntypedBindingEntry( |
||||
|
ValueFrame frame, |
||||
|
StyledPropertyBase<TTarget> property, |
||||
|
IObservable<object?> source) |
||||
|
: base(frame, property, source) |
||||
|
{ |
||||
|
_validate = property.ValidateValue; |
||||
|
} |
||||
|
|
||||
|
public new StyledPropertyBase<TTarget> Property => (StyledPropertyBase<TTarget>)base.Property; |
||||
|
|
||||
|
protected override BindingValue<TTarget> ConvertAndValidate(object? value) |
||||
|
{ |
||||
|
return UntypedValueUtils.ConvertAndValidate(value, Property.PropertyType, _validate); |
||||
|
} |
||||
|
|
||||
|
protected override BindingValue<TTarget> ConvertAndValidate(BindingValue<object?> value) |
||||
|
{ |
||||
|
throw new NotSupportedException(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,52 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// An <see cref="IValueEntry"/> that holds a binding whose source observable and target
|
||||
|
/// property are both typed.
|
||||
|
/// </summary>
|
||||
|
internal sealed class TypedBindingEntry<T> : BindingEntryBase<T, T> |
||||
|
{ |
||||
|
public TypedBindingEntry( |
||||
|
ValueFrame frame, |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<T> source) |
||||
|
: base(frame, property, source) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
public TypedBindingEntry( |
||||
|
ValueFrame frame, |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<BindingValue<T>> source) |
||||
|
: base(frame, property, source) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
public new StyledPropertyBase<T> Property => (StyledPropertyBase<T>)base.Property; |
||||
|
|
||||
|
protected override BindingValue<T> ConvertAndValidate(T value) |
||||
|
{ |
||||
|
if (Property.ValidateValue?.Invoke(value) == false) |
||||
|
{ |
||||
|
return BindingValue<T>.BindingError( |
||||
|
new InvalidCastException($"'{value}' is not a valid value.")); |
||||
|
} |
||||
|
|
||||
|
return value; |
||||
|
} |
||||
|
|
||||
|
protected override BindingValue<T> ConvertAndValidate(BindingValue<T> value) |
||||
|
{ |
||||
|
if (value.HasValue && Property.ValidateValue?.Invoke(value.Value) == false) |
||||
|
{ |
||||
|
return BindingValue<T>.BindingError( |
||||
|
new InvalidCastException($"'{value.Value}' is not a valid value.")); |
||||
|
} |
||||
|
|
||||
|
return value; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,33 @@ |
|||||
|
using System; |
||||
|
using Avalonia.Data; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// An <see cref="IValueEntry"/> that holds a binding whose source observable and target
|
||||
|
/// property are both untyped.
|
||||
|
/// </summary>
|
||||
|
internal class UntypedBindingEntry : BindingEntryBase<object?, object?> |
||||
|
{ |
||||
|
private readonly Func<object?, bool>? _validate; |
||||
|
|
||||
|
public UntypedBindingEntry( |
||||
|
ValueFrame frame, |
||||
|
AvaloniaProperty property, |
||||
|
IObservable<object?> source) |
||||
|
: base(frame, property, source) |
||||
|
{ |
||||
|
_validate = ((IStyledPropertyAccessor)property).ValidateValue; |
||||
|
} |
||||
|
|
||||
|
protected override BindingValue<object?> ConvertAndValidate(object? value) |
||||
|
{ |
||||
|
return UntypedValueUtils.ConvertAndValidate(value, Property.PropertyType, _validate); |
||||
|
} |
||||
|
|
||||
|
protected override BindingValue<object?> ConvertAndValidate(BindingValue<object?> value) |
||||
|
{ |
||||
|
throw new NotSupportedException(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,55 @@ |
|||||
|
using System; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
using Avalonia.Data; |
||||
|
using Avalonia.Utilities; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal static class UntypedValueUtils |
||||
|
{ |
||||
|
public static BindingValue<T> ConvertAndValidate<T>( |
||||
|
object? value, |
||||
|
Type targetType, |
||||
|
Func<T, bool>? validate) |
||||
|
{ |
||||
|
var v = BindingValue<T>.FromUntyped(value, targetType); |
||||
|
|
||||
|
if (v.HasValue && validate?.Invoke(v.Value) == false) |
||||
|
{ |
||||
|
return BindingValue<T>.BindingError( |
||||
|
new InvalidCastException($"'{v.Value}' is not a valid value.")); |
||||
|
} |
||||
|
|
||||
|
return v; |
||||
|
} |
||||
|
|
||||
|
public static bool TryConvertAndValidate( |
||||
|
AvaloniaProperty property, |
||||
|
object? value, |
||||
|
out object? result) |
||||
|
{ |
||||
|
if (TypeUtilities.TryConvertImplicit(property.PropertyType, value, out result)) |
||||
|
return ((IStyledPropertyAccessor)property).ValidateValue(result); |
||||
|
|
||||
|
result = default; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public static bool TryConvertAndValidate<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
object? value, |
||||
|
[MaybeNullWhen(false)] out T result) |
||||
|
{ |
||||
|
if (TypeUtilities.TryConvertImplicit(typeof(T), value, out var v)) |
||||
|
{ |
||||
|
result = (T)v!; |
||||
|
|
||||
|
if (property.ValidateValue?.Invoke(result) != false) |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
result = default; |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,103 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
using Avalonia.Data; |
||||
|
using Avalonia.Utilities; |
||||
|
using static Avalonia.Rendering.Composition.Animations.PropertySetSnapshot; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal abstract class ValueFrame |
||||
|
{ |
||||
|
private List<IValueEntry>? _entries; |
||||
|
private AvaloniaPropertyDictionary<IValueEntry> _index; |
||||
|
private ValueStore? _owner; |
||||
|
private bool _isShared; |
||||
|
|
||||
|
public int EntryCount => _index.Count; |
||||
|
public bool IsActive => GetIsActive(out _); |
||||
|
public ValueStore? Owner => !_isShared ? _owner : |
||||
|
throw new AvaloniaInternalException("Cannot get owner for shared ValueFrame"); |
||||
|
public BindingPriority Priority { get; protected set; } |
||||
|
|
||||
|
public bool Contains(AvaloniaProperty property) => _index.ContainsKey(property); |
||||
|
|
||||
|
public IValueEntry GetEntry(int index) => _entries?[index] ?? _index[0]; |
||||
|
|
||||
|
public void SetOwner(ValueStore? owner) |
||||
|
{ |
||||
|
if (_owner is not null && owner is not null) |
||||
|
throw new AvaloniaInternalException("ValueFrame already has an owner."); |
||||
|
if (!_isShared) |
||||
|
_owner = owner; |
||||
|
} |
||||
|
|
||||
|
public bool TryGetEntryIfActive( |
||||
|
AvaloniaProperty property, |
||||
|
[NotNullWhen(true)] out IValueEntry? entry, |
||||
|
out bool activeChanged) |
||||
|
{ |
||||
|
if (_index.TryGetValue(property, out entry)) |
||||
|
return GetIsActive(out activeChanged); |
||||
|
activeChanged = false; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public void OnBindingCompleted(IValueEntry binding) |
||||
|
{ |
||||
|
var property = binding.Property; |
||||
|
Remove(property); |
||||
|
Owner?.OnValueEntryRemoved(this, property); |
||||
|
} |
||||
|
|
||||
|
public virtual void Dispose() |
||||
|
{ |
||||
|
for (var i = 0; i < _index.Count; ++i) |
||||
|
_index[i].Unsubscribe(); |
||||
|
} |
||||
|
|
||||
|
protected abstract bool GetIsActive(out bool hasChanged); |
||||
|
|
||||
|
protected void MakeShared() |
||||
|
{ |
||||
|
_isShared = true; |
||||
|
_owner = null; |
||||
|
} |
||||
|
|
||||
|
protected void Add(IValueEntry value) |
||||
|
{ |
||||
|
Debug.Assert(!value.Property.IsDirect); |
||||
|
|
||||
|
if (_entries is null && _index.Count == 1) |
||||
|
{ |
||||
|
_entries = new(); |
||||
|
_entries.Add(_index[0]); |
||||
|
} |
||||
|
|
||||
|
_index.Add(value.Property, value); |
||||
|
_entries?.Add(value); |
||||
|
} |
||||
|
|
||||
|
protected void Remove(AvaloniaProperty property) |
||||
|
{ |
||||
|
Debug.Assert(!property.IsDirect); |
||||
|
|
||||
|
if (_entries is not null) |
||||
|
{ |
||||
|
var count = _entries.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
if (_entries[i].Property == property) |
||||
|
{ |
||||
|
_entries.RemoveAt(i); |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
_index.Remove(property); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,45 +0,0 @@ |
|||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.PropertyStore |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Represents a union type of <see cref="ValueStore"/> and <see cref="PriorityValue{T}"/>,
|
|
||||
/// which are the valid owners of a value store <see cref="IValue"/>.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="T">The value type.</typeparam>
|
|
||||
internal readonly struct ValueOwner<T> |
|
||||
{ |
|
||||
private readonly ValueStore? _store; |
|
||||
private readonly PriorityValue<T>? _priorityValue; |
|
||||
|
|
||||
public ValueOwner(ValueStore o) |
|
||||
{ |
|
||||
_store = o; |
|
||||
_priorityValue = null; |
|
||||
} |
|
||||
|
|
||||
public ValueOwner(PriorityValue<T> v) |
|
||||
{ |
|
||||
_store = null; |
|
||||
_priorityValue = v; |
|
||||
} |
|
||||
|
|
||||
public bool IsValueStore => _store is not null; |
|
||||
|
|
||||
public void Completed(StyledPropertyBase<T> property, IPriorityValueEntry entry, Optional<T> oldValue) |
|
||||
{ |
|
||||
if (_store is not null) |
|
||||
_store?.Completed(property, entry, oldValue); |
|
||||
else |
|
||||
_priorityValue!.Completed(entry, oldValue); |
|
||||
} |
|
||||
|
|
||||
public void ValueChanged(AvaloniaPropertyChangedEventArgs<T> e) |
|
||||
{ |
|
||||
if (_store is not null) |
|
||||
_store?.ValueChanged(e); |
|
||||
else |
|
||||
_priorityValue!.ValueChanged(e); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,962 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.Diagnostics.CodeAnalysis; |
||||
|
using Avalonia.Data; |
||||
|
using Avalonia.Diagnostics; |
||||
|
using Avalonia.Logging; |
||||
|
using Avalonia.Utilities; |
||||
|
|
||||
|
namespace Avalonia.PropertyStore |
||||
|
{ |
||||
|
internal class ValueStore |
||||
|
{ |
||||
|
private readonly List<ValueFrame> _frames = new(); |
||||
|
private Dictionary<int, IDisposable>? _localValueBindings; |
||||
|
private AvaloniaPropertyDictionary<EffectiveValue> _effectiveValues; |
||||
|
private int _inheritedValueCount; |
||||
|
private int _isEvaluating; |
||||
|
private int _frameGeneration; |
||||
|
private int _styling; |
||||
|
|
||||
|
public ValueStore(AvaloniaObject owner) => Owner = owner; |
||||
|
|
||||
|
public AvaloniaObject Owner { get; } |
||||
|
public ValueStore? InheritanceAncestor { get; private set; } |
||||
|
public bool IsEvaluating => _isEvaluating > 0; |
||||
|
public IReadOnlyList<ValueFrame> Frames => _frames; |
||||
|
|
||||
|
public void BeginStyling() => ++_styling; |
||||
|
|
||||
|
public void EndStyling() |
||||
|
{ |
||||
|
if (--_styling == 0) |
||||
|
ReevaluateEffectiveValues(); |
||||
|
} |
||||
|
|
||||
|
public void AddFrame(ValueFrame style) |
||||
|
{ |
||||
|
InsertFrame(style); |
||||
|
ReevaluateEffectiveValues(); |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<BindingValue<T>> source, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
if (priority == BindingPriority.LocalValue) |
||||
|
{ |
||||
|
var observer = new LocalValueBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var effective = GetEffectiveValue(property); |
||||
|
|
||||
|
var frame = GetOrCreateImmediateValueFrame(property, priority, out _); |
||||
|
var result = frame.AddBinding(property, source); |
||||
|
|
||||
|
if (effective is null || priority <= effective.Priority) |
||||
|
result.Start(); |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<T> source, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
if (priority == BindingPriority.LocalValue) |
||||
|
{ |
||||
|
var observer = new LocalValueBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var effective = GetEffectiveValue(property); |
||||
|
|
||||
|
var frame = GetOrCreateImmediateValueFrame(property, priority, out _); |
||||
|
var result = frame.AddBinding(property, source); |
||||
|
|
||||
|
if (effective is null || priority <= effective.Priority) |
||||
|
result.Start(); |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
IObservable<object?> source, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
if (priority == BindingPriority.LocalValue) |
||||
|
{ |
||||
|
var observer = new LocalValueUntypedBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var effective = GetEffectiveValue(property); |
||||
|
|
||||
|
var frame = GetOrCreateImmediateValueFrame(property, priority, out _); |
||||
|
var result = frame.AddBinding(property, source); |
||||
|
|
||||
|
if (effective is null || priority <= effective.Priority) |
||||
|
result.Start(); |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>(DirectPropertyBase<T> property, IObservable<BindingValue<T>> source) |
||||
|
{ |
||||
|
var observer = new DirectBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>(DirectPropertyBase<T> property, IObservable<T> source) |
||||
|
{ |
||||
|
var observer = new DirectBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
|
||||
|
public IDisposable AddBinding<T>(DirectPropertyBase<T> property, IObservable<object?> source) |
||||
|
{ |
||||
|
var observer = new DirectUntypedBindingObserver<T>(this, property); |
||||
|
DisposeExistingLocalValueBinding(property); |
||||
|
_localValueBindings ??= new(); |
||||
|
_localValueBindings[property.Id] = observer; |
||||
|
observer.Start(source); |
||||
|
return observer; |
||||
|
} |
||||
|
|
||||
|
public void ClearLocalValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (TryGetEffectiveValue(property, out var effective) && |
||||
|
effective.Priority == BindingPriority.LocalValue) |
||||
|
{ |
||||
|
ReevaluateEffectiveValue(property, effective, ignoreLocalValue: true); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public IDisposable? SetValue<T>(StyledPropertyBase<T> property, T value, BindingPriority priority) |
||||
|
{ |
||||
|
if (property.ValidateValue?.Invoke(value) == false) |
||||
|
{ |
||||
|
throw new ArgumentException($"{value} is not a valid value for '{property.Name}."); |
||||
|
} |
||||
|
|
||||
|
if (priority != BindingPriority.LocalValue) |
||||
|
{ |
||||
|
var frame = GetOrCreateImmediateValueFrame(property, priority, out _); |
||||
|
var result = frame.AddValue(property, value); |
||||
|
|
||||
|
if (TryGetEffectiveValue(property, out var existing)) |
||||
|
{ |
||||
|
var effective = (EffectiveValue<T>)existing; |
||||
|
effective.SetAndRaise(this, result, priority); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var effectiveValue = new EffectiveValue<T>(Owner, property); |
||||
|
AddEffectiveValue(property, effectiveValue); |
||||
|
effectiveValue.SetAndRaise(this, result, priority); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (TryGetEffectiveValue(property, out var existing)) |
||||
|
{ |
||||
|
var effective = (EffectiveValue<T>)existing; |
||||
|
effective.SetLocalValueAndRaise(this, property, value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var effectiveValue = new EffectiveValue<T>(Owner, property); |
||||
|
AddEffectiveValue(property, effectiveValue); |
||||
|
effectiveValue.SetLocalValueAndRaise(this, property, value); |
||||
|
} |
||||
|
|
||||
|
return null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public object? GetValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
return v.Value; |
||||
|
if (property.Inherits && TryGetInheritedValue(property, out v)) |
||||
|
return v.Value; |
||||
|
|
||||
|
return GetDefaultValue(property); |
||||
|
} |
||||
|
|
||||
|
public T GetValue<T>(StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
return ((EffectiveValue<T>)v).Value; |
||||
|
if (property.Inherits && TryGetInheritedValue(property, out v)) |
||||
|
return ((EffectiveValue<T>)v).Value; |
||||
|
return property.GetDefaultValue(Owner.GetType()); |
||||
|
} |
||||
|
|
||||
|
public bool IsAnimating(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
return v.Priority <= BindingPriority.Animation; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public bool IsSet(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
return v.Priority < BindingPriority.Inherited; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public void CoerceValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
v.CoerceValue(this, property); |
||||
|
} |
||||
|
|
||||
|
public Optional<T> GetBaseValue<T>(StyledPropertyBase<T> property) |
||||
|
{ |
||||
|
if (TryGetEffectiveValue(property, out var v) && |
||||
|
((EffectiveValue<T>)v).TryGetBaseValue(out var baseValue)) |
||||
|
{ |
||||
|
return baseValue; |
||||
|
} |
||||
|
|
||||
|
return default; |
||||
|
} |
||||
|
|
||||
|
public bool TryGetInheritedValue( |
||||
|
AvaloniaProperty property, |
||||
|
[NotNullWhen(true)] out EffectiveValue? result) |
||||
|
{ |
||||
|
Debug.Assert(property.Inherits); |
||||
|
|
||||
|
var i = InheritanceAncestor; |
||||
|
|
||||
|
while (i is not null) |
||||
|
{ |
||||
|
if (i.TryGetEffectiveValue(property, out result)) |
||||
|
return true; |
||||
|
i = i.InheritanceAncestor; |
||||
|
} |
||||
|
|
||||
|
result = null; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public void SetInheritanceParent(AvaloniaObject? newParent) |
||||
|
{ |
||||
|
var values = AvaloniaPropertyDictionaryPool<OldNewValue>.Get(); |
||||
|
var oldAncestor = InheritanceAncestor; |
||||
|
var newAncestor = newParent?.GetValueStore(); |
||||
|
|
||||
|
if (newAncestor?._inheritedValueCount == 0) |
||||
|
newAncestor = newAncestor.InheritanceAncestor; |
||||
|
|
||||
|
// The old and new inheritance ancestors are the same, nothing to do here.
|
||||
|
if (oldAncestor == newAncestor) |
||||
|
return; |
||||
|
|
||||
|
// First get the old values from the old inheritance ancestor.
|
||||
|
var f = oldAncestor; |
||||
|
|
||||
|
while (f is not null) |
||||
|
{ |
||||
|
var count = f._effectiveValues.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
f._effectiveValues.GetKeyValue(i, out var key, out var value); |
||||
|
if (key.Inherits) |
||||
|
values.TryAdd(key, new(value)); |
||||
|
} |
||||
|
|
||||
|
f = f.InheritanceAncestor; |
||||
|
} |
||||
|
|
||||
|
f = newAncestor; |
||||
|
|
||||
|
// Get the new values from the new inheritance ancestor.
|
||||
|
while (f is not null) |
||||
|
{ |
||||
|
var count = f._effectiveValues.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
f._effectiveValues.GetKeyValue(i, out var key, out var value); |
||||
|
|
||||
|
if (!key.Inherits) |
||||
|
continue; |
||||
|
|
||||
|
if (values.TryGetValue(key, out var existing)) |
||||
|
{ |
||||
|
if (existing.NewValue is null) |
||||
|
values[key] = existing.WithNewValue(value); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
values.Add(key, new(null, value)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
f = f.InheritanceAncestor; |
||||
|
} |
||||
|
|
||||
|
OnInheritanceAncestorChanged(newAncestor); |
||||
|
|
||||
|
// Raise PropertyChanged events where necessary on this object and inheritance children.
|
||||
|
{ |
||||
|
var count = values.Count; |
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
values.GetKeyValue(i, out var key, out var v); |
||||
|
var oldValue = v.OldValue; |
||||
|
var newValue = v.NewValue; |
||||
|
|
||||
|
if (oldValue != newValue) |
||||
|
InheritedValueChanged(key, oldValue, newValue); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
AvaloniaPropertyDictionaryPool<OldNewValue>.Release(values); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by non-LocalValue binding entries to re-evaluate the effective value when the
|
||||
|
/// binding produces a new value.
|
||||
|
/// </summary>
|
||||
|
/// <param name="entry">The binding entry.</param>
|
||||
|
/// <param name="priority">The priority of binding which produced a new value.</param>
|
||||
|
public void OnBindingValueChanged( |
||||
|
IValueEntry entry, |
||||
|
BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority != BindingPriority.LocalValue); |
||||
|
|
||||
|
var property = entry.Property; |
||||
|
|
||||
|
if (TryGetEffectiveValue(property, out var existing)) |
||||
|
{ |
||||
|
if (priority <= existing.BasePriority) |
||||
|
ReevaluateEffectiveValue(property, existing); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
AddEffectiveValueAndRaise(property, entry, priority); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by non-LocalValue binding entries to re-evaluate the effective value when the
|
||||
|
/// binding produces an unset value.
|
||||
|
/// </summary>
|
||||
|
/// <param name="property">The bound property.</param>
|
||||
|
/// <param name="priority">The priority of binding which produced a new value.</param>
|
||||
|
public void OnBindingValueCleared(AvaloniaProperty property, BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority != BindingPriority.LocalValue); |
||||
|
|
||||
|
if (TryGetEffectiveValue(property, out var existing)) |
||||
|
{ |
||||
|
if (priority <= existing.Priority) |
||||
|
ReevaluateEffectiveValue(property, existing); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by a <see cref="ValueFrame"/> when its <see cref="ValueFrame.IsActive"/>
|
||||
|
/// state changes.
|
||||
|
/// </summary>
|
||||
|
/// <param name="frame">The frame which produced the change.</param>
|
||||
|
public void OnFrameActivationChanged(ValueFrame frame) |
||||
|
{ |
||||
|
if (frame.EntryCount == 0) |
||||
|
return; |
||||
|
else if (frame.EntryCount == 1) |
||||
|
{ |
||||
|
var property = frame.GetEntry(0).Property; |
||||
|
_effectiveValues.TryGetValue(property, out var current); |
||||
|
ReevaluateEffectiveValue(property, current); |
||||
|
} |
||||
|
else |
||||
|
ReevaluateEffectiveValues(); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by the parent value store when its inheritance ancestor changes.
|
||||
|
/// </summary>
|
||||
|
/// <param name="ancestor">The new inheritance ancestor.</param>
|
||||
|
public void OnInheritanceAncestorChanged(ValueStore? ancestor) |
||||
|
{ |
||||
|
if (ancestor != this) |
||||
|
{ |
||||
|
InheritanceAncestor = ancestor; |
||||
|
if (_inheritedValueCount > 0) |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var children = Owner.GetInheritanceChildren(); |
||||
|
|
||||
|
if (children is null) |
||||
|
return; |
||||
|
|
||||
|
var count = children.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
children[i].GetValueStore().OnInheritanceAncestorChanged(ancestor); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by <see cref="EffectiveValue{T}"/> when an property with inheritance enabled
|
||||
|
/// changes its value on this value store.
|
||||
|
/// </summary>
|
||||
|
/// <param name="property">The property whose value changed.</param>
|
||||
|
/// <param name="oldValue">The old value of the property.</param>
|
||||
|
/// <param name="value">The effective value instance.</param>
|
||||
|
public void OnInheritedEffectiveValueChanged<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
T oldValue, |
||||
|
EffectiveValue<T> value) |
||||
|
{ |
||||
|
Debug.Assert(property.Inherits); |
||||
|
|
||||
|
var children = Owner.GetInheritanceChildren(); |
||||
|
|
||||
|
if (children is null) |
||||
|
return; |
||||
|
|
||||
|
var count = children.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
children[i].GetValueStore().OnAncestorInheritedValueChanged(property, oldValue, value.Value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by <see cref="EffectiveValue{T}"/> when an property with inheritance enabled
|
||||
|
/// is removed from the effective values.
|
||||
|
/// </summary>
|
||||
|
/// <param name="property">The property whose value changed.</param>
|
||||
|
/// <param name="oldValue">The old value of the property.</param>
|
||||
|
public void OnInheritedEffectiveValueDisposed<T>(StyledPropertyBase<T> property, T oldValue) |
||||
|
{ |
||||
|
Debug.Assert(property.Inherits); |
||||
|
|
||||
|
var children = Owner.GetInheritanceChildren(); |
||||
|
|
||||
|
if (children is not null) |
||||
|
{ |
||||
|
var defaultValue = property.GetDefaultValue(Owner.GetType()); |
||||
|
var count = children.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
children[i].GetValueStore().OnAncestorInheritedValueChanged(property, oldValue, defaultValue); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called when a <see cref="LocalValueBindingObserver{T}"/> or
|
||||
|
/// <see cref="DirectBindingObserver{T}"/> completes.
|
||||
|
/// </summary>
|
||||
|
/// <param name="property">The previously bound property.</param>
|
||||
|
/// <param name="observer">The observer.</param>
|
||||
|
public void OnLocalValueBindingCompleted(AvaloniaProperty property, IDisposable observer) |
||||
|
{ |
||||
|
if (_localValueBindings is not null && |
||||
|
_localValueBindings.TryGetValue(property.Id, out var existing)) |
||||
|
{ |
||||
|
if (existing == observer) |
||||
|
{ |
||||
|
_localValueBindings?.Remove(property.Id); |
||||
|
ClearLocalValue(property); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called when an inherited property changes on the value store of the inheritance ancestor.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="T">The property type.</typeparam>
|
||||
|
/// <param name="property">The property.</param>
|
||||
|
/// <param name="oldValue">The old value of the property.</param>
|
||||
|
/// <param name="newValue">The new value of the property.</param>
|
||||
|
public void OnAncestorInheritedValueChanged<T>( |
||||
|
StyledPropertyBase<T> property, |
||||
|
T oldValue, |
||||
|
T newValue) |
||||
|
{ |
||||
|
Debug.Assert(property.Inherits); |
||||
|
|
||||
|
// If the inherited value is set locally, propagation stops here.
|
||||
|
if (_effectiveValues.ContainsKey(property)) |
||||
|
return; |
||||
|
|
||||
|
using var notifying = PropertyNotifying.Start(Owner, property); |
||||
|
|
||||
|
Owner.RaisePropertyChanged( |
||||
|
property, |
||||
|
oldValue, |
||||
|
newValue, |
||||
|
BindingPriority.Inherited, |
||||
|
true); |
||||
|
|
||||
|
var children = Owner.GetInheritanceChildren(); |
||||
|
|
||||
|
if (children is null) |
||||
|
return; |
||||
|
|
||||
|
var count = children.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
children[i].GetValueStore().OnAncestorInheritedValueChanged(property, oldValue, newValue); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Called by a <see cref="ValueFrame"/> to re-evaluate the effective value when a value
|
||||
|
/// is removed.
|
||||
|
/// </summary>
|
||||
|
/// <param name="frame">The frame on which the change occurred.</param>
|
||||
|
/// <param name="property">The property whose value was removed.</param>
|
||||
|
public void OnValueEntryRemoved(ValueFrame frame, AvaloniaProperty property) |
||||
|
{ |
||||
|
if (frame.EntryCount == 0) |
||||
|
_frames.Remove(frame); |
||||
|
|
||||
|
if (TryGetEffectiveValue(property, out var existing)) |
||||
|
{ |
||||
|
if (frame.Priority <= existing.Priority) |
||||
|
ReevaluateEffectiveValue(property, existing); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public bool RemoveFrame(ValueFrame frame) |
||||
|
{ |
||||
|
if (_frames.Remove(frame)) |
||||
|
{ |
||||
|
frame.Dispose(); |
||||
|
++_frameGeneration; |
||||
|
ReevaluateEffectiveValues(); |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public AvaloniaPropertyValue GetDiagnostic(AvaloniaProperty property) |
||||
|
{ |
||||
|
object? value; |
||||
|
BindingPriority priority; |
||||
|
|
||||
|
if (_effectiveValues.TryGetValue(property, out var v)) |
||||
|
{ |
||||
|
value = v.Value; |
||||
|
priority = v.Priority; |
||||
|
} |
||||
|
else if (property.Inherits && TryGetInheritedValue(property, out v)) |
||||
|
{ |
||||
|
value = v.Value; |
||||
|
priority = BindingPriority.Inherited; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
value = GetDefaultValue(property); |
||||
|
priority = BindingPriority.Unset; |
||||
|
} |
||||
|
|
||||
|
return new AvaloniaPropertyValue( |
||||
|
property, |
||||
|
value, |
||||
|
priority, |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
private int InsertFrame(ValueFrame frame) |
||||
|
{ |
||||
|
// Uncomment this line when #8549 is fixed.
|
||||
|
//Debug.Assert(!_frames.Contains(frame));
|
||||
|
|
||||
|
var index = BinarySearchFrame(frame.Priority); |
||||
|
_frames.Insert(index, frame); |
||||
|
++_frameGeneration; |
||||
|
frame.SetOwner(this); |
||||
|
return index; |
||||
|
} |
||||
|
|
||||
|
private ImmediateValueFrame GetOrCreateImmediateValueFrame( |
||||
|
AvaloniaProperty property, |
||||
|
BindingPriority priority, |
||||
|
out int frameIndex) |
||||
|
{ |
||||
|
Debug.Assert(priority != BindingPriority.LocalValue); |
||||
|
|
||||
|
var index = BinarySearchFrame(priority); |
||||
|
|
||||
|
if (index > 0 && _frames[index - 1] is ImmediateValueFrame f && |
||||
|
f.Priority == priority && |
||||
|
!f.Contains(property)) |
||||
|
{ |
||||
|
frameIndex = index - 1; |
||||
|
return f; |
||||
|
} |
||||
|
|
||||
|
var result = new ImmediateValueFrame(priority); |
||||
|
frameIndex = InsertFrame(result); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
private void AddEffectiveValue(AvaloniaProperty property, EffectiveValue effectiveValue) |
||||
|
{ |
||||
|
_effectiveValues.Add(property, effectiveValue); |
||||
|
|
||||
|
if (property.Inherits && _inheritedValueCount++ == 0) |
||||
|
OnInheritanceAncestorChanged(this); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adds a new effective value, raises the initial <see cref="AvaloniaObject.PropertyChanged"/>
|
||||
|
/// event and notifies inheritance children if necessary .
|
||||
|
/// </summary>
|
||||
|
/// <param name="property">The property.</param>
|
||||
|
/// <param name="entry">The value entry.</param>
|
||||
|
/// <param name="priority">The value priority.</param>
|
||||
|
private void AddEffectiveValueAndRaise(AvaloniaProperty property, IValueEntry entry, BindingPriority priority) |
||||
|
{ |
||||
|
Debug.Assert(priority < BindingPriority.Inherited); |
||||
|
var effectiveValue = property.CreateEffectiveValue(Owner); |
||||
|
AddEffectiveValue(property, effectiveValue); |
||||
|
effectiveValue.SetAndRaise(this, entry, priority); |
||||
|
} |
||||
|
|
||||
|
private void RemoveEffectiveValue(AvaloniaProperty property, int index) |
||||
|
{ |
||||
|
_effectiveValues.RemoveAt(index); |
||||
|
if (property.Inherits && --_inheritedValueCount == 0) |
||||
|
OnInheritanceAncestorChanged(InheritanceAncestor); |
||||
|
} |
||||
|
|
||||
|
private bool RemoveEffectiveValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.Remove(property)) |
||||
|
{ |
||||
|
if (property.Inherits && --_inheritedValueCount == 0) |
||||
|
OnInheritanceAncestorChanged(InheritanceAncestor); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
private void InheritedValueChanged( |
||||
|
AvaloniaProperty property, |
||||
|
EffectiveValue? oldValue, |
||||
|
EffectiveValue? newValue) |
||||
|
{ |
||||
|
Debug.Assert(oldValue != newValue); |
||||
|
Debug.Assert(oldValue is not null || newValue is not null); |
||||
|
|
||||
|
// If the value is set locally, propagaton ends here.
|
||||
|
if (_effectiveValues.ContainsKey(property) == true) |
||||
|
return; |
||||
|
|
||||
|
using var notifying = PropertyNotifying.Start(Owner, property); |
||||
|
|
||||
|
// Raise PropertyChanged on this object if necessary.
|
||||
|
(oldValue ?? newValue!).RaiseInheritedValueChanged(Owner, property, oldValue, newValue); |
||||
|
|
||||
|
var children = Owner.GetInheritanceChildren(); |
||||
|
|
||||
|
if (children is null) |
||||
|
return; |
||||
|
|
||||
|
var count = children.Count; |
||||
|
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
{ |
||||
|
children[i].GetValueStore().InheritedValueChanged(property, oldValue, newValue); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReevaluateEffectiveValue( |
||||
|
AvaloniaProperty property, |
||||
|
EffectiveValue? current, |
||||
|
bool ignoreLocalValue = false) |
||||
|
{ |
||||
|
++_isEvaluating; |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
restart: |
||||
|
// Don't reevaluate if a styling pass is in effect, reevaluation will be done when
|
||||
|
// it has finished.
|
||||
|
if (_styling > 0) |
||||
|
return; |
||||
|
|
||||
|
var generation = _frameGeneration; |
||||
|
|
||||
|
// Notify the existing effective value that reevaluation is starting.
|
||||
|
current?.BeginReevaluation(ignoreLocalValue); |
||||
|
|
||||
|
// Iterate the frames to get the effective value.
|
||||
|
for (var i = _frames.Count - 1; i >= 0; --i) |
||||
|
{ |
||||
|
var frame = _frames[i]; |
||||
|
var priority = frame.Priority; |
||||
|
var foundEntry = frame.TryGetEntryIfActive(property, out var entry, out var activeChanged); |
||||
|
|
||||
|
// If the active state of the frame has changed since the last read, and
|
||||
|
// the frame holds multiple values then we need to re-evaluate the
|
||||
|
// effective values of all properties.
|
||||
|
if (activeChanged && frame.EntryCount > 1) |
||||
|
{ |
||||
|
ReevaluateEffectiveValues(); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// We're interested in the value if:
|
||||
|
// - There is no current effective value, or
|
||||
|
// - The value's priority is higher than the current effective value's priority, or
|
||||
|
// - The value is a non-animation value and its priority is higher than the current
|
||||
|
// effective value's base priority
|
||||
|
var isRelevantPriority = current is null || |
||||
|
priority < current.Priority || |
||||
|
(priority > BindingPriority.Animation && priority < current.BasePriority); |
||||
|
|
||||
|
if (foundEntry && isRelevantPriority && entry!.HasValue) |
||||
|
{ |
||||
|
if (current is not null) |
||||
|
{ |
||||
|
current.SetAndRaise(this, entry, priority); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
current = property.CreateEffectiveValue(Owner); |
||||
|
AddEffectiveValue(property, current); |
||||
|
current.SetAndRaise(this, entry, priority); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (generation != _frameGeneration) |
||||
|
goto restart; |
||||
|
|
||||
|
if (current?.Priority < BindingPriority.Unset && |
||||
|
current?.BasePriority < BindingPriority.Unset) |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
current?.EndReevaluation(); |
||||
|
|
||||
|
if (current?.Priority == BindingPriority.Unset) |
||||
|
{ |
||||
|
if (current.BasePriority == BindingPriority.Unset) |
||||
|
{ |
||||
|
RemoveEffectiveValue(property); |
||||
|
current.DisposeAndRaiseUnset(this, property); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
current.RemoveAnimationAndRaise(this, property); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
--_isEvaluating; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReevaluateEffectiveValues() |
||||
|
{ |
||||
|
++_isEvaluating; |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
restart: |
||||
|
// Don't reevaluate if a styling pass is in effect, reevaluation will be done when
|
||||
|
// it has finished.
|
||||
|
if (_styling > 0) |
||||
|
return; |
||||
|
|
||||
|
var generation = _frameGeneration; |
||||
|
var count = _effectiveValues.Count; |
||||
|
|
||||
|
// Notify the existing effective values that reevaluation is starting.
|
||||
|
for (var i = 0; i < count; ++i) |
||||
|
_effectiveValues[i].BeginReevaluation(); |
||||
|
|
||||
|
// Iterate the frames, setting and creating effective values.
|
||||
|
for (var i = _frames.Count - 1; i >= 0; --i) |
||||
|
{ |
||||
|
var frame = _frames[i]; |
||||
|
|
||||
|
if (!frame.IsActive) |
||||
|
continue; |
||||
|
|
||||
|
var priority = frame.Priority; |
||||
|
|
||||
|
count = frame.EntryCount; |
||||
|
|
||||
|
for (var j = 0; j < count; ++j) |
||||
|
{ |
||||
|
var entry = frame.GetEntry(j); |
||||
|
var property = entry.Property; |
||||
|
|
||||
|
// Skip if we already have a value/base value for this property.
|
||||
|
if (_effectiveValues.TryGetValue(property, out var effectiveValue) && |
||||
|
effectiveValue.BasePriority < BindingPriority.Unset) |
||||
|
continue; |
||||
|
|
||||
|
if (!entry.HasValue) |
||||
|
continue; |
||||
|
|
||||
|
if (effectiveValue is not null) |
||||
|
{ |
||||
|
effectiveValue.SetAndRaise(this, entry, priority); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var v = property.CreateEffectiveValue(Owner); |
||||
|
AddEffectiveValue(property, v); |
||||
|
v.SetAndRaise(this, entry, priority); |
||||
|
} |
||||
|
|
||||
|
if (generation != _frameGeneration) |
||||
|
goto restart; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Remove all effective values that are still unset.
|
||||
|
for (var i = _effectiveValues.Count - 1; i >= 0; --i) |
||||
|
{ |
||||
|
_effectiveValues.GetKeyValue(i, out var key, out var e); |
||||
|
e.EndReevaluation(); |
||||
|
|
||||
|
if (e.Priority == BindingPriority.Unset) |
||||
|
{ |
||||
|
RemoveEffectiveValue(key, i); |
||||
|
e.DisposeAndRaiseUnset(this, key); |
||||
|
|
||||
|
if (i > _effectiveValues.Count) |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
--_isEvaluating; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private bool TryGetEffectiveValue( |
||||
|
AvaloniaProperty property, |
||||
|
[NotNullWhen(true)] out EffectiveValue? value) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out value)) |
||||
|
return true; |
||||
|
value = null; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
private EffectiveValue? GetEffectiveValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_effectiveValues.TryGetValue(property, out var value)) |
||||
|
return value; |
||||
|
return null; |
||||
|
} |
||||
|
|
||||
|
private object? GetDefaultValue(AvaloniaProperty property) |
||||
|
{ |
||||
|
return ((IStyledPropertyAccessor)property).GetDefaultValue(Owner.GetType()); |
||||
|
} |
||||
|
|
||||
|
private void DisposeExistingLocalValueBinding(AvaloniaProperty property) |
||||
|
{ |
||||
|
if (_localValueBindings is not null && |
||||
|
_localValueBindings.TryGetValue(property.Id, out var existing)) |
||||
|
{ |
||||
|
existing.Dispose(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private int BinarySearchFrame(BindingPriority priority) |
||||
|
{ |
||||
|
var lo = 0; |
||||
|
var hi = _frames.Count - 1; |
||||
|
|
||||
|
// Binary search insertion point.
|
||||
|
while (lo <= hi) |
||||
|
{ |
||||
|
var i = lo + ((hi - lo) >> 1); |
||||
|
var order = priority - _frames[i].Priority; |
||||
|
|
||||
|
if (order <= 0) |
||||
|
{ |
||||
|
lo = i + 1; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
hi = i - 1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return lo; |
||||
|
} |
||||
|
|
||||
|
private readonly struct OldNewValue |
||||
|
{ |
||||
|
public OldNewValue(EffectiveValue? oldValue) |
||||
|
{ |
||||
|
OldValue = oldValue; |
||||
|
NewValue = null; |
||||
|
} |
||||
|
|
||||
|
public OldNewValue(EffectiveValue? oldValue, EffectiveValue? newValue) |
||||
|
{ |
||||
|
OldValue = oldValue; |
||||
|
NewValue = newValue; |
||||
|
} |
||||
|
|
||||
|
public readonly EffectiveValue? OldValue; |
||||
|
public readonly EffectiveValue? NewValue; |
||||
|
|
||||
|
public OldNewValue WithNewValue(EffectiveValue newValue) => new(OldValue, newValue); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,59 +0,0 @@ |
|||||
using System; |
|
||||
using System.Reactive.Subjects; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.Reactive |
|
||||
{ |
|
||||
internal class BindingValueAdapter<T> : SingleSubscriberObservableBase<BindingValue<T>>, |
|
||||
IObserver<T> |
|
||||
{ |
|
||||
private readonly IObservable<T> _source; |
|
||||
private IDisposable? _subscription; |
|
||||
|
|
||||
public BindingValueAdapter(IObservable<T> source) => _source = source; |
|
||||
public void OnCompleted() => PublishCompleted(); |
|
||||
public void OnError(Exception error) => PublishError(error); |
|
||||
public void OnNext(T value) => PublishNext(BindingValue<T>.FromUntyped(value)); |
|
||||
protected override void Subscribed() => _subscription = _source.Subscribe(this); |
|
||||
protected override void Unsubscribed() => _subscription?.Dispose(); |
|
||||
} |
|
||||
|
|
||||
internal class BindingValueSubjectAdapter<T> : SingleSubscriberObservableBase<BindingValue<T>>, |
|
||||
ISubject<BindingValue<T>> |
|
||||
{ |
|
||||
private readonly ISubject<T> _source; |
|
||||
private readonly Inner _inner; |
|
||||
private IDisposable? _subscription; |
|
||||
|
|
||||
public BindingValueSubjectAdapter(ISubject<T> source) |
|
||||
{ |
|
||||
_source = source; |
|
||||
_inner = new Inner(this); |
|
||||
} |
|
||||
|
|
||||
public void OnCompleted() => _source.OnCompleted(); |
|
||||
public void OnError(Exception error) => _source.OnError(error); |
|
||||
|
|
||||
public void OnNext(BindingValue<T> value) |
|
||||
{ |
|
||||
if (value.HasValue) |
|
||||
{ |
|
||||
_source.OnNext(value.Value); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
protected override void Subscribed() => _subscription = _source.Subscribe(_inner); |
|
||||
protected override void Unsubscribed() => _subscription?.Dispose(); |
|
||||
|
|
||||
private class Inner : IObserver<T> |
|
||||
{ |
|
||||
private readonly BindingValueSubjectAdapter<T> _owner; |
|
||||
|
|
||||
public Inner(BindingValueSubjectAdapter<T> owner) => _owner = owner; |
|
||||
|
|
||||
public void OnCompleted() => _owner.PublishCompleted(); |
|
||||
public void OnError(Exception error) => _owner.PublishError(error); |
|
||||
public void OnNext(T value) => _owner.PublishNext(BindingValue<T>.FromUntyped(value)); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,33 +0,0 @@ |
|||||
using System; |
|
||||
using System.Reactive.Subjects; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.Reactive |
|
||||
{ |
|
||||
public static class BindingValueExtensions |
|
||||
{ |
|
||||
public static IObservable<BindingValue<T>> ToBindingValue<T>(this IObservable<T> source) |
|
||||
{ |
|
||||
source = source ?? throw new ArgumentNullException(nameof(source)); |
|
||||
return new BindingValueAdapter<T>(source); |
|
||||
} |
|
||||
|
|
||||
public static ISubject<BindingValue<T>> ToBindingValue<T>(this ISubject<T> source) |
|
||||
{ |
|
||||
source = source ?? throw new ArgumentNullException(nameof(source)); |
|
||||
return new BindingValueSubjectAdapter<T>(source); |
|
||||
} |
|
||||
|
|
||||
public static IObservable<object?> ToUntyped<T>(this IObservable<BindingValue<T>> source) |
|
||||
{ |
|
||||
source = source ?? throw new ArgumentNullException(nameof(source)); |
|
||||
return new UntypedBindingAdapter<T>(source); |
|
||||
} |
|
||||
|
|
||||
public static ISubject<object?> ToUntyped<T>(this ISubject<BindingValue<T>> source) |
|
||||
{ |
|
||||
source = source ?? throw new ArgumentNullException(nameof(source)); |
|
||||
return new UntypedBindingSubjectAdapter<T>(source); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,62 +0,0 @@ |
|||||
using System; |
|
||||
using Avalonia.Data; |
|
||||
using Avalonia.Logging; |
|
||||
|
|
||||
namespace Avalonia.Reactive |
|
||||
{ |
|
||||
internal class TypedBindingAdapter<T> : SingleSubscriberObservableBase<BindingValue<T>>, |
|
||||
IObserver<BindingValue<object?>> |
|
||||
{ |
|
||||
private readonly IAvaloniaObject _target; |
|
||||
private readonly AvaloniaProperty<T> _property; |
|
||||
private readonly IObservable<BindingValue<object?>> _source; |
|
||||
private IDisposable? _subscription; |
|
||||
|
|
||||
public TypedBindingAdapter( |
|
||||
IAvaloniaObject target, |
|
||||
AvaloniaProperty<T> property, |
|
||||
IObservable<BindingValue<object?>> source) |
|
||||
{ |
|
||||
_target = target; |
|
||||
_property = property; |
|
||||
_source = source; |
|
||||
} |
|
||||
|
|
||||
public void OnNext(BindingValue<object?> value) |
|
||||
{ |
|
||||
try |
|
||||
{ |
|
||||
PublishNext(value.Convert<T>()); |
|
||||
} |
|
||||
catch (InvalidCastException e) |
|
||||
{ |
|
||||
var unwrappedValue = value.HasValue ? value.Value : null; |
|
||||
|
|
||||
Logger.TryGet(LogEventLevel.Error, LogArea.Binding)?.Log( |
|
||||
_target, |
|
||||
"Binding produced invalid value for {$Property} ({$PropertyType}): {$Value} ({$ValueType})", |
|
||||
_property.Name, |
|
||||
_property.PropertyType, |
|
||||
unwrappedValue, |
|
||||
unwrappedValue?.GetType()); |
|
||||
PublishNext(BindingValue<T>.BindingError(e)); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public void OnCompleted() => PublishCompleted(); |
|
||||
public void OnError(Exception error) => PublishError(error); |
|
||||
|
|
||||
public static IObservable<BindingValue<T>> Create( |
|
||||
IAvaloniaObject target, |
|
||||
AvaloniaProperty<T> property, |
|
||||
IObservable<BindingValue<object?>> source) |
|
||||
{ |
|
||||
return source is IObservable<BindingValue<T>> result ? |
|
||||
result : |
|
||||
new TypedBindingAdapter<T>(target, property, source); |
|
||||
} |
|
||||
|
|
||||
protected override void Subscribed() => _subscription = _source.Subscribe(this); |
|
||||
protected override void Unsubscribed() => _subscription?.Dispose(); |
|
||||
} |
|
||||
} |
|
||||
@ -1,55 +0,0 @@ |
|||||
using System; |
|
||||
using System.Reactive.Subjects; |
|
||||
using Avalonia.Data; |
|
||||
|
|
||||
namespace Avalonia.Reactive |
|
||||
{ |
|
||||
internal class UntypedBindingAdapter<T> : SingleSubscriberObservableBase<object?>, |
|
||||
IObserver<BindingValue<T>> |
|
||||
{ |
|
||||
private readonly IObservable<BindingValue<T>> _source; |
|
||||
private IDisposable? _subscription; |
|
||||
|
|
||||
public UntypedBindingAdapter(IObservable<BindingValue<T>> source) => _source = source; |
|
||||
public void OnCompleted() => PublishCompleted(); |
|
||||
public void OnError(Exception error) => PublishError(error); |
|
||||
public void OnNext(BindingValue<T> value) => value.ToUntyped(); |
|
||||
protected override void Subscribed() => _subscription = _source.Subscribe(this); |
|
||||
protected override void Unsubscribed() => _subscription?.Dispose(); |
|
||||
} |
|
||||
|
|
||||
internal class UntypedBindingSubjectAdapter<T> : SingleSubscriberObservableBase<object?>, |
|
||||
ISubject<object?> |
|
||||
{ |
|
||||
private readonly ISubject<BindingValue<T>> _source; |
|
||||
private readonly Inner _inner; |
|
||||
private IDisposable? _subscription; |
|
||||
|
|
||||
public UntypedBindingSubjectAdapter(ISubject<BindingValue<T>> source) |
|
||||
{ |
|
||||
_source = source; |
|
||||
_inner = new Inner(this); |
|
||||
} |
|
||||
|
|
||||
public void OnCompleted() => _source.OnCompleted(); |
|
||||
public void OnError(Exception error) => _source.OnError(error); |
|
||||
public void OnNext(object? value) |
|
||||
{ |
|
||||
_source.OnNext(BindingValue<T>.FromUntyped(value)); |
|
||||
} |
|
||||
|
|
||||
protected override void Subscribed() => _subscription = _source.Subscribe(_inner); |
|
||||
protected override void Unsubscribed() => _subscription?.Dispose(); |
|
||||
|
|
||||
private class Inner : IObserver<BindingValue<T>> |
|
||||
{ |
|
||||
private readonly UntypedBindingSubjectAdapter<T> _owner; |
|
||||
|
|
||||
public Inner(UntypedBindingSubjectAdapter<T> owner) => _owner = owner; |
|
||||
|
|
||||
public void OnCompleted() => _owner.PublishCompleted(); |
|
||||
public void OnError(Exception error) => _owner.PublishError(error); |
|
||||
public void OnNext(BindingValue<T> value) => _owner.PublishNext(value.ToUntyped()); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,6 @@ |
|||||
|
namespace Avalonia.Styling |
||||
|
{ |
||||
|
internal class DirectPropertySetterBindingInstance : ISetterInstance |
||||
|
{ |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,12 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Linq; |
||||
|
using System.Text; |
||||
|
using System.Threading.Tasks; |
||||
|
|
||||
|
namespace Avalonia.Styling |
||||
|
{ |
||||
|
internal class DirectPropertySetterInstance : ISetterInstance |
||||
|
{ |
||||
|
} |
||||
|
} |
||||
@ -1,40 +1,12 @@ |
|||||
using System; |
using Avalonia.Metadata; |
||||
using Avalonia.Metadata; |
|
||||
|
|
||||
namespace Avalonia.Styling |
namespace Avalonia.Styling |
||||
{ |
{ |
||||
/// <summary>
|
/// <summary>
|
||||
/// Represents a setter that has been instanced on a control.
|
/// Represents an <see cref="ISetter"/> that has been instanced on a control.
|
||||
/// </summary>
|
/// </summary>
|
||||
[Unstable] |
[Unstable] |
||||
public interface ISetterInstance : IDisposable |
public interface ISetterInstance |
||||
{ |
{ |
||||
/// <summary>
|
|
||||
/// Starts the setter instance.
|
|
||||
/// </summary>
|
|
||||
/// <param name="hasActivator">Whether the parent style has an activator.</param>
|
|
||||
/// <remarks>
|
|
||||
/// If <paramref name="hasActivator"/> is false then the setter should be immediately
|
|
||||
/// applied and <see cref="Activate"/> and <see cref="Deactivate"/> should not be called.
|
|
||||
/// If true, then bindings etc should be initiated but not produce a value until
|
|
||||
/// <see cref="Activate"/> called.
|
|
||||
/// </remarks>
|
|
||||
public void Start(bool hasActivator); |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Activates the setter.
|
|
||||
/// </summary>
|
|
||||
/// <remarks>
|
|
||||
/// Should only be called if hasActivator was true when <see cref="Start(bool)"/> was called.
|
|
||||
/// </remarks>
|
|
||||
public void Activate(); |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Deactivates the setter.
|
|
||||
/// </summary>
|
|
||||
/// <remarks>
|
|
||||
/// Should only be called if hasActivator was true when <see cref="Start(bool)"/> was called.
|
|
||||
/// </remarks>
|
|
||||
public void Deactivate(); |
|
||||
} |
} |
||||
} |
} |
||||
|
|||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue