From 1d03f5b6b433b062a098bf7899a349d550aafac7 Mon Sep 17 00:00:00 2001
From: Ariver <shanghai3168@gmail.com>
Date: Mon, 29 Jun 2026 00:08:52 +0800
Subject: [PATCH] docs: update results map QA evidence
---
C1.source/Sources/Aligner/Infrastructure/Windows/CGWindowAXWindowService.swift | 1817 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 1,738 insertions(+), 79 deletions(-)
diff --git a/C1.source/Sources/Aligner/Infrastructure/Windows/CGWindowAXWindowService.swift b/C1.source/Sources/Aligner/Infrastructure/Windows/CGWindowAXWindowService.swift
index 799c87d..15fbdda 100644
--- a/C1.source/Sources/Aligner/Infrastructure/Windows/CGWindowAXWindowService.swift
+++ b/C1.source/Sources/Aligner/Infrastructure/Windows/CGWindowAXWindowService.swift
@@ -1,10 +1,10 @@
import AppKit
-import ApplicationServices
+@preconcurrency import ApplicationServices
import CoreGraphics
import Foundation
import AlignerCore
-final class CGWindowAXWindowService: WindowServiceProtocol, WindowRestorationServiceProtocol, WindowActivationServiceProtocol {
+final class CGWindowAXWindowService: WindowServiceProtocol, WindowRestorationServiceProtocol, WindowActivationServiceProtocol, WindowCloseServiceProtocol {
weak var delegate: WindowServiceDelegate?
private let appCategorizer: any AppCategorizer
@@ -13,6 +13,62 @@
private let privateActivationBridge: PrivateWindowActivationBridge?
private let privateSpaceActivationBridge: PrivateSpaceActivationBridge?
private var restorableAXWindowsByID: [UInt32: RestorableAXWindow] = [:]
+
+ private struct FinderTabControl {
+ let button: AXUIElement
+ let tabGroup: AXUIElement?
+ }
+
+ private struct KeyboardShortcut {
+ let name: String
+ let keyCode: CGKeyCode
+ let flags: CGEventFlags
+ }
+
+ private struct FinderTabActivationBudget {
+ let startedAt: TimeInterval
+ let limit: TimeInterval
+
+ init(limit: TimeInterval) {
+ startedAt = ProcessInfo.processInfo.systemUptime
+ self.limit = limit
+ }
+
+ var elapsed: TimeInterval {
+ ProcessInfo.processInfo.systemUptime - startedAt
+ }
+
+ var elapsedMilliseconds: Int {
+ CGWindowAXWindowService.milliseconds(elapsed)
+ }
+
+ var remaining: TimeInterval {
+ max(0, limit - elapsed)
+ }
+
+ var isExhausted: Bool {
+ remaining <= 0
+ }
+ }
+
+ private struct WindowFocusAttempt {
+ let focused: AXActionResult
+ let main: AXActionResult
+ let raised: AXActionResult
+
+ var success: Bool {
+ focused.success || main.success || raised.success
+ }
+ }
+
+ private static let finderTabActivationBudgetLimit: TimeInterval = 1.50
+ private static let finderTabCycleMaximumAttempts = 5
+ private static let finderTabHostRepresentationScanLimit = 5
+ private static let finderTabFastTitleMatchAttempts = 4
+ private static let finderTabFastTitleMatchDelay: TimeInterval = 0.03
+ private static let finderTabWindowMenuVerificationInitialDelay: TimeInterval = 0.08
+ private static let finderTabWindowMenuVerificationAttempts = 8
+ private static let finderTabWindowMenuVerificationDelay: TimeInterval = 0.04
init(
spaceIDsByWindowIDProvider: @escaping ([UInt32]) -> [UInt32: [UInt64]],
@@ -71,51 +127,49 @@
throw AXWindowRestoreError.setMinimizedFailed(minimizeResult)
}
- let focusedBeforeActivateResult = focusWindowResult(
+ let beforeActivateAttempt = focusMainRaiseWindowResult(
restorableWindow.element,
processIdentifier: restorableWindow.processIdentifier
)
- let raisedBeforeActivateResult = raiseWindowResult(restorableWindow.element)
- let focusedBeforeActivate = focusedBeforeActivateResult.success
- let raisedBeforeActivate = raisedBeforeActivateResult.success
guard activateApplication(processIdentifier: restorableWindow.processIdentifier) else {
DevelopmentDiagnostics.log("windowActivation.restore.activateApplicationFailed", [
"windowID": windowID,
"pid": restorableWindow.processIdentifier,
- "focusedBeforeActivate": focusedBeforeActivate,
- "focusBeforeAXError": String(describing: focusedBeforeActivateResult.error),
- "raisedBeforeActivate": raisedBeforeActivate,
- "raiseBeforeAXError": String(describing: raisedBeforeActivateResult.error)
+ "focusedBeforeActivate": beforeActivateAttempt.focused.success,
+ "focusBeforeAXError": String(describing: beforeActivateAttempt.focused.error),
+ "mainBeforeActivate": beforeActivateAttempt.main.success,
+ "mainBeforeAXError": String(describing: beforeActivateAttempt.main.error),
+ "raisedBeforeActivate": beforeActivateAttempt.raised.success,
+ "raiseBeforeAXError": String(describing: beforeActivateAttempt.raised.error)
])
return .activationFailed
}
- let focusedAfterActivateResult = focusWindowResult(
+ let afterActivateAttempt = focusMainRaiseWindowResult(
restorableWindow.element,
processIdentifier: restorableWindow.processIdentifier
)
- let raisedAfterActivateResult = raiseWindowResult(restorableWindow.element)
- let focusedAfterActivate = focusedAfterActivateResult.success
- let raisedAfterActivate = raisedAfterActivateResult.success
- let restored = focusedBeforeActivate || focusedAfterActivate || raisedBeforeActivate || raisedAfterActivate
+ let restored = beforeActivateAttempt.success || afterActivateAttempt.success
DevelopmentDiagnostics.log("windowActivation.restore.end", [
"windowID": windowID,
"pid": restorableWindow.processIdentifier,
- "focusedBeforeActivate": focusedBeforeActivate,
- "focusBeforeAXError": String(describing: focusedBeforeActivateResult.error),
- "raisedBeforeActivate": raisedBeforeActivate,
- "raiseBeforeAXError": String(describing: raisedBeforeActivateResult.error),
- "focusedAfterActivate": focusedAfterActivate,
- "focusAfterAXError": String(describing: focusedAfterActivateResult.error),
- "raisedAfterActivate": raisedAfterActivate,
- "raiseAfterAXError": String(describing: raisedAfterActivateResult.error),
+ "focusedBeforeActivate": beforeActivateAttempt.focused.success,
+ "focusBeforeAXError": String(describing: beforeActivateAttempt.focused.error),
+ "mainBeforeActivate": beforeActivateAttempt.main.success,
+ "mainBeforeAXError": String(describing: beforeActivateAttempt.main.error),
+ "raisedBeforeActivate": beforeActivateAttempt.raised.success,
+ "raiseBeforeAXError": String(describing: beforeActivateAttempt.raised.error),
+ "focusedAfterActivate": afterActivateAttempt.focused.success,
+ "focusAfterAXError": String(describing: afterActivateAttempt.focused.error),
+ "mainAfterActivate": afterActivateAttempt.main.success,
+ "mainAfterAXError": String(describing: afterActivateAttempt.main.error),
+ "raisedAfterActivate": afterActivateAttempt.raised.success,
+ "raiseAfterAXError": String(describing: afterActivateAttempt.raised.error),
"result": restored ? "restored" : "activationFailed"
])
- return focusedBeforeActivate || focusedAfterActivate || raisedBeforeActivate || raisedAfterActivate
- ? .restored
- : .activationFailed
+ return restored ? .restored : .activationFailed
}
func activate(window: AlignerWindow) throws -> WindowActivationResult {
@@ -162,16 +216,13 @@
let privateActivationOutcome = activateViaPrivateWindowServerAPI(window)
let didPrivatelyActivate = privateActivationOutcome?.succeeded == true
- let axWindow = AXWindowMetadataReader
- .metadata(appCategorizer: appCategorizer)
- .first { metadata in
- if let windowID = metadata.windowID {
- return windowID == window.id
- }
-
- return metadata.processIdentifier == window.app.processIdentifier
- && metadata.title == window.title
- }
+ let currentAXMetadata = AXWindowMetadataReader.metadata(appCategorizer: appCategorizer)
+ let axWindow = axWindow(
+ for: window,
+ in: currentAXMetadata,
+ operation: "windowActivation",
+ matchAttempt: "initial"
+ )
DevelopmentDiagnostics.log("windowActivation.activate.axLookup", [
"windowID": window.id,
@@ -192,69 +243,1429 @@
"spaceFocusError": spaceFocusOutcome?.error
])
guard let axWindow else {
+ if let finderTabActivated = activateFinderTabPageIfNeeded(
+ window: window,
+ axMetadata: currentAXMetadata,
+ operation: "windowActivation",
+ reason: "axMissing"
+ ) {
+ DevelopmentDiagnostics.log("windowActivation.activate.finderTabResult", [
+ "windowID": window.id,
+ "pid": window.app.processIdentifier,
+ "activated": finderTabActivated
+ ])
+ return finderTabActivated ? .activated : .activationFailed
+ }
+
let activated = activateApplication(for: window)
+ let retryAttempt = activated
+ ? retryFocusMainRaiseWindow(
+ for: window,
+ delay: 0.10,
+ matchAttempt: "axMissingPostActivate"
+ )
+ : nil
+ let retrySucceeded = retryAttempt?.success ?? false
DevelopmentDiagnostics.log("windowActivation.activate.axMissing", [
"windowID": window.id,
"appName": window.app.name,
"pid": window.app.processIdentifier,
"privateActivated": didPrivatelyActivate,
"applicationActivated": activated,
- "result": didPrivatelyActivate ? "activated" : (activated ? "appActivatedOnly" : "windowNotFound")
+ "retryFocused": retryAttempt?.focused.success,
+ "retryFocusAXError": retryAttempt.map { String(describing: $0.focused.error) },
+ "retryMain": retryAttempt?.main.success,
+ "retryMainAXError": retryAttempt.map { String(describing: $0.main.error) },
+ "retryRaised": retryAttempt?.raised.success,
+ "retryRaiseAXError": retryAttempt.map { String(describing: $0.raised.error) },
+ "result": (didPrivatelyActivate || retrySucceeded) ? "activated" : (activated ? "appActivatedOnly" : "windowNotFound")
])
- if didPrivatelyActivate {
+ if didPrivatelyActivate || retrySucceeded {
return .activated
}
return activated ? .appActivatedOnly : .windowNotFound
}
- let focusedBeforeActivateResult = focusWindowResult(
+ let beforeActivateAttempt = focusMainRaiseWindowResult(
axWindow.element,
processIdentifier: axWindow.processIdentifier
)
- let raisedBeforeActivateResult = raiseWindowResult(axWindow.element)
- let focusedBeforeActivate = focusedBeforeActivateResult.success
- let raisedBeforeActivate = raisedBeforeActivateResult.success
guard didPrivatelyActivate || activateApplication(for: window) else {
DevelopmentDiagnostics.log("windowActivation.activate.applicationActivationFailed", [
"windowID": window.id,
"pid": window.app.processIdentifier,
"privateActivated": didPrivatelyActivate,
- "focusedBeforeActivate": focusedBeforeActivate,
- "focusBeforeAXError": String(describing: focusedBeforeActivateResult.error),
- "raisedBeforeActivate": raisedBeforeActivate,
- "raiseBeforeAXError": String(describing: raisedBeforeActivateResult.error)
+ "focusedBeforeActivate": beforeActivateAttempt.focused.success,
+ "focusBeforeAXError": String(describing: beforeActivateAttempt.focused.error),
+ "mainBeforeActivate": beforeActivateAttempt.main.success,
+ "mainBeforeAXError": String(describing: beforeActivateAttempt.main.error),
+ "raisedBeforeActivate": beforeActivateAttempt.raised.success,
+ "raiseBeforeAXError": String(describing: beforeActivateAttempt.raised.error)
])
return .activationFailed
}
- let focusedAfterActivateResult = focusWindowResult(
+ let afterActivateAttempt = focusMainRaiseWindowResult(
axWindow.element,
processIdentifier: axWindow.processIdentifier
)
- let raisedAfterActivateResult = raiseWindowResult(axWindow.element)
- let focusedAfterActivate = focusedAfterActivateResult.success
- let raisedAfterActivate = raisedAfterActivateResult.success
+ let retryAttempt = (didPrivatelyActivate || beforeActivateAttempt.success || afterActivateAttempt.success)
+ ? nil
+ : retryFocusMainRaiseWindow(
+ for: window,
+ delay: 0.10,
+ matchAttempt: "postActivateRetry"
+ )
- let didFocusOrRaise = focusedBeforeActivate || focusedAfterActivate || raisedBeforeActivate || raisedAfterActivate
+ let didFocusOrRaise = beforeActivateAttempt.success || afterActivateAttempt.success || (retryAttempt?.success ?? false)
+ let finderDirectFallbackResult: Bool?
+ if (didPrivatelyActivate || didFocusOrRaise),
+ isFinderCGOnlyPageCandidate(window),
+ let processIdentifier = window.app.processIdentifier {
+ let normalizedTargetTitle = normalizedWindowTitle(window.title)
+ let focusedTitle = finderFocusedOrMainWindowTitle(processIdentifier: processIdentifier)
+ let directTitleMatched = normalizedWindowTitle(focusedTitle ?? "") == normalizedTargetTitle
+ DevelopmentDiagnostics.log("windowActivation.activate.finderDirectVerification", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "directTitleMatched": directTitleMatched,
+ "focusedTitleHash": DevelopmentDiagnostics.stableFingerprint(focusedTitle),
+ "focusedTitleLength": focusedTitle?.count,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count
+ ])
+ if directTitleMatched {
+ finderDirectFallbackResult = true
+ } else {
+ finderDirectFallbackResult = activateFinderTabPageIfNeeded(
+ window: window,
+ axMetadata: AXWindowMetadataReader.metadata(appCategorizer: appCategorizer),
+ operation: "windowActivation",
+ reason: "directAXTitleMismatch"
+ )
+ }
+ } else {
+ finderDirectFallbackResult = nil
+ }
+
+ let finderPreciseActivationFailed = finderDirectFallbackResult == false
+ let activated = finderDirectFallbackResult ?? (didPrivatelyActivate || didFocusOrRaise)
DevelopmentDiagnostics.log("windowActivation.activate.end", [
"windowID": window.id,
"pid": window.app.processIdentifier,
"privateActivated": didPrivatelyActivate,
- "focusedBeforeActivate": focusedBeforeActivate,
- "focusBeforeAXError": String(describing: focusedBeforeActivateResult.error),
- "raisedBeforeActivate": raisedBeforeActivate,
- "raiseBeforeAXError": String(describing: raisedBeforeActivateResult.error),
- "focusedAfterActivate": focusedAfterActivate,
- "focusAfterAXError": String(describing: focusedAfterActivateResult.error),
- "raisedAfterActivate": raisedAfterActivate,
- "raiseAfterAXError": String(describing: raisedAfterActivateResult.error),
- "result": (didFocusOrRaise || didPrivatelyActivate) ? "activated" : "appActivatedOnly"
+ "focusedBeforeActivate": beforeActivateAttempt.focused.success,
+ "focusBeforeAXError": String(describing: beforeActivateAttempt.focused.error),
+ "mainBeforeActivate": beforeActivateAttempt.main.success,
+ "mainBeforeAXError": String(describing: beforeActivateAttempt.main.error),
+ "raisedBeforeActivate": beforeActivateAttempt.raised.success,
+ "raiseBeforeAXError": String(describing: beforeActivateAttempt.raised.error),
+ "focusedAfterActivate": afterActivateAttempt.focused.success,
+ "focusAfterAXError": String(describing: afterActivateAttempt.focused.error),
+ "mainAfterActivate": afterActivateAttempt.main.success,
+ "mainAfterAXError": String(describing: afterActivateAttempt.main.error),
+ "raisedAfterActivate": afterActivateAttempt.raised.success,
+ "raiseAfterAXError": String(describing: afterActivateAttempt.raised.error),
+ "retryFocused": retryAttempt?.focused.success,
+ "retryFocusAXError": retryAttempt.map { String(describing: $0.focused.error) },
+ "retryMain": retryAttempt?.main.success,
+ "retryMainAXError": retryAttempt.map { String(describing: $0.main.error) },
+ "retryRaised": retryAttempt?.raised.success,
+ "retryRaiseAXError": retryAttempt.map { String(describing: $0.raised.error) },
+ "finderDirectFallbackResult": finderDirectFallbackResult,
+ "result": finderPreciseActivationFailed ? "activationFailed" : (activated ? "activated" : "appActivatedOnly")
])
- return didPrivatelyActivate || focusedBeforeActivate || focusedAfterActivate || raisedBeforeActivate || raisedAfterActivate
- ? .activated
- : .appActivatedOnly
+ if finderPreciseActivationFailed {
+ return .activationFailed
+ }
+ return activated ? .activated : .appActivatedOnly
+ }
+
+ func close(window: AlignerWindow) throws -> WindowCloseResult {
+ DevelopmentDiagnostics.log("windowClose.window.start", [
+ "windowID": window.id,
+ "identifierSource": String(describing: window.identifierSource),
+ "titleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "titleLength": window.title.count,
+ "titleIsEmpty": window.title.isEmpty,
+ "appName": window.app.name,
+ "bundleIdentifier": window.app.bundleIdentifier,
+ "pid": window.app.processIdentifier
+ ])
+
+ let axMetadata = AXWindowMetadataReader.metadata(appCategorizer: appCategorizer)
+ var matchedAXWindow = axWindow(for: window, in: axMetadata)
+ var finalAXMetadata = axMetadata
+
+ let shouldPreferFocusedPageClose = matchedAXWindow?.windowID != window.id
+ if shouldPreferFocusedPageClose,
+ let focusedPageCloseResult = closeFocusedPageViaCommandW(
+ window: window,
+ reason: matchedAXWindow == nil ? "axMissing" : "nonDirectAXMatch"
+ ) {
+ return focusedPageCloseResult
+ }
+
+ if matchedAXWindow == nil {
+ Thread.sleep(forTimeInterval: 0.12)
+ finalAXMetadata = AXWindowMetadataReader.metadata(appCategorizer: appCategorizer)
+ matchedAXWindow = axWindow(for: window, in: finalAXMetadata, matchAttempt: "retry")
+ }
+
+ guard let matchedAXWindow else {
+ DevelopmentDiagnostics.log("windowClose.window.axMissing", [
+ "windowID": window.id,
+ "appName": window.app.name,
+ "pid": window.app.processIdentifier,
+ "candidateCount": finalAXMetadata.filter { $0.processIdentifier == window.app.processIdentifier }.count,
+ "matchingTitleCandidateCount": matchingAXTitleCandidateCount(for: window, in: finalAXMetadata),
+ "matchingSizeCandidateCount": matchingAXSizeCandidateCount(for: window, in: finalAXMetadata)
+ ])
+ return .windowNotFound
+ }
+
+ if matchedAXWindow.windowID != window.id,
+ let focusedPageCloseResult = closeFocusedPageViaCommandW(
+ window: window,
+ reason: "retryNonDirectAXMatch"
+ ) {
+ return focusedPageCloseResult
+ }
+
+ guard let closeButton = closeButton(for: matchedAXWindow) else {
+ Thread.sleep(forTimeInterval: 0.12)
+ let retryMetadata = AXWindowMetadataReader.metadata(appCategorizer: appCategorizer)
+ if let retryAXWindow = axWindow(for: window, in: retryMetadata, matchAttempt: "closeButtonRetry"),
+ let retryCloseButton = closeButton(for: retryAXWindow) {
+ return performCloseButtonPress(
+ retryCloseButton,
+ window: window,
+ processIdentifier: retryAXWindow.processIdentifier,
+ attempt: "closeButtonRetry"
+ )
+ }
+ DevelopmentDiagnostics.log("windowClose.window.closeButtonMissing", [
+ "windowID": window.id,
+ "pid": matchedAXWindow.processIdentifier,
+ "appName": window.app.name
+ ])
+ return .windowNotFound
+ }
+
+ return performCloseButtonPress(
+ closeButton,
+ window: window,
+ processIdentifier: matchedAXWindow.processIdentifier,
+ attempt: "initial"
+ )
+ }
+
+ private func closeButton(for axWindow: AXWindowMetadata) -> AXUIElement? {
+ var closeButtonValue: CFTypeRef?
+ let closeButtonLookupResult = AXUIElementCopyAttributeValue(
+ axWindow.element,
+ kAXCloseButtonAttribute as CFString,
+ &closeButtonValue
+ )
+ guard closeButtonLookupResult == .success,
+ let closeButton = closeButtonValue,
+ CFGetTypeID(closeButton) == AXUIElementGetTypeID()
+ else {
+ DevelopmentDiagnostics.log("windowClose.window.closeButtonLookupFailed", [
+ "pid": axWindow.processIdentifier,
+ "axError": String(describing: closeButtonLookupResult)
+ ])
+ return nil
+ }
+
+ return (closeButton as! AXUIElement)
+ }
+
+ private func performCloseButtonPress(
+ _ closeButton: AXUIElement,
+ window: AlignerWindow,
+ processIdentifier: Int32,
+ attempt: String
+ ) -> WindowCloseResult {
+ let closeResult = AXUIElementPerformAction(closeButton, kAXPressAction as CFString)
+ DevelopmentDiagnostics.log("windowClose.window.result", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "attempt": attempt,
+ "axError": String(describing: closeResult)
+ ])
+
+ switch closeResult {
+ case .success:
+ return .requested
+ case .actionUnsupported, .notImplemented:
+ return .unsupported
+ default:
+ return .failed(String(describing: closeResult))
+ }
+ }
+
+ private func closeFocusedPageViaCommandW(
+ window: AlignerWindow,
+ reason: String
+ ) -> WindowCloseResult? {
+ guard window.identifierSource == .cgWindow,
+ let processIdentifier = window.app.processIdentifier
+ else {
+ DevelopmentDiagnostics.log("windowClose.commandW.skipped", [
+ "windowID": window.id,
+ "reason": reason,
+ "identifierSource": String(describing: window.identifierSource),
+ "hasPID": window.app.processIdentifier != nil
+ ])
+ return nil
+ }
+
+ if let finderTabActivated = activateFinderTabPageIfNeeded(
+ window: window,
+ axMetadata: AXWindowMetadataReader.metadata(appCategorizer: appCategorizer),
+ operation: "windowClose",
+ reason: reason
+ ) {
+ guard finderTabActivated else {
+ DevelopmentDiagnostics.log("windowClose.commandW.finderTabActivationFailed", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason
+ ])
+ return .failed("finderTabActivationFailed")
+ }
+ } else {
+ guard let activationOutcome = activateViaPrivateWindowServerAPI(window),
+ activationOutcome.succeeded
+ else {
+ DevelopmentDiagnostics.log("windowClose.commandW.activationFailed", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason
+ ])
+ return nil
+ }
+ }
+
+ Thread.sleep(forTimeInterval: 0.08)
+ guard postCommandW(to: processIdentifier) else {
+ DevelopmentDiagnostics.log("windowClose.commandW.postFailed", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason
+ ])
+ return .failed("commandWPostFailed")
+ }
+
+ DevelopmentDiagnostics.log("windowClose.commandW.requested", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason
+ ])
+ return .requested
+ }
+
+ private func postCommandW(to processIdentifier: Int32) -> Bool {
+ let source = CGEventSource(stateID: .combinedSessionState)
+ guard let keyDown = CGEvent(
+ keyboardEventSource: source,
+ virtualKey: Self.commandWVirtualKeyCode,
+ keyDown: true
+ ),
+ let keyUp = CGEvent(
+ keyboardEventSource: source,
+ virtualKey: Self.commandWVirtualKeyCode,
+ keyDown: false
+ )
+ else {
+ return false
+ }
+
+ keyDown.flags = .maskCommand
+ keyUp.flags = .maskCommand
+ keyDown.postToPid(processIdentifier)
+ keyUp.postToPid(processIdentifier)
+ return true
+ }
+
+ private func axWindow(
+ for window: AlignerWindow,
+ in axMetadata: [AXWindowMetadata],
+ operation: String = "windowClose",
+ matchAttempt: String = "initial"
+ ) -> AXWindowMetadata? {
+ if let directMatch = axMetadata.first(where: { $0.windowID == window.id }) {
+ DevelopmentDiagnostics.log("\(operation).axMatch.directWindowID", [
+ "windowID": window.id,
+ "pid": window.app.processIdentifier,
+ "attempt": matchAttempt
+ ])
+ return directMatch
+ }
+
+ guard let processIdentifier = window.app.processIdentifier else {
+ return nil
+ }
+
+ if let geometryFingerprint = axWindowGeometryFingerprint(for: window) {
+ let geometryMatches = axMetadata.filter { metadata in
+ AXWindowGeometryFingerprint(metadata) == geometryFingerprint
+ }
+ if geometryMatches.count == 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.geometryFingerprint", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "attempt": matchAttempt
+ ])
+ return geometryMatches[0]
+ }
+
+ if geometryMatches.count > 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.geometryFingerprintAmbiguous", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "candidateCount": geometryMatches.count,
+ "attempt": matchAttempt
+ ])
+ }
+ }
+
+ if let cgFingerprint = cgWindowFingerprint(for: window) {
+ let fingerprintMatches = axMetadata.filter { metadata in
+ AXWindowFingerprint(metadata) == cgFingerprint
+ }
+ if fingerprintMatches.count == 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.fingerprint", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "attempt": matchAttempt
+ ])
+ return fingerprintMatches[0]
+ }
+
+ if fingerprintMatches.count > 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.fingerprintAmbiguous", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "candidateCount": fingerprintMatches.count,
+ "attempt": matchAttempt
+ ])
+ }
+ }
+
+ let normalizedTitle = normalizedWindowTitle(window.title)
+ let titleMatches = axMetadata.filter { metadata in
+ metadata.processIdentifier == processIdentifier
+ && normalizedWindowTitle(metadata.title ?? "") == normalizedTitle
+ }
+ if !normalizedTitle.isEmpty, titleMatches.count == 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.normalizedTitle", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "attempt": matchAttempt
+ ])
+ return titleMatches[0]
+ }
+
+ if window.app.bundleIdentifier == "com.apple.finder",
+ let finderMatch = finderFallbackAXWindow(
+ for: window,
+ processIdentifier: processIdentifier,
+ in: axMetadata
+ ) {
+ DevelopmentDiagnostics.log("\(operation).axMatch.finderFallback", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "attempt": matchAttempt
+ ])
+ return finderMatch
+ }
+
+ if titleMatches.count > 1 {
+ DevelopmentDiagnostics.log("\(operation).axMatch.titleAmbiguous", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "candidateCount": titleMatches.count,
+ "attempt": matchAttempt
+ ])
+ }
+
+ return nil
+ }
+
+ private func finderFallbackAXWindow(
+ for window: AlignerWindow,
+ processIdentifier: Int32,
+ in axMetadata: [AXWindowMetadata]
+ ) -> AXWindowMetadata? {
+ let normalizedTitle = normalizedWindowTitle(window.title)
+ guard !normalizedTitle.isEmpty else { return nil }
+
+ let finderCandidates = axMetadata.filter { metadata in
+ metadata.processIdentifier == processIdentifier
+ && normalizedWindowTitle(metadata.title ?? "") == normalizedTitle
+ && metadata.subrole == .standard
+ }
+ return finderCandidates.count == 1 ? finderCandidates[0] : nil
+ }
+
+ private func activateFinderTabPageIfNeeded(
+ window: AlignerWindow,
+ axMetadata: [AXWindowMetadata],
+ operation: String,
+ reason: String
+ ) -> Bool? {
+ guard isFinderCGOnlyPageCandidate(window),
+ let processIdentifier = window.app.processIdentifier
+ else {
+ return nil
+ }
+
+ let budget = FinderTabActivationBudget(limit: Self.finderTabActivationBudgetLimit)
+ let hostLookupStartedAt = ProcessInfo.processInfo.systemUptime
+ let host = finderTabHostAXWindow(for: window, in: axMetadata, budget: budget)
+ DevelopmentDiagnostics.log("\(operation).finderTab.hostLookup", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason,
+ "hostFound": host != nil,
+ "hostWindowID": host?.windowID,
+ "elapsedMilliseconds": Self.elapsedMilliseconds(since: hostLookupStartedAt),
+ "overallElapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetRemainingMilliseconds": Self.milliseconds(budget.remaining)
+ ])
+
+ guard let host else {
+ if budget.isExhausted {
+ DevelopmentDiagnostics.log("\(operation).finderTab.hostMissingBudgetExceeded", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return false
+ }
+
+ let normalizedTargetTitle = normalizedWindowTitle(window.title)
+ let applicationActivated = activateApplication(processIdentifier: processIdentifier)
+ let selectedViaWindowMenu = !normalizedTargetTitle.isEmpty
+ && selectFinderWindowMenuItem(
+ processIdentifier: processIdentifier,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ budget: budget
+ )
+ DevelopmentDiagnostics.log("\(operation).finderTab.hostlessWindowMenuResult", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason,
+ "applicationActivated": applicationActivated,
+ "selectedViaWindowMenu": selectedViaWindowMenu,
+ "spaceIDs": window.spaceIDs,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ if selectedViaWindowMenu {
+ return true
+ }
+
+ DevelopmentDiagnostics.log("\(operation).finderTab.hostMissing", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason,
+ "spaceIDs": window.spaceIDs,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return false
+ }
+
+ let hostPrivateActivationSucceeded: Bool
+ if let hostWindowID = host.windowID,
+ let privateActivationBridge {
+ hostPrivateActivationSucceeded = privateActivationBridge.activate(
+ processIdentifier: processIdentifier,
+ windowID: hostWindowID
+ ).succeeded
+ } else {
+ hostPrivateActivationSucceeded = false
+ }
+
+ let applicationActivated = activateApplication(processIdentifier: processIdentifier)
+ let beforeAttempt = focusMainRaiseWindowResult(host.element, processIdentifier: processIdentifier)
+ let selectedTabStartedAt = ProcessInfo.processInfo.systemUptime
+ let selectedTab = budget.isExhausted ? false : selectFinderTab(window, in: host, budget: budget)
+ DevelopmentDiagnostics.log("\(operation).finderTab.selectElapsed", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "hostWindowID": host.windowID,
+ "selectedTab": selectedTab,
+ "elapsedMilliseconds": Self.elapsedMilliseconds(since: selectedTabStartedAt),
+ "overallElapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetRemainingMilliseconds": Self.milliseconds(budget.remaining)
+ ])
+ if selectedTab, budget.remaining > 0 {
+ Thread.sleep(forTimeInterval: min(0.05, budget.remaining))
+ }
+ let afterAttempt: WindowFocusAttempt?
+ if selectedTab {
+ // For Finder tab/page cards, re-focusing the original host AX window after
+ // selecting the tab can switch Finder back to the host's previous tab.
+ afterAttempt = nil
+ } else {
+ afterAttempt = focusMainRaiseWindowResult(host.element, processIdentifier: processIdentifier)
+ }
+
+ let didFocusOrRaise = beforeAttempt.success || (afterAttempt?.success ?? false)
+ let activated = selectedTab
+ && (hostPrivateActivationSucceeded || applicationActivated || didFocusOrRaise)
+
+ DevelopmentDiagnostics.log("\(operation).finderTab.result", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "reason": reason,
+ "hostWindowID": host.windowID,
+ "hostTitleHash": DevelopmentDiagnostics.stableFingerprint(host.title),
+ "hostTitleLength": host.title?.count,
+ "hostPrivateActivated": hostPrivateActivationSucceeded,
+ "applicationActivated": applicationActivated,
+ "selectedTab": selectedTab,
+ "focusBeforeAXError": String(describing: beforeAttempt.focused.error),
+ "mainBeforeAXError": String(describing: beforeAttempt.main.error),
+ "raiseBeforeAXError": String(describing: beforeAttempt.raised.error),
+ "focusAfterAXError": afterAttempt.map { String(describing: $0.focused.error) } ?? "skippedAfterTabSelection",
+ "mainAfterAXError": afterAttempt.map { String(describing: $0.main.error) } ?? "skippedAfterTabSelection",
+ "raiseAfterAXError": afterAttempt.map { String(describing: $0.raised.error) } ?? "skippedAfterTabSelection",
+ "activated": activated,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+
+ return activated
+ }
+
+ private func isFinderCGOnlyPageCandidate(_ window: AlignerWindow) -> Bool {
+ window.identifierSource == .cgWindow
+ && window.app.bundleIdentifier == "com.apple.finder"
+ && !window.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+ }
+
+ private func finderTabHostAXWindow(
+ for window: AlignerWindow,
+ in axMetadata: [AXWindowMetadata],
+ budget: FinderTabActivationBudget
+ ) -> AXWindowMetadata? {
+ guard let processIdentifier = window.app.processIdentifier else { return nil }
+ let candidates = axMetadata.filter { metadata in
+ metadata.processIdentifier == processIdentifier
+ && metadata.subrole == .standard
+ && metadata.frame?.isEmpty == false
+ }
+ guard !candidates.isEmpty else { return nil }
+
+ let targetSpaceIDs = Set(window.spaceIDs)
+ let candidateIDs = candidates.compactMap(\.windowID)
+ let candidateSpacesByID = targetSpaceIDs.isEmpty ? [:] : spaceIDsByWindowIDProvider(candidateIDs)
+ let spaceCompatibleCandidates = targetSpaceIDs.isEmpty
+ ? candidates
+ : candidates.filter { metadata in
+ guard let windowID = metadata.windowID else { return false }
+ return !Set(candidateSpacesByID[windowID] ?? []).isDisjoint(with: targetSpaceIDs)
+ }
+ let spaceScopedCandidates = spaceCompatibleCandidates.isEmpty ? candidates : spaceCompatibleCandidates
+
+ let targetFrame = matchingFrame(for: window)
+ let frameScoredHosts = spaceScopedCandidates.compactMap { metadata -> (metadata: AXWindowMetadata, score: CGFloat)? in
+ guard let score = frameOverlapScore(targetFrame, metadata.frame),
+ score >= 0.85
+ else {
+ return nil
+ }
+
+ return (metadata, score)
+ }
+ .sorted { lhs, rhs in
+ if lhs.score != rhs.score {
+ return lhs.score > rhs.score
+ }
+ return (lhs.metadata.windowID ?? UInt32.max) < (rhs.metadata.windowID ?? UInt32.max)
+ }
+
+ if let best = frameScoredHosts.first {
+ if frameScoredHosts.count == 1 {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.frameInferredHost", [
+ "windowID": window.id,
+ "hostWindowID": best.metadata.windowID,
+ "score": Double(best.score),
+ "spaceIDCount": targetSpaceIDs.count,
+ "candidateCount": spaceScopedCandidates.count,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count
+ ])
+ return best.metadata
+ }
+
+ let secondBest = frameScoredHosts[1]
+ if best.score - secondBest.score >= 0.05 {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.frameInferredHost", [
+ "windowID": window.id,
+ "hostWindowID": best.metadata.windowID,
+ "score": Double(best.score),
+ "secondBestScore": Double(secondBest.score),
+ "spaceIDCount": targetSpaceIDs.count,
+ "candidateCount": spaceScopedCandidates.count,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count
+ ])
+ return best.metadata
+ }
+ }
+
+ guard !budget.isExhausted else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.hostLookupBudgetExceeded", [
+ "windowID": window.id,
+ "candidateCount": spaceScopedCandidates.count,
+ "spaceIDCount": targetSpaceIDs.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return nil
+ }
+
+ let representationScanCandidates = Array(spaceScopedCandidates.prefix(Self.finderTabHostRepresentationScanLimit))
+ let selectableHostCandidates = representationScanCandidates.filter { metadata in
+ finderHostCanRepresentTarget(window, in: metadata, budget: budget)
+ }
+
+ if spaceScopedCandidates.count > representationScanCandidates.count {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.hostRepresentationScanLimited", [
+ "windowID": window.id,
+ "candidateCount": spaceScopedCandidates.count,
+ "scannedCandidateCount": representationScanCandidates.count,
+ "selectableCandidateCount": selectableHostCandidates.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ }
+
+ let hostCandidates = selectableHostCandidates.isEmpty
+ ? spaceScopedCandidates
+ : selectableHostCandidates
+
+ if hostCandidates.count == 1 {
+ if selectableHostCandidates.isEmpty {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.singleFrameHostFallback", [
+ "windowID": window.id,
+ "hostWindowID": hostCandidates[0].windowID,
+ "spaceIDCount": targetSpaceIDs.count,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count
+ ])
+ }
+ return hostCandidates[0]
+ }
+
+ DevelopmentDiagnostics.log("windowActivation.finderTab.hostAmbiguous", [
+ "windowID": window.id,
+ "candidateCount": hostCandidates.count,
+ "spaceIDCount": targetSpaceIDs.count,
+ "hasTargetFrame": targetFrame != nil,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count
+ ])
+ return nil
+ }
+
+ private func finderHostCanRepresentTarget(
+ _ window: AlignerWindow,
+ in host: AXWindowMetadata,
+ budget: FinderTabActivationBudget
+ ) -> Bool {
+ let normalizedTargetTitle = normalizedWindowTitle(window.title)
+ guard !normalizedTargetTitle.isEmpty else { return false }
+
+ if normalizedWindowTitle(host.title ?? "") == normalizedTargetTitle {
+ return true
+ }
+
+ guard !budget.isExhausted else { return false }
+ return finderTabControl(matchingNormalizedTitle: normalizedTargetTitle, in: host.element, budget: budget) != nil
+ }
+
+ private func selectFinderTab(
+ _ window: AlignerWindow,
+ in host: AXWindowMetadata,
+ budget: FinderTabActivationBudget
+ ) -> Bool {
+ let normalizedTargetTitle = normalizedWindowTitle(window.title)
+ guard !normalizedTargetTitle.isEmpty else { return false }
+
+ if normalizedWindowTitle(host.title ?? "") == normalizedTargetTitle {
+ return true
+ }
+
+ guard let tabControl = finderTabControl(
+ matchingNormalizedTitle: normalizedTargetTitle,
+ in: host.element,
+ budget: budget
+ ) else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.tabButtonMissing", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ if let processIdentifier = window.app.processIdentifier,
+ !budget.isExhausted,
+ selectFinderTabByCyclingTabs(
+ processIdentifier: processIdentifier,
+ host: host,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ budget: budget
+ ) {
+ return true
+ }
+ if let processIdentifier = window.app.processIdentifier,
+ !budget.isExhausted,
+ selectFinderWindowMenuItem(
+ processIdentifier: processIdentifier,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ budget: budget
+ ) {
+ return true
+ }
+ return false
+ }
+
+ let tabButton = tabControl.button
+ let tabButtonRole = axStringAttribute(kAXRoleAttribute as String, for: tabButton)
+ let tabButtonSubrole = axStringAttribute(kAXSubroleAttribute as String, for: tabButton)
+ let pressResult = AXUIElementPerformAction(tabButton, kAXPressAction as CFString)
+ DevelopmentDiagnostics.log("windowActivation.finderTab.pressTab", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "tabButtonRole": tabButtonRole,
+ "tabButtonSubrole": tabButtonSubrole,
+ "axError": String(describing: pressResult)
+ ])
+ if pressResult == .success,
+ finderHostTitleMatchesTarget(
+ host,
+ normalizedTargetTitle: normalizedTargetTitle,
+ attempts: Self.finderTabFastTitleMatchAttempts,
+ delay: Self.finderTabFastTitleMatchDelay,
+ budget: budget
+ ) {
+ return true
+ }
+
+ if let tabGroup = tabControl.tabGroup {
+ let selectedChildrenResult = AXUIElementSetAttributeValue(
+ tabGroup,
+ kAXSelectedChildrenAttribute as CFString,
+ [tabButton] as CFArray
+ )
+ DevelopmentDiagnostics.log("windowActivation.finderTab.setSelectedChildren", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "axError": String(describing: selectedChildrenResult)
+ ])
+ if selectedChildrenResult == .success,
+ finderHostTitleMatchesTarget(
+ host,
+ normalizedTargetTitle: normalizedTargetTitle,
+ attempts: Self.finderTabFastTitleMatchAttempts,
+ delay: Self.finderTabFastTitleMatchDelay,
+ budget: budget
+ ) {
+ return true
+ }
+ }
+
+ let valueResult = AXUIElementSetAttributeValue(
+ tabButton,
+ kAXValueAttribute as CFString,
+ kCFBooleanTrue
+ )
+ DevelopmentDiagnostics.log("windowActivation.finderTab.setValue", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "axError": String(describing: valueResult)
+ ])
+ if valueResult == .success,
+ finderHostTitleMatchesTarget(
+ host,
+ normalizedTargetTitle: normalizedTargetTitle,
+ attempts: Self.finderTabFastTitleMatchAttempts,
+ delay: Self.finderTabFastTitleMatchDelay,
+ budget: budget
+ ) {
+ return true
+ }
+
+ if let processIdentifier = window.app.processIdentifier,
+ !budget.isExhausted,
+ selectFinderTabByCyclingTabs(
+ processIdentifier: processIdentifier,
+ host: host,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ budget: budget
+ ) {
+ return true
+ }
+
+ if let processIdentifier = window.app.processIdentifier,
+ !budget.isExhausted,
+ selectFinderWindowMenuItem(
+ processIdentifier: processIdentifier,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ budget: budget
+ ) {
+ return true
+ }
+
+ let currentHostTitle = axStringAttribute(kAXTitleAttribute as String, for: host.element) ?? ""
+ DevelopmentDiagnostics.log("windowActivation.finderTab.selectionVerificationFailed", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count,
+ "currentHostTitleHash": DevelopmentDiagnostics.stableFingerprint(currentHostTitle),
+ "currentHostTitleLength": currentHostTitle.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+ return false
+ }
+
+ private func finderTabControl(
+ matchingNormalizedTitle targetTitle: String,
+ in root: AXUIElement,
+ budget: FinderTabActivationBudget
+ ) -> FinderTabControl? {
+ var visitedCount = 0
+
+ func search(_ element: AXUIElement, depth: Int, tabGroup: AXUIElement?) -> FinderTabControl? {
+ visitedCount += 1
+ guard visitedCount <= 240, depth <= 9, !budget.isExhausted else { return nil }
+
+ let role = axStringAttribute(kAXRoleAttribute as String, for: element)
+ let subrole = axStringAttribute(kAXSubroleAttribute as String, for: element)
+ let title = axStringAttribute(kAXTitleAttribute as String, for: element)
+ ?? axStringAttribute(kAXDescriptionAttribute as String, for: element)
+ ?? axStringAttribute(kAXValueAttribute as String, for: element)
+ let isTabGroup = role == "AXTabGroup"
+ let currentTabGroup = isTabGroup ? element : tabGroup
+ let isTabControl = subrole == "AXTabButton"
+ || (currentTabGroup != nil && (role == kAXRadioButtonRole as String || role == kAXButtonRole as String))
+
+ if normalizedWindowTitle(title ?? "") == targetTitle,
+ isTabControl {
+ return FinderTabControl(button: element, tabGroup: currentTabGroup)
+ }
+
+ guard isTabGroup || currentTabGroup != nil || depth < 7 else { return nil }
+ for child in axChildren(of: element) {
+ if let match = search(child, depth: depth + 1, tabGroup: currentTabGroup) {
+ return match
+ }
+ }
+
+ return nil
+ }
+
+ return search(root, depth: 0, tabGroup: nil)
+ }
+
+ private func finderHostTitleMatchesTarget(
+ _ host: AXWindowMetadata,
+ normalizedTargetTitle: String,
+ attempts: Int = 10,
+ delay: TimeInterval = 0.04,
+ budget: FinderTabActivationBudget? = nil
+ ) -> Bool {
+ let attemptCount = max(1, attempts)
+ for attempt in 0..<attemptCount {
+ if attempt > 0 {
+ let sleepDuration = budget.map { min(delay, $0.remaining) } ?? delay
+ if sleepDuration > 0 {
+ Thread.sleep(forTimeInterval: sleepDuration)
+ }
+ }
+
+ let selectedTitle = normalizedWindowTitle(
+ axStringAttribute(kAXTitleAttribute as String, for: host.element) ?? ""
+ )
+ if selectedTitle == normalizedTargetTitle {
+ return true
+ }
+
+ if budget?.isExhausted == true {
+ break
+ }
+ }
+
+ return false
+ }
+
+ private func selectFinderWindowMenuItem(
+ processIdentifier: Int32,
+ window: AlignerWindow,
+ normalizedTargetTitle: String,
+ budget: FinderTabActivationBudget
+ ) -> Bool {
+ guard !budget.isExhausted else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuSkippedBudgetExceeded", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return false
+ }
+
+ let appElement = AXUIElementCreateApplication(processIdentifier)
+ guard let menuBar = axElementAttribute(kAXMenuBarAttribute as String, for: appElement) else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuMissing", [
+ "windowID": window.id,
+ "pid": processIdentifier
+ ])
+ return false
+ }
+
+ for menuBarItem in axChildren(of: menuBar) where isWindowMenuBarItem(menuBarItem) {
+ let openResult = AXUIElementPerformAction(menuBarItem, kAXPressAction as CFString)
+ if budget.remaining > 0 {
+ Thread.sleep(forTimeInterval: min(0.08, budget.remaining))
+ }
+ guard openResult == .success,
+ let menuItem = finderWindowMenuItem(
+ matchingNormalizedTitle: normalizedTargetTitle,
+ in: menuBarItem,
+ budget: budget
+ )
+ else {
+ continue
+ }
+
+ let pressResult = AXUIElementPerformAction(menuItem, kAXPressAction as CFString)
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuPress", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "axError": String(describing: pressResult)
+ ])
+ guard pressResult == .success else { return false }
+
+ if finderFocusedWindowTitleMatches(
+ processIdentifier: processIdentifier,
+ window: window,
+ normalizedTargetTitle: normalizedTargetTitle,
+ initialDelay: Self.finderTabWindowMenuVerificationInitialDelay,
+ attempts: Self.finderTabWindowMenuVerificationAttempts,
+ delay: Self.finderTabWindowMenuVerificationDelay,
+ requiredConsecutiveMatches: 2,
+ budget: budget
+ ) {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuSucceeded", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return true
+ }
+
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuVerificationFailed", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+ }
+
+ DevelopmentDiagnostics.log("windowActivation.finderTab.windowMenuItemMissing", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+ return false
+ }
+
+ private func isWindowMenuBarItem(_ element: AXUIElement) -> Bool {
+ let title = normalizedWindowTitle(axStringAttribute(kAXTitleAttribute as String, for: element) ?? "")
+ return title == "window" || title == "窗口"
+ }
+
+ private func finderWindowMenuItem(
+ matchingNormalizedTitle targetTitle: String,
+ in root: AXUIElement,
+ budget: FinderTabActivationBudget
+ ) -> AXUIElement? {
+ var visitedCount = 0
+
+ func search(_ element: AXUIElement, depth: Int) -> AXUIElement? {
+ visitedCount += 1
+ guard visitedCount <= 500, depth <= 8, !budget.isExhausted else { return nil }
+
+ let role = axStringAttribute(kAXRoleAttribute as String, for: element)
+ let title = axStringAttribute(kAXTitleAttribute as String, for: element)
+ ?? axStringAttribute(kAXDescriptionAttribute as String, for: element)
+ if role == kAXMenuItemRole as String,
+ normalizedWindowTitle(title ?? "") == targetTitle {
+ return element
+ }
+
+ for child in axChildren(of: element) {
+ if let match = search(child, depth: depth + 1) {
+ return match
+ }
+ }
+
+ return nil
+ }
+
+ return search(root, depth: 0)
+ }
+
+ private func finderFocusedOrMainWindowTitle(processIdentifier: Int32) -> String? {
+ let appElement = AXUIElementCreateApplication(processIdentifier)
+ let focusedWindow = axElementAttribute(kAXFocusedWindowAttribute as String, for: appElement)
+ ?? axElementAttribute(kAXMainWindowAttribute as String, for: appElement)
+ return focusedWindow.flatMap {
+ axStringAttribute(kAXTitleAttribute as String, for: $0)
+ }
+ }
+
+ private func finderFocusedWindowTitleMatches(
+ processIdentifier: Int32,
+ window: AlignerWindow,
+ normalizedTargetTitle: String,
+ initialDelay: TimeInterval,
+ attempts: Int,
+ delay: TimeInterval,
+ requiredConsecutiveMatches: Int,
+ budget: FinderTabActivationBudget
+ ) -> Bool {
+ var consecutiveMatches = 0
+ var lastTitle: String?
+
+ if budget.remaining > 0 {
+ Thread.sleep(forTimeInterval: min(initialDelay, budget.remaining))
+ }
+ let attemptCount = max(1, attempts)
+ for attempt in 0..<attemptCount {
+ let title = finderFocusedOrMainWindowTitle(processIdentifier: processIdentifier)
+ lastTitle = title
+ if normalizedWindowTitle(title ?? "") == normalizedTargetTitle {
+ consecutiveMatches += 1
+ } else {
+ consecutiveMatches = 0
+ }
+
+ if consecutiveMatches >= requiredConsecutiveMatches {
+ return true
+ }
+ if budget.isExhausted || attempt == attemptCount - 1 {
+ break
+ }
+ let sleepDuration = min(delay, budget.remaining)
+ if sleepDuration > 0 {
+ Thread.sleep(forTimeInterval: sleepDuration)
+ }
+ }
+
+ DevelopmentDiagnostics.log("windowActivation.finderTab.focusedTitleMismatch", [
+ "windowID": window.id,
+ "pid": processIdentifier,
+ "targetTitleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
+ "targetTitleLength": window.title.count,
+ "lastTitleHash": DevelopmentDiagnostics.stableFingerprint(lastTitle),
+ "lastTitleLength": lastTitle?.count,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+ return false
+ }
+
+ private func selectFinderTabByCyclingTabs(
+ processIdentifier: Int32,
+ host: AXWindowMetadata,
+ window: AlignerWindow,
+ normalizedTargetTitle: String,
+ budget: FinderTabActivationBudget
+ ) -> Bool {
+ let maximumAttempts = Self.finderTabCycleMaximumAttempts
+ for attempt in 1...maximumAttempts {
+ guard !budget.isExhausted else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.cycleBudgetExceeded", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "attempt": attempt,
+ "attemptLimit": maximumAttempts,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return false
+ }
+
+ for shortcut in Self.finderNextTabShortcuts {
+ guard postKeyboardShortcut(to: processIdentifier, shortcut: shortcut) else {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.cyclePostFailed", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "attempt": attempt,
+ "shortcut": shortcut.name
+ ])
+ return false
+ }
+
+ if finderHostTitleMatchesTarget(
+ host,
+ normalizedTargetTitle: normalizedTargetTitle,
+ attempts: 2,
+ delay: 0.025,
+ budget: budget
+ ) {
+ DevelopmentDiagnostics.log("windowActivation.finderTab.cycleSucceeded", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "attempt": attempt,
+ "attemptLimit": maximumAttempts,
+ "shortcut": shortcut.name,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit)
+ ])
+ return true
+ }
+ }
+ }
+
+ DevelopmentDiagnostics.log("windowActivation.finderTab.cycleFailed", [
+ "windowID": window.id,
+ "hostWindowID": host.windowID,
+ "attemptCount": maximumAttempts,
+ "elapsedMilliseconds": budget.elapsedMilliseconds,
+ "budgetMilliseconds": Self.milliseconds(budget.limit),
+ "budgetExceeded": budget.isExhausted
+ ])
+ return false
+ }
+
+ private func postKeyboardShortcut(
+ to processIdentifier: Int32,
+ shortcut: KeyboardShortcut
+ ) -> Bool {
+ let source = CGEventSource(stateID: .combinedSessionState)
+ guard let keyDown = CGEvent(
+ keyboardEventSource: source,
+ virtualKey: shortcut.keyCode,
+ keyDown: true
+ ),
+ let keyUp = CGEvent(
+ keyboardEventSource: source,
+ virtualKey: shortcut.keyCode,
+ keyDown: false
+ )
+ else {
+ return false
+ }
+
+ keyDown.flags = shortcut.flags
+ keyUp.flags = shortcut.flags
+ keyDown.postToPid(processIdentifier)
+ keyUp.postToPid(processIdentifier)
+ return true
+ }
+
+ private func axChildren(of element: AXUIElement) -> [AXUIElement] {
+ var value: CFTypeRef?
+ guard AXUIElementCopyAttributeValue(element, kAXChildrenAttribute as CFString, &value) == .success,
+ let children = value as? [AXUIElement]
+ else {
+ return []
+ }
+
+ return children
+ }
+
+ private func axStringAttribute(_ attribute: String, for element: AXUIElement) -> String? {
+ var value: CFTypeRef?
+ guard AXUIElementCopyAttributeValue(element, attribute as CFString, &value) == .success,
+ let value
+ else {
+ return nil
+ }
+
+ return value as? String
+ }
+
+ private func axElementAttribute(_ attribute: String, for element: AXUIElement) -> AXUIElement? {
+ var value: CFTypeRef?
+ guard AXUIElementCopyAttributeValue(element, attribute as CFString, &value) == .success,
+ let value,
+ CFGetTypeID(value) == AXUIElementGetTypeID()
+ else {
+ return nil
+ }
+
+ return (value as! AXUIElement)
+ }
+
+ private func frameOverlapScore(_ lhs: CGRect?, _ rhs: CGRect?) -> CGFloat? {
+ guard let lhs,
+ let rhs,
+ !lhs.isEmpty,
+ !rhs.isEmpty
+ else {
+ return nil
+ }
+
+ let intersection = lhs.intersection(rhs)
+ guard !intersection.isNull,
+ !intersection.isEmpty
+ else {
+ return nil
+ }
+
+ let denominator = min(lhs.width * lhs.height, rhs.width * rhs.height)
+ guard denominator > 0 else { return nil }
+ let overlap = (intersection.width * intersection.height) / denominator
+ let widthSimilarity = min(lhs.width, rhs.width) / max(lhs.width, rhs.width)
+ let heightSimilarity = min(lhs.height, rhs.height) / max(lhs.height, rhs.height)
+ let sizeSimilarity = min(widthSimilarity, heightSimilarity)
+ guard sizeSimilarity >= 0.80 else { return nil }
+ return min(overlap, sizeSimilarity)
+ }
+
+ private func cgWindowFingerprint(for window: AlignerWindow) -> AXWindowFingerprint? {
+ guard let rawWindows = CGWindowListCopyWindowInfo(
+ [.optionIncludingWindow],
+ CGWindowID(window.id)
+ ) as? [[String: Any]],
+ let rawWindow = rawWindows.first,
+ let ownerPID = int32Value(rawWindow[kCGWindowOwnerPID as String])
+ else {
+ return nil
+ }
+
+ return AXWindowFingerprint(
+ processIdentifier: ownerPID,
+ title: normalizedWindowTitle(title(rawWindow: rawWindow, axWindow: nil)),
+ size: bounds(rawWindow[kCGWindowBounds as String]).size
+ )
+ }
+
+ private func axWindowGeometryFingerprint(for window: AlignerWindow) -> AXWindowGeometryFingerprint? {
+ guard let processIdentifier = window.app.processIdentifier else { return nil }
+ let frame = matchingFrame(for: window)
+ return AXWindowGeometryFingerprint(
+ processIdentifier: processIdentifier,
+ title: normalizedWindowTitle(window.title),
+ frame: frame
+ )
+ }
+
+ private func cgWindowFrame(for window: AlignerWindow) -> CGRect? {
+ guard let rawWindows = CGWindowListCopyWindowInfo(
+ [.optionIncludingWindow],
+ CGWindowID(window.id)
+ ) as? [[String: Any]],
+ let rawWindow = rawWindows.first
+ else {
+ return nil
+ }
+
+ return bounds(rawWindow[kCGWindowBounds as String])
+ }
+
+ private func matchingFrame(for window: AlignerWindow) -> CGRect? {
+ if isFinderCGOnlyPageCandidate(window) {
+ return window.frame ?? cgWindowFrame(for: window)
+ }
+
+ return cgWindowFrame(for: window) ?? window.frame
+ }
+
+ private func matchingAXTitleCandidateCount(
+ for window: AlignerWindow,
+ in axMetadata: [AXWindowMetadata]
+ ) -> Int {
+ guard let processIdentifier = window.app.processIdentifier else { return 0 }
+ let normalizedTitle = normalizedWindowTitle(window.title)
+ return axMetadata.filter { metadata in
+ metadata.processIdentifier == processIdentifier
+ && normalizedWindowTitle(metadata.title ?? "") == normalizedTitle
+ }.count
+ }
+
+ private func matchingAXSizeCandidateCount(
+ for window: AlignerWindow,
+ in axMetadata: [AXWindowMetadata]
+ ) -> Int {
+ guard let processIdentifier = window.app.processIdentifier,
+ let cgFingerprint = cgWindowFingerprint(for: window)
+ else {
+ return 0
+ }
+
+ return axMetadata.filter { metadata in
+ metadata.processIdentifier == processIdentifier
+ && Int(metadata.size.width.rounded()) == cgFingerprint.width
+ && Int(metadata.size.height.rounded()) == cgFingerprint.height
+ }.count
+ }
+
+ func close(app: AlignerApp) throws -> WindowCloseResult {
+ DevelopmentDiagnostics.log("windowClose.app.start", [
+ "appName": app.name,
+ "bundleIdentifier": app.bundleIdentifier,
+ "pid": app.processIdentifier
+ ])
+
+ guard let processIdentifier = app.processIdentifier else {
+ DevelopmentDiagnostics.log("windowClose.app.missingPID", [
+ "appName": app.name,
+ "bundleIdentifier": app.bundleIdentifier
+ ])
+ return .appNotFound
+ }
+ guard let runningApplication = NSRunningApplication(processIdentifier: processIdentifier) else {
+ DevelopmentDiagnostics.log("windowClose.app.missingApplication", [
+ "appName": app.name,
+ "pid": processIdentifier
+ ])
+ return .appNotFound
+ }
+
+ let requested = runningApplication.terminate()
+ DevelopmentDiagnostics.log("windowClose.app.result", [
+ "appName": app.name,
+ "pid": processIdentifier,
+ "requested": requested
+ ])
+ return requested ? .requested : .failed("terminateFailed")
}
private func activateViaPrivateWindowServerAPI(_ window: AlignerWindow) -> PrivateWindowActivationOutcome? {
@@ -362,13 +1773,14 @@
return nil
}
+ let rawBounds = bounds(rawWindow[kCGWindowBounds as String])
let ownerPID = int32Value(rawWindow[kCGWindowOwnerPID as String])
let runningApplication = ownerPID.flatMap(NSRunningApplication.init(processIdentifier:))
let rawFingerprint = ownerPID.map {
AXWindowFingerprint(
processIdentifier: $0,
title: title(rawWindow: rawWindow, axWindow: nil),
- size: bounds(rawWindow[kCGWindowBounds as String]).size
+ size: rawBounds.size
)
}
let directAXWindow = axMetadata[windowID]
@@ -388,7 +1800,8 @@
app: app,
activationPolicy: activationPolicy(from: runningApplication),
title: title(rawWindow: rawWindow, axWindow: axWindow),
- size: bounds(rawWindow[kCGWindowBounds as String]).size,
+ size: rawBounds.size,
+ frame: rawBounds,
subrole: axWindow?.subrole ?? .standard,
isMinimized: axWindow?.isMinimized ?? false,
isFullscreen: !Set(spaceIDs).isDisjoint(with: fullscreenSpaceIDs),
@@ -457,10 +1870,33 @@
}
let spaceIDs = spaceIDsByWindowID[resolvedWindowID] ?? []
- nextRestorableAXWindowsByID[resolvedWindowID] = RestorableAXWindow(
- processIdentifier: axWindow.processIdentifier,
- element: axWindow.element
- )
+ let isFullscreen = !Set(spaceIDs).isDisjoint(with: fullscreenSpaceIDs)
+ guard WindowEnumerationPolicy.shouldIncludeAXOnlyRecord(
+ identifierSource: identifierSource,
+ isMinimized: axWindow.isMinimized,
+ isFullscreen: isFullscreen,
+ spaceIDs: spaceIDs
+ ) else {
+ DevelopmentDiagnostics.log("windowEnumeration.axOnly.lowConfidenceSkipped", [
+ "windowID": resolvedWindowID,
+ "pid": axWindow.processIdentifier,
+ "appName": axWindow.app.name,
+ "bundleIdentifier": axWindow.app.bundleIdentifier,
+ "titleHash": DevelopmentDiagnostics.stableFingerprint(axWindow.title ?? ""),
+ "titleLength": axWindow.title?.count ?? 0,
+ "identifierSource": String(describing: identifierSource),
+ "isMinimized": axWindow.isMinimized,
+ "isFullscreen": isFullscreen,
+ "spaceIDCount": spaceIDs.count
+ ])
+ continue
+ }
+ if axWindow.isMinimized {
+ nextRestorableAXWindowsByID[resolvedWindowID] = RestorableAXWindow(
+ processIdentifier: axWindow.processIdentifier,
+ element: axWindow.element
+ )
+ }
axOnlyRecords.append(WindowEnumerationRecord(
id: resolvedWindowID,
app: axWindow.app,
@@ -468,9 +1904,10 @@
title: axWindow.title ?? "",
identifierSource: identifierSource,
size: axWindow.size,
+ frame: axWindow.frame,
subrole: axWindow.subrole,
isMinimized: axWindow.isMinimized,
- isFullscreen: !Set(spaceIDs).isDisjoint(with: fullscreenSpaceIDs),
+ isFullscreen: isFullscreen,
isGhost: false,
isDesktopElement: false,
isSystemCritical: isSystemCritical(app: axWindow.app),
@@ -482,7 +1919,31 @@
}
restorableAXWindowsByID = nextRestorableAXWindowsByID
- return cgRecords + axOnlyRecords
+ let records = cgRecords + axOnlyRecords
+ let attributedRecords = FinderTabSpaceAttributionPolicy.attributedRecords(records)
+ DevelopmentDiagnostics.log("windowEnumeration.finderTabSpaceAttribution", [
+ "finderNoSpaceCandidateCount": records.filter { record in
+ record.app.bundleIdentifier == "com.apple.finder"
+ && record.identifierSource == .cgWindow
+ && record.spaceIDs.isEmpty
+ && !record.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+ && record.frame?.isEmpty == false
+ }.count,
+ "finderFullscreenHostCount": records.filter { record in
+ record.app.bundleIdentifier == "com.apple.finder"
+ && record.isFullscreen
+ && !record.spaceIDs.isEmpty
+ && record.subrole == .standard
+ && record.frame?.isEmpty == false
+ }.count,
+ "attributedCount": zip(records, attributedRecords).filter { before, after in
+ before.spaceIDs.isEmpty && !after.spaceIDs.isEmpty
+ }.count,
+ "attributedWindowIDs": zip(records, attributedRecords).compactMap { before, after in
+ before.spaceIDs.isEmpty && !after.spaceIDs.isEmpty ? after.id : nil
+ }
+ ])
+ return attributedRecords
}
private func app(
@@ -544,6 +2005,64 @@
return activated
}
+ private func retryFocusMainRaiseWindow(
+ for window: AlignerWindow,
+ delay: TimeInterval,
+ matchAttempt: String
+ ) -> WindowFocusAttempt? {
+ if delay > 0 {
+ Thread.sleep(forTimeInterval: delay)
+ }
+
+ let retryMetadata = AXWindowMetadataReader.metadata(appCategorizer: appCategorizer)
+ guard let retryAXWindow = axWindow(
+ for: window,
+ in: retryMetadata,
+ operation: "windowActivation",
+ matchAttempt: matchAttempt
+ ) else {
+ DevelopmentDiagnostics.log("windowActivation.activate.retryAXLookupMissing", [
+ "windowID": window.id,
+ "pid": window.app.processIdentifier,
+ "attempt": matchAttempt,
+ "candidateCount": retryMetadata.filter { $0.processIdentifier == window.app.processIdentifier }.count,
+ "matchingTitleCandidateCount": matchingAXTitleCandidateCount(for: window, in: retryMetadata),
+ "matchingSizeCandidateCount": matchingAXSizeCandidateCount(for: window, in: retryMetadata)
+ ])
+ return nil
+ }
+
+ let attempt = focusMainRaiseWindowResult(
+ retryAXWindow.element,
+ processIdentifier: retryAXWindow.processIdentifier
+ )
+ DevelopmentDiagnostics.log("windowActivation.activate.retryAXFocus", [
+ "windowID": window.id,
+ "pid": retryAXWindow.processIdentifier,
+ "attempt": matchAttempt,
+ "matchedWindowID": retryAXWindow.windowID,
+ "matchedTitleHash": DevelopmentDiagnostics.stableFingerprint(retryAXWindow.title),
+ "focused": attempt.focused.success,
+ "focusAXError": String(describing: attempt.focused.error),
+ "main": attempt.main.success,
+ "mainAXError": String(describing: attempt.main.error),
+ "raised": attempt.raised.success,
+ "raiseAXError": String(describing: attempt.raised.error)
+ ])
+ return attempt
+ }
+
+ private func focusMainRaiseWindowResult(
+ _ window: AXUIElement,
+ processIdentifier: Int32
+ ) -> WindowFocusAttempt {
+ WindowFocusAttempt(
+ focused: focusWindowResult(window, processIdentifier: processIdentifier),
+ main: mainWindowResult(window),
+ raised: raiseWindowResult(window)
+ )
+ }
+
private func focusWindowResult(_ window: AXUIElement, processIdentifier: Int32) -> AXActionResult {
let appElement = AXUIElementCreateApplication(processIdentifier)
let error = AXUIElementSetAttributeValue(
@@ -554,8 +2073,25 @@
return AXActionResult(error: error)
}
+ private func mainWindowResult(_ window: AXUIElement) -> AXActionResult {
+ let error = AXUIElementSetAttributeValue(
+ window,
+ kAXMainAttribute as CFString,
+ kCFBooleanTrue
+ )
+ return AXActionResult(error: error)
+ }
+
private func raiseWindowResult(_ window: AXUIElement) -> AXActionResult {
AXActionResult(error: AXUIElementPerformAction(window, kAXRaiseAction as CFString))
+ }
+
+ private static func elapsedMilliseconds(since startedAt: TimeInterval) -> Int {
+ milliseconds(ProcessInfo.processInfo.systemUptime - startedAt)
+ }
+
+ private static func milliseconds(_ interval: TimeInterval) -> Int {
+ Int((max(0, interval) * 1_000).rounded())
}
private func activationPolicy(from runningApplication: NSRunningApplication?) -> AlignerActivationPolicy {
@@ -639,7 +2175,8 @@
let trimmedTitle = title.trimmingCharacters(in: .whitespacesAndNewlines)
if app.bundleIdentifier == "cc.ffitch.shottr" {
- return alpha > 0
+ return isOnscreen
+ && alpha > 0
&& trimmedTitle == "Shottr"
&& rawBounds.width > WindowEnumerationPolicy.minimumVisibleWidth
&& rawBounds.height > WindowEnumerationPolicy.minimumVisibleHeight
@@ -699,6 +2236,14 @@
return "activationFailed"
}
}
+
+ private static let commandWVirtualKeyCode: CGKeyCode = 13
+ private static let rightBracketVirtualKeyCode: CGKeyCode = 30
+ private static let tabVirtualKeyCode: CGKeyCode = 48
+ private static let finderNextTabShortcuts: [KeyboardShortcut] = [
+ KeyboardShortcut(name: "controlTab", keyCode: tabVirtualKeyCode, flags: .maskControl),
+ KeyboardShortcut(name: "commandShiftRightBracket", keyCode: rightBracketVirtualKeyCode, flags: [.maskCommand, .maskShift])
+ ]
}
private struct AXWindowMetadata {
@@ -708,6 +2253,7 @@
let title: String?
let isMinimized: Bool
let size: CGSize
+ let frame: CGRect?
let subrole: AlignerWindowSubrole
let hasExplicitSubrole: Bool
let isInteractable: Bool
@@ -767,6 +2313,34 @@
}
}
+private struct AXWindowGeometryFingerprint: Hashable {
+ let processIdentifier: Int32
+ let title: String
+ let x: Int
+ let y: Int
+ let width: Int
+ let height: Int
+
+ init?(processIdentifier: Int32, title: String, frame: CGRect?) {
+ guard let frame else { return nil }
+
+ self.processIdentifier = processIdentifier
+ self.title = title
+ self.x = Int(frame.origin.x.rounded())
+ self.y = Int(frame.origin.y.rounded())
+ self.width = Int(frame.size.width.rounded())
+ self.height = Int(frame.size.height.rounded())
+ }
+
+ init?(_ metadata: AXWindowMetadata) {
+ self.init(
+ processIdentifier: metadata.processIdentifier,
+ title: normalizedWindowTitle(metadata.title ?? ""),
+ frame: metadata.frame
+ )
+ }
+}
+
private struct RestorableAXWindow {
let processIdentifier: Int32
let element: AXUIElement
@@ -794,22 +2368,21 @@
let app = app(from: application, appCategorizer: appCategorizer)
let appElement = AXUIElementCreateApplication(application.processIdentifier)
- var windowsValue: CFTypeRef?
- guard AXUIElementCopyAttributeValue(appElement, kAXWindowsAttribute as CFString, &windowsValue) == .success,
- let windows = windowsValue as? [AXUIElement]
- else {
- continue
- }
+ let windows = windows(for: appElement)
+ guard !windows.isEmpty else { continue }
for (windowIndex, window) in windows.enumerated() {
let subrole = subrole(for: window)
+ let size = size(for: window)
+ let position = position(for: window)
result.append(AXWindowMetadata(
windowID: windowID(for: window),
app: app,
activationPolicy: activationPolicy(from: application),
title: title(for: window),
isMinimized: boolAttribute(kAXMinimizedAttribute as String, for: window) ?? false,
- size: size(for: window),
+ size: size,
+ frame: position.map { CGRect(origin: $0, size: size) },
subrole: subrole.value,
hasExplicitSubrole: subrole.isExplicit,
isInteractable: boolAttribute(kAXEnabledAttribute as String, for: window) ?? true,
@@ -818,6 +2391,38 @@
element: window
))
}
+ }
+
+ return result
+ }
+
+ private static func windows(for appElement: AXUIElement) -> [AXUIElement] {
+ var result: [AXUIElement] = []
+ var seen = Set<AXWindowElementKey>()
+
+ func append(_ window: AXUIElement) {
+ let key = AXWindowElementKey(window)
+ guard !seen.contains(key) else { return }
+ seen.insert(key)
+ result.append(window)
+ }
+
+ var windowsValue: CFTypeRef?
+ if AXUIElementCopyAttributeValue(appElement, kAXWindowsAttribute as CFString, &windowsValue) == .success,
+ let windows = windowsValue as? [AXUIElement] {
+ windows.forEach(append)
+ }
+
+ for attribute in [kAXFocusedWindowAttribute, kAXMainWindowAttribute] {
+ var windowValue: CFTypeRef?
+ guard AXUIElementCopyAttributeValue(appElement, attribute as CFString, &windowValue) == .success,
+ let window = windowValue,
+ CFGetTypeID(window) == AXUIElementGetTypeID()
+ else {
+ continue
+ }
+
+ append(window as! AXUIElement)
}
return result
@@ -904,6 +2509,23 @@
return size
}
+ private static func position(for window: AXUIElement) -> CGPoint? {
+ var value: CFTypeRef?
+ guard AXUIElementCopyAttributeValue(window, kAXPositionAttribute as CFString, &value) == .success,
+ let axValue = value,
+ CFGetTypeID(axValue) == AXValueGetTypeID()
+ else {
+ return nil
+ }
+
+ var position = CGPoint.zero
+ guard AXValueGetValue(axValue as! AXValue, .cgPoint, &position) else {
+ return nil
+ }
+
+ return position
+ }
+
private static func subrole(for window: AXUIElement) -> (value: AlignerWindowSubrole, isExplicit: Bool) {
var value: CFTypeRef?
guard AXUIElementCopyAttributeValue(window, kAXSubroleAttribute as CFString, &value) == .success,
@@ -922,6 +2544,39 @@
default:
return (.unknown(subrole), true)
}
+ }
+}
+
+private struct AXWindowElementKey: Hashable {
+ private let typeID: CFTypeID
+ private let pointer: UInt
+ private let windowID: UInt32?
+
+ init(_ element: AXUIElement) {
+ self.typeID = CFGetTypeID(element)
+ self.pointer = UInt(bitPattern: Unmanaged.passUnretained(element).toOpaque())
+ self.windowID = PrivateAXWindowIDReader.windowID(for: element)
+ }
+
+ static func == (lhs: AXWindowElementKey, rhs: AXWindowElementKey) -> Bool {
+ if let lhsWindowID = lhs.windowID,
+ let rhsWindowID = rhs.windowID {
+ return lhsWindowID == rhsWindowID
+ }
+
+ return lhs.typeID == rhs.typeID && lhs.pointer == rhs.pointer
+ }
+
+ func hash(into hasher: inout Hasher) {
+ if let windowID {
+ hasher.combine("windowID")
+ hasher.combine(windowID)
+ return
+ }
+
+ hasher.combine("pointer")
+ hasher.combine(typeID)
+ hasher.combine(pointer)
}
}
@@ -963,6 +2618,10 @@
value as? String
}
+private func normalizedWindowTitle(_ title: String) -> String {
+ title.trimmingCharacters(in: .whitespacesAndNewlines)
+}
+
private func boolValue(_ value: Any?) -> Bool {
switch value {
case let bool as Bool:
--
Gitblit v1.9.3