rshotkey 0.1.1

A Hotkey tracker and handler
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
131
132
133
134

#![allow(unused)]
use rshotkey::key::{BindKey, KeySet};
use rshotkey::listener::{HookResult, Listener};
use rshotkey::rdev::{Button, EventType, Key};

use anyhow::Result;
use futures::FutureExt;
use std::process;
use std::time::Duration;
use tokio::time;

fn clicked() -> HookResult {
    async move {
        println!("左键被按下");
        Ok(())
    }
    .boxed()
}

fn press_c() -> HookResult {
    async move {
        println!("C被按下");
        Ok(())
    }
    .boxed()
}

fn press_ctrl_d() -> HookResult {
    async move {
        println!("Ctrl+D被按下");
        Ok(())
    }
    .boxed()
}

fn double_clicked() -> HookResult {
    async move {
        println!("鼠标双击");
        Ok(())
    }
    .boxed()
}

#[tokio::main]
async fn main() -> Result<()> {
    env_logger::init();

    let c: KeySet = BindKey::new(vec![EventType::KeyPress(Key::KeyC)]).into();
    let ctrl_d_press: KeySet = BindKey::new(vec![
        EventType::KeyPress(Key::KeyD),
        EventType::KeyPress(Key::ControlLeft),
    ])
    .into();
    let ctrl_d_release = KeySet::default().bind(BindKey::new(vec![
        EventType::KeyRelease(Key::KeyD),
        EventType::KeyRelease(Key::ControlLeft),
    ]));
    let ctrl_d = KeySet::default()
        .bind(BindKey::new(vec![
            EventType::KeyPress(Key::KeyD),
            EventType::KeyPress(Key::ControlLeft),
        ]))
        .bind(BindKey::new(vec![
            EventType::KeyRelease(Key::KeyD),
            EventType::KeyRelease(Key::ControlLeft),
        ]));

    let left_click_once: KeySet = BindKey::new(vec![EventType::ButtonPress(Button::Left)])
        .delay(Duration::from_secs_f64(1.0))
        .into();

    let delay_click = KeySet::default()
        .bind(
            BindKey::new(vec![EventType::ButtonPress(Button::Left)])
                .delay(Duration::from_secs_f64(0.2)),
        )
        .bind(BindKey::new(vec![EventType::ButtonRelease(Button::Left)]));

    let double_click = KeySet::default()
        .bind(
            BindKey::new(vec![
                EventType::ButtonPress(Button::Left),
                EventType::ButtonRelease(Button::Left),
            ])
            .delay(Duration::from_secs_f64(0.2)),
        )
        .bind(BindKey::new(vec![EventType::ButtonPress(Button::Left)]));

    let listener = Listener::default();
    listener.register(c, press_c).await?;
    listener.register(ctrl_d_press, press_ctrl_d).await?;
    listener
        .register(ctrl_d_release, move || {
            async move {
                println!("Ctrl_D 被释放！");
                Ok(())
            }
            .boxed()
        })
        .await?;
    listener
        .register(ctrl_d, move || {
            async move {
                println!("完整的 Ctrl_D 过程！");
                Ok(())
            }
            .boxed()
        })
        .await?;

    listener.register(left_click_once, clicked).await?;
    listener
        .register(delay_click, move || {
            async move {
                println!("鼠标单击后在 0.2s 内释放！");
                Ok(())
            }
            .boxed()
        })
        .await?;
    listener.register(double_click, double_clicked).await?;

    let runner = listener.listen();

    time::sleep(Duration::from_secs(5)).await;

    println!("上一个键: {:?}", listener.priorkey().await);

    runner.await?;

    tokio::signal::ctrl_c().await?;

    process::exit(0);
}