willhook 0.6.3

Capture all keyboard and mouse input regardless of application focus on the active windows desktop
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

use std::sync::Mutex;
use std::sync::mpsc::{channel, Receiver, Sender};

use crate::event::*;

pub struct HookChannels {
    keyboard_sender: Mutex<Sender<InputEvent>>,
    mouse_sender: Mutex<Sender<InputEvent>>,
    receiver: Mutex<Receiver<InputEvent>>,
}

impl HookChannels {
    pub fn new() -> HookChannels {
        let (s, r) = channel();
        HookChannels {
            keyboard_sender: Mutex::new(s.clone()),
            mouse_sender: Mutex::new(s.clone()),
            receiver: Mutex::new(r),
        }
    }

    pub fn send_keyboard_event(&self, ke: KeyboardEvent) -> Result<(), std::sync::mpsc::SendError<InputEvent>> {
        self.keyboard_sender.lock().unwrap().send(InputEvent::Keyboard(ke))
    }

    pub fn send_mouse_event(&self, me: MouseEvent) -> Result<(), std::sync::mpsc::SendError<InputEvent>>  {
        self.mouse_sender.lock().unwrap().send(InputEvent::Mouse(me))
    }

    pub fn recv(&self) -> Result<InputEvent, std::sync::mpsc::RecvError> {
        self.receiver.lock().unwrap().recv()
    }

    pub fn try_recv(&self) -> Result<InputEvent, std::sync::mpsc::TryRecvError> {
        self.receiver.lock().unwrap().try_recv()
    }

    pub fn drain(&self) {
        let guarded = self.receiver.lock().unwrap();
        let r: &Receiver<InputEvent> = &*guarded;
        while let Ok(_) = r.try_recv() {}
    }
}