refactor: rdev -> monio (#51)

* refactor: rdev -> monio

Author: blindFS

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.0.1"
 edition = "2024"
 
 [dependencies]
-rdev = {version = "0.5.3", features = ["unstable_grab"]}
+monio = "0.1.1"
 toml = "1.1.2"
 serde = { version = "1.0.228", features = ["derive"] }
 accessibility = "0.2.0"

src/app_engine/interaction.rs

@@ -9,32 +9,23 @@ use accessibility::{AXUIElement, AXUIElementActions, AXUIElementAttributes};
 use accessibility_sys::{
     kAXErrorAttributeUnsupported, kAXErrorCannotComplete, kAXFocusedAttribute,
 };
-use core_foundation::{base::TCFType, boolean::CFBoolean, number::CFNumber};
+use core_foundation::{base::TCFType, boolean::CFBoolean, number::CFNumber, string::CFString};
 use log::Level;
-use objc2_app_kit::NSEvent;
-use rdev::{Button, EventType, simulate};
-use std::time::Duration;
+use monio::{Button, Event, ScrollDirection};
 
 impl AppEngine {
-    pub(super) fn simulate_event(&self, event_type: &EventType) {
-        match simulate(event_type) {
-            Ok(()) => (),
-            Err(e) => {
-                log::error!("Failed to simulate event {event_type:?}: {e}");
-            }
-        }
-    }
-
     /// Move the mouse to `(end_x, end_y)` with a fading triangle cursor trail animation.
     pub(super) fn move_mouse_with_trail(&self, end_x: f64, end_y: f64) {
         // Get current mouse position (Cocoa bottom-left origin)
-        let mouse_loc = NSEvent::mouseLocation();
+        let mouse_loc = objc2_app_kit::NSEvent::mouseLocation();
 
         if self.config.theme.enable_animation {
             self.drawer
                 .draw_trail(mouse_loc.x, mouse_loc.y, end_x, end_y);
         }
-        self.simulate_event(&EventType::MouseMove { x: end_x, y: end_y });
+        if let Err(e) = monio::mouse_move(end_x, end_y) {
+            log::error!("Failed to move mouse to ({end_x}, {end_y}): {e}");
+        }
     }
 
     pub(super) fn simulate_click(&self, x: f64, y: f64, button: Button) {
@@ -53,10 +44,10 @@ impl AppEngine {
             let color = frame_colors.get(color_idx).unwrap_or(default_color);
             self.drawer.draw_ripple(x, y, color);
         }
-        std::thread::sleep(Duration::from_millis(20));
-        self.simulate_event(&EventType::ButtonPress(button));
-        std::thread::sleep(Duration::from_millis(20));
-        self.simulate_event(&EventType::ButtonRelease(button));
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        if let Err(e) = monio::mouse_click(button) {
+            log::error!("Failed to click mouse button {button:?}: {e}");
+        }
     }
 
     pub(super) fn focus_on_element(&self, element: &AXUIElement) {
@@ -203,6 +194,17 @@ impl AppEngine {
         }
     }
 
+    fn simulate_scroll(delta: f64) {
+        let direction = if delta > 0.0 {
+            ScrollDirection::Up
+        } else {
+            ScrollDirection::Down
+        };
+        if let Err(e) = monio::simulate(&Event::mouse_wheel(0.0, 0.0, direction, delta)) {
+            log::error!("Failed to simulate scroll {delta}: {e}");
+        }
+    }
+
     pub(super) fn perform_scroll_action(&mut self, sa: ScrollAction) {
         let Some(selected) = self.selected.as_ref() else {
             return;
@@ -248,19 +250,13 @@ impl AppEngine {
                 }
             }
         } else {
-            let distance = (frame.size().1 * self.config.scroll_distance).max(1.0) as i64;
+            let distance = (frame.size().1 * self.config.scroll_distance).max(1.0);
             match sa {
                 ScrollAction::DownRight => {
-                    self.simulate_event(&EventType::Wheel {
-                        delta_x: 0,
-                        delta_y: -distance,
-                    });
+                    Self::simulate_scroll(-distance);
                 }
                 ScrollAction::UpLeft => {
-                    self.simulate_event(&EventType::Wheel {
-                        delta_x: 0,
-                        delta_y: distance,
-                    });
+                    Self::simulate_scroll(distance);
                 }
                 ScrollAction::IncreaseDistance => {
                     self.config.scroll_distance *= 1.5;
@@ -269,17 +265,11 @@ impl AppEngine {
                     self.config.scroll_distance /= 1.5;
                 }
                 ScrollAction::Top => {
-                    self.simulate_event(&EventType::Wheel {
-                        delta_x: 0,
-                        delta_y: 999999,
-                    });
+                    Self::simulate_scroll(999999.0);
                     self.draw_element_menu("", RoleOfInterest::ScrollBar, false);
                 }
                 ScrollAction::Bottom => {
-                    self.simulate_event(&EventType::Wheel {
-                        delta_x: 0,
-                        delta_y: -999999,
-                    });
+                    Self::simulate_scroll(-999999.0);
                     self.draw_element_menu("", RoleOfInterest::ScrollBar, false);
                 }
             }
@@ -300,14 +290,11 @@ impl AppEngine {
     pub(super) fn update_editing_text(&mut self, new_text: String) {
         if let Some(selected) = self.editing.as_ref()
             && let Some(ele) = selected.element()
+            && let Err(e) = ele.set_value(CFString::new(&new_text).as_CFType())
         {
-            use accessibility::AXUIElementAttributes;
-            use core_foundation::{base::TCFType, string::CFString};
-            if let Err(e) = ele.set_value(CFString::new(&new_text).as_CFType()) {
-                log::warn!("Failed to set the text of focused element: {ele:?}\n Error: {e}");
-                // Reset editing upon failure
-                self.editing = None;
-            }
+            log::warn!("Failed to set the text of focused element: {ele:?}\n Error: {e}");
+            // Reset editing upon failure
+            self.editing = None;
         }
     }
 

src/app_engine/workflow.rs

@@ -4,7 +4,7 @@ use crate::{
     config::{RoleOfInterest, WorkFlow, WorkFlowAction},
 };
 use log::Level;
-use rdev::{Button, EventType};
+use monio::Button;
 use std::time::Duration;
 
 impl AppEngine {
@@ -64,11 +64,11 @@ impl AppEngine {
             WorkFlowAction::KeyCombo(kb) => {
                 self.set_simulating_key(true);
                 for k in kb.keys.iter() {
-                    self.simulate_event(&EventType::KeyPress(*k));
+                    let _ = monio::key_press(*k);
                     std::thread::sleep(Duration::from_millis(20));
                 }
                 for k in kb.keys.iter().rev() {
-                    self.simulate_event(&EventType::KeyRelease(*k));
+                    let _ = monio::key_release(*k);
                 }
                 self.set_simulating_key(false);
                 return false;

src/config.rs

@@ -1,9 +1,9 @@
+use monio::Key;
 use objc2::rc::Retained;
 use objc2_app_kit::NSFont;
 use objc2_core_foundation::CFRetained;
 use objc2_core_graphics::CGColor;
 use objc2_foundation::{NSString, ns_string};
-use rdev::Key;
 use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::PathBuf;
@@ -253,16 +253,16 @@ impl AlphabeticKey for Key {
             Key::Num9 => '9',
             Key::Num0 => '0',
             Key::Backspace | Key::Delete => '-',
-            Key::LeftBracket => '[',
-            Key::RightBracket => ']',
+            Key::BracketLeft => '[',
+            Key::BracketRight => ']',
             Key::ShiftLeft | Key::ShiftRight => '󰘶',
             _ => ' ',
         }
     }
 
     fn to_str(&self) -> String {
         match self {
-            Key::Alt | Key::AltGr => "ALT".to_string(),
+            Key::AltLeft | Key::AltRight => "ALT".to_string(),
             Key::ControlLeft | Key::ControlRight => "CTRL".to_string(),
             Key::MetaLeft | Key::MetaRight => "META".to_string(),
             Key::ShiftLeft | Key::ShiftRight => "SHIFT".to_string(),
@@ -298,7 +298,7 @@ impl AlphabeticKey for Key {
             "X" => Some(Key::KeyX),
             "Y" => Some(Key::KeyY),
             "Z" => Some(Key::KeyZ),
-            "ALT" => Some(Key::Alt),
+            "ALT" => Some(Key::AltLeft),
             "CTRL" => Some(Key::ControlLeft),
             "SHIFT" => Some(Key::ShiftLeft),
             "META" => Some(Key::MetaLeft),
@@ -308,7 +308,7 @@ impl AlphabeticKey for Key {
 
     fn right_alternative(&self) -> Option<Key> {
         match self {
-            Key::Alt => Some(Key::AltGr),
+            Key::AltLeft => Some(Key::AltRight),
             Key::ControlLeft => Some(Key::ControlRight),
             Key::ShiftLeft => Some(Key::ShiftRight),
             Key::ShiftRight => Some(Key::MetaRight),
@@ -417,7 +417,7 @@ impl GlyphlowConfig {
 
 fn default_global_keybinding() -> KeyBinding {
     KeyBinding {
-        keys: vec![Key::Alt, Key::KeyG],
+        keys: vec![Key::AltLeft, Key::KeyG],
     }
 }
 fn default_text_actions() -> Vec<CommandAction> {

src/key_listener.rs

@@ -5,7 +5,7 @@ use std::{
     sync::{Mutex, MutexGuard},
 };
 
-use rdev::Key;
+use monio::Key;
 use tokio::sync::mpsc::Sender;
 
 use crate::{
@@ -355,7 +355,7 @@ impl KeyListener {
             }
             Mode::DashBoard => self.menu_helper(&key, MenuType::Dashboard, state, key_state),
             // To act on selected parent node
-            Mode::Filtering if key == Key::Return => {
+            Mode::Filtering if key == Key::Enter => {
                 self.send(AppSignal::ActOnSelected);
                 self.send(AppSignal::MenuRefresh("".into()));
                 *state = Mode::DashBoard;
@@ -370,7 +370,7 @@ impl KeyListener {
             Mode::WordPicking => {
                 match key {
                     Key::Slash => self.send(AppSignal::WordPickerStartSearch),
-                    Key::Return => self.send(AppSignal::WordPickerFinishSearch),
+                    Key::Enter => self.send(AppSignal::WordPickerFinishSearch),
                     Key::Escape => {
                         self.send(AppSignal::DeActivate);
                         *state = Mode::Idle;

src/main.rs

@@ -7,9 +7,9 @@ use glyphlow::{
     config::{GlyphlowConfig, get_config_path},
     os_util::check_accessibility_permissions,
 };
+use monio::{EventType, grab};
 use notify::RecursiveMode;
 use notify_debouncer_mini::{DebounceEventResult, new_debouncer};
-use rdev::{EventType, grab};
 use std::{
     collections::HashSet,
     path::PathBuf,
@@ -53,7 +53,7 @@ async fn main() {
     let key_listener = KeyListener::new(tx, &config);
 
     let state = Arc::new(Mutex::new(Mode::Idle));
-    // Need this because rdev::grab takes a Fn not FnMut
+    // Key state for tracking pressed keys and simulating state
     let key_state = Arc::new(Mutex::new(KeyState::default()));
 
     // Listen to temp file updates
@@ -102,23 +102,24 @@ async fn main() {
         let state = state.clone();
         let _ = grab(move |event| {
             let Ok(mut k_s) = key_state.lock() else {
-                return Some(event);
+                return Some(event.clone());
             };
             if k_s.is_simulating {
-                return Some(event);
+                return Some(event.clone());
             }
-            let swallow = match event.event_type {
-                EventType::KeyPress(key) => {
-                    k_s.key_down(&key);
-                    key_listener.key_down(key, &state, &mut k_s)
-                }
-                EventType::KeyRelease(key) => {
-                    k_s.key_up(&key);
-                    false
+
+            let mut pass_on = true;
+            if let Some(kb) = &event.keyboard {
+                match event.event_type {
+                    EventType::KeyPressed => {
+                        k_s.key_down(&kb.key);
+                        pass_on = !key_listener.key_down(kb.key, &state, &mut k_s)
+                    }
+                    EventType::KeyReleased => k_s.key_up(&kb.key),
+                    _ => (),
                 }
-                _ => false,
             };
-            (!swallow).then_some(event)
+            pass_on.then(|| event.clone())
         });
     });