feat(macOS&linux): ad pressed and released states (#34)

* feat: add Pressed and Released enum to GlobalHotKeyEvent * feet: handle macos hotkey release * fix: examples consider hotkey state * docs: add comment for pub struct and enum * Apply suggestions from code review --------- Co-authored-by: Amr Bashir <[email protected]>
tauri-apps · Oct 18, 2023 · 0e35ee3 · 0e35ee3
1 parent ac63064
commit 0e35ee3
Show file tree

Hide file tree

Showing 7 changed files with 59 additions and 19 deletions.
diff --git a/examples/tao.rs b/examples/tao.rs
@@ -4,7 +4,7 @@
 
 use global_hotkey::{
     hotkey::{Code, HotKey, Modifiers},
-    GlobalHotKeyEvent, GlobalHotKeyManager,
+    GlobalHotKeyEvent, GlobalHotKeyManager, HotKeyState,
 };
 use tao::event_loop::{ControlFlow, EventLoopBuilder};
 
@@ -29,7 +29,7 @@ fn main() {
         if let Ok(event) = global_hotkey_channel.try_recv() {
             println!("{event:?}");
 
-            if hotkey2.id() == event.id {
+            if hotkey2.id() == event.id && event.state == HotKeyState::Released {
                 hotkeys_manager.unregister(hotkey2).unwrap();
             }
         }

diff --git a/examples/winit.rs b/examples/winit.rs
@@ -4,7 +4,7 @@
 
 use global_hotkey::{
     hotkey::{Code, HotKey, Modifiers},
-    GlobalHotKeyEvent, GlobalHotKeyManager,
+    GlobalHotKeyEvent, GlobalHotKeyManager, HotKeyState,
 };
 use winit::event_loop::{ControlFlow, EventLoopBuilder};
 
@@ -29,7 +29,7 @@ fn main() {
         if let Ok(event) = global_hotkey_channel.try_recv() {
             println!("{event:?}");
 
-            if hotkey2.id() == event.id {
+            if hotkey2.id() == event.id && event.state == HotKeyState::Released {
                 hotkeys_manager.unregister(hotkey2).unwrap();
             }
         }

diff --git a/src/lib.rs b/src/lib.rs
@@ -60,12 +60,22 @@ mod platform_impl;
 pub use self::error::*;
 use hotkey::HotKey;
 
-/// Contains the id of the triggered [`HotKey`].
-/// Describes a global hotkey event emitted when a [`HotKey`] is pressed.
+/// Describes the state of the [`HotKey`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum HotKeyState {
+    /// The [`HotKey`] is pressed (the key is down).  
+    Pressed,
+    /// The [`HotKey`] is released (the key is up).  
+    Released,
+}
+
+/// Describes a global hotkey event emitted when a [`HotKey`] is pressed or released.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct GlobalHotKeyEvent {
     /// Id of the associated [`HotKey`].
     pub id: u32,
+    /// State of the associated [`HotKey`].
+    pub state: HotKeyState,
 }
 
 /// A reciever that could be used to listen to global hotkey events.

diff --git a/src/platform_impl/macos/ffi.rs b/src/platform_impl/macos/ffi.rs
@@ -13,6 +13,7 @@ pub type OSType = FourCharCode;
 pub type ByteCount = ::std::os::raw::c_ulong;
 pub type ItemCount = ::std::os::raw::c_ulong;
 pub type OptionBits = UInt32;
+pub type EventKind = UInt32;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct OpaqueEventRef {
@@ -63,6 +64,8 @@ pub type _bindgen_ty_1939 = ::std::os::raw::c_uint;
 pub const kEventClassKeyboard: _bindgen_ty_1939 = 1801812322;
 pub type _bindgen_ty_1980 = ::std::os::raw::c_uint;
 pub const kEventHotKeyPressed: _bindgen_ty_1980 = 5;
+pub type _bindgen_ty_1981 = ::std::os::raw::c_uint;
+pub const kEventHotKeyReleased: _bindgen_ty_1981 = 6;
 pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
 pub const noErr: _bindgen_ty_1 = 0;
 
@@ -77,7 +80,7 @@ pub struct EventHotKeyID {
 #[derive(Debug, Copy, Clone)]
 pub struct EventTypeSpec {
     pub eventClass: OSType,
-    pub eventKind: UInt32,
+    pub eventKind: EventKind,
 }
 
 #[link(name = "Carbon", kind = "framework")]
@@ -91,6 +94,7 @@ extern "C" {
         outActualSize: *mut ByteCount,
         outData: *mut ::std::os::raw::c_void,
     ) -> OSStatus;
+    pub fn GetEventKind(inEvent: EventRef) -> EventKind;
     pub fn GetApplicationEventTarget() -> EventTargetRef;
     pub fn InstallEventHandler(
         inTarget: EventTargetRef,

diff --git a/src/platform_impl/macos/mod.rs b/src/platform_impl/macos/mod.rs
@@ -5,10 +5,10 @@ use keyboard_types::{Code, Modifiers};
 use crate::{hotkey::HotKey, GlobalHotKeyEvent};
 
 use self::ffi::{
-    kEventClassKeyboard, kEventHotKeyPressed, kEventParamDirectObject, noErr, typeEventHotKeyID,
-    EventHandlerCallRef, EventHandlerRef, EventHotKeyID, EventHotKeyRef, EventRef, EventTypeSpec,
-    GetApplicationEventTarget, GetEventParameter, InstallEventHandler, OSStatus,
-    RegisterEventHotKey, RemoveEventHandler, UnregisterEventHotKey,
+    kEventClassKeyboard, kEventHotKeyPressed, kEventHotKeyReleased, kEventParamDirectObject, noErr,
+    typeEventHotKeyID, EventHandlerCallRef, EventHandlerRef, EventHotKeyID, EventHotKeyRef,
+    EventRef, EventTypeSpec, GetApplicationEventTarget, GetEventKind, GetEventParameter,
+    InstallEventHandler, OSStatus, RegisterEventHotKey, RemoveEventHandler, UnregisterEventHotKey,
 };
 
 mod ffi;
@@ -23,19 +23,24 @@ unsafe impl Sync for GlobalHotKeyManager {}
 
 impl GlobalHotKeyManager {
     pub fn new() -> crate::Result<Self> {
-        let event_type = EventTypeSpec {
+        let pressed_event_type = EventTypeSpec {
             eventClass: kEventClassKeyboard,
             eventKind: kEventHotKeyPressed,
         };
+        let released_event_type = EventTypeSpec {
+            eventClass: kEventClassKeyboard,
+            eventKind: kEventHotKeyReleased,
+        };
+        let event_types = [pressed_event_type, released_event_type];
 
         let ptr = unsafe {
             let mut handler_ref: EventHandlerRef = std::mem::zeroed();
 
             let result = InstallEventHandler(
                 GetApplicationEventTarget(),
                 Some(hotkey_handler),
-                1,
-                &event_type,
+                2,
+                event_types.as_ptr(),
                 std::ptr::null_mut(),
                 &mut handler_ref,
             );
@@ -174,9 +179,20 @@ unsafe extern "C" fn hotkey_handler(
     );
 
     if result == noErr as _ {
-        let _ = GlobalHotKeyEvent::send(GlobalHotKeyEvent {
-            id: event_hotkey.id,
-        });
+        let event_kind = GetEventKind(event);
+        match event_kind {
+            #[allow(non_upper_case_globals)]
+            kEventHotKeyPressed => GlobalHotKeyEvent::send(GlobalHotKeyEvent {
+                id: event_hotkey.id,
+                state: crate::HotKeyState::Pressed,
+            }),
+            #[allow(non_upper_case_globals)]
+            kEventHotKeyReleased => GlobalHotKeyEvent::send(GlobalHotKeyEvent {
+                id: event_hotkey.id,
+                state: crate::HotKeyState::Released,
+            }),
+            _ => {}
+        };
     }
 
     noErr as _

diff --git a/src/platform_impl/windows/mod.rs b/src/platform_impl/windows/mod.rs
@@ -139,7 +139,10 @@ unsafe extern "system" fn global_hotkey_subclass_proc(
     _subclass_input_ptr: usize,
 ) -> LRESULT {
     if msg == WM_HOTKEY {
-        GlobalHotKeyEvent::send(GlobalHotKeyEvent { id: wparam as _ });
+        GlobalHotKeyEvent::send(GlobalHotKeyEvent {
+            id: wparam as _,
+            state: crate::HotKeyState::Pressed,
+        });
     }
 
     DefSubclassProc(hwnd, msg, wparam, lparam)

diff --git a/src/platform_impl/x11/mod.rs b/src/platform_impl/x11/mod.rs
@@ -94,10 +94,17 @@ fn events_processor(thread_rx: Receiver<ThreadMessage>) {
                             if let Some((id, repeating)) = hotkeys.get_mut(&(modifiers, keycode)) {
                                 match (e, *repeating) {
                                     (xlib::KeyPress, false) => {
-                                        GlobalHotKeyEvent::send(GlobalHotKeyEvent { id: *id });
+                                        GlobalHotKeyEvent::send(GlobalHotKeyEvent {
+                                            id: *id,
+                                            state: crate::HotKeyState::Pressed,
+                                        });
                                         *repeating = true;
                                     }
                                     (xlib::KeyRelease, true) => {
+                                        GlobalHotKeyEvent::send(GlobalHotKeyEvent {
+                                            id: *id,
+                                            state: crate::HotKeyState::Released,
+                                        });
                                         *repeating = false;
                                     }
                                     _ => {}