feat(gesture): 将关闭窗口手势从长按捏合改为上滑 1 秒

jiangzhibin · jiangzhibin · commit 46646f04514b · 2026-01-28T16:44:29.000+08:00
变更内容:
- 关闭窗口触发机制从"长按捏合"改为"上滑持续"
- 时间阈值从 2.0 秒缩短为 1.0 秒
- 添加与"恢复最小化窗口"的冲突处理逻辑

修复与优化:
- 修复 HUD 浮层干扰窗口检测导致的抖动问题
- 添加 Chrome 视觉全屏检测（解决演示模式不设置 AXFullScreen 的问题）
- 优化 isInTitleBarArea 方法，减少重复窗口查询

其他:
- 更新 README 文档和 HUD 反馈图标/文字
- 添加 xcuserstate 到 .gitignore
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,6 @@
 /.npm-cache/
 /.idea/
 /.claude/
+
+# Xcode user-specific files
+*.xcuserstate
diff --git a/README.md b/README.md
@@ -25,7 +25,7 @@
 > 建议录制以下场景：
 > - 双指张开手势 → 窗口全屏
 > - 双指捏合手势 → 窗口还原（全屏时）
-> - 长按捏合 2秒 → 关闭窗口（非全屏时，带环形进度条）
+> - 上滑 1秒 → 关闭窗口（非全屏时，带环形进度条）
 > - 双指下滑手势 → 窗口最小化
 > - 双指上滑手势 → 恢复最小化窗口
 
@@ -48,18 +48,18 @@ SwishMini 为 macOS 带来直观的触控板手势控制，让窗口管理更加
 |------|------|------|
 | 👐 **双指张开** | 全屏 | 将当前窗口切换至全屏模式 |
 | 🤏 **双指捏合** | 还原 | 全屏时退出全屏 |
-| 🤏 **长按捏合 2秒** | 关闭窗口 | 非全屏时长按捏合关闭当前窗口 |
+| 👆 **上滑 1秒** | 关闭窗口 | 非全屏时上滑 1 秒关闭当前窗口 |
 | 👇 **双指下滑** | 最小化 | 最小化当前窗口到 Dock |
 | 👆 **双指上滑** | 取消最小化 | 在原位置恢复最小化的窗口 |
 
 ### 🎯 HUD 视觉反馈
 
 执行手势时，屏幕会显示实时视觉反馈：
 
-- **环形进度条**：长按关闭窗口时显示倒计时进度环
+- **环形进度条**：上滑关闭窗口时显示倒计时进度环
 - **颜色渐变**：从橙色平滑过渡到红色，表示紧迫程度
 - **进度百分比**：实时显示当前进度（如 50%、75%）
-- **取消提示**：松手或张开手指时显示"已取消"
+- **取消提示**：松手或收回手指时显示"已取消"
 
 ### 🌐 特别支持
 
@@ -324,7 +324,7 @@ Made with ❤️ by 江志彬
 > Suggested scenarios to record:
 > - Two-finger pinch open → Window goes fullscreen
 > - Two-finger pinch close → Window restores (when fullscreen)
-> - Long press pinch 2s → Close window (when not fullscreen, with progress ring)
+> - Swipe up 1s → Close window (when not fullscreen, with progress ring)
 > - Two-finger swipe down → Window minimizes
 > - Two-finger swipe up → Restore minimized window
 
@@ -347,18 +347,18 @@ SwishMini brings intuitive trackpad gesture control to macOS, making window mana
 |---------|--------|-------------|
 | 👐 **Two-Finger Pinch Open** | Fullscreen | Switch current window to fullscreen mode |
 | 🤏 **Two-Finger Pinch Close** | Restore | Exit fullscreen (when in fullscreen) |
-| 🤏 **Long Press Pinch 2s** | Close Window | Close current window (when not fullscreen) |
+| 👆 **Swipe Up 1s** | Close Window | Close current window (when not fullscreen) |
 | 👇 **Two-Finger Swipe Down** | Minimize | Minimize current window to Dock |
 | 👆 **Two-Finger Swipe Up** | Unminimize | Restore minimized window at original location |
 
 ### 🎯 HUD Visual Feedback
 
 Real-time visual feedback is displayed when performing gestures:
 
-- **Progress Ring**: Shows countdown progress when long-pressing to close window
+- **Progress Ring**: Shows countdown progress when swiping up to close window
 - **Color Gradient**: Smoothly transitions from orange to red, indicating urgency
 - **Progress Percentage**: Displays current progress in real-time (e.g., 50%, 75%)
-- **Cancel Indicator**: Shows "Cancelled" when releasing or spreading fingers
+- **Cancel Indicator**: Shows "Cancelled" when releasing or retracting fingers
 
 ### 🌐 Special Support
 
diff --git a/SwishMini/GestureFeedback.swift b/SwishMini/GestureFeedback.swift
@@ -32,9 +32,9 @@ enum GestureCandidate: Equatable {
     case pinchOpen
     /// 双指捏合 -> 还原（全屏时退出全屏）
     case pinchClose
-    /// 非全屏 + 长按捏合 -> 关闭窗口
+    /// 非全屏 + 上滑持续 1 秒 -> 关闭窗口
     case closeWindow
-    /// 已取消（未完成长按捏合就松手/张开手指）
+    /// 已取消（上滑关闭未完成就松手）
     case cancelled
     /// 双指下滑 -> 最小化
     case swipeDown
@@ -47,7 +47,7 @@ enum GestureCandidate: Equatable {
         case .none:        return "macwindow"
         case .pinchOpen:   return "arrow.up.left.and.arrow.down.right"
         case .pinchClose:  return "arrow.down.right.and.arrow.up.left"
-        case .closeWindow: return "xmark.circle"
+        case .closeWindow: return "arrow.up.circle.fill"  // 上滑关闭
         case .cancelled:   return "xmark.circle"
         case .swipeDown:   return "arrow.down.circle"
         case .swipeUp:     return "arrow.up.circle"
@@ -60,7 +60,7 @@ enum GestureCandidate: Equatable {
         case .none:        return "标题栏区域"
         case .pinchOpen:   return "双指张开"
         case .pinchClose:  return "双指捏合"
-        case .closeWindow: return "长按捏合"
+        case .closeWindow: return "上滑关闭"
         case .cancelled:   return "已取消"
         case .swipeDown:   return "双指下滑"
         case .swipeUp:     return "双指上滑"
diff --git a/SwishMini/PinchGestureDetector.swift b/SwishMini/PinchGestureDetector.swift
@@ -40,9 +40,9 @@ class PinchGestureDetector {
     private var gestureStartY: Float = 0
     private var previousY: Float = 0
 
-    // 非全屏捏合关闭窗口的持续时间阈值（秒）
-    private let nonFullScreenPinchCloseHoldThreshold: TimeInterval = 2.0
-    
+    // 非全屏上滑关闭窗口的持续时间阈值（秒）
+    private let nonFullScreenSwipeUpCloseThreshold: TimeInterval = 1.0
+
     // 框架引用
     private var frameworkHandle: UnsafeMutableRawPointer?
     private var deviceList: [UnsafeMutableRawPointer] = []
@@ -202,6 +202,11 @@ class PinchGestureDetector {
                 let denom = max(CGFloat(swipeDownThreshold), 0.0001)
                 return (.swipeDown, min(absY / denom, 1))
             } else {
+                // 上滑：非全屏时显示"关闭窗口"提示（使用时间进度驱动 HUD 动画）
+                if !isWindowFullScreen {
+                    let holdProgress = min(gestureDuration / nonFullScreenSwipeUpCloseThreshold, 1)
+                    return (.closeWindow, holdProgress)
+                }
                 let denom = max(CGFloat(swipeUpThreshold), 0.0001)
                 return (.swipeUp, min(absY / denom, 1))
             }
@@ -212,11 +217,6 @@ class PinchGestureDetector {
                 let denom = max(CGFloat(pinchOpenThreshold) - 1.0, 0.0001)
                 return (.pinchOpen, min((scale - 1.0) / denom, 1))
             } else {
-                // 捏合：非全屏时显示"关闭窗口"提示（使用时间进度驱动 HUD 动画）
-                if !isWindowFullScreen {
-                    let holdProgress = min(gestureDuration / nonFullScreenPinchCloseHoldThreshold, 1)
-                    return (.closeWindow, holdProgress)
-                }
                 let denom = max(1.0 - CGFloat(pinchCloseThreshold), 0.0001)
                 return (.pinchClose, min((1.0 - scale) / denom, 1))
             }
@@ -240,7 +240,7 @@ class PinchGestureDetector {
         let windowFrame = windowInfo?.frame
         let isWindowFullScreen = windowInfo.map { WindowManager.shared.isWindowFullScreen($0.window) } ?? false
 
-        let classified: (candidate: GestureCandidate, progress: CGFloat)
+        var classified: (candidate: GestureCandidate, progress: CGFloat)
         if let override = override {
             classified = override
         } else {
@@ -253,6 +253,19 @@ class PinchGestureDetector {
             )
         }
 
+        // 修正：如果有可恢复的最小化窗口且鼠标在恢复热点附近，
+        // 上滑应优先显示为"取消最小化"，避免 HUD 错误地显示"关闭窗口"进度环
+        if classified.candidate == .closeWindow, let record = lastMinimizedWindow {
+            let dx = mouseLocation.x - record.location.x
+            let dy = mouseLocation.y - record.location.y
+            let distance = sqrt(dx * dx + dy * dy)
+            if distance <= restoreProximityThreshold {
+                let absY = abs(yDelta)
+                let denom = max(CGFloat(swipeUpThreshold), 0.0001)
+                classified = (.swipeUp, min(absY / denom, 1))
+            }
+        }
+
         // 记录：一旦进入"关闭窗口"提示状态
         if (phase == .began || phase == .changed), classified.candidate == .closeWindow {
             didEnterCloseWindowHint = true
@@ -442,11 +455,13 @@ class PinchGestureDetector {
         let willPinchOpen = hasValidWindow && isPinchGestureDominant && finalScale > pinchOpenThreshold
         let willPinchClose = hasValidWindow && isPinchGestureDominant && finalScale < pinchCloseThreshold
 
-        // 预判是否会执行关闭窗口操作（非全屏 + 捏合 + 达到阈值 + 持续时间足够 + 有效窗口）
+        // 预判是否会执行关闭窗口操作（非全屏 + 上滑主导 + 达到阈值 + 持续时间足够 + 有效窗口）
         let willCloseWindow = hasValidWindow &&
                               !isWindowFullScreen &&
-                              willPinchClose &&
-                              gestureDuration >= nonFullScreenPinchCloseHoldThreshold
+                              isSwipeGestureDominant &&
+                              totalYDelta > swipeUpThreshold &&
+                              gestureDuration >= nonFullScreenSwipeUpCloseThreshold &&
+                              !willSwipeUp  // 若命中"恢复最小化"则不应关闭窗口
 
         // 预判是否会执行全屏还原操作（全屏 + 捏合）
         let willRestoreFromFullScreen = hasValidWindow && isWindowFullScreen && willPinchClose
@@ -529,7 +544,10 @@ class PinchGestureDetector {
 
         switch gesture {
         case .swipeUp:
-            // 双指上滑 -> 取消最小化
+            // 双指上滑：
+            // 1. 优先恢复最小化窗口（如果有记录且在原位置附近）
+            // 2. 否则，非全屏 + 持续 >= 1 秒：关闭窗口
+            // 3. 全屏时：无动作（或后续扩展为其他功能）
             if let record = lastMinimizedWindow {
                 // 检查是否在原来的位置附近
                 let dx = mouseLocation.x - record.location.x
@@ -540,11 +558,22 @@ class PinchGestureDetector {
                     print("✅ [Action] 在原位置附近上滑，恢复窗口 (距离: \(String(format: "%.0f", distance))px)")
                     WindowManager.shared.unminimizeWindow(record.windowElement)
                     lastMinimizedWindow = nil  // 清除记录
-                } else {
-                    print("⚠️ [Action] 上滑位置距离历史位置过远 (\(String(format: "%.0f", distance))px > \(restoreProximityThreshold)px)")
+                    return
                 }
+                print("⚠️ [Action] 上滑位置距离历史位置过远 (\(String(format: "%.0f", distance))px > \(restoreProximityThreshold)px)")
+            }
+
+            // 未触发恢复（可能没有记录，或不在恢复热点），检查是否应该关闭窗口
+            guard let (window, _) = WindowManager.shared.getWindowUnderMouse(mouseLocation) else {
+                print("⚠️ [Action] 无法获取当前窗口")
+                return
+            }
+
+            if !WindowManager.shared.isWindowFullScreen(window) && gestureDuration >= nonFullScreenSwipeUpCloseThreshold {
+                print("❌ [Action] 非全屏 + 长上滑(\(String(format: "%.1f", gestureDuration))s >= \(nonFullScreenSwipeUpCloseThreshold)s)，关闭窗口")
+                WindowManager.shared.closeWindow(window)
             } else {
-                print("⚠️ [Action] 没有记录的最小化窗口")
+                print("ℹ️ [Action] 上滑但不满足关闭条件")
             }
             return
 
@@ -566,16 +595,12 @@ class PinchGestureDetector {
         case .pinchClose:
             // 双指捏合：
             // - 全屏状态：退出全屏
-            // - 非全屏 + 持续>=2秒：关闭窗口
-            // - 非全屏 + 持续<2秒：无动作
+            // - 非全屏：无动作
             if WindowManager.shared.isWindowFullScreen(window) {
                 print("🔄 [Action] 全屏状态，退出全屏")
                 WindowManager.shared.restoreWindow(window)
-            } else if gestureDuration >= nonFullScreenPinchCloseHoldThreshold {
-                print("❌ [Action] 非全屏 + 长捏合(\(String(format: "%.1f", gestureDuration))s >= \(nonFullScreenPinchCloseHoldThreshold)s)，关闭窗口")
-                WindowManager.shared.closeWindow(window)
             } else {
-                print("ℹ️ [Action] 非全屏 + 短捏合(\(String(format: "%.1f", gestureDuration))s < \(nonFullScreenPinchCloseHoldThreshold)s)，无动作")
+                print("ℹ️ [Action] 非全屏状态，捏合无动作")
             }
 
         case .swipeDown:
diff --git a/SwishMini/WindowManager.swift b/SwishMini/WindowManager.swift
@@ -22,16 +22,20 @@ class WindowManager {
         guard let mainScreen = NSScreen.screens.first else { return nil }
         let mainScreenHeight = mainScreen.frame.height
         let screenPoint = CGPoint(x: mouseLocation.x, y: mainScreenHeight - mouseLocation.y)
-        
+
+        // 排除自身进程的窗口（如 HUD 浮层），防止 HUD 干扰窗口检测导致抖动
+        let selfPID = getpid()
+
         guard let windowList = CGWindowListCopyWindowInfo([.optionOnScreenOnly, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
             return nil
         }
-        
+
         for windowInfo in windowList {
             guard let boundsDict = windowInfo[kCGWindowBounds as String] as? [String: CGFloat],
                   let ownerPID = windowInfo[kCGWindowOwnerPID as String] as? pid_t,
                   let layer = windowInfo[kCGWindowLayer as String] as? Int,
-                  layer >= 0 && layer < 25 else {
+                  layer >= 0 && layer < 25,
+                  ownerPID != selfPID else {  // 忽略 SwishMini 自身的窗口
                 continue
             }
             
@@ -67,17 +71,20 @@ class WindowManager {
         guard let mainScreen = NSScreen.screens.first else { return false }
         let screenHeight = mainScreen.frame.height
 
+        // 单次查询窗口信息，确保结果一致性
+        let windowInfo = getWindowUnderMouse(point)
+
         // 全屏检测：鼠标在屏幕顶部边缘（用于触发全屏标题栏）
         let screenTopEdge: CGFloat = 6  // 顶部 6 像素触发区域
         if point.y >= screenHeight - screenTopEdge {
             // 检查当前窗口是否全屏
-            if let (window, _) = getWindowUnderMouse(point), isWindowFullScreen(window) {
+            if let window = windowInfo?.window, isWindowFullScreen(window) {
                 return true
             }
         }
 
         // 普通窗口标题栏检测
-        guard let (_, frame) = getWindowUnderMouse(point) else {
+        guard let frame = windowInfo?.frame else {
             return false
         }
 
@@ -90,15 +97,65 @@ class WindowManager {
     }
 
     /// 检查窗口是否处于全屏状态
+    /// - Note: 对 Chrome 进行特殊处理，因为 Chrome 使用键盘快捷键进入的"演示模式"全屏
+    ///         不会设置 AXFullScreen 属性，需要通过窗口尺寸判断
     func isWindowFullScreen(_ window: AXUIElement) -> Bool {
+        // 方法1: 检查标准的 AXFullScreen 属性
         var fullScreenValue: AnyObject?
         if AXUIElementCopyAttributeValue(window, "AXFullScreen" as CFString, &fullScreenValue) == .success,
-           let isFullScreen = fullScreenValue as? Bool {
-            return isFullScreen
+           let isFullScreen = fullScreenValue as? Bool, isFullScreen {
+            return true
+        }
+
+        // 方法2: 对 Chrome 进行视觉全屏检测
+        // Chrome 使用 ⌘+Ctrl+F 进入的全屏不会设置 AXFullScreen 属性
+        if isChrome(window) {
+            return isWindowVisuallyFullScreen(window)
         }
+
         return false
     }
-    
+
+    /// 检查窗口是否"视觉上全屏"（覆盖整个屏幕，包括菜单栏区域）
+    /// - Note: 用于检测 Chrome 等不设置 AXFullScreen 属性的应用
+    private func isWindowVisuallyFullScreen(_ window: AXUIElement) -> Bool {
+        guard let windowFrame = getWindowFrame(window) else {
+            return false
+        }
+
+        // 找到窗口所在的屏幕（而非主屏幕）
+        let windowCenter = CGPoint(
+            x: windowFrame.origin.x + windowFrame.width / 2,
+            y: windowFrame.origin.y + windowFrame.height / 2
+        )
+        guard let screen = NSScreen.screens.first(where: { $0.frame.contains(windowCenter) }) ?? NSScreen.main else {
+            return false
+        }
+
+        let screenFrame = screen.frame
+
+        // 严格的全屏检测：窗口必须覆盖整个屏幕（包括菜单栏）
+        // Chrome 演示模式全屏特征：
+        // 1. 窗口 y 坐标接近 0（屏幕顶部）
+        // 2. 窗口 x 坐标接近屏幕左边界
+        // 3. 窗口宽度等于屏幕宽度
+        // 4. 窗口高度等于屏幕高度（真全屏覆盖菜单栏）
+        let tolerance: CGFloat = 2.0  // 收紧容差，减少误判
+
+        let isAtScreenOrigin = abs(windowFrame.origin.x - screenFrame.origin.x) <= tolerance &&
+                               abs(windowFrame.origin.y - screenFrame.origin.y) <= tolerance
+        let isFullWidth = abs(windowFrame.width - screenFrame.width) <= tolerance
+        let isFullHeight = abs(windowFrame.height - screenFrame.height) <= tolerance  // 必须覆盖菜单栏
+
+        let isVisuallyFullScreen = isAtScreenOrigin && isFullWidth && isFullHeight
+
+        if isVisuallyFullScreen {
+            print("🔍 [WindowManager] Chrome 视觉全屏检测: 窗口覆盖整个屏幕 (screen: \(screenFrame), window: \(windowFrame))")
+        }
+
+        return isVisuallyFullScreen
+    }
+
     // MARK: - 窗口信息
     
     private func getWindowFrame(_ window: AXUIElement) -> CGRect? {
