From e47223fbd1a6ec0c1ea417d36c4eff1feee93b81 Mon Sep 17 00:00:00 2001
From: Ariver <shanghai3168@gmail.com>
Date: Sat, 30 May 2026 17:01:31 +0800
Subject: [PATCH] Prepare 7.8.3 release package

---
 Scripts/window_logic_qa.sh |  274 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 259 insertions(+), 15 deletions(-)

diff --git a/Scripts/window_logic_qa.sh b/Scripts/window_logic_qa.sh
index 59b2b96..3d90bec 100755
--- a/Scripts/window_logic_qa.sh
+++ b/Scripts/window_logic_qa.sh
@@ -14,6 +14,8 @@
 DEFAULTS_DOMAIN="$LAUNCH_AGENT_LABEL"
 SHOW_DOCK_ICON_WAS_SET=false
 SHOW_DOCK_ICON_VALUE=""
+APP_LANGUAGE_WAS_SET=false
+APP_LANGUAGE_VALUE=""
 FULLSCREEN_QA_PID=""
 CLICK_TOOL="${CLICK_TOOL:-$(command -v cliclick || true)}"
 
@@ -31,6 +33,10 @@
   if value="$(defaults read "$DEFAULTS_DOMAIN" showDockIcon 2>/dev/null)"; then
     SHOW_DOCK_ICON_WAS_SET=true
     SHOW_DOCK_ICON_VALUE="$value"
+  fi
+  if value="$(defaults read "$DEFAULTS_DOMAIN" appLanguage 2>/dev/null)"; then
+    APP_LANGUAGE_WAS_SET=true
+    APP_LANGUAGE_VALUE="$value"
   fi
 }
 
@@ -50,6 +56,12 @@
     fi
   else
     defaults delete "$DEFAULTS_DOMAIN" showDockIcon >/dev/null 2>&1 || true
+  fi
+
+  if [[ "$APP_LANGUAGE_WAS_SET" == true ]]; then
+    defaults write "$DEFAULTS_DOMAIN" appLanguage -string "$APP_LANGUAGE_VALUE"
+  else
+    defaults delete "$DEFAULTS_DOMAIN" appLanguage >/dev/null 2>&1 || true
   fi
 }
 
@@ -298,9 +310,10 @@
 
 assert_swift="$(mktemp -t taglauncher-window-assert.XXXXXX.swift)"
 coords_swift="$(mktemp -t taglauncher-window-coords.XXXXXX.swift)"
+settings_ax_swift="$(mktemp -t taglauncher-settings-ax.XXXXXX.swift)"
 screens_swift="$(mktemp -t taglauncher-screens.XXXXXX.swift)"
 fullscreen_swift="$(mktemp -t taglauncher-fullscreen-target.XXXXXX.swift)"
-trap 'cleanup; rm -f "$assert_swift" "$coords_swift" "$screens_swift" "$fullscreen_swift" "$LAUNCH_AGENT_BACKUP"' EXIT
+trap 'cleanup; rm -f "$assert_swift" "$coords_swift" "$settings_ax_swift" "$screens_swift" "$fullscreen_swift" "$LAUNCH_AGENT_BACKUP"' EXIT
 
 cat >"$assert_swift" <<'SWIFT'
 import AppKit
@@ -368,6 +381,39 @@
     }
 }
 
+func rect(_ window: WindowInfo) -> CGRect {
+    CGRect(
+        x: dimension(window.bounds, "X"),
+        y: dimension(window.bounds, "Y"),
+        width: dimension(window.bounds, "Width"),
+        height: dimension(window.bounds, "Height")
+    )
+}
+
+func isOverlayWindow(_ window: WindowInfo) -> Bool {
+    guard window.name.isEmpty else { return false }
+    let windowFrame = rect(window)
+    return NSScreen.screens.contains { screen in
+        let screenFrame = screen.frame
+        return abs(windowFrame.width - screenFrame.width) <= 12
+            && windowFrame.height >= screenFrame.height * 0.75
+            && abs(windowFrame.midX - screenFrame.midX) <= 12
+    }
+}
+
+func isQuickSearchWindow(_ window: WindowInfo) -> Bool {
+    guard window.name.isEmpty, !isOverlayWindow(window) else { return false }
+    let windowFrame = rect(window)
+    return windowFrame.width >= 500
+        && windowFrame.width <= 900
+        && windowFrame.height >= 120
+        && windowFrame.height <= 850
+}
+
+func isSettingsLikeWindow(_ window: WindowInfo) -> Bool {
+    !window.name.isEmpty
+}
+
 func assertTagLayer(_ tag: [WindowInfo]) {
     for window in tag where window.layer != 23 {
         fail("TagLauncher window has unexpected layer \(window.layer); expected 23")
@@ -382,16 +428,32 @@
 case "overlay":
     guard tag.count == 1 else { fail("overlay expected 1 TagLauncher window, got \(tag.count)") }
     assertTagLayer(tag)
+    guard isOverlayWindow(tag[0]) else { fail("overlay window was not full-screen sized: \(tag[0].bounds)") }
     let menubarLayer = windows.first { $0.owner == "Window Server" && $0.name == "Menubar" }?.layer
     guard menubarLayer == 24 else { fail("menubar layer expected 24, got \(String(describing: menubarLayer))") }
     let dockWindows = windows.filter { $0.owner == "Dock" }
     guard dockWindows.isEmpty else { fail("Dock should be hidden while overlay is visible; found \(dockWindows.count) Dock windows") }
     print("PASS overlay: tagLayer=\(tag[0].layer) menubarLayer=24 dockWindows=0")
 
+case "quick-search":
+    guard tag.count == 2 else { fail("quick search expected overlay plus panel, got \(tag.count)") }
+    assertTagLayer(tag)
+    let overlays = tag.filter(isOverlayWindow)
+    let quickSearch = tag.filter(isQuickSearchWindow)
+    guard overlays.count == 1, quickSearch.count == 1 else {
+        fail("quick search stack wrong: names=\(tag.map(\.name)) bounds=\(tag.map(\.bounds))")
+    }
+    print("PASS quick search stack: tagLayers=\(tag.map(\.layer))")
+
 case "settings":
     guard tag.count == 2 else { fail("settings expected 2 TagLauncher windows, got \(tag.count)") }
     assertTagLayer(tag)
-    guard !tag[0].name.isEmpty, tag[1].name.isEmpty else {
+    let overlays = tag.filter(isOverlayWindow)
+    let settings = tag.filter(isSettingsLikeWindow)
+    guard overlays.count == 1, settings.count == 1 else {
+        fail("settings stack wrong: names=\(tag.map(\.name)) bounds=\(tag.map(\.bounds))")
+    }
+    guard !tag[0].name.isEmpty else {
         fail("settings order wrong: \(tag.map(\.name))")
     }
     print("PASS settings over overlay: order=\(tag.map(\.name))")
@@ -438,26 +500,33 @@
     print("PASS fullscreen target: layer=\(target.layer) bounds=\(target.bounds)")
 
 case "fullscreen-overlay":
-    guard tag.count == 1 else { fail("fullscreen overlay expected 1 TagLauncher window, got \(tag.count)") }
+    guard tag.count == 1 || tag.count == 2 else { fail("fullscreen overlay expected 1 or 2 TagLauncher windows, got \(tag.count)") }
     assertTagLayer(tag)
     guard let target = windows.first(where: { $0.name == "TagLauncherFullscreenQATargetFullscreen" }) else {
         fail("fullscreen target disappeared; TagLauncher likely switched to another Space")
     }
-    let overlayWidth = dimension(tag[0].bounds, "Width")
-    let overlayHeight = dimension(tag[0].bounds, "Height")
-    let overlayMidX = dimension(tag[0].bounds, "X") + overlayWidth / 2
+    guard let overlay = tag.first(where: isOverlayWindow) else {
+        fail("fullscreen overlay TagLauncher window not found: \(tag.map(\.bounds))")
+    }
+    let quickSearch = tag.filter(isQuickSearchWindow)
+    guard quickSearch.count == tag.count - 1 else {
+        fail("fullscreen overlay stack has unexpected windows: \(tag.map(\.bounds))")
+    }
+    let overlayWidth = dimension(overlay.bounds, "Width")
+    let overlayHeight = dimension(overlay.bounds, "Height")
+    let overlayMidX = dimension(overlay.bounds, "X") + overlayWidth / 2
     let targetWidth = dimension(target.bounds, "Width")
     let targetHeight = dimension(target.bounds, "Height")
     let targetMidX = dimension(target.bounds, "X") + targetWidth / 2
     guard abs(overlayWidth - targetWidth) <= 12,
           overlayHeight >= targetHeight * 0.88,
           abs(overlayMidX - targetMidX) <= 12 else {
-        fail("fullscreen overlay is not on the target fullscreen display: overlay=\(tag[0].bounds) target=\(target.bounds)")
+        fail("fullscreen overlay is not on the target fullscreen display: overlay=\(overlay.bounds) target=\(target.bounds)")
     }
-    guard tag[0].layer > target.layer else {
-        fail("TagLauncher layer \(tag[0].layer) is not above fullscreen target layer \(target.layer)")
+    guard tag.allSatisfy({ $0.layer > target.layer }) else {
+        fail("TagLauncher stack is not above fullscreen target")
     }
-    print("PASS fullscreen overlay above target: overlayLayer=\(tag[0].layer) targetLayer=\(target.layer)")
+    print("PASS fullscreen overlay above target: tagLayers=\(tag.map(\.layer)) targetLayer=\(target.layer)")
 
 case "fullscreen-settings":
     guard tag.count == 2 else { fail("fullscreen settings expected 2 TagLauncher windows, got \(tag.count)") }
@@ -465,7 +534,12 @@
     guard let target = windows.first(where: { $0.name == "TagLauncherFullscreenQATargetFullscreen" }) else {
         fail("fullscreen target disappeared after opening settings; TagLauncher likely switched to another Space")
     }
-    guard !tag[0].name.isEmpty, tag[1].name.isEmpty else {
+    let overlays = tag.filter(isOverlayWindow)
+    let settings = tag.filter(isSettingsLikeWindow)
+    guard overlays.count == 1, settings.count == 1 else {
+        fail("fullscreen settings stack wrong: names=\(tag.map(\.name)) bounds=\(tag.map(\.bounds))")
+    }
+    guard !tag[0].name.isEmpty else {
         fail("fullscreen settings order wrong: \(tag.map(\.name))")
     }
     guard tag.allSatisfy({ $0.layer > target.layer }) else {
@@ -621,6 +695,23 @@
     let overlayX = dimension(overlayBounds, "X")
     let overlayY = dimension(overlayBounds, "Y")
     print("\(Int(round(overlayX + 120))) \(Int(round(overlayY + 160)))")
+case "overlay-center":
+    guard let overlay = tag.max(by: { lhs, rhs in
+        let lhsBounds = lhs[kCGWindowBounds as String] as? NSDictionary ?? [:]
+        let rhsBounds = rhs[kCGWindowBounds as String] as? NSDictionary ?? [:]
+        let lhsArea = dimension(lhsBounds, "Width") * dimension(lhsBounds, "Height")
+        let rhsArea = dimension(rhsBounds, "Width") * dimension(rhsBounds, "Height")
+        return lhsArea < rhsArea
+    }), let overlayBounds = overlay[kCGWindowBounds as String] as? NSDictionary else {
+        let screen = NSScreen.screens.first?.frame ?? CGRect(x: 0, y: 0, width: 1200, height: 800)
+        print("\(Int(round(screen.midX))) \(Int(round(screen.midY)))")
+        exit(0)
+    }
+    let overlayX = dimension(overlayBounds, "X")
+    let overlayY = dimension(overlayBounds, "Y")
+    let overlayWidth = dimension(overlayBounds, "Width")
+    let overlayHeight = dimension(overlayBounds, "Height")
+    print("\(Int(round(overlayX + overlayWidth / 2))) \(Int(round(overlayY + overlayHeight / 2)))")
 case "fullscreen-target-center":
     guard let target = raw.first(where: { ($0[kCGWindowName as String] as? String) == "TagLauncherFullscreenQATargetFullscreen" }),
           let bounds = target[kCGWindowBounds as String] as? NSDictionary else {
@@ -634,6 +725,111 @@
     print("\(Int(round(x + width / 2))) \(Int(round(y + height / 2)))")
 default:
     fputs("FAIL: unknown coords mode \(mode)\n", stderr)
+    exit(1)
+}
+SWIFT
+
+cat >"$settings_ax_swift" <<'SWIFT'
+import AppKit
+import ApplicationServices
+import Foundation
+
+let mode = CommandLine.arguments.dropFirst().first ?? ""
+let bundleID = "com.taglauncher.app"
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: bundleID).first else {
+    fputs("FAIL: TagLauncher is not running\n", stderr)
+    exit(1)
+}
+
+let root = AXUIElementCreateApplication(app.processIdentifier)
+
+func copyAttribute(_ element: AXUIElement, _ attribute: CFString) -> CFTypeRef? {
+    var value: CFTypeRef?
+    let result = AXUIElementCopyAttributeValue(element, attribute, &value)
+    guard result == .success else { return nil }
+    return value
+}
+
+func stringAttribute(_ element: AXUIElement, _ attribute: CFString) -> String? {
+    copyAttribute(element, attribute) as? String
+}
+
+func titleCandidates(for element: AXUIElement) -> [String] {
+    [
+        stringAttribute(element, kAXTitleAttribute as CFString),
+        stringAttribute(element, kAXDescriptionAttribute as CFString),
+        stringAttribute(element, kAXValueAttribute as CFString),
+        stringAttribute(element, kAXHelpAttribute as CFString)
+    ].compactMap { $0 }.filter { !$0.isEmpty }
+}
+
+func children(of element: AXUIElement) -> [AXUIElement] {
+    if let values = copyAttribute(element, kAXChildrenAttribute as CFString) as? [AXUIElement] {
+        return values
+    }
+    return []
+}
+
+func matches(_ element: AXUIElement, candidates: [String]) -> Bool {
+    let role = stringAttribute(element, kAXRoleAttribute as CFString) ?? ""
+    let titles = titleCandidates(for: element)
+    guard !titles.isEmpty else { return false }
+    let interactiveRole = role == kAXButtonRole as String
+        || role == kAXRadioButtonRole as String
+        || role == kAXTabGroupRole as String
+        || role == kAXMenuItemRole as String
+    guard interactiveRole else { return false }
+    return titles.contains { title in
+        candidates.contains { candidate in
+            title == candidate || title.localizedCaseInsensitiveContains(candidate)
+        }
+    }
+}
+
+func findMatchingElement(
+    _ element: AXUIElement,
+    candidates: [String],
+    depth: Int,
+    visited: inout Set<CFHashCode>
+) -> AXUIElement? {
+    guard depth >= 0 else { return nil }
+    let hash = CFHash(element)
+    guard !visited.contains(hash) else { return nil }
+    visited.insert(hash)
+
+    if matches(element, candidates: candidates) {
+        return element
+    }
+
+    for child in children(of: element) {
+        if let match = findMatchingElement(child, candidates: candidates, depth: depth - 1, visited: &visited) {
+            return match
+        }
+    }
+    return nil
+}
+
+let candidates: [String]
+switch mode {
+case "data-tab":
+    candidates = ["Data"]
+case "export":
+    candidates = ["Export"]
+default:
+    fputs("FAIL: unknown settings action \(mode)\n", stderr)
+    exit(1)
+}
+
+var visited = Set<CFHashCode>()
+guard let element = findMatchingElement(root, candidates: candidates, depth: 12, visited: &visited) else {
+    fputs("FAIL: could not find settings control for \(mode)\n", stderr)
+    exit(1)
+}
+
+let result = AXUIElementPerformAction(element, kAXPressAction as CFString)
+guard result == .success else {
+    fputs("FAIL: could not press settings control for \(mode): \(result.rawValue)\n", stderr)
     exit(1)
 }
 SWIFT
@@ -760,11 +956,41 @@
   click_xy "$x" "$y"
 }
 
+click_settings_control() {
+  local mode="$1"
+  if swift "$settings_ax_swift" "$mode" >/dev/null 2>&1; then
+    return 0
+  fi
+  click_relative_to_settings "$mode"
+}
+
 click_overlay_outside_quick_search() {
   local coords
   coords="$(swift "$coords_swift" overlay-outside)"
   read -r x y <<<"$coords"
   click_xy "$x" "$y"
+}
+
+page_scroll_appgrid() {
+  local coords
+  coords="$(swift "$coords_swift" overlay-center)"
+  read -r x y <<<"$coords"
+  move_xy "$x" "$y"
+  sleep 0.15
+  swift - <<'SWIFT'
+import CoreGraphics
+if let event = CGEvent(
+    scrollWheelEvent2Source: nil,
+    units: .pixel,
+    wheelCount: 1,
+    wheel1: -900,
+    wheel2: 0,
+    wheel3: 0
+) {
+    event.post(tap: .cghidEventTap)
+}
+SWIFT
+  sleep 0.25
 }
 
 kill_fullscreen_qa_target() {
@@ -810,6 +1036,7 @@
 
 log "==> Preparing QA defaults"
 defaults write "$DEFAULTS_DOMAIN" showDockIcon -bool true
+defaults write "$DEFAULTS_DOMAIN" appLanguage -string en
 reset_dock_for_qa
 
 log "==> Starting clean app instance"
@@ -892,9 +1119,9 @@
 swift_assert settings
 
 log "==> QA 2/7: import/export file panel floats above settings"
-click_relative_to_settings data-tab
+click_settings_control data-tab
 sleep 0.3
-click_relative_to_settings export
+click_settings_control export
 sleep 0.7
 swift_assert file-panel
 send_keycode 53
@@ -912,6 +1139,22 @@
 swift_assert overlay
 send_keycode 53
 sleep 0.4
+swift_assert no-overlay
+
+log "==> QA 4/7: appgrid scroll keeps Space and Esc keyboard routing"
+show_overlay
+for _ in {1..5}; do
+  page_scroll_appgrid
+  send_keycode 49
+  sleep 0.35
+  swift_assert quick-search
+  send_keycode 53
+  sleep 0.25
+  swift_assert overlay
+done
+page_scroll_appgrid
+send_keycode 53
+sleep 0.35
 swift_assert no-overlay
 
 log "==> QA 5/7: clicking outside quick search closes search, not appgrid"
@@ -965,8 +1208,9 @@
 SWIFT
   done < <(swift "$screens_swift")
 else
-  rg -Fq 'screenContainingCurrentPointer() ??' "$ROOT_DIR/Apptag/ApptagApp.swift"
-  rg -Fq 'NSMouseInRect(mousePoint, $0.frame, false)' "$ROOT_DIR/Apptag/ApptagApp.swift"
+  rg -Fq 'statusMenuScreenForNextOverlay = overlayController.screenContainingCurrentPointer()' "$ROOT_DIR/Apptag/ApptagApp.swift"
+  rg -Fq 'screenContainingCurrentPointer() ??' "$ROOT_DIR/Apptag/OverlayWindowController.swift"
+  rg -Fq 'NSMouseInRect(mousePoint, $0.frame, false)' "$ROOT_DIR/Apptag/OverlayWindowController.swift"
   log "PASS screen-following static path: single physical display here; code selects NSScreen under current pointer"
 fi
 

--
Gitblit v1.9.3