Merge branch 'main' into remove-analytics-manager-shim-2519353167747654180

Author: NullPointerDepressiveDisorder

.github/workflows/objective-c-xcode.yml

@@ -4,12 +4,25 @@ permissions:
 
 on:
   push:
-    branches: [main]
+    branches: 
+      - '**'
   pull_request:
-    branches: [main]
+    branches:
+      - '**'
 
 jobs:
+
+  pre_job:
+    runs-on: ubuntu-latest
+    outputs:
+      should_skip: ${{ steps.skip_check.outputs.should_skip }}
+    steps:
+      - id: skip_check
+        uses: fkirc/skip-duplicate-actions@master
+
   build:
+    needs: pre_job
+    if: ${{ needs.pre_job.outputs.should_skip != 'true' }}
     name: Build MiddleDrag
     runs-on: macos-15
 

.gitignore

@@ -20,3 +20,4 @@ xcuserdata/
 *.ipa
 *.dSYM.zip
 *.dSYM
+.vscode/settings.json

MiddleDrag/Core/GestureRecognizer.swift

@@ -1,67 +1,95 @@
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// Manages gesture recognition from touch input
 class GestureRecognizer {
-    
+
     // MARK: - Properties
-    
+
     /// Configuration for gesture detection
     var configuration = GestureConfiguration()
-    
+
     /// Current gesture state
     private(set) var state: GestureState = .idle
-    
+
     /// Delegate for gesture events
     weak var delegate: GestureRecognizerDelegate?
-    
+
     // Position tracking
     private var lastFingerPositions: [MTPoint] = []
     private var gestureStartTime: Double = 0
     private var gestureStartPosition: MTPoint?
     private var lastCentroid: MTPoint?
     private var frameCount: Int = 0
-    
+
     // Stability tracking - prevents false gesture ends during brief state transitions
     private var stableFrameCount: Int = 0
-    
+
+    // Cooldown after 4-finger cancellation
+    // Prevents accidental gesture triggers when lifting one finger during Mission Control
+    private var isInCancellationCooldown: Bool = false
+
     // MARK: - Public Interface
-    
+
     /// Process new touch data from the multitouch device
     /// - Parameters:
     ///   - touches: Raw pointer to touch data array
     ///   - count: Number of touches in the array
     ///   - timestamp: Timestamp of the touch frame
     func processTouches(_ touches: UnsafeMutableRawPointer, count: Int, timestamp: Double) {
         let touchArray = touches.bindMemory(to: MTTouch.self, capacity: count)
-        
+
         // Collect only valid touching fingers (state 3 = touching down, state 4 = active)
         // Skip state 5 (lifting), 6 (lingering), 7 (gone)
         var validFingers: [MTPoint] = []
-        
+
         for i in 0..<count {
             let touch = touchArray[i]
             if touch.state == 3 || touch.state == 4 {
                 validFingers.append(touch.normalizedVector.position)
             }
         }
-        
+
         let fingerCount = validFingers.count
-        
-        if fingerCount >= 3 {
+
+        // ALWAYS cancel on 4+ fingers regardless of configuration
+        // This ensures Mission Control and other system gestures always work
+        if fingerCount >= 4 {
+            if state != .idle {
+                handleGestureCancel()
+            }
+            // Enter cooldown to prevent restart when finger is briefly lifted
+            isInCancellationCooldown = true
+            return
+        }
+
+        // Clear cooldown when finger count drops to 0-2,
+        // or when finger count is 3 and we're idle (so user can start a new gesture)
+        if fingerCount <= 2 || (fingerCount == 3 && state == .idle) {
+            isInCancellationCooldown = false
+        }
+
+        // Process exactly 3-finger gestures only
+        // 4+ fingers are cancelled above, 0-2 fingers end the gesture below
+        // Note: requiresExactlyThreeFingers no longer has an effect since we always
+        // require exactly 3 to preserve Mission Control - could be deprecated
+        let isValidThreeFingerGesture = !isInCancellationCooldown && fingerCount == 3
+
+        if isValidThreeFingerGesture {
             handleThreeFingerGesture(fingers: validFingers, timestamp: timestamp)
         } else if state != .idle {
-            // Only end gesture if we've been below 3 fingers for multiple frames
-            // This prevents ending during brief state transitions
+            // Gesture state changed - finger count dropped below 3
+            // (4+ fingers case is handled by cancellation above before we get here)
+            // Use stable frame count to prevent false ends during brief transitions
             stableFrameCount += 1
             if stableFrameCount >= 2 {
                 handleGestureEnd(timestamp: timestamp)
             }
         }
-        
+
         frameCount += 1
     }
-    
+
     /// Reset gesture recognition state
     func reset() {
         state = .idle
@@ -71,15 +99,16 @@ class GestureRecognizer {
         gestureStartTime = 0
         frameCount = 0
         stableFrameCount = 0
+        isInCancellationCooldown = false  // Clear cooldown on reset
     }
-    
+
     // MARK: - Private Methods
-    
+
     private func handleThreeFingerGesture(fingers: [MTPoint], timestamp: Double) {
         stableFrameCount = 0  // Reset since we have 3 fingers
-        
+
         let centroid = calculateCentroid(fingers: fingers)
-        
+
         // Check for large centroid jumps (finger added/removed causing position shift)
         if let last = lastCentroid {
             let jump = centroid.distance(to: last)
@@ -90,7 +119,7 @@ class GestureRecognizer {
                 return
             }
         }
-        
+
         switch state {
         case .idle:
             // Start new gesture
@@ -100,27 +129,27 @@ class GestureRecognizer {
             lastCentroid = centroid
             lastFingerPositions = fingers
             delegate?.gestureRecognizerDidStart(self, at: centroid)
-            
+
         case .possibleTap:
             // Check if we should transition to drag
             guard let startPos = gestureStartPosition else { return }
             let movement = startPos.distance(to: centroid)
             let elapsed = timestamp - gestureStartTime
-            
+
             if movement > configuration.moveThreshold || elapsed > configuration.tapThreshold {
                 state = .dragging
                 lastCentroid = centroid
                 delegate?.gestureRecognizerDidBeginDragging(self)
             } else {
                 lastCentroid = centroid
             }
-            
+
         case .dragging:
             // Calculate delta from last frame
             if let last = lastCentroid {
                 let deltaX = centroid.x - last.x
                 let deltaY = centroid.y - last.y
-                
+
                 // Only process small deltas (real movement, not jumps)
                 if abs(deltaX) < 0.03 && abs(deltaY) < 0.03 {
                     if abs(deltaX) > 0.0001 || abs(deltaY) > 0.0001 {
@@ -137,17 +166,17 @@ class GestureRecognizer {
                 }
             }
             lastCentroid = centroid
-            
+
         case .waitingForRelease:
             break
         }
-        
+
         lastFingerPositions = fingers
     }
-    
+
     private func handleGestureEnd(timestamp: Double) {
         let elapsed = timestamp - gestureStartTime
-        
+
         switch state {
         case .possibleTap:
             if elapsed < configuration.tapThreshold {
@@ -158,10 +187,26 @@ class GestureRecognizer {
         default:
             break
         }
-        
+
+        reset()
+    }
+
+    /// Cancel gesture without completing it (e.g., when 4th finger detected)
+    private func handleGestureCancel() {
+        switch state {
+        case .possibleTap:
+            // Cancel the possible tap - notify delegate so it can reset state
+            delegate?.gestureRecognizerDidCancel(self)
+        case .dragging:
+            // Cancel the drag - don't complete it normally
+            delegate?.gestureRecognizerDidCancelDragging(self)
+        default:
+            break
+        }
+
         reset()
     }
-    
+
     private func calculateCentroid(fingers: [MTPoint]) -> MTPoint {
         let sumX = fingers.reduce(0) { $0 + $1.x }
         let sumY = fingers.reduce(0) { $0 + $1.y }
@@ -179,17 +224,17 @@ struct GestureData {
     let fingerCount: Int
     let startPosition: MTPoint?
     let lastPosition: MTPoint
-    
+
     /// Calculate frame-to-frame delta with sensitivity applied
     func frameDelta(from configuration: GestureConfiguration) -> (x: CGFloat, y: CGFloat) {
         let deltaX = CGFloat(centroid.x - lastPosition.x)
         let deltaY = CGFloat(centroid.y - lastPosition.y)
-        
+
         // Reject large deltas (likely jumps from finger changes)
         if abs(deltaX) > 0.03 || abs(deltaY) > 0.03 {
             return (0, 0)
         }
-        
+
         let sensitivity = CGFloat(configuration.effectiveSensitivity(for: velocity))
         return (deltaX * sensitivity, deltaY * sensitivity)
     }
@@ -201,16 +246,22 @@ struct GestureData {
 protocol GestureRecognizerDelegate: AnyObject {
     /// Called when a gesture starts (3 fingers detected)
     func gestureRecognizerDidStart(_ recognizer: GestureRecognizer, at position: MTPoint)
-    
+
     /// Called when a tap gesture is recognized
     func gestureRecognizerDidTap(_ recognizer: GestureRecognizer)
-    
+
     /// Called when dragging begins
     func gestureRecognizerDidBeginDragging(_ recognizer: GestureRecognizer)
-    
+
     /// Called during drag with movement data
     func gestureRecognizerDidUpdateDragging(_ recognizer: GestureRecognizer, with data: GestureData)
-    
-    /// Called when dragging ends
+
+    /// Called when dragging ends normally (user lifted fingers)
     func gestureRecognizerDidEndDragging(_ recognizer: GestureRecognizer)
+
+    /// Called when gesture is cancelled from early state (e.g., possibleTap when 4th finger added)
+    func gestureRecognizerDidCancel(_ recognizer: GestureRecognizer)
+
+    /// Called when dragging is cancelled (e.g., 4th finger added for Mission Control)
+    func gestureRecognizerDidCancelDragging(_ recognizer: GestureRecognizer)
 }