fix: various issues with the app freezing or being slowly

lwouis · lwouis · commit 121515cbc757 · 2025-01-07T01:12:06.000+01:00
diff --git a/src/logic/Application.swift b/src/logic/Application.swift
@@ -54,7 +54,7 @@ class Application: NSObject {
     func removeWindowslessAppWindow() {
         if let windowlessAppWindow = (Windows.list.firstIndex { $0.isWindowlessApp == true && $0.application.pid == pid }) {
             Windows.list.remove(at: windowlessAppWindow)
-            App.app.refreshOpenUi([])
+            App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)
         }
     }
 
@@ -72,9 +72,11 @@ class Application: NSObject {
         retryAxCallUntilTimeout(group, 5) { [weak self] in
             guard let self = self else { return }
             var atLeastOneActualWindow = false
-            if let axWindows_ = try self.axUiElement!.windows(), axWindows_.count > 0 {
+            if let axWindows_ = try self.axUiElement!.windows(), !axWindows_.isEmpty {
                 // bug in macOS: sometimes the OS returns multiple duplicate windows (e.g. Mail.app starting at login)
-                try Array(Set(axWindows_)).forEach { axWindow in
+                let uniqueWindows = Array(Set(axWindows_))
+                if uniqueWindows.isEmpty { return }
+                for axWindow in uniqueWindows {
                     if let wid = try axWindow.cgWindowId() {
                         let title = try axWindow.title()
                         let subrole = try axWindow.subrole()
@@ -96,7 +98,7 @@ class Application: NSObject {
                                     window.position = position
                                 } else {
                                     let window = self.addWindow(axWindow, wid, title, isFullscreen, isMinimized, position, size)
-                                    App.app.refreshOpenUi([window])
+                                    App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
                                 }
                             }
                         }
@@ -107,7 +109,7 @@ class Application: NSObject {
                 DispatchQueue.main.async { [weak self] in
                     guard let self = self else { return }
                     if self.addWindowlessWindowIfNeeded() != nil {
-                        App.app.refreshOpenUi([])
+                        App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)
                     }
                 }
                 // workaround: some apps launch but take a while to create their window(s)
diff --git a/src/logic/Applications.swift b/src/logic/Applications.swift
@@ -83,7 +83,7 @@ class Applications {
                 Windows.cycleFocusedWindowIndex(-windowsOnTheLeftOfFocusedWindow)
             }
             if !existingWindowstoRemove.isEmpty {
-                App.app.refreshOpenUi([])
+                App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)
             }
         }
     }
diff --git a/src/logic/BackgroundWork.swift b/src/logic/BackgroundWork.swift
@@ -12,16 +12,18 @@ class BackgroundWork {
     static var repeatingKeyThread: BackgroundThreadWithRunLoop!
     static var missionControlThread: BackgroundThreadWithRunLoop!
     static var cliEventsThread: BackgroundThreadWithRunLoop!
-    static let screenshotsDispatchGroup = DispatchGroup()
 
     // swift static variables are lazy; we artificially force the threads to init
     static func start() {
-        // screenshots are taken off the main thread, concurrently
-        screenshotsQueue = DispatchQueue.globalConcurrent("screenshotsQueue", .userInteractive)
+        // screenshots are taken on a serial DispatchQueue. They used to be taken on the .global() concurrent queue.
+        // it could hand the app the screenshot OS calls are slow. It would hang or crash with this error:
+        // >Processes reached dispatch thread soft limit (64)
+        screenshotsQueue = DispatchQueue.queue("screenshotsQueue", .userInteractive, false)
         // calls to act on windows (e.g. AXUIElementSetAttributeValue, AXUIElementPerformAction) are done off the main thread
-        accessibilityCommandsQueue = DispatchQueue.globalConcurrent("accessibilityCommandsQueue", .userInteractive)
-        // calls to the AX APIs are blocking. We dispatch those on a globalConcurrent queue
-        axCallsQueue = DispatchQueue.globalConcurrent("axCallsQueue", .userInteractive)
+        accessibilityCommandsQueue = DispatchQueue.queue("accessibilityCommandsQueue", .userInteractive, false)
+        // calls to the AX APIs can block for a long time (e.g. if an app is unresponsive)
+        // We can't use a serial queue. We use the global concurrent queue
+        axCallsQueue = DispatchQueue.queue("axCallsQueue", .userInteractive, true)
         // we observe app and windows notifications. They arrive on this thread, and are handled off the main thread initially
         accessibilityEventsThread = BackgroundThreadWithRunLoop("accessibilityEventsThread", .userInteractive)
         // we listen to as any keyboard events as possible on a background thread, as it's more available/reliable than the main thread
@@ -37,7 +39,7 @@ class BackgroundWork {
     static func startCrashReportsQueue() {
         if crashReportsQueue == nil {
             // crash reports can be sent off the main thread
-            crashReportsQueue = DispatchQueue.globalConcurrent("crashReportsQueue", .utility)
+            crashReportsQueue = DispatchQueue.queue("crashReportsQueue", .utility, false)
         }
     }
 
@@ -79,27 +81,14 @@ class BackgroundWork {
     }
 }
 
-// we cap concurrent tasks to .processorCount to avoid thread explosion on the .global queue
-let backgroundWorkGlobalSemaphore = DispatchSemaphore(value: ProcessInfo.processInfo.processorCount)
-
 extension DispatchQueue {
-    static func globalConcurrent(_ label: String, _ qos: DispatchQoS) -> DispatchQueue {
-        // label is not reflected in Instruments because the target is .global
-        // if we want to see our custom labels, we need our private queue.
-        // However, we want to be efficient and use the OS thread pool, so we use .global
-        DispatchQueue(label: label, attributes: .concurrent, target: .global(qos: qos.qosClass))
-    }
-
-    func asyncWithCap(_ deadline: DispatchTime? = nil, _ fn: @escaping () -> Void) {
-        let block = {
-            fn()
-            backgroundWorkGlobalSemaphore.signal()
-        }
-        backgroundWorkGlobalSemaphore.wait()
-        if let deadline = deadline {
-            asyncAfter(deadline: deadline, execute: block)
-        } else {
-            async(execute: block)
+    static func queue(_ label: String, _ qos: DispatchQoS, _ globalParallel: Bool) -> DispatchQueue {
+        if globalParallel {
+            // label is not reflected in Instruments because the target is .global
+            // if we want to see our custom labels, we need our private queue.
+            // However, we want to be efficient and use the OS thread pool, so we use .global
+            return DispatchQueue(label: label, attributes: [.concurrent], target: .global(qos: qos.qosClass))
         }
+        return DispatchQueue(label: label, qos: qos)
     }
 }
diff --git a/src/logic/Window.swift b/src/logic/Window.swift
@@ -97,18 +97,17 @@ class Window {
         CFRunLoopAddSource(BackgroundWork.accessibilityEventsThread.runLoop, AXObserverGetRunLoopSource(axObserver), .commonModes)
     }
 
-    func refreshThumbnail(_ screenshot: NSImage?) {
+    func refreshThumbnail(_ screenshot: NSImage) {
         thumbnail = screenshot
-        thumbnailFullSize = screenshot?.size
-        if App.app.appIsBeingUsed && shouldShowTheUser {
-            if let index = (Windows.list.firstIndex { $0.cgWindowId == cgWindowId }) {
-                let view = ThumbnailsView.recycledViews[index]
-                if !view.thumbnail.isHidden {
-                    view.thumbnail.image = thumbnail?.copyToSeparateContexts()
-                    let thumbnailSize = ThumbnailView.thumbnailSize(thumbnail, false)
-                    view.thumbnail.setSize(thumbnailSize)
-                }
+        thumbnailFullSize = screenshot.size
+        if !App.app.appIsBeingUsed || !shouldShowTheUser { return }
+        if let view = (ThumbnailsView.recycledViews.first { $0.window_?.cgWindowId == cgWindowId }) {
+            if !view.thumbnail.isHidden {
+                view.thumbnail.image = thumbnail?.copyToSeparateContexts()
+                let thumbnailSize = ThumbnailView.thumbnailSize(thumbnail, false)
+                view.thumbnail.setSize(thumbnailSize)
             }
+            App.app.previewPanel.updateImageIfShowing(cgWindowId, screenshot, screenshot.size)
         }
     }
 
@@ -121,7 +120,7 @@ class Window {
             NSSound.beep()
             return
         }
-        BackgroundWork.accessibilityCommandsQueue.asyncWithCap { [weak self] in
+        BackgroundWork.accessibilityCommandsQueue.async { [weak self] in
             guard let self = self else { return }
             if self.isFullscreen {
                 self.axUiElement.setAttribute(kAXFullscreenAttribute, false)
@@ -141,12 +140,12 @@ class Window {
             NSSound.beep()
             return
         }
-        BackgroundWork.accessibilityCommandsQueue.asyncWithCap { [weak self] in
+        BackgroundWork.accessibilityCommandsQueue.async { [weak self] in
             guard let self = self else { return }
             if self.isFullscreen {
                 self.axUiElement.setAttribute(kAXFullscreenAttribute, false)
                 // minimizing is ignored if sent immediatly; we wait for the de-fullscreen animation to be over
-                BackgroundWork.accessibilityCommandsQueue.asyncWithCap(.now() + .seconds(1)) { [weak self] in
+                BackgroundWork.accessibilityCommandsQueue.asyncAfter(deadline: .now() + .seconds(1)) { [weak self] in
                     guard let self = self else { return }
                     self.axUiElement.setAttribute(kAXMinimizedAttribute, true)
                 }
@@ -161,7 +160,7 @@ class Window {
             NSSound.beep()
             return
         }
-        BackgroundWork.accessibilityCommandsQueue.asyncWithCap { [weak self] in
+        BackgroundWork.accessibilityCommandsQueue.async { [weak self] in
             guard let self = self else { return }
             self.axUiElement.setAttribute(kAXFullscreenAttribute, !self.isFullscreen)
         }
@@ -186,7 +185,7 @@ class Window {
             // macOS bug: when switching to a System Preferences window in another space, it switches to that space,
             // but quickly switches back to another window in that space
             // You can reproduce this buggy behaviour by clicking on the dock icon, proving it's an OS bug
-            BackgroundWork.accessibilityCommandsQueue.asyncWithCap { [weak self] in
+            BackgroundWork.accessibilityCommandsQueue.async { [weak self] in
                 guard let self = self else { return }
                 var psn = ProcessSerialNumber()
                 GetProcessForPID(self.application.pid, &psn)
diff --git a/src/logic/Windows.swift b/src/logic/Windows.swift
@@ -273,7 +273,6 @@ class Windows {
         lazy var cgsWindowIds = Spaces.windowsInSpaces(spaceIdsAndIndexes)
         lazy var visibleCgsWindowIds = Spaces.windowsInSpaces(spaceIdsAndIndexes, false)
         for window in list {
-            // TODO: can the CGS call inside detectTabbedWindows introduce latency when WindowServer is busy?
             detectTabbedWindows(window, cgsWindowIds, visibleCgsWindowIds)
             updatesWindowSpace(window)
             refreshIfWindowShouldBeShownToTheUser(window)
@@ -303,38 +302,30 @@ class Windows {
     }
 
     // dispatch screenshot requests off the main-thread, then wait for completion
-    static func refreshThumbnails(_ windows: [Window], _ onlyUpdateScreenshots: Bool) {
+    static func refreshThumbnails(_ windows: [Window], _ source: RefreshCausedBy) {
         var eligibleWindows = [Window]()
         for window in windows {
             if !window.isWindowlessApp, let cgWindowId = window.cgWindowId, cgWindowId != CGWindowID(bitPattern: -1) {
                 eligibleWindows.append(window)
             }
         }
         if eligibleWindows.isEmpty { return }
-        screenshotEligibleWindowsAndRefreshUi(eligibleWindows, onlyUpdateScreenshots)
+        screenshotEligibleWindowsAndRefreshUi(eligibleWindows, source)
     }
 
-    private static func screenshotEligibleWindowsAndRefreshUi(_ eligibleWindows: [Window], _ onlyUpdateScreenshots: Bool) {
-        eligibleWindows.forEach { _ in BackgroundWork.screenshotsDispatchGroup.enter() }
+    private static func screenshotEligibleWindowsAndRefreshUi(_ eligibleWindows: [Window], _ source: RefreshCausedBy) {
         for window in eligibleWindows {
             BackgroundWork.screenshotsQueue.async { [weak window] in
-                backgroundWorkGlobalSemaphore.wait()
-                defer {
-                    backgroundWorkGlobalSemaphore.signal()
-                    BackgroundWork.screenshotsDispatchGroup.leave()
-                }
-                if let cgImage = window?.cgWindowId?.screenshot() {
+                if source == .refreshOnlyThumbnailsAfterShowUi && !App.app.appIsBeingUsed { return }
+                if let wid = window?.cgWindowId, let cgImage = wid.screenshot() {
+                    if source == .refreshOnlyThumbnailsAfterShowUi && !App.app.appIsBeingUsed { return }
                     DispatchQueue.main.async { [weak window] in
+                        if source == .refreshOnlyThumbnailsAfterShowUi && !App.app.appIsBeingUsed { return }
                         window?.refreshThumbnail(NSImage.fromCgImage(cgImage))
                     }
                 }
             }
         }
-        if !onlyUpdateScreenshots {
-            BackgroundWork.screenshotsDispatchGroup.notify(queue: DispatchQueue.main) {
-                App.app.refreshOpenUi([])
-            }
-        }
     }
 
     static func refreshWhichWindowsToShowTheUser() {
diff --git a/src/logic/events/AccessibilityEvents.swift b/src/logic/events/AccessibilityEvents.swift
@@ -42,7 +42,7 @@ fileprivate func applicationActivated(_ element: AXUIElement, _ pid: pid_t) thro
             let window = (appFocusedWindow != nil && wid != nil) ? Windows.updateLastFocus(appFocusedWindow!, wid!)?.first : nil
             app.focusedWindow = window
             App.app.checkIfShortcutsShouldBeDisabled(window, app.runningApplication)
-            App.app.refreshOpenUi(window != nil ? [window!] : [])
+            App.app.refreshOpenUi(window != nil ? [window!] : [], .refreshUiAfterExternalEvent)
         }
     }
 }
@@ -55,7 +55,11 @@ fileprivate func applicationHiddenOrShown(_ pid: pid_t, _ type: String) throws {
                 // for AXUIElement of apps, CFEqual or == don't work; looks like a Cocoa bug
                 return $0.application.pid == pid
             }
-            App.app.refreshOpenUi(windows)
+            // if we process the "shown" event too fast, the window won't be listed by CGSCopyWindowsWithOptionsAndTags
+            // it will thus be detected as isTabbed. We add a delay to work around this scenario
+            DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(200)) {
+                App.app.refreshOpenUi(windows, .refreshUiAfterExternalEvent)
+            }
         }
     }
 }
@@ -77,7 +81,7 @@ fileprivate func windowCreated(_ element: AXUIElement, _ pid: pid_t) throws {
                     let window = Window(element, app, wid, axTitle, isFullscreen, isMinimized, position, size)
                     Windows.appendAndUpdateFocus(window)
                     Windows.cycleFocusedWindowIndex(1)
-                    App.app.refreshOpenUi([window])
+                    App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
                 }
             }
         }
@@ -106,11 +110,11 @@ fileprivate func focusedWindowChanged(_ element: AXUIElement, _ pid: pid_t) thro
                     app.focusedWindow = w
                 }
                 if let windows = Windows.updateLastFocus(element, wid) {
-                    App.app.refreshOpenUi(windows)
+                    App.app.refreshOpenUi(windows, .refreshUiAfterExternalEvent)
                 } else if AXUIElement.isActualWindow(app, wid, level, axTitle, subrole, role, size) {
                     let window = Window(element, app, wid, axTitle, isFullscreen, isMinimized, position, size)
                     Windows.appendAndUpdateFocus(window)
-                    App.app.refreshOpenUi([window])
+                    App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
                 }
             }
         }
@@ -142,7 +146,7 @@ fileprivate func windowDestroyed(_ element: AXUIElement, _ pid: pid_t) throws {
             }
             if Windows.list.count > 0 {
                 Windows.moveFocusedWindowIndexAfterWindowDestroyedInBackground(index)
-                App.app.refreshOpenUi([])
+                App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)
             } else {
                 App.app.hideUi()
             }
@@ -155,7 +159,7 @@ fileprivate func windowMiniaturizedOrDeminiaturized(_ element: AXUIElement, _ ty
         DispatchQueue.main.async {
             if let window = (Windows.list.first { $0.isEqualRobust(element, wid) }) {
                 window.isMinimized = type == kAXWindowMiniaturizedNotification
-                App.app.refreshOpenUi([window])
+                App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
             }
         }
     }
@@ -167,7 +171,7 @@ fileprivate func windowTitleChanged(_ element: AXUIElement) throws {
         DispatchQueue.main.async {
             if let window = (Windows.list.first { $0.isEqualRobust(element, wid) }), newTitle != window.title {
                 window.title = window.bestEffortTitle(newTitle)
-                App.app.refreshOpenUi([window])
+                App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
             }
         }
     }
@@ -188,7 +192,7 @@ fileprivate func windowResizedOrMoved(_ element: AXUIElement) throws {
                     window.isFullscreen = isFullscreen
                     App.app.checkIfShortcutsShouldBeDisabled(window, nil)
                 }
-                App.app.refreshOpenUi([window])
+                App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)
             }
         }
     }
diff --git a/src/logic/events/ScreensEvents.swift b/src/logic/events/ScreensEvents.swift
@@ -8,7 +8,7 @@ class ScreensEvents {
     @objc private static func handleEvent(_ notification: Notification) {
         Logger.debug(notification.name.rawValue)
         // a screen added or removed can shuffle windows around Spaces; we refresh them
-        App.app.refreshOpenUi(Windows.list)
+        App.app.refreshOpenUi(Windows.list, .refreshUiAfterExternalEvent)
         Logger.info("screens", NSScreen.screens.map { ($0.uuid() ?? "nil" as CFString, $0.frame) })
         Logger.info("spaces", Spaces.screenSpacesMap)
         Logger.info("current space", Spaces.currentSpaceIndex, Spaces.currentSpaceId)
diff --git a/src/logic/events/SpacesEvents.swift b/src/logic/events/SpacesEvents.swift
@@ -8,7 +8,7 @@ class SpacesEvents {
     @objc private static func handleEvent(_ notification: Notification) {
         Logger.debug(notification.name.rawValue)
         // if UI was kept open during Space transition, the Spaces may be obsolete; we refresh them
-        App.app.refreshOpenUi(Windows.list)
+        App.app.refreshOpenUi(Windows.list, .refreshUiAfterExternalEvent)
         Logger.info("current space", Spaces.currentSpaceIndex, Spaces.currentSpaceId)
         // from macos 12.2 beta onwards, we can't get other-space windows; grabbing windows when switching spaces mitigates the issue
         // also, updating windows on Space transition works around an issue with Safari where its fullscreen windows spawn not in fullscreen.
diff --git a/src/ui/App.swift b/src/ui/App.swift
diff --git a/src/ui/main-window/PreviewPanel.swift b/src/ui/main-window/PreviewPanel.swift

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ class Application: NSObject {`
`54`	`54`	`func removeWindowslessAppWindow() {`
`55`	`55`	`if let windowlessAppWindow = (Windows.list.firstIndex { $0.isWindowlessApp == true && $0.application.pid == pid }) {`
`56`	`56`	`Windows.list.remove(at: windowlessAppWindow)`
`57`		`- App.app.refreshOpenUi([])`
	`57`	`+ App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`@@ -72,9 +72,11 @@ class Application: NSObject {`
`72`	`72`	`retryAxCallUntilTimeout(group, 5) { [weak self] in`
`73`	`73`	`guard let self = self else { return }`
`74`	`74`	`var atLeastOneActualWindow = false`
`75`		`- if let axWindows_ = try self.axUiElement!.windows(), axWindows_.count > 0 {`
	`75`	`+ if let axWindows_ = try self.axUiElement!.windows(), !axWindows_.isEmpty {`
`76`	`76`	`// bug in macOS: sometimes the OS returns multiple duplicate windows (e.g. Mail.app starting at login)`
`77`		`- try Array(Set(axWindows_)).forEach { axWindow in`
	`77`	`+ let uniqueWindows = Array(Set(axWindows_))`
	`78`	`+ if uniqueWindows.isEmpty { return }`
	`79`	`+ for axWindow in uniqueWindows {`
`78`	`80`	`if let wid = try axWindow.cgWindowId() {`
`79`	`81`	`let title = try axWindow.title()`
`80`	`82`	`let subrole = try axWindow.subrole()`
`@@ -96,7 +98,7 @@ class Application: NSObject {`
`96`	`98`	`window.position = position`
`97`	`99`	`} else {`
`98`	`100`	`let window = self.addWindow(axWindow, wid, title, isFullscreen, isMinimized, position, size)`
`99`		`- App.app.refreshOpenUi([window])`
	`101`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`100`	`102`	`}`
`101`	`103`	`}`
`102`	`104`	`}`
`@@ -107,7 +109,7 @@ class Application: NSObject {`
`107`	`109`	`DispatchQueue.main.async { [weak self] in`
`108`	`110`	`guard let self = self else { return }`
`109`	`111`	`if self.addWindowlessWindowIfNeeded() != nil {`
`110`		`- App.app.refreshOpenUi([])`
	`112`	`+ App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)`
`111`	`113`	`}`
`112`	`114`	`}`
`113`	`115`	`// workaround: some apps launch but take a while to create their window(s)`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ class Applications {`
`83`	`83`	`Windows.cycleFocusedWindowIndex(-windowsOnTheLeftOfFocusedWindow)`
`84`	`84`	`}`
`85`	`85`	`if !existingWindowstoRemove.isEmpty {`
`86`		`- App.app.refreshOpenUi([])`
	`86`	`+ App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ fileprivate func applicationActivated(_ element: AXUIElement, _ pid: pid_t) thro`
`42`	`42`	`let window = (appFocusedWindow != nil && wid != nil) ? Windows.updateLastFocus(appFocusedWindow!, wid!)?.first : nil`
`43`	`43`	`app.focusedWindow = window`
`44`	`44`	`App.app.checkIfShortcutsShouldBeDisabled(window, app.runningApplication)`
`45`		`- App.app.refreshOpenUi(window != nil ? [window!] : [])`
	`45`	`+ App.app.refreshOpenUi(window != nil ? [window!] : [], .refreshUiAfterExternalEvent)`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -55,7 +55,11 @@ fileprivate func applicationHiddenOrShown(_ pid: pid_t, _ type: String) throws {`
`55`	`55`	`// for AXUIElement of apps, CFEqual or == don't work; looks like a Cocoa bug`
`56`	`56`	`return $0.application.pid == pid`
`57`	`57`	`}`
`58`		`- App.app.refreshOpenUi(windows)`
	`58`	`+ // if we process the "shown" event too fast, the window won't be listed by CGSCopyWindowsWithOptionsAndTags`
	`59`	`+ // it will thus be detected as isTabbed. We add a delay to work around this scenario`
	`60`	`+ DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(200)) {`
	`61`	`+ App.app.refreshOpenUi(windows, .refreshUiAfterExternalEvent)`
	`62`	`+ }`
`59`	`63`	`}`
`60`	`64`	`}`
`61`	`65`	`}`
`@@ -77,7 +81,7 @@ fileprivate func windowCreated(_ element: AXUIElement, _ pid: pid_t) throws {`
`77`	`81`	`let window = Window(element, app, wid, axTitle, isFullscreen, isMinimized, position, size)`
`78`	`82`	`Windows.appendAndUpdateFocus(window)`
`79`	`83`	`Windows.cycleFocusedWindowIndex(1)`
`80`		`- App.app.refreshOpenUi([window])`
	`84`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`81`	`85`	`}`
`82`	`86`	`}`
`83`	`87`	`}`
`@@ -106,11 +110,11 @@ fileprivate func focusedWindowChanged(_ element: AXUIElement, _ pid: pid_t) thro`
`106`	`110`	`app.focusedWindow = w`
`107`	`111`	`}`
`108`	`112`	`if let windows = Windows.updateLastFocus(element, wid) {`
`109`		`- App.app.refreshOpenUi(windows)`
	`113`	`+ App.app.refreshOpenUi(windows, .refreshUiAfterExternalEvent)`
`110`	`114`	`} else if AXUIElement.isActualWindow(app, wid, level, axTitle, subrole, role, size) {`
`111`	`115`	`let window = Window(element, app, wid, axTitle, isFullscreen, isMinimized, position, size)`
`112`	`116`	`Windows.appendAndUpdateFocus(window)`
`113`		`- App.app.refreshOpenUi([window])`
	`117`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`114`	`118`	`}`
`115`	`119`	`}`
`116`	`120`	`}`
`@@ -142,7 +146,7 @@ fileprivate func windowDestroyed(_ element: AXUIElement, _ pid: pid_t) throws {`
`142`	`146`	`}`
`143`	`147`	`if Windows.list.count > 0 {`
`144`	`148`	`Windows.moveFocusedWindowIndexAfterWindowDestroyedInBackground(index)`
`145`		`- App.app.refreshOpenUi([])`
	`149`	`+ App.app.refreshOpenUi([], .refreshUiAfterExternalEvent)`
`146`	`150`	`} else {`
`147`	`151`	`App.app.hideUi()`
`148`	`152`	`}`
`@@ -155,7 +159,7 @@ fileprivate func windowMiniaturizedOrDeminiaturized(_ element: AXUIElement, _ ty`
`155`	`159`	`DispatchQueue.main.async {`
`156`	`160`	`if let window = (Windows.list.first { $0.isEqualRobust(element, wid) }) {`
`157`	`161`	`window.isMinimized = type == kAXWindowMiniaturizedNotification`
`158`		`- App.app.refreshOpenUi([window])`
	`162`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`159`	`163`	`}`
`160`	`164`	`}`
`161`	`165`	`}`
`@@ -167,7 +171,7 @@ fileprivate func windowTitleChanged(_ element: AXUIElement) throws {`
`167`	`171`	`DispatchQueue.main.async {`
`168`	`172`	`if let window = (Windows.list.first { $0.isEqualRobust(element, wid) }), newTitle != window.title {`
`169`	`173`	`window.title = window.bestEffortTitle(newTitle)`
`170`		`- App.app.refreshOpenUi([window])`
	`174`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`171`	`175`	`}`
`172`	`176`	`}`
`173`	`177`	`}`
`@@ -188,7 +192,7 @@ fileprivate func windowResizedOrMoved(_ element: AXUIElement) throws {`
`188`	`192`	`window.isFullscreen = isFullscreen`
`189`	`193`	`App.app.checkIfShortcutsShouldBeDisabled(window, nil)`
`190`	`194`	`}`
`191`		`- App.app.refreshOpenUi([window])`
	`195`	`+ App.app.refreshOpenUi([window], .refreshUiAfterExternalEvent)`
`192`	`196`	`}`
`193`	`197`	`}`
`194`	`198`	`}`