srhd 0.4.0

A lightweight hotkey daemon for MacOS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use rdev::GrabError;

use crate::config::{Binding, Config, Key};
use std::sync::{Arc, Mutex};

pub struct HeldKeys {
    pub command: bool,
    pub control: bool,
    pub shift: bool,
    pub option: bool,
    pub function: bool,
    pub capslock: bool,
    pub key: Option<rdev::Key>,
}

impl HeldKeys {
    fn new() -> Self {
        HeldKeys {
            command: false,
            control: false,
            shift: false,
            option: false,
            function: false,
            capslock: false,
            key: None,
        }
    }

    /// Checks if the binding is pressed, clean this up
    pub fn binding_pressed(&self, binding: &Binding) -> bool {
        let test: HeldKeys = binding.into();
        if test.key != self.key {
            return false;
        }

        if test.command != self.command {
            return false;
        }

        if test.control != self.control {
            return false;
        }

        if test.shift != self.shift {
            return false;
        }

        if test.option != self.option {
            return false;
        }

        true
    }

    fn toggle(&mut self, key: rdev::Key, is: bool) {
        use rdev::Key::*;
        match key {
            ControlLeft | ControlRight => self.control = is,
            ShiftLeft | ShiftRight => self.shift = is,
            MetaLeft | MetaRight => self.command = is,
            Alt | AltGr => self.option = is,
            Function => self.function = is,
            CapsLock => self.capslock = is,
            other if is => self.key = Some(other),
            _ => self.key = None,
        };
    }
}
/// Starts the main event loop for the listener
pub fn srhd_process(debug: bool) {
    let config = Config::load();
    let keys = Arc::new(Mutex::new(HeldKeys::new()));
    use rdev::{grab, Event};

    let callback = move |event: Event| -> Option<Event> {
        let mut keys = keys.lock().unwrap();

        match event.event_type {
            rdev::EventType::KeyRelease(key) => {
                keys.toggle(key, false);
                return Some(event);
            }
            rdev::EventType::KeyPress(key) => {
                keys.toggle(key, true);
                if config.execute_command(&keys) {
                    return None;
                }

                if debug {
                    let db: Key = key.into();
                    println!("{}", db);
                }

                return Some(event);
            }
            _ => return Some(event),
        }
    };

    if let Err(error) = grab(callback) {
        match error {
            GrabError::EventTapError => {
                eprintln!("Failed to listen to keys, you may need to re-enable the accessibility settings on your terminal emulator");
            }
            _ => {
                eprintln!("Error: {:?}", error);
            }
        }
    }
}