macos: fix modifier capture

input-capture/src/macos.rs

@@ -1,39 +1,31 @@
 use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
 use async_trait::async_trait;
 use bitflags::bitflags;
-use core_foundation::{
+use core_foundation::base::{kCFAllocatorDefault, CFRelease};
-    base::{kCFAllocatorDefault, CFRelease},
+use core_foundation::date::CFTimeInterval;
-    date::CFTimeInterval,
+use core_foundation::number::{kCFBooleanTrue, CFBooleanRef};
-    number::{kCFBooleanTrue, CFBooleanRef},
+use core_foundation::runloop::{kCFRunLoopCommonModes, CFRunLoop, CFRunLoopSource};
-    runloop::{kCFRunLoopCommonModes, CFRunLoop, CFRunLoopSource},
+use core_foundation::string::{kCFStringEncodingUTF8, CFStringCreateWithCString, CFStringRef};
-    string::{kCFStringEncodingUTF8, CFStringCreateWithCString, CFStringRef},
+use core_graphics::base::{kCGErrorSuccess, CGError};
-};
+use core_graphics::display::{CGDisplay, CGPoint};
-use core_graphics::{
+use core_graphics::event::{
-    base::{kCGErrorSuccess, CGError},
+    CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
-    display::{CGDisplay, CGPoint},
+    CGEventTapProxy, CGEventType, CallbackResult, EventField,
-    event::{
-        CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions,
-        CGEventTapPlacement, CGEventTapProxy, CGEventType, CallbackResult, EventField,
-    },
-    event_source::{CGEventSource, CGEventSourceStateID},
 };
+use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
 use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
 use keycode::{KeyMap, KeyMapping};
 use libc::c_void;
 use once_cell::unsync::Lazy;
-use std::{
+use std::collections::HashSet;
-    collections::HashSet,
+use std::ffi::{c_char, CString};
-    ffi::{c_char, CString},
+use std::pin::Pin;
-    pin::Pin,
+use std::sync::Arc;
-    sync::Arc,
+use std::task::{ready, Context, Poll};
-    task::{ready, Context, Poll},
+use std::thread::{self};
-    thread::{self},
+use tokio::sync::mpsc::{self, Receiver, Sender};
-};
+use tokio::sync::{oneshot, Mutex};
-use tokio::sync::{
-    mpsc::{self, Receiver, Sender},
-    oneshot, Mutex,
-};
 
 #[derive(Debug, Default)]
 struct Bounds {
@@ -45,15 +37,9 @@ struct Bounds {
 
 #[derive(Debug)]
 struct InputCaptureState {
-    /// active capture positions
     active_clients: Lazy<HashSet<Position>>,
-    /// the currently entered capture position, if any
     current_pos: Option<Position>,
-    /// position where the cursor was captured
-    enter_position: Option<CGPoint>,
-    /// bounds of the input capture area
     bounds: Bounds,
-    /// current state of modifier keys
     modifier_state: XMods,
 }
 
@@ -71,7 +57,6 @@ impl InputCaptureState {
         let mut res = Self {
             active_clients: Lazy::new(HashSet::new),
             current_pos: None,
-            enter_position: None,
             bounds: Bounds::default(),
             modifier_state: Default::default(),
         };
@@ -113,34 +98,45 @@ impl InputCaptureState {
         Ok(())
     }
 
-    /// start the input capture by
+    // We can't disable mouse movement when in a client so we need to reset the cursor position
-    fn start_capture(&mut self, event: &CGEvent, position: Position) -> Result<(), CaptureError> {
+    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
-        let mut location = event.location();
+    // random location when we exit the client
-        let edge_offset = 1.0;
+    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
-        // move cursor location to display bounds
+        if let Some(pos) = self.current_pos {
-        match position {
+            let location = event.location();
-            Position::Left => location.x = self.bounds.xmin + edge_offset,
+            let edge_offset = 1.0;
-            Position::Right => location.x = self.bounds.xmax - edge_offset,
-            Position::Top => location.y = self.bounds.ymin + edge_offset,
-            Position::Bottom => location.y = self.bounds.ymax - edge_offset,
-        };
-        self.enter_position = Some(location);
-        self.reset_cursor()
-    }
 
-    /// resets the cursor to the position, where the capture started
+            // After the cursor is warped no event is produced but the next event
-    fn reset_cursor(&mut self) -> Result<(), CaptureError> {
+            // will carry the delta from the warp so only half the delta is needed to move the cursor
-        let pos = self.enter_position.expect("capture active");
+            let delta_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y) / 2.0;
-        log::trace!("Resetting cursor position to: {}, {}", pos.x, pos.y);
+            let delta_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X) / 2.0;
-        CGDisplay::warp_mouse_cursor_position(pos).map_err(CaptureError::WarpCursor)
-    }
 
-    fn hide_cursor(&self) -> Result<(), CaptureError> {
+            let mut new_x = location.x + delta_x;
-        CGDisplay::hide_cursor(&CGDisplay::main()).map_err(CaptureError::CoreGraphics)
+            let mut new_y = location.y + delta_y;
-    }
 
-    fn show_cursor(&self) -> Result<(), CaptureError> {
+            match pos {
-        CGDisplay::show_cursor(&CGDisplay::main()).map_err(CaptureError::CoreGraphics)
+                Position::Left => {
+                    new_x = self.bounds.xmin + edge_offset;
+                }
+                Position::Right => {
+                    new_x = self.bounds.xmax - edge_offset;
+                }
+                Position::Top => {
+                    new_y = self.bounds.ymin + edge_offset;
+                }
+                Position::Bottom => {
+                    new_y = self.bounds.ymax - edge_offset;
+                }
+            }
+            let new_pos = CGPoint::new(new_x, new_y);
+
+            log::trace!("Resetting cursor position to: {new_x}, {new_y}");
+
+            return CGDisplay::warp_mouse_cursor_position(new_pos)
+                .map_err(CaptureError::WarpCursor);
+        }
+
+        Err(CaptureError::ResetMouseWithoutClient)
     }
 
     async fn handle_producer_event(
@@ -151,13 +147,15 @@ impl InputCaptureState {
         match producer_event {
             ProducerEvent::Release => {
                 if self.current_pos.is_some() {
-                    self.show_cursor()?;
+                    CGDisplay::show_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
                     self.current_pos = None;
                 }
             }
             ProducerEvent::Grab(pos) => {
                 if self.current_pos.is_none() {
-                    self.hide_cursor()?;
+                    CGDisplay::hide_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
                     self.current_pos = Some(pos);
                 }
             }
@@ -167,7 +165,8 @@ impl InputCaptureState {
             ProducerEvent::Destroy(p) => {
                 if let Some(current) = self.current_pos {
                     if current == p {
-                        self.show_cursor()?;
+                        CGDisplay::show_cursor(&CGDisplay::main())
+                            .map_err(CaptureError::CoreGraphics)?;
                         self.current_pos = None;
                     };
                 }
@@ -365,7 +364,7 @@ fn create_event_tap<'a>(
         move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
             log::trace!("Got event from tap: {event_type:?}");
             let mut state = client_state.blocking_lock();
-            let mut capture_position = None;
+            let mut pos = None;
             let mut res_events = vec![];
 
             if matches!(
@@ -382,7 +381,7 @@ fn create_event_tap<'a>(
 
             // Are we in a client?
             if let Some(current_pos) = state.current_pos {
-                capture_position = Some(current_pos);
+                pos = Some(current_pos);
                 get_events(
                     &event_type,
                     cg_ev,
@@ -394,22 +393,16 @@ fn create_event_tap<'a>(
                 });
 
                 // Keep (hidden) cursor at the edge of the screen
-                if matches!(
+                if matches!(event_type, CGEventType::MouseMoved) {
-                    event_type,
+                    state.reset_mouse_position(cg_ev).unwrap_or_else(|e| {
-                    CGEventType::MouseMoved
+                        log::error!("Failed to reset mouse position: {e}");
-                        | CGEventType::LeftMouseDragged
+                    })
-                        | CGEventType::RightMouseDragged
-                        | CGEventType::OtherMouseDragged
-                ) {
-                    state.reset_cursor().unwrap_or_else(|e| log::warn!("{e}"));
                 }
-            } else if matches!(event_type, CGEventType::MouseMoved) {
+            }
-                // Did we cross a barrier?
+            // Did we cross a barrier?
+            else if matches!(event_type, CGEventType::MouseMoved) {
                 if let Some(new_pos) = state.crossed(cg_ev) {
-                    capture_position = Some(new_pos);
+                    pos = Some(new_pos);
-                    state
-                        .start_capture(cg_ev, new_pos)
-                        .unwrap_or_else(|e| log::warn!("{e}"));
                     res_events.push(CaptureEvent::Begin);
                     notify_tx
                         .blocking_send(ProducerEvent::Grab(new_pos))
@@ -417,7 +410,7 @@ fn create_event_tap<'a>(
                 }
             }
 
-            if let Some(pos) = capture_position {
+            if let Some(pos) = pos {
                 res_events.iter().for_each(|e| {
                     // error must be ignored, since the event channel
                     // may already be closed when the InputCapture instance is dropped.
@@ -522,7 +515,10 @@ impl MacOSInputCapture {
                             log::error!("Failed to handle producer event: {e}");
                         })
                     }
-                    _ = &mut tap_exit_rx => break,
+
+                    _ = &mut tap_exit_rx => {
+                        break;
+                    }
                 }
             }
             // show cursor