- Lots of performance improvements with regards to CPU usage

- Aligns much better with all kinds of cursors
- Fixed the clipping at the edges of the screens
- Hiding cursor is no longer time gated

Author: Brad Johnson

MouseHook/AppDelegate.swift

@@ -6,39 +6,82 @@
 //
 
 import Cocoa
+import Combine
 
 class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     private var statusItem: NSStatusItem!
     private var menu: NSMenu!
+    private var mouseWindow: NSWindow!
     private var mouseController: MouseViewController!
+    private var slowEventThrottle: Publishers.Throttle<PassthroughSubject<NSEvent, Never>, DispatchQueue>!
+    private var fastEventThrottle: Publishers.Throttle<PassthroughSubject<NSEvent, Never>, DispatchQueue>!
+    private var refreshObserver: NSKeyValueObservation!
+    private var eventMonitor: Any!
+    private var cancellationToken: AnyCancellable?
+    
+    @objc private dynamic var fastFreqRefresh: Bool = false
+    
+    private let eventSubject = PassthroughSubject<NSEvent, Never>()
     private let userDefaults = UserDefaults.standard
+    
+    deinit {
+        refreshObserver?.invalidate()
+        NSEvent.removeMonitor(eventMonitor!)
+    }
 
     func applicationDidFinishLaunching(_ aNotification: Notification) {
         statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
         if let button = statusItem.button {
             button.image = NSImage(named: NSImage.Name("mousehook-menubar"))
         }
-        
         mouseController = MouseViewController()
-        setupMouseHook()
+        fastEventThrottle = self.eventSubject.throttle(for: .seconds(1.0/60.0), scheduler: DispatchQueue.global(), latest: true) // 60Hz
+        slowEventThrottle = self.eventSubject.throttle(for: .seconds(1.0/5.0), scheduler: DispatchQueue.global(), latest: true) // 5Hz
+        
+        setupMouseWindow()
         setupMenu()
         statusItem.menu = menu
+        
+        refreshObserver = self.observe(\.fastFreqRefresh, options: [.new], changeHandler: { (this, change) in
+            self.cancellationToken?.cancel()
+            
+            let eventThrottle = change.newValue! ? self.fastEventThrottle : self.slowEventThrottle
+            
+            self.cancellationToken = eventThrottle?.subscribe(on: DispatchQueue.global()).sink { event in
+                // Don't bother updating mouse position if it is currently hidden
+                DispatchQueue.main.async {
+                    self.update(event)
+                }
+            }
+        })
+        fastFreqRefresh = true
+        
+        //TODO: Find a way to make global event monitoring not take up SO MUCH CPU
+        eventMonitor = NSEvent.addGlobalMonitorForEvents(matching: [.mouseMoved, .leftMouseDragged, .rightMouseDragged, .otherMouseDragged]) { (event) in
+            self.eventSubject.send(event)
+        }
     }
 
-    func setupMouseHook() {
-        let mouseWindow = NSWindow(contentViewController: mouseController)
+    func update(_ event: NSEvent) {
+        let cursorVisible = mouseController.update(event)
+        
+        if cursorVisible {
+            mouseWindow.setFrameOrigin(mouseController.getFrameOrigin(event.locationInWindow))
+        }
+        // Only use fast refresh rate if the cursor is actually visible
+        if (fastFreqRefresh != cursorVisible) {
+            fastFreqRefresh = cursorVisible
+        }
+    }
+    
+    func setupMouseWindow() {
+        mouseWindow = NSWindow(contentViewController: mouseController)
         mouseWindow.styleMask = [.borderless]
         mouseWindow.ignoresMouseEvents = true
         mouseWindow.setFrame(NSRect(x: 0, y: 0, width: 50, height: 50), display: false)
         mouseWindow.backgroundColor = .clear
         mouseWindow.level = .screenSaver
         mouseWindow.orderFront(nil)
-        
-        NSEvent.addGlobalMonitorForEvents(matching: [.mouseMoved, .leftMouseDragged, .rightMouseDragged, .otherMouseDragged]) { (event) in
-            let mouseLocation = event.locationInWindow
-            mouseWindow.setFrameOrigin(self.mouseController.getFrameOrigin(mouseLocation))
-            self.mouseController.update(event)
-        }
     }
 
     func setupMenu() {
@@ -81,6 +124,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
 
     @objc func menuItemClicked(item: NSMenuItem) {
         updateEnabledMonitors(CGDirectDisplayID(item.identifier!.rawValue)!)
+        mouseController.resetCurrentMonitor()
     }
 
     func updateEnabledMonitors(_ toUpdate: CGDirectDisplayID) {

MouseHook/MouseViewController.swift

@@ -6,15 +6,21 @@
 //
 
 import Cocoa
+import CommonCrypto
 
 class MouseViewController: NSViewController {
     private var cursorImageView: NSImageView!
-    private var activeMonitorObserver: NSKeyValueObservation!
+    private var enabledMonitorObserver: NSKeyValueObservation!
+    private var cursorObserver: NSKeyValueObservation!
     private var enabledMonitors: Set<CGDirectDisplayID> = Set<CGDirectDisplayID>()
-    private var currentCursor: NSCursor = NSCursor.current
-    private var lastUpdate: Date = Date(milliseconds: 0)
+    private var currentMonitor: NSScreen?
 
-    private let hideRefreshIntervalMs = 1500
+    @objc private dynamic var currentCursor: NSCursor = NSCursor.current
+    
+    private let pointingHandHash: String? = NSCursor.pointingHand.image.tiffRepresentation?.sha256
+    private let openHandHash: String? = NSCursor.openHand.image.tiffRepresentation?.sha256
+    private let closedHandHash: String? = NSCursor.closedHand.image.tiffRepresentation?.sha256
+    private let hideRefreshIntervalSecs = 1.5
 
     override init(nibName nibNameOrNil: NSNib.Name?, bundle nibBundleOrNil: Bundle?) {
         super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
@@ -26,82 +32,125 @@ class MouseViewController: NSViewController {
         setupMouseViewController()
     }
 
+    deinit {
+        enabledMonitorObserver?.invalidate()
+        cursorObserver?.invalidate()
+    }
+    
     private func setupMouseViewController() {
-        activeMonitorObserver = UserDefaults.standard.observe(\.activeMonitors, options: [.initial, .new], changeHandler: { (defaults, change) in
-            if let mons = defaults.activeMonitors as [CGDirectDisplayID]? {
-                self.enabledMonitors = Set(mons.map { $0 })
-            }
-        })
-        NSCursor.addObserver(self, forKeyPath: "currentSystem", options: [.new, .old], context: nil)
         cursorImageView = NSImageView()
         cursorImageView.wantsLayer = true
         cursorImageView.image = currentCursor.image
         cursorImageView.imageScaling = .scaleNone
         cursorImageView.layer?.backgroundColor = NSColor.clear.cgColor
         self.view = cursorImageView
+        
+        setupObservers()
     }
 
-    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
-        if keyPath == "currentSystem" {
-            if let newCursor = change?[NSKeyValueChangeKey.newKey] as? NSCursor {
-                self.cursorImageView.image = newCursor.image
+    private func setupObservers() {
+        enabledMonitorObserver = UserDefaults.standard.observe(\.activeMonitors, options: [.initial, .new], changeHandler: { (defaults, change) in
+            if let mons = defaults.activeMonitors as [CGDirectDisplayID]? {
+                self.enabledMonitors = Set(mons.map { $0 })
             }
-        }
+        })
+        cursorObserver = self.observe(\.currentCursor, options: [.initial, .new], changeHandler: { (this, change) in
+            self.cursorImageView.image = this.currentCursor.image
+        })
     }
 
+    /** These magic numbers work for the default mouse cursor at the default size on MacOS Monterey.
+     I can't guarantee it will work for custom mouse cursors or different OS versions, but I think it'll be pretty close. **/
     func getFrameOrigin(_ pt: NSPoint) -> NSPoint {
         var offset: (Double, Double)
+        
+        // There is no simple way to check the exact image of a cursor, but size is cheap, easy, and works in most cases to determine the offset.
         switch (currentCursor.image.size) {
         case NSCursor.arrow.image.size:
-            fallthrough
+            offset = (21, 32)
         case NSCursor.pointingHand.image.size:
-            offset = (21.5, 32)
-            break
+            // There are representations that match the size of pointingHand but not the offset, so check the hash of the image
+            switch (currentCursor.image.tiffRepresentation?.sha256) {
+            case pointingHandHash:
+                offset = (21.5, 32)
+            case openHandHash:
+                offset = (24.5, 24.5)
+            case closedHandHash:
+                offset = (24.5, 25)
+            default:
+                // It is likely a type of iBeam
+                offset = (24, 28)
+            }
         case NSCursor.iBeam.image.size:
             fallthrough
         case NSCursor.resizeLeftRight.image.size:
-            fallthrough
-        case NSCursor.resizeUpDown.image.size:
             offset = (24.5, 24.5)
-            break
+        case NSCursor.disappearingItem.image.size:
+            offset = (16.5, 38.5)
+        case NSCursor.dragLink.image.size:
+            offset = (28, 32)
         default:
             offset = (23.5, 25.5)
         }
 
         return NSPoint(x: pt.x - offset.0, y: pt.y - offset.1)
     }
 
-    func update(_ event: NSEvent) {
-        currentCursor = NSCursor.currentSystem != nil ? NSCursor.currentSystem! : currentCursor
-        cursorImageView.image = currentCursor.image
+    
+    override func viewDidLoad() {
+        let aCursor = NSCursor.resizeUpDown
+        view.addCursorRect(view.bounds, cursor: aCursor)
+        aCursor.set()
+        view.addTrackingRect(view.bounds, owner: aCursor, userData: nil, assumeInside: true)
 
-        let now = Date.now
-        guard (now.millisecondsSince1970 - lastUpdate.millisecondsSince1970) > hideRefreshIntervalMs else { return }
-        cursorImageView.isHidden = NSScreen.screens.reduce(true) { (result, screen) in
-            // If the monitor is not enabled, return immediately with a vote to `hide`
-            guard enabledMonitors.contains(screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as! CGDirectDisplayID) else { return result && true }
-
-            let screenBounds = screen.visibleFrame
-            let mousePosition = event.locationInWindow
-
-            return result && !screenBounds.contains(mousePosition)
+    }
+    
+    func resetCurrentMonitor(_ mousePosition: NSPoint? = nil) {
+        if (mousePosition != nil) {
+            currentMonitor = NSScreen.screens.first(where: { $0.frame.contains(mousePosition!) })
         }
-        lastUpdate = now
+        cursorImageView.isHidden = !enabledMonitors.contains(currentMonitor?.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? CGDirectDisplayID ?? kCGNullDirectDisplay)
     }
-
-    deinit {
-        activeMonitorObserver?.invalidate()
-        NSCursor.removeObserver(self, forKeyPath: "current")
+    
+    func update(_ event: NSEvent) -> Bool {
+        if (NSCursor.currentSystem != nil) {
+            currentCursor = NSCursor.currentSystem!
+        }
+        
+        let screenBounds = currentMonitor?.frame
+        // Apply a small transform to the y axis to avoid it going out of bounds along the top axis
+        let mousePosition = event.locationInWindow.applying(CGAffineTransform(translationX: 0.0, y: -0.00001))
+        if (screenBounds?.contains(mousePosition) != true) {
+            resetCurrentMonitor(mousePosition)
+        }
+        
+        return !cursorImageView.isHidden
     }
 }
 
-extension Date {
-    var millisecondsSince1970:Int64 {
-        Int64((self.timeIntervalSince1970 * 1000.0).rounded())
+extension Data {
+    public var sha256:String {
+        get {
+            return hexStringFromData(input: digest(input: self as NSData))
+        }
     }
-    
-    init(milliseconds:Int64) {
-        self = Date(timeIntervalSince1970: TimeInterval(milliseconds) / 1000)
+
+    private func digest(input : NSData) -> NSData {
+        let digestLength = Int(CC_SHA256_DIGEST_LENGTH)
+        var hash = [UInt8](repeating: 0, count: digestLength)
+        CC_SHA256(input.bytes, UInt32(input.length), &hash)
+        return NSData(bytes: hash, length: digestLength)
     }
-}
 
+    private  func hexStringFromData(input: NSData) -> String {
+        var bytes = [UInt8](repeating: 0, count: input.length)
+        input.getBytes(&bytes, length: input.length)
+
+        var hexString = ""
+        for byte in bytes {
+            hexString += String(format:"%02x", UInt8(byte))
+        }
+
+        return hexString
+    }
+}