diff --git a/Avalonia.Desktop.slnf b/Avalonia.Desktop.slnf index d4cde99240..76620e8b93 100644 --- a/Avalonia.Desktop.slnf +++ b/Avalonia.Desktop.slnf @@ -38,13 +38,14 @@ "src\\Markup\\Avalonia.Markup.Xaml\\Avalonia.Markup.Xaml.csproj", "src\\Markup\\Avalonia.Markup\\Avalonia.Markup.csproj", "src\\Skia\\Avalonia.Skia\\Avalonia.Skia.csproj", - "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj", - "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj", - "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj", + "src\\tools\\Avalonia.Generators\\Avalonia.Generators.csproj", "src\\tools\\Avalonia.Generators\\Avalonia.Generators.csproj", "src\\tools\\DevAnalyzers\\DevAnalyzers.csproj", "src\\tools\\DevGenerators\\DevGenerators.csproj", "src\\tools\\PublicAnalyzers\\Avalonia.Analyzers.csproj", + "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj", + "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj", + "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj", "tests\\Avalonia.Base.UnitTests\\Avalonia.Base.UnitTests.csproj", "tests\\Avalonia.Benchmarks\\Avalonia.Benchmarks.csproj", "tests\\Avalonia.Controls.DataGrid.UnitTests\\Avalonia.Controls.DataGrid.UnitTests.csproj", diff --git a/native/Avalonia.Native/src/OSX/AvnView.mm b/native/Avalonia.Native/src/OSX/AvnView.mm index 5440b76bfe..fdc144e3a5 100644 --- a/native/Avalonia.Native/src/OSX/AvnView.mm +++ b/native/Avalonia.Native/src/OSX/AvnView.mm @@ -598,13 +598,13 @@ { [[_markedText mutableString] setString:@""]; + [[self inputContext] discardMarkedText]; + if(!_parent->InputMethod->IsActive()){ return; } _parent->InputMethod->Client->SetPreeditText(nullptr); - - [[self inputContext] discardMarkedText]; } - (NSArray *)validAttributesForMarkedText @@ -619,17 +619,12 @@ - (void)insertText:(id)string replacementRange:(NSRange)replacementRange { - //[_text replaceCharactersInRange:replacementRange withString:string]; - [self unmarkText]; - - //if(!_lastKeyHandled) - //{ - if(_parent != nullptr) - { - _lastKeyHandled = _parent->BaseEvents->RawTextInputEvent(0, [string UTF8String]); - } - //} + + if(_parent != nullptr) + { + _lastKeyHandled = _parent->BaseEvents->RawTextInputEvent(0, [string UTF8String]); + } [[self inputContext] invalidateCharacterCoordinates]; } diff --git a/native/Avalonia.Native/src/OSX/platformthreading.mm b/native/Avalonia.Native/src/OSX/platformthreading.mm index 6d5bd4aa02..d80df68fea 100644 --- a/native/Avalonia.Native/src/OSX/platformthreading.mm +++ b/native/Avalonia.Native/src/OSX/platformthreading.mm @@ -1,193 +1,266 @@ #include "common.h" class PlatformThreadingInterface; + + +class LoopCancellation : public ComSingleObject +{ +public: + FORWARD_IUNKNOWN() + + bool Running = false; + bool Cancelled = false; + bool IsApp = false; + + virtual void Cancel() override + { + Cancelled = true; + if(Running) + { + Running = false; + if(![NSThread isMainThread]) + { + AddRef(); + dispatch_async(dispatch_get_main_queue(), ^{ + if(Release() == 0) + return; + Cancel(); + }); + return; + }; + if(IsApp) + [NSApp stop:nil]; + else + { + // Wakeup the event loop + NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined + location:NSMakePoint(0, 0) + modifierFlags:0 + timestamp:0 + windowNumber:0 + context:nil + subtype:0 + data1:0 + data2:0]; + [NSApp postEvent:event atStart:YES]; + } + } + }; +}; + +// CFRunLoopTimerSetNextFireDate docs recommend to "create a repeating timer with an initial +// firing time in the distant future (or the initial firing time) and a very large repeat +// interval—on the order of decades or more" +static double distantFutureInterval = (double)50*365*24*3600; + @interface Signaler : NSObject --(void) setParent: (PlatformThreadingInterface*)parent; --(void) signal: (int) priority; +-(void) setEvents:(IAvnPlatformThreadingInterfaceEvents*) events; +-(void) updateTimer:(int)ms; -(Signaler*) init; +-(void) destroyObserver; +-(void) signal; @end -@implementation ActionCallback +@implementation Signaler { - ComPtr _callback; + ComPtr _events; + bool _wakeupDelegateSent; + bool _signaled; + bool _backgroundProcessingRequested; + CFRunLoopObserverRef _observer; + CFRunLoopTimerRef _timer; +} +- (void) checkSignaled +{ + bool signaled; + @synchronized (self) { + signaled = _signaled; + _signaled = false; + } + if(signaled) + { + _events->Signaled(); + } } -- (ActionCallback*) initWithCallback: (IAvnActionCallback*) callback + +- (Signaler*) init { - _callback = callback; + _observer = CFRunLoopObserverCreateWithHandler(nil, + kCFRunLoopBeforeSources + | kCFRunLoopAfterWaiting + | kCFRunLoopBeforeWaiting + , + true, 0, + ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) { + if(activity == kCFRunLoopBeforeWaiting) + { + bool triggerProcessing; + @synchronized (self) { + triggerProcessing = self->_backgroundProcessingRequested; + self->_backgroundProcessingRequested = false; + } + if(triggerProcessing) + self->_events->ReadyForBackgroundProcessing(); + } + [self checkSignaled]; + }); + CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes); + + + _timer = CFRunLoopTimerCreateWithHandler(nil, CFAbsoluteTimeGetCurrent() + distantFutureInterval, distantFutureInterval, 0, 0, ^(CFRunLoopTimerRef timer) { + self->_events->Timer(); + }); + + CFRunLoopAddTimer(CFRunLoopGetMain(), _timer, kCFRunLoopCommonModes); + return self; } -- (void) action +- (void) destroyObserver { - _callback->Run(); + if(_observer != nil) + { + CFRunLoopObserverInvalidate(_observer); + CFRelease(_observer); + _observer = nil; + } + + if(_timer != nil) + { + CFRunLoopTimerInvalidate(_timer); + CFRelease(_timer); + _timer = nil; + } } +-(void) updateTimer:(int)ms +{ + if(_timer == nil) + return; + double interval = ms < 0 ? distantFutureInterval : ((double)ms / 1000); + CFRunLoopTimerSetTolerance(_timer, 0); + CFRunLoopTimerSetNextFireDate(_timer, CFAbsoluteTimeGetCurrent() + interval); +} -@end +- (void) setEvents: (IAvnPlatformThreadingInterfaceEvents*) events +{ + _events = events; +} -class TimerWrapper : public ComUnknownObject +- (void) signal { - NSTimer* _timer; -public: - TimerWrapper(IAvnActionCallback* callback, int ms) - { - auto cb = [[ActionCallback alloc] initWithCallback:callback]; - _timer = [NSTimer scheduledTimerWithTimeInterval:(NSTimeInterval)(double)ms/1000 target:cb selector:@selector(action) userInfo:nullptr repeats:true]; + @synchronized (self) { + if(_signaled) + return; + _signaled = true; + dispatch_async(dispatch_get_main_queue(), ^{ + [self checkSignaled]; + }); + CFRunLoopWakeUp(CFRunLoopGetMain()); } - - virtual ~TimerWrapper() - { - [_timer invalidate]; +} + +- (void) requestBackgroundProcessing +{ + @synchronized (self) { + if(_backgroundProcessingRequested) + return; + _backgroundProcessingRequested = true; + dispatch_async(dispatch_get_main_queue(), ^{ + // This is needed to wakeup the loop if we are called from inside of BeforeWait hook + }); } -}; + + +} +@end class PlatformThreadingInterface : public ComSingleObject { private: + ComPtr _events; Signaler* _signaler; - bool _wasRunningAtLeastOnce = false; - - class LoopCancellation : public ComSingleObject - { - public: - FORWARD_IUNKNOWN() - - bool Running = false; - bool Cancelled = false; - - virtual void Cancel() override - { - Cancelled = true; - if(Running) - { - Running = false; - dispatch_async(dispatch_get_main_queue(), ^{ - [[NSApplication sharedApplication] stop:nil]; - NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined - location:NSMakePoint(0, 0) - modifierFlags:0 - timestamp:0 - windowNumber:0 - context:nil - subtype:0 - data1:0 - data2:0]; - [NSApp postEvent:event atStart:YES]; - }); - } - } - - }; - + CFRunLoopObserverRef _observer = nil; public: FORWARD_IUNKNOWN() - ComPtr SignaledCallback; - PlatformThreadingInterface() { _signaler = [Signaler new]; - [_signaler setParent:this]; - } + }; ~PlatformThreadingInterface() { - if(_signaler) - [_signaler setParent: NULL]; - _signaler = NULL; + [_signaler destroyObserver]; } - virtual bool GetCurrentThreadIsLoopThread() override + bool GetCurrentThreadIsLoopThread() override { return [NSThread isMainThread]; - } - virtual void SetSignaledCallback(IAvnSignaledCallback* cb) override + }; + + + + void SetEvents(IAvnPlatformThreadingInterfaceEvents *cb) override { - SignaledCallback = cb; - } - virtual IAvnLoopCancellation* CreateLoopCancellation() override + _events = cb; + [_signaler setEvents:cb]; + }; + + IAvnLoopCancellation *CreateLoopCancellation() override { return new LoopCancellation(); - } + }; - virtual HRESULT RunLoop(IAvnLoopCancellation* cancel) override + void RunLoop(IAvnLoopCancellation *cancel) override { START_COM_CALL; - auto can = dynamic_cast(cancel); if(can->Cancelled) - return S_OK; - if(_wasRunningAtLeastOnce) - return E_FAIL; + return; can->Running = true; - _wasRunningAtLeastOnce = true; - [NSApp run]; - return S_OK; - } + if(![NSApp isRunning]) + { + can->IsApp = true; + [NSApp run]; + return; + } + else + { + while(!can->Cancelled) + { + @autoreleasepool + { + NSEvent* ev = [NSApp + nextEventMatchingMask:NSEventMaskAny + untilDate: [NSDate dateWithTimeIntervalSinceNow:1] + inMode:NSDefaultRunLoopMode + dequeue:true]; + if(ev != NULL) + [NSApp sendEvent:ev]; + } + } + } + }; - virtual void Signal(int priority) override + void Signal() override { - [_signaler signal:priority]; - } + [_signaler signal]; + }; - virtual IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback) override - { - @autoreleasepool { - - return new TimerWrapper(callback, ms); - } - } -}; - -@implementation Signaler - -PlatformThreadingInterface* _parent = 0; -bool _signaled = 0; -NSArray* _modes; - --(Signaler*) init -{ - if(self = [super init]) + void UpdateTimer(int ms) override { - _modes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEventTrackingRunLoopMode, NSModalPanelRunLoopMode, NSRunLoopCommonModes, NSConnectionReplyMode, nil]; - } - return self; -} - --(void) perform -{ - ComPtr cb; - @synchronized (self) { - _signaled = false; - if(_parent != NULL) - cb = _parent->SignaledCallback; - } - if(cb != nullptr) - cb->Signaled(0, false); -} - --(void) setParent:(PlatformThreadingInterface *)parent -{ - @synchronized (self) { - _parent = parent; - } -} - --(void) signal: (int) priority -{ - - @synchronized (self) { - if(_signaled) - return; - _signaled = true; - [self performSelector:@selector(perform) onThread:[NSThread mainThread] withObject:NULL waitUntilDone:false modes:_modes]; + [_signaler updateTimer:ms]; + }; + + void RequestBackgroundProcessing() override { + [_signaler requestBackgroundProcessing]; } -} -@end - + +}; extern IAvnPlatformThreadingInterface* CreatePlatformThreading() { diff --git a/src/Android/Avalonia.Android/AndroidThreadingInterface.cs b/src/Android/Avalonia.Android/AndroidThreadingInterface.cs index 152076013f..c85d5b1343 100644 --- a/src/Android/Avalonia.Android/AndroidThreadingInterface.cs +++ b/src/Android/Avalonia.Android/AndroidThreadingInterface.cs @@ -21,8 +21,6 @@ namespace Avalonia.Android _handler = new Handler(App.Context.MainLooper); } - public void RunLoop(CancellationToken cancellationToken) => throw new NotSupportedException(); - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) { if (interval.TotalMilliseconds < 10) diff --git a/src/Avalonia.Base/Media/FontManager.cs b/src/Avalonia.Base/Media/FontManager.cs index cc9bc6f30a..2e8d8e415d 100644 --- a/src/Avalonia.Base/Media/FontManager.cs +++ b/src/Avalonia.Base/Media/FontManager.cs @@ -119,9 +119,7 @@ namespace Avalonia.Media } } - var familyName = fontFamily.FamilyNames.PrimaryFamilyName.ToUpperInvariant(); - - if (fontCollection != null && fontCollection.TryGetGlyphTypeface(familyName, + if (fontCollection != null && fontCollection.TryGetGlyphTypeface(fontFamily.FamilyNames.PrimaryFamilyName, typeface.Style, typeface.Weight, typeface.Stretch, out glyphTypeface)) { return true; @@ -135,7 +133,7 @@ namespace Avalonia.Media foreach (var familyName in fontFamily.FamilyNames) { - if (SystemFonts.TryGetGlyphTypeface(familyName.ToUpperInvariant(), typeface.Style, typeface.Weight, typeface.Stretch, out glyphTypeface)) + if (SystemFonts.TryGetGlyphTypeface(familyName, typeface.Style, typeface.Weight, typeface.Stretch, out glyphTypeface)) { return true; } diff --git a/src/Avalonia.Base/Media/Fonts/EmbeddedFontCollection.cs b/src/Avalonia.Base/Media/Fonts/EmbeddedFontCollection.cs index 3350358d68..f2fb490592 100644 --- a/src/Avalonia.Base/Media/Fonts/EmbeddedFontCollection.cs +++ b/src/Avalonia.Base/Media/Fonts/EmbeddedFontCollection.cs @@ -3,6 +3,7 @@ using System.Collections; using System.Collections.Concurrent; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; +using System.Globalization; using Avalonia.Platform; namespace Avalonia.Media.Fonts @@ -42,13 +43,11 @@ namespace Avalonia.Media.Fonts if (fontManager.TryCreateGlyphTypeface(stream, out var glyphTypeface)) { - var familyName = glyphTypeface.FamilyName.ToUpperInvariant(); - - if (!_glyphTypefaceCache.TryGetValue(familyName, out var glyphTypefaces)) + if (!_glyphTypefaceCache.TryGetValue(glyphTypeface.FamilyName, out var glyphTypefaces)) { glyphTypefaces = new ConcurrentDictionary(); - if (_glyphTypefaceCache.TryAdd(familyName, glyphTypefaces)) + if (_glyphTypefaceCache.TryAdd(glyphTypeface.FamilyName, glyphTypefaces)) { _fontFamilies.Add(new FontFamily(_key, glyphTypeface.FamilyName)); } @@ -87,8 +86,6 @@ namespace Avalonia.Media.Fonts public bool TryGetGlyphTypeface(string familyName, FontStyle style, FontWeight weight, FontStretch stretch, [NotNullWhen(true)] out IGlyphTypeface? glyphTypeface) { - familyName = familyName.ToUpperInvariant(); - var key = new FontCollectionKey(style, weight, stretch); if (_glyphTypefaceCache.TryGetValue(familyName, out var glyphTypefaces)) @@ -104,11 +101,9 @@ namespace Avalonia.Media.Fonts { var fontFamily = _fontFamilies[i]; - if (fontFamily.Name.ToUpperInvariant().StartsWith(familyName.ToUpperInvariant())) + if (fontFamily.Name.ToLower(CultureInfo.InvariantCulture).StartsWith(familyName.ToLower(CultureInfo.InvariantCulture))) { - familyName = fontFamily.Name.ToUpperInvariant(); - - if (_glyphTypefaceCache.TryGetValue(familyName, out glyphTypefaces) && + if (_glyphTypefaceCache.TryGetValue(fontFamily.Name, out glyphTypefaces) && TryGetNearestMatch(glyphTypefaces, key, out glyphTypeface)) { return true; diff --git a/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs b/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs index 1687deb37b..fd332c6ebe 100644 --- a/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs +++ b/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs @@ -42,8 +42,6 @@ namespace Avalonia.Media.Fonts familyName = _fontManager.DefaultFontFamilyName; } - familyName = familyName.ToUpperInvariant(); - var key = new FontCollectionKey(style, weight, stretch); if (_glyphTypefaceCache.TryGetValue(familyName, out var glyphTypefaces)) diff --git a/src/Avalonia.Base/Platform/IPlatformThreadingInterface.cs b/src/Avalonia.Base/Platform/IPlatformThreadingInterface.cs index 3dbc7c1bb2..4fe4a2e6b9 100644 --- a/src/Avalonia.Base/Platform/IPlatformThreadingInterface.cs +++ b/src/Avalonia.Base/Platform/IPlatformThreadingInterface.cs @@ -11,8 +11,6 @@ namespace Avalonia.Platform [Unstable] public interface IPlatformThreadingInterface { - void RunLoop(CancellationToken cancellationToken); - /// /// Starts a timer. /// diff --git a/src/Avalonia.Base/PropertyStore/EffectiveValue.cs b/src/Avalonia.Base/PropertyStore/EffectiveValue.cs index 11a4dd7893..7e9f9ae9ba 100644 --- a/src/Avalonia.Base/PropertyStore/EffectiveValue.cs +++ b/src/Avalonia.Base/PropertyStore/EffectiveValue.cs @@ -54,9 +54,9 @@ namespace Avalonia.PropertyStore /// public void BeginReevaluation(bool clearLocalValue = false) { - if (clearLocalValue || Priority != BindingPriority.LocalValue) + if (clearLocalValue || (Priority != BindingPriority.LocalValue && !IsOverridenCurrentValue)) Priority = BindingPriority.Unset; - if (clearLocalValue || BasePriority != BindingPriority.LocalValue) + if (clearLocalValue || (BasePriority != BindingPriority.LocalValue && !IsOverridenCurrentValue)) BasePriority = BindingPriority.Unset; } diff --git a/src/Avalonia.Base/PropertyStore/ValueStore.cs b/src/Avalonia.Base/PropertyStore/ValueStore.cs index 53cd3ff307..af31459a98 100644 --- a/src/Avalonia.Base/PropertyStore/ValueStore.cs +++ b/src/Avalonia.Base/PropertyStore/ValueStore.cs @@ -395,7 +395,7 @@ namespace Avalonia.PropertyStore if (TryGetEffectiveValue(property, out var existing)) { if (priority <= existing.BasePriority) - ReevaluateEffectiveValue(property, existing); + ReevaluateEffectiveValue(property, existing, changedValueEntry: entry); } else { @@ -774,6 +774,7 @@ namespace Avalonia.PropertyStore private void ReevaluateEffectiveValue( AvaloniaProperty property, EffectiveValue? current, + IValueEntry? changedValueEntry = null, bool ignoreLocalValue = false) { ++_isEvaluating; @@ -796,6 +797,12 @@ namespace Avalonia.PropertyStore { var frame = _frames[i]; var priority = frame.Priority; + + // Exit early if the current EffectiveValue has higher priority than this frame. + if (current?.Priority < priority && current?.BasePriority < priority) + break; + + // Try to get an entry from the frame for the property we're reevaluating. 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 @@ -803,20 +810,17 @@ namespace Avalonia.PropertyStore // effective values of all properties. if (activeChanged && frame.EntryCount > 1) { - ReevaluateEffectiveValues(); + ReevaluateEffectiveValues(changedValueEntry); 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 < current.BasePriority) || - (priority > BindingPriority.Animation && priority < current.BasePriority); - - if (foundEntry && isRelevantPriority && entry!.HasValue) + // If the frame has an entry for this property with a higher priority than the + // current effective value (and that entry has a value), then we have a new + // value for the property. Note that the check for entry.HasValue must be + // evaluated last as it can cause bindings to be subscribed. + if (foundEntry && + HasHigherPriority(entry!, priority, current, changedValueEntry) && + entry!.HasValue) { if (current is not null) { @@ -832,10 +836,6 @@ namespace Avalonia.PropertyStore if (generation != _frameGeneration) goto restart; - - if (current?.Priority < BindingPriority.Unset && - current?.BasePriority < BindingPriority.Unset) - break; } if (current?.Priority == BindingPriority.Unset) @@ -859,7 +859,7 @@ namespace Avalonia.PropertyStore } } - private void ReevaluateEffectiveValues() + private void ReevaluateEffectiveValues(IValueEntry? changedValueEntry = null) { ++_isEvaluating; @@ -894,10 +894,9 @@ namespace Avalonia.PropertyStore { 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) + _effectiveValues.TryGetValue(property, out var effectiveValue); + + if (!HasHigherPriority(entry, priority, effectiveValue, changedValueEntry)) continue; if (!entry.HasValue) @@ -942,6 +941,37 @@ namespace Avalonia.PropertyStore } } + private static bool HasHigherPriority( + IValueEntry entry, + BindingPriority entryPriority, + EffectiveValue? current, + IValueEntry? changedValueEntry) + { + // Set the value if: there is no current effective value; or + if (current is null) + return true; + + // The value's priority is higher than the current effective value's priority; or + if (entryPriority < current.Priority && entryPriority < current.BasePriority) + return true; + + // - The value's priority is equal to the current effective value's priority + // - But the effective value was set via SetCurrentValue + // - As long as the SetCurrentValue wasn't overriding the value from the value entry under consideration + // - Or if it was, the value entry under consideration has changed; or + if (entryPriority == current.Priority && + current.IsOverridenCurrentValue && + (current.ValueEntry != entry || entry == changedValueEntry)) + return true; + + // The value is a non-animation value and its priority is higher than the current effective value's base + // priority. + if (entryPriority > BindingPriority.Animation && entryPriority < current.BasePriority) + return true; + + return false; + } + private bool TryGetEffectiveValue( AvaloniaProperty property, [NotNullWhen(true)] out EffectiveValue? value) diff --git a/src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs b/src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs index f24f449551..032a3046d7 100644 --- a/src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs +++ b/src/Avalonia.Base/Rendering/Composition/Transport/BatchStreamArrayPool.cs @@ -30,7 +30,8 @@ internal abstract class BatchStreamPoolBase : IDisposable GC.SuppressFinalize(needsFinalize); var updateRef = new WeakReference>(this); - if (AvaloniaLocator.Current.GetService() == null) + if (AvaloniaLocator.Current.GetService() == null + && AvaloniaLocator.Current.GetService() == null) _reclaimImmediately = true; else StartUpdateTimer(startTimer, updateRef); diff --git a/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs b/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs index 2cade55f32..1b29cf32f7 100644 --- a/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs +++ b/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs @@ -30,7 +30,7 @@ namespace Avalonia.Threading /// public override void Post(SendOrPostCallback d, object? state) { - Dispatcher.UIThread.Post(d, state, DispatcherPriority.Background); + Dispatcher.UIThread.Post(d, state, DispatcherPriority.Background); } /// diff --git a/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs b/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs new file mode 100644 index 0000000000..80b62b3818 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs @@ -0,0 +1,553 @@ +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Threading; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// Note that the default priority is DispatcherPriority.Send. + /// + public void Invoke(Action callback) + { + Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + public void Invoke(Action callback, DispatcherPriority priority) + { + Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken) + { + Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The minimum amount of time to wait for the operation to start. + /// Once the operation has started, it will complete before this method + /// returns. + /// + public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken, + TimeSpan timeout) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + if (timeout.TotalMilliseconds < 0 && + timeout != TimeSpan.FromMilliseconds(-1)) + { + throw new ArgumentOutOfRangeException("timeout"); + } + + // Fast-Path: if on the same thread, and invoking at Send priority, + // and the cancellation token is not already canceled, then just + // call the callback directly. + if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess()) + { + callback(); + return; + } + + // Slow-Path: go through the queue. + DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false); + InvokeImpl(operation, cancellationToken, timeout); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The return value from the delegate being invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Send. + /// + public TResult Invoke(Func callback) + { + return Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority) + { + return Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + return Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The minimum amount of time to wait for the operation to start. + /// Once the operation has started, it will complete before this method + /// returns. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken, TimeSpan timeout) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + if (timeout.TotalMilliseconds < 0 && + timeout != TimeSpan.FromMilliseconds(-1)) + { + throw new ArgumentOutOfRangeException("timeout"); + } + + // Fast-Path: if on the same thread, and invoking at Send priority, + // and the cancellation token is not already canceled, then just + // call the callback directly. + if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess()) + { + return callback(); + } + + // Slow-Path: go through the queue. + DispatcherOperation operation = new DispatcherOperation(this, priority, callback); + return (TResult)InvokeImpl(operation, cancellationToken, timeout)!; + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Normal. + /// + public DispatcherOperation InvokeAsync(Action callback) + { + return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None); + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority) + { + return InvokeAsync(callback, priority, CancellationToken.None); + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false); + InvokeAsyncImpl(operation, cancellationToken); + + return operation; + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Normal. + /// + public DispatcherOperation InvokeAsync(Func callback) + { + return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None); + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Func callback, DispatcherPriority priority) + { + return InvokeAsync(callback, priority, CancellationToken.None); + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + DispatcherOperation operation = new DispatcherOperation(this, priority, callback); + InvokeAsyncImpl(operation, cancellationToken); + + return operation; + } + + private void InvokeAsyncImpl(DispatcherOperation operation, CancellationToken cancellationToken) + { + bool succeeded = false; + + // Could be a non-dispatcher thread, lock to read + lock (InstanceLock) + { + if (!cancellationToken.IsCancellationRequested && + !_hasShutdownFinished && + !Environment.HasShutdownStarted) + { + // Add the operation to the work queue + _queue.Enqueue(operation.Priority, operation); + + // Make sure we will wake up to process this operation. + succeeded = RequestProcessing(); + + if (!succeeded) + { + // Dequeue the item since we failed to request + // processing for it. Note we will mark it aborted + // below. + _queue.RemoveItem(operation); + } + } + } + + if (succeeded == true) + { + // We have enqueued the operation. Register a callback + // with the cancellation token to abort the operation + // when cancellation is requested. + if (cancellationToken.CanBeCanceled) + { + CancellationTokenRegistration cancellationRegistration = + cancellationToken.Register(s => ((DispatcherOperation)s!).Abort(), operation); + + // Revoke the cancellation when the operation is done. + operation.Aborted += (s, e) => cancellationRegistration.Dispose(); + operation.Completed += (s, e) => cancellationRegistration.Dispose(); + } + } + else + { + // We failed to enqueue the operation, and the caller that + // created the operation does not expose it before we return, + // so it is safe to modify the operation outside of the lock. + // Just mark the operation as aborted, which we can safely + // return to the user. + operation.DoAbort(); + } + } + + + private object? InvokeImpl(DispatcherOperation operation, CancellationToken cancellationToken, TimeSpan timeout) + { + object? result = null; + + Debug.Assert(timeout.TotalMilliseconds >= 0 || timeout == TimeSpan.FromMilliseconds(-1)); + Debug.Assert(operation.Priority != DispatcherPriority.Send || !CheckAccess()); // should be handled by caller + + if (!cancellationToken.IsCancellationRequested) + { + // This operation must be queued since it was invoked either to + // another thread, or at a priority other than Send. + InvokeAsyncImpl(operation, cancellationToken); + + CancellationToken ctTimeout = CancellationToken.None; + CancellationTokenRegistration ctTimeoutRegistration = new CancellationTokenRegistration(); + CancellationTokenSource? ctsTimeout = null; + + if (timeout.TotalMilliseconds >= 0) + { + // Create a CancellationTokenSource that will abort the + // operation after the timeout. Note that this does not + // cancel the operation, just abort it if it is still pending. + ctsTimeout = new CancellationTokenSource(timeout); + ctTimeout = ctsTimeout.Token; + ctTimeoutRegistration = ctTimeout.Register(s => ((DispatcherOperation)s!).Abort(), operation); + } + + + // We have already registered with the cancellation tokens + // (both provided by the user, and one for the timeout) to + // abort the operation when they are canceled. If the + // operation has already started when the timeout expires, + // we still wait for it to complete. This is different + // than simply waiting on the operation with a timeout + // because we are the ones queueing the dispatcher + // operation, not the caller. We can't leave the operation + // in a state that it might execute if we return that it did not + // invoke. + try + { + operation.GetTask().Wait(); + + Debug.Assert(operation.Status == DispatcherOperationStatus.Completed || + operation.Status == DispatcherOperationStatus.Aborted); + + // Old async semantics return from Wait without + // throwing an exception if the operation was aborted. + // There is no need to test the timout condition, since + // the old async semantics would just return the result, + // which would be null. + + // This should not block because either the operation + // is using the old async sematics, or the operation + // completed successfully. + result = operation.GetResult(); + } + catch (OperationCanceledException) + { + Debug.Assert(operation.Status == DispatcherOperationStatus.Aborted); + + // New async semantics will throw an exception if the + // operation was aborted. Here we convert that + // exception into a timeout exception if the timeout + // has expired (admittedly a weak relationship + // assuming causality). + if (ctTimeout.IsCancellationRequested) + { + // The operation was canceled because of the + // timeout, throw a TimeoutException instead. + throw new TimeoutException(); + } + else + { + // The operation was canceled from some other reason. + throw; + } + } + finally + { + ctTimeoutRegistration.Dispose(); + if (ctsTimeout != null) + { + ctsTimeout.Dispose(); + } + } + } + + return result; + } + + /// + public void Post(Action action, DispatcherPriority priority = default) + { + _ = action ?? throw new ArgumentNullException(nameof(action)); + InvokeAsyncImpl(new DispatcherOperation(this, priority, action, true), CancellationToken.None); + } + + /// + /// Posts an action that will be invoked on the dispatcher thread. + /// + /// The method. + /// The argument of method to call. + /// The priority with which to invoke the method. + public void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default) + { + _ = action ?? throw new ArgumentNullException(nameof(action)); + InvokeAsyncImpl(new SendOrPostCallbackDispatcherOperation(this, priority, action, arg, true), CancellationToken.None); + } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/Dispatcher.Queue.cs b/src/Avalonia.Base/Threading/Dispatcher.Queue.cs new file mode 100644 index 0000000000..c91af1a514 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Queue.cs @@ -0,0 +1,238 @@ +using System; +using System.Diagnostics; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + private readonly DispatcherPriorityQueue _queue = new(); + private bool _signaled; + private bool _explicitBackgroundProcessingRequested; + private const int MaximumTimeProcessingBackgroundJobs = 50; + + void RequestBackgroundProcessing() + { + lock (InstanceLock) + { + if (_backgroundProcessingImpl != null) + { + if(_explicitBackgroundProcessingRequested) + return; + _explicitBackgroundProcessingRequested = true; + _backgroundProcessingImpl.RequestBackgroundProcessing(); + } + else if (_dueTimeForBackgroundProcessing == null) + { + _dueTimeForBackgroundProcessing = Now + 1; + UpdateOSTimer(); + } + } + } + + private void OnReadyForExplicitBackgroundProcessing() + { + lock (InstanceLock) + { + _explicitBackgroundProcessingRequested = false; + ExecuteJobsCore(); + } + } + + /// + /// Force-runs all dispatcher operations ignoring any pending OS events, use with caution + /// + public void RunJobs(DispatcherPriority? priority = null) + { + priority ??= DispatcherPriority.MinimumActiveValue; + if (priority < DispatcherPriority.MinimumActiveValue) + priority = DispatcherPriority.MinimumActiveValue; + while (true) + { + DispatcherOperation? job; + lock (InstanceLock) + job = _queue.Peek(); + if (job == null) + return; + if (priority != null && job.Priority < priority.Value) + return; + ExecuteJob(job); + } + } + + class DummyShuttingDownUnitTestDispatcherImpl : IDispatcherImpl + { + public bool CurrentThreadIsLoopThread => true; + public void Signal() + { + } + + public event Action? Signaled; + public event Action? Timer; + public long Now => 0; + public void UpdateTimer(long? dueTimeInMs) + { + } + } + + internal static void ResetForUnitTests() + { + if (s_uiThread == null) + return; + var st = Stopwatch.StartNew(); + while (true) + { + s_uiThread._pendingInputImpl = s_uiThread._controlledImpl = null; + s_uiThread._impl = new DummyShuttingDownUnitTestDispatcherImpl(); + if (st.Elapsed.TotalSeconds > 5) + throw new InvalidProgramException("You've caused dispatcher loop"); + + DispatcherOperation? job; + lock (s_uiThread.InstanceLock) + job = s_uiThread._queue.Peek(); + if (job == null || job.Priority <= DispatcherPriority.Inactive) + { + s_uiThread = null; + return; + } + + s_uiThread.ExecuteJob(job); + } + + } + + private void ExecuteJob(DispatcherOperation job) + { + lock (InstanceLock) + _queue.RemoveItem(job); + job.Execute(); + // The backend might be firing timers with a low priority, + // so we manually check if our high priority timers are due for execution + PromoteTimers(); + } + + private void Signaled() + { + lock (InstanceLock) + _signaled = false; + + ExecuteJobsCore(); + } + + void ExecuteJobsCore() + { + long? backgroundJobExecutionStartedAt = null; + while (true) + { + DispatcherOperation? job; + + lock (InstanceLock) + job = _queue.Peek(); + + if (job == null || job.Priority < DispatcherPriority.MinimumActiveValue) + return; + + + // We don't stop for executing jobs queued with >Input priority + if (job.Priority > DispatcherPriority.Input) + { + ExecuteJob(job); + backgroundJobExecutionStartedAt = null; + } + // If platform supports pending input query, ask the platform if we can continue running low priority jobs + else if (_pendingInputImpl?.CanQueryPendingInput == true) + { + if (!_pendingInputImpl.HasPendingInput) + ExecuteJob(job); + else + { + RequestBackgroundProcessing(); + return; + } + } + // We can't check if there is pending input, but still need to enforce interactivity + // so we stop processing background jobs after some timeout and start a timer to continue later + else + { + if (backgroundJobExecutionStartedAt == null) + backgroundJobExecutionStartedAt = Now; + + if (Now - backgroundJobExecutionStartedAt.Value > MaximumTimeProcessingBackgroundJobs) + { + _signaled = true; + RequestBackgroundProcessing(); + return; + } + else + ExecuteJob(job); + } + } + } + + private bool RequestProcessing() + { + lock (InstanceLock) + { + if (!CheckAccess()) + { + RequestForegroundProcessing(); + return true; + } + + if (_queue.MaxPriority <= DispatcherPriority.Input) + { + if (_pendingInputImpl is { CanQueryPendingInput: true, HasPendingInput: false }) + RequestForegroundProcessing(); + else + RequestBackgroundProcessing(); + } + else + RequestForegroundProcessing(); + } + return true; + } + + private void RequestForegroundProcessing() + { + if (!_signaled) + { + _signaled = true; + _impl.Signal(); + } + } + + internal void Abort(DispatcherOperation operation) + { + lock (InstanceLock) + _queue.RemoveItem(operation); + operation.DoAbort(); + } + + // Returns whether or not the priority was set. + internal bool SetPriority(DispatcherOperation operation, DispatcherPriority priority) // NOTE: should be Priority + { + bool notify = false; + + lock(InstanceLock) + { + if(operation.IsQueued) + { + _queue.ChangeItemPriority(operation, priority); + notify = true; + + if(notify) + { + // Make sure we will wake up to process this operation. + RequestProcessing(); + + } + } + } + return notify; + } + + public bool HasJobsWithPriority(DispatcherPriority priority) + { + lock (InstanceLock) + return _queue.MaxPriority >= priority; + } +} diff --git a/src/Avalonia.Base/Threading/Dispatcher.Timers.cs b/src/Avalonia.Base/Threading/Dispatcher.Timers.cs new file mode 100644 index 0000000000..bb252b7f55 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Timers.cs @@ -0,0 +1,207 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + private List _timers = new(); + private long _timersVersion; + private bool _dueTimeFound; + private long _dueTimeInMs; + + private long? _dueTimeForTimers; + private long? _dueTimeForBackgroundProcessing; + private long? _osTimerSetTo; + + internal long Now => _impl.Now; + + private void UpdateOSTimer() + { + VerifyAccess(); + var nextDueTime = + (_dueTimeForTimers.HasValue && _dueTimeForBackgroundProcessing.HasValue) ? + Math.Min(_dueTimeForTimers.Value, _dueTimeForBackgroundProcessing.Value) : + _dueTimeForTimers ?? _dueTimeForBackgroundProcessing; + if (_osTimerSetTo == nextDueTime) + return; + _impl.UpdateTimer(_osTimerSetTo = nextDueTime); + } + + internal void RescheduleTimers() + { + if (!CheckAccess()) + { + Post(RescheduleTimers, DispatcherPriority.Send); + return; + } + + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Dispatcher thread, does not technically need the lock to read + { + bool oldDueTimeFound = _dueTimeFound; + long oldDueTimeInTicks = _dueTimeInMs; + _dueTimeFound = false; + _dueTimeInMs = 0; + + if (_timers.Count > 0) + { + // We could do better if we sorted the list of timers. + for (int i = 0; i < _timers.Count; i++) + { + var timer = _timers[i]; + + if (!_dueTimeFound || timer.DueTimeInMs - _dueTimeInMs < 0) + { + _dueTimeFound = true; + _dueTimeInMs = timer.DueTimeInMs; + } + } + } + + if (_dueTimeFound) + { + if (_dueTimeForTimers == null || !oldDueTimeFound || (oldDueTimeInTicks != _dueTimeInMs)) + { + _dueTimeForTimers = _dueTimeInMs; + UpdateOSTimer(); + } + } + else if (oldDueTimeFound) + { + _dueTimeForTimers = null; + UpdateOSTimer(); + } + } + } + } + + internal void AddTimer(DispatcherTimer timer) + { + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + _timers.Add(timer); + _timersVersion++; + } + } + + RescheduleTimers(); + } + + internal void RemoveTimer(DispatcherTimer timer) + { + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + _timers.Remove(timer); + _timersVersion++; + } + } + + RescheduleTimers(); + } + + private void OnOSTimer() + { + _impl.UpdateTimer(null); + _osTimerSetTo = null; + bool needToPromoteTimers = false; + bool needToProcessQueue = false; + lock (InstanceLock) + { + _impl.UpdateTimer(_osTimerSetTo = null); + needToPromoteTimers = _dueTimeForTimers.HasValue && _dueTimeForTimers.Value <= Now; + if (needToPromoteTimers) + _dueTimeForTimers = null; + needToProcessQueue = _dueTimeForBackgroundProcessing.HasValue && + _dueTimeForBackgroundProcessing.Value <= Now; + if (needToProcessQueue) + _dueTimeForBackgroundProcessing = null; + } + + if (needToPromoteTimers) + PromoteTimers(); + if (needToProcessQueue) + ExecuteJobsCore(); + UpdateOSTimer(); + } + + internal void PromoteTimers() + { + long currentTimeInTicks = Now; + try + { + List? timers = null; + long timersVersion = 0; + + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + if (_dueTimeFound && _dueTimeInMs - currentTimeInTicks <= 0) + { + timers = _timers; + timersVersion = _timersVersion; + } + } + } + + if (timers != null) + { + DispatcherTimer? timer = null; + int iTimer = 0; + + do + { + lock (InstanceLock) + { + timer = null; + + // If the timers collection changed while we are in the middle of + // looking for timers, start over. + if (timersVersion != _timersVersion) + { + timersVersion = _timersVersion; + iTimer = 0; + } + + while (iTimer < _timers.Count) + { + // WARNING: this is vulnerable to wrapping + if (timers[iTimer].DueTimeInMs - currentTimeInTicks <= 0) + { + // Remove this timer from our list. + // Do not increment the index. + timer = timers[iTimer]; + timers.RemoveAt(iTimer); + break; + } + else + { + iTimer++; + } + } + } + + // Now that we are outside of the lock, promote the timer. + if (timer != null) + { + timer.Promote(); + } + } while (timer != null); + } + } + finally + { + RescheduleTimers(); + } + } + + internal static List SnapshotTimersForUnitTests() => + s_uiThread!._timers.ToList(); +} diff --git a/src/Avalonia.Base/Threading/Dispatcher.cs b/src/Avalonia.Base/Threading/Dispatcher.cs index 571f782813..25a4a4ce2c 100644 --- a/src/Avalonia.Base/Threading/Dispatcher.cs +++ b/src/Avalonia.Base/Threading/Dispatcher.cs @@ -1,159 +1,121 @@ using System; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; using System.Threading; -using System.Threading.Tasks; using Avalonia.Platform; -namespace Avalonia.Threading +namespace Avalonia.Threading; + +/// +/// Provides services for managing work items on a thread. +/// +/// +/// In Avalonia, there is usually only a single in the application - +/// the one for the UI thread, retrieved via the property. +/// +public partial class Dispatcher : IDispatcher { - /// - /// Provides services for managing work items on a thread. - /// - /// - /// In Avalonia, there is usually only a single in the application - - /// the one for the UI thread, retrieved via the property. - /// - public class Dispatcher : IDispatcher + private IDispatcherImpl _impl; + internal object InstanceLock { get; } = new(); + private bool _hasShutdownFinished; + private IControlledDispatcherImpl? _controlledImpl; + private static Dispatcher? s_uiThread; + private IDispatcherImplWithPendingInput? _pendingInputImpl; + private IDispatcherImplWithExplicitBackgroundProcessing? _backgroundProcessingImpl; + + internal Dispatcher(IDispatcherImpl impl) { - private readonly JobRunner _jobRunner; - private IPlatformThreadingInterface? _platform; - - public static Dispatcher UIThread { get; } = - new Dispatcher(AvaloniaLocator.Current.GetService()); - - public Dispatcher(IPlatformThreadingInterface? platform) - { - _platform = platform; - _jobRunner = new JobRunner(platform); - - if (_platform != null) - { - _platform.Signaled += _jobRunner.RunJobs; - } - } - - /// - /// Checks that the current thread is the UI thread. - /// - public bool CheckAccess() => _platform?.CurrentThreadIsLoopThread ?? true; - - /// - /// Checks that the current thread is the UI thread and throws if not. - /// - /// - /// The current thread is not the UI thread. - /// - public void VerifyAccess() - { - if (!CheckAccess()) - throw new InvalidOperationException("Call from invalid thread"); - } - - /// - /// Runs the dispatcher's main loop. - /// - /// - /// A cancellation token used to exit the main loop. - /// - public void MainLoop(CancellationToken cancellationToken) - { - var platform = AvaloniaLocator.Current.GetRequiredService(); - cancellationToken.Register(() => platform.Signal(DispatcherPriority.Send)); - platform.RunLoop(cancellationToken); - } - - /// - /// Runs continuations pushed on the loop. - /// - public void RunJobs() - { - _jobRunner.RunJobs(null); - } - - /// - /// Use this method to ensure that more prioritized tasks are executed - /// - /// - public void RunJobs(DispatcherPriority minimumPriority) => _jobRunner.RunJobs(minimumPriority); - - /// - /// Use this method to check if there are more prioritized tasks - /// - /// - public bool HasJobsWithPriority(DispatcherPriority minimumPriority) => - _jobRunner.HasJobsWithPriority(minimumPriority); - - /// - public Task InvokeAsync(Action action, DispatcherPriority priority = default) - { - _ = action ?? throw new ArgumentNullException(nameof(action)); - return _jobRunner.InvokeAsync(action, priority); - } - - /// - public Task InvokeAsync(Func function, DispatcherPriority priority = default) - { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority); - } - - /// - public Task InvokeAsync(Func function, DispatcherPriority priority = default) - { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority).Unwrap(); - } + _impl = impl; + impl.Timer += OnOSTimer; + impl.Signaled += Signaled; + _controlledImpl = _impl as IControlledDispatcherImpl; + _pendingInputImpl = _impl as IDispatcherImplWithPendingInput; + _backgroundProcessingImpl = _impl as IDispatcherImplWithExplicitBackgroundProcessing; + if (_backgroundProcessingImpl != null) + _backgroundProcessingImpl.ReadyForBackgroundProcessing += OnReadyForExplicitBackgroundProcessing; + } + + public static Dispatcher UIThread => s_uiThread ??= CreateUIThreadDispatcher(); - /// - public Task InvokeAsync(Func> function, DispatcherPriority priority = default) + private static Dispatcher CreateUIThreadDispatcher() + { + var impl = AvaloniaLocator.Current.GetService(); + if (impl == null) { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority).Unwrap(); + var platformThreading = AvaloniaLocator.Current.GetService(); + if (platformThreading != null) + impl = new LegacyDispatcherImpl(platformThreading); + else + impl = new NullDispatcherImpl(); } + return new Dispatcher(impl); + } - /// - public void Post(Action action, DispatcherPriority priority = default) - { - _ = action ?? throw new ArgumentNullException(nameof(action)); - _jobRunner.Post(action, priority); - } + /// + /// Checks that the current thread is the UI thread. + /// + public bool CheckAccess() => _impl?.CurrentThreadIsLoopThread ?? true; - /// - public void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default) + /// + /// Checks that the current thread is the UI thread and throws if not. + /// + /// + /// The current thread is not the UI thread. + /// + public void VerifyAccess() + { + if (!CheckAccess()) { - _ = action ?? throw new ArgumentNullException(nameof(action)); - _jobRunner.Post(action, arg, priority); - } + // Used to inline VerifyAccess. + [DoesNotReturn] + [MethodImpl(MethodImplOptions.NoInlining)] + static void ThrowVerifyAccess() + => throw new InvalidOperationException("Call from invalid thread"); - /// - /// This is needed for platform backends that don't have internal priority system (e. g. win32) - /// To ensure that there are no jobs with higher priority - /// - /// - internal void EnsurePriority(DispatcherPriority currentPriority) - { - if (currentPriority == DispatcherPriority.MaxValue) - return; - currentPriority += 1; - _jobRunner.RunJobs(currentPriority); + ThrowVerifyAccess(); } + } - /// - /// Allows unit tests to change the platform threading interface. - /// - internal void UpdateServices() + internal void Shutdown() + { + DispatcherOperation? operation = null; + _impl.Timer -= PromoteTimers; + _impl.Signaled -= Signaled; + do { - if (_platform != null) + lock(InstanceLock) { - _platform.Signaled -= _jobRunner.RunJobs; + if(_queue.MaxPriority != DispatcherPriority.Invalid) + { + operation = _queue.Peek(); + } + else + { + operation = null; + } } - _platform = AvaloniaLocator.Current.GetService(); - _jobRunner.UpdateServices(); - - if (_platform != null) + if(operation != null) { - _platform.Signaled += _jobRunner.RunJobs; + operation.Abort(); } - } + } while(operation != null); + _impl.UpdateTimer(null); + _hasShutdownFinished = true; + } + + /// + /// Runs the dispatcher's main loop. + /// + /// + /// A cancellation token used to exit the main loop. + /// + public void MainLoop(CancellationToken cancellationToken) + { + if (_controlledImpl == null) + throw new PlatformNotSupportedException(); + cancellationToken.Register(() => RequestProcessing()); + _controlledImpl.RunLoop(cancellationToken); } } diff --git a/src/Avalonia.Base/Threading/DispatcherOperation.cs b/src/Avalonia.Base/Threading/DispatcherOperation.cs new file mode 100644 index 0000000000..173ab81ef8 --- /dev/null +++ b/src/Avalonia.Base/Threading/DispatcherOperation.cs @@ -0,0 +1,308 @@ +using System; +using System.ComponentModel; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Threading.Tasks; + +namespace Avalonia.Threading; + +public class DispatcherOperation +{ + protected readonly bool ThrowOnUiThread; + public DispatcherOperationStatus Status { get; protected set; } + public Dispatcher Dispatcher { get; } + + public DispatcherPriority Priority + { + get => _priority; + set + { + _priority = value; + // Dispatcher is null in ctor + // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract + Dispatcher?.SetPriority(this, value); + } + } + + protected object? Callback; + protected object? TaskSource; + + internal DispatcherOperation? SequentialPrev { get; set; } + internal DispatcherOperation? SequentialNext { get; set; } + internal DispatcherOperation? PriorityPrev { get; set; } + internal DispatcherOperation? PriorityNext { get; set; } + internal PriorityChain? Chain { get; set; } + + internal bool IsQueued => Chain != null; + + private EventHandler? _aborted; + private EventHandler? _completed; + private DispatcherPriority _priority; + + internal DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Action callback, bool throwOnUiThread) : + this(dispatcher, priority, throwOnUiThread) + { + Callback = callback; + } + + private protected DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, bool throwOnUiThread) + { + ThrowOnUiThread = throwOnUiThread; + Priority = priority; + Dispatcher = dispatcher; + } + + /// + /// An event that is raised when the operation is aborted or canceled. + /// + public event EventHandler Aborted + { + add + { + lock (Dispatcher.InstanceLock) + { + _aborted += value; + } + } + + remove + { + lock(Dispatcher.InstanceLock) + { + _aborted -= value; + } + } + } + + /// + /// An event that is raised when the operation completes. + /// + /// + /// Completed indicates that the operation was invoked and has + /// either completed successfully or faulted. Note that a canceled + /// or aborted operation is never is never considered completed. + /// + public event EventHandler Completed + { + add + { + lock (Dispatcher.InstanceLock) + { + _completed += value; + } + } + + remove + { + lock(Dispatcher.InstanceLock) + { + _completed -= value; + } + } + } + + public void Abort() + { + lock (Dispatcher.InstanceLock) + { + if (Status == DispatcherOperationStatus.Pending) + return; + Dispatcher.Abort(this); + } + } + + public void Wait() + { + if (Dispatcher.CheckAccess()) + throw new InvalidOperationException("Wait is only supported on background thread"); + GetTask().Wait(); + } + + public Task GetTask() => GetTaskCore(); + + /// + /// Returns an awaiter for awaiting the completion of the operation. + /// + /// + /// This method is intended to be used by compilers. + /// + [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)] + public TaskAwaiter GetAwaiter() + { + return GetTask().GetAwaiter(); + } + + internal void DoAbort() + { + Status = DispatcherOperationStatus.Aborted; + AbortTask(); + _aborted?.Invoke(this, EventArgs.Empty); + } + + internal void Execute() + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Executing; + } + + try + { + InvokeCore(); + } + finally + { + _completed?.Invoke(this, EventArgs.Empty); + } + } + + protected virtual void InvokeCore() + { + try + { + ((Action)Callback!)(); + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetResult(null); + } + } + catch (Exception e) + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetException(e); + } + + if (ThrowOnUiThread) + throw; + } + } + + internal virtual object? GetResult() => null; + + protected virtual void AbortTask() => (TaskSource as TaskCompletionSource)?.SetCanceled(); + + private static CancellationToken CreateCancelledToken() + { + var cts = new CancellationTokenSource(); + cts.Cancel(); + return cts.Token; + } + + private static readonly Task s_abortedTask = Task.FromCanceled(CreateCancelledToken()); + + protected virtual Task GetTaskCore() + { + lock (Dispatcher.InstanceLock) + { + if (Status == DispatcherOperationStatus.Aborted) + return s_abortedTask; + if (Status == DispatcherOperationStatus.Completed) + return Task.CompletedTask; + if (TaskSource is not TaskCompletionSource tcs) + TaskSource = tcs = new(TaskCreationOptions.RunContinuationsAsynchronously); + return tcs.Task; + } + } +} + +public class DispatcherOperation : DispatcherOperation +{ + public DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Func callback) : base(dispatcher, priority, false) + { + TaskSource = new TaskCompletionSource(); + Callback = callback; + } + + private TaskCompletionSource TaskCompletionSource => (TaskCompletionSource)TaskSource!; + + public new Task GetTask() => TaskCompletionSource!.Task; + + protected override Task GetTaskCore() => GetTask(); + + protected override void AbortTask() => TaskCompletionSource.SetCanceled(); + + internal override object? GetResult() => GetTask().Result; + + protected override void InvokeCore() + { + try + { + var result = ((Func)Callback!)(); + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + TaskCompletionSource.SetResult(result); + } + } + catch (Exception e) + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + TaskCompletionSource.SetException(e); + } + } + } + + public T Result + { + get + { + if (TaskCompletionSource.Task.IsCompleted || !Dispatcher.CheckAccess()) + return TaskCompletionSource.Task.GetAwaiter().GetResult(); + throw new InvalidOperationException("Synchronous wait is only supported on non-UI threads"); + } + } +} + +internal class SendOrPostCallbackDispatcherOperation : DispatcherOperation +{ + private readonly object? _arg; + + internal SendOrPostCallbackDispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, + SendOrPostCallback callback, object? arg, bool throwOnUiThread) + : base(dispatcher, priority, throwOnUiThread) + { + Callback = callback; + _arg = arg; + } + + protected override void InvokeCore() + { + try + { + ((SendOrPostCallback)Callback!)(_arg); + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetResult(null); + } + } + catch (Exception e) + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetException(e); + } + + if (ThrowOnUiThread) + throw; + } + } +} + +public enum DispatcherOperationStatus +{ + Pending = 0, + Aborted = 1, + Completed = 2, + Executing = 3, +} diff --git a/src/Avalonia.Base/Threading/DispatcherPriority.cs b/src/Avalonia.Base/Threading/DispatcherPriority.cs index b3194e249b..a71140d288 100644 --- a/src/Avalonia.Base/Threading/DispatcherPriority.cs +++ b/src/Avalonia.Base/Threading/DispatcherPriority.cs @@ -18,44 +18,62 @@ namespace Avalonia.Threading } /// - /// Minimum possible priority + /// The lowest foreground dispatcher priority /// - public static readonly DispatcherPriority MinValue = new(0); - + internal static readonly DispatcherPriority Default = new(0); + /// - /// The job will be processed when the system is idle. + /// The job will be processed with the same priority as input. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority SystemIdle = MinValue; - + public static readonly DispatcherPriority Input = new(Default - 1); + /// - /// The job will be processed when the application is idle. + /// The job will be processed after other non-idle operations have completed. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ApplicationIdle = MinValue; - + public static readonly DispatcherPriority Background = new(Input - 1); + /// /// The job will be processed after background operations have completed. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ContextIdle = MinValue; - + public static readonly DispatcherPriority ContextIdle = new(Background - 1); + + /// - /// The job will be processed with normal priority. + /// The job will be processed when the application is idle. /// - public static readonly DispatcherPriority Normal = MinValue; - + public static readonly DispatcherPriority ApplicationIdle = new (ContextIdle - 1); + /// - /// The job will be processed after other non-idle operations have completed. + /// The job will be processed when the system is idle. /// - public static readonly DispatcherPriority Background = new(MinValue + 1); + public static readonly DispatcherPriority SystemIdle = new(ApplicationIdle - 1); /// - /// The job will be processed with the same priority as input. + /// Minimum possible priority that's actually dispatched, default value /// - public static readonly DispatcherPriority Input = new(Background + 1); + internal static readonly DispatcherPriority MinimumActiveValue = new(SystemIdle); + + /// + /// A dispatcher priority for jobs that shouldn't be executed yet + /// + public static readonly DispatcherPriority Inactive = new(MinimumActiveValue - 1); + + /// + /// Minimum valid priority + /// + internal static readonly DispatcherPriority MinValue = new(Inactive); + + /// + /// Used internally in dispatcher code + /// + public static readonly DispatcherPriority Invalid = new(MinimumActiveValue - 2); + + /// /// The job will be processed after layout and render but before input. /// - public static readonly DispatcherPriority Loaded = new(Input + 1); + public static readonly DispatcherPriority Loaded = new(Default + 1); /// /// The job will be processed with the same priority as render. @@ -80,12 +98,19 @@ namespace Avalonia.Threading /// /// The job will be processed with the same priority as data binding. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority DataBind = MinValue; + [Obsolete("WPF compatibility")] public static readonly DispatcherPriority DataBind = new(Layout); + + /// + /// The job will be processed with normal priority. + /// +#pragma warning disable CS0618 + public static readonly DispatcherPriority Normal = new(DataBind + 1); +#pragma warning restore CS0618 /// /// The job will be processed before other asynchronous operations. /// - public static readonly DispatcherPriority Send = new(Layout + 1); + public static readonly DispatcherPriority Send = new(Normal + 1); /// /// Maximum possible priority @@ -127,5 +152,48 @@ namespace Avalonia.Threading /// public int CompareTo(DispatcherPriority other) => Value.CompareTo(other.Value); + + public static void Validate(DispatcherPriority priority, string parameterName) + { + if (priority < Inactive || priority > MaxValue) + throw new ArgumentException("Invalid DispatcherPriority value", parameterName); + } + +#pragma warning disable CS0618 + public override string ToString() + { + if (this == Invalid) + return nameof(Invalid); + if (this == Inactive) + return nameof(Inactive); + if (this == SystemIdle) + return nameof(SystemIdle); + if (this == ContextIdle) + return nameof(ContextIdle); + if (this == ApplicationIdle) + return nameof(ApplicationIdle); + if (this == Background) + return nameof(Background); + if (this == Input) + return nameof(Input); + if (this == Default) + return nameof(Default); + if (this == Loaded) + return nameof(Loaded); + if (this == Render) + return nameof(Render); + if (this == Composition) + return nameof(Composition); + if (this == PreComposition) + return nameof(PreComposition); + if (this == DataBind) + return nameof(DataBind); + if (this == Normal) + return nameof(Normal); + if (this == Send) + return nameof(Send); + return Value.ToString(); + } +#pragma warning restore CS0618 } } diff --git a/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs b/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs new file mode 100644 index 0000000000..524b4fab8d --- /dev/null +++ b/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs @@ -0,0 +1,418 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using Avalonia.Threading; + +namespace Avalonia.Threading; + + +internal class DispatcherPriorityQueue +{ + // Priority chains... + private readonly SortedList _priorityChains; // NOTE: should be Priority + private readonly Stack _cacheReusableChains; + + // Sequential chain... + private DispatcherOperation? _head; + private DispatcherOperation? _tail; + + public DispatcherPriorityQueue() + { + // Build the collection of priority chains. + _priorityChains = new SortedList(); // NOTE: should be Priority + _cacheReusableChains = new Stack(10); + + _head = _tail = null; + } + + // NOTE: not used + // public int Count {get{return _count;}} + + public DispatcherPriority MaxPriority // NOTE: should be Priority + { + get + { + int count = _priorityChains.Count; + + if (count > 0) + { + return _priorityChains.Keys[count - 1]; + } + else + { + return DispatcherPriority.Invalid; // NOTE: should be Priority.Invalid; + } + } + } + + public DispatcherOperation Enqueue(DispatcherPriority priority, DispatcherOperation item) // NOTE: should be Priority + { + // Find the existing chain for this priority, or create a new one + // if one does not exist. + PriorityChain chain = GetChain(priority); + + // Step 1: Append this to the end of the "sequential" linked list. + InsertItemInSequentialChain(item, _tail); + + // Step 2: Append the item into the priority chain. + InsertItemInPriorityChain(item, chain, chain.Tail); + + return item; + } + + public DispatcherOperation Dequeue() + { + // Get the max-priority chain. + int count = _priorityChains.Count; + if (count > 0) + { + PriorityChain chain = _priorityChains.Values[count - 1]; + Debug.Assert(chain != null, "PriorityQueue.Dequeue: a chain should exist."); + + DispatcherOperation? item = chain.Head; + Debug.Assert(item != null, "PriorityQueue.Dequeue: a priority item should exist."); + + RemoveItem(item); + + return item; + } + else + { + throw new InvalidOperationException(); + } + } + + public DispatcherOperation? Peek() + { + // Get the max-priority chain. + int count = _priorityChains.Count; + if (count > 0) + { + PriorityChain chain = _priorityChains.Values[count - 1]; + Debug.Assert(chain != null, "PriorityQueue.Peek: a chain should exist."); + + DispatcherOperation? item = chain.Head; + Debug.Assert(item != null, "PriorityQueue.Peek: a priority item should exist."); + + return item; + } + + return null; + } + + public void RemoveItem(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItem: invalid item."); + Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItem: a chain should exist."); + + // Step 1: Remove the item from its priority chain. + RemoveItemFromPriorityChain(item); + + // Step 2: Remove the item from the sequential chain. + RemoveItemFromSequentialChain(item); + } + + public void ChangeItemPriority(DispatcherOperation item, DispatcherPriority priority) // NOTE: should be Priority + { + // Remove the item from its current priority and insert it into + // the new priority chain. Note that this does not change the + // sequential ordering. + + // Step 1: Remove the item from the priority chain. + RemoveItemFromPriorityChain(item); + + // Step 2: Insert the item into the new priority chain. + // Find the existing chain for this priority, or create a new one + // if one does not exist. + PriorityChain chain = GetChain(priority); + InsertItemInPriorityChain(item, chain); + } + + private PriorityChain GetChain(DispatcherPriority priority) // NOTE: should be Priority + { + PriorityChain? chain = null; + + int count = _priorityChains.Count; + if (count > 0) + { + if (priority == _priorityChains.Keys[0]) + { + chain = _priorityChains.Values[0]; + } + else if (priority == _priorityChains.Keys[count - 1]) + { + chain = _priorityChains.Values[count - 1]; + } + else if ((priority > _priorityChains.Keys[0]) && + (priority < _priorityChains.Keys[count - 1])) + { + _priorityChains.TryGetValue(priority, out chain); + } + } + + if (chain == null) + { + if (_cacheReusableChains.Count > 0) + { + chain = _cacheReusableChains.Pop(); + chain.Priority = priority; + } + else + { + chain = new PriorityChain(priority); + } + + _priorityChains.Add(priority, chain); + } + + return chain; + } + + private void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain) + { + // Scan along the sequential chain, in the previous direction, + // looking for an item that is already in the new chain. We will + // insert ourselves after the item we found. We can short-circuit + // this search if the new chain is empty. + if (chain.Head == null) + { + Debug.Assert(chain.Tail == null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null."); + InsertItemInPriorityChain(item, chain, null); + } + else + { + Debug.Assert(chain.Tail != null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null."); + + DispatcherOperation? after; + + // Search backwards along the sequential chain looking for an + // item already in this list. + for (after = item.SequentialPrev; after != null; after = after.SequentialPrev) + { + if (after.Chain == chain) + { + break; + } + } + + InsertItemInPriorityChain(item, chain, after); + } + } + + internal void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain, DispatcherOperation? after) + { + Debug.Assert(chain != null, "PriorityQueue.InsertItemInPriorityChain: a chain must be provided."); + Debug.Assert(item.Chain == null && item.PriorityPrev == null && item.PriorityNext == null, + "PriorityQueue.InsertItemInPriorityChain: item must not already be in a priority chain."); + + item.Chain = chain; + + if (after == null) + { + // Note: passing null for after means insert at the head. + + if (chain.Head != null) + { + Debug.Assert(chain.Tail != null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null."); + + chain.Head.PriorityPrev = item; + item.PriorityNext = chain.Head; + chain.Head = item; + } + else + { + Debug.Assert(chain.Tail == null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null."); + + chain.Head = chain.Tail = item; + } + } + else + { + item.PriorityPrev = after; + + if (after.PriorityNext != null) + { + item.PriorityNext = after.PriorityNext; + after.PriorityNext.PriorityPrev = item; + after.PriorityNext = item; + } + else + { + Debug.Assert(item.Chain.Tail == after, + "PriorityQueue.InsertItemInPriorityChain: the chain's tail should be the item we are inserting after."); + after.PriorityNext = item; + chain.Tail = item; + } + } + + chain.Count++; + } + + private void RemoveItemFromPriorityChain(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItemFromPriorityChain: invalid item."); + Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItemFromPriorityChain: a chain should exist."); + + // Step 1: Fix up the previous link + if (item.PriorityPrev != null) + { + Debug.Assert(item.Chain.Head != item, + "PriorityQueue.RemoveItemFromPriorityChain: the head should not point to this item."); + + item.PriorityPrev.PriorityNext = item.PriorityNext; + } + else + { + Debug.Assert(item.Chain.Head == item, + "PriorityQueue.RemoveItemFromPriorityChain: the head should point to this item."); + + item.Chain.Head = item.PriorityNext; + } + + // Step 2: Fix up the next link + if (item.PriorityNext != null) + { + Debug.Assert(item.Chain.Tail != item, + "PriorityQueue.RemoveItemFromPriorityChain: the tail should not point to this item."); + + item.PriorityNext.PriorityPrev = item.PriorityPrev; + } + else + { + Debug.Assert(item.Chain.Tail == item, + "PriorityQueue.RemoveItemFromPriorityChain: the tail should point to this item."); + + item.Chain.Tail = item.PriorityPrev; + } + + // Step 3: cleanup + item.PriorityPrev = item.PriorityNext = null; + item.Chain.Count--; + if (item.Chain.Count == 0) + { + if (item.Chain.Priority == _priorityChains.Keys[_priorityChains.Count - 1]) + { + _priorityChains.RemoveAt(_priorityChains.Count - 1); + } + else + { + _priorityChains.Remove(item.Chain.Priority); + } + + if (_cacheReusableChains.Count < 10) + { + item.Chain.Priority = DispatcherPriority.Invalid; + _cacheReusableChains.Push(item.Chain); + } + } + + item.Chain = null; + } + + internal void InsertItemInSequentialChain(DispatcherOperation item, DispatcherOperation? after) + { + Debug.Assert(item.SequentialPrev == null && item.SequentialNext == null, + "PriorityQueue.InsertItemInSequentialChain: item must not already be in the sequential chain."); + + if (after == null) + { + // Note: passing null for after means insert at the head. + + if (_head != null) + { + Debug.Assert(_tail != null, + "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should not be null."); + + _head.SequentialPrev = item; + item.SequentialNext = _head; + _head = item; + } + else + { + Debug.Assert(_tail == null, + "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should be null."); + + _head = _tail = item; + } + } + else + { + item.SequentialPrev = after; + + if (after.SequentialNext != null) + { + item.SequentialNext = after.SequentialNext; + after.SequentialNext.SequentialPrev = item; + after.SequentialNext = item; + } + else + { + Debug.Assert(_tail == after, + "PriorityQueue.InsertItemInSequentialChain: the tail should be the item we are inserting after."); + after.SequentialNext = item; + _tail = item; + } + } + } + + private void RemoveItemFromSequentialChain(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItemFromSequentialChain: invalid item."); + + // Step 1: Fix up the previous link + if (item.SequentialPrev != null) + { + Debug.Assert(_head != item, + "PriorityQueue.RemoveItemFromSequentialChain: the head should not point to this item."); + + item.SequentialPrev.SequentialNext = item.SequentialNext; + } + else + { + Debug.Assert(_head == item, + "PriorityQueue.RemoveItemFromSequentialChain: the head should point to this item."); + + _head = item.SequentialNext; + } + + // Step 2: Fix up the next link + if (item.SequentialNext != null) + { + Debug.Assert(_tail != item, + "PriorityQueue.RemoveItemFromSequentialChain: the tail should not point to this item."); + + item.SequentialNext.SequentialPrev = item.SequentialPrev; + } + else + { + Debug.Assert(_tail == item, + "PriorityQueue.RemoveItemFromSequentialChain: the tail should point to this item."); + + _tail = item.SequentialPrev; + } + + // Step 3: cleanup + item.SequentialPrev = item.SequentialNext = null; + } +} + + +internal class PriorityChain +{ + public PriorityChain(DispatcherPriority priority) // NOTE: should be Priority + { + Priority = priority; + } + + public DispatcherPriority Priority { get; set; } // NOTE: should be Priority + + public int Count { get; set; } + + public DispatcherOperation? Head { get; set; } + + public DispatcherOperation? Tail { get; set; } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/DispatcherTimer.cs b/src/Avalonia.Base/Threading/DispatcherTimer.cs index f81229eb48..879d9d8a5f 100644 --- a/src/Avalonia.Base/Threading/DispatcherTimer.cs +++ b/src/Avalonia.Base/Threading/DispatcherTimer.cs @@ -1,207 +1,352 @@ using System; using Avalonia.Reactive; -using Avalonia.Platform; -namespace Avalonia.Threading +namespace Avalonia.Threading; + +/// +/// A timer that is integrated into the Dispatcher queues, and will +/// be processed after a given amount of time at a specified priority. +/// +public partial class DispatcherTimer { /// - /// A timer that uses a to fire at a specified interval. + /// Creates a timer that uses theUI thread's Dispatcher2 to + /// process the timer event at background priority. /// - public class DispatcherTimer + public DispatcherTimer() : this(DispatcherPriority.Background) { - private IDisposable? _timer; + } - private readonly DispatcherPriority _priority; + /// + /// Creates a timer that uses the UI thread's Dispatcher2 to + /// process the timer event at the specified priority. + /// + /// + /// The priority to process the timer at. + /// + public DispatcherTimer(DispatcherPriority priority) : this(Threading.Dispatcher.UIThread, priority, + TimeSpan.FromMilliseconds(0)) + { + } - private TimeSpan _interval; + /// + /// Creates a timer that uses the specified Dispatcher2 to + /// process the timer event at the specified priority. + /// + /// + /// The priority to process the timer at. + /// + /// + /// The dispatcher to use to process the timer. + /// + internal DispatcherTimer(DispatcherPriority priority, Dispatcher dispatcher) : this(dispatcher, priority, + TimeSpan.FromMilliseconds(0)) + { + } - /// - /// Initializes a new instance of the class. - /// - public DispatcherTimer() : this(DispatcherPriority.Background) + /// + /// Creates a timer that uses the UI thread's Dispatcher2 to + /// process the timer event at the specified priority after the specified timeout. + /// + /// + /// The interval to tick the timer after. + /// + /// + /// The priority to process the timer at. + /// + /// + /// The callback to call when the timer ticks. + /// + public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback) + : this(Threading.Dispatcher.UIThread, priority, interval) + { + if (callback == null) { + throw new ArgumentNullException("callback"); } - /// - /// Initializes a new instance of the class. - /// - /// The priority to use. - public DispatcherTimer(DispatcherPriority priority) - { - _priority = priority; - } + Tick += callback; + Start(); + } - /// - /// Initializes a new instance of the class. - /// - /// The interval at which to tick. - /// The priority to use. - /// The event to call when the timer ticks. - public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback) : this(priority) - { - _priority = priority; - Interval = interval; - Tick += callback; - } + /// + /// Gets the dispatcher this timer is associated with. + /// + public Dispatcher Dispatcher + { + get { return _dispatcher; } + } - /// - /// Finalizes an instance of the class. - /// - ~DispatcherTimer() + /// + /// Gets or sets whether the timer is running. + /// + public bool IsEnabled + { + get { return _isEnabled; } + + set { - if (_timer != null) + lock (_instanceLock) { - Stop(); + if (!value && _isEnabled) + { + Stop(); + } + else if (value && !_isEnabled) + { + Start(); + } } } + } - /// - /// Raised when the timer ticks. - /// - public event EventHandler? Tick; + /// + /// Gets or sets the time between timer ticks. + /// + public TimeSpan Interval + { + get { return _interval; } - /// - /// Gets or sets the interval at which the timer ticks. - /// - public TimeSpan Interval + set { - get + bool updateOSTimer = false; + + if (value.TotalMilliseconds < 0) + throw new ArgumentOutOfRangeException("value", + "TimeSpan period must be greater than or equal to zero."); + + if (value.TotalMilliseconds > Int32.MaxValue) + throw new ArgumentOutOfRangeException("value", + "TimeSpan period must be less than or equal to Int32.MaxValue."); + + lock (_instanceLock) { - return _interval; + _interval = value; + + if (_isEnabled) + { + DueTimeInMs = _dispatcher.Now + (long)_interval.TotalMilliseconds; + updateOSTimer = true; + } } - set + if (updateOSTimer) { - bool enabled = IsEnabled; - Stop(); - _interval = value; - IsEnabled = enabled; + _dispatcher.RescheduleTimers(); } } + } - /// - /// Gets or sets a value indicating whether the timer is running. - /// - public bool IsEnabled + /// + /// Starts the timer. + /// + public void Start() + { + lock (_instanceLock) { - get + if (!_isEnabled) { - return _timer != null; + _isEnabled = true; + + Restart(); } + } + } - set + /// + /// Stops the timer. + /// + public void Stop() + { + bool updateOSTimer = false; + + lock (_instanceLock) + { + if (_isEnabled) { - if (IsEnabled != value) + _isEnabled = false; + updateOSTimer = true; + + // If the operation is in the queue, abort it. + if (_operation != null) { - if (value) - { - Start(); - } - else - { - Stop(); - } + _operation.Abort(); + _operation = null; } } } - /// - /// Gets or sets user-defined data associated with the timer. - /// - public object? Tag + if (updateOSTimer) { - get; - set; + _dispatcher.RemoveTimer(this); } + } + + /// + /// Starts a new timer. + /// + /// + /// The method to call on timer tick. If the method returns false, the timer will stop. + /// + /// The interval at which to tick. + /// The priority to use. + /// An used to cancel the timer. + public static IDisposable Run(Func action, TimeSpan interval, DispatcherPriority priority = default) + { + var timer = new DispatcherTimer(priority) { Interval = interval }; - /// - /// Starts a new timer. - /// - /// - /// The method to call on timer tick. If the method returns false, the timer will stop. - /// - /// The interval at which to tick. - /// The priority to use. - /// An used to cancel the timer. - public static IDisposable Run(Func action, TimeSpan interval, DispatcherPriority priority = default) + timer.Tick += (s, e) => { - var timer = new DispatcherTimer(priority) { Interval = interval }; - - timer.Tick += (s, e) => + if (!action()) { - if (!action()) - { - timer.Stop(); - } - }; + timer.Stop(); + } + }; - timer.Start(); + timer.Start(); - return Disposable.Create(() => timer.Stop()); - } + return Disposable.Create(() => timer.Stop()); + } + + /// + /// Runs a method once, after the specified interval. + /// + /// + /// The method to call after the interval has elapsed. + /// + /// The interval after which to call the method. + /// The priority to use. + /// An used to cancel the timer. + public static IDisposable RunOnce( + Action action, + TimeSpan interval, + DispatcherPriority priority = default) + { + interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1); + + var timer = new DispatcherTimer(priority) { Interval = interval }; - /// - /// Runs a method once, after the specified interval. - /// - /// - /// The method to call after the interval has elapsed. - /// - /// The interval after which to call the method. - /// The priority to use. - /// An used to cancel the timer. - public static IDisposable RunOnce( - Action action, - TimeSpan interval, - DispatcherPriority priority = default) + timer.Tick += (s, e) => { - interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1); - - var timer = new DispatcherTimer(priority) { Interval = interval }; + action(); + timer.Stop(); + }; + + timer.Start(); + + return Disposable.Create(() => timer.Stop()); + } + + /// + /// Occurs when the specified timer interval has elapsed and the + /// timer is enabled. + /// + public event EventHandler? Tick; + + /// + /// Any data that the caller wants to pass along with the timer. + /// + public object? Tag { get; set; } - timer.Tick += (s, e) => - { - action(); - timer.Stop(); - }; - timer.Start(); + internal DispatcherTimer(Dispatcher dispatcher, DispatcherPriority priority, TimeSpan interval) + { + if (dispatcher == null) + { + throw new ArgumentNullException("dispatcher"); + } - return Disposable.Create(() => timer.Stop()); + DispatcherPriority.Validate(priority, "priority"); + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("Specified priority is not valid.", "priority"); } - /// - /// Starts the timer. - /// - public void Start() + if (interval.TotalMilliseconds < 0) + throw new ArgumentOutOfRangeException("interval", "TimeSpan period must be greater than or equal to zero."); + + if (interval.TotalMilliseconds > Int32.MaxValue) + throw new ArgumentOutOfRangeException("interval", + "TimeSpan period must be less than or equal to Int32.MaxValue."); + + + _dispatcher = dispatcher; + _priority = priority; + _interval = interval; + } + + private void Restart() + { + lock (_instanceLock) { - if (!IsEnabled) + if (_operation != null) { - var threading = AvaloniaLocator.Current.GetRequiredService(); - _timer = threading.StartTimer(_priority, Interval, InternalTick); + // Timer has already been restarted, e.g. Start was called form the Tick handler. + return; + } + + // BeginInvoke a new operation. + _operation = _dispatcher.InvokeAsync(FireTick, DispatcherPriority.Inactive); + + DueTimeInMs = _dispatcher.Now + (long)_interval.TotalMilliseconds; + + if (_interval.TotalMilliseconds == 0 && _dispatcher.CheckAccess()) + { + // shortcut - just promote the item now + Promote(); + } + else + { + _dispatcher.AddTimer(this); } } + } - /// - /// Stops the timer. - /// - public void Stop() + internal void Promote() // called from Dispatcher + { + lock (_instanceLock) { - if (IsEnabled) + // Simply promote the operation to it's desired priority. + if (_operation != null) { - _timer!.Dispose(); - _timer = null; + _operation.Priority = _priority; } } + } + private void FireTick() + { + // The operation has been invoked, so forget about it. + _operation = null; + // The dispatcher thread is calling us because item's priority + // was changed from inactive to something else. + if (Tick != null) + { + Tick(this, EventArgs.Empty); + } - /// - /// Raises the event on the dispatcher thread. - /// - private void InternalTick() + // If we are still enabled, start the timer again. + if (_isEnabled) { - Dispatcher.UIThread.EnsurePriority(_priority); - Tick?.Invoke(this, EventArgs.Empty); + Restart(); } } -} + + // This is the object we use to synchronize access. + private object _instanceLock = new object(); + + // Note: We cannot BE a dispatcher-affinity object because we can be + // created by a worker thread. We are still associated with a + // dispatcher (where we post the item) but we can be accessed + // by any thread. + private Dispatcher _dispatcher; + + private DispatcherPriority _priority; // NOTE: should be Priority + private TimeSpan _interval; + private DispatcherOperation? _operation; + private bool _isEnabled; + + // used by Dispatcher + internal long DueTimeInMs { get; private set; } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/IDispatcher.cs b/src/Avalonia.Base/Threading/IDispatcher.cs index 1c700132b7..e2a3115f9c 100644 --- a/src/Avalonia.Base/Threading/IDispatcher.cs +++ b/src/Avalonia.Base/Threading/IDispatcher.cs @@ -26,30 +26,5 @@ namespace Avalonia.Threading /// The method. /// The priority with which to invoke the method. void Post(Action action, DispatcherPriority priority = default); - - /// - /// Posts an action that will be invoked on the dispatcher thread. - /// - /// The method. - /// The argument of method to call. - /// The priority with which to invoke the method. - void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default); - - /// - /// Invokes a action on the dispatcher thread. - /// - /// The method. - /// The priority with which to invoke the method. - /// A task that can be used to track the method's execution. - Task InvokeAsync(Action action, DispatcherPriority priority = default); - - /// - /// Queues the specified work to run on the dispatcher thread and returns a proxy for the - /// task returned by . - /// - /// The work to execute asynchronously. - /// The priority with which to invoke the method. - /// A task that represents a proxy for the task returned by . - Task InvokeAsync(Func function, DispatcherPriority priority = default); } } diff --git a/src/Avalonia.Base/Threading/IDispatcherImpl.cs b/src/Avalonia.Base/Threading/IDispatcherImpl.cs new file mode 100644 index 0000000000..4c30e2eb2c --- /dev/null +++ b/src/Avalonia.Base/Threading/IDispatcherImpl.cs @@ -0,0 +1,103 @@ +using System; +using System.Diagnostics; +using System.Threading; +using Avalonia.Metadata; +using Avalonia.Platform; + +namespace Avalonia.Threading; + +[Unstable] +public interface IDispatcherImpl +{ + bool CurrentThreadIsLoopThread { get; } + + // Asynchronously triggers Signaled callback + void Signal(); + event Action Signaled; + event Action Timer; + long Now { get; } + void UpdateTimer(long? dueTimeInMs); +} + +[Unstable] +public interface IDispatcherImplWithPendingInput : IDispatcherImpl +{ + // Checks if dispatcher implementation can + bool CanQueryPendingInput { get; } + // Checks if there is pending user input + bool HasPendingInput { get; } +} + +[Unstable] +public interface IDispatcherImplWithExplicitBackgroundProcessing : IDispatcherImpl +{ + event Action ReadyForBackgroundProcessing; + void RequestBackgroundProcessing(); +} + +[Unstable] +public interface IControlledDispatcherImpl : IDispatcherImplWithPendingInput +{ + // Runs the event loop + void RunLoop(CancellationToken token); +} + +internal class LegacyDispatcherImpl : IDispatcherImpl +{ + private readonly IPlatformThreadingInterface _platformThreading; + private IDisposable? _timer; + private Stopwatch _clock = Stopwatch.StartNew(); + + public LegacyDispatcherImpl(IPlatformThreadingInterface platformThreading) + { + _platformThreading = platformThreading; + _platformThreading.Signaled += delegate { Signaled?.Invoke(); }; + } + + public bool CurrentThreadIsLoopThread => _platformThreading.CurrentThreadIsLoopThread; + public void Signal() => _platformThreading.Signal(DispatcherPriority.Send); + + public event Action? Signaled; + public event Action? Timer; + public long Now => _clock.ElapsedMilliseconds; + public void UpdateTimer(long? dueTimeInMs) + { + _timer?.Dispose(); + _timer = null; + + if (dueTimeInMs.HasValue) + { + var interval = Math.Max(1, dueTimeInMs.Value - _clock.ElapsedMilliseconds); + _timer = _platformThreading.StartTimer(DispatcherPriority.Send, + TimeSpan.FromMilliseconds(interval), + OnTick); + } + } + + private void OnTick() + { + _timer?.Dispose(); + _timer = null; + Timer?.Invoke(); + } +} + +class NullDispatcherImpl : IDispatcherImpl +{ + public bool CurrentThreadIsLoopThread => true; + + public void Signal() + { + + } + + public event Action? Signaled; + public event Action? Timer; + + public long Now => 0; + + public void UpdateTimer(long? dueTimeInMs) + { + + } +} diff --git a/src/Avalonia.Base/Threading/JobRunner.cs b/src/Avalonia.Base/Threading/JobRunner.cs deleted file mode 100644 index ced3423c27..0000000000 --- a/src/Avalonia.Base/Threading/JobRunner.cs +++ /dev/null @@ -1,300 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading; -using System.Threading.Tasks; -using Avalonia.Platform; - -namespace Avalonia.Threading -{ - /// - /// A main loop in a . - /// - internal class JobRunner - { - private IPlatformThreadingInterface? _platform; - - private readonly Queue[] _queues = Enumerable.Range(0, (int)DispatcherPriority.MaxValue + 1) - .Select(_ => new Queue()).ToArray(); - - public JobRunner(IPlatformThreadingInterface? platform) - { - _platform = platform; - } - - /// - /// Runs continuations pushed on the loop. - /// - /// Priority to execute jobs for. Pass null if platform doesn't have internal priority system - public void RunJobs(DispatcherPriority? priority) - { - var minimumPriority = priority ?? DispatcherPriority.MinValue; - while (true) - { - var job = GetNextJob(minimumPriority); - if (job == null) - return; - - job.Run(); - } - } - - /// - /// Invokes a method on the main loop. - /// - /// The method. - /// The priority with which to invoke the method. - /// A task that can be used to track the method's execution. - public Task InvokeAsync(Action action, DispatcherPriority priority) - { - var job = new Job(action, priority, false); - AddJob(job); - return job.Task!; - } - - /// - /// Invokes a method on the main loop. - /// - /// The method. - /// The priority with which to invoke the method. - /// A task that can be used to track the method's execution. - public Task InvokeAsync(Func function, DispatcherPriority priority) - { - var job = new JobWithResult(function, priority); - AddJob(job); - return job.Task; - } - - /// - /// Post action that will be invoked on main thread - /// - /// The method. - /// - /// The priority with which to invoke the method. - internal void Post(Action action, DispatcherPriority priority) - { - AddJob(new Job(action, priority, true)); - } - - /// - /// Post action that will be invoked on main thread - /// - /// The method to call. - /// The parameter of method to call. - /// The priority with which to invoke the method. - internal void Post(SendOrPostCallback action, object? parameter, DispatcherPriority priority) - { - AddJob(new JobWithArg(action, parameter, priority, true)); - } - - /// - /// Allows unit tests to change the platform threading interface. - /// - internal void UpdateServices() - { - _platform = AvaloniaLocator.Current.GetService(); - } - - private void AddJob(IJob job) - { - bool needWake; - var queue = _queues[(int)job.Priority]; - lock (queue) - { - needWake = queue.Count == 0; - queue.Enqueue(job); - } - if (needWake) - _platform?.Signal(job.Priority); - } - - private IJob? GetNextJob(DispatcherPriority minimumPriority) - { - for (int c = (int)DispatcherPriority.MaxValue; c >= (int)minimumPriority; c--) - { - var q = _queues[c]; - lock (q) - { - if (q.Count > 0) - return q.Dequeue(); - } - } - return null; - } - - public bool HasJobsWithPriority(DispatcherPriority minimumPriority) - { - for (int c = (int)minimumPriority; c < (int)DispatcherPriority.MaxValue; c++) - { - var q = _queues[c]; - lock (q) - { - if (q.Count > 0) - return true; - } - } - - return false; - } - - private interface IJob - { - /// - /// Gets the job priority. - /// - DispatcherPriority Priority { get; } - - /// - /// Runs the job. - /// - void Run(); - } - - /// - /// A job to run. - /// - private sealed class Job : IJob - { - /// - /// The method to call. - /// - private readonly Action _action; - /// - /// The task completion source. - /// - private readonly TaskCompletionSource? _taskCompletionSource; - - /// - /// Initializes a new instance of the class. - /// - /// The method to call. - /// The job priority. - /// Do not wrap exception in TaskCompletionSource - public Job(Action action, DispatcherPriority priority, bool throwOnUiThread) - { - _action = action; - Priority = priority; - _taskCompletionSource = throwOnUiThread ? null : new TaskCompletionSource(); - } - - /// - public DispatcherPriority Priority { get; } - - /// - /// The task. - /// - public Task? Task => _taskCompletionSource?.Task; - - /// - void IJob.Run() - { - if (_taskCompletionSource == null) - { - _action(); - return; - } - try - { - _action(); - _taskCompletionSource.SetResult(null); - } - catch (Exception e) - { - _taskCompletionSource.SetException(e); - } - } - } - - /// - /// A typed job to run. - /// - private sealed class JobWithArg : IJob - { - private readonly SendOrPostCallback _action; - private readonly object? _parameter; - private readonly TaskCompletionSource? _taskCompletionSource; - - /// - /// Initializes a new instance of the class. - /// - /// The method to call. - /// The parameter of method to call. - /// The job priority. - /// Do not wrap exception in TaskCompletionSource - - public JobWithArg(SendOrPostCallback action, object? parameter, DispatcherPriority priority, bool throwOnUiThread) - { - _action = action; - _parameter = parameter; - Priority = priority; - _taskCompletionSource = throwOnUiThread ? null : new TaskCompletionSource(); - } - - /// - public DispatcherPriority Priority { get; } - - /// - void IJob.Run() - { - if (_taskCompletionSource == null) - { - _action(_parameter); - return; - } - try - { - _action(_parameter); - _taskCompletionSource.SetResult(default); - } - catch (Exception e) - { - _taskCompletionSource.SetException(e); - } - } - } - - /// - /// A job to run thath return value. - /// - /// Type of job result - private sealed class JobWithResult : IJob - { - private readonly Func _function; - private readonly TaskCompletionSource _taskCompletionSource; - - /// - /// Initializes a new instance of the class. - /// - /// The method to call. - /// The job priority. - public JobWithResult(Func function, DispatcherPriority priority) - { - _function = function; - Priority = priority; - _taskCompletionSource = new TaskCompletionSource(); - } - - /// - public DispatcherPriority Priority { get; } - - /// - /// The task. - /// - public Task Task => _taskCompletionSource.Task; - - /// - void IJob.Run() - { - try - { - var result = _function(); - _taskCompletionSource.SetResult(result); - } - catch (Exception e) - { - _taskCompletionSource.SetException(e); - } - } - } - } -} diff --git a/src/Avalonia.Controls/Platform/InternalPlatformThreadingInterface.cs b/src/Avalonia.Controls/Platform/InternalPlatformThreadingInterface.cs deleted file mode 100644 index e1f6db9c60..0000000000 --- a/src/Avalonia.Controls/Platform/InternalPlatformThreadingInterface.cs +++ /dev/null @@ -1,92 +0,0 @@ -using System; -using System.Runtime.InteropServices; -using System.Threading; -using Avalonia.Metadata; -using Avalonia.Platform; -using Avalonia.Threading; - -namespace Avalonia.Controls.Platform -{ - [Unstable] - public class InternalPlatformThreadingInterface : IPlatformThreadingInterface - { - public InternalPlatformThreadingInterface() - { - TlsCurrentThreadIsLoopThread = true; - } - - private readonly AutoResetEvent _signaled = new AutoResetEvent(false); - - - public void RunLoop(CancellationToken cancellationToken) - { - var handles = new[] { _signaled, cancellationToken.WaitHandle }; - - while (!cancellationToken.IsCancellationRequested) - { - Signaled?.Invoke(null); - WaitHandle.WaitAny(handles); - } - } - - - class TimerImpl : IDisposable - { - private readonly DispatcherPriority _priority; - private readonly TimeSpan _interval; - private readonly Action _tick; - private Timer? _timer; - private GCHandle _handle; - - public TimerImpl(DispatcherPriority priority, TimeSpan interval, Action tick) - { - _priority = priority; - _interval = interval; - _tick = tick; - _timer = new Timer(OnTimer, null, interval, Timeout.InfiniteTimeSpan); - _handle = GCHandle.Alloc(_timer); - } - - private void OnTimer(object? state) - { - if (_timer == null) - return; - Dispatcher.UIThread.Post(() => - { - - if (_timer == null) - return; - _tick(); - _timer?.Change(_interval, Timeout.InfiniteTimeSpan); - }); - } - - - public void Dispose() - { - _handle.Free(); - _timer?.Dispose(); - _timer = null; - } - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - return new TimerImpl(priority, interval, tick); - } - - public void Signal(DispatcherPriority prio) - { - _signaled.Set(); - } - - [ThreadStatic] private static bool TlsCurrentThreadIsLoopThread; - - public bool CurrentThreadIsLoopThread => TlsCurrentThreadIsLoopThread; - public event Action? Signaled; -#pragma warning disable CS0067 - public event Action? Tick; -#pragma warning restore CS0067 - - } -} diff --git a/src/Avalonia.Controls/Platform/ManagedDispatcherImpl.cs b/src/Avalonia.Controls/Platform/ManagedDispatcherImpl.cs new file mode 100644 index 0000000000..20aa91c83e --- /dev/null +++ b/src/Avalonia.Controls/Platform/ManagedDispatcherImpl.cs @@ -0,0 +1,109 @@ +using System; +using System.Diagnostics; +using System.Threading; +using Avalonia.Metadata; +using Avalonia.Threading; + +namespace Avalonia.Controls.Platform; + +[Unstable] +public class ManagedDispatcherImpl : IControlledDispatcherImpl +{ + private readonly IManagedDispatcherInputProvider? _inputProvider; + private readonly AutoResetEvent _wakeup = new(false); + private bool _signaled; + private readonly object _lock = new(); + private readonly Stopwatch _clock = Stopwatch.StartNew(); + private TimeSpan? _nextTimer; + private readonly Thread _loopThread = Thread.CurrentThread; + + public interface IManagedDispatcherInputProvider + { + bool HasInput { get; } + void DispatchNextInputEvent(); + } + + public ManagedDispatcherImpl(IManagedDispatcherInputProvider? inputProvider) + { + _inputProvider = inputProvider; + } + + public bool CurrentThreadIsLoopThread => _loopThread == Thread.CurrentThread; + public void Signal() + { + lock (_lock) + { + _signaled = true; + _wakeup.Set(); + } + } + + public event Action? Signaled; + public event Action? Timer; + public long Now => _clock.ElapsedMilliseconds; + public void UpdateTimer(long? dueTimeInMs) + { + lock (_lock) + { + _nextTimer = dueTimeInMs == null + ? null + : TimeSpan.FromMilliseconds(dueTimeInMs.Value); + if (!CurrentThreadIsLoopThread) + _wakeup.Set(); + } + } + + public bool CanQueryPendingInput => _inputProvider != null; + public bool HasPendingInput => _inputProvider?.HasInput ?? false; + + public void RunLoop(CancellationToken token) + { + while (!token.IsCancellationRequested) + { + bool signaled; + lock (_lock) + { + signaled = _signaled; + _signaled = false; + } + + if (signaled) + { + Signaled?.Invoke(); + continue; + } + + bool fireTimer = false; + lock (_lock) + { + if (_nextTimer < _clock.Elapsed) + { + fireTimer = true; + _nextTimer = null; + } + } + + if (fireTimer) + { + Timer?.Invoke(); + continue; + } + + if (_inputProvider?.HasInput == true) + { + _inputProvider.DispatchNextInputEvent(); + continue; + } + + if (_nextTimer != null) + { + var waitFor = _clock.Elapsed - _nextTimer.Value; + if (waitFor.TotalMilliseconds < 1) + continue; + _wakeup.WaitOne(waitFor); + } + else + _wakeup.WaitOne(); + } + } +} \ No newline at end of file diff --git a/src/Avalonia.Controls/SplitView/SplitView.cs b/src/Avalonia.Controls/SplitView/SplitView.cs index 1099a40f08..8060ca9594 100644 --- a/src/Avalonia.Controls/SplitView/SplitView.cs +++ b/src/Avalonia.Controls/SplitView/SplitView.cs @@ -8,6 +8,7 @@ using Avalonia.Interactivity; using Avalonia.LogicalTree; using Avalonia.Media; using Avalonia.Metadata; +using Avalonia.Reactive; namespace Avalonia.Controls { @@ -15,18 +16,21 @@ namespace Avalonia.Controls /// A control with two views: A collapsible pane and an area for content /// [TemplatePart("PART_PaneRoot", typeof(Panel))] - [PseudoClasses(":open", ":closed")] - [PseudoClasses(":compactoverlay", ":compactinline", ":overlay", ":inline")] - [PseudoClasses(":left", ":right")] - [PseudoClasses(":lightdismiss")] + [PseudoClasses(pcOpen, pcClosed)] + [PseudoClasses(pcCompactOverlay, pcCompactInline, pcOverlay, pcInline)] + [PseudoClasses(pcLeft, pcRight)] + [PseudoClasses(pcLightDismiss)] public class SplitView : ContentControl { - /* - Pseudo classes & combos - :open / :closed - :compactoverlay :compactinline :overlay :inline - :left :right - */ + protected const string pcOpen = ":open"; + protected const string pcClosed = ":closed"; + protected const string pcCompactOverlay = ":compactoverlay"; + protected const string pcCompactInline = ":compactinline"; + protected const string pcOverlay = ":overlay"; + protected const string pcInline = ":inline"; + protected const string pcLeft = ":left"; + protected const string pcRight = ":right"; + protected const string pcLightDismiss = ":lightDismiss"; /// /// Defines the property @@ -94,8 +98,9 @@ namespace Avalonia.Controls /// /// Defines the property /// - public static readonly StyledProperty TemplateSettingsProperty = - AvaloniaProperty.Register(nameof(TemplateSettings)); + public static readonly DirectProperty TemplateSettingsProperty = + AvaloniaProperty.RegisterDirect(nameof(TemplateSettings), + x => x.TemplateSettings); /// /// Defines the event. @@ -131,18 +136,9 @@ namespace Avalonia.Controls private Panel? _pane; private IDisposable? _pointerDisposable; - - public SplitView() - { - PseudoClasses.Add(":overlay"); - PseudoClasses.Add(":left"); - - TemplateSettings = new SplitViewTemplateSettings(); - } - - static SplitView() - { - } + private SplitViewTemplateSettings _templateSettings = new SplitViewTemplateSettings(); + private string? _lastDisplayModePseudoclass; + private string? _lastPlacementPseudoclass; /// /// Gets or sets the length of the pane when in @@ -208,7 +204,7 @@ namespace Avalonia.Controls get => GetValue(PaneProperty); set => SetValue(PaneProperty, value); } - + /// /// Gets or sets the data template used to display the header content of the control. /// @@ -235,8 +231,8 @@ namespace Avalonia.Controls /// public SplitViewTemplateSettings TemplateSettings { - get => GetValue(TemplateSettingsProperty); - set => SetValue(TemplateSettingsProperty, value); + get => _templateSettings; + private set => SetAndRaise(TemplateSettingsProperty, ref _templateSettings, value); } /// @@ -291,7 +287,7 @@ namespace Avalonia.Controls { return true; } - + return result; } @@ -299,17 +295,18 @@ namespace Avalonia.Controls { base.OnApplyTemplate(e); _pane = e.NameScope.Find("PART_PaneRoot"); + + UpdateVisualStateForDisplayMode(DisplayMode); } protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e) { base.OnAttachedToVisualTree(e); - var topLevel = this.VisualRoot; - if (topLevel is Window window) - { - _pointerDisposable = window.AddDisposableHandler(PointerPressedEvent, PointerPressedOutside, RoutingStrategies.Tunnel); - } + // :left and :right style triggers contain the template so we need to do this as + // soon as we're attached so the template applies. The other visual states can + // be updated after the template applies + UpdateVisualStateForPanePlacementProperty(PanePlacement); } protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e) @@ -325,36 +322,11 @@ namespace Avalonia.Controls if (change.Property == CompactPaneLengthProperty) { - var newLen = change.GetNewValue(); - var displayMode = DisplayMode; - if (displayMode == SplitViewDisplayMode.CompactInline) - { - TemplateSettings.ClosedPaneWidth = newLen; - } - else if (displayMode == SplitViewDisplayMode.CompactOverlay) - { - TemplateSettings.ClosedPaneWidth = newLen; - TemplateSettings.PaneColumnGridLength = new GridLength(newLen, GridUnitType.Pixel); - } + UpdateVisualStateForCompactPaneLength(change.GetNewValue()); } else if (change.Property == DisplayModeProperty) { - var oldState = GetPseudoClass(change.GetOldValue()); - var newState = GetPseudoClass(change.GetNewValue()); - - PseudoClasses.Remove($":{oldState}"); - PseudoClasses.Add($":{newState}"); - - var (closedPaneWidth, paneColumnGridLength) = change.GetNewValue() switch - { - SplitViewDisplayMode.Overlay => (0, new GridLength(0, GridUnitType.Pixel)), - SplitViewDisplayMode.CompactOverlay => (CompactPaneLength, new GridLength(CompactPaneLength, GridUnitType.Pixel)), - SplitViewDisplayMode.Inline => (0, new GridLength(0, GridUnitType.Auto)), - SplitViewDisplayMode.CompactInline => (CompactPaneLength, new GridLength(0, GridUnitType.Auto)), - _ => throw new NotImplementedException(), - }; - TemplateSettings.ClosedPaneWidth = closedPaneWidth; - TemplateSettings.PaneColumnGridLength = paneColumnGridLength; + UpdateVisualStateForDisplayMode(change.GetNewValue()); } else if (change.Property == IsPaneOpenProperty) { @@ -362,15 +334,15 @@ namespace Avalonia.Controls if (isPaneOpen) { - PseudoClasses.Add(":open"); - PseudoClasses.Remove(":closed"); + PseudoClasses.Add(pcOpen); + PseudoClasses.Remove(pcClosed); OnPaneOpened(new RoutedEventArgs(PaneOpenedEvent, this)); } else { - PseudoClasses.Add(":closed"); - PseudoClasses.Remove(":open"); + PseudoClasses.Add(pcClosed); + PseudoClasses.Remove(pcOpen); OnPaneClosed(new RoutedEventArgs(PaneClosedEvent, this)); } @@ -389,33 +361,37 @@ namespace Avalonia.Controls } else if (change.Property == PanePlacementProperty) { - var oldState = GetPseudoClass(change.GetOldValue()); - var newState = GetPseudoClass(change.GetNewValue()); - PseudoClasses.Remove($":{oldState}"); - PseudoClasses.Add($":{newState}"); + UpdateVisualStateForPanePlacementProperty(change.GetNewValue()); } else if (change.Property == UseLightDismissOverlayModeProperty) { var mode = change.GetNewValue(); - PseudoClasses.Set(":lightdismiss", mode); + PseudoClasses.Set(pcLightDismiss, mode); } } - private void PointerPressedOutside(object? sender, PointerPressedEventArgs e) + protected override void OnKeyDown(KeyEventArgs e) { - if (!IsPaneOpen) + if (!e.Handled && e.Key == Key.Escape) { - return; + if (IsPaneOpen && IsInOverlayMode()) + { + SetCurrentValue(IsPaneOpenProperty, false); + e.Handled = true; + } } - //If we click within the Pane, don't do anything - //Otherwise, ClosePane if open & using an overlay display mode - bool closePane = ShouldClosePane(); - if (!closePane) + base.OnKeyDown(e); + } + + private void PointerReleasedOutside(object? sender, PointerReleasedEventArgs e) + { + if (!IsPaneOpen || _pane == null) { return; } + var closePane = true; var src = e.Source as Visual; while (src != null) { @@ -432,14 +408,15 @@ namespace Avalonia.Controls src = src.VisualParent; } + if (closePane) { SetCurrentValue(IsPaneOpenProperty, false); e.Handled = true; } } - - private bool ShouldClosePane() + + private bool IsInOverlayMode() { return (DisplayMode == SplitViewDisplayMode.CompactOverlay || DisplayMode == SplitViewDisplayMode.Overlay); } @@ -451,6 +428,7 @@ namespace Avalonia.Controls protected virtual void OnPaneOpened(RoutedEventArgs args) { + EnableLightDismiss(); RaiseEvent(args); } @@ -461,6 +439,8 @@ namespace Avalonia.Controls protected virtual void OnPaneClosed(RoutedEventArgs args) { + _pointerDisposable?.Dispose(); + _pointerDisposable = null; RaiseEvent(args); } @@ -471,14 +451,14 @@ namespace Avalonia.Controls { return mode switch { - SplitViewDisplayMode.Inline => "inline", - SplitViewDisplayMode.CompactInline => "compactinline", - SplitViewDisplayMode.Overlay => "overlay", - SplitViewDisplayMode.CompactOverlay => "compactoverlay", + SplitViewDisplayMode.Inline => pcInline, + SplitViewDisplayMode.CompactInline => pcCompactInline, + SplitViewDisplayMode.Overlay => pcOverlay, + SplitViewDisplayMode.CompactOverlay => pcCompactOverlay, _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null) }; } - + /// /// Gets the appropriate PseudoClass for the given . /// @@ -486,8 +466,8 @@ namespace Avalonia.Controls { return placement switch { - SplitViewPanePlacement.Left => "left", - SplitViewPanePlacement.Right => "right", + SplitViewPanePlacement.Left => pcLeft, + SplitViewPanePlacement.Right => pcRight, _ => throw new ArgumentOutOfRangeException(nameof(placement), placement, null) }; } @@ -519,6 +499,86 @@ namespace Avalonia.Controls return value; } + private void UpdateVisualStateForCompactPaneLength(double newLen) + { + var displayMode = DisplayMode; + if (displayMode == SplitViewDisplayMode.CompactInline) + { + TemplateSettings.ClosedPaneWidth = newLen; + } + else if (displayMode == SplitViewDisplayMode.CompactOverlay) + { + TemplateSettings.ClosedPaneWidth = newLen; + TemplateSettings.PaneColumnGridLength = new GridLength(newLen, GridUnitType.Pixel); + } + } + + private void UpdateVisualStateForDisplayMode(SplitViewDisplayMode newValue) + { + if (!string.IsNullOrEmpty(_lastDisplayModePseudoclass)) + { + PseudoClasses.Remove(_lastDisplayModePseudoclass); + } + + _lastDisplayModePseudoclass = GetPseudoClass(newValue); + PseudoClasses.Add(_lastDisplayModePseudoclass); + + var (closedPaneWidth, paneColumnGridLength) = newValue switch + { + SplitViewDisplayMode.Overlay => (0, new GridLength(0, GridUnitType.Pixel)), + SplitViewDisplayMode.CompactOverlay => (CompactPaneLength, new GridLength(CompactPaneLength, GridUnitType.Pixel)), + SplitViewDisplayMode.Inline => (0, new GridLength(0, GridUnitType.Auto)), + SplitViewDisplayMode.CompactInline => (CompactPaneLength, new GridLength(0, GridUnitType.Auto)), + _ => throw new NotImplementedException(), + }; + TemplateSettings.ClosedPaneWidth = closedPaneWidth; + TemplateSettings.PaneColumnGridLength = paneColumnGridLength; + } + + private void UpdateVisualStateForPanePlacementProperty(SplitViewPanePlacement newValue) + { + if (!string.IsNullOrEmpty(_lastPlacementPseudoclass)) + { + PseudoClasses.Remove(_lastPlacementPseudoclass); + } + + _lastPlacementPseudoclass = GetPseudoClass(newValue); + PseudoClasses.Add(_lastPlacementPseudoclass); + } + + private void EnableLightDismiss() + { + if (_pane == null) + return; + + // If this returns false, we're not in Overlay or CompactOverlay DisplayMode + // and don't need the light dismiss behavior + if (!IsInOverlayMode()) + return; + + var topLevel = TopLevel.GetTopLevel(this); + if (topLevel != null) + { + _pointerDisposable = Disposable.Create(() => + { + topLevel.PointerReleased -= PointerReleasedOutside; + topLevel.BackRequested -= TopLevelBackRequested; + }); + + topLevel.PointerReleased += PointerReleasedOutside; + topLevel.BackRequested += TopLevelBackRequested; + } + } + + private void TopLevelBackRequested(object? sender, RoutedEventArgs e) + { + if (!IsInOverlayMode()) + return; + + SetCurrentValue(IsPaneOpenProperty, false); + e.Handled = true; + } + /// /// Coerces/validates the property value. /// diff --git a/src/Avalonia.DesignerSupport/Remote/PreviewerWindowingPlatform.cs b/src/Avalonia.DesignerSupport/Remote/PreviewerWindowingPlatform.cs index cd14b2d69a..808153cc4a 100644 --- a/src/Avalonia.DesignerSupport/Remote/PreviewerWindowingPlatform.cs +++ b/src/Avalonia.DesignerSupport/Remote/PreviewerWindowingPlatform.cs @@ -6,6 +6,7 @@ using Avalonia.Input.Platform; using Avalonia.Platform; using Avalonia.Remote.Protocol; using Avalonia.Rendering; +using Avalonia.Threading; namespace Avalonia.DesignerSupport.Remote { @@ -46,13 +47,12 @@ namespace Avalonia.DesignerSupport.Remote { s_transport = transport; var instance = new PreviewerWindowingPlatform(); - var threading = new InternalPlatformThreadingInterface(); AvaloniaLocator.CurrentMutable .Bind().ToSingleton() .Bind().ToSingleton() .Bind().ToConstant(Keyboard) .Bind().ToSingleton() - .Bind().ToConstant(threading) + .Bind().ToConstant(new ManagedDispatcherImpl(null)) .Bind().ToConstant(new RenderLoop()) .Bind().ToConstant(new DefaultRenderTimer(60)) .Bind().ToConstant(instance) diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.otf deleted file mode 100644 index c74cc0c6c1..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.ttf new file mode 100644 index 0000000000..a372c5fcca Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-Bold.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.otf deleted file mode 100644 index 6dc068dc90..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.ttf new file mode 100644 index 0000000000..13ef261fff Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-ExtraLight.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Light.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-Light.otf deleted file mode 100644 index 2a83ae168d..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-Light.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Light.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-Light.ttf new file mode 100644 index 0000000000..9f75ff2780 Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-Light.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.otf deleted file mode 100644 index ca7bfcd434..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.ttf new file mode 100644 index 0000000000..2c5e25453c Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-Medium.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.otf deleted file mode 100644 index 84e6a61c3c..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.ttf new file mode 100644 index 0000000000..c28fe4d744 Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-Regular.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.otf deleted file mode 100644 index daf4c4413f..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.ttf new file mode 100644 index 0000000000..d085eb4994 Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-SemiBold.ttf differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.otf b/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.otf deleted file mode 100644 index 22592e045c..0000000000 Binary files a/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.otf and /dev/null differ diff --git a/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.ttf b/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.ttf new file mode 100644 index 0000000000..016a13482b Binary files /dev/null and b/src/Avalonia.Fonts.Inter/Assets/Inter-Thin.ttf differ diff --git a/src/Avalonia.Headless/AvaloniaHeadlessPlatform.cs b/src/Avalonia.Headless/AvaloniaHeadlessPlatform.cs index b0b1d731d2..319b0da7bf 100644 --- a/src/Avalonia.Headless/AvaloniaHeadlessPlatform.cs +++ b/src/Avalonia.Headless/AvaloniaHeadlessPlatform.cs @@ -60,7 +60,7 @@ namespace Avalonia.Headless internal static void Initialize(AvaloniaHeadlessPlatformOptions opts) { AvaloniaLocator.CurrentMutable - .Bind().ToConstant(new HeadlessPlatformThreadingInterface()) + .Bind().ToConstant(new ManagedDispatcherImpl(null)) .Bind().ToSingleton() .Bind().ToSingleton() .Bind().ToSingleton() diff --git a/src/Avalonia.Headless/HeadlessPlatformThreadingInterface.cs b/src/Avalonia.Headless/HeadlessPlatformThreadingInterface.cs deleted file mode 100644 index 046e4645e3..0000000000 --- a/src/Avalonia.Headless/HeadlessPlatformThreadingInterface.cs +++ /dev/null @@ -1,86 +0,0 @@ -using System; -using Avalonia.Reactive; -using System.Threading; -using Avalonia.Platform; -using Avalonia.Threading; - -namespace Avalonia.Headless -{ - class HeadlessPlatformThreadingInterface : IPlatformThreadingInterface - { - public HeadlessPlatformThreadingInterface() - { - _thread = Thread.CurrentThread; - } - - private AutoResetEvent _event = new AutoResetEvent(false); - private Thread _thread; - private object _lock = new object(); - private DispatcherPriority? _signaledPriority; - - public void RunLoop(CancellationToken cancellationToken) - { - while (!cancellationToken.IsCancellationRequested) - { - DispatcherPriority? signaled = null; - lock (_lock) - { - signaled = _signaledPriority; - _signaledPriority = null; - } - if(signaled.HasValue) - Signaled?.Invoke(signaled); - WaitHandle.WaitAny(new[] {cancellationToken.WaitHandle, _event}, TimeSpan.FromMilliseconds(20)); - } - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - if (interval.TotalMilliseconds < 10) - interval = TimeSpan.FromMilliseconds(10); - - var stopped = false; - Timer timer = null; - timer = new Timer(_ => - { - if (stopped) - return; - - Dispatcher.UIThread.Post(() => - { - try - { - tick(); - } - finally - { - if (!stopped) - timer.Change(interval, Timeout.InfiniteTimeSpan); - } - }); - }, - null, interval, Timeout.InfiniteTimeSpan); - - return Disposable.Create(() => - { - stopped = true; - timer.Dispose(); - }); - } - - public void Signal(DispatcherPriority priority) - { - lock (_lock) - { - if (_signaledPriority == null || _signaledPriority.Value > priority) - { - _signaledPriority = priority; - } - _event.Set(); - } - } - - public bool CurrentThreadIsLoopThread => _thread == Thread.CurrentThread; - public event Action Signaled; - } -} diff --git a/src/Avalonia.Native/AvaloniaNativePlatform.cs b/src/Avalonia.Native/AvaloniaNativePlatform.cs index 67b55bd512..e6a103f6b9 100644 --- a/src/Avalonia.Native/AvaloniaNativePlatform.cs +++ b/src/Avalonia.Native/AvaloniaNativePlatform.cs @@ -9,6 +9,7 @@ using Avalonia.OpenGL; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Threading; using MicroCom.Runtime; #nullable enable @@ -98,8 +99,8 @@ namespace Avalonia.Native } AvaloniaLocator.CurrentMutable - .Bind() - .ToConstant(new PlatformThreadingInterface(_factory.CreatePlatformThreadingInterface())) + .Bind() + .ToConstant(new DispatcherImpl(_factory.CreatePlatformThreadingInterface())) .Bind().ToConstant(new CursorFactory(_factory.CreateCursorFactory())) .Bind().ToSingleton() .Bind().ToConstant(KeyboardDevice) diff --git a/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs b/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs index b216970af3..796a0ced37 100644 --- a/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs +++ b/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs @@ -60,7 +60,18 @@ namespace Avalonia.Native return; } - _inputMethod.SetCursorRect(_client.CursorRectangle.ToAvnRect()); + var visualRoot = _client.TextViewVisual.VisualRoot; + + var transform = _client.TextViewVisual.TransformToVisual((Visual)visualRoot); + + if (transform == null) + { + return; + } + + var rect = _client.CursorRectangle.TransformToAABB(transform.Value); + + _inputMethod.SetCursorRect(rect.ToAvnRect()); } private void OnSurroundingTextChanged(object sender, EventArgs e) diff --git a/src/Avalonia.Native/CallbackBase.cs b/src/Avalonia.Native/CallbackBase.cs index 9f59c97f9b..c5978e2a0d 100644 --- a/src/Avalonia.Native/CallbackBase.cs +++ b/src/Avalonia.Native/CallbackBase.cs @@ -2,6 +2,7 @@ using System.Runtime.ExceptionServices; using Avalonia.MicroCom; using Avalonia.Platform; +using Avalonia.Threading; using MicroCom.Runtime; namespace Avalonia.Native @@ -10,11 +11,9 @@ namespace Avalonia.Native { public void RaiseException(Exception e) { - if (AvaloniaLocator.Current.GetService() is PlatformThreadingInterface threadingInterface) + if (AvaloniaLocator.Current.GetService() is DispatcherImpl dispatcherImpl) { - threadingInterface.TerminateNativeApp(); - - threadingInterface.DispatchException(ExceptionDispatchInfo.Capture(e)); + dispatcherImpl.PropagateCallbackException(ExceptionDispatchInfo.Capture(e)); } } } diff --git a/src/Avalonia.Native/DispatcherImpl.cs b/src/Avalonia.Native/DispatcherImpl.cs new file mode 100644 index 0000000000..fd8ef567f4 --- /dev/null +++ b/src/Avalonia.Native/DispatcherImpl.cs @@ -0,0 +1,132 @@ +#nullable enable +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.ExceptionServices; +using System.Threading; +using Avalonia.Native.Interop; +using Avalonia.Threading; +using MicroCom.Runtime; + +namespace Avalonia.Native; + +internal class DispatcherImpl : IControlledDispatcherImpl, IDispatcherImplWithExplicitBackgroundProcessing +{ + private readonly IAvnPlatformThreadingInterface _native; + private Thread? _loopThread; + private Stopwatch _clock = Stopwatch.StartNew(); + private Stack _managedFrames = new(); + + public DispatcherImpl(IAvnPlatformThreadingInterface native) + { + _native = native; + using var events = new Events(this); + _native.SetEvents(events); + } + + public event Action Signaled; + public event Action Timer; + public event Action ReadyForBackgroundProcessing; + + private class Events : NativeCallbackBase, IAvnPlatformThreadingInterfaceEvents + { + private readonly DispatcherImpl _parent; + + public Events(DispatcherImpl parent) + { + _parent = parent; + } + public void Signaled() => _parent.Signaled?.Invoke(); + + public void Timer() => _parent.Timer?.Invoke(); + + public void ReadyForBackgroundProcessing() => _parent.ReadyForBackgroundProcessing?.Invoke(); + } + + public bool CurrentThreadIsLoopThread + { + get + { + if (_loopThread != null) + return Thread.CurrentThread == _loopThread; + if (_native.CurrentThreadIsLoopThread == 0) + return false; + _loopThread = Thread.CurrentThread; + return true; + } + } + + public void Signal() => _native.Signal(); + + public void UpdateTimer(long? dueTimeInMs) + { + var ms = dueTimeInMs == null ? -1 : (int)Math.Min(int.MaxValue - 10, Math.Max(1, dueTimeInMs.Value - Now)); + _native.UpdateTimer(ms); + } + + public bool CanQueryPendingInput => false; + public bool HasPendingInput => false; + + class RunLoopFrame : IDisposable + { + public ExceptionDispatchInfo? Exception; + public CancellationTokenSource CancellationTokenSource = new(); + + public RunLoopFrame(CancellationToken token) + { + CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token); + } + + public void Dispose() => CancellationTokenSource.Dispose(); + } + + public void RunLoop(CancellationToken token) + { + if (token.IsCancellationRequested) + return; + object l = new(); + var exited = false; + + using var frame = new RunLoopFrame(token); + + using var cancel = _native.CreateLoopCancellation(); + frame.CancellationTokenSource.Token.Register(() => + { + lock (l) + // ReSharper disable once AccessToModifiedClosure + // ReSharper disable once AccessToDisposedClosure + if (!exited) + cancel.Cancel(); + }); + + try + { + _managedFrames.Push(frame); + _native.RunLoop(cancel); + } + finally + { + lock (l) + exited = true; + _managedFrames.Pop(); + if (frame.Exception != null) + frame.Exception.Throw(); + } + } + + public long Now => _clock.ElapsedMilliseconds; + + public void PropagateCallbackException(ExceptionDispatchInfo capture) + { + if (_managedFrames.Count == 0) + { + Debug.Assert(false, "We should never get here"); + return; + } + + var frame = _managedFrames.Peek(); + frame.Exception = capture; + frame.CancellationTokenSource.Cancel(); + } + public void RequestBackgroundProcessing() => _native.RequestBackgroundProcessing(); +} diff --git a/src/Avalonia.Native/PlatformThreadingInterface.cs b/src/Avalonia.Native/PlatformThreadingInterface.cs deleted file mode 100644 index 99aa8a5850..0000000000 --- a/src/Avalonia.Native/PlatformThreadingInterface.cs +++ /dev/null @@ -1,115 +0,0 @@ -using System; -using System.Runtime.ExceptionServices; -using System.Threading; -using Avalonia.Native.Interop; -using Avalonia.Platform; -using Avalonia.Threading; - -namespace Avalonia.Native -{ - internal class PlatformThreadingInterface : IPlatformThreadingInterface - { - class TimerCallback : NativeCallbackBase, IAvnActionCallback - { - readonly Action _tick; - - public TimerCallback(Action tick) - { - _tick = tick; - } - - public void Run() - { - _tick(); - } - } - - class SignaledCallback : NativeCallbackBase, IAvnSignaledCallback - { - readonly PlatformThreadingInterface _parent; - - public SignaledCallback(PlatformThreadingInterface parent) - { - _parent = parent; - } - - public void Signaled(int priority, int priorityContainsMeaningfulValue) - { - _parent.Signaled?.Invoke(priorityContainsMeaningfulValue.FromComBool() ? (DispatcherPriority?)priority : null); - } - } - - readonly IAvnPlatformThreadingInterface _native; - private ExceptionDispatchInfo _exceptionDispatchInfo; - private CancellationTokenSource _exceptionCancellationSource; - - public PlatformThreadingInterface(IAvnPlatformThreadingInterface native) - { - _native = native; - using (var cb = new SignaledCallback(this)) - _native.SetSignaledCallback(cb); - } - - public bool CurrentThreadIsLoopThread => _native.CurrentThreadIsLoopThread.FromComBool(); - - public event Action Signaled; - - public void RunLoop(CancellationToken cancellationToken) - { - _exceptionDispatchInfo?.Throw(); - var l = new object(); - _exceptionCancellationSource = new CancellationTokenSource(); - - var compositeCancellation = CancellationTokenSource - .CreateLinkedTokenSource(cancellationToken, _exceptionCancellationSource.Token).Token; - - var cancellation = _native.CreateLoopCancellation(); - compositeCancellation.Register(() => - { - lock (l) - { - cancellation?.Cancel(); - } - }); - - try - { - _native.RunLoop(cancellation); - } - finally - { - lock (l) - { - cancellation?.Dispose(); - cancellation = null; - } - } - - if (_exceptionDispatchInfo != null) - { - _exceptionDispatchInfo.Throw(); - } - } - - public void DispatchException (ExceptionDispatchInfo exceptionInfo) - { - _exceptionDispatchInfo = exceptionInfo; - } - - public void TerminateNativeApp() - { - _exceptionCancellationSource?.Cancel(); - } - - public void Signal(DispatcherPriority priority) - { - _native.Signal((int)priority); - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - using (var cb = new TimerCallback(tick)) - return _native.StartTimer((int)priority, (int)interval.TotalMilliseconds, cb); - } - } -} diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl index b107e83e7a..09e9168d8f 100644 --- a/src/Avalonia.Native/avn.idl +++ b/src/Avalonia.Native/avn.idl @@ -645,9 +645,11 @@ interface IAvnActionCallback : IUnknown } [uuid(6df4d2db-0b80-4f59-ad88-0baa5e21eb14)] -interface IAvnSignaledCallback : IUnknown +interface IAvnPlatformThreadingInterfaceEvents : IUnknown { - void Signaled(int priority, bool priorityContainsMeaningfulValue); + void Signaled(); + void Timer(); + void ReadyForBackgroundProcessing(); } [uuid(97330f88-c22b-4a8e-a130-201520091b01)] @@ -660,12 +662,12 @@ interface IAvnLoopCancellation : IUnknown interface IAvnPlatformThreadingInterface : IUnknown { bool GetCurrentThreadIsLoopThread(); - void SetSignaledCallback(IAvnSignaledCallback* cb); + void SetEvents(IAvnPlatformThreadingInterfaceEvents* cb); IAvnLoopCancellation* CreateLoopCancellation(); - HRESULT RunLoop(IAvnLoopCancellation* cancel); - // Can't pass int* to sharpgentools for some reason - void Signal(int priority); - IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback); + void RunLoop(IAvnLoopCancellation* cancel); + void Signal(); + void UpdateTimer(int ms); + void RequestBackgroundProcessing(); } [uuid(6c621a6e-e4c1-4ae3-9749-83eeeffa09b6)] diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs index 170c6ce6b3..e4e5dbfcb8 100644 --- a/src/Avalonia.X11/X11Platform.cs +++ b/src/Avalonia.X11/X11Platform.cs @@ -14,6 +14,7 @@ using Avalonia.OpenGL.Egl; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Threading; using Avalonia.X11; using Avalonia.X11.Glx; using static Avalonia.X11.XLib; @@ -34,6 +35,7 @@ namespace Avalonia.X11 public X11PlatformOptions Options { get; private set; } public IntPtr OrphanedWindow { get; private set; } public X11Globals Globals { get; private set; } + public ManualRawEventGrouperDispatchQueue EventGrouperDispatchQueue { get; } = new(); [DllImport("libc")] private static extern void setlocale(int type, string s); public void Initialize(X11PlatformOptions options) @@ -72,7 +74,7 @@ namespace Avalonia.X11 AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(this) - .Bind().ToConstant(new X11PlatformThreading(this)) + .Bind().ToConstant(new X11PlatformThreading(this)) .Bind().ToConstant(new SleepLoopRenderTimer(60)) .Bind().ToConstant(new RenderLoop()) .Bind().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Control)) diff --git a/src/Avalonia.X11/X11PlatformThreading.cs b/src/Avalonia.X11/X11PlatformThreading.cs index 1946642de3..de0e3bee5d 100644 --- a/src/Avalonia.X11/X11PlatformThreading.cs +++ b/src/Avalonia.X11/X11PlatformThreading.cs @@ -9,7 +9,7 @@ using static Avalonia.X11.XLib; namespace Avalonia.X11 { - internal unsafe class X11PlatformThreading : IPlatformThreadingInterface + internal unsafe class X11PlatformThreading : IControlledDispatcherImpl { private readonly AvaloniaX11Platform _platform; private readonly IntPtr _display; @@ -68,44 +68,11 @@ namespace Avalonia.X11 private int _sigread, _sigwrite; private object _lock = new object(); private bool _signaled; - private DispatcherPriority _signaledPriority; + private bool _wakeupRequested; + private long? _nextTimer; private int _epoll; private Stopwatch _clock = Stopwatch.StartNew(); - private class X11Timer : IDisposable - { - private readonly X11PlatformThreading _parent; - - public X11Timer(X11PlatformThreading parent, DispatcherPriority prio, TimeSpan interval, Action tick) - { - _parent = parent; - Priority = prio; - Tick = tick; - Interval = interval; - Reschedule(); - } - - public DispatcherPriority Priority { get; } - public TimeSpan NextTick { get; private set; } - public TimeSpan Interval { get; } - public Action Tick { get; } - public bool Disposed { get; private set; } - - public void Reschedule() - { - NextTick = _parent._clock.Elapsed + Interval; - } - - public void Dispose() - { - Disposed = true; - lock (_parent._lock) - _parent._timers.Remove(this); - } - } - - private List _timers = new List(); - public X11PlatformThreading(AvaloniaX11Platform platform) { _platform = platform; @@ -139,29 +106,16 @@ namespace Avalonia.X11 throw new X11Exception("Unable to attach signal pipe to epoll"); } - private int TimerComparer(X11Timer t1, X11Timer t2) - { - return t2.Priority - t1.Priority; - } - private void CheckSignaled() { - int buf = 0; - while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0) - { - } - - DispatcherPriority prio; lock (_lock) { if (!_signaled) return; _signaled = false; - prio = _signaledPriority; - _signaledPriority = DispatcherPriority.MinValue; } - Signaled?.Invoke(prio); + Signaled?.Invoke(); } private unsafe void HandleX11(CancellationToken cancellationToken) @@ -170,6 +124,7 @@ namespace Avalonia.X11 { if (cancellationToken.IsCancellationRequested) return; + XNextEvent(_display, out var xev); if(XFilterEvent(ref xev, IntPtr.Zero)) continue; @@ -195,90 +150,94 @@ namespace Avalonia.X11 XFreeEventData(_display, &xev.GenericEventCookie); } } - - Dispatcher.UIThread.RunJobs(); } - + public void RunLoop(CancellationToken cancellationToken) { - var readyTimers = new List(); while (!cancellationToken.IsCancellationRequested) { - var now = _clock.Elapsed; - TimeSpan? nextTick = null; - readyTimers.Clear(); - lock(_timers) - foreach (var t in _timers) - { - if (nextTick == null || t.NextTick < nextTick.Value) - nextTick = t.NextTick; - if (t.NextTick < now) - readyTimers.Add(t); - } - - readyTimers.Sort(TimerComparer); - - foreach (var t in readyTimers) + var now = _clock.ElapsedMilliseconds; + if (_nextTimer.HasValue && now > _nextTimer.Value) { - if (cancellationToken.IsCancellationRequested) - return; - t.Tick(); - if(!t.Disposed) - { - t.Reschedule(); - if (nextTick == null || t.NextTick < nextTick.Value) - nextTick = t.NextTick; - } + Timer?.Invoke(); } if (cancellationToken.IsCancellationRequested) return; + //Flush whatever requests were made to XServer XFlush(_display); epoll_event ev; if (XPending(_display) == 0) - epoll_wait(_epoll, &ev, 1, - nextTick == null ? -1 : Math.Max(1, (int)(nextTick.Value - _clock.Elapsed).TotalMilliseconds)); + { + now = _clock.ElapsedMilliseconds; + if (_nextTimer < now) + continue; + + var timeout = _nextTimer == null ? (int)-1 : Math.Max(1, _nextTimer.Value - now); + epoll_wait(_epoll, &ev, 1, (int)Math.Min(int.MaxValue, timeout)); + + // Drain the signaled pipe + int buf = 0; + while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0) + { + } + + lock (_lock) + _wakeupRequested = false; + } + if (cancellationToken.IsCancellationRequested) return; CheckSignaled(); HandleX11(cancellationToken); + while (_platform.EventGrouperDispatchQueue.HasJobs) + { + CheckSignaled(); + _platform.EventGrouperDispatchQueue.DispatchNext(); + } } } - + private void Wakeup() + { + lock (_lock) + { + if(_wakeupRequested) + return; + _wakeupRequested = true; + int buf = 0; + write(_sigwrite, &buf, new IntPtr(1)); + } + } - public void Signal(DispatcherPriority priority) + public void Signal() { lock (_lock) { - if (priority > _signaledPriority) - _signaledPriority = priority; - if(_signaled) return; _signaled = true; - int buf = 0; - write(_sigwrite, &buf, new IntPtr(1)); + Wakeup(); } } public bool CurrentThreadIsLoopThread => Thread.CurrentThread == _mainThread; - public event Action Signaled; - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) + public event Action Signaled; + public event Action Timer; + + public void UpdateTimer(long? dueTimeInMs) { - if (_mainThread != Thread.CurrentThread) - throw new InvalidOperationException("StartTimer can be only called from UI thread"); - if (interval <= TimeSpan.Zero) - throw new ArgumentException("Interval must be positive", nameof(interval)); - - // We assume that we are on the main thread and outside of epoll_wait, so there is no need for wakeup signal - - var timer = new X11Timer(this, priority, interval, tick); - lock(_timers) - _timers.Add(timer); - return timer; + _nextTimer = dueTimeInMs; + if (_nextTimer != null) + Wakeup(); } + + + public long Now => (int)_clock.ElapsedMilliseconds; + public bool CanQueryPendingInput => true; + + public bool HasPendingInput => _platform.EventGrouperDispatchQueue.HasJobs || XPending(_display) != 0; } } diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs index 22748f6aa3..e04a53dcab 100644 --- a/src/Avalonia.X11/X11Window.cs +++ b/src/Avalonia.X11/X11Window.cs @@ -190,7 +190,7 @@ namespace Avalonia.X11 UpdateMotifHints(); UpdateSizeHints(null); - _rawEventGrouper = new RawEventGrouper(DispatchInput); + _rawEventGrouper = new RawEventGrouper(DispatchInput, platform.EventGrouperDispatchQueue); _transparencyHelper = new TransparencyHelper(_x11, _handle, platform.Globals); _transparencyHelper.SetTransparencyRequest(WindowTransparencyLevel.None); @@ -515,7 +515,6 @@ namespace Avalonia.X11 if (changedSize && !updatedSizeViaScaling && !_popup) Resized?.Invoke(ClientSize, PlatformResizeReason.Unspecified); - Dispatcher.UIThread.RunJobs(DispatcherPriority.Layout); }, DispatcherPriority.Layout); if (_useRenderWindow) XConfigureResizeWindow(_x11.Display, _renderHandle, ev.ConfigureEvent.width, diff --git a/src/Browser/Avalonia.Browser/WindowingPlatform.cs b/src/Browser/Avalonia.Browser/WindowingPlatform.cs index 46db8936eb..0578a08ec3 100644 --- a/src/Browser/Avalonia.Browser/WindowingPlatform.cs +++ b/src/Browser/Avalonia.Browser/WindowingPlatform.cs @@ -49,11 +49,6 @@ namespace Avalonia.Browser .Bind().ToSingleton(); } - public void RunLoop(CancellationToken cancellationToken) - { - throw new NotSupportedException(); - } - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) { return GetRuntimePlatform() diff --git a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs index 9dc7f08064..af4a70f128 100644 --- a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs +++ b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs @@ -8,13 +8,15 @@ using Avalonia.LinuxFramebuffer.Output; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; + using Avalonia.Threading; -namespace Avalonia.LinuxFramebuffer + namespace Avalonia.LinuxFramebuffer { class FramebufferToplevelImpl : ITopLevelImpl, IScreenInfoProvider { private readonly IOutputBackend _outputBackend; private readonly IInputBackend _inputBackend; + private readonly RawEventGrouper _inputQueue; public IInputRoot InputRoot { get; private set; } @@ -22,9 +24,12 @@ namespace Avalonia.LinuxFramebuffer { _outputBackend = outputBackend; _inputBackend = inputBackend; + _inputQueue = new RawEventGrouper(groupedInput => Input?.Invoke(groupedInput), + LinuxFramebufferPlatform.EventGrouperDispatchQueue); Surfaces = new object[] { _outputBackend }; - _inputBackend.Initialize(this, e => Input?.Invoke(e)); + _inputBackend.Initialize(this, e => + Dispatcher.UIThread.Post(() => _inputQueue.HandleEvent(e), DispatcherPriority.Send )); } public IRenderer CreateRenderer(IRenderRoot root) diff --git a/src/Linux/Avalonia.LinuxFramebuffer/Input/EvDev/EvDevBackend.cs b/src/Linux/Avalonia.LinuxFramebuffer/Input/EvDev/EvDevBackend.cs index 686050e7c2..61c94a48bd 100644 --- a/src/Linux/Avalonia.LinuxFramebuffer/Input/EvDev/EvDevBackend.cs +++ b/src/Linux/Avalonia.LinuxFramebuffer/Input/EvDev/EvDevBackend.cs @@ -14,12 +14,10 @@ namespace Avalonia.LinuxFramebuffer.Input.EvDev private int _epoll; private Action _onInput; private IInputRoot _inputRoot; - private RawEventGroupingThreadingHelper _inputQueue; public EvDevBackend(EvDevDeviceDescription[] devices) { _deviceDescriptions = devices; - _inputQueue = new RawEventGroupingThreadingHelper(e => _onInput?.Invoke(e)); } unsafe void InputThread() @@ -45,12 +43,9 @@ namespace Avalonia.LinuxFramebuffer.Input.EvDev } } - private void OnRawEvent(RawInputEventArgs obj) - { - _inputQueue.OnEvent(obj); - } - - + private void OnRawEvent(RawInputEventArgs obj) => _onInput?.Invoke(obj); + + public void Initialize(IScreenInfoProvider info, Action onInput) { _onInput = onInput; diff --git a/src/Linux/Avalonia.LinuxFramebuffer/Input/LibInput/LibInputBackend.cs b/src/Linux/Avalonia.LinuxFramebuffer/Input/LibInput/LibInputBackend.cs index bff9ddc55c..300cbc2689 100644 --- a/src/Linux/Avalonia.LinuxFramebuffer/Input/LibInput/LibInputBackend.cs +++ b/src/Linux/Avalonia.LinuxFramebuffer/Input/LibInput/LibInputBackend.cs @@ -13,14 +13,12 @@ namespace Avalonia.LinuxFramebuffer.Input.LibInput private IInputRoot _inputRoot; private TouchDevice _touch = new TouchDevice(); private const string LibInput = nameof(Avalonia.LinuxFramebuffer) + "/" + nameof(Avalonia.LinuxFramebuffer.Input) + "/" + nameof(LibInput); - private readonly RawEventGroupingThreadingHelper _inputQueue; private Action _onInput; private Dictionary _pointers = new Dictionary(); public LibInputBackend() { var ctx = libinput_path_create_context(); - _inputQueue = new(e => _onInput?.Invoke(e)); new Thread(() => InputThread(ctx)).Start(); } @@ -58,7 +56,7 @@ namespace Avalonia.LinuxFramebuffer.Input.LibInput } } - private void ScheduleInput(RawInputEventArgs ev) => _inputQueue.OnEvent(ev); + private void ScheduleInput(RawInputEventArgs ev) => _onInput.Invoke(ev); private void HandleTouch(IntPtr ev, LibInputEventType type) { diff --git a/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs b/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs index c3e90f5fd7..bc178c8ecb 100644 --- a/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs +++ b/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs @@ -16,6 +16,8 @@ using Avalonia.LinuxFramebuffer.Output; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Threading; + #nullable enable namespace Avalonia.LinuxFramebuffer @@ -23,9 +25,7 @@ namespace Avalonia.LinuxFramebuffer class LinuxFramebufferPlatform { IOutputBackend _fb; - private static readonly Stopwatch St = Stopwatch.StartNew(); - internal static uint Timestamp => (uint)St.ElapsedTicks; - public static InternalPlatformThreadingInterface? Threading; + public static ManualRawEventGrouperDispatchQueue EventGrouperDispatchQueue = new(); internal static Compositor Compositor { get; private set; } = null!; @@ -34,18 +34,16 @@ namespace Avalonia.LinuxFramebuffer { _fb = backend; } - - + void Initialize() { - Threading = new InternalPlatformThreadingInterface(); if (_fb is IGlOutputBackend gl) AvaloniaLocator.CurrentMutable.Bind().ToConstant(gl.PlatformGraphics); var opts = AvaloniaLocator.Current.GetService() ?? new LinuxFramebufferPlatformOptions(); AvaloniaLocator.CurrentMutable - .Bind().ToConstant(Threading) + .Bind().ToConstant(new ManagedDispatcherImpl(new ManualRawEventGrouperDispatchQueueDispatcherInputProvider(EventGrouperDispatchQueue))) .Bind().ToConstant(new DefaultRenderTimer(opts.Fps)) .Bind().ToConstant(new RenderLoop()) .Bind().ToTransient() diff --git a/src/Shared/RawEventGrouping.cs b/src/Shared/RawEventGrouping.cs index c4772db820..cdcd5af142 100644 --- a/src/Shared/RawEventGrouping.cs +++ b/src/Shared/RawEventGrouping.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using Avalonia.Collections.Pooled; +using Avalonia.Controls.Platform; using Avalonia.Input.Raw; using Avalonia.Threading; @@ -12,28 +13,60 @@ namespace Avalonia; While doing that it groups Move and TouchUpdate events so we could provide GetIntermediatePoints API */ -internal class RawEventGrouper : IDisposable +internal interface IRawEventGrouperDispatchQueue { - private readonly Action _eventCallback; - private readonly Queue _inputQueue = new(); + void Add(RawInputEventArgs args, Action handler); +} + + +class ManualRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue +{ + private readonly Queue<(RawInputEventArgs args, Action handler)> _inputQueue = new(); + public void Add(RawInputEventArgs args, Action handler) => _inputQueue.Enqueue((args, handler)); + + public bool HasJobs => _inputQueue.Count > 0; + + public void DispatchNext() + { + if (_inputQueue.Count == 0) + return; + var ev = _inputQueue.Dequeue(); + ev.handler(ev.args); + } +} + +internal class ManualRawEventGrouperDispatchQueueDispatcherInputProvider : ManagedDispatcherImpl.IManagedDispatcherInputProvider +{ + private readonly ManualRawEventGrouperDispatchQueue _queue; + + public ManualRawEventGrouperDispatchQueueDispatcherInputProvider(ManualRawEventGrouperDispatchQueue queue) + { + _queue = queue; + } + + public bool HasInput => _queue.HasJobs; + public void DispatchNextInputEvent() => _queue.DispatchNext(); +} + +internal class AutomaticRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue +{ + private readonly Queue<(RawInputEventArgs args, Action handler)> _inputQueue = new(); private readonly Action _dispatchFromQueue; - private readonly Dictionary _lastTouchPoints = new(); - private RawInputEventArgs? _lastEvent; - public RawEventGrouper(Action eventCallback) + public AutomaticRawEventGrouperDispatchQueue() { - _eventCallback = eventCallback; _dispatchFromQueue = DispatchFromQueue; } - private void AddToQueue(RawInputEventArgs args) + public void Add(RawInputEventArgs args, Action handler) { - _lastEvent = args; - _inputQueue.Enqueue(args); + _inputQueue.Enqueue((args, handler)); + if (_inputQueue.Count == 1) Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input); + } - + private void DispatchFromQueue() { while (true) @@ -43,17 +76,8 @@ internal class RawEventGrouper : IDisposable var ev = _inputQueue.Dequeue(); - if (_lastEvent == ev) - _lastEvent = null; + ev.handler(ev.args); - if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate) - _lastTouchPoints.Remove(touchUpdate.RawPointerId); - - _eventCallback?.Invoke(ev); - - if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList list }) - list.Dispose(); - if (Dispatcher.UIThread.HasJobsWithPriority(DispatcherPriority.Input + 1)) { Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input); @@ -61,6 +85,47 @@ internal class RawEventGrouper : IDisposable } } } +} + +internal class RawEventGrouper : IDisposable +{ + private readonly Action _eventCallback; + private readonly IRawEventGrouperDispatchQueue _queue; + private readonly Dictionary _lastTouchPoints = new(); + private RawInputEventArgs? _lastEvent; + private Action _dispatch; + private bool _disposed; + + public RawEventGrouper(Action eventCallback, IRawEventGrouperDispatchQueue? queue = null) + { + _eventCallback = eventCallback; + _queue = queue ?? new AutomaticRawEventGrouperDispatchQueue(); + _dispatch = Dispatch; + } + + private void AddToQueue(RawInputEventArgs args) + { + _lastEvent = args; + _queue.Add(args, _dispatch); + } + + private void Dispatch(RawInputEventArgs ev) + { + if (!_disposed) + { + if (_lastEvent == ev) + _lastEvent = null; + + if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate) + _lastTouchPoints.Remove(touchUpdate.RawPointerId); + + _eventCallback?.Invoke(ev); + } + + if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList list }) + list.Dispose(); + } + public void HandleEvent(RawInputEventArgs args) { @@ -123,7 +188,7 @@ internal class RawEventGrouper : IDisposable public void Dispose() { - _inputQueue.Clear(); + _disposed = true; _lastEvent = null; _lastTouchPoints.Clear(); } diff --git a/src/Skia/Avalonia.Skia/TextShaperImpl.cs b/src/Skia/Avalonia.Skia/TextShaperImpl.cs index 153e4f0720..7d7be46c72 100644 --- a/src/Skia/Avalonia.Skia/TextShaperImpl.cs +++ b/src/Skia/Avalonia.Skia/TextShaperImpl.cs @@ -72,7 +72,7 @@ namespace Avalonia.Skia var glyphOffset = GetGlyphOffset(glyphPositions, i, textScale); - if (textSpan[i] == '\t') + if (i < textSpan.Length && textSpan[i] == '\t') { glyphIndex = typeface.GetGlyph(' '); diff --git a/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs index d42bc3c5cf..36897d3aff 100644 --- a/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs +++ b/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs @@ -68,7 +68,7 @@ namespace Avalonia.Direct2D1.Media var glyphOffset = GetGlyphOffset(glyphPositions, i, textScale); - if (textSpan[i] == '\t') + if (i < textSpan.Length && textSpan[i] == '\t') { glyphIndex = typeface.GetGlyph(' '); diff --git a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs index 1dd2ef20c7..7510b48270 100644 --- a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs +++ b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs @@ -1784,6 +1784,49 @@ namespace Avalonia.Win32.Interop return result; } + [Flags] + internal enum QueueStatusFlags + { + QS_KEY = 0x0001, + QS_MOUSEMOVE = 0x0002, + QS_MOUSEBUTTON = 0x0004, + QS_POSTMESSAGE = 0x0008, + QS_TIMER = 0x0010, + QS_PAINT = 0x0020, + QS_SENDMESSAGE = 0x0040, + QS_HOTKEY = 0x0080, + QS_ALLPOSTMESSAGE = 0x0100, + QS_EVENT = 0x02000, + QS_MOUSE = QS_MOUSEMOVE | QS_MOUSEBUTTON, + QS_INPUT = QS_MOUSE | QS_KEY, + QS_ALLEVENTS = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY, + QS_ALLINPUT = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY | QS_SENDMESSAGE + } + + [Flags] + internal enum MsgWaitForMultipleObjectsFlags + { + MWMO_WAITALL = 0x0001, + MWMO_ALERTABLE = 0x0002, + MWMO_INPUTAVAILABLE = 0x0004 + } + + [DllImport("user32", EntryPoint="MsgWaitForMultipleObjectsEx", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)] + private static extern int IntMsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds, + QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags); + + internal static int MsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds, + QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags) + { + int result = IntMsgWaitForMultipleObjectsEx(nCount, pHandles, dwMilliseconds, dwWakeMask, dwFlags); + if(result == -1) + { + throw new Win32Exception(); + } + + return result; + } + [DllImport("user32.dll")] internal static extern int SetWindowCompositionAttribute(IntPtr hwnd, ref WindowCompositionAttributeData data); diff --git a/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs b/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs new file mode 100644 index 0000000000..581e5fa306 --- /dev/null +++ b/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs @@ -0,0 +1,121 @@ +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Threading; +using Avalonia.Threading; +using Avalonia.Win32.Interop; +using static Avalonia.Win32.Interop.UnmanagedMethods; +namespace Avalonia.Win32; + +internal class Win32DispatcherImpl : IControlledDispatcherImpl +{ + private readonly IntPtr _messageWindow; + private static Thread? s_uiThread; + private readonly Stopwatch _clock = Stopwatch.StartNew(); + public Win32DispatcherImpl(IntPtr messageWindow) + { + _messageWindow = messageWindow; + s_uiThread = Thread.CurrentThread; + } + + public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread; + internal const int SignalW = unchecked((int)0xdeadbeaf); + internal const int SignalL = unchecked((int)0x12345678); + + public void Signal() => + // Messages from PostMessage are always processed before any user input, + // so Win32 should call us ASAP + PostMessage( + _messageWindow, + (int)WindowsMessage.WM_DISPATCH_WORK_ITEM, + new IntPtr(SignalW), + new IntPtr(SignalL)); + + public void DispatchWorkItem() => Signaled?.Invoke(); + + public event Action? Signaled; + public event Action? Timer; + + public void FireTimer() => Timer?.Invoke(); + + public void UpdateTimer(long? dueTimeInMs) + { + if (dueTimeInMs == null) + { + KillTimer(_messageWindow, (IntPtr)Win32Platform.TIMERID_DISPATCHER); + } + else + { + var interval = (uint)Math.Min(int.MaxValue - 10, Math.Max(1, Now - dueTimeInMs.Value)); + SetTimer( + _messageWindow, + (IntPtr)Win32Platform.TIMERID_DISPATCHER, + interval, + null!); + } + } + + public bool CanQueryPendingInput => true; + + public bool HasPendingInput + { + get + { + // We need to know if there is any pending input in the Win32 + // queue because we want to only process Avalon "background" + // items after Win32 input has been processed. + // + // Win32 provides the GetQueueStatus API -- but it has a major + // drawback: it only counts "new" input. This means that + // sometimes it could return false, even if there really is input + // that needs to be processed. This results in very hard to + // find bugs. + // + // Luckily, Win32 also provides the MsgWaitForMultipleObjectsEx + // API. While more awkward to use, this API can return queue + // status information even if the input is "old". The various + // flags we use are: + // + // QS_INPUT + // This represents any pending input - such as mouse moves, or + // key presses. It also includes the new GenericInput messages. + // + // QS_EVENT + // This is actually a private flag that represents the various + // events that can be queued in Win32. Some of these events + // can cause input, but Win32 doesn't include them in the + // QS_INPUT flag. An example is WM_MOUSELEAVE. + // + // QS_POSTMESSAGE + // If there is already a message in the queue, we need to process + // it before we can process input. + // + // MWMO_INPUTAVAILABLE + // This flag indicates that any input (new or old) is to be + // reported. + // + + return MsgWaitForMultipleObjectsEx(0, null, 0, + QueueStatusFlags.QS_INPUT | QueueStatusFlags.QS_EVENT | QueueStatusFlags.QS_POSTMESSAGE, + MsgWaitForMultipleObjectsFlags.MWMO_INPUTAVAILABLE) == 0; + } + } + + public void RunLoop(CancellationToken cancellationToken) + { + var result = 0; + while (!cancellationToken.IsCancellationRequested + && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0) + { + TranslateMessage(ref msg); + DispatchMessage(ref msg); + } + if (result < 0) + { + Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform) + ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error()); + } + } + + public long Now => _clock.ElapsedMilliseconds; +} diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs index 7a9f2bb814..857af3a783 100644 --- a/src/Windows/Avalonia.Win32/Win32Platform.cs +++ b/src/Windows/Avalonia.Win32/Win32Platform.cs @@ -107,21 +107,22 @@ namespace Avalonia namespace Avalonia.Win32 { - internal class Win32Platform : IPlatformThreadingInterface, IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl + internal class Win32Platform : IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl { private static readonly Win32Platform s_instance = new(); - private static Thread? s_uiThread; private static Win32PlatformOptions? s_options; private static Compositor? s_compositor; + internal const int TIMERID_DISPATCHER = 1; private WndProc? _wndProcDelegate; private IntPtr _hwnd; - private readonly List _delegates = new(); + private Win32DispatcherImpl _dispatcher; public Win32Platform() { SetDpiAwareness(); CreateMessageWindow(); + _dispatcher = new Win32DispatcherImpl(_hwnd); } internal static Win32Platform Instance => s_instance; @@ -157,7 +158,7 @@ namespace Avalonia.Win32 .Bind().ToConstant(CursorFactory.Instance) .Bind().ToConstant(WindowsKeyboardDevice.Instance) .Bind().ToSingleton() - .Bind().ToConstant(s_instance) + .Bind().ToConstant(s_instance._dispatcher) .Bind().ToConstant(new RenderLoop()) .Bind().ToConstant(renderTimer) .Bind().ToConstant(s_instance) @@ -174,8 +175,6 @@ namespace Avalonia.Win32 .Bind().ToConstant(new WindowsMountedVolumeInfoProvider()) .Bind().ToConstant(s_instance); - s_uiThread = Thread.CurrentThread; - var platformGraphics = options.CustomPlatformGraphics ?? Win32GlManager.Initialize(); @@ -184,88 +183,16 @@ namespace Avalonia.Win32 s_compositor = new Compositor(AvaloniaLocator.Current.GetRequiredService(), platformGraphics); } - - public bool HasMessages() - { - return PeekMessage(out _, IntPtr.Zero, 0, 0, 0); - } - - public void ProcessMessage() - { - if (GetMessage(out var msg, IntPtr.Zero, 0, 0) > -1) - { - TranslateMessage(ref msg); - DispatchMessage(ref msg); - } - else - { - Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform) - ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(ProcessMessage), Marshal.GetLastWin32Error()); - - } - } - - public void RunLoop(CancellationToken cancellationToken) - { - var result = 0; - while (!cancellationToken.IsCancellationRequested - && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0) - { - TranslateMessage(ref msg); - DispatchMessage(ref msg); - } - if (result < 0) - { - Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform) - ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error()); - } - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action callback) - { - TimerProc timerDelegate = (_, _, _, _) => callback(); - - IntPtr handle = SetTimer( - IntPtr.Zero, - IntPtr.Zero, - (uint)interval.TotalMilliseconds, - timerDelegate); - - // Prevent timerDelegate being garbage collected. - _delegates.Add(timerDelegate); - - return Disposable.Create(() => - { - _delegates.Remove(timerDelegate); - KillTimer(IntPtr.Zero, handle); - }); - } - - private const int SignalW = unchecked((int)0xdeadbeaf); - private const int SignalL = unchecked((int)0x12345678); - - public void Signal(DispatcherPriority prio) - { - PostMessage( - _hwnd, - (int)WindowsMessage.WM_DISPATCH_WORK_ITEM, - new IntPtr(SignalW), - new IntPtr(SignalL)); - } - - public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread; - - public event Action? Signaled; - + public event EventHandler? ShutdownRequested; [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")] private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) { - if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM && wParam.ToInt64() == SignalW && lParam.ToInt64() == SignalL) - { - Signaled?.Invoke(null); - } + if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM + && wParam.ToInt64() == Win32DispatcherImpl.SignalW + && lParam.ToInt64() == Win32DispatcherImpl.SignalL) + _dispatcher?.DispatchWorkItem(); if(msg == (uint)WindowsMessage.WM_QUERYENDSESSION) { @@ -292,6 +219,12 @@ namespace Avalonia.Win32 win32PlatformSettings.OnColorValuesChanged(); } } + + if (msg == (uint)WindowsMessage.WM_TIMER) + { + if (wParam == (IntPtr)TIMERID_DISPATCHER) + _dispatcher?.FireTimer(); + } TrayIconImpl.ProcWnd(hWnd, msg, wParam, lParam); diff --git a/src/iOS/Avalonia.iOS/PlatformThreadingInterface.cs b/src/iOS/Avalonia.iOS/PlatformThreadingInterface.cs index fa36ab6c79..93caecf711 100644 --- a/src/iOS/Avalonia.iOS/PlatformThreadingInterface.cs +++ b/src/iOS/Avalonia.iOS/PlatformThreadingInterface.cs @@ -14,11 +14,6 @@ namespace Avalonia.iOS public bool CurrentThreadIsLoopThread => NSThread.Current.IsMainThread; public event Action Signaled; - public void RunLoop(CancellationToken cancellationToken) - { - //Mobile platforms are using external main loop - throw new NotSupportedException(); - } public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) => NSTimer.CreateRepeatingScheduledTimer(interval, _ => tick()); diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs index 9f74d2fc08..e4080dd0a9 100644 --- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs +++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs @@ -962,12 +962,12 @@ namespace Avalonia.Base.UnitTests var currentThreadId = Thread.CurrentThread.ManagedThreadId; var raised = 0; - var threadingInterfaceMock = new Mock(); - threadingInterfaceMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) + var dispatcherMock = new Mock(); + dispatcherMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) .Returns(() => Thread.CurrentThread.ManagedThreadId == currentThreadId); var services = new TestServices( - threadingInterface: threadingInterfaceMock.Object); + dispatcherImpl: dispatcherMock.Object); target.PropertyChanged += (s, e) => { @@ -1000,12 +1000,12 @@ namespace Avalonia.Base.UnitTests var currentThreadId = Thread.CurrentThread.ManagedThreadId; var raised = 0; - var threadingInterfaceMock = new Mock(); - threadingInterfaceMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) + var dispatcherMock = new Mock(); + dispatcherMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) .Returns(() => Thread.CurrentThread.ManagedThreadId == currentThreadId); var services = new TestServices( - threadingInterface: threadingInterfaceMock.Object); + dispatcherImpl: dispatcherMock.Object); target.PropertyChanged += (s, e) => { @@ -1038,12 +1038,12 @@ namespace Avalonia.Base.UnitTests var currentThreadId = Thread.CurrentThread.ManagedThreadId; var raised = 0; - var threadingInterfaceMock = new Mock(); + var threadingInterfaceMock = new Mock(); threadingInterfaceMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) .Returns(() => Thread.CurrentThread.ManagedThreadId == currentThreadId); var services = new TestServices( - threadingInterface: threadingInterfaceMock.Object); + dispatcherImpl: threadingInterfaceMock.Object); target.PropertyChanged += (s, e) => { @@ -1071,12 +1071,12 @@ namespace Avalonia.Base.UnitTests var source = new Subject(); var currentThreadId = Thread.CurrentThread.ManagedThreadId; - var threadingInterfaceMock = new Mock(); + var threadingInterfaceMock = new Mock(); threadingInterfaceMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) .Returns(() => Thread.CurrentThread.ManagedThreadId == currentThreadId); var services = new TestServices( - threadingInterface: threadingInterfaceMock.Object); + dispatcherImpl: threadingInterfaceMock.Object); using (UnitTestApplication.Start(services)) { diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs index 973090ee92..ad8c2751cd 100644 --- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs +++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Direct.cs @@ -530,12 +530,12 @@ namespace Avalonia.Base.UnitTests var currentThreadId = Thread.CurrentThread.ManagedThreadId; var raised = 0; - var threadingInterfaceMock = new Mock(); - threadingInterfaceMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) + var dispatcherMock = new Mock(); + dispatcherMock.SetupGet(mock => mock.CurrentThreadIsLoopThread) .Returns(() => Thread.CurrentThread.ManagedThreadId == currentThreadId); var services = new TestServices( - threadingInterface: threadingInterfaceMock.Object); + dispatcherImpl: dispatcherMock.Object); target.PropertyChanged += (s, e) => { diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_SetCurrentValue.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_SetCurrentValue.cs index c850fbdb08..ad3f395e4f 100644 --- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_SetCurrentValue.cs +++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_SetCurrentValue.cs @@ -1,4 +1,6 @@ using System; +using System.Reactive.Concurrency; +using System.Reactive.Subjects; using Avalonia.Controls; using Avalonia.Data; using Avalonia.Diagnostics; @@ -351,6 +353,134 @@ namespace Avalonia.Base.UnitTests Assert.Equal("inheriteddefault", target.Inherited); } + [Fact] + public void SetCurrent_Value_Persists_When_Toggling_Style_3() + { + var target = new Class1(); + var root = new TestRoot(target) + { + Styles = + { + new Style(x => x.OfType().Class("foo")) + { + Setters = + { + new Setter(Class1.BarProperty, "bar"), + new Setter(Class1.InheritedProperty, "inherited"), + }, + } + } + }; + + root.LayoutManager.ExecuteInitialLayoutPass(); + + target.SetValue(Class1.FooProperty, "not current", BindingPriority.Template); + target.SetCurrentValue(Class1.FooProperty, "current"); + + Assert.Equal("current", target.Foo); + Assert.Equal("bardefault", target.Bar); + Assert.Equal("inheriteddefault", target.Inherited); + + target.Classes.Add("foo"); + + Assert.Equal("current", target.Foo); + Assert.Equal("bar", target.Bar); + Assert.Equal("inherited", target.Inherited); + + target.Classes.Remove("foo"); + + Assert.Equal("current", target.Foo); + Assert.Equal("bardefault", target.Bar); + Assert.Equal("inheriteddefault", target.Inherited); + } + + [Theory] + [InlineData(BindingPriority.LocalValue)] + [InlineData(BindingPriority.Style)] + [InlineData(BindingPriority.Animation)] + public void CurrentValue_Is_Replaced_By_Binding_Value(BindingPriority priority) + { + var target = new Class1(); + var source = new BehaviorSubject("initial"); + + target.Bind(Class1.FooProperty, source, priority); + target.SetCurrentValue(Class1.FooProperty, "current"); + source.OnNext("new"); + + Assert.Equal("new", target.Foo); + } + + [Fact] + public void CurrentValue_Is_Replaced_By_New_Style_Activation_1() + { + var target = new Class1(); + var root = new TestRoot(target) + { + Styles = + { + new Style(x => x.OfType().Class("foo")) + { + Setters = + { + new Setter(Class1.FooProperty, "initial"), + new Setter(Class1.BarProperty, "bar"), + }, + }, + new Style(x => x.OfType().Class("bar")) + { + Setters = + { + new Setter(Class1.FooProperty, "new"), + new Setter(Class1.BarProperty, "baz"), + }, + }, } + }; + + root.LayoutManager.ExecuteInitialLayoutPass(); + + target.Classes.Add("foo"); + Assert.Equal("initial", target.Foo); + + target.SetCurrentValue(Class1.FooProperty, "current"); + target.Classes.Add("bar"); + + Assert.Equal("new", target.Foo); + } + + [Fact] + public void CurrentValue_Is_Replaced_By_New_Style_Activation_2() + { + var target = new Class1(); + var root = new TestRoot(target) + { + Styles = + { + new Style(x => x.OfType().Class("foo")) + { + Setters = + { + new Setter(Class1.FooProperty, "foo"), + }, + }, + new Style(x => x.OfType().Class("foo")) + { + Setters = + { + new Setter(Class1.BarProperty, "bar"), + }, + }, + } + }; + + root.LayoutManager.ExecuteInitialLayoutPass(); + + target.SetValue(Class1.FooProperty, "template", BindingPriority.Template); + target.SetCurrentValue(Class1.FooProperty, "current"); + + target.Classes.Add("foo"); + Assert.Equal("foo", target.Foo); + } + private BindingPriority GetPriority(AvaloniaObject target, AvaloniaProperty property) { return target.GetDiagnostic(property).Priority; @@ -383,5 +513,23 @@ namespace Avalonia.Base.UnitTests return Math.Min(value, ((Class1)sender).CoerceMax); } } + + private class ViewModel : NotifyingBase + { + private string _value; + + public string Value + { + get => _value; + set + { + if (_value != value) + { + _value = value; + RaisePropertyChanged(); + } + } + } + } } } diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Threading.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Threading.cs index 7b68852f03..7f1251f73e 100644 --- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Threading.cs +++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Threading.cs @@ -11,12 +11,12 @@ namespace Avalonia.Base.UnitTests { public class AvaloniaObjectTests_Threading { - private ThreadingInterface _threading = new ThreadingInterface(true); + private TestDipatcherImpl _threading = new(true); [Fact] public void AvaloniaObject_Constructor_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: new ThreadingInterface()))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: new TestDipatcherImpl()))) { Assert.Throws(() => new Class1()); } @@ -25,7 +25,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void StyledProperty_GetValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -36,7 +36,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void StyledProperty_SetValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -47,7 +47,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void Setting_StyledProperty_Binding_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -61,7 +61,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void StyledProperty_ClearValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -72,7 +72,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void StyledProperty_IsSet_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -83,7 +83,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void DirectProperty_GetValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -94,7 +94,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void DirectProperty_SetValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -105,7 +105,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void Setting_DirectProperty_Binding_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -119,7 +119,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void DirectProperty_ClearValue_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -130,7 +130,7 @@ namespace Avalonia.Base.UnitTests [Fact] public void DirectProperty_IsSet_Should_Throw() { - using (UnitTestApplication.Start(new TestServices(threadingInterface: _threading))) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: _threading))) { var target = new Class1(); _threading.CurrentThreadIsLoopThread = false; @@ -147,10 +147,10 @@ namespace Avalonia.Base.UnitTests AvaloniaProperty.RegisterDirect("Qux", _ => null, (o, v) => { }); } - private class ThreadingInterface : IPlatformThreadingInterface + private class TestDipatcherImpl : IDispatcherImpl { - public ThreadingInterface(bool isLoopThread = false) + public TestDipatcherImpl(bool isLoopThread = false) { CurrentThreadIsLoopThread = isLoopThread; } @@ -158,23 +158,17 @@ namespace Avalonia.Base.UnitTests public bool CurrentThreadIsLoopThread { get; set; } #pragma warning disable 67 - public event Action Signaled; -#pragma warning restore 67 - - public void RunLoop(CancellationToken cancellationToken) - { - throw new NotImplementedException(); - } - - public void Signal(DispatcherPriority prio) + public event Action Signaled; + public event Action Timer; + public long Now => 0; + public void UpdateTimer(long? dueTimeInMs) { throw new NotImplementedException(); } + public void Signal() => throw new NotImplementedException(); +#pragma warning restore 67 - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - throw new NotImplementedException(); - } + } } } diff --git a/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs b/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs index 41c0eb3958..510d7c2c6d 100644 --- a/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs +++ b/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs @@ -62,13 +62,24 @@ public class CompositionAnimationTests } } } + + class DummyDispatcher : IDispatcher + { + public bool CheckAccess() => true; + + public void VerifyAccess() + { + } + + public void Post(Action action, DispatcherPriority priority = default) => throw new NotSupportedException(); + } [AnimationDataProvider] [Theory] public void GenericCheck(AnimationData data) { var compositor = - new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new Dispatcher(null)), null); + new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new DummyDispatcher()), null); var target = compositor.CreateSolidColorVisual(); var ani = new ScalarKeyFrameAnimation(null); foreach (var frame in data.Frames) diff --git a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs new file mode 100644 index 0000000000..38175ad410 --- /dev/null +++ b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs @@ -0,0 +1,173 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Avalonia.Threading; +using Xunit; +namespace Avalonia.Base.UnitTests; + +public class DispatcherTests +{ + class SimpleDispatcherImpl : IDispatcherImpl, IDispatcherImplWithPendingInput + { + public bool CurrentThreadIsLoopThread => true; + + public void Signal() => AskedForSignal = true; + + public event Action Signaled; + public event Action Timer; + public long? NextTimer { get; private set; } + public bool AskedForSignal { get; private set; } + + public void UpdateTimer(long? dueTimeInTicks) + { + NextTimer = dueTimeInTicks; + } + + public long Now { get; set; } + + public void ExecuteSignal() + { + if (!AskedForSignal) + return; + AskedForSignal = false; + Signaled?.Invoke(); + } + + public void ExecuteTimer() + { + if (NextTimer == null) + return; + Now = NextTimer.Value; + Timer?.Invoke(); + } + + public bool CanQueryPendingInput => TestInputPending != null; + public bool HasPendingInput => TestInputPending == true; + public bool? TestInputPending { get; set; } + } + + + [Fact] + public void DispatcherExecutesJobsAccordingToPriority() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl); + var actions = new List(); + disp.Post(()=>actions.Add("Background"), DispatcherPriority.Background); + disp.Post(()=>actions.Add("Render"), DispatcherPriority.Render); + disp.Post(()=>actions.Add("Input"), DispatcherPriority.Input); + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + Assert.Equal(new[] { "Render", "Input", "Background" }, actions); + } + + [Fact] + public void DispatcherPreservesOrderWhenChangingPriority() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl); + var actions = new List(); + var toPromote = disp.InvokeAsync(()=>actions.Add("PromotedRender"), DispatcherPriority.Background); + var toPromote2 = disp.InvokeAsync(()=>actions.Add("PromotedRender2"), DispatcherPriority.Input); + disp.Post(() => actions.Add("Render"), DispatcherPriority.Render); + + toPromote.Priority = DispatcherPriority.Render; + toPromote2.Priority = DispatcherPriority.Render; + + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + + Assert.Equal(new[] { "PromotedRender", "PromotedRender2", "Render" }, actions); + } + + [Fact] + public void DispatcherStopsItemProcessingWhenInteractivityDeadlineIsReached() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl); + var actions = new List(); + for (var c = 0; c < 10; c++) + { + var itemId = c; + disp.Post(() => + { + actions.Add(itemId); + impl.Now += 20; + }, DispatcherPriority.Background); + } + + Assert.False(impl.AskedForSignal); + Assert.NotNull(impl.NextTimer); + + for (var c = 0; c < 4; c++) + { + Assert.NotNull(impl.NextTimer); + Assert.False(impl.AskedForSignal); + impl.ExecuteTimer(); + Assert.False(impl.AskedForSignal); + impl.ExecuteSignal(); + var expectedCount = (c + 1) * 3; + if (c == 3) + expectedCount = 10; + + Assert.Equal(Enumerable.Range(0, expectedCount), actions); + Assert.False(impl.AskedForSignal); + if (c < 3) + { + Assert.True(impl.NextTimer > impl.Now); + } + else + Assert.Null(impl.NextTimer); + } + } + + + [Fact] + public void DispatcherStopsItemProcessingWhenInputIsPending() + { + var impl = new SimpleDispatcherImpl(); + impl.TestInputPending = true; + var disp = new Dispatcher(impl); + var actions = new List(); + for (var c = 0; c < 10; c++) + { + var itemId = c; + disp.Post(() => + { + actions.Add(itemId); + if (itemId == 0 || itemId == 3 || itemId == 7) + impl.TestInputPending = true; + }, DispatcherPriority.Background); + } + Assert.False(impl.AskedForSignal); + Assert.NotNull(impl.NextTimer); + impl.TestInputPending = false; + + for (var c = 0; c < 4; c++) + { + Assert.NotNull(impl.NextTimer); + impl.ExecuteTimer(); + Assert.False(impl.AskedForSignal); + var expectedCount = c switch + { + 0 => 1, + 1 => 4, + 2 => 8, + 3 => 10 + }; + + Assert.Equal(Enumerable.Range(0, expectedCount), actions); + Assert.False(impl.AskedForSignal); + if (c < 3) + { + Assert.True(impl.NextTimer > impl.Now); + impl.Now = impl.NextTimer.Value + 1; + } + else + Assert.Null(impl.NextTimer); + + impl.TestInputPending = false; + } + } + +} \ No newline at end of file diff --git a/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs b/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs index d466f6a4a5..c3630c36b7 100644 --- a/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs +++ b/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs @@ -1,5 +1,7 @@ using System; using System.Collections.Generic; +using System.Linq; +using Avalonia.Base.UnitTests.Utilities; using Avalonia.Controls; using Avalonia.Input; using Avalonia.Input.GestureRecognizers; @@ -7,14 +9,16 @@ using Avalonia.Media; using Avalonia.Platform; using Avalonia.Threading; using Avalonia.UnitTests; +using Avalonia.Utilities; using Moq; using Xunit; +// ReSharper disable RedundantArgumentDefaultValue namespace Avalonia.Base.UnitTests.Input { public class GesturesTests { - private MouseTestHelper _mouse = new MouseTestHelper(); + private readonly MouseTestHelper _mouse = new MouseTestHelper(); [Fact] public void Tapped_Should_Follow_Pointer_Pressed_Released() @@ -60,7 +64,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.TappedEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.TappedEvent, (_, _) => raised = true); _mouse.Click(border, MouseButton.Middle); @@ -77,7 +81,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.TappedEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.TappedEvent, (_, _) => raised = true); _mouse.Click(border, MouseButton.Right); @@ -94,7 +98,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.RightTappedEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.RightTappedEvent, (_, _) => raised = true); _mouse.Click(border, MouseButton.Right); @@ -147,7 +151,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.DoubleTappedEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.DoubleTappedEvent, (_, _) => raised = true); _mouse.Click(border, MouseButton.Middle); _mouse.Down(border, MouseButton.Middle, clickCount: 2); @@ -165,7 +169,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.DoubleTappedEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.DoubleTappedEvent, (_, _) => raised = true); _mouse.Click(border, MouseButton.Right); _mouse.Down(border, MouseButton.Right, clickCount: 2); @@ -182,10 +186,8 @@ namespace Avalonia.Base.UnitTests.Input iSettingsMock.Setup(x => x.GetTapSize(It.IsAny())).Returns(new Size(16, 16)); AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -195,15 +197,15 @@ namespace Avalonia.Base.UnitTests.Input }; HoldingState holding = HoldingState.Cancelled; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => holding = e.HoldingState); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => holding = e.HoldingState); _mouse.Down(border); Assert.False(holding != HoldingState.Cancelled); // Verify timer duration, but execute it immediately. - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); Assert.True(holding == HoldingState.Started); @@ -220,10 +222,8 @@ namespace Avalonia.Base.UnitTests.Input iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300)); AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -233,7 +233,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Started); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => raised = e.HoldingState == HoldingState.Started); _mouse.Down(border); Assert.False(raised); @@ -242,9 +242,9 @@ namespace Avalonia.Base.UnitTests.Input Assert.False(raised); // Verify timer duration, but execute it immediately. - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); Assert.False(raised); } @@ -257,10 +257,8 @@ namespace Avalonia.Base.UnitTests.Input iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300)); AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -270,7 +268,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Completed); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => raised = e.HoldingState == HoldingState.Completed); _mouse.Down(border); Assert.False(raised); @@ -279,9 +277,9 @@ namespace Avalonia.Base.UnitTests.Input Assert.False(raised); // Verify timer duration, but execute it immediately. - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); Assert.False(raised); } @@ -294,10 +292,8 @@ namespace Avalonia.Base.UnitTests.Input iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300)); AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -307,14 +303,14 @@ namespace Avalonia.Base.UnitTests.Input }; var cancelled = false; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => cancelled = e.HoldingState == HoldingState.Cancelled); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => cancelled = e.HoldingState == HoldingState.Cancelled); _mouse.Down(border); Assert.False(cancelled); - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); var secondMouse = new MouseTestHelper(); @@ -333,9 +329,7 @@ namespace Avalonia.Base.UnitTests.Input AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -345,13 +339,13 @@ namespace Avalonia.Base.UnitTests.Input }; var cancelled = false; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => cancelled = e.HoldingState == HoldingState.Cancelled); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => cancelled = e.HoldingState == HoldingState.Cancelled); _mouse.Down(border); - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); _mouse.Move(border, position: new Point(3, 3)); @@ -371,9 +365,7 @@ namespace Avalonia.Base.UnitTests.Input AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(iSettingsMock.Object); - var scheduledTimers = new List<(TimeSpan time, Action action)>(); - using var app = UnitTestApplication.Start(new TestServices( - threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t)))); + using var app = UnitTestApplication.Start(); Border border = new Border(); Gestures.SetIsHoldWithMouseEnabled(border, true); @@ -383,31 +375,21 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Completed); + decorator.AddHandler(Gestures.HoldingEvent, (_, e) => raised = e.HoldingState == HoldingState.Completed); var secondMouse = new MouseTestHelper(); _mouse.Down(border, MouseButton.Left); // Verify timer duration, but execute it immediately. - var timer = Assert.Single(scheduledTimers); - Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time); - timer.action(); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.Interval); + timer.ForceFire(); secondMouse.Down(border, MouseButton.Left); Assert.False(raised); } - - private static IPlatformThreadingInterface CreatePlatformThreadingInterface(Action<(TimeSpan, Action)> callback) - { - var threadingInterface = new Mock(); - threadingInterface.SetupGet(p => p.CurrentThreadIsLoopThread).Returns(true); - threadingInterface.Setup(p => p - .StartTimer(It.IsAny(), It.IsAny(), It.IsAny())) - .Callback((_, t, a) => callback((t, a))); - return threadingInterface.Object; - } private static void AddHandlers( Decorator decorator, @@ -415,7 +397,7 @@ namespace Avalonia.Base.UnitTests.Input IList result, bool markHandled) { - decorator.AddHandler(Border.PointerPressedEvent, (s, e) => + decorator.AddHandler(InputElement.PointerPressedEvent, (_, e) => { result.Add("dp"); @@ -425,7 +407,7 @@ namespace Avalonia.Base.UnitTests.Input } }); - decorator.AddHandler(Border.PointerReleasedEvent, (s, e) => + decorator.AddHandler(InputElement.PointerReleasedEvent, (_, e) => { result.Add("dr"); @@ -435,13 +417,13 @@ namespace Avalonia.Base.UnitTests.Input } }); - border.AddHandler(Border.PointerPressedEvent, (s, e) => result.Add("bp")); - border.AddHandler(Border.PointerReleasedEvent, (s, e) => result.Add("br")); + border.AddHandler(InputElement.PointerPressedEvent, (_, _) => result.Add("bp")); + border.AddHandler(InputElement.PointerReleasedEvent, (_, _) => result.Add("br")); - decorator.AddHandler(Gestures.TappedEvent, (s, e) => result.Add("dt")); - decorator.AddHandler(Gestures.DoubleTappedEvent, (s, e) => result.Add("ddt")); - border.AddHandler(Gestures.TappedEvent, (s, e) => result.Add("bt")); - border.AddHandler(Gestures.DoubleTappedEvent, (s, e) => result.Add("bdt")); + decorator.AddHandler(Gestures.TappedEvent, (_, _) => result.Add("dt")); + decorator.AddHandler(Gestures.DoubleTappedEvent, (_, _) => result.Add("ddt")); + border.AddHandler(Gestures.TappedEvent, (_, _) => result.Add("bt")); + border.AddHandler(Gestures.DoubleTappedEvent, (_, _) => result.Add("bdt")); } [Fact] @@ -462,7 +444,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.PinchEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.PinchEvent, (_, _) => raised = true); var firstPoint = new Point(5, 5); var secondPoint = new Point(10, 10); @@ -490,7 +472,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.PinchEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.PinchEvent, (_, _) => raised = true); var firstPoint = new Point(5, 5); var secondPoint = new Point(10, 10); @@ -526,7 +508,7 @@ namespace Avalonia.Base.UnitTests.Input }; var raised = false; - decorator.AddHandler(Gestures.ScrollGestureEvent, (s, e) => raised = true); + decorator.AddHandler(Gestures.ScrollGestureEvent, (_, _) => raised = true); var firstTouch = new TouchTestHelper(); diff --git a/tests/Avalonia.Base.UnitTests/Input/MouseDeviceTests.cs b/tests/Avalonia.Base.UnitTests/Input/MouseDeviceTests.cs index 1bb1b4af73..642e762c1b 100644 --- a/tests/Avalonia.Base.UnitTests/Input/MouseDeviceTests.cs +++ b/tests/Avalonia.Base.UnitTests/Input/MouseDeviceTests.cs @@ -3,6 +3,7 @@ using Avalonia.Input; using Avalonia.Input.Raw; using Avalonia.Media; using Avalonia.Platform; +using Avalonia.Threading; using Avalonia.UnitTests; using Moq; using Xunit; @@ -16,9 +17,9 @@ namespace Avalonia.Base.UnitTests.Input { using var scope = AvaloniaLocator.EnterScope(); var settingsMock = new Mock(); - var threadingMock = new Mock(); + var dispatcherMock = new Mock(); - threadingMock.Setup(x => x.CurrentThreadIsLoopThread).Returns(true); + dispatcherMock.Setup(x => x.CurrentThreadIsLoopThread).Returns(true); AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(settingsMock.Object); @@ -26,7 +27,7 @@ namespace Avalonia.Base.UnitTests.Input using var app = UnitTestApplication.Start( new TestServices( inputManager: new InputManager(), - threadingInterface: threadingMock.Object)); + dispatcherImpl: dispatcherMock.Object)); var renderer = RendererMocks.CreateRenderer(); var device = new MouseDevice(); diff --git a/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs b/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs index 36587ea222..0653d49191 100644 --- a/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs +++ b/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs @@ -1,6 +1,7 @@ using System; using Avalonia.Input.Raw; using Avalonia.Platform; +using Avalonia.Threading; using Avalonia.UnitTests; using Moq; using Xunit; @@ -207,7 +208,7 @@ namespace Avalonia.Input.UnitTests private IDisposable UnitTestApp(TimeSpan doubleClickTime = new TimeSpan()) { var unitTestApp = UnitTestApplication.Start( - new TestServices(inputManager: new InputManager(), threadingInterface: Mock.Of(x => x.CurrentThreadIsLoopThread == true))); + new TestServices(inputManager: new InputManager(), dispatcherImpl: Mock.Of(x => x.CurrentThreadIsLoopThread == true))); var iSettingsMock = new Mock(); iSettingsMock.Setup(x => x.GetDoubleTapTime(It.IsAny())).Returns(doubleClickTime); iSettingsMock.Setup(x => x.GetDoubleTapSize(It.IsAny())).Returns(new Size(16, 16)); diff --git a/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs index 6855a378b4..97740fab00 100644 --- a/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs +++ b/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs @@ -47,9 +47,8 @@ namespace Avalonia.Base.UnitTests.Rendering { var dispatcher = new Mock(); dispatcher.Setup( - d => d.InvokeAsync(It.IsAny(), DispatcherPriority.Render)) - .Callback((Action a, DispatcherPriority _) => a()) - .Returns(Task.CompletedTask); + d => d.Post(It.IsAny(), DispatcherPriority.Render)) + .Callback((Action a, DispatcherPriority _) => a()); var timer = new Mock(); var loop = new RenderLoop(timer.Object, dispatcher.Object); diff --git a/tests/Avalonia.Benchmarks/Layout/ControlsBenchmark.cs b/tests/Avalonia.Benchmarks/Layout/ControlsBenchmark.cs index eacf73ac94..5df1dd1679 100644 --- a/tests/Avalonia.Benchmarks/Layout/ControlsBenchmark.cs +++ b/tests/Avalonia.Benchmarks/Layout/ControlsBenchmark.cs @@ -18,7 +18,7 @@ namespace Avalonia.Benchmarks.Layout _app = UnitTestApplication.Start( TestServices.StyledWindow.With( renderInterface: new NullRenderingPlatform(), - threadingInterface: new NullThreadingPlatform(), + dispatcherImpl: new NullThreadingPlatform(), standardCursorFactory: new NullCursorFactory())); _root = new TestRoot(true, null) diff --git a/tests/Avalonia.Benchmarks/NullThreadingPlatform.cs b/tests/Avalonia.Benchmarks/NullThreadingPlatform.cs index bb469a6b33..1b5b60031c 100644 --- a/tests/Avalonia.Benchmarks/NullThreadingPlatform.cs +++ b/tests/Avalonia.Benchmarks/NullThreadingPlatform.cs @@ -6,26 +6,22 @@ using Avalonia.Threading; namespace Avalonia.Benchmarks { - internal class NullThreadingPlatform : IPlatformThreadingInterface + internal class NullThreadingPlatform : IDispatcherImpl { - public void RunLoop(CancellationToken cancellationToken) + public void Signal() { } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - return Disposable.Empty; - } - - public void Signal(DispatcherPriority priority) + + public void UpdateTimer(long? dueTimeInMs) { } public bool CurrentThreadIsLoopThread => true; #pragma warning disable CS0067 - public event Action Signaled; + public event Action Signaled; + public event Action Timer; + public long Now => 0; #pragma warning restore CS0067 - } } diff --git a/tests/Avalonia.Benchmarks/Styling/ControlTheme_Change.cs b/tests/Avalonia.Benchmarks/Styling/ControlTheme_Change.cs index 627edfdeb6..00080e3b82 100644 --- a/tests/Avalonia.Benchmarks/Styling/ControlTheme_Change.cs +++ b/tests/Avalonia.Benchmarks/Styling/ControlTheme_Change.cs @@ -23,7 +23,7 @@ namespace Avalonia.Benchmarks.Styling _app = UnitTestApplication.Start( TestServices.StyledWindow.With( renderInterface: new NullRenderingPlatform(), - threadingInterface: new NullThreadingPlatform())); + dispatcherImpl: new NullThreadingPlatform())); // Simulate an application with a lot of styles by creating a tree of nested panels, // each with a bunch of styles applied. diff --git a/tests/Avalonia.Benchmarks/Styling/ResourceBenchmarks.cs b/tests/Avalonia.Benchmarks/Styling/ResourceBenchmarks.cs index bc47e68bc1..b044bcde59 100644 --- a/tests/Avalonia.Benchmarks/Styling/ResourceBenchmarks.cs +++ b/tests/Avalonia.Benchmarks/Styling/ResourceBenchmarks.cs @@ -23,7 +23,7 @@ namespace Avalonia.Benchmarks.Styling renderInterface: new MockPlatformRenderInterface(), standardCursorFactory: Mock.Of(), theme: () => CreateTheme(), - threadingInterface: new NullThreadingPlatform(), + dispatcherImpl: new NullThreadingPlatform(), fontManagerImpl: new MockFontManagerImpl(), textShaperImpl: new MockTextShaperImpl(), windowingPlatform: new MockWindowingPlatform()); diff --git a/tests/Avalonia.Benchmarks/Styling/Style_Apply_Detach_Complex.cs b/tests/Avalonia.Benchmarks/Styling/Style_Apply_Detach_Complex.cs index a6be6c0c18..307f15a6c0 100644 --- a/tests/Avalonia.Benchmarks/Styling/Style_Apply_Detach_Complex.cs +++ b/tests/Avalonia.Benchmarks/Styling/Style_Apply_Detach_Complex.cs @@ -20,7 +20,7 @@ namespace Avalonia.Benchmarks.Styling _app = UnitTestApplication.Start( TestServices.StyledWindow.With( renderInterface: new NullRenderingPlatform(), - threadingInterface: new NullThreadingPlatform())); + dispatcherImpl: new NullThreadingPlatform())); // Simulate an application with a lot of styles by creating a tree of nested panels, // each with a bunch of styles applied. diff --git a/tests/Avalonia.Benchmarks/Text/HugeTextLayout.cs b/tests/Avalonia.Benchmarks/Text/HugeTextLayout.cs index 03b85840a7..22ca9d8c6d 100644 --- a/tests/Avalonia.Benchmarks/Text/HugeTextLayout.cs +++ b/tests/Avalonia.Benchmarks/Text/HugeTextLayout.cs @@ -32,7 +32,7 @@ public class HugeTextLayout : IDisposable var testServices = TestServices.StyledWindow.With( renderInterface: new NullRenderingPlatform(), - threadingInterface: new NullThreadingPlatform(), + dispatcherImpl: new NullThreadingPlatform(), standardCursorFactory: new NullCursorFactory()); if (s_useSkia) diff --git a/tests/Avalonia.Benchmarks/Themes/FluentBenchmark.cs b/tests/Avalonia.Benchmarks/Themes/FluentBenchmark.cs index 1115bc9760..e9b82d5381 100644 --- a/tests/Avalonia.Benchmarks/Themes/FluentBenchmark.cs +++ b/tests/Avalonia.Benchmarks/Themes/FluentBenchmark.cs @@ -47,7 +47,7 @@ namespace Avalonia.Benchmarks.Themes renderInterface: new MockPlatformRenderInterface(), standardCursorFactory: Mock.Of(), theme: () => LoadFluentTheme(), - threadingInterface: new NullThreadingPlatform(), + dispatcherImpl: new NullThreadingPlatform(), fontManagerImpl: new MockFontManagerImpl(), textShaperImpl: new MockTextShaperImpl(), windowingPlatform: new MockWindowingPlatform()); diff --git a/tests/Avalonia.Controls.UnitTests/DesktopStyleApplicationLifetimeTests.cs b/tests/Avalonia.Controls.UnitTests/DesktopStyleApplicationLifetimeTests.cs index 8cd5816984..90a0db691c 100644 --- a/tests/Avalonia.Controls.UnitTests/DesktopStyleApplicationLifetimeTests.cs +++ b/tests/Avalonia.Controls.UnitTests/DesktopStyleApplicationLifetimeTests.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using Avalonia.Controls.ApplicationLifetimes; using Avalonia.Platform; using Avalonia.Rendering; +using Avalonia.Threading; using Avalonia.UnitTests; using Moq; using Xunit; @@ -12,10 +13,13 @@ namespace Avalonia.Controls.UnitTests public class DesktopStyleApplicationLifetimeTests { + IDispatcherImpl CreateDispatcherWithInstantMainLoop() => Mock.Of(x => x.CurrentThreadIsLoopThread == true); + + [Fact] public void Should_Set_ExitCode_After_Shutdown() { - using (UnitTestApplication.Start(TestServices.MockThreadingInterface)) + using (UnitTestApplication.Start(new TestServices(dispatcherImpl: CreateDispatcherWithInstantMainLoop()))) using(var lifetime = new ClassicDesktopStyleApplicationLifetime()) { lifetime.Shutdown(1337); @@ -215,7 +219,7 @@ namespace Avalonia.Controls.UnitTests [Fact] public void Should_Allow_Canceling_Shutdown_Via_ShutdownRequested_Event() { - using (UnitTestApplication.Start(TestServices.StyledWindow)) + using (UnitTestApplication.Start(TestServices.StyledWindow.With(dispatcherImpl: CreateDispatcherWithInstantMainLoop()))) using (var lifetime = new ClassicDesktopStyleApplicationLifetime()) { var lifetimeEvents = new Mock(); diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs index 3fa2bb515d..9574598038 100644 --- a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs +++ b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs @@ -2084,13 +2084,9 @@ namespace Avalonia.Controls.UnitTests.Primitives [Fact] public void Setting_IsTextSearchEnabled_Enables_Or_Disables_Text_Search() { - var pti = Mock.Of(x => x.CurrentThreadIsLoopThread == true); - - Mock.Get(pti) - .Setup(v => v.StartTimer(It.IsAny(), It.IsAny(), It.IsAny())) - .Returns(Disposable.Empty); - - using (UnitTestApplication.Start(TestServices.StyledWindow.With(threadingInterface: pti))) + var pti = Mock.Of(x => x.CurrentThreadIsLoopThread == true); + + using (UnitTestApplication.Start(TestServices.StyledWindow.With(dispatcherImpl: pti))) { var items = new[] { diff --git a/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs b/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs index 03653ec42c..9b43c469ba 100644 --- a/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs +++ b/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs @@ -1,6 +1,5 @@ -using System; -using System.Collections.Generic; -using System.Text; +using Avalonia.Input; +using Avalonia.UnitTests; using Xunit; namespace Avalonia.Controls.UnitTests @@ -62,5 +61,224 @@ namespace Avalonia.Controls.UnitTests Assert.True(splitView.IsPaneOpen); } + + [Fact] + public void SplitView_TemplateSettings_Are_Correct_For_Display_Modes() + { + using var app = UnitTestApplication.Start(TestServices.StyledWindow); + var wnd = new Window + { + Width = 1280, + Height = 720 + }; + var splitView = new SplitView(); + wnd.Content = splitView; + wnd.Show(); + + var zeroGridLength = new GridLength(0); + var compactLength = splitView.CompactPaneLength; + var compactGridLength = new GridLength(compactLength); + + // Overlay is default DisplayMode + Assert.Equal(0, splitView.TemplateSettings.ClosedPaneWidth); + Assert.Equal(zeroGridLength, splitView.TemplateSettings.PaneColumnGridLength); + + splitView.DisplayMode = SplitViewDisplayMode.CompactOverlay; + Assert.Equal(compactLength, splitView.TemplateSettings.ClosedPaneWidth); + Assert.Equal(compactGridLength, splitView.TemplateSettings.PaneColumnGridLength); + + splitView.DisplayMode = SplitViewDisplayMode.Inline; + Assert.Equal(0, splitView.TemplateSettings.ClosedPaneWidth); + Assert.Equal(GridLength.Auto, splitView.TemplateSettings.PaneColumnGridLength); + + splitView.DisplayMode = SplitViewDisplayMode.CompactInline; + Assert.Equal(compactLength, splitView.TemplateSettings.ClosedPaneWidth); + Assert.Equal(GridLength.Auto, splitView.TemplateSettings.PaneColumnGridLength); + } + + [Fact] + public void SplitView_TemplateSettings_Update_With_CompactPaneLength() + { + var splitView = new SplitView(); + + // CompactInline: + // - ClosedPaneWidth = CompactPaneLength + // - PaneColumnGridLength = Auto + splitView.DisplayMode = SplitViewDisplayMode.CompactInline; + + var compactLength = splitView.CompactPaneLength; + + Assert.Equal(GridLength.Auto, splitView.TemplateSettings.PaneColumnGridLength); + Assert.Equal(compactLength, splitView.TemplateSettings.ClosedPaneWidth); + + splitView.CompactPaneLength = 100; + + Assert.Equal(GridLength.Auto, splitView.TemplateSettings.PaneColumnGridLength); + Assert.Equal(100, splitView.TemplateSettings.ClosedPaneWidth); + + // CompactOverlay: + // - ClosedPaneWidth = CompactPaneLength + // - PaneColumnGridLength = GridLength { CompactPaneLength, Pixel } + splitView.DisplayMode = SplitViewDisplayMode.CompactOverlay; + splitView.CompactPaneLength = 50; + + Assert.Equal(new GridLength(50), splitView.TemplateSettings.PaneColumnGridLength); + Assert.Equal(50, splitView.TemplateSettings.ClosedPaneWidth); + + // Value shouldn't change for these - changing the display mode will update + // the template settings with the right value + splitView.DisplayMode = SplitViewDisplayMode.Inline; + splitView.CompactPaneLength = 1; + + Assert.Equal(GridLength.Auto, splitView.TemplateSettings.PaneColumnGridLength); + Assert.Equal(0, splitView.TemplateSettings.ClosedPaneWidth); + + splitView.DisplayMode = SplitViewDisplayMode.Overlay; + splitView.CompactPaneLength = 2; + + Assert.Equal(new GridLength(0), splitView.TemplateSettings.PaneColumnGridLength); + Assert.Equal(0, splitView.TemplateSettings.ClosedPaneWidth); + } + + [Fact] + public void SplitView_Pointer_Closes_Pane_In_Overlay_Mode() + { + using var app = UnitTestApplication.Start(TestServices.StyledWindow + .With(globalClock: new MockGlobalClock())); + var wnd = new Window + { + Width = 1280, + Height = 720 + }; + var splitView = new SplitView(); + wnd.Content = splitView; + wnd.Show(); + + splitView.IsPaneOpen = true; + + splitView.RaiseEvent(new PointerReleasedEventArgs(splitView, + null, wnd, new Point(1270, 30), 0, + new PointerPointProperties(), + KeyModifiers.None, + MouseButton.Left)); + + Assert.False(splitView.IsPaneOpen); + + // Inline shouldn't close the pane + splitView.DisplayMode = SplitViewDisplayMode.Inline; + splitView.IsPaneOpen = true; + + splitView.RaiseEvent(new PointerReleasedEventArgs(splitView, + null, wnd, new Point(1270, 30), 0, + new PointerPointProperties(), + KeyModifiers.None, + MouseButton.Left)); + + Assert.True(splitView.IsPaneOpen); + } + + [Fact] + public void SplitView_Pointer_Should_Not_Close_Pane_If_Over_Pane() + { + using var app = UnitTestApplication.Start(TestServices.StyledWindow + .With(globalClock: new MockGlobalClock())); + var wnd = new Window + { + Width = 1280, + Height = 720 + }; + var clickBorder = new Border + { + Width = 100, + Height = 100, + HorizontalAlignment = Layout.HorizontalAlignment.Left, + VerticalAlignment = Layout.VerticalAlignment.Top + }; + var splitView = new SplitView + { + Pane = clickBorder + }; + wnd.Content = splitView; + wnd.Show(); + + splitView.IsPaneOpen = true; + + clickBorder.RaiseEvent(new PointerReleasedEventArgs(splitView, + null, wnd, new Point(5, 5), 0, + new PointerPointProperties(), + KeyModifiers.None, + MouseButton.Left)); + + Assert.True(splitView.IsPaneOpen); + } + + [Fact] + public void SplitView_Escape_Key_Closes_Light_Dismissable_Pane() + { + using var app = UnitTestApplication.Start(TestServices.StyledWindow + .With(globalClock: new MockGlobalClock())); + var wnd = new Window + { + Width = 1280, + Height = 720 + }; + var button = new Button(); + var splitView = new SplitView + { + Pane = button + }; + wnd.Content = splitView; + wnd.Show(); + + splitView.IsPaneOpen = true; + + button.RaiseEvent(new KeyEventArgs + { + Key = Key.Escape, + RoutedEvent = InputElement.KeyDownEvent + }); + + Assert.False(splitView.IsPaneOpen); + + splitView.DisplayMode = SplitViewDisplayMode.Inline; + + splitView.IsPaneOpen = true; + + button.RaiseEvent(new KeyEventArgs + { + Key = Key.Escape, + RoutedEvent = InputElement.KeyDownEvent + }); + + Assert.True(splitView.IsPaneOpen); + } + + [Fact] + public void Top_Level_Back_Requested_Closes_Light_Dismissable_Pane() + { + using var app = UnitTestApplication.Start(TestServices.StyledWindow + .With(globalClock: new MockGlobalClock())); + var wnd = new Window + { + Width = 1280, + Height = 720 + }; + var splitView = new SplitView(); + wnd.Content = splitView; + wnd.Show(); + + splitView.IsPaneOpen = true; + + wnd.RaiseEvent(new Interactivity.RoutedEventArgs(TopLevel.BackRequestedEvent)); + + Assert.False(splitView.IsPaneOpen); + + splitView.DisplayMode = SplitViewDisplayMode.Inline; + splitView.IsPaneOpen = true; + + wnd.RaiseEvent(new Interactivity.RoutedEventArgs(TopLevel.BackRequestedEvent)); + + Assert.True(splitView.IsPaneOpen); + } } } diff --git a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs index c196a8f984..74e506105d 100644 --- a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs +++ b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs @@ -4,6 +4,7 @@ using Avalonia.Markup.Xaml; using Avalonia.Platform; using Avalonia.Threading; using Avalonia.UnitTests; +using Avalonia.Utilities; using Avalonia.VisualTree; using Moq; using Xunit; @@ -160,21 +161,7 @@ namespace Avalonia.Controls.UnitTests [Fact] public void Should_Open_On_Pointer_Enter_With_Delay() { - Action timercallback = null; - var delay = TimeSpan.Zero; - - var pti = Mock.Of(x => x.CurrentThreadIsLoopThread == true); - - Mock.Get(pti) - .Setup(v => v.StartTimer(It.IsAny(), It.IsAny(), It.IsAny())) - .Callback((priority, interval, tick) => - { - delay = interval; - timercallback = tick; - }) - .Returns(Disposable.Empty); - - using (UnitTestApplication.Start(TestServices.StyledWindow.With(threadingInterface: pti))) + using (UnitTestApplication.Start(TestServices.StyledWindow)) { var window = new Window(); @@ -194,11 +181,11 @@ namespace Avalonia.Controls.UnitTests _mouseHelper.Enter(target); - Assert.Equal(TimeSpan.FromMilliseconds(1), delay); - Assert.NotNull(timercallback); + var timer = Assert.Single(Dispatcher.SnapshotTimersForUnitTests()); + Assert.Equal(TimeSpan.FromMilliseconds(1), timer.Interval); Assert.False(ToolTip.GetIsOpen(target)); - timercallback(); + timer.ForceFire(); Assert.True(ToolTip.GetIsOpen(target)); } diff --git a/tests/Avalonia.Direct2D1.RenderTests/Avalonia.Direct2D1.RenderTests.csproj b/tests/Avalonia.Direct2D1.RenderTests/Avalonia.Direct2D1.RenderTests.csproj index a99421f107..17e1ab0e50 100644 --- a/tests/Avalonia.Direct2D1.RenderTests/Avalonia.Direct2D1.RenderTests.csproj +++ b/tests/Avalonia.Direct2D1.RenderTests/Avalonia.Direct2D1.RenderTests.csproj @@ -16,6 +16,7 @@ + diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs index 114b9d6064..20a4543b72 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; +using System.Runtime.CompilerServices; using System.Xml; using Avalonia.Controls; using Avalonia.Markup.Xaml.Styling; diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs b/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs index ea03b003ca..6d26de2b29 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.IO; using System.Reflection; using System.Text; +using Avalonia.Controls; using Avalonia.Data; namespace Avalonia.Markup.Xaml.UnitTests @@ -13,6 +14,7 @@ namespace Avalonia.Markup.Xaml.UnitTests { // Ensure necessary assemblies are loaded. var _ = typeof(TemplateBinding); + GC.KeepAlive(typeof(ItemsRepeater)); if (AvaloniaLocator.Current.GetService() == null) AvaloniaLocator.CurrentMutable.Bind() .ToConstant(new TestXamlLoaderShim()); diff --git a/tests/Avalonia.RenderTests/TestBase.cs b/tests/Avalonia.RenderTests/TestBase.cs index 81474d5efb..4732099d60 100644 --- a/tests/Avalonia.RenderTests/TestBase.cs +++ b/tests/Avalonia.RenderTests/TestBase.cs @@ -17,6 +17,8 @@ using Avalonia.Controls.Platform.Surfaces; using Avalonia.Media; using Avalonia.Rendering.Composition; using Avalonia.Threading; +using Avalonia.UnitTests; +using Avalonia.Utilities; using SixLabors.ImageSharp.PixelFormats; using Image = SixLabors.ImageSharp.Image; #if AVALONIA_SKIA @@ -40,8 +42,8 @@ namespace Avalonia.Direct2D1.RenderTests #endif public static FontFamily TestFontFamily = new FontFamily(s_fontUri); - private static readonly TestThreadingInterface threadingInterface = - new TestThreadingInterface(); + private static readonly TestDispatcherImpl threadingInterface = + new TestDispatcherImpl(); private static readonly IAssetLoader assetLoader = new AssetLoader(); @@ -53,7 +55,7 @@ namespace Avalonia.Direct2D1.RenderTests Direct2D1Platform.Initialize(); #endif AvaloniaLocator.CurrentMutable - .Bind() + .Bind() .ToConstant(threadingInterface); AvaloniaLocator.CurrentMutable @@ -122,7 +124,8 @@ namespace Avalonia.Direct2D1.RenderTests // Free pools for (var c = 0; c < 11; c++) - TestThreadingInterface.RunTimers(); + foreach (var dp in Dispatcher.SnapshotTimersForUnitTests()) + dp.ForceFire(); writableBitmap.Save(compositedPath); } } @@ -241,45 +244,27 @@ namespace Avalonia.Direct2D1.RenderTests return path; } - private class TestThreadingInterface : IPlatformThreadingInterface + private class TestDispatcherImpl : IDispatcherImpl { public bool CurrentThreadIsLoopThread => MainThread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId; public Thread MainThread { get; set; } #pragma warning disable 67 - public event Action Signaled; + public event Action Signaled; + public event Action Timer; #pragma warning restore 67 - public void RunLoop(CancellationToken cancellationToken) - { - throw new NotImplementedException(); - } - - public void Signal(DispatcherPriority prio) + public void Signal() { // No-op } - private static List s_timers = new(); - - public static void RunTimers() - { - lock (s_timers) - { - foreach(var t in s_timers.ToList()) - t.Invoke(); - } - } + public long Now => 0; - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) + public void UpdateTimer(long? dueTimeInMs) { - var act = () => tick(); - lock (s_timers) s_timers.Add(act); - return Disposable.Create(() => - { - lock (s_timers) s_timers.Remove(act); - }); + // No-op } } diff --git a/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj b/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj index 0d182678ef..ca9f5ed974 100644 --- a/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj +++ b/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj @@ -17,6 +17,7 @@ + diff --git a/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs b/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs index 4b91209e5b..e18344580b 100644 --- a/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs @@ -68,6 +68,66 @@ namespace Avalonia.Skia.UnitTests.Media return true; } + public IGlyphTypeface CreateGlyphTypeface(Typeface typeface) + { + SKTypeface skTypeface; + + Uri source = null; + + switch (typeface.FontFamily.Name) + { + case "Twitter Color Emoji": + { + source = _emojiTypeface.FontFamily.Key.Source; + break; + } + case "Noto Sans": + { + source = _italicTypeface.FontFamily.Key.Source; + break; + } + case "Noto Sans Arabic": + { + source = _arabicTypeface.FontFamily.Key.Source; + break; + } + case "Noto Sans Hebrew": + { + source = _hebrewTypeface.FontFamily.Key.Source; + break; + } + case FontFamily.DefaultFontFamilyName: + case "Noto Mono": + { + source = _defaultTypeface.FontFamily.Key.Source; + break; + } + default: + { + + break; + } + } + + if (source is null) + { + skTypeface = SKTypeface.FromFamilyName(typeface.FontFamily.Name, + (SKFontStyleWeight)typeface.Weight, SKFontStyleWidth.Normal, (SKFontStyleSlant)typeface.Style); + } + else + { + var assetLoader = AvaloniaLocator.Current.GetRequiredService(); + + var assetUri = FontFamilyLoader.LoadFontAssets(source).First(); + + var stream = assetLoader.Open(assetUri); + + skTypeface = SKTypeface.FromStream(stream); + } + + return new GlyphTypefaceImpl(skTypeface, FontSimulations.None); + } + public bool TryCreateGlyphTypeface(string familyName, FontStyle style, FontWeight weight, FontStretch stretch, [NotNullWhen(true)] out IGlyphTypeface glyphTypeface) { @@ -77,40 +137,54 @@ namespace Avalonia.Skia.UnitTests.Media switch (familyName) { - case "TWITTER COLOR EMOJI": + case "Twitter Color Emoji": { source = _emojiTypeface.FontFamily.Key.Source; break; } - case "NOTO SANS": + case "Noto Sans": { source = _italicTypeface.FontFamily.Key.Source; break; } - case "NOTO SANS ARABIC": + case "Noto Sans Arabic": { source = _arabicTypeface.FontFamily.Key.Source; break; } - case "NOTO SANS HEBREW": + case "Noto Sans Hebrew": { source = _hebrewTypeface.FontFamily.Key.Source; break; } - default: + case FontFamily.DefaultFontFamilyName: + case "Noto Mono": { source = _defaultTypeface.FontFamily.Key.Source; + break; + } + default: + { + break; } } - var assetLoader = AvaloniaLocator.Current.GetRequiredService(); + if (source is null) + { + skTypeface = SKTypeface.FromFamilyName(familyName, + (SKFontStyleWeight)weight, SKFontStyleWidth.Normal, (SKFontStyleSlant)style); + } + else + { + var assetLoader = AvaloniaLocator.Current.GetRequiredService(); - var assetUri = FontFamilyLoader.LoadFontAssets(source).First(); + var assetUri = FontFamilyLoader.LoadFontAssets(source).First(); - var stream = assetLoader.Open(assetUri); + var stream = assetLoader.Open(assetUri); - skTypeface = SKTypeface.FromStream(stream); + skTypeface = SKTypeface.FromStream(stream); + } glyphTypeface = new GlyphTypefaceImpl(skTypeface, FontSimulations.None); diff --git a/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs b/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs index 37f275484a..c15cbfb845 100644 --- a/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs @@ -38,10 +38,10 @@ namespace Avalonia.Skia.UnitTests.Media public void Should_Yield_Default_GlyphTypeface_For_Invalid_FamilyName() { using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface.With(fontManagerImpl: new FontManagerImpl()))) - { - var glyphTypeface = new Typeface(new FontFamily("Unknown")).GlyphTypeface; + { + var glyphTypeface = new Typeface(new FontFamily("Unknown")).GlyphTypeface; - Assert.Equal(FontManager.Current.DefaultFontFamilyName, glyphTypeface.FamilyName); + Assert.Equal(FontManager.Current.DefaultFontFamilyName, glyphTypeface.FamilyName); } } @@ -87,19 +87,6 @@ namespace Avalonia.Skia.UnitTests.Media } } - [Fact] - public void Should_Load_Embedded_Font_With_Wrong_CharacterCasing() - { - using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface.With(fontManagerImpl: new FontManagerImpl()))) - { - var result = FontManager.Current.TryGetGlyphTypeface(new Typeface("resm:Avalonia.Skia.UnitTests.Assets?assembly=Avalonia.Skia.UnitTests#noto mOnO"), out var glyphTypeface); - - Assert.True(result); - - Assert.Equal("Noto Mono", glyphTypeface.FamilyName); - } - } - [Fact] public void Should_Load_Embedded_DefaultFontFamily() { diff --git a/tests/Avalonia.UnitTests/DispatcherTimerHelper.cs b/tests/Avalonia.UnitTests/DispatcherTimerHelper.cs new file mode 100644 index 0000000000..ef7271a2d3 --- /dev/null +++ b/tests/Avalonia.UnitTests/DispatcherTimerHelper.cs @@ -0,0 +1,13 @@ +using Avalonia.Threading; + +namespace Avalonia.UnitTests; + +public static class DispatcherTimerUtils +{ + public static void ForceFire(this DispatcherTimer timer) + { + timer.Promote(); + timer.Dispatcher.RemoveTimer(timer); + timer.Dispatcher.RunJobs(); + } +} \ No newline at end of file diff --git a/tests/Avalonia.UnitTests/TestServices.cs b/tests/Avalonia.UnitTests/TestServices.cs index 339cb1462c..800abbc2c7 100644 --- a/tests/Avalonia.UnitTests/TestServices.cs +++ b/tests/Avalonia.UnitTests/TestServices.cs @@ -13,6 +13,7 @@ using System.Collections.Generic; using Avalonia.Controls; using System.Reflection; using Avalonia.Animation; +using Avalonia.Threading; namespace Avalonia.UnitTests { @@ -24,7 +25,7 @@ namespace Avalonia.UnitTests renderInterface: new MockPlatformRenderInterface(), standardCursorFactory: Mock.Of(), theme: () => CreateSimpleTheme(), - threadingInterface: Mock.Of(x => x.CurrentThreadIsLoopThread == true), + dispatcherImpl: Mock.Of(x => x.CurrentThreadIsLoopThread == true), fontManagerImpl: new MockFontManagerImpl(), textShaperImpl: new MockTextShaperImpl(), windowingPlatform: new MockWindowingPlatform()); @@ -39,7 +40,7 @@ namespace Avalonia.UnitTests platform: Mock.Of()); public static readonly TestServices MockThreadingInterface = new TestServices( - threadingInterface: Mock.Of(x => x.CurrentThreadIsLoopThread == true)); + dispatcherImpl: Mock.Of(x => x.CurrentThreadIsLoopThread == true)); public static readonly TestServices MockWindowingPlatform = new TestServices( windowingPlatform: new MockWindowingPlatform()); @@ -73,7 +74,7 @@ namespace Avalonia.UnitTests IRenderTimer renderLoop = null, ICursorFactory standardCursorFactory = null, Func theme = null, - IPlatformThreadingInterface threadingInterface = null, + IDispatcherImpl dispatcherImpl = null, IFontManagerImpl fontManagerImpl = null, ITextShaperImpl textShaperImpl = null, IWindowImpl windowImpl = null, @@ -92,7 +93,7 @@ namespace Avalonia.UnitTests TextShaperImpl = textShaperImpl; StandardCursorFactory = standardCursorFactory; Theme = theme; - ThreadingInterface = threadingInterface; + DispatcherImpl = dispatcherImpl; WindowImpl = windowImpl; WindowingPlatform = windowingPlatform; } @@ -110,7 +111,7 @@ namespace Avalonia.UnitTests public ITextShaperImpl TextShaperImpl { get; } public ICursorFactory StandardCursorFactory { get; } public Func Theme { get; } - public IPlatformThreadingInterface ThreadingInterface { get; } + public IDispatcherImpl DispatcherImpl { get; } public IWindowImpl WindowImpl { get; } public IWindowingPlatform WindowingPlatform { get; } @@ -128,7 +129,7 @@ namespace Avalonia.UnitTests IScheduler scheduler = null, ICursorFactory standardCursorFactory = null, Func theme = null, - IPlatformThreadingInterface threadingInterface = null, + IDispatcherImpl dispatcherImpl = null, IFontManagerImpl fontManagerImpl = null, ITextShaperImpl textShaperImpl = null, IWindowImpl windowImpl = null, @@ -148,7 +149,7 @@ namespace Avalonia.UnitTests textShaperImpl: textShaperImpl ?? TextShaperImpl, standardCursorFactory: standardCursorFactory ?? StandardCursorFactory, theme: theme ?? Theme, - threadingInterface: threadingInterface ?? ThreadingInterface, + dispatcherImpl: dispatcherImpl ?? DispatcherImpl, windowingPlatform: windowingPlatform ?? WindowingPlatform, windowImpl: windowImpl ?? WindowImpl); } diff --git a/tests/Avalonia.UnitTests/UnitTestApplication.cs b/tests/Avalonia.UnitTests/UnitTestApplication.cs index fe7f9712b4..8d9f08caa1 100644 --- a/tests/Avalonia.UnitTests/UnitTestApplication.cs +++ b/tests/Avalonia.UnitTests/UnitTestApplication.cs @@ -43,7 +43,7 @@ namespace Avalonia.UnitTests { var scope = AvaloniaLocator.EnterScope(); var app = new UnitTestApplication(services); - Dispatcher.UIThread.UpdateServices(); + Dispatcher.ResetForUnitTests(); return Disposable.Create(() => { if (Dispatcher.UIThread.CheckAccess()) @@ -52,7 +52,7 @@ namespace Avalonia.UnitTests } scope.Dispose(); - Dispatcher.UIThread.UpdateServices(); + Dispatcher.ResetForUnitTests(); }); } @@ -71,7 +71,7 @@ namespace Avalonia.UnitTests .Bind().ToConstant(Services.RenderInterface) .Bind().ToConstant(Services.FontManagerImpl) .Bind().ToConstant(Services.TextShaperImpl) - .Bind().ToConstant(Services.ThreadingInterface) + .Bind().ToConstant(Services.DispatcherImpl) .Bind().ToConstant(Services.StandardCursorFactory) .Bind().ToConstant(Services.WindowingPlatform) .Bind().ToSingleton();