Adding keyboard state accessible for Linux. (#48)

* Adding keyboard state accessible for Linux.

* Adding windows version.

* Forgot fmt.

* Adding MacOS.

- Reworked KeyboardState to trait
- Keyboard is now the struct (won't be documented) that initializes the
  trait.
- In the future Keyboard should be able to implement any kind of layout
  which should help with testing. For now testing depends on the current
layout to work (errors messages should at least convey that !)

* cargo fmt.

* Renamed keyboard_state.rs to keyboard.rs

* A bit of clippy and fix windows grab.

* Small fixes to windows.

* Last fix from windows grab?

* New minor version (Keyboard capabilities).

Author: Narsil

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rdev"
-version = "0.3.6"
+version = "0.4.0"
 authors = ["Nicolas Patry <[email protected]>"]
 edition = "2018"
 
@@ -21,6 +21,7 @@ serialize = ["serde"]
 unstable_grab = []
 
 [target.'cfg(target_os = "macos")'.dependencies]
+lazy_static = "1.4.0"
 cocoa = "0.20"
 core-graphics = {version = "0.19.0", features = ["highsierra"]}
 core-foundation = {version = "0.7"}
@@ -33,6 +34,7 @@ x11 = {version = "2.18", features = ["xlib", "xrecord", "xinput"]}
 xproto = "1.1"
 
 [target.'cfg(target_os = "windows")'.dependencies]
+lazy_static = "1.4.0"
 winapi = { version = "0.3", features = ["winuser", "errhandlingapi", "processthreadsapi"] }
 
 [dev-dependencies]

README.md

@@ -77,6 +77,25 @@ fn main() {
 }
 ```
 
+### Keyboard state
+
+We can define a dummy Keyboard, that we will use to detect
+what kind of EventType trigger some String. We get the currently used
+layout for now !
+Caveat : This is layout dependent. If your app needs to support
+layout switching don't use this !
+Caveat: On Linux, the dead keys mechanism is not implemented.
+Caveat: Only shift and dead keys are implemented, Alt+unicode code on windows
+won't work.
+
+```rust
+use rdev::{Keyboard, EventType, Key, KeyboardState};
+
+let mut keyboard = Keyboard::new().unwrap();
+let string = keyboard.add(&EventType::KeyPress(Key::KeyS));
+// string == Some("s")
+```
+
 ### Grabbing global events.
 
 In the callback, returning None ignores the event

examples/keyboard_state.rs

@@ -0,0 +1,18 @@
+use rdev::{EventType, Key, Keyboard, KeyboardState};
+
+fn main() {
+    let mut keyboard = Keyboard::new().unwrap();
+    let char_s = keyboard.add(&EventType::KeyPress(Key::KeyS)).unwrap();
+    assert_eq!(char_s, "s".to_string());
+    println!("Pressing S gives: {:?}", char_s);
+    let n = keyboard.add(&EventType::KeyRelease(Key::KeyS));
+    assert_eq!(n, None);
+
+    keyboard.add(&EventType::KeyPress(Key::ShiftLeft));
+    let char_s = keyboard.add(&EventType::KeyPress(Key::KeyS)).unwrap();
+    println!("Pressing Shift+S gives: {:?}", char_s);
+    assert_eq!(char_s, "S".to_string());
+    let n = keyboard.add(&EventType::KeyRelease(Key::KeyS));
+    assert_eq!(n, None);
+    keyboard.add(&EventType::KeyRelease(Key::ShiftLeft));
+}

src/lib.rs

@@ -67,6 +67,25 @@
 //! assert!(h > 0);
 //! ```
 //!
+//! ### Keyboard state
+//!
+//! We can define a dummy Keyboard, that we will use to detect
+//! what kind of EventType trigger some String. We get the currently used
+//! layout for now !
+//! Caveat : This is layout dependent. If your app needs to support
+//! layout switching don't use this !
+//! Caveat: On Linux, the dead keys mechanism is not implemented.
+//! Caveat: Only shift and dead keys are implemented, Alt+unicode code on windows
+//! won't work.
+//!
+//! ```no_run
+//! use rdev::{Keyboard, EventType, Key, KeyboardState};
+//!
+//! let mut keyboard = Keyboard::new().unwrap();
+//! let string = keyboard.add(&EventType::KeyPress(Key::KeyS));
+//! // string == Some("s")
+//! ```
+//!
 //! ### Grabbing global events. (Requires `unstable_grab` feature)
 //!
 //! In the callback, returning None ignores the event
@@ -82,24 +101,28 @@
 //! Serialization and deserialization. (Requires `serialize` feature).
 mod rdev;
 pub use crate::rdev::{
-    Button, Callback, DisplayError, Event, EventType, GrabCallback, GrabError, Key, ListenError,
-    SimulateError,
+    Button, Callback, DisplayError, Event, EventType, GrabCallback, GrabError, Key, KeyboardState,
+    ListenError, SimulateError,
 };
 
 #[cfg(target_os = "macos")]
 mod macos;
 #[cfg(target_os = "macos")]
+pub use crate::macos::Keyboard;
+#[cfg(target_os = "macos")]
 use crate::macos::{display_size as _display_size, listen as _listen, simulate as _simulate};
 
 #[cfg(target_os = "linux")]
 mod linux;
-
+#[cfg(target_os = "linux")]
+pub use crate::linux::Keyboard;
 #[cfg(target_os = "linux")]
 use crate::linux::{display_size as _display_size, listen as _listen, simulate as _simulate};
 
 #[cfg(target_os = "windows")]
 mod windows;
-
+#[cfg(target_os = "windows")]
+pub use crate::windows::Keyboard;
 #[cfg(target_os = "windows")]
 use crate::windows::{display_size as _display_size, listen as _listen, simulate as _simulate};
 
@@ -216,3 +239,48 @@ pub use crate::windows::grab as _grab;
 pub fn grab(callback: GrabCallback) -> Result<(), GrabError> {
     _grab(callback)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_keyboard_state() {
+        // S
+        let mut keyboard = Keyboard::new().unwrap();
+        let char_s = keyboard.add(&EventType::KeyPress(Key::KeyS)).unwrap();
+        assert_eq!(
+            char_s,
+            "s".to_string(),
+            "This test should pass only on Qwerty layout !"
+        );
+        let n = keyboard.add(&EventType::KeyRelease(Key::KeyS));
+        assert_eq!(n, None);
+
+        // Shift + S
+        keyboard.add(&EventType::KeyPress(Key::ShiftLeft));
+        let char_s = keyboard.add(&EventType::KeyPress(Key::KeyS)).unwrap();
+        assert_eq!(char_s, "S".to_string());
+        let n = keyboard.add(&EventType::KeyRelease(Key::KeyS));
+        assert_eq!(n, None);
+        keyboard.add(&EventType::KeyRelease(Key::ShiftLeft));
+
+        // Reset
+        keyboard.add(&EventType::KeyPress(Key::ShiftLeft));
+        keyboard.reset();
+        let char_s = keyboard.add(&EventType::KeyPress(Key::KeyS)).unwrap();
+        assert_eq!(char_s, "s".to_string());
+        let n = keyboard.add(&EventType::KeyRelease(Key::KeyS));
+        assert_eq!(n, None);
+        keyboard.add(&EventType::KeyRelease(Key::ShiftLeft));
+
+        // UsIntl layout required
+        // let n = keyboard.add(&EventType::KeyPress(Key::Quote));
+        // assert_eq!(n, Some("".to_string()));
+        // let m = keyboard.add(&EventType::KeyRelease(Key::Quote));
+        // assert_eq!(m, None);
+        // let e = keyboard.add(&EventType::KeyPress(Key::KeyE)).unwrap();
+        // assert_eq!(e, "é".to_string());
+        // keyboard.add(&EventType::KeyRelease(Key::KeyE));
+    }
+}

src/linux/common.rs

@@ -1,4 +1,4 @@
-use crate::linux::keyboard_state::KeyboardState;
+use crate::linux::keyboard::Keyboard;
 use crate::linux::keycodes::key_from_code;
 use crate::rdev::{Button, Event, EventType};
 use std::convert::TryInto;
@@ -55,7 +55,7 @@ pub fn convert(code: c_uint, state: c_uint, type_: c_int, x: f64, y: f64) -> Opt
         let event_type = convert_event(code as c_uchar, type_, x, y)?;
         let name = match event_type {
             EventType::KeyPress(_) => {
-                KeyboardState::new().map(|mut kboard| kboard.name_from_code(code, state))
+                Keyboard::new().map(|mut kboard| kboard.name_from_code(code, state))
             }
             _ => None,
         }

src/linux/keyboard_state.rs renamed to src/linux/keyboard.rs

@@ -1,31 +1,75 @@
 extern crate x11;
+use crate::linux::keycodes::code_from_key;
+use crate::rdev::{EventType, Key, KeyboardState};
 use std::ffi::CString;
 use std::os::raw::{c_char, c_int, c_uchar, c_uint, c_void};
 use std::ptr::{null, null_mut, NonNull};
 use x11::xlib;
 
+#[derive(Debug)]
+struct State {
+    alt: bool,
+    ctrl: bool,
+    caps_lock: bool,
+    shift: bool,
+    meta: bool,
+}
+
 // Inspired from https://github.com/wavexx/screenkey
 // But without remitting events to custom windows, instead we recreate  XKeyEvent
 // from xEvent data received via xrecord.
 // Other source of inspiration https://gist.github.com/baines/5a49f1334281b2685af5dcae81a6fa8a
 // Needed xproto crate as x11 does not implement _xevent.
+impl State {
+    fn new() -> State {
+        State {
+            alt: false,
+            ctrl: false,
+            caps_lock: false,
+            meta: false,
+            shift: false,
+        }
+    }
+
+    fn value(&self) -> c_uint {
+        let mut res: c_uint = 0;
+        if self.alt {
+            res += xlib::Mod1Mask;
+        }
+        if self.ctrl {
+            res += xlib::ControlMask;
+        }
+        if self.caps_lock {
+            res += xlib::LockMask;
+        }
+        if self.meta {
+            res += xlib::Mod4Mask;
+        }
+        if self.shift {
+            res += xlib::ShiftMask;
+        }
+        res
+    }
+}
+
 #[derive(Debug)]
-pub struct KeyboardState {
+pub struct Keyboard {
     pub xic: Box<xlib::XIC>,
     pub display: Box<*mut xlib::Display>,
     keysym: Box<u64>,
     status: Box<i32>,
+    state: State,
 }
-impl Drop for KeyboardState {
+impl Drop for Keyboard {
     fn drop(&mut self) {
         unsafe {
             xlib::XCloseDisplay(*self.display);
         }
     }
 }
 
-impl KeyboardState {
-    pub fn new() -> Option<KeyboardState> {
+impl Keyboard {
+    pub fn new() -> Option<Keyboard> {
         unsafe {
             let dpy = xlib::XOpenDisplay(null());
             if dpy.is_null() {
@@ -81,16 +125,21 @@ impl KeyboardState {
                 null::<c_void>(),
             );
             NonNull::new(xic)?;
-            Some(KeyboardState {
+            Some(Keyboard {
                 xic: Box::new(xic),
                 display: Box::new(dpy),
                 keysym: Box::new(0),
                 status: Box::new(0),
+                state: State::new(),
             })
         }
     }
 
-    pub unsafe fn name_from_code(&mut self, keycode: c_uint, state: c_uint) -> Option<String> {
+    pub(crate) unsafe fn name_from_code(
+        &mut self,
+        keycode: c_uint,
+        state: c_uint,
+    ) -> Option<String> {
         if self.display.is_null() || self.xic.is_null() {
             println!("We don't seem to have a display or a xic");
             return None;
@@ -127,3 +176,36 @@ impl KeyboardState {
         String::from_utf8(buf[..len].to_vec()).ok()
     }
 }
+
+impl KeyboardState for Keyboard {
+    fn add(&mut self, event_type: &EventType) -> Option<String> {
+        match event_type {
+            EventType::KeyPress(key) => match key {
+                Key::ShiftLeft | Key::ShiftRight => {
+                    self.state.shift = true;
+                    None
+                }
+                Key::CapsLock => {
+                    self.state.caps_lock = !self.state.caps_lock;
+                    None
+                }
+                key => {
+                    let keycode = code_from_key(*key)?;
+                    let state = self.state.value();
+                    unsafe { self.name_from_code(keycode, state) }
+                }
+            },
+            EventType::KeyRelease(key) => match key {
+                Key::ShiftLeft | Key::ShiftRight => {
+                    self.state.shift = false;
+                    None
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+    fn reset(&mut self) {
+        self.state = State::new();
+    }
+}

src/linux/mod.rs

@@ -5,13 +5,14 @@ mod common;
 mod display;
 #[cfg(feature = "unstable_grab")]
 mod grab;
-mod keyboard_state;
+mod keyboard;
 mod keycodes;
 mod listen;
 mod simulate;
 
 pub use crate::linux::display::display_size;
 #[cfg(feature = "unstable_grab")]
 pub use crate::linux::grab::grab;
+pub use crate::linux::keyboard::Keyboard;
 pub use crate::linux::listen::listen;
 pub use crate::linux::simulate::simulate;

src/macos/common.rs

@@ -1,9 +1,11 @@
-use crate::macos::keyboard_state::KeyboardState;
+use crate::macos::keyboard::Keyboard;
 use crate::rdev::{Button, Event, EventType};
 use cocoa::base::id;
 use core_graphics::event::{CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, EventField};
+use lazy_static::lazy_static;
 use std::convert::TryInto;
 use std::os::raw::c_void;
+use std::sync::Mutex;
 use std::time::SystemTime;
 
 use crate::macos::keycodes::key_from_code;
@@ -32,7 +34,9 @@ pub enum CGEventTapOption {
 }
 
 pub static mut LAST_FLAGS: CGEventFlags = CGEventFlags::CGEventFlagNull;
-pub static mut KEYBOARD_STATE: KeyboardState = KeyboardState { dead_state: 0 };
+lazy_static! {
+    pub static ref KEYBOARD_STATE: Mutex<Keyboard> = Mutex::new(Keyboard::new().unwrap());
+}
 
 // https://developer.apple.com/documentation/coregraphics/cgeventmask?language=objc
 pub type CGEventMask = u64;
@@ -84,7 +88,7 @@ pub type QCallback = unsafe extern "C" fn(
 pub unsafe fn convert(
     _type: CGEventType,
     cg_event: &CGEvent,
-    keyboard_state: &mut KeyboardState,
+    keyboard_state: &mut Keyboard,
 ) -> Option<Event> {
     let option_type = match _type {
         CGEventType::LeftMouseDown => Some(EventType::ButtonPress(Button::Left)),

src/macos/grab.rs

@@ -19,9 +19,12 @@ unsafe extern "C" fn raw_callback(
 ) -> CGEventRef {
     // println!("Event ref {:?}", cg_event_ptr);
     // let cg_event: CGEvent = transmute_copy::<*mut c_void, CGEvent>(&cg_event_ptr);
-    if let Some(event) = convert(_type, &cg_event, &mut KEYBOARD_STATE) {
-        if GLOBAL_CALLBACK(event).is_none() {
-            cg_event.set_type(CGEventType::Null);
+    let opt = KEYBOARD_STATE.lock();
+    if let Ok(mut keyboard) = opt {
+        if let Some(event) = convert(_type, &cg_event, &mut keyboard) {
+            if GLOBAL_CALLBACK(event).is_none() {
+                cg_event.set_type(CGEventType::Null);
+            }
         }
     }
     cg_event