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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Gets keyboard events dynamically.

pub use super::event_broker::Filter;

use hookmap_core::event::{ButtonEvent, NativeEventOperation};

use super::event_broker::EventBroker;

use std::sync::Arc;
use std::sync::Mutex;

use once_cell::sync::Lazy;

static BROKER: Lazy<Mutex<EventBroker>> = Lazy::new(Mutex::default);

pub(super) fn publish_event(event: ButtonEvent) -> NativeEventOperation {
    BROKER.lock().unwrap().publish(event)
}

/// Set the hook that receives input events;
///
/// # Examples
///
/// ```no_run
/// use hookmap::prelude::*;
///
/// let filter = Filter::new().action(ButtonAction::Press);
/// let event = Interceptor::dispatch(filter).get();
/// println!("{:?}, {:?}", event.target, event.action);
/// ```
///
pub struct Interceptor {
    filter: Arc<Filter>,
    native_event_operation: NativeEventOperation,
}

impl Interceptor {
    /// Creates a new instance of [`Interceptor`].
    /// Captured events are blocked.
    ///
    /// ```no_run
    /// use hookmap::prelude::*;
    ///
    /// let filter = Filter::new();
    /// let event = Interceptor::blocking(filter).get();
    /// println!("This event is blocked: {:?}", event);
    /// ```
    ///
    pub fn blocking(filter: Filter) -> Self {
        Self {
            filter: Arc::new(filter),
            native_event_operation: NativeEventOperation::Block,
        }
    }

    /// Creates a new instance of [`Interceptor`].
    /// Captured events are not blocked.
    ///
    /// ```no_run
    /// use hookmap::prelude::*;
    ///
    /// let filter = Filter::new();
    /// let event = Interceptor::dispatch(filter).get();
    /// println!("This event is blocked: {:?}", event);
    /// ```
    ///
    pub fn dispatch(filter: Filter) -> Self {
        Self {
            filter: Arc::new(filter),
            native_event_operation: NativeEventOperation::Dispatch,
        }
    }

    /// Captures a single event.
    ///
    /// ```no_run
    /// use hookmap::prelude::*;
    ///
    /// let filter = Filter::new();
    /// let event = Interceptor::dispatch(filter).get();
    /// println!("{:?}", event);
    /// ```
    pub fn get(&self) -> ButtonEvent {
        let rx = BROKER
            .lock()
            .unwrap()
            .subscribe_once(Arc::clone(&self.filter), self.native_event_operation);

        rx.recv().unwrap()
    }

    /// Captures events with an iterator.
    ///
    /// ```no_run
    /// use hookmap::prelude::*;
    ///
    /// let filter = Filter::new();
    /// let keys: Vec<Button> = Interceptor::blocking(filter)
    ///     .iter()
    ///     .filter(|e| e.action == ButtonAction::Press)
    ///     .take(3)
    ///     .map(|e| e.target)
    ///     .collect();
    /// ```
    ///
    pub fn iter(&self) -> Iter {
        Iter {
            filter: Arc::clone(&self.filter),
            native_event_operation: self.native_event_operation,
        }
    }
}

pub struct Iter {
    filter: Arc<Filter>,
    native_event_operation: NativeEventOperation,
}

impl Iterator for Iter {
    type Item = ButtonEvent;

    fn next(&mut self) -> Option<ButtonEvent> {
        let rx = BROKER
            .lock()
            .unwrap()
            .subscribe_once(Arc::clone(&self.filter), self.native_event_operation);

        rx.recv().ok()
    }
}