monio 0.1.1

Pure Rust cross-platform input monitoring library with proper drag detection
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

//! Event recorder example - record and playback macros.
//!
//! Usage:
//!   cargo run --example recorder --features recorder -- record macro.json
//!   cargo run --example recorder --features recorder -- playback macro.json
//!   cargo run --example recorder --features recorder -- playback-fast macro.json

use std::env;
use std::time::Duration;

#[cfg(feature = "recorder")]
use monio::{EventRecorder, Recording};

fn main() -> monio::Result<()> {
    #[cfg(not(feature = "recorder"))]
    {
        eprintln!("This example requires the 'recorder' feature.");
        eprintln!("Run with: cargo run --example recorder --features recorder -- ...");
        std::process::exit(1);
    }

    #[cfg(feature = "recorder")]
    {
        let args: Vec<String> = env::args().collect();

        if args.len() < 3 {
            println!("Usage:");
            println!("  {} record <filename>   - Record for 5 seconds", args[0]);
            println!(
                "  {} playback <filename>  - Playback with original timing",
                args[0]
            );
            println!(
                "  {} playback-fast <filename> - Playback as fast as possible",
                args[0]
            );
            return Ok(());
        }

        let command = &args[1];
        let filename = &args[2];

        match command.as_str() {
            "record" => {
                println!("Recording for 5 seconds...");
                println!("Perform some keyboard and mouse actions!");

                let recording = EventRecorder::record_for(Duration::from_secs(5))?;

                println!("\nRecording complete!");
                println!("Total events: {}", recording.event_count());
                println!("Duration: {:?}", recording.duration());

                recording.save(filename)?;
                println!("Saved to: {}", filename);
            }
            "playback" => {
                let recording = Recording::load(filename)?;
                println!("Playing back {} events...", recording.event_count());
                println!("Press Ctrl+C to stop");

                recording.playback()?;
                println!("Playback complete!");
            }
            "playback-fast" => {
                let recording = Recording::load(filename)?;
                println!(
                    "Playing back {} events (fast mode)...",
                    recording.event_count()
                );

                recording.playback_fast()?;
                println!("Playback complete!");
            }
            _ => {
                eprintln!("Unknown command: {}", command);
            }
        }
    }

    Ok(())
}