Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.
// SPDX-License-Identifier: GPL-3.0-or-later
//! Synthesizes mouse and keyboard input on Linux for a paired phone acting as
//! a touchpad, keyboard, or presentation remote (`docs/protocol/remote.md`),
//! as well as reverse PC mirror touch injection.
//!
//! Input backends are tried in order of lowest overhead and broadest display-server
//! support:
//! 1. In-process `/dev/uinput` virtual input device (works on both X11 and Wayland).
//! 2. On Wayland: in-process `org.freedesktop.portal.RemoteDesktop` D-Bus session.
//! 3. On X11 / XWayland: in-process `libX11.so.6` + `libXtst.so.6` (`XTest`).
//! 4. Subprocess fallbacks (`ydotool`, `wtype`, `xdotool`), piping text via stdin
//! so typed strings never appear in `/proc/<pid>/cmdline`.
use std::{
collections::HashMap,
ffi::{CStr, CString, c_char, c_int, c_uint, c_ulong, c_void},
io::Write,
process::{Command, Stdio},
sync::{Mutex, OnceLock},
};
use nectarlink_core::{ButtonAction, KeyMod, MouseButton, PowerAction, SlideAction, TouchAction};
// ---- Linux `/dev/uinput` kernel ABI constants ----
const EV_SYN: u16 = 0x00;
const EV_KEY: u16 = 0x01;
const EV_REL: u16 = 0x02;
const SYN_REPORT: u16 = 0x00;
const REL_X: u16 = 0x00;
const REL_Y: u16 = 0x01;
const REL_HWHEEL: u16 = 0x06;
const REL_WHEEL: u16 = 0x08;
const BTN_LEFT: u16 = 0x110;
const BTN_RIGHT: u16 = 0x111;
const BTN_MIDDLE: u16 = 0x112;
const BUS_USB: u16 = 0x03;
const UI_DEV_CREATE: c_ulong = 0x5501;
const UI_DEV_DESTROY: c_ulong = 0x5502;
const UI_DEV_SETUP: c_ulong = 0x405c_5503;
const UI_SET_EVBIT: c_ulong = 0x4004_5564;
const UI_SET_KEYBIT: c_ulong = 0x4004_5565;
const UI_SET_RELBIT: c_ulong = 0x4004_5566;
#[repr(C)]
struct InputId {
bustype: u16,
vendor: u16,
product: u16,
version: u16,
}
#[repr(C)]
struct UinputSetup {
id: InputId,
name: [u8; 80],
ff_effects_max: u32,
}
#[repr(C)]
struct InputEvent {
tv_sec: libc::time_t,
tv_usec: libc::suseconds_t,
type_: u16,
code: u16,
value: i32,
}
struct UinputDevice {
fd: c_int,
}
impl UinputDevice {
fn open() -> Option<Self> {
let paths = [c"/dev/uinput", c"/dev/input/uinput"];
let mut fd = -1;
for path in paths {
// SAFETY: `path` is a valid null-terminated C string.
let opened =
unsafe { libc::open(path.as_ptr(), libc::O_WRONLY | libc::O_NONBLOCK | libc::O_CLOEXEC) };
if opened >= 0 {
fd = opened;
break;
}
}
if fd < 0 {
return None;
}
// SAFETY: `fd` is an open `/dev/uinput` descriptor; ioctl configures supported event bits.
unsafe {
if libc::ioctl(fd, UI_SET_EVBIT, c_int::from(EV_SYN)) < 0
|| libc::ioctl(fd, UI_SET_EVBIT, c_int::from(EV_KEY)) < 0
|| libc::ioctl(fd, UI_SET_EVBIT, c_int::from(EV_REL)) < 0
{
let _ = libc::close(fd);
return None;
}
for rel in [REL_X, REL_Y, REL_WHEEL, REL_HWHEEL] {
if libc::ioctl(fd, UI_SET_RELBIT, c_int::from(rel)) < 0 {
let _ = libc::close(fd);
return None;
}
}
for btn in [BTN_LEFT, BTN_RIGHT, BTN_MIDDLE] {
if libc::ioctl(fd, UI_SET_KEYBIT, c_int::from(btn)) < 0 {
let _ = libc::close(fd);
return None;
}
}
for key in 1..=248 {
let _ = libc::ioctl(fd, UI_SET_KEYBIT, key as c_int);
}
let mut setup = UinputSetup {
id: InputId { bustype: BUS_USB, vendor: 0x1d6b, product: 0x0104, version: 1 },
name: [0u8; 80],
ff_effects_max: 0,
};
let dev_name = b"NectarLink Virtual Input";
setup.name[..dev_name.len()].copy_from_slice(dev_name);
if libc::ioctl(fd, UI_DEV_SETUP, &setup) < 0 || libc::ioctl(fd, UI_DEV_CREATE) < 0 {
let _ = libc::close(fd);
return None;
}
}
Some(Self { fd })
}
fn emit(&self, type_: u16, code: u16, value: i32) -> bool {
let ev = InputEvent { tv_sec: 0, tv_usec: 0, type_, code, value };
let size = std::mem::size_of::<InputEvent>();
// SAFETY: `ev` is a repr(C) `input_event` struct written atomically to `self.fd`.
let written = unsafe { libc::write(self.fd, (&raw const ev).cast::<c_void>(), size) };
written == size as isize
}
fn syn(&self) -> bool {
self.emit(EV_SYN, SYN_REPORT, 0)
}
fn move_relative(&self, dx: i32, dy: i32) -> bool {
let mut ok = true;
if dx != 0 {
ok &= self.emit(EV_REL, REL_X, dx);
}
if dy != 0 {
ok &= self.emit(EV_REL, REL_Y, dy);
}
ok && self.syn()
}
fn button(&self, btn: u16, down: bool) -> bool {
self.emit(EV_KEY, btn, i32::from(down)) && self.syn()
}
fn scroll(&self, nx: i32, ny: i32) -> bool {
let mut ok = true;
if ny != 0 {
// In evdev, positive REL_WHEEL is scroll up; our `ny > 0` is scroll down.
ok &= self.emit(EV_REL, REL_WHEEL, -ny);
}
if nx != 0 {
ok &= self.emit(EV_REL, REL_HWHEEL, nx);
}
ok && self.syn()
}
fn key_combo(&self, keycode: u16, mods: &[u16]) -> bool {
let mut ok = true;
for &m in mods {
ok &= self.emit(EV_KEY, m, 1);
}
ok &= self.emit(EV_KEY, keycode, 1);
ok &= self.syn();
ok &= self.emit(EV_KEY, keycode, 0);
for &m in mods.iter().rev() {
ok &= self.emit(EV_KEY, m, 0);
}
ok && self.syn()
}
}
impl Drop for UinputDevice {
fn drop(&mut self) {
if self.fd >= 0 {
// SAFETY: `self.fd` is a valid uinput descriptor owned by `self`.
unsafe {
let _ = libc::ioctl(self.fd, UI_DEV_DESTROY);
let _ = libc::close(self.fd);
}
}
}
}
fn with_uinput<F: FnOnce(&UinputDevice) -> bool>(f: F) -> bool {
static UINPUT: OnceLock<Mutex<Option<UinputDevice>>> = OnceLock::new();
let mutex = UINPUT.get_or_init(|| Mutex::new(UinputDevice::open()));
let guard = mutex.lock().unwrap_or_else(|e| e.into_inner());
guard.as_ref().is_some_and(f)
}
fn evdev_button_code(button: MouseButton) -> u16 {
match button {
MouseButton::Left => BTN_LEFT,
MouseButton::Right => BTN_RIGHT,
MouseButton::Middle => BTN_MIDDLE,
}
}
pub(crate) fn evdev_key_for_mod(m: KeyMod) -> u16 {
match m {
KeyMod::Ctrl => 29, // KEY_LEFTCTRL
KeyMod::Shift => 42, // KEY_LEFTSHIFT
KeyMod::Alt => 56, // KEY_LEFTALT
KeyMod::Win => 125, // KEY_LEFTMETA
}
}
/// Maps a named X11 keysym (as returned by [`resolve_key`]) to a Linux evdev `KEY_*` code.
/// Letters and digits aren't here: where they are depends on the layout ([`key_code_for_sym`]).
pub(crate) fn evdev_key_for_sym(sym: &str) -> Option<u16> {
let code = match sym {
"Escape" => 1,
"BackSpace" => 14,
"Tab" => 15,
"Return" => 28,
"space" => 57,
"F1" => 59,
"F2" => 60,
"F3" => 61,
"F4" => 62,
"F5" => 63,
"F6" => 64,
"F7" => 65,
"F8" => 66,
"F9" => 67,
"F10" => 68,
"F11" => 87,
"F12" => 88,
"Print" => 99,
"Home" => 102,
"Up" => 103,
"Prior" => 104,
"Left" => 105,
"Right" => 106,
"End" => 107,
"Down" => 108,
"Next" => 109,
"Insert" => 110,
"Delete" => 111,
"XF86AudioMute" => 113,
"XF86AudioLowerVolume" => 114,
"XF86AudioRaiseVolume" => 115,
"XF86AudioNext" => 163,
"XF86AudioPlay" => 164,
"XF86AudioPrev" => 165,
_ => return None,
};
Some(code)
}
/// The modifier keys a [`KeyPress`](super::keymap::KeyPress) needs held.
fn press_mods(press: &super::keymap::KeyPress) -> Vec<u16> {
let mut mods = Vec::with_capacity(2);
if press.shift {
mods.push(evdev_key_for_mod(KeyMod::Shift));
}
if press.altgr {
mods.push(super::keymap::KEY_RIGHTALT);
}
mods
}
/// The evdev key for a shortcut's key name. Named keys (arrows, F-keys,
/// Enter) are in the same place on every layout; a letter isn't (Z is
/// where Y is on a German keyboard), so letters go through the user's
/// layout, and without a known layout there is no key code to send.
fn key_code_for_sym(sym: &str) -> Option<u16> {
let mut chars = sym.chars();
match (chars.next(), chars.next()) {
(Some(ch), None) => {
super::keymap::current()?.press_for(ch).filter(|p| !p.shift && !p.altgr).map(|p| p.code)
}
_ => evdev_key_for_sym(sym),
}
}
/// Converts a Unicode character to its X11 keysym (`XK_*` or `0x0100_0000 | codepoint`).
pub(crate) fn char_to_x11_keysym(ch: char) -> u32 {
match ch {
'\n' => 0xff0d, // XK_Return
'\t' => 0xff09, // XK_Tab
'\u{08}' => 0xff08, // XK_BackSpace
'\u{1b}' => 0xff1b, // XK_Escape
' '..='~' | '\u{a0}'..='\u{ff}' => ch as u32,
c => 0x0100_0000 | (c as u32),
}
}
// ---- Wayland `org.freedesktop.portal.RemoteDesktop` backend ----
struct RemoteDesktopPortal {
conn: zbus::blocking::Connection,
session_path: zbus::zvariant::OwnedObjectPath,
}
impl RemoteDesktopPortal {
fn connect() -> Option<Self> {
let conn = zbus::blocking::Connection::session().ok()?;
if !super::dbus_name_has_owner(&conn, "org.freedesktop.portal.Desktop") {
return None;
}
let rule = zbus::MatchRule::builder()
.msg_type(zbus::message::Type::Signal)
.interface("org.freedesktop.portal.Request")
.and_then(|b| b.member("Response"))
.map(|b| b.build())
.ok()?;
let mut iter = zbus::blocking::MessageIterator::for_match_rule(rule, &conn, None).ok()?;
let pid = std::process::id();
let session_token = format!("nectarlink_rd_sess_{pid}");
let create_token = format!("nectarlink_rd_create_{pid}");
let mut create_opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
create_opts.insert("handle_token", zbus::zvariant::Value::from(create_token));
create_opts.insert("session_handle_token", zbus::zvariant::Value::from(session_token));
let create_reply = conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"CreateSession",
&(&create_opts,),
)
.ok()?;
let create_req_path =
create_reply.body().deserialize::<zbus::zvariant::OwnedObjectPath>().ok().map(|p| p.to_string());
let create_results = Self::wait_portal_response(&mut iter, create_req_path.as_deref())?;
let session_str =
create_results.get("session_handle").and_then(|v| <&str>::try_from(v).ok())?.to_owned();
let session_path = zbus::zvariant::OwnedObjectPath::try_from(session_str).ok()?;
// SelectDevices: types = 3 (1 = KEYBOARD | 2 = POINTER).
let select_token = format!("nectarlink_rd_select_{pid}");
let mut select_opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
select_opts.insert("handle_token", zbus::zvariant::Value::from(select_token));
select_opts.insert("types", zbus::zvariant::Value::U32(3));
let select_reply = conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"SelectDevices",
&(&session_path, &select_opts),
)
.ok()?;
let select_req_path =
select_reply.body().deserialize::<zbus::zvariant::OwnedObjectPath>().ok().map(|p| p.to_string());
Self::wait_portal_response(&mut iter, select_req_path.as_deref())?;
// Start session.
let start_token = format!("nectarlink_rd_start_{pid}");
let mut start_opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
start_opts.insert("handle_token", zbus::zvariant::Value::from(start_token));
let start_reply = conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"Start",
&(&session_path, "", &start_opts),
)
.ok()?;
let start_req_path =
start_reply.body().deserialize::<zbus::zvariant::OwnedObjectPath>().ok().map(|p| p.to_string());
Self::wait_portal_response(&mut iter, start_req_path.as_deref())?;
Some(Self { conn, session_path })
}
fn wait_portal_response(
iter: &mut zbus::blocking::MessageIterator,
expected_path: Option<&str>,
) -> Option<HashMap<String, zbus::zvariant::OwnedValue>> {
for msg in iter.take(32) {
let msg = msg.ok()?;
if let Some(expected) = expected_path
&& msg.header().path().map(|p| p.as_str()) != Some(expected)
{
continue;
}
if let Ok((code, results)) =
msg.body().deserialize::<(u32, HashMap<String, zbus::zvariant::OwnedValue>)>()
{
return (code == 0).then_some(results);
}
}
None
}
fn move_relative(&self, dx: f64, dy: f64) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
self.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyPointerMotion",
&(&self.session_path, &opts, dx, dy),
)
.is_ok()
}
fn move_absolute(&self, x: f64, y: f64) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
self.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyPointerMotionAbsolute",
&(&self.session_path, &opts, 0u32, x, y),
)
.is_ok()
}
fn button(&self, evdev_btn: i32, down: bool) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
let state: u32 = u32::from(down);
self.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyPointerButton",
&(&self.session_path, &opts, evdev_btn, state),
)
.is_ok()
}
fn scroll(&self, nx: i32, ny: i32) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
let mut ok = true;
if ny != 0 {
ok &= self
.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyPointerAxisDiscrete",
&(&self.session_path, &opts, 0u32, ny),
)
.is_ok();
}
if nx != 0 {
ok &= self
.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyPointerAxisDiscrete",
&(&self.session_path, &opts, 1u32, nx),
)
.is_ok();
}
ok
}
fn keycode(&self, evdev_key: i32, down: bool) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
let state: u32 = u32::from(down);
self.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyKeyboardKeycode",
&(&self.session_path, &opts, evdev_key, state),
)
.is_ok()
}
fn keysym(&self, keysym: i32, down: bool) -> bool {
let opts: HashMap<&str, zbus::zvariant::Value<'_>> = HashMap::new();
let state: u32 = u32::from(down);
self.conn
.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.portal.RemoteDesktop"),
"NotifyKeyboardKeysym",
&(&self.session_path, &opts, keysym, state),
)
.is_ok()
}
}
fn with_wayland_portal<F: FnOnce(&RemoteDesktopPortal) -> bool + Send>(f: F) -> bool {
if !has_wayland_display() {
return false;
}
super::non_tokio(|| {
static PORTAL: OnceLock<Mutex<Option<RemoteDesktopPortal>>> = OnceLock::new();
let mutex = PORTAL.get_or_init(|| Mutex::new(RemoteDesktopPortal::connect()));
let guard = mutex.lock().unwrap_or_else(|e| e.into_inner());
guard.as_ref().is_some_and(f)
})
}
fn has_remote_desktop_portal() -> bool {
super::non_tokio(|| {
let Ok(conn) = zbus::blocking::Connection::session() else {
return false;
};
if !super::dbus_name_has_owner(&conn, "org.freedesktop.portal.Desktop") {
return false;
}
let Ok(msg) = conn.call_method(
Some("org.freedesktop.portal.Desktop"),
"/org/freedesktop/portal/desktop",
Some("org.freedesktop.DBus.Properties"),
"Get",
&("org.freedesktop.portal.RemoteDesktop", "AvailableDeviceTypes"),
) else {
return false;
};
if let Ok(val) = msg.body().deserialize::<zbus::zvariant::OwnedValue>()
&& let Ok(types) = u32::try_from(val)
{
return types != 0;
}
true
})
}
// ---- X11 `libX11.so.6` + `libXtst.so.6` (`XTest`) backend ----
struct X11TestApi {
_x11_lib: *mut c_void,
_xtst_lib: *mut c_void,
open_display: unsafe extern "C" fn(*const c_char) -> *mut c_void,
flush: unsafe extern "C" fn(*mut c_void) -> c_int,
string_to_keysym: unsafe extern "C" fn(*const c_char) -> c_ulong,
keysym_to_keycode: unsafe extern "C" fn(*mut c_void, c_ulong) -> u8,
keycode_to_keysym: Option<unsafe extern "C" fn(*mut c_void, u8, c_int) -> c_ulong>,
query_extension:
unsafe extern "C" fn(*mut c_void, *mut c_int, *mut c_int, *mut c_int, *mut c_int) -> c_int,
fake_motion: unsafe extern "C" fn(*mut c_void, c_int, c_int, c_int, c_ulong) -> c_int,
fake_relative_motion: unsafe extern "C" fn(*mut c_void, c_int, c_int, c_ulong) -> c_int,
fake_button: unsafe extern "C" fn(*mut c_void, c_uint, c_int, c_ulong) -> c_int,
fake_key: unsafe extern "C" fn(*mut c_void, c_uint, c_int, c_ulong) -> c_int,
}
// SAFETY: Function pointers loaded from libX11.so.6 and libXtst.so.6 are process-wide.
unsafe impl Send for X11TestApi {}
unsafe impl Sync for X11TestApi {}
struct X11Display(*mut c_void);
// SAFETY: Access to the Display pointer is serialized through a Mutex.
unsafe impl Send for X11Display {}
unsafe fn load_sym<T>(handle: *mut c_void, name: &CStr) -> Option<T> {
let raw = unsafe { libc::dlsym(handle, name.as_ptr()) };
if raw.is_null() {
return None;
}
Some(unsafe { std::mem::transmute_copy(&raw) })
}
fn x11_test_api() -> Option<&'static X11TestApi> {
static API: OnceLock<Option<X11TestApi>> = OnceLock::new();
API.get_or_init(|| unsafe {
let x11_lib = libc::dlopen(c"libX11.so.6".as_ptr(), libc::RTLD_LAZY | libc::RTLD_LOCAL);
if x11_lib.is_null() {
return None;
}
let xtst_lib = libc::dlopen(c"libXtst.so.6".as_ptr(), libc::RTLD_LAZY | libc::RTLD_LOCAL);
if xtst_lib.is_null() {
let _ = libc::dlclose(x11_lib);
return None;
}
let api = X11TestApi {
_x11_lib: x11_lib,
_xtst_lib: xtst_lib,
open_display: load_sym(x11_lib, c"XOpenDisplay")?,
flush: load_sym(x11_lib, c"XFlush")?,
string_to_keysym: load_sym(x11_lib, c"XStringToKeysym")?,
keysym_to_keycode: load_sym(x11_lib, c"XKeysymToKeycode")?,
keycode_to_keysym: load_sym(x11_lib, c"XKeycodeToKeysym"),
query_extension: load_sym(xtst_lib, c"XTestQueryExtension")?,
fake_motion: load_sym(xtst_lib, c"XTestFakeMotionEvent")?,
fake_relative_motion: load_sym(xtst_lib, c"XTestFakeRelativeMotionEvent")?,
fake_button: load_sym(xtst_lib, c"XTestFakeButtonEvent")?,
fake_key: load_sym(xtst_lib, c"XTestFakeKeyEvent")?,
};
Some(api)
})
.as_ref()
}
fn with_xtest<F: FnOnce(&X11TestApi, *mut c_void)>(f: F) -> bool {
if std::env::var_os("DISPLAY").is_none() {
return false;
}
let Some(api) = x11_test_api() else {
return false;
};
static DISPLAY_CONN: OnceLock<Mutex<Option<X11Display>>> = OnceLock::new();
let mutex = DISPLAY_CONN.get_or_init(|| Mutex::new(None));
let mut guard = mutex.lock().unwrap_or_else(|e| e.into_inner());
if guard.is_none() {
// SAFETY: XOpenDisplay(NULL) connects to $DISPLAY; XTestQueryExtension checks XTEST support.
let dpy = unsafe { (api.open_display)(std::ptr::null()) };
if dpy.is_null() {
return false;
}
let mut ev = 0;
let mut err = 0;
let mut maj = 0;
let mut min = 0;
let ok = unsafe { (api.query_extension)(dpy, &mut ev, &mut err, &mut maj, &mut min) };
if ok == 0 {
return false;
}
*guard = Some(X11Display(dpy));
}
if let Some(X11Display(dpy)) = *guard {
f(api, dpy);
// SAFETY: dpy is a valid open X11 Display pointer protected by DISPLAY_CONN mutex.
unsafe {
let _ = (api.flush)(dpy);
}
true
} else {
false
}
}
fn uinput_writable() -> bool {
std::fs::OpenOptions::new().write(true).open("/dev/uinput").is_ok()
|| std::fs::OpenOptions::new().write(true).open("/dev/input/uinput").is_ok()
}
/// Returns `true` when input synthesis is supported in the current desktop session.
pub fn is_available() -> bool {
if uinput_writable() {
return true;
}
if has_x11_display() && (x11_test_api().is_some() || has_executable_in_path("xdotool")) {
return true;
}
if has_wayland_display()
&& (has_executable_in_path("ydotool")
|| has_executable_in_path("wtype")
|| has_remote_desktop_portal())
{
return true;
}
false
}
fn has_executable_in_path(binary: &str) -> bool {
std::env::var_os("PATH")
.is_some_and(|paths| std::env::split_paths(&paths).any(|dir| dir.join(binary).is_file()))
}
/// Fractional remainders for sub-pixel pointer motion and sub-notch scrolling,
/// plus which mouse buttons are currently held down by remote input.
#[derive(Default, Debug, Clone, PartialEq)]
struct InputState {
move_rem_x: f32,
move_rem_y: f32,
scroll_rem_x: f32,
scroll_rem_y: f32,
held_left: bool,
held_right: bool,
held_middle: bool,
}
impl InputState {
fn accumulate_move(&mut self, dx: f32, dy: f32) -> (i32, i32) {
let total_x = self.move_rem_x + dx;
let total_y = self.move_rem_y + dy;
let ix = total_x.round() as i32;
let iy = total_y.round() as i32;
self.move_rem_x = total_x - (ix as f32);
self.move_rem_y = total_y - (iy as f32);
(ix, iy)
}
fn accumulate_scroll(&mut self, dx: f32, dy: f32) -> (i32, i32) {
let total_x = self.scroll_rem_x + dx;
let total_y = self.scroll_rem_y + dy;
let nx = total_x.round() as i32;
let ny = total_y.round() as i32;
self.scroll_rem_x = total_x - (nx as f32);
self.scroll_rem_y = total_y - (ny as f32);
(nx, ny)
}
fn record_button(&mut self, button: MouseButton, action: ButtonAction) {
let slot = match button {
MouseButton::Left => &mut self.held_left,
MouseButton::Right => &mut self.held_right,
MouseButton::Middle => &mut self.held_middle,
};
*slot = matches!(action, ButtonAction::Down);
}
fn take_held_and_reset(&mut self) -> (bool, bool, bool) {
let held = (self.held_left, self.held_right, self.held_middle);
self.held_left = false;
self.held_right = false;
self.held_middle = false;
self.move_rem_x = 0.0;
self.move_rem_y = 0.0;
self.scroll_rem_x = 0.0;
self.scroll_rem_y = 0.0;
held
}
}
static STATE: Mutex<InputState> = Mutex::new(InputState {
move_rem_x: 0.0,
move_rem_y: 0.0,
scroll_rem_x: 0.0,
scroll_rem_y: 0.0,
held_left: false,
held_right: false,
held_middle: false,
});
fn has_display_env() -> bool {
std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some()
}
fn has_wayland_display() -> bool {
std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v| !v.is_empty())
}
fn has_x11_display() -> bool {
std::env::var_os("DISPLAY").is_some_and(|v| !v.is_empty())
}
fn run_quiet(program: &str, args: &[&str]) -> bool {
if !has_display_env() {
return false;
}
Command::new(program)
.args(args)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.is_ok_and(|s| s.success())
}
fn run_with_stdin(program: &str, args: &[&str], input: &[u8]) -> bool {
if !has_display_env() {
return false;
}
let Ok(mut child) = Command::new(program)
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
else {
return false;
};
if let Some(mut stdin) = child.stdin.take()
&& stdin.write_all(input).is_err()
{
let _ = child.kill();
let _ = child.wait();
return false;
}
child.wait().is_ok_and(|s| s.success())
}
fn display_dimensions() -> (i32, i32) {
let mut sx = 0;
let mut sy = 0;
let mut sw = 0;
let mut sh = 0;
if crate::bridge::native::ffi::linux_screen_geometry(&mut sx, &mut sy, &mut sw, &mut sh)
&& sw > 0
&& sh > 0
{
return (sw, sh);
}
if let Some((x, y, w, h)) = super::work_area() {
let total_w = (x.max(0) + w).max(1);
let total_h = (y.max(0) + h).max(1);
if total_w > 0 && total_h > 0 {
return (total_w, total_h);
}
}
if has_display_env()
&& let Ok(out) = Command::new("xdotool")
.arg("getdisplaygeometry")
.stdin(Stdio::null())
.stderr(Stdio::null())
.output()
&& out.status.success()
{
let text = String::from_utf8_lossy(&out.stdout);
let mut parts = text.split_whitespace().filter_map(|s| s.parse::<i32>().ok());
if let (Some(w), Some(h)) = (parts.next(), parts.next())
&& w > 0
&& h > 0
{
return (w, h);
}
}
(1920, 1080)
}
fn normalized_to_pixels(x: f32, y: f32, width: i32, height: i32) -> (i32, i32) {
let max_x = (width - 1).max(1) as f32;
let max_y = (height - 1).max(1) as f32;
let px = (x.clamp(0.0, 1.0) * max_x).round() as i32;
let py = (y.clamp(0.0, 1.0) * max_y).round() as i32;
(px, py)
}
/// Moves the mouse cursor relatively by `(dx, dy)` pixels, keeping sub-pixel
/// fractions for the next move.
pub fn move_relative(dx: f32, dy: f32) {
if !dx.is_finite() || !dy.is_finite() {
return;
}
let (ix, iy) = {
let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
s.accumulate_move(dx, dy)
};
if ix == 0 && iy == 0 {
return;
}
if with_uinput(|u| u.move_relative(ix, iy)) {
return;
}
if with_wayland_portal(|p| p.move_relative(f64::from(ix), f64::from(iy))) {
return;
}
let sx = ix.to_string();
let sy = iy.to_string();
if has_wayland_display() && run_quiet("ydotool", &["mousemove", "-x", &sx, "-y", &sy]) {
return;
}
if with_xtest(|api, dpy| unsafe {
let _ = (api.fake_relative_motion)(dpy, ix, iy, 0);
}) {
return;
}
if !run_quiet("xdotool", &["mousemove_relative", "--", &sx, &sy]) {
let _ = run_quiet("ydotool", &["mousemove", "-x", &sx, "-y", &sy]);
}
}
/// Moves the mouse cursor to normalized coordinates `(x, y)` on the primary
/// display (`0.0..=1.0`).
pub fn move_absolute(x: f32, y: f32) {
if !x.is_finite() || !y.is_finite() {
return;
}
let (w, h) = display_dimensions();
let (px, py) = normalized_to_pixels(x, y, w, h);
if with_wayland_portal(|p| p.move_absolute(f64::from(px), f64::from(py))) {
return;
}
let sx = px.to_string();
let sy = py.to_string();
if has_wayland_display() && run_quiet("ydotool", &["mousemove", "--absolute", "-x", &sx, "-y", &sy]) {
return;
}
if with_xtest(|api, dpy| unsafe {
let _ = (api.fake_motion)(dpy, -1, px, py, 0);
}) {
return;
}
if !run_quiet("xdotool", &["mousemove", "--", &sx, &sy]) {
let _ = run_quiet("ydotool", &["mousemove", "--absolute", "-x", &sx, "-y", &sy]);
}
}
/// Injects a normalized touch event (`0.0..=1.0`) from reverse PC mirroring as
/// absolute mouse movement + left button press/release.
pub fn mirror_touch(action: TouchAction, x: f32, y: f32) {
if !x.is_finite() || !y.is_finite() {
return;
}
let (w, h) = display_dimensions();
let (px, py) = normalized_to_pixels(x, y, w, h);
let sx = px.to_string();
let sy = py.to_string();
match action {
TouchAction::Down => {
if let Ok(mut s) = STATE.lock() {
s.held_left = true;
}
if !has_wayland_display()
&& with_xtest(|api, dpy| unsafe {
let _ = (api.fake_motion)(dpy, -1, px, py, 0);
let _ = (api.fake_button)(dpy, 1, 1, 0);
})
{
return;
}
if has_wayland_display()
|| !run_quiet("xdotool", &["mousemove", "--", &sx, &sy, "mousedown", "1"])
{
move_absolute(x, y);
mouse_button(MouseButton::Left, ButtonAction::Down);
}
}
TouchAction::Move => {
move_absolute(x, y);
}
TouchAction::Up => {
if let Ok(mut s) = STATE.lock() {
s.held_left = false;
}
if !has_wayland_display()
&& with_xtest(|api, dpy| unsafe {
let _ = (api.fake_motion)(dpy, -1, px, py, 0);
let _ = (api.fake_button)(dpy, 1, 0, 0);
})
{
return;
}
if has_wayland_display() || !run_quiet("xdotool", &["mousemove", "--", &sx, &sy, "mouseup", "1"])
{
move_absolute(x, y);
mouse_button(MouseButton::Left, ButtonAction::Up);
}
}
}
}
fn x11_button_num(button: MouseButton) -> c_uint {
match button {
MouseButton::Left => 1,
MouseButton::Middle => 2,
MouseButton::Right => 3,
}
}
fn xdotool_button_id(button: MouseButton) -> &'static str {
match button {
MouseButton::Left => "1",
MouseButton::Middle => "2",
MouseButton::Right => "3",
}
}
/// Presses, releases or clicks a mouse button.
pub fn mouse_button(button: MouseButton, action: ButtonAction) {
{
let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
s.record_button(button, action);
}
let evdev_btn = evdev_button_code(button);
if with_uinput(|u| match action {
ButtonAction::Click => u.button(evdev_btn, true) && u.button(evdev_btn, false),
ButtonAction::Down => u.button(evdev_btn, true),
ButtonAction::Up => u.button(evdev_btn, false),
}) {
return;
}
if with_wayland_portal(|p| match action {
ButtonAction::Click => p.button(i32::from(evdev_btn), true) && p.button(i32::from(evdev_btn), false),
ButtonAction::Down => p.button(i32::from(evdev_btn), true),
ButtonAction::Up => p.button(i32::from(evdev_btn), false),
}) {
return;
}
let ydo_code = match (button, action) {
(MouseButton::Left, ButtonAction::Click) => "0xC0",
(MouseButton::Left, ButtonAction::Down) => "0x40",
(MouseButton::Left, ButtonAction::Up) => "0x80",
(MouseButton::Right, ButtonAction::Click) => "0xC1",
(MouseButton::Right, ButtonAction::Down) => "0x41",
(MouseButton::Right, ButtonAction::Up) => "0x81",
(MouseButton::Middle, ButtonAction::Click) => "0xC2",
(MouseButton::Middle, ButtonAction::Down) => "0x42",
(MouseButton::Middle, ButtonAction::Up) => "0x82",
};
if has_wayland_display() && run_quiet("ydotool", &["click", ydo_code]) {
return;
}
let btn_num = x11_button_num(button);
if with_xtest(|api, dpy| unsafe {
match action {
ButtonAction::Click => {
let _ = (api.fake_button)(dpy, btn_num, 1, 0);
let _ = (api.fake_button)(dpy, btn_num, 0, 0);
}
ButtonAction::Down => {
let _ = (api.fake_button)(dpy, btn_num, 1, 0);
}
ButtonAction::Up => {
let _ = (api.fake_button)(dpy, btn_num, 0, 0);
}
}
}) {
return;
}
let btn = xdotool_button_id(button);
let subcmd = match action {
ButtonAction::Click => "click",
ButtonAction::Down => "mousedown",
ButtonAction::Up => "mouseup",
};
if !run_quiet("xdotool", &[subcmd, btn]) {
let _ = run_quiet("ydotool", &["click", ydo_code]);
}
}
/// Releases any mouse buttons still held down by remote input.
pub fn release_held_buttons() {
let (left, right, middle) = {
let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
s.take_held_and_reset()
};
if !left && !right && !middle {
return;
}
if with_uinput(|u| {
let mut ok = true;
if left {
ok &= u.button(BTN_LEFT, false);
}
if middle {
ok &= u.button(BTN_MIDDLE, false);
}
if right {
ok &= u.button(BTN_RIGHT, false);
}
ok
}) {
return;
}
if with_wayland_portal(|p| {
let mut ok = true;
if left {
ok &= p.button(i32::from(BTN_LEFT), false);
}
if middle {
ok &= p.button(i32::from(BTN_MIDDLE), false);
}
if right {
ok &= p.button(i32::from(BTN_RIGHT), false);
}
ok
}) {
return;
}
if has_wayland_display() {
let mut handled = true;
if left {
handled &= run_quiet("ydotool", &["click", "0x80"]);
}
if middle {
handled &= run_quiet("ydotool", &["click", "0x82"]);
}
if right {
handled &= run_quiet("ydotool", &["click", "0x81"]);
}
if handled {
return;
}
}
if !has_wayland_display()
&& with_xtest(|api, dpy| unsafe {
if left {
let _ = (api.fake_button)(dpy, 1, 0, 0);
}
if middle {
let _ = (api.fake_button)(dpy, 2, 0, 0);
}
if right {
let _ = (api.fake_button)(dpy, 3, 0, 0);
}
})
{
return;
}
if left && !run_quiet("xdotool", &["mouseup", "1"]) {
let _ = run_quiet("ydotool", &["click", "0x80"]);
}
if middle && !run_quiet("xdotool", &["mouseup", "2"]) {
let _ = run_quiet("ydotool", &["click", "0x82"]);
}
if right && !run_quiet("xdotool", &["mouseup", "3"]) {
let _ = run_quiet("ydotool", &["click", "0x81"]);
}
}
/// Scrolls the mouse wheel smoothly (`dy > 0` scrolls down, `dx > 0` scrolls right).
pub fn scroll(dx: f32, dy: f32) {
if !dx.is_finite() || !dy.is_finite() {
return;
}
let (nx, ny) = {
let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
s.accumulate_scroll(dx, dy)
};
if nx == 0 && ny == 0 {
return;
}
if with_uinput(|u| u.scroll(nx, ny)) {
return;
}
if with_wayland_portal(|p| p.scroll(nx, ny)) {
return;
}
if has_wayland_display() {
let mut ydo_ok = true;
if ny != 0 {
let wheel_y = (-ny).to_string();
ydo_ok &= run_quiet("ydotool", &["mousemove", "--wheel", "-x", "0", "-y", &wheel_y]);
}
if nx != 0 {
let wheel_x = nx.to_string();
ydo_ok &= run_quiet("ydotool", &["mousemove", "--wheel", "-x", &wheel_x, "-y", "0"]);
}
if ydo_ok {
return;
}
}
if with_xtest(|api, dpy| unsafe {
if ny != 0 {
let btn: c_uint = if ny > 0 { 5 } else { 4 };
for _ in 0..ny.unsigned_abs() {
let _ = (api.fake_button)(dpy, btn, 1, 0);
let _ = (api.fake_button)(dpy, btn, 0, 0);
}
}
if nx != 0 {
let btn: c_uint = if nx > 0 { 7 } else { 6 };
for _ in 0..nx.unsigned_abs() {
let _ = (api.fake_button)(dpy, btn, 1, 0);
let _ = (api.fake_button)(dpy, btn, 0, 0);
}
}
}) {
return;
}
if ny != 0 {
// X11 button 4 = wheel up, button 5 = wheel down.
let btn = if ny > 0 { "5" } else { "4" };
let count = ny.unsigned_abs().to_string();
if !run_quiet("xdotool", &["click", "--repeat", &count, "--delay", "1", btn]) {
let wheel_y = (-ny).to_string();
let _ = run_quiet("ydotool", &["mousemove", "--wheel", "-x", "0", "-y", &wheel_y]);
}
}
if nx != 0 {
// X11 button 6 = wheel left, button 7 = wheel right.
let btn = if nx > 0 { "7" } else { "6" };
let count = nx.unsigned_abs().to_string();
if !run_quiet("xdotool", &["click", "--repeat", &count, "--delay", "1", btn]) {
let wheel_x = nx.to_string();
let _ = run_quiet("ydotool", &["mousemove", "--wheel", "-x", &wheel_x, "-y", "0"]);
}
}
}
/// Types arbitrary Unicode text (filtering carriage returns `\r`) without
/// exposing the text on any subprocess command line (`ps` / `/proc/<pid>/cmdline`).
pub fn type_text(text: &str) {
let cleaned: String = text.chars().filter(|&c| c != '\r').collect();
if cleaned.is_empty() {
return;
}
// 1. `/dev/uinput`, pressing the keys that type each character on the
// user's layout. Without a known layout, skip it: a guessed layout
// types the wrong characters.
let presses: Option<Vec<super::keymap::KeyPress>> =
super::keymap::current().and_then(|km| cleaned.chars().map(|ch| km.press_for(ch)).collect());
if let Some(ref presses) = presses
&& with_uinput(|u| presses.iter().all(|p| u.key_combo(p.code, &press_mods(p))))
{
return;
}
// 2. On Wayland, try `org.freedesktop.portal.RemoteDesktop.NotifyKeyboardKeysym`.
if with_wayland_portal(|p| {
cleaned.chars().all(|ch| {
let ks = char_to_x11_keysym(ch) as i32;
p.keysym(ks, true) && p.keysym(ks, false)
})
}) {
return;
}
// 3. On X11, try in-process XTest key injection when all characters map to keycodes.
let mut xtest_typed = false;
let _ = with_xtest(|api, dpy| unsafe {
let shift_ks = (api.string_to_keysym)(c"Shift_L".as_ptr());
let shift_kc = c_uint::from((api.keysym_to_keycode)(dpy, shift_ks));
let mut steps: Vec<(c_uint, bool)> = Vec::with_capacity(cleaned.len());
for ch in cleaned.chars() {
let ks = c_ulong::from(char_to_x11_keysym(ch));
let kc = (api.keysym_to_keycode)(dpy, ks);
if kc == 0 {
return;
}
let needs_shift = if let Some(kc_to_ks) = api.keycode_to_keysym {
let unshifted = kc_to_ks(dpy, kc, 0);
let shifted = kc_to_ks(dpy, kc, 1);
unshifted != ks && shifted == ks
} else {
ch.is_ascii_uppercase()
|| matches!(
ch,
'!' | '@'
| '#'
| '$'
| '%'
| '^'
| '&'
| '*'
| '('
| ')'
| '_'
| '+'
| '{'
| '}'
| '|'
| ':'
| '"'
| '<'
| '>'
| '?'
| '~'
)
};
steps.push((c_uint::from(kc), needs_shift));
}
for (kc, shift) in steps {
if shift && shift_kc != 0 {
let _ = (api.fake_key)(dpy, shift_kc, 1, 0);
}
let _ = (api.fake_key)(dpy, kc, 1, 0);
let _ = (api.fake_key)(dpy, kc, 0, 0);
if shift && shift_kc != 0 {
let _ = (api.fake_key)(dpy, shift_kc, 0, 0);
}
}
xtest_typed = true;
});
if xtest_typed {
return;
}
// 4. Pipe text over stdin (`wtype -` or `xdotool type --file -`) so it is never on argv.
if has_wayland_display() && run_with_stdin("wtype", &["-"], cleaned.as_bytes()) {
return;
}
if !run_with_stdin(
"xdotool",
&["type", "--clearmodifiers", "--delay", "0", "--file", "-"],
cleaned.as_bytes(),
) {
let _ = run_with_stdin("wtype", &["-"], cleaned.as_bytes());
}
}
/// Resolves a protocol key or shortcut name into `(keysym, extra_mods)`.
pub(crate) fn resolve_key(key: &str) -> Option<(String, &'static [KeyMod])> {
const CTRL: &[KeyMod] = &[KeyMod::Ctrl];
const WIN: &[KeyMod] = &[KeyMod::Win];
const NONE: &[KeyMod] = &[];
let trimmed = key.trim();
if trimmed.is_empty() {
return None;
}
let lower = trimmed.to_ascii_lowercase();
let (sym, mods): (&str, &'static [KeyMod]) = match lower.as_str() {
"copy" => ("c", CTRL),
"paste" => ("v", CTRL),
"cut" => ("x", CTRL),
"undo" => ("z", CTRL),
"redo" => ("y", CTRL),
"select_all" => ("a", CTRL),
"task_view" => ("Tab", WIN),
"enter" | "return" => ("Return", NONE),
"backspace" => ("BackSpace", NONE),
"tab" => ("Tab", NONE),
"escape" | "esc" => ("Escape", NONE),
"space" => ("space", NONE),
"delete" | "del" => ("Delete", NONE),
"insert" | "ins" => ("Insert", NONE),
"up" => ("Up", NONE),
"down" => ("Down", NONE),
"left" => ("Left", NONE),
"right" => ("Right", NONE),
"home" => ("Home", NONE),
"end" => ("End", NONE),
"page_up" | "pageup" | "pgup" | "prior" => ("Prior", NONE),
"page_down" | "pagedown" | "pgdn" | "next" => ("Next", NONE),
"print" | "printscreen" | "sysrq" => ("Print", NONE),
"f1" => ("F1", NONE),
"f2" => ("F2", NONE),
"f3" => ("F3", NONE),
"f4" => ("F4", NONE),
"f5" => ("F5", NONE),
"f6" => ("F6", NONE),
"f7" => ("F7", NONE),
"f8" => ("F8", NONE),
"f9" => ("F9", NONE),
"f10" => ("F10", NONE),
"f11" => ("F11", NONE),
"f12" => ("F12", NONE),
"volume_up" | "xf86audioraisevolume" => ("XF86AudioRaiseVolume", NONE),
"volume_down" | "xf86audiolowervolume" => ("XF86AudioLowerVolume", NONE),
"volume_mute" | "xf86audiomute" => ("XF86AudioMute", NONE),
"play_pause" | "xf86audioplay" => ("XF86AudioPlay", NONE),
"next_track" | "xf86audionext" => ("XF86AudioNext", NONE),
"prev_track" | "xf86audioprev" => ("XF86AudioPrev", NONE),
s if s.len() == 1 => {
let b = s.as_bytes()[0];
if b.is_ascii_lowercase() || b.is_ascii_digit() {
return Some((s.to_owned(), NONE));
}
return None;
}
_ => return None,
};
Some((sym.to_owned(), mods))
}
fn mod_name(m: KeyMod) -> &'static str {
match m {
KeyMod::Ctrl => "ctrl",
KeyMod::Alt => "alt",
KeyMod::Shift => "shift",
KeyMod::Win => "super",
}
}
/// Formats an `xdotool key` combo string (e.g. `"ctrl+shift+k"` or `"super+Tab"`)
/// for a protocol key and modifier list.
pub(crate) fn format_xdotool_combo(key: &str, mods: &[KeyMod]) -> Option<String> {
let (sym, preset_mods) = resolve_key(key)?;
let mut all_mods: Vec<KeyMod> = Vec::with_capacity(4);
for &m in preset_mods.iter().chain(mods.iter()) {
if !all_mods.contains(&m) {
all_mods.push(m);
}
}
if all_mods.is_empty() {
return Some(sym);
}
let mut parts: Vec<&str> = all_mods.iter().map(|&m| mod_name(m)).collect();
parts.push(&sym);
Some(parts.join("+"))
}
fn mod_x11_keysym_name(m: KeyMod) -> &'static CStr {
match m {
KeyMod::Ctrl => c"Control_L",
KeyMod::Alt => c"Alt_L",
KeyMod::Shift => c"Shift_L",
KeyMod::Win => c"Super_L",
}
}
/// Presses a named key or shortcut with optional modifiers.
pub fn press_key(key: &str, mods: &[KeyMod]) {
if key.eq_ignore_ascii_case("lock") {
let _ = crate::links::power(PowerAction::Lock);
return;
}
let Some((sym, preset_mods)) = resolve_key(key) else {
return;
};
let mut all_mods: Vec<KeyMod> = Vec::with_capacity(4);
for &m in preset_mods.iter().chain(mods.iter()) {
if !all_mods.contains(&m) {
all_mods.push(m);
}
}
if let Some(evdev_code) = key_code_for_sym(&sym) {
let mod_codes: Vec<u16> = all_mods.iter().map(|&m| evdev_key_for_mod(m)).collect();
if with_uinput(|u| u.key_combo(evdev_code, &mod_codes)) {
return;
}
if with_wayland_portal(|p| {
let mut ok = true;
for &mc in &mod_codes {
ok &= p.keycode(i32::from(mc), true);
}
ok &= p.keycode(i32::from(evdev_code), true);
ok &= p.keycode(i32::from(evdev_code), false);
for &mc in mod_codes.iter().rev() {
ok &= p.keycode(i32::from(mc), false);
}
ok
}) {
return;
}
}
if has_wayland_display() {
let mut wtype_args: Vec<String> = Vec::new();
for &m in &all_mods {
let wm = match m {
KeyMod::Ctrl => "ctrl",
KeyMod::Alt => "alt",
KeyMod::Shift => "shift",
KeyMod::Win => "logo",
};
wtype_args.push("-M".into());
wtype_args.push(wm.into());
}
wtype_args.push("-k".into());
wtype_args.push(sym.clone());
let refs: Vec<&str> = wtype_args.iter().map(String::as_str).collect();
if run_quiet("wtype", &refs) {
return;
}
}
if let Ok(c_sym) = CString::new(sym.as_str()) {
let mut injected = false;
let _ = with_xtest(|api, dpy| unsafe {
let ks = (api.string_to_keysym)(c_sym.as_ptr());
if ks == 0 {
return;
}
let kc = (api.keysym_to_keycode)(dpy, ks);
if kc == 0 {
return;
}
let mut mod_kcs: Vec<c_uint> = Vec::with_capacity(all_mods.len());
for &m in &all_mods {
let mks = (api.string_to_keysym)(mod_x11_keysym_name(m).as_ptr());
let mkc = (api.keysym_to_keycode)(dpy, mks);
if mkc != 0 {
mod_kcs.push(c_uint::from(mkc));
}
}
for &mkc in &mod_kcs {
let _ = (api.fake_key)(dpy, mkc, 1, 0);
}
let _ = (api.fake_key)(dpy, c_uint::from(kc), 1, 0);
let _ = (api.fake_key)(dpy, c_uint::from(kc), 0, 0);
for &mkc in mod_kcs.iter().rev() {
let _ = (api.fake_key)(dpy, mkc, 0, 0);
}
injected = true;
});
if injected {
return;
}
}
if let Some(combo) = format_xdotool_combo(key, mods) {
let _ = run_quiet("xdotool", &["key", "--clearmodifiers", &combo]);
}
}
/// Executes a presentation slide action.
pub fn slide(action: SlideAction) {
let key = match action {
SlideAction::Next => "page_down",
SlideAction::Previous => "page_up",
SlideAction::Start => "f5",
SlideAction::Stop => "escape",
SlideAction::Black => "b",
};
press_key(key, &[]);
}
/// Parses idle milliseconds from `xprintidle` output (`"8801\n"`) or D-Bus
/// `GetIdletime` / `GetSessionIdleTime` output (`"(uint64 8801,)"` or `"(uint32 8,)"`).
pub(crate) fn parse_idle_output_ms(raw: &str, is_seconds: bool) -> Option<u64> {
let trimmed = raw.trim();
if trimmed.is_empty() {
return None;
}
if let Ok(val) = trimmed.parse::<u64>() {
return Some(if is_seconds { val.saturating_mul(1000) } else { val });
}
for token in trimmed.split(|c: char| !c.is_ascii_digit()) {
if !token.is_empty()
&& token != "64"
&& token != "32"
&& let Ok(val) = token.parse::<u64>()
{
return Some(if is_seconds { val.saturating_mul(1000) } else { val });
}
}
None
}
fn query_idle_ms() -> Option<u64> {
if !has_display_env() {
return None;
}
// 1. On X11, prefer `xprintidle` first (always returns milliseconds).
if has_x11_display()
&& let Ok(out) = Command::new("xprintidle").stdin(Stdio::null()).stderr(Stdio::null()).output()
&& out.status.success()
&& let Some(ms) = parse_idle_output_ms(&String::from_utf8_lossy(&out.stdout), false)
{
return Some(ms);
}
// 2. Query D-Bus idle monitors in-process via `zbus::blocking::Connection::session()`.
if let Some(ms) = super::non_tokio(|| {
let conn = zbus::blocking::Connection::session().ok()?;
// GNOME Mutter IdleMonitor returns u64 milliseconds.
if super::dbus_name_has_owner(&conn, "org.gnome.Mutter.IdleMonitor")
&& let Ok(reply) = conn.call_method(
Some("org.gnome.Mutter.IdleMonitor"),
"/org/gnome/Mutter/IdleMonitor/Core",
Some("org.gnome.Mutter.IdleMonitor"),
"GetIdletime",
&(),
)
{
let body = reply.body();
if let Ok(ms) = body.deserialize::<u64>().or_else(|_| body.deserialize::<(u64,)>().map(|(v,)| v))
{
return Some(ms);
}
}
// Freedesktop ScreenSaver (`GetSessionIdleTime` returns u32).
if super::dbus_name_has_owner(&conn, "org.freedesktop.ScreenSaver") {
for path in ["/org/freedesktop/ScreenSaver", "/ScreenSaver"] {
if let Ok(reply) = conn.call_method(
Some("org.freedesktop.ScreenSaver"),
path,
Some("org.freedesktop.ScreenSaver"),
"GetSessionIdleTime",
&(),
) {
let body = reply.body();
if let Ok(val) =
body.deserialize::<u32>().or_else(|_| body.deserialize::<(u32,)>().map(|(v,)| v))
{
return Some(u64::from(val));
}
}
}
}
None
}) {
return Some(ms);
}
// 3. Fallback to `xprintidle` on Wayland with XWayland if D-Bus idle monitors were unavailable.
if !has_x11_display()
&& let Ok(out) = Command::new("xprintidle").stdin(Stdio::null()).stderr(Stdio::null()).output()
&& out.status.success()
&& let Some(ms) = parse_idle_output_ms(&String::from_utf8_lossy(&out.stdout), false)
{
return Some(ms);
}
None
}
/// Returns `true` when the user has moved the mouse or pressed a key on this PC
/// within the last `max_idle_ms` milliseconds.
pub fn is_user_active_within_ms(max_idle_ms: u32) -> bool {
match query_idle_ms() {
Some(idle_ms) => idle_ms <= u64::from(max_idle_ms),
None => true,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolves_named_keys_and_shortcuts() {
assert_eq!(resolve_key("enter"), Some(("Return".to_owned(), &[][..])));
assert_eq!(resolve_key("up"), Some(("Up".to_owned(), &[][..])));
assert_eq!(resolve_key("copy"), Some(("c".to_owned(), &[KeyMod::Ctrl][..])));
assert_eq!(resolve_key("paste"), Some(("v".to_owned(), &[KeyMod::Ctrl][..])));
assert_eq!(resolve_key("task_view"), Some(("Tab".to_owned(), &[KeyMod::Win][..])));
assert_eq!(resolve_key("a"), Some(("a".to_owned(), &[][..])));
assert_eq!(resolve_key("A"), Some(("a".to_owned(), &[][..])));
assert_eq!(resolve_key("5"), Some(("5".to_owned(), &[][..])));
assert_eq!(resolve_key("f5"), Some(("F5".to_owned(), &[][..])));
assert_eq!(resolve_key("play_pause"), Some(("XF86AudioPlay".to_owned(), &[][..])));
assert_eq!(resolve_key("volume_up"), Some(("XF86AudioRaiseVolume".to_owned(), &[][..])));
assert_eq!(resolve_key("print"), Some(("Print".to_owned(), &[][..])));
assert!(resolve_key("unknown_key").is_none());
}
#[test]
fn maps_evdev_keys_and_unicode_keysyms() {
assert_eq!(evdev_key_for_sym("Return"), Some(28));
assert_eq!(evdev_key_for_sym("Escape"), Some(1));
assert_eq!(evdev_key_for_sym("F5"), Some(63));
assert_eq!(evdev_key_for_sym("XF86AudioPlay"), Some(164));
assert_eq!(evdev_key_for_mod(KeyMod::Win), 125);
assert_eq!(char_to_x11_keysym('a'), 0x61);
assert_eq!(char_to_x11_keysym('\n'), 0xff0d);
assert_eq!(char_to_x11_keysym('é'), 0x00e9);
assert_eq!(char_to_x11_keysym('€'), 0x0100_20ac);
}
#[test]
fn formats_xdotool_combos_with_preset_and_explicit_modifiers() {
assert_eq!(format_xdotool_combo("copy", &[]), Some("ctrl+c".to_owned()));
assert_eq!(
format_xdotool_combo("k", &[KeyMod::Ctrl, KeyMod::Shift]),
Some("ctrl+shift+k".to_owned())
);
assert_eq!(format_xdotool_combo("tab", &[KeyMod::Alt]), Some("alt+Tab".to_owned()));
assert_eq!(format_xdotool_combo("d", &[KeyMod::Win]), Some("super+d".to_owned()));
assert_eq!(format_xdotool_combo("f5", &[]), Some("F5".to_owned()));
}
#[test]
fn accumulates_subpixel_move_and_scroll_remainders() {
let mut s = InputState::default();
assert_eq!(s.accumulate_move(0.4, -0.4), (0, 0));
assert_eq!(s.accumulate_move(0.4, -0.4), (1, -1));
assert_eq!(s.accumulate_move(0.4, -0.4), (0, 0));
assert_eq!(s.accumulate_scroll(0.3, 0.3), (0, 0));
assert_eq!(s.accumulate_scroll(0.3, 0.3), (1, 1));
}
#[test]
fn tracks_held_mouse_buttons_and_resets_on_release() {
let mut s = InputState::default();
s.record_button(MouseButton::Left, ButtonAction::Down);
s.record_button(MouseButton::Right, ButtonAction::Click);
assert!(s.held_left);
assert!(!s.held_right);
let held = s.take_held_and_reset();
assert_eq!(held, (true, false, false));
assert!(!s.held_left);
}
#[test]
fn maps_normalized_coordinates_and_parses_idle_output() {
assert_eq!(normalized_to_pixels(0.0, 0.0, 1920, 1080), (0, 0));
assert_eq!(normalized_to_pixels(1.0, 1.0, 1920, 1080), (1919, 1079));
assert_eq!(normalized_to_pixels(0.5, 0.5, 1921, 1081), (960, 540));
assert_eq!(parse_idle_output_ms("8801\n", false), Some(8801));
assert_eq!(parse_idle_output_ms("(uint64 4250,)", false), Some(4250));
assert_eq!(parse_idle_output_ms("(uint32 19,)", true), Some(19_000));
assert_eq!(parse_idle_output_ms("12", true), Some(12_000));
}
}