hookmap 0.5.1

Registers hotkeys and simulates keyboard and mouse input.
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

mod button_state;
mod event_broker;
pub mod interceptor;

use hookmap_core::event::{Event, NativeEventHandler, NativeEventOperation};

use self::button_state::RealButtonState;
use crate::hook::{ButtonState, Hook, HookStorage};

use std::thread;

#[derive(Debug)]
pub(crate) struct Runtime<T, S: ButtonState = RealButtonState>
where
    T: HookStorage + Send + 'static,
    <T as HookStorage>::ButtonHook: Send,
    <T as HookStorage>::MouseWheelHook: Send,
    <T as HookStorage>::MouseCursorHook: Send,
{
    storage: T,
    state: S,
}

impl<T> Runtime<T, RealButtonState>
where
    T: HookStorage + Send,
    <T as HookStorage>::ButtonHook: Send,
    <T as HookStorage>::MouseWheelHook: Send,
    <T as HookStorage>::MouseCursorHook: Send,
{
    pub(crate) fn new(storage: T) -> Self {
        Self::with_state(storage, RealButtonState)
    }
}

impl<T, S: ButtonState> Runtime<T, S>
where
    T: HookStorage + Send + 'static,
    <T as HookStorage>::ButtonHook: Send,
    <T as HookStorage>::MouseWheelHook: Send,
    <T as HookStorage>::MouseCursorHook: Send,
{
    pub(crate) fn with_state(storage: T, state: S) -> Self {
        Self { storage, state }
    }

    fn handle_event<F, E, H>(&self, fetch: F, event: E, native_handler: NativeEventHandler)
    where
        F: FnOnce(&T, E, &S) -> Vec<H>,
        E: Copy + Send + 'static,
        H: Hook<E> + Send + 'static,
    {
        let hooks = fetch(&self.storage, event, &self.state);
        let has_block_operation = hooks
            .iter()
            .map(|hook| hook.native_event_operation())
            .any(|operation| operation == NativeEventOperation::Block);
        let operation = if has_block_operation {
            NativeEventOperation::Block
        } else {
            NativeEventOperation::Dispatch
        };
        native_handler.handle(operation);
        thread::spawn(move || hooks.iter().for_each(|hook| hook.run(event)));
    }

    pub(crate) fn start(&self) {
        let event_receiver = hookmap_core::install_hook();

        while let Ok((event, native_handler)) = event_receiver.recv() {
            match event {
                Event::Button(event) => {
                    if interceptor::publish_event(event) == NativeEventOperation::Block {
                        native_handler.block();
                        continue;
                    }
                    self.handle_event(HookStorage::fetch_button_hook, event, native_handler);
                }
                Event::Wheel(event) => {
                    self.handle_event(HookStorage::fetch_mouse_wheel_hook, event, native_handler);
                }
                Event::Cursor(event) => {
                    self.handle_event(HookStorage::fetch_mouse_cursor_hook, event, native_handler);
                }
            }
        }
    }
}