diff --git a/native/Avalonia.Native/src/OSX/AvnString.h b/native/Avalonia.Native/src/OSX/AvnString.h index 5d299374e5..3ce83d370a 100644 --- a/native/Avalonia.Native/src/OSX/AvnString.h +++ b/native/Avalonia.Native/src/OSX/AvnString.h @@ -11,6 +11,7 @@ extern IAvnString* CreateAvnString(NSString* string); extern IAvnStringArray* CreateAvnStringArray(NSArray* array); +extern IAvnStringArray* CreateAvnStringArray(NSArray* array); extern IAvnStringArray* CreateAvnStringArray(NSString* string); extern IAvnString* CreateByteArray(void* data, int len); #endif /* AvnString_h */ diff --git a/native/Avalonia.Native/src/OSX/AvnString.mm b/native/Avalonia.Native/src/OSX/AvnString.mm index 00b748ef63..001cf151d8 100644 --- a/native/Avalonia.Native/src/OSX/AvnString.mm +++ b/native/Avalonia.Native/src/OSX/AvnString.mm @@ -85,6 +85,16 @@ public: } } + AvnStringArrayImpl(NSArray* array) + { + for(int c = 0; c < [array count]; c++) + { + ComPtr s; + *s.getPPV() = new AvnStringImpl([array objectAtIndex:c].absoluteString); + _list.push_back(s); + } + } + AvnStringArrayImpl(NSString* string) { ComPtr s; @@ -117,6 +127,11 @@ IAvnStringArray* CreateAvnStringArray(NSArray * array) return new AvnStringArrayImpl(array); } +IAvnStringArray* CreateAvnStringArray(NSArray * array) +{ + return new AvnStringArrayImpl(array); +} + IAvnStringArray* CreateAvnStringArray(NSString* string) { return new AvnStringArrayImpl(string); diff --git a/native/Avalonia.Native/src/OSX/app.mm b/native/Avalonia.Native/src/OSX/app.mm index 814b91cb62..460c24ea3a 100644 --- a/native/Avalonia.Native/src/OSX/app.mm +++ b/native/Avalonia.Native/src/OSX/app.mm @@ -1,10 +1,20 @@ #include "common.h" +#include "AvnString.h" @interface AvnAppDelegate : NSObject +-(AvnAppDelegate* _Nonnull) initWithEvents: (IAvnApplicationEvents* _Nonnull) events; @end NSApplicationActivationPolicy AvnDesiredActivationPolicy = NSApplicationActivationPolicyRegular; @implementation AvnAppDelegate +ComPtr _events; + +- (AvnAppDelegate *)initWithEvents:(IAvnApplicationEvents *)events +{ + _events = events; + return self; +} + - (void)applicationWillFinishLaunching:(NSNotification *)notification { if([[NSApplication sharedApplication] activationPolicy] != AvnDesiredActivationPolicy) @@ -27,11 +37,23 @@ NSApplicationActivationPolicy AvnDesiredActivationPolicy = NSApplicationActivati [[NSRunningApplication currentApplication] activateWithOptions:NSApplicationActivateIgnoringOtherApps]; } +- (void)application:(NSApplication *)sender openFiles:(NSArray *)filenames +{ + auto array = CreateAvnStringArray(filenames); + + _events->FilesOpened(array); +} + +- (void)application:(NSApplication *)application openURLs:(NSArray *)urls +{ + auto array = CreateAvnStringArray(urls); + + _events->FilesOpened(array); +} @end @interface AvnApplication : NSApplication - @end @implementation AvnApplication @@ -63,9 +85,9 @@ NSApplicationActivationPolicy AvnDesiredActivationPolicy = NSApplicationActivati @end -extern void InitializeAvnApp() +extern void InitializeAvnApp(IAvnApplicationEvents* events) { NSApplication* app = [AvnApplication sharedApplication]; - id delegate = [AvnAppDelegate new]; + id delegate = [[AvnAppDelegate alloc] initWithEvents:events]; [app setDelegate:delegate]; } diff --git a/native/Avalonia.Native/src/OSX/clipboard.mm b/native/Avalonia.Native/src/OSX/clipboard.mm index 303f727317..f148374759 100644 --- a/native/Avalonia.Native/src/OSX/clipboard.mm +++ b/native/Avalonia.Native/src/OSX/clipboard.mm @@ -56,7 +56,7 @@ public: return S_OK; } - NSArray* arr = (NSArray*)data; + NSArray* arr = (NSArray*)data; for(int c = 0; c < [arr count]; c++) if(![[arr objectAtIndex:c] isKindOfClass:[NSString class]]) diff --git a/native/Avalonia.Native/src/OSX/common.h b/native/Avalonia.Native/src/OSX/common.h index 05b2d762ae..0f7215f37c 100644 --- a/native/Avalonia.Native/src/OSX/common.h +++ b/native/Avalonia.Native/src/OSX/common.h @@ -31,7 +31,7 @@ extern NSMenuItem* GetAppMenuItem (); extern void SetAutoGenerateDefaultAppMenuItems (bool enabled); extern bool GetAutoGenerateDefaultAppMenuItems (); -extern void InitializeAvnApp(); +extern void InitializeAvnApp(IAvnApplicationEvents* events); extern NSApplicationActivationPolicy AvnDesiredActivationPolicy; extern NSPoint ToNSPoint (AvnPoint p); extern AvnPoint ToAvnPoint (NSPoint p); diff --git a/native/Avalonia.Native/src/OSX/main.mm b/native/Avalonia.Native/src/OSX/main.mm index 17746e1d1d..11742e3b5c 100644 --- a/native/Avalonia.Native/src/OSX/main.mm +++ b/native/Avalonia.Native/src/OSX/main.mm @@ -163,13 +163,13 @@ class AvaloniaNative : public ComSingleObject _propertyChanged; private List _inheritanceChildren; private ValueStore _values; - private ValueStore Values => _values ?? (_values = new ValueStore(this)); + private bool _batchUpdate; /// /// Initializes a new instance of the class. @@ -117,6 +117,22 @@ namespace Avalonia set { this.Bind(binding.Property, value); } } + private ValueStore Values + { + get + { + if (_values is null) + { + _values = new ValueStore(this); + + if (_batchUpdate) + _values.BeginBatchUpdate(); + } + + return _values; + } + } + public bool CheckAccess() => Dispatcher.UIThread.CheckAccess(); public void VerifyAccess() => Dispatcher.UIThread.VerifyAccess(); @@ -434,6 +450,28 @@ namespace Avalonia _values?.CoerceValue(property); } + public void BeginBatchUpdate() + { + if (_batchUpdate) + { + throw new InvalidOperationException("Batch update already in progress."); + } + + _batchUpdate = true; + _values?.BeginBatchUpdate(); + } + + public void EndBatchUpdate() + { + if (!_batchUpdate) + { + throw new InvalidOperationException("No batch update in progress."); + } + + _batchUpdate = false; + _values?.EndBatchUpdate(); + } + /// void IAvaloniaObject.AddInheritanceChild(IAvaloniaObject child) { diff --git a/src/Avalonia.Base/PropertyStore/BindingEntry.cs b/src/Avalonia.Base/PropertyStore/BindingEntry.cs index 0d563947e7..38c1728cd9 100644 --- a/src/Avalonia.Base/PropertyStore/BindingEntry.cs +++ b/src/Avalonia.Base/PropertyStore/BindingEntry.cs @@ -9,8 +9,9 @@ namespace Avalonia.PropertyStore /// /// Represents an untyped interface to . /// - internal interface IBindingEntry : IPriorityValueEntry, IDisposable + internal interface IBindingEntry : IBatchUpdate, IPriorityValueEntry, IDisposable { + void Start(bool ignoreBatchUpdate); } /// @@ -22,6 +23,8 @@ namespace Avalonia.PropertyStore private readonly IAvaloniaObject _owner; private IValueSink _sink; private IDisposable? _subscription; + private bool _isSubscribed; + private bool _batchUpdate; private Optional _value; public BindingEntry( @@ -39,10 +42,20 @@ namespace Avalonia.PropertyStore } public StyledPropertyBase Property { get; } - public BindingPriority Priority { get; } + public BindingPriority Priority { get; private set; } public IObservable> Source { get; } Optional IValue.GetValue() => _value.ToObject(); + public void BeginBatchUpdate() => _batchUpdate = true; + + public void EndBatchUpdate() + { + _batchUpdate = false; + + if (_sink is ValueStore) + Start(); + } + public Optional GetValue(BindingPriority maxPriority) { return Priority >= maxPriority ? _value : Optional.Empty; @@ -52,10 +65,17 @@ namespace Avalonia.PropertyStore { _subscription?.Dispose(); _subscription = null; - _sink.Completed(Property, this, _value); + _isSubscribed = false; + OnCompleted(); } - public void OnCompleted() => _sink.Completed(Property, this, _value); + public void OnCompleted() + { + var oldValue = _value; + _value = default; + Priority = BindingPriority.Unset; + _sink.Completed(Property, this, oldValue); + } public void OnError(Exception error) { @@ -79,13 +99,36 @@ namespace Avalonia.PropertyStore } } - public void Start() + public void Start() => Start(false); + + public void Start(bool ignoreBatchUpdate) { - _subscription = Source.Subscribe(this); + // 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. + if (!_isSubscribed && (!_batchUpdate || ignoreBatchUpdate)) + { + _isSubscribed = true; + _subscription = Source.Subscribe(this); + } } public void Reparent(IValueSink sink) => _sink = sink; - + + public void RaiseValueChanged( + IValueSink sink, + IAvaloniaObject owner, + AvaloniaProperty property, + Optional oldValue, + Optional newValue) + { + sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( + owner, + (AvaloniaProperty)property, + oldValue.GetValueOrDefault(), + newValue.GetValueOrDefault(), + Priority)); + } + private void UpdateValue(BindingValue value) { if (value.HasValue && Property.ValidateValue?.Invoke(value.Value) == false) diff --git a/src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs b/src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs index 46f6f9a137..600d725187 100644 --- a/src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs +++ b/src/Avalonia.Base/PropertyStore/ConstantValueEntry.cs @@ -1,4 +1,5 @@ using System; +using System.Diagnostics.CodeAnalysis; using Avalonia.Data; #nullable enable @@ -17,7 +18,7 @@ namespace Avalonia.PropertyStore public ConstantValueEntry( StyledPropertyBase property, - T value, + [AllowNull] T value, BindingPriority priority, IValueSink sink) { @@ -28,7 +29,7 @@ namespace Avalonia.PropertyStore } public StyledPropertyBase Property { get; } - public BindingPriority Priority { get; } + public BindingPriority Priority { get; private set; } Optional IValue.GetValue() => _value.ToObject(); public Optional GetValue(BindingPriority maxPriority = BindingPriority.Animation) @@ -36,7 +37,30 @@ namespace Avalonia.PropertyStore return Priority >= maxPriority ? _value : Optional.Empty; } - public void Dispose() => _sink.Completed(Property, this, _value); + public void Dispose() + { + var oldValue = _value; + _value = default; + Priority = BindingPriority.Unset; + _sink.Completed(Property, this, oldValue); + } + public void Reparent(IValueSink sink) => _sink = sink; + public void Start() { } + + public void RaiseValueChanged( + IValueSink sink, + IAvaloniaObject owner, + AvaloniaProperty property, + Optional oldValue, + Optional newValue) + { + sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( + owner, + (AvaloniaProperty)property, + oldValue.GetValueOrDefault(), + newValue.GetValueOrDefault(), + Priority)); + } } } diff --git a/src/Avalonia.Base/PropertyStore/IBatchUpdate.cs b/src/Avalonia.Base/PropertyStore/IBatchUpdate.cs new file mode 100644 index 0000000000..af4faf989c --- /dev/null +++ b/src/Avalonia.Base/PropertyStore/IBatchUpdate.cs @@ -0,0 +1,8 @@ +namespace Avalonia.PropertyStore +{ + internal interface IBatchUpdate + { + void BeginBatchUpdate(); + void EndBatchUpdate(); + } +} diff --git a/src/Avalonia.Base/PropertyStore/IValue.cs b/src/Avalonia.Base/PropertyStore/IValue.cs index 249cfc360c..7f5245bb45 100644 --- a/src/Avalonia.Base/PropertyStore/IValue.cs +++ b/src/Avalonia.Base/PropertyStore/IValue.cs @@ -9,8 +9,15 @@ namespace Avalonia.PropertyStore /// internal interface IValue { - Optional GetValue(); BindingPriority Priority { get; } + Optional GetValue(); + void Start(); + void RaiseValueChanged( + IValueSink sink, + IAvaloniaObject owner, + AvaloniaProperty property, + Optional oldValue, + Optional newValue); } /// diff --git a/src/Avalonia.Base/PropertyStore/LocalValueEntry.cs b/src/Avalonia.Base/PropertyStore/LocalValueEntry.cs index 859e9ba81c..f49b74f4a8 100644 --- a/src/Avalonia.Base/PropertyStore/LocalValueEntry.cs +++ b/src/Avalonia.Base/PropertyStore/LocalValueEntry.cs @@ -24,5 +24,21 @@ namespace Avalonia.PropertyStore } public void SetValue(T value) => _value = value; + public void Start() { } + + public void RaiseValueChanged( + IValueSink sink, + IAvaloniaObject owner, + AvaloniaProperty property, + Optional oldValue, + Optional newValue) + { + sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( + owner, + (AvaloniaProperty)property, + oldValue.GetValueOrDefault(), + newValue.GetValueOrDefault(), + BindingPriority.LocalValue)); + } } } diff --git a/src/Avalonia.Base/PropertyStore/PriorityValue.cs b/src/Avalonia.Base/PropertyStore/PriorityValue.cs index 5e223cad60..80496fc045 100644 --- a/src/Avalonia.Base/PropertyStore/PriorityValue.cs +++ b/src/Avalonia.Base/PropertyStore/PriorityValue.cs @@ -18,7 +18,7 @@ namespace Avalonia.PropertyStore /// entries (sorted first by priority and then in the order /// they were added) plus a local value. /// - internal class PriorityValue : IValue, IValueSink + internal class PriorityValue : IValue, IValueSink, IBatchUpdate { private readonly IAvaloniaObject _owner; private readonly IValueSink _sink; @@ -26,6 +26,8 @@ namespace Avalonia.PropertyStore private readonly Func? _coerceValue; private Optional _localValue; private Optional _value; + private bool _isCalculatingValue; + private bool _batchUpdate; public PriorityValue( IAvaloniaObject owner, @@ -53,6 +55,18 @@ namespace Avalonia.PropertyStore 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) @@ -78,6 +92,28 @@ namespace Avalonia.PropertyStore public IReadOnlyList> Entries => _entries; Optional 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() { UpdateEffectiveValue(new AvaloniaPropertyChangedEventArgs( @@ -134,10 +170,37 @@ namespace Avalonia.PropertyStore var binding = new BindingEntry(_owner, Property, source, priority, 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 CoerceValue() => UpdateEffectiveValue(null); + public void UpdateEffectiveValue() => UpdateEffectiveValue(null); + public void Start() => UpdateEffectiveValue(null); + + public void RaiseValueChanged( + IValueSink sink, + IAvaloniaObject owner, + AvaloniaProperty property, + Optional oldValue, + Optional newValue) + { + sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( + owner, + (AvaloniaProperty)property, + oldValue.GetValueOrDefault(), + newValue.GetValueOrDefault(), + Priority)); + } void IValueSink.ValueChanged(AvaloniaPropertyChangedEventArgs change) { @@ -146,7 +209,7 @@ namespace Avalonia.PropertyStore _localValue = default; } - if (change is AvaloniaPropertyChangedEventArgs c) + if (!_isCalculatingValue && change is AvaloniaPropertyChangedEventArgs c) { UpdateEffectiveValue(c); } @@ -188,41 +251,47 @@ namespace Avalonia.PropertyStore public (Optional, BindingPriority) CalculateValue(BindingPriority maxPriority) { - var reachedLocalValues = false; + _isCalculatingValue = true; - for (var i = _entries.Count - 1; i >= 0; --i) + try { - var entry = _entries[i]; - - if (entry.Priority < maxPriority) + for (var i = _entries.Count - 1; i >= 0; --i) { - continue; + 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 (!reachedLocalValues && - entry.Priority >= BindingPriority.LocalValue && - maxPriority <= BindingPriority.LocalValue && - _localValue.HasValue) + if (maxPriority <= BindingPriority.LocalValue && _localValue.HasValue) { return (_localValue, BindingPriority.LocalValue); } - var entryValue = entry.GetValue(); - - if (entryValue.HasValue) - { - return (entryValue, entry.Priority); - } + return (default, BindingPriority.Unset); } - - if (!reachedLocalValues && - maxPriority <= BindingPriority.LocalValue && - _localValue.HasValue) + finally { - return (_localValue, BindingPriority.LocalValue); + _isCalculatingValue = false; } - - return (default, BindingPriority.Unset); } private void UpdateEffectiveValue(AvaloniaPropertyChangedEventArgs? change) diff --git a/src/Avalonia.Base/Utilities/AvaloniaPropertyValueStore.cs b/src/Avalonia.Base/Utilities/AvaloniaPropertyValueStore.cs index 6e52b6770a..1af6f21156 100644 --- a/src/Avalonia.Base/Utilities/AvaloniaPropertyValueStore.cs +++ b/src/Avalonia.Base/Utilities/AvaloniaPropertyValueStore.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; @@ -22,6 +22,9 @@ namespace Avalonia.Utilities _entries = s_emptyEntries; } + public int Count => _entries.Length - 1; + public TValue this[int index] => _entries[index].Value; + private (int, bool) TryFindEntry(int propertyId) { if (_entries.Length <= 12) @@ -163,18 +166,6 @@ namespace Avalonia.Utilities } } - public Dictionary ToDictionary() - { - var dict = new Dictionary(_entries.Length - 1); - - for (int i = 0; i < _entries.Length - 1; ++i) - { - dict.Add(AvaloniaPropertyRegistry.Instance.FindRegistered(_entries[i].PropertyId), _entries[i].Value); - } - - return dict; - } - private struct Entry { internal int PropertyId; diff --git a/src/Avalonia.Base/ValueStore.cs b/src/Avalonia.Base/ValueStore.cs index 6b89fcbdb9..e32b20cc96 100644 --- a/src/Avalonia.Base/ValueStore.cs +++ b/src/Avalonia.Base/ValueStore.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using Avalonia.Data; using Avalonia.PropertyStore; using Avalonia.Utilities; @@ -26,6 +27,7 @@ namespace Avalonia private readonly AvaloniaObject _owner; private readonly IValueSink _sink; private readonly AvaloniaPropertyValueStore _values; + private BatchUpdate? _batchUpdate; public ValueStore(AvaloniaObject owner) { @@ -33,6 +35,25 @@ namespace Avalonia _values = new AvaloniaPropertyValueStore(); } + public void BeginBatchUpdate() + { + _batchUpdate ??= new BatchUpdate(this); + _batchUpdate.Begin(); + } + + public void EndBatchUpdate() + { + if (_batchUpdate is null) + { + throw new InvalidOperationException("No batch update in progress."); + } + + if (_batchUpdate.End()) + { + _batchUpdate = null; + } + } + public bool IsAnimating(AvaloniaProperty property) { if (_values.TryGetValue(property, out var slot)) @@ -90,23 +111,21 @@ namespace Avalonia { // If the property has any coercion callbacks then always create a PriorityValue. var entry = new PriorityValue(_owner, property, this); - _values.AddValue(property, entry); + AddValue(property, entry); result = entry.SetValue(value, priority); } else { - var change = new AvaloniaPropertyChangedEventArgs(_owner, property, default, value, priority); - if (priority == BindingPriority.LocalValue) { - _values.AddValue(property, new LocalValueEntry(value)); - _sink.ValueChanged(change); + AddValue(property, new LocalValueEntry(value)); + NotifyValueChanged(property, default, value, priority); } else { var entry = new ConstantValueEntry(property, value, priority, this); - _values.AddValue(property, entry); - _sink.ValueChanged(change); + AddValue(property, entry); + NotifyValueChanged(property, default, value, priority); result = entry; } } @@ -128,15 +147,13 @@ namespace Avalonia // If the property has any coercion callbacks then always create a PriorityValue. var entry = new PriorityValue(_owner, property, this); var binding = entry.AddBinding(source, priority); - _values.AddValue(property, entry); - binding.Start(); + AddValue(property, entry); return binding; } else { var entry = new BindingEntry(_owner, property, source, priority, this); - _values.AddValue(property, entry); - entry.Start(); + AddValue(property, entry); return entry; } } @@ -149,23 +166,32 @@ namespace Avalonia { p.ClearLocalValue(); } - else + else if (slot.Priority == BindingPriority.LocalValue) { - var remove = slot is ConstantValueEntry c ? - c.Priority == BindingPriority.LocalValue : - !(slot is IPriorityValueEntry); + var old = TryGetValue(property, BindingPriority.LocalValue, out var value) ? value : default; - if (remove) + // During batch update values can't be removed immediately because they're needed to raise + // a correctly-typed _sink.ValueChanged notification. They instead mark themselves for removal + // by setting their priority to Unset. + if (_batchUpdate is null) { - var old = TryGetValue(property, BindingPriority.LocalValue, out var value) ? value : default; _values.Remove(property); - _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( - _owner, - property, - new Optional(old), - default, - BindingPriority.Unset)); } + else if (slot is IDisposable d) + { + d.Dispose(); + } + else + { + // Local value entries are optimized and contain only a single value field to save space, + // so there's no way to mark them for removal at the end of a batch update. Instead convert + // them to a constant value entry with Unset priority in the event of a local value being + // cleared during a batch update. + var sentinel = new ConstantValueEntry(property, default, BindingPriority.Unset, _sink); + _values.SetValue(property, sentinel); + } + + NotifyValueChanged(property, old, default, BindingPriority.Unset); } } } @@ -176,7 +202,7 @@ namespace Avalonia { if (slot is PriorityValue p) { - p.CoerceValue(); + p.UpdateEffectiveValue(); } } } @@ -198,7 +224,17 @@ namespace Avalonia void IValueSink.ValueChanged(AvaloniaPropertyChangedEventArgs change) { - _sink.ValueChanged(change); + if (_batchUpdate is object) + { + if (change.IsEffectiveValueChange) + { + NotifyValueChanged(change.Property, change.OldValue, change.NewValue, change.Priority); + } + } + else + { + _sink.ValueChanged(change); + } } void IValueSink.Completed( @@ -206,13 +242,17 @@ namespace Avalonia IPriorityValueEntry entry, Optional oldValue) { - if (_values.TryGetValue(property, out var slot)) + if (_values.TryGetValue(property, out var slot) && slot == entry) { - if (slot == entry) + if (_batchUpdate is null) { _values.Remove(property); _sink.Completed(property, entry, oldValue); } + else + { + _batchUpdate.ValueChanged(property, oldValue.ToObject()); + } } } @@ -240,16 +280,13 @@ namespace Avalonia { var old = l.GetValue(BindingPriority.LocalValue); l.SetValue(value); - _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( - _owner, - property, - old, - value, - priority)); + NotifyValueChanged(property, old, value, priority); } else { var priorityValue = new PriorityValue(_owner, property, this, l); + if (_batchUpdate is object) + priorityValue.BeginBatchUpdate(); result = priorityValue.SetValue(value, priority); _values.SetValue(property, priorityValue); } @@ -273,6 +310,11 @@ namespace Avalonia if (slot is IPriorityValueEntry e) { priorityValue = new PriorityValue(_owner, property, this, e); + + if (_batchUpdate is object) + { + priorityValue.BeginBatchUpdate(); + } } else if (slot is PriorityValue p) { @@ -289,8 +331,162 @@ namespace Avalonia var binding = priorityValue.AddBinding(source, priority); _values.SetValue(property, priorityValue); - binding.Start(); + priorityValue.UpdateEffectiveValue(); return binding; } + + private void AddValue(AvaloniaProperty property, IValue value) + { + _values.AddValue(property, value); + if (_batchUpdate is object && value is IBatchUpdate batch) + batch.BeginBatchUpdate(); + value.Start(); + } + + private void NotifyValueChanged( + AvaloniaProperty property, + Optional oldValue, + BindingValue newValue, + BindingPriority priority) + { + if (_batchUpdate is null) + { + _sink.ValueChanged(new AvaloniaPropertyChangedEventArgs( + _owner, + property, + oldValue, + newValue, + priority)); + } + else + { + _batchUpdate.ValueChanged(property, oldValue.ToObject()); + } + } + + private class BatchUpdate + { + private ValueStore _owner; + private List? _notifications; + private int _batchUpdateCount; + private int _iterator = -1; + + public BatchUpdate(ValueStore owner) => _owner = owner; + + public void Begin() + { + if (_batchUpdateCount++ == 0) + { + var values = _owner._values; + + for (var i = 0; i < values.Count; ++i) + { + (values[i] as IBatchUpdate)?.BeginBatchUpdate(); + } + } + } + + public bool End() + { + if (--_batchUpdateCount > 0) + return false; + + var values = _owner._values; + + // First call EndBatchUpdate on all bindings. This should cause the active binding to be subscribed + // but notifications will still not be raised because the owner ValueStore will still have a reference + // to this batch update object. + for (var i = 0; i < values.Count; ++i) + { + (values[i] as IBatchUpdate)?.EndBatchUpdate(); + + // Somehow subscribing to a binding caused a new batch update. This shouldn't happen but in case it + // does, abort and continue batch updating. + if (_batchUpdateCount > 0) + return false; + } + + if (_notifications is object) + { + // Raise all batched notifications. Doing this can cause other notifications to be added and even + // cause a new batch update to start, so we need to handle _notifications being modified by storing + // the index in field. + _iterator = 0; + + for (; _iterator < _notifications.Count; ++_iterator) + { + var entry = _notifications[_iterator]; + + if (values.TryGetValue(entry.property, out var slot)) + { + var oldValue = entry.oldValue; + var newValue = slot.GetValue(); + + // Raising this notification can cause a new batch update to be started, which in turn + // results in another change to the property. In this case we need to update the old value + // so that the *next* notification has an oldValue which follows on from the newValue + // raised here. + _notifications[_iterator] = new Notification + { + property = entry.property, + oldValue = newValue, + }; + + // Call _sink.ValueChanged with an appropriately typed AvaloniaPropertyChangedEventArgs. + slot.RaiseValueChanged(_owner._sink, _owner._owner, entry.property, oldValue, newValue); + + // During batch update values can't be removed immediately because they're needed to raise + // the _sink.ValueChanged notification. They instead mark themselves for removal by setting + // their priority to Unset. + if (slot.Priority == BindingPriority.Unset) + { + values.Remove(entry.property); + } + } + else + { + throw new AvaloniaInternalException("Value could not be found at the end of batch update."); + } + + // If a new batch update was started while ending this one, abort. + if (_batchUpdateCount > 0) + return false; + } + } + + _iterator = int.MaxValue - 1; + return true; + } + + public void ValueChanged(AvaloniaProperty property, Optional oldValue) + { + _notifications ??= new List(); + + for (var i = 0; i < _notifications.Count; ++i) + { + if (_notifications[i].property == property) + { + oldValue = _notifications[i].oldValue; + _notifications.RemoveAt(i); + + if (i <= _iterator) + --_iterator; + break; + } + } + + _notifications.Add(new Notification + { + property = property, + oldValue = oldValue, + }); + } + + private struct Notification + { + public AvaloniaProperty property; + public Optional oldValue; + } + } } } diff --git a/src/Avalonia.Controls.DataGrid/DataGridCheckBoxColumn.cs b/src/Avalonia.Controls.DataGrid/DataGridCheckBoxColumn.cs index e2a067ac61..ccf1f3f77a 100644 --- a/src/Avalonia.Controls.DataGrid/DataGridCheckBoxColumn.cs +++ b/src/Avalonia.Controls.DataGrid/DataGridCheckBoxColumn.cs @@ -17,7 +17,6 @@ namespace Avalonia.Controls /// public class DataGridCheckBoxColumn : DataGridBoundColumn { - private bool _beganEditWithKeyboard; private CheckBox _currentCheckBox; private DataGrid _owningGrid; @@ -153,23 +152,7 @@ namespace Avalonia.Controls { if (editingElement is CheckBox editingCheckBox) { - bool? uneditedValue = editingCheckBox.IsChecked; - bool editValue = false; - if(editingEventArgs is PointerPressedEventArgs args) - { - // Editing was triggered by a mouse click - Point position = args.GetPosition(editingCheckBox); - Rect rect = new Rect(0, 0, editingCheckBox.Bounds.Width, editingCheckBox.Bounds.Height); - editValue = rect.Contains(position); - } - else if (_beganEditWithKeyboard) - { - // Editing began by a user pressing spacebar - editValue = true; - _beganEditWithKeyboard = false; - } - - if (editValue) + void EditValue() { // User clicked the checkbox itself or pressed space, let's toggle the IsChecked value if (editingCheckBox.IsThreeState) @@ -192,6 +175,40 @@ namespace Avalonia.Controls editingCheckBox.IsChecked = !editingCheckBox.IsChecked; } } + + bool? uneditedValue = editingCheckBox.IsChecked; + if(editingEventArgs is PointerPressedEventArgs args) + { + void ProcessPointerArgs() + { + // Editing was triggered by a mouse click + Point position = args.GetPosition(editingCheckBox); + Rect rect = new Rect(0, 0, editingCheckBox.Bounds.Width, editingCheckBox.Bounds.Height); + if(rect.Contains(position)) + { + EditValue(); + } + } + + void OnLayoutUpdated(object sender, EventArgs e) + { + if(!editingCheckBox.Bounds.IsEmpty) + { + editingCheckBox.LayoutUpdated -= OnLayoutUpdated; + ProcessPointerArgs(); + } + } + + if(editingCheckBox.Bounds.IsEmpty) + { + editingCheckBox.LayoutUpdated += OnLayoutUpdated; + } + else + { + ProcessPointerArgs(); + } + } + return uneditedValue; } return false; @@ -284,13 +301,10 @@ namespace Avalonia.Controls CheckBox checkBox = GetCellContent(row) as CheckBox; if (checkBox == _currentCheckBox) { - _beganEditWithKeyboard = true; OwningGrid.BeginEdit(); - return; } } } - _beganEditWithKeyboard = false; } private void OwningGrid_LoadingRow(object sender, DataGridRowEventArgs e) diff --git a/src/Avalonia.Controls/ApiCompatBaseline.txt b/src/Avalonia.Controls/ApiCompatBaseline.txt index e5adc8c6ed..aa8db78087 100644 --- a/src/Avalonia.Controls/ApiCompatBaseline.txt +++ b/src/Avalonia.Controls/ApiCompatBaseline.txt @@ -1,6 +1,7 @@ Compat issues with assembly Avalonia.Controls: MembersMustExist : Member 'public void Avalonia.Controls.Embedding.Offscreen.OffscreenTopLevelImplBase.SetCursor(Avalonia.Platform.IPlatformHandle)' does not exist in the implementation but it does exist in the contract. +MembersMustExist : Member 'public Avalonia.AvaloniaProperty Avalonia.AvaloniaProperty Avalonia.Controls.Notifications.NotificationCard.CloseOnClickProperty' does not exist in the implementation but it does exist in the contract. InterfacesShouldHaveSameMembers : Interface member 'public void Avalonia.Platform.ITopLevelImpl.SetCursor(Avalonia.Platform.ICursorImpl)' is present in the implementation but not in the contract. InterfacesShouldHaveSameMembers : Interface member 'public void Avalonia.Platform.ITopLevelImpl.SetCursor(Avalonia.Platform.IPlatformHandle)' is present in the contract but not in the implementation. MembersMustExist : Member 'public void Avalonia.Platform.ITopLevelImpl.SetCursor(Avalonia.Platform.IPlatformHandle)' does not exist in the implementation but it does exist in the contract. -Total Issues: 4 +Total Issues: 5 diff --git a/src/Avalonia.Controls/Application.cs b/src/Avalonia.Controls/Application.cs index 3bf72460df..54c576bb76 100644 --- a/src/Avalonia.Controls/Application.cs +++ b/src/Avalonia.Controls/Application.cs @@ -30,7 +30,7 @@ namespace Avalonia /// method. /// - Tracks the lifetime of the application. /// - public class Application : AvaloniaObject, IDataContextProvider, IGlobalDataTemplates, IGlobalStyles, IResourceHost + public class Application : AvaloniaObject, IDataContextProvider, IGlobalDataTemplates, IGlobalStyles, IResourceHost, IApplicationPlatformEvents { /// /// The application-global data templates. @@ -55,6 +55,8 @@ namespace Avalonia /// public event EventHandler ResourcesChanged; + public event EventHandler UrlsOpened; + /// /// Creates an instance of the class. /// @@ -247,7 +249,11 @@ namespace Avalonia public virtual void OnFrameworkInitializationCompleted() { - + } + + void IApplicationPlatformEvents.RaiseUrlsOpened(string[] urls) + { + UrlsOpened?.Invoke(this, new UrlOpenedEventArgs (urls)); } private void NotifyResourcesChanged(ResourcesChangedEventArgs e) @@ -288,5 +294,6 @@ namespace Avalonia get => _name; set => SetAndRaise(NameProperty, ref _name, value); } + } } diff --git a/src/Avalonia.Controls/ApplicationLifetimes/ClassicDesktopStyleApplicationLifetime.cs b/src/Avalonia.Controls/ApplicationLifetimes/ClassicDesktopStyleApplicationLifetime.cs index e2c8e7e8e2..aa4342f075 100644 --- a/src/Avalonia.Controls/ApplicationLifetimes/ClassicDesktopStyleApplicationLifetime.cs +++ b/src/Avalonia.Controls/ApplicationLifetimes/ClassicDesktopStyleApplicationLifetime.cs @@ -5,6 +5,7 @@ using System.Threading; using Avalonia.Controls; using Avalonia.Controls.ApplicationLifetimes; using Avalonia.Interactivity; +using Avalonia.Platform; using Avalonia.Threading; namespace Avalonia.Controls.ApplicationLifetimes @@ -102,6 +103,14 @@ namespace Avalonia.Controls.ApplicationLifetimes public int Start(string[] args) { Startup?.Invoke(this, new ControlledApplicationLifetimeStartupEventArgs(args)); + + var options = AvaloniaLocator.Current.GetService(); + + if(options != null && options.ProcessUrlActivationCommandLine && args.Length > 0) + { + ((IApplicationPlatformEvents)Application.Current).RaiseUrlsOpened(args); + } + _cts = new CancellationTokenSource(); MainWindow?.Show(); Dispatcher.UIThread.MainLoop(_cts.Token); @@ -115,6 +124,11 @@ namespace Avalonia.Controls.ApplicationLifetimes _activeLifetime = null; } } + + public class ClassicDesktopStyleApplicationLifetimeOptions + { + public bool ProcessUrlActivationCommandLine { get; set; } + } } namespace Avalonia diff --git a/src/Avalonia.Controls/Control.cs b/src/Avalonia.Controls/Control.cs index 620f5afa81..4aab92c428 100644 --- a/src/Avalonia.Controls/Control.cs +++ b/src/Avalonia.Controls/Control.cs @@ -20,7 +20,7 @@ namespace Avalonia.Controls /// /// - A property to allow user-defined data to be attached to the control. /// - public class Control : InputElement, IControl, INamed, ISupportInitialize, IVisualBrushInitialize, ISetterValue + public class Control : InputElement, IControl, INamed, IVisualBrushInitialize, ISetterValue { /// /// Defines the property. diff --git a/src/Avalonia.Controls/DefinitionBase.cs b/src/Avalonia.Controls/DefinitionBase.cs index 38ebbe5bf9..3237f6f37b 100644 --- a/src/Avalonia.Controls/DefinitionBase.cs +++ b/src/Avalonia.Controls/DefinitionBase.cs @@ -662,31 +662,64 @@ namespace Avalonia.Controls { DefinitionBase definitionBase = _registry[i]; - if (sharedMinSizeChanged || definitionBase.LayoutWasUpdated) + // we'll set d.UseSharedMinimum to maintain the invariant: + // d.UseSharedMinimum iff d._minSize < this.MinSize + // i.e. iff d is not a "long-pole" definition. + // + // Measure/Arrange of d's Grid uses d._minSize for long-pole + // definitions, and max(d._minSize, shared size) for + // short-pole definitions. This distinction allows us to react + // to changes in "long-pole-ness" more efficiently and correctly, + // by avoiding remeasures when a long-pole definition changes. + bool useSharedMinimum = !MathUtilities.AreClose(definitionBase._minSize, sharedMinSize); + + // before doing that, determine whether d's Grid needs to be remeasured. + // It's important _not_ to remeasure if the last measure is still + // valid, otherwise infinite loops are possible + bool measureIsValid; + + if(!definitionBase.UseSharedMinimum) { - // if definition's min size is different, then need to re-measure - if (!MathUtilities.AreClose(sharedMinSize, definitionBase.MinSize)) - { - Grid parentGrid = (Grid)definitionBase.Parent; - parentGrid.InvalidateMeasure(); - definitionBase.UseSharedMinimum = true; - } - else - { - definitionBase.UseSharedMinimum = false; - - // if measure is valid then also need to check arrange. - // Note: definitionBase.SizeCache is volatile but at this point - // it contains up-to-date final size - if (!MathUtilities.AreClose(sharedMinSize, definitionBase.SizeCache)) - { - Grid parentGrid = (Grid)definitionBase.Parent; - parentGrid.InvalidateArrange(); - } - } + // d was a long-pole. measure is valid iff it's still a long-pole, + // since previous measure didn't use shared size. + measureIsValid = !useSharedMinimum; + } + else if(useSharedMinimum) + { + // d was a short-pole, and still is. measure is valid + // iff the shared size didn't change + measureIsValid = !sharedMinSizeChanged; + } + else + { + // d was a short-pole, but is now a long-pole. This can + // happen in several ways: + // a. d's minSize increased to or past the old shared size + // b. other long-pole definitions decreased, leaving + // d as the new winner + // In the former case, the measure is valid - it used + // d's new larger minSize. In the latter case, the + // measure is invalid - it used the old shared size, + // which is larger than d's (possibly changed) minSize + measureIsValid = (definitionBase.LayoutWasUpdated && + MathUtilities.GreaterThanOrClose(definitionBase._minSize, this.MinSize)); + } - definitionBase.LayoutWasUpdated = false; + if(!measureIsValid) + { + definitionBase.Parent.InvalidateMeasure(); } + else if (!MathUtilities.AreClose(sharedMinSize, definitionBase.SizeCache)) + { + // if measure is valid then also need to check arrange. + // Note: definitionBase.SizeCache is volatile but at this point + // it contains up-to-date final size + definitionBase.Parent.InvalidateArrange(); + } + + // now we can restore the invariant, and clear the layout flag + definitionBase.UseSharedMinimum = useSharedMinimum; + definitionBase.LayoutWasUpdated = false; } _minSize = sharedMinSize; diff --git a/src/Avalonia.Controls/Notifications/NotificationCard.cs b/src/Avalonia.Controls/Notifications/NotificationCard.cs index cdbace3ced..ad883c8076 100644 --- a/src/Avalonia.Controls/Notifications/NotificationCard.cs +++ b/src/Avalonia.Controls/Notifications/NotificationCard.cs @@ -16,6 +16,11 @@ namespace Avalonia.Controls.Notifications private bool _isClosed; private bool _isClosing; + static NotificationCard() + { + CloseOnClickProperty.Changed.AddClassHandler