Forgot grab.

Author: Narsil

src/macos/grab.rs

@@ -1,38 +1,42 @@
 #![allow(improper_ctypes_definitions)]
 use crate::macos::common::*;
 use crate::rdev::{Event, GrabError};
-use cocoa::base::nil;
-use cocoa::foundation::NSAutoreleasePool;
-use core_graphics::event::{CGEventTapLocation, CGEventType};
+use objc2_core_foundation::{CFMachPort, CFRunLoop, kCFRunLoopCommonModes};
+use objc2_core_graphics::{
+    CGEvent, CGEventTapCallBack, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
+    CGEventTapProxy, CGEventType, kCGEventMaskForAllEvents,
+};
+use objc2_foundation::NSAutoreleasePool;
 use std::os::raw::c_void;
+use std::ptr::{NonNull, null_mut};
 
 static mut GLOBAL_CALLBACK: Option<Box<dyn FnMut(Event) -> Option<Event>>> = None;
 
 #[link(name = "Cocoa", kind = "framework")]
 unsafe extern "C" {}
 
-unsafe extern "C" fn raw_callback(
+unsafe extern "C-unwind" fn raw_callback(
     _proxy: CGEventTapProxy,
     _type: CGEventType,
-    cg_event: CGEventRef,
+    cg_event: NonNull<CGEvent>,
     _user_info: *mut c_void,
-) -> CGEventRef {
+) -> *mut CGEvent {
     let opt = KEYBOARD_STATE.lock();
     if let Ok(mut keyboard) = opt {
         unsafe {
-            if let Some(event) = convert(_type, &cg_event, &mut keyboard) {
+            if let Some(event) = convert(_type, cg_event, &mut keyboard) {
                 // Reborrowing the global callback pointer.
                 // Totally UB. but not sure there's a great alternative.
                 let ptr = &raw mut GLOBAL_CALLBACK;
                 if let Some(callback) = &mut *ptr {
                     if callback(event).is_none() {
-                        cg_event.set_type(CGEventType::Null);
+                        CGEvent::set_type(Some(cg_event.as_ref()), CGEventType::Null)
                     }
                 }
             }
         }
     }
-    cg_event
+    cg_event.as_ptr()
 }
 
 pub fn grab<T>(callback: T) -> Result<(), GrabError>
@@ -41,28 +45,25 @@ where
 {
     unsafe {
         GLOBAL_CALLBACK = Some(Box::new(callback));
-        let _pool = NSAutoreleasePool::new(nil);
-        let tap = CGEventTapCreate(
-            CGEventTapLocation::HID, // HID, Session, AnnotatedSession,
-            kCGHeadInsertEventTap,
-            CGEventTapOption::Default,
-            kCGEventMaskForAllEvents,
-            raw_callback,
-            nil,
-        );
-        if tap.is_null() {
-            return Err(GrabError::EventTapError);
-        }
-        let _loop = CFMachPortCreateRunLoopSource(nil, tap, 0);
-        if _loop.is_null() {
-            return Err(GrabError::LoopSourceError);
-        }
+        let _pool = NSAutoreleasePool::new();
+        let callback: CGEventTapCallBack = Some(raw_callback);
+        let tap = CGEvent::tap_create(
+            CGEventTapLocation::HIDEventTap, // HID, Session, AnnotatedSession,
+            CGEventTapPlacement::HeadInsertEventTap,
+            CGEventTapOptions::Default,
+            kCGEventMaskForAllEvents.into(),
+            callback,
+            null_mut(),
+        )
+        .ok_or(GrabError::EventTapError)?;
+        let loop_ = CFMachPort::new_run_loop_source(None, Some(&tap), 0)
+            .ok_or(GrabError::LoopSourceError)?;
 
-        let current_loop = CFRunLoopGetCurrent();
-        CFRunLoopAddSource(current_loop, _loop, kCFRunLoopCommonModes);
+        let current_loop = CFRunLoop::current().unwrap();
+        current_loop.add_source(Some(&loop_), kCFRunLoopCommonModes);
 
-        CGEventTapEnable(tap, true);
-        CFRunLoopRun();
+        CGEvent::tap_enable(&tap, true);
+        CFRunLoop::run();
     }
     Ok(())
 }

src/macos/mod.rs

@@ -1,16 +1,16 @@
 mod common;
 mod display;
-// #[cfg(feature = "unstable_grab")]
-// mod grab;
+#[cfg(feature = "unstable_grab")]
+mod grab;
 mod keyboard;
 mod keycodes;
 mod listen;
 mod simulate;
 
 pub use crate::macos::common::set_is_main_thread;
 pub use crate::macos::display::display_size;
-// #[cfg(feature = "unstable_grab")]
-// pub use crate::macos::grab::grab;
+#[cfg(feature = "unstable_grab")]
+pub use crate::macos::grab::grab;
 pub use crate::macos::keyboard::Keyboard;
 pub use crate::macos::listen::listen;
 pub use crate::macos::simulate::simulate;