Added Force Quit and modifier settings

Author: LoopyDev

Xcode/MiddleQuit/EventTapManager.swift

@@ -14,8 +14,13 @@ final class EventTapManager {
         case middle = 2
     }
 
+    enum ResolvedAction {
+        case quit
+        case forceQuit
+    }
+
     // Return true to consume the event (prevent Dock from seeing it)
-    typealias MiddleClickHandler = (_ locationInScreen: CGPoint) -> Bool
+    typealias MiddleClickHandler = (_ locationInScreen: CGPoint, _ action: ResolvedAction) -> Bool
 
     private var eventTap: CFMachPort?
     private var runLoopSource: CFRunLoopSource?
@@ -27,31 +32,33 @@ final class EventTapManager {
     // Public read-only: whether this tap can swallow events (depends on creation mode)
     private(set) var canSwallow = false
 
-    // Accessor for the current activation mode (injected so changes are live)
-    private var activationModeProvider: (() -> Preferences.ActivationMode)?
+    // Provider to resolve action based on current modifiers. Return nil for "no action".
+    private var actionResolver: ((NSEvent.ModifierFlags) -> ResolvedAction?)?
 
-    func start(activationMode: @escaping () -> Preferences.ActivationMode,
+    func start(resolveAction: @escaping (NSEvent.ModifierFlags) -> ResolvedAction?,
                handler: @escaping MiddleClickHandler) {
         self.handler = handler
-        self.activationModeProvider = activationMode
+        self.actionResolver = resolveAction
 
-        // Listen only for middle (other) mouse clicks, down and up.
-        let mask =
-            (1 << CGEventType.otherMouseDown.rawValue) |
-            (1 << CGEventType.otherMouseUp.rawValue)
+        // Build mask in a way that works across SDKs (UInt vs UInt64)
+        let downShift = CGEventMask(CGEventType.otherMouseDown.rawValue)
+        let upShift   = CGEventMask(CGEventType.otherMouseUp.rawValue)
+        let downBit: CGEventMask = CGEventMask(1) << downShift
+        let upBit: CGEventMask   = CGEventMask(1) << upShift
+        let mask: CGEventMask = downBit | upBit
 
         // Try session default (captures synthetic events, can swallow)
-        if createTap(tap: .cgSessionEventTap, options: .defaultTap, eventsOfInterest: CGEventMask(mask)) {
+        if createTap(tap: .cgSessionEventTap, options: .defaultTap, eventsOfInterest: mask) {
             canSwallow = true
             print("EventTap: using cgSessionEventTap (default) — can swallow")
         }
         // Else try HID default (captures hardware events, can swallow)
-        else if createTap(tap: .cghidEventTap, options: .defaultTap, eventsOfInterest: CGEventMask(mask)) {
+        else if createTap(tap: .cghidEventTap, options: .defaultTap, eventsOfInterest: mask) {
             canSwallow = true
             print("EventTap: using cghidEventTap (default) — can swallow")
         }
         // Else, try session listen-only (observe only, cannot swallow)
-        else if createTap(tap: .cgSessionEventTap, options: .listenOnly, eventsOfInterest: CGEventMask(mask)) {
+        else if createTap(tap: .cgSessionEventTap, options: .listenOnly, eventsOfInterest: mask) {
             canSwallow = false
             print("EventTap: using cgSessionEventTap (listenOnly) — cannot swallow")
         } else {
@@ -88,15 +95,16 @@ final class EventTapManager {
                         return Unmanaged.passUnretained(event)
                     }
 
-                    // Check activation mode against current modifier flags
-                    if !manager.matchesActivationMode(event: event) {
-                        return Unmanaged.passUnretained(event)
-                    }
-
                     let loc = event.location
-                    if let shouldConsume = manager.handler?(loc), shouldConsume, manager.canSwallow {
-                        manager.swallowNextOtherMouseUp = true
-                        return nil // swallow down
+
+                    // CGEvent.flags.rawValue is UInt64; NSEvent.ModifierFlags.RawValue is UInt.
+                    let flags = NSEvent.ModifierFlags(rawValue: UInt(event.flags.rawValue))
+
+                    if let action = manager.actionResolver?(flags) {
+                        if let shouldConsume = manager.handler?(loc, action), shouldConsume, manager.canSwallow {
+                            manager.swallowNextOtherMouseUp = true
+                            return nil // swallow down
+                        }
                     }
                     return Unmanaged.passUnretained(event)
                 } else {
@@ -123,28 +131,6 @@ final class EventTapManager {
         return false
     }
 
-    private func matchesActivationMode(event: CGEvent) -> Bool {
-        let flags = event.flags
-        let mode = activationModeProvider?() ?? .none
-
-        switch mode {
-        case .none:
-            // Require no primary modifiers (ignore caps lock, numeric pad, function)
-            return !flags.contains(.maskCommand)
-                && !flags.contains(.maskAlternate)
-                && !flags.contains(.maskControl)
-                && !flags.contains(.maskShift)
-        case .command:
-            return flags.contains(.maskCommand)
-        case .option:
-            return flags.contains(.maskAlternate)
-        case .control:
-            return flags.contains(.maskControl)
-        case .shift:
-            return flags.contains(.maskShift)
-        }
-    }
-
     func stop() {
         if let tap = eventTap {
             CGEvent.tapEnable(tap: tap, enable: false)
@@ -157,7 +143,7 @@ final class EventTapManager {
         handler = nil
         swallowNextOtherMouseUp = false
         canSwallow = false
-        activationModeProvider = nil
+        actionResolver = nil
     }
 }
 

Xcode/MiddleQuit/MiddleQuitApp.swift

@@ -13,7 +13,6 @@ struct MiddleQuitApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
 
     var body: some Scene {
-        // Provide a real Settings window with a toggle for the menu bar icon
         Settings {
             SettingsView(
                 preferences: appDelegate.preferences,
@@ -22,21 +21,19 @@ struct MiddleQuitApp: App {
                 }
             )
         }
+        .windowResizability(.contentSize)
     }
 }
 
 final class AppDelegate: NSObject, NSApplicationDelegate {
-    // Make preferences internal so SettingsView can access it via appDelegate
     let preferences = Preferences()
     private let eventTapManager = EventTapManager()
     private let dockHelper = DockAccessibilityHelper()
     private let quitController = QuitController()
     private let launchAtLogin = LaunchAtLoginManager()
     private var statusController: StatusItemController!
 
-    // Polling timer to detect when AX trust flips to true after prompting
     private var axPollingTimer: Timer?
-    // Guard to avoid starting the tap twice
     private var hasStartedEventTap = false
 
     func applicationDidFinishLaunching(_ notification: Notification) {
@@ -75,14 +72,6 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
             isLaunchAtLoginEnabled: { [weak self] in
                 return self?.launchAtLogin.isEnabled ?? false
             },
-            getActivationMode: { [weak self] in
-                self?.preferences.activationMode ?? .none
-            },
-            onSetActivationMode: { [weak self] mode in
-                guard let self else { return }
-                self.preferences.activationMode = mode
-                // EventTapManager reads mode dynamically
-            },
             onQuit: {
                 NSApp.terminate(nil)
             }
@@ -94,7 +83,6 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
     // MARK: - Accessibility flow (Option C)
 
-    // Show the system-managed AX prompt and auto-start when trust becomes true.
     private func promptForAccessibilityAndAutoStart() {
         NSApp.activate(ignoringOtherApps: true)
 
@@ -163,19 +151,52 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         }
         hasStartedEventTap = true
 
-        // Rebuild menu so the "Open Accessibility Settings" item disappears
         statusController.rebuildMenu()
 
-        eventTapManager.start(activationMode: { [weak self] in
-            self?.preferences.activationMode ?? .none
-        }) { [weak self] point in
-            guard let self else { return false }
-            if let pid = self.dockHelper.pidForDockTile(at: point) {
-                self.quitController.gracefulQuit(pid: pid)
-                return self.eventTapManager.canSwallow
+        eventTapManager.start(
+            resolveAction: { [weak self] flags in
+                guard let self else { return nil }
+
+                // Choose a single effective modifier (priority: ⌘ > ⌥ > ⌃ > ⇧ > none)
+                func effectiveModifier(from flags: NSEvent.ModifierFlags) -> Preferences.ActivationChoice {
+                    if flags.contains(.command) { return .command }
+                    if flags.contains(.option)  { return .option }
+                    if flags.contains(.control) { return .control }
+                    if flags.contains(.shift)   { return .shift }
+                    return .none
+                }
+
+                let eff = effectiveModifier(from: flags)
+                let quitChoice = self.preferences.quitActivation
+                let forceChoice = self.preferences.forceActivation
+
+                // If both are set to the same non-disabled choice, do nothing until resolved.
+                if quitChoice == forceChoice, quitChoice != .disabled {
+                    return nil
+                }
+
+                if eff == quitChoice, quitChoice != .disabled {
+                    return .quit
+                }
+                if eff == forceChoice, forceChoice != .disabled {
+                    return .forceQuit
+                }
+                return nil
+            },
+            handler: { [weak self] point, action in
+                guard let self else { return false }
+                if let pid = self.dockHelper.pidForDockTile(at: point) {
+                    switch action {
+                    case .quit:
+                        self.quitController.gracefulQuit(pid: pid)
+                    case .forceQuit:
+                        self.quitController.forceQuit(pid: pid)
+                    }
+                    return self.eventTapManager.canSwallow
+                }
+                return false
             }
-            return false
-        }
+        )
     }
 
     func applyStatusItemVisibility(show: Bool) {
@@ -193,3 +214,4 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         eventTapManager.stop()
     }
 }
+

Xcode/MiddleQuit/Preferences.swift

@@ -11,31 +11,36 @@ import AppKit
 final class Preferences {
     private let defaults = UserDefaults.standard
     private let showKey = "showStatusItem"
-    private let activationModeKey = "activationMode"
 
-    enum ActivationMode: String, CaseIterable, Identifiable {
-        case none
+    // Keys for per-action activations
+    private let quitActivationKey = "quitActivation"
+    private let forceActivationKey = "forceActivation"
+
+    enum ActivationChoice: String, CaseIterable, Identifiable {
+        case disabled
+        case none         // Plain middle click
         case command
         case option
         case control
         case shift
 
         var id: String { rawValue }
 
-        var displayName: String {
+        // Full descriptive label used in menus
+        var menuLabel: String {
             switch self {
-            case .none: return "Middle Click"
-            case .command: return "⌘ Command + Middle Click"
-            case .option: return "⌥ Option + Middle Click"
-            case .control: return "⌃ Control + Middle Click"
-            case .shift: return "⇧ Shift + Middle Click"
+            case .disabled: return "Disabled"
+            case .none:     return "Middle Click"
+            case .command:  return "⌘ Command + click"
+            case .option:   return "⌥ Option + click"
+            case .control:  return "⌃ Control + click"
+            case .shift:    return "⇧ Shift + click"
             }
         }
     }
 
     var showStatusItem: Bool {
         get {
-            // Default to true (visible)
             if defaults.object(forKey: showKey) == nil {
                 return true
             }
@@ -46,17 +51,30 @@ final class Preferences {
         }
     }
 
-    var activationMode: ActivationMode {
+    // Default: Quit = Middle Click, Force Quit = Option + click
+    var quitActivation: ActivationChoice {
         get {
-            if let raw = defaults.string(forKey: activationModeKey),
-               let mode = ActivationMode(rawValue: raw) {
-                return mode
+            if let raw = defaults.string(forKey: quitActivationKey),
+               let v = ActivationChoice(rawValue: raw) {
+                return v
             }
-            // Default: plain middle click
             return .none
         }
         set {
-            defaults.set(newValue.rawValue, forKey: activationModeKey)
+            defaults.set(newValue.rawValue, forKey: quitActivationKey)
+        }
+    }
+
+    var forceActivation: ActivationChoice {
+        get {
+            if let raw = defaults.string(forKey: forceActivationKey),
+               let v = ActivationChoice(rawValue: raw) {
+                return v
+            }
+            return .option
+        }
+        set {
+            defaults.set(newValue.rawValue, forKey: forceActivationKey)
         }
     }
 }

Xcode/MiddleQuit/QuitController.swift

@@ -12,4 +12,13 @@ final class QuitController {
         guard let app = NSRunningApplication(processIdentifier: pid) else { return }
         app.terminate()
     }
+
+    func forceQuit(pid: pid_t) {
+        guard let app = NSRunningApplication(processIdentifier: pid) else { return }
+        if !app.forceTerminate() {
+            // Fallback if needed
+            kill(app.processIdentifier, SIGKILL)
+        }
+    }
 }
+