mirror of
https://github.com/anomalyco/hex.git
synced 2026-11-22 21:23:02 +01:00
* linux: send a letter no layout has as its physical keycode * linux: say how paste resolves a letter no group has
809 lines
28 KiB
Rust
809 lines
28 KiB
Rust
//! Wayland paste through the desktop's RemoteDesktop portal
|
|
//! (`org.freedesktop.portal.RemoteDesktop`), for compositors without the
|
|
//! virtual keyboard protocol `wtype` needs, such as KWin and Mutter.
|
|
//!
|
|
//! One keyboard-only session lives as long as its `RemoteDesktop`. The
|
|
//! user approves it once: the portal's restore token, kept owner-only in
|
|
//! Application Support, restores later sessions without a dialog, so the
|
|
//! paster can close an idle session and reopen it at the next paste.
|
|
//!
|
|
//! A chord goes out as evdev keycodes when the desktop's keymap confirms every
|
|
//! key of it — each letter on one key across the layout groups that have it,
|
|
//! and Ctrl, Shift, and Enter where their keymap options leave them — and
|
|
//! otherwise as keysyms, which the desktop resolves in the active group; KWin's
|
|
//! lookup for a Latin `v` on a Russian layout can lose the held Ctrl. A letter
|
|
//! no group has at all still goes out on its pc105 key: the desktop's keysym
|
|
//! lookup searches only the active group, where it would find no key for it.
|
|
//! [`keymap`] reads and resolves the keymap; a chord never mixes the two.
|
|
|
|
mod keymap;
|
|
|
|
use std::collections::HashMap;
|
|
use std::io::Write;
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
use std::path::PathBuf;
|
|
use std::sync::atomic::AtomicBool;
|
|
use std::time::{Duration, Instant};
|
|
|
|
use color_eyre::eyre::{Result, WrapErr, eyre};
|
|
use zbus::{OwnedObjectPath, Variant};
|
|
|
|
use crate::linux::paste::Chord;
|
|
use crate::linux::portal::{Event, PortalBus};
|
|
|
|
pub(crate) const INTERFACE: &str = "org.freedesktop.portal.RemoteDesktop";
|
|
const KEYBOARD: u32 = 1;
|
|
/// Persist the grant until the user revokes it.
|
|
const PERSIST_UNTIL_REVOKED: u32 = 2;
|
|
/// Keysyms, for a chord the keymap can't confirm keycode by keycode.
|
|
const XK_CONTROL_L: i32 = 0xffe3;
|
|
const XK_SHIFT_L: i32 = 0xffe1;
|
|
const XK_A: i32 = 0x61;
|
|
const XK_C: i32 = 0x63;
|
|
const XK_V: i32 = 0x76;
|
|
const XK_RETURN: i32 = 0xff0d;
|
|
/// Evdev codes of the keys a chord holds; the keymap says whether they still
|
|
/// carry what they are named for.
|
|
const EVDEV_KEY_LEFTCTRL: i32 = 29;
|
|
const EVDEV_KEY_LEFTSHIFT: i32 = 42;
|
|
const EVDEV_KEY_ENTER: i32 = 28;
|
|
/// The pc105 keys the chord's Latin letters sit on, for a keymap that has none.
|
|
const EVDEV_KEY_A: i32 = 30;
|
|
const EVDEV_KEY_C: i32 = 46;
|
|
const EVDEV_KEY_V: i32 = 47;
|
|
const PRESSED: u32 = 1;
|
|
const RELEASED: u32 = 0;
|
|
/// A restored grant starts in tens of milliseconds; a start that takes
|
|
/// longer waited for the person in the desktop's dialog.
|
|
const DIALOG_THRESHOLD: Duration = Duration::from_millis(500);
|
|
|
|
pub(crate) struct RemoteDesktop {
|
|
bus: PortalBus,
|
|
session: OwnedObjectPath,
|
|
/// The portal handed out a restore token, so a later session restores
|
|
/// this grant without a dialog.
|
|
restorable: bool,
|
|
/// The desktop showed its approval dialog for this session.
|
|
prompted: bool,
|
|
/// The desktop already ended the session, so there is nothing to close.
|
|
ended: bool,
|
|
}
|
|
|
|
impl RemoteDesktop {
|
|
/// Starts a keyboard session, which shows the desktop's approval
|
|
/// dialog unless a saved grant restores it.
|
|
pub(crate) fn start(stop: &AtomicBool) -> Result<Self> {
|
|
let mut bus = PortalBus::open(INTERFACE, stop)?
|
|
.ok_or_else(|| eyre!("the desktop has no RemoteDesktop portal ({INTERFACE})"))?;
|
|
let began = Instant::now();
|
|
let session = bus.create_session(stop)?;
|
|
let persists = bus.version >= 2;
|
|
let restore = persists.then(load_restore_token).flatten();
|
|
bus.request(
|
|
"SelectDevices",
|
|
|token| {
|
|
let mut options = HashMap::from([
|
|
("handle_token", Variant::from(token.to_owned())),
|
|
("types", Variant::from(KEYBOARD)),
|
|
]);
|
|
if persists {
|
|
options.insert("persist_mode", Variant::from(PERSIST_UNTIL_REVOKED));
|
|
}
|
|
if let Some(restore) = restore.clone() {
|
|
options.insert("restore_token", Variant::from(restore));
|
|
}
|
|
(session.clone(), options)
|
|
},
|
|
stop,
|
|
)?;
|
|
let started = bus.request(
|
|
"Start",
|
|
|token| {
|
|
(
|
|
session.clone(),
|
|
"",
|
|
HashMap::from([("handle_token", Variant::from(token.to_owned()))]),
|
|
)
|
|
},
|
|
stop,
|
|
)?;
|
|
let devices = started
|
|
.get("devices")
|
|
.and_then(|devices| u32::try_from(devices).ok())
|
|
.unwrap_or(0);
|
|
if devices & KEYBOARD == 0 {
|
|
bus.close_session(&session);
|
|
return Err(eyre!("the desktop did not allow Hex to use the keyboard"));
|
|
}
|
|
let prompted = restore.is_none() || began.elapsed() >= DIALOG_THRESHOLD;
|
|
// Restore tokens are single-use: each start hands out the next one.
|
|
let mut restorable = false;
|
|
if let Some(token) = started
|
|
.get("restore_token")
|
|
.and_then(|token| <&str>::try_from(token).ok())
|
|
{
|
|
match save_restore_token(token) {
|
|
Ok(()) => restorable = true,
|
|
Err(error) => tracing::warn!(
|
|
error = format!("{error:#}"),
|
|
"could not save the RemoteDesktop grant"
|
|
),
|
|
}
|
|
}
|
|
Ok(Self {
|
|
bus,
|
|
session,
|
|
restorable,
|
|
prompted,
|
|
ended: false,
|
|
})
|
|
}
|
|
|
|
/// Asks the desktop for the keyboard ahead of the first paste, from
|
|
/// onboarding or Settings. The saved grant lets later pastes start
|
|
/// without a dialog.
|
|
pub(crate) fn ask() -> Result<()> {
|
|
Self::start(&AtomicBool::new(false)).map(drop)
|
|
}
|
|
|
|
/// Whether the desktop granted the keyboard before: a saved grant.
|
|
pub(crate) fn granted() -> bool {
|
|
load_restore_token().is_some()
|
|
}
|
|
|
|
/// Whether a later session restores this grant without a dialog.
|
|
pub(crate) fn restorable(&self) -> bool {
|
|
self.restorable
|
|
}
|
|
|
|
/// Whether the desktop showed its approval dialog for this session.
|
|
pub(crate) fn prompted(&self) -> bool {
|
|
self.prompted
|
|
}
|
|
|
|
/// Whether the desktop ended the session, as when the user revokes it.
|
|
pub(crate) fn closed(&mut self) -> bool {
|
|
if !self.ended {
|
|
let session = self.session.as_str().to_owned();
|
|
self.ended = self
|
|
.bus
|
|
.events()
|
|
.into_iter()
|
|
.any(|(closed, event)| closed == session && event == Event::Closed);
|
|
}
|
|
self.ended
|
|
}
|
|
|
|
/// Presses and releases a clipboard chord: Ctrl+A, Ctrl+C, or Ctrl+V
|
|
/// (Ctrl+Shift+V for terminals).
|
|
pub(crate) fn send(&self, chord: Chord, with_shift: bool) -> Result<()> {
|
|
// Read per chord, not per session: a session can outlive the keymap it
|
|
// started under (a grant that can't restore keeps it for the paster's
|
|
// lifetime), and changing a layout or variant replaces the keymap.
|
|
let keymap = keymap::read();
|
|
let (encoding, keys) = chord_keys(chord, with_shift, keymap.as_ref());
|
|
if keymap.is_none() {
|
|
tracing::debug!(
|
|
chord = ?chord,
|
|
"could not read the desktop's keymap; sending keysyms"
|
|
);
|
|
} else if encoding == Encoding::Keysym {
|
|
tracing::debug!(
|
|
chord = ?chord,
|
|
"the keymap names no single key for this chord; sending keysyms"
|
|
);
|
|
}
|
|
send_keys(&keys, encoding, |key, state| {
|
|
self.bus.call_portal(
|
|
encoding.method(),
|
|
&(
|
|
&self.session,
|
|
HashMap::<&str, Variant<'_>>::new(),
|
|
key,
|
|
state,
|
|
),
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
/// How a chord names its keys to the portal. One chord never mixes the two: a
|
|
/// keycode and a keysym for the same letter would disagree about which key is
|
|
/// held.
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
enum Encoding {
|
|
Keycode,
|
|
Keysym,
|
|
}
|
|
|
|
impl Encoding {
|
|
fn method(self) -> &'static str {
|
|
match self {
|
|
Self::Keycode => "NotifyKeyboardKeycode",
|
|
Self::Keysym => "NotifyKeyboardKeysym",
|
|
}
|
|
}
|
|
|
|
fn name(self) -> &'static str {
|
|
match self {
|
|
Self::Keycode => "keycode",
|
|
Self::Keysym => "keysym",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Sends each key in order. A call that fails may still have reached the
|
|
/// desktop, so every key still held is released before the error returns.
|
|
fn send_keys(
|
|
keys: &[(i32, u32)],
|
|
encoding: Encoding,
|
|
mut notify: impl FnMut(i32, u32) -> Result<()>,
|
|
) -> Result<()> {
|
|
let mut pressed = Vec::new();
|
|
for &(key, state) in keys {
|
|
if state == PRESSED {
|
|
// Recorded before the call: a timeout does not mean it never ran.
|
|
pressed.push(key);
|
|
}
|
|
if let Err(error) = notify(key, state) {
|
|
tracing::warn!(
|
|
encoding = encoding.name(),
|
|
key,
|
|
state,
|
|
error = format!("{error:#}"),
|
|
"could not send a paste key"
|
|
);
|
|
for key in pressed.iter().rev() {
|
|
if let Err(error) = notify(*key, RELEASED) {
|
|
tracing::warn!(
|
|
encoding = encoding.name(),
|
|
key,
|
|
error = format!("{error:#}"),
|
|
"could not release a paste key"
|
|
);
|
|
}
|
|
}
|
|
return Err(error).wrap_err_with(|| {
|
|
format!("could not send {} {key} in state {state}", encoding.name())
|
|
});
|
|
}
|
|
// A failed release stays recorded: the key may still be down, and
|
|
// releasing one already up is harmless.
|
|
if state == RELEASED
|
|
&& let Some(index) = pressed.iter().rposition(|held| *held == key)
|
|
{
|
|
pressed.remove(index);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
impl Drop for RemoteDesktop {
|
|
fn drop(&mut self) {
|
|
// Closing a session the desktop already ended (the user stopped it
|
|
// from GNOME's remote-control indicator) only fails (#718).
|
|
if !self.closed() {
|
|
self.bus.close_session(&self.session);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Presses and releases a chord's keys in order: as evdev keycodes when the
|
|
/// keymap confirms the modifiers and names one key for the letter, and as
|
|
/// keysyms otherwise. A letter no group has still goes out on its pc105 key.
|
|
fn chord_keys(
|
|
chord: Chord,
|
|
with_shift: bool,
|
|
keymap: Option<&keymap::Groups>,
|
|
) -> (Encoding, Vec<(i32, u32)>) {
|
|
if chord == Chord::Return {
|
|
return match keymap.filter(|groups| types(groups, EVDEV_KEY_ENTER, XK_RETURN)) {
|
|
Some(_) => (
|
|
Encoding::Keycode,
|
|
vec![(EVDEV_KEY_ENTER, PRESSED), (EVDEV_KEY_ENTER, RELEASED)],
|
|
),
|
|
None => (
|
|
Encoding::Keysym,
|
|
vec![(XK_RETURN, PRESSED), (XK_RETURN, RELEASED)],
|
|
),
|
|
};
|
|
}
|
|
let (letter, physical, shift) = match chord {
|
|
Chord::SelectAll => (XK_A, EVDEV_KEY_A, false),
|
|
Chord::Copy => (XK_C, EVDEV_KEY_C, false),
|
|
Chord::Paste => (XK_V, EVDEV_KEY_V, with_shift),
|
|
Chord::Return => unreachable!("returned above"),
|
|
};
|
|
let keycode = keymap.and_then(|groups| {
|
|
// Options such as `ctrl:swapcaps` put Control_L on another key, so the
|
|
// fixed code is only used when the keymap still types it there.
|
|
if !types(groups, EVDEV_KEY_LEFTCTRL, XK_CONTROL_L) {
|
|
return None;
|
|
}
|
|
if shift && !types(groups, EVDEV_KEY_LEFTSHIFT, XK_SHIFT_L) {
|
|
return None;
|
|
}
|
|
let letter = u32::try_from(letter).ok()?;
|
|
keymap::resolve(groups, letter).or_else(|| {
|
|
// The compositor's keysym path searches only the active group, so a
|
|
// letter no group has can never be typed by keysym. The physical
|
|
// pc105 key is what a real Ctrl+V press sends.
|
|
let physical = u16::try_from(physical).ok()?;
|
|
(!keymap::anywhere(groups, letter)).then_some(physical)
|
|
})
|
|
});
|
|
match keycode {
|
|
Some(code) => (
|
|
Encoding::Keycode,
|
|
presses(
|
|
EVDEV_KEY_LEFTCTRL,
|
|
EVDEV_KEY_LEFTSHIFT,
|
|
i32::from(code),
|
|
shift,
|
|
),
|
|
),
|
|
None => (
|
|
Encoding::Keysym,
|
|
presses(XK_CONTROL_L, XK_SHIFT_L, letter, shift),
|
|
),
|
|
}
|
|
}
|
|
|
|
/// Whether the keymap types `keysym` on the fixed key `code` in every group.
|
|
fn types(groups: &keymap::Groups, code: i32, keysym: i32) -> bool {
|
|
let (Ok(code), Ok(keysym)) = (u16::try_from(code), u32::try_from(keysym)) else {
|
|
return false;
|
|
};
|
|
keymap::every_group(groups, code, keysym)
|
|
}
|
|
|
|
/// Ctrl, [Shift], key, key, [Shift], Ctrl.
|
|
fn presses(control: i32, shift: i32, key: i32, with_shift: bool) -> Vec<(i32, u32)> {
|
|
let mut keys = vec![(control, PRESSED)];
|
|
if with_shift {
|
|
keys.push((shift, PRESSED));
|
|
}
|
|
keys.extend([(key, PRESSED), (key, RELEASED)]);
|
|
if with_shift {
|
|
keys.push((shift, RELEASED));
|
|
}
|
|
keys.push((control, RELEASED));
|
|
keys
|
|
}
|
|
|
|
fn restore_token_path() -> Result<PathBuf> {
|
|
Ok(crate::app_paths::support_dir()?.join("remote-desktop-token"))
|
|
}
|
|
|
|
fn load_restore_token() -> Option<String> {
|
|
let token = std::fs::read_to_string(restore_token_path().ok()?).ok()?;
|
|
let token = token.trim();
|
|
(!token.is_empty() && token.len() <= 1024).then(|| token.to_owned())
|
|
}
|
|
|
|
fn save_restore_token(token: &str) -> Result<()> {
|
|
let path = restore_token_path()?;
|
|
let directory = path
|
|
.parent()
|
|
.ok_or_else(|| eyre!("the grant has no folder"))?;
|
|
std::fs::create_dir_all(directory)?;
|
|
let staged = directory.join(format!(".remote-desktop-token.{}", std::process::id()));
|
|
let mut file = std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(true)
|
|
.mode(0o600)
|
|
.open(&staged)
|
|
.wrap_err("could not stage the grant")?;
|
|
file.write_all(token.as_bytes())?;
|
|
file.sync_all()?;
|
|
std::fs::rename(&staged, &path)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// A `us` keymap: `a`, `c`, and `v` on their QWERTY keys, and the
|
|
/// modifiers and Return where a plain layout leaves them.
|
|
fn qwerty() -> keymap::Groups {
|
|
vec![vec![
|
|
(29, u32::try_from(XK_CONTROL_L).unwrap()),
|
|
(42, u32::try_from(XK_SHIFT_L).unwrap()),
|
|
(28, u32::try_from(XK_RETURN).unwrap()),
|
|
(30, u32::try_from(XK_A).unwrap()),
|
|
(46, u32::try_from(XK_C).unwrap()),
|
|
(47, u32::try_from(XK_V).unwrap()),
|
|
]]
|
|
}
|
|
|
|
/// `ctrl:swapcaps`: Caps_Lock on 29 and Control_L on 58, with `v` still on
|
|
/// its QWERTY key.
|
|
fn swapcaps() -> keymap::Groups {
|
|
vec![vec![
|
|
(29, 0xffe5),
|
|
(58, u32::try_from(XK_CONTROL_L).unwrap()),
|
|
(42, u32::try_from(XK_SHIFT_L).unwrap()),
|
|
(28, u32::try_from(XK_RETURN).unwrap()),
|
|
(47, u32::try_from(XK_V).unwrap()),
|
|
]]
|
|
}
|
|
|
|
/// A lone `ru`: `a`, `c`, and `v` are Cyrillic on their QWERTY keys, so
|
|
/// no group types the Latin letters at all.
|
|
fn russian() -> keymap::Groups {
|
|
vec![vec![
|
|
(29, u32::try_from(XK_CONTROL_L).unwrap()),
|
|
(42, u32::try_from(XK_SHIFT_L).unwrap()),
|
|
(28, u32::try_from(XK_RETURN).unwrap()),
|
|
(30, 0x6c6), // Cyrillic_ef
|
|
(46, 0x6d3), // Cyrillic_es
|
|
(47, 0x6cd), // Cyrillic_em
|
|
]]
|
|
}
|
|
|
|
/// Both ways a chord can go out: no keymap at all, and a keymap that names
|
|
/// the letters' keys.
|
|
fn ways() -> [Option<keymap::Groups>; 2] {
|
|
[None, Some(qwerty())]
|
|
}
|
|
|
|
#[test]
|
|
fn paste_keys_balance_their_modifiers() {
|
|
// Without a keymap the chord is keysyms, as it always was.
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, None),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, true, None),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_SHIFT_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_SHIFT_L, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
// A keymap names the key each layout puts `v` on.
|
|
let keymap = qwerty();
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(47, PRESSED),
|
|
(47, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, true, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(EVDEV_KEY_LEFTSHIFT, PRESSED),
|
|
(47, PRESSED),
|
|
(47, RELEASED),
|
|
(EVDEV_KEY_LEFTSHIFT, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
}
|
|
|
|
/// A Latin-free keymap (`ru` alone) still gets the physical pc105 key: the
|
|
/// desktop's keysym path searches only the active group, where no key
|
|
/// types the letter, so it would inject nothing.
|
|
#[test]
|
|
fn a_letter_no_group_has_goes_out_on_its_physical_key() {
|
|
let keymap = russian();
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(EVDEV_KEY_V, PRESSED),
|
|
(EVDEV_KEY_V, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, true, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(EVDEV_KEY_LEFTSHIFT, PRESSED),
|
|
(EVDEV_KEY_V, PRESSED),
|
|
(EVDEV_KEY_V, RELEASED),
|
|
(EVDEV_KEY_LEFTSHIFT, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
for (chord, code) in [(Chord::SelectAll, EVDEV_KEY_A), (Chord::Copy, EVDEV_KEY_C)] {
|
|
for with_shift in [false, true] {
|
|
assert_eq!(
|
|
chord_keys(chord, with_shift, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(code, PRESSED),
|
|
(code, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// `us,us(dvorak)` disagrees about `v`, so the chord stays keysyms rather
|
|
/// than guessing one Latin layout's key for the other.
|
|
#[test]
|
|
fn disagreeing_groups_still_send_keysyms() {
|
|
let keymap = vec![
|
|
vec![(29, 0xffe3), (47, 0x76)],
|
|
vec![(29, 0xffe3), (52, 0x76)],
|
|
];
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, Some(&keymap)),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
}
|
|
|
|
/// Select-all and copy never take the terminal paste's Shift.
|
|
#[test]
|
|
fn select_all_and_copy_ignore_the_terminal_paste_preference() {
|
|
let keymap = qwerty();
|
|
for (chord, keysym, code) in [(Chord::SelectAll, XK_A, 30), (Chord::Copy, XK_C, 46)] {
|
|
for with_shift in [false, true] {
|
|
assert_eq!(
|
|
chord_keys(chord, with_shift, None),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(keysym, PRESSED),
|
|
(keysym, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(chord, with_shift, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(code, PRESSED),
|
|
(code, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Return goes out as a keycode only where the keymap still types Return
|
|
/// on it; without a keymap it stays a keysym, as it always was.
|
|
#[test]
|
|
fn return_follows_the_keymap() {
|
|
assert_eq!(
|
|
chord_keys(Chord::Return, false, None),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![(XK_RETURN, PRESSED), (XK_RETURN, RELEASED)]
|
|
)
|
|
);
|
|
let keymap = qwerty();
|
|
assert_eq!(
|
|
chord_keys(Chord::Return, false, Some(&keymap)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![(EVDEV_KEY_ENTER, PRESSED), (EVDEV_KEY_ENTER, RELEASED)]
|
|
)
|
|
);
|
|
// A layout that moved Return off 28 keeps the keysym.
|
|
let moved = vec![vec![(29, 0xffe3), (47, 0x76), (24, 0xff0d)]];
|
|
assert_eq!(
|
|
chord_keys(Chord::Return, false, Some(&moved)),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![(XK_RETURN, PRESSED), (XK_RETURN, RELEASED)]
|
|
)
|
|
);
|
|
}
|
|
|
|
/// `ctrl:swapcaps` moves Control_L off 29, where a keycode chord would
|
|
/// hold Caps_Lock instead, so the whole chord falls back to keysyms.
|
|
#[test]
|
|
fn moved_modifiers_fall_back_to_keysyms() {
|
|
let keymap = swapcaps();
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, Some(&keymap)),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, true, Some(&keymap)),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_SHIFT_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_SHIFT_L, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
|
|
// A moved Shift only matters to the chords that hold it.
|
|
let moved_shift = vec![vec![(29, 0xffe3), (42, 0xffe5), (47, 0x76)]];
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, false, Some(&moved_shift)),
|
|
(
|
|
Encoding::Keycode,
|
|
vec![
|
|
(EVDEV_KEY_LEFTCTRL, PRESSED),
|
|
(47, PRESSED),
|
|
(47, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
assert_eq!(
|
|
chord_keys(Chord::Paste, true, Some(&moved_shift)),
|
|
(
|
|
Encoding::Keysym,
|
|
vec![
|
|
(XK_CONTROL_L, PRESSED),
|
|
(XK_SHIFT_L, PRESSED),
|
|
(XK_V, PRESSED),
|
|
(XK_V, RELEASED),
|
|
(XK_SHIFT_L, RELEASED),
|
|
(XK_CONTROL_L, RELEASED)
|
|
]
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_successful_paste_sends_each_key_once() {
|
|
for keymap in ways() {
|
|
for chord in [Chord::Paste, Chord::SelectAll, Chord::Copy] {
|
|
for with_shift in [false, true] {
|
|
let (encoding, keys) = chord_keys(chord, with_shift, keymap.as_ref());
|
|
let mut sent = Vec::new();
|
|
send_keys(&keys, encoding, |key, state| {
|
|
sent.push((key, state));
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
assert_eq!(sent, keys);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_paste_releases_the_keys_it_still_holds() {
|
|
for keymap in ways() {
|
|
for chord in [Chord::Paste, Chord::SelectAll, Chord::Copy] {
|
|
for with_shift in [false, true] {
|
|
let (encoding, keys) = chord_keys(chord, with_shift, keymap.as_ref());
|
|
for fail_at in 0..keys.len() {
|
|
let mut sent = Vec::new();
|
|
let result = send_keys(&keys, encoding, |key, state| {
|
|
sent.push((key, state));
|
|
if sent.len() == fail_at + 1 {
|
|
return Err(eyre!("injected failure"));
|
|
}
|
|
Ok(())
|
|
});
|
|
assert!(result.is_err());
|
|
// Cleanup releases every key still held: each press up to
|
|
// and including the failed call, minus keys whose release
|
|
// already succeeded before it. A failed release stays in,
|
|
// since it may not have reached the desktop.
|
|
let mut held: Vec<_> = keys[..=fail_at]
|
|
.iter()
|
|
.filter(|(_, state)| *state == PRESSED)
|
|
.map(|(key, _)| *key)
|
|
.collect();
|
|
for (key, state) in &keys[..fail_at] {
|
|
if *state == RELEASED
|
|
&& let Some(index) = held.iter().rposition(|held| held == key)
|
|
{
|
|
held.remove(index);
|
|
}
|
|
}
|
|
let mut expected: Vec<_> =
|
|
held.into_iter().map(|key| (key, RELEASED)).collect();
|
|
expected.reverse();
|
|
assert_eq!(&sent[fail_at + 1..], expected, "failed at {fail_at}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_cleanup_release_keeps_the_original_error() {
|
|
for (keymap, tail) in [
|
|
(
|
|
None,
|
|
vec![
|
|
(XK_V, RELEASED),
|
|
(XK_SHIFT_L, RELEASED),
|
|
(XK_CONTROL_L, RELEASED),
|
|
],
|
|
),
|
|
(
|
|
Some(qwerty()),
|
|
vec![
|
|
(47, RELEASED),
|
|
(EVDEV_KEY_LEFTSHIFT, RELEASED),
|
|
(EVDEV_KEY_LEFTCTRL, RELEASED),
|
|
],
|
|
),
|
|
] {
|
|
let (encoding, keys) = chord_keys(Chord::Paste, true, keymap.as_ref());
|
|
let mut sent = Vec::new();
|
|
let error = send_keys(&keys, encoding, |key, state| {
|
|
sent.push((key, state));
|
|
match sent.len() {
|
|
// The V press fails partway.
|
|
3 => Err(eyre!("the original failure")),
|
|
// Its release fails too, which must not stop the cleanup.
|
|
4 => Err(eyre!("a cleanup failure")),
|
|
_ => Ok(()),
|
|
}
|
|
})
|
|
.unwrap_err();
|
|
let error = format!("{error:#}");
|
|
assert!(error.contains("the original failure"), "{error}");
|
|
assert!(!error.contains("a cleanup failure"), "{error}");
|
|
assert!(error.contains(encoding.name()), "{error}");
|
|
assert_eq!(&sent[3..], tail);
|
|
}
|
|
}
|
|
}
|