typechar 1.0.0

Type any Unicode string on macOS, regardless of keyboard layout
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

#[cfg(not(target_os = "macos"))]
compile_error!("typechar only works on macOS — it types characters via CoreGraphics events");

use std::thread::sleep;
use std::time::Duration;

use core_graphics::event::{CGEvent, CGEventTapLocation};
use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
use typechar::{Action, parse_args, utf16_chunks};

/// CGEventKeyboardSetUnicodeString silently truncates long strings; 20 UTF-16
/// code units per event is the documented-by-folklore safe limit.
const MAX_UNITS_PER_EVENT: usize = 20;

// Not exposed by the core-graphics crate; resolved from the already-linked
// CoreGraphics framework.
unsafe extern "C" {
    fn CGPreflightPostEventAccess() -> bool;
    fn CGRequestPostEventAccess() -> bool;
}

const USAGE: &str = "\
typechar — type any Unicode string, regardless of keyboard layout

Usage:
  typechar [OPTIONS] <string>
  typechar [OPTIONS] --unicode <hex> [--unicode <hex>...]

Options:
  -u, --unicode <hex>  Codepoint to type, e.g. 20ac or U+20AC (repeatable)
  -d, --delay <ms>     Wait before typing (for apps that drop fast events)
  -h, --help           Show this help
  -V, --version        Show version

Examples:
  typechar €
  typechar --unicode 20ac
  typechar --delay 100 '¯\\_(ツ)_/¯'";

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    match parse_args(&args) {
        Ok(Action::Help) => println!("{USAGE}"),
        Ok(Action::Version) => println!("typechar {}", env!("CARGO_PKG_VERSION")),
        Ok(Action::Type { text, delay_ms }) => {
            if delay_ms > 0 {
                sleep(Duration::from_millis(delay_ms));
            }
            if let Err(msg) = type_text(&text) {
                eprintln!("typechar: {msg}");
                std::process::exit(1);
            }
        }
        Err(msg) => {
            eprintln!("typechar: {msg}\n\n{USAGE}");
            std::process::exit(2);
        }
    }
}

fn type_text(text: &str) -> Result<(), String> {
    if !unsafe { CGPreflightPostEventAccess() } {
        unsafe { CGRequestPostEventAccess() };
        return Err("no permission to post keyboard events.\n\
             Grant Accessibility access to the app that runs typechar (your terminal, \
             Karabiner, skhd, ...) in System Settings → Privacy & Security → Accessibility, \
             then try again."
            .into());
    }

    let source = CGEventSource::new(CGEventSourceStateID::HIDSystemState)
        .map_err(|_| "failed to create event source".to_string())?;

    for chunk in utf16_chunks(text, MAX_UNITS_PER_EVENT) {
        for key_down in [true, false] {
            let event = CGEvent::new_keyboard_event(source.clone(), 0, key_down)
                .map_err(|_| "failed to create keyboard event".to_string())?;
            event.set_string_from_utf16_unchecked(&chunk);
            event.post(CGEventTapLocation::HID);
        }
        // Give the WindowServer a beat between chunks so long strings arrive in order.
        sleep(Duration::from_millis(1));
    }
    Ok(())
}