Struct Keyboard 

pub struct Keyboard { /* private fields */ }

Virtual keyboard that injects keystrokes via uinput, or via XTEST on X11 (see [Keyboard::new_xtest]).

Implementations

impl Keyboard

pub fn new(key_delay: Duration) -> Result<Self>

Create a new virtual keyboard with auto-detected layout and clipboard.

This is the most ergonomic constructor: it picks up the active XKB layout from the compositor (Hyprland / Sway / env vars), picks the right clipboard backend for the current display server, and builds the uinput device.

key_delay is the inter-event delay. Raise it for TUIs that drop characters in raw mode (e.g. Node/Ink-based apps like Claude Code).

Requires write access to /dev/uinput.

For full control over keymap/clipboard, see Keyboard::with_components; to force a specific XKB layout, see Keyboard::with_layout.

pub fn new_prewarm(key_delay: Duration) -> Result<Self>

Like Keyboard::new, but uses a longer post-creation settle delay suited for the first virtual keyboard created in a process. Call this from a startup prewarm so X11 has time to process MappingNotify and attach the new device’s keymap before any character is typed.

Subsequent recreates (e.g. on error recovery) should keep using Keyboard::new, which uses a shorter settle so the user’s typing path is not stalled by 1s on every recovery.

pub fn with_layout( layout: &str, variant: Option<&str>, key_delay: Duration, ) -> Result<Self>

Create a virtual keyboard for a specific XKB layout (and optional variant), with the auto-detected clipboard backend.

Useful when the application already knows the user’s layout and wants to skip the compositor probe (e.g. it’s stored in a config file).

pub fn with_components( keymap: XkbKeymap, clipboard: Box<dyn ClipboardBackend>, key_delay: Duration, ) -> Result<Self>

Create a virtual keyboard from explicit components (keymap + clipboard backend).

Use this when you need to inject a custom XkbKeymap (e.g. for tests) or a non-default clipboard backend (crate::NoopClipboard / crate::WaylandClipboard / crate::X11Clipboard).

Requires write access to /dev/uinput (user must be in the input group or have the appropriate udev rule installed).

key_delay is the inter-event delay. Raise it for TUIs that drop characters in raw mode (e.g. Node/Ink-based apps like Claude Code).

pub fn set_key_delay(&mut self, key_delay: Duration)

pub fn type_text(&mut self, text: &str) -> Result<()>

Type text by injecting keystrokes through the virtual device.

Characters found in the keymap are typed via direct key events (with Shift/AltGr modifiers as needed, including dead-key sequences). Characters not found in the keymap are accumulated and pasted as a batch via the clipboard (Ctrl+V), with clipboard save/restore so the user’s clipboard is not permanently overwritten.

Types everything; Keyboard::type_text_gated (and crate::KeyInjector::type_text) can pause or stop between keys.

pub fn type_text_gated( &mut self, text: &str, gate: &mut dyn FnMut(usize) -> ControlFlow<()>, ) -> Result<Typed>

Keyboard::type_text, asking gate before every key tap and before every clipboard paste, with the byte offset of the next unsent character (for a paste, the first character of the run). A dead key and its base letter are one character: asked about once, never split. On ControlFlow::Break nothing more is sent, the events sent so far are flushed, and the result is Typed::StoppedAt that offset. See crate::KeyInjector::type_text.

pub fn backspace(&mut self, count: usize) -> Result<()>

Emit Backspace count times.

pub fn send_combo(&mut self, keys: &[Key]) -> Result<()>

Press all keys in keys, then release them in reverse order.

Each press and release is separated by self.key_delay.

Trait Implementations

impl KeyInjector for Keyboard

fn type_text( &mut self, text: &str, gate: &mut dyn FnMut(usize) -> ControlFlow<()>, ) -> Result<Typed>

Type text by injecting the corresponding keystrokes, asking gate before each one.

fn backspace(&mut self, count: usize) -> Result<()>

Emit Backspace count times.

fn send_combo(&mut self, keys: &[Key]) -> Result<()>

Press all keys in keys, then release them in reverse order.

fn set_key_delay(&mut self, delay: Duration)

Set the inter-event delay used between injected key events.