use crate::paste::{PasteOutcome, Shortcut};
use std::os::fd::AsFd;
use std::sync::Mutex;
use std::time::Instant;
use wayland_client::protocol::{wl_registry, wl_seat};
use wayland_client::{Connection, Dispatch, Proxy, QueueHandle};
use wayland_protocols_misc::zwp_virtual_keyboard_v1::client::{
zwp_virtual_keyboard_manager_v1::{self, ZwpVirtualKeyboardManagerV1},
zwp_virtual_keyboard_v1::{self, ZwpVirtualKeyboardV1},
};
use xkbcommon::xkb;
const KEY_LEFTCTRL: u32 = 29;
const KEY_LEFTSHIFT: u32 = 42;
const KEY_V: u32 = 47;
const KEYMAP_FORMAT_XKB_V1: u32 = 1;
const KEY_STATE_RELEASED: u32 = 0;
const KEY_STATE_PRESSED: u32 = 1;
struct RegistryState {
manager: Option<ZwpVirtualKeyboardManagerV1>,
seat: Option<wl_seat::WlSeat>,
}
impl Dispatch<wl_registry::WlRegistry, ()> for RegistryState {
fn event(
state: &mut Self,
registry: &wl_registry::WlRegistry,
event: wl_registry::Event,
_: &(),
_: &Connection,
qh: &QueueHandle<Self>,
) {
if let wl_registry::Event::Global {
name,
interface,
version,
} = event
{
if interface == ZwpVirtualKeyboardManagerV1::interface().name {
let bound = version.min(ZwpVirtualKeyboardManagerV1::interface().version);
state.manager = Some(registry.bind::<ZwpVirtualKeyboardManagerV1, _, _>(
name, bound, qh, (),
));
} else if interface == wl_seat::WlSeat::interface().name && state.seat.is_none() {
let bound = version.min(wl_seat::WlSeat::interface().version);
state.seat = Some(registry.bind::<wl_seat::WlSeat, _, _>(name, bound, qh, ()));
}
}
}
}
impl Dispatch<wl_seat::WlSeat, ()> for RegistryState {
fn event(_: &mut Self, _: &wl_seat::WlSeat, _: wl_seat::Event, _: &(), _: &Connection, _: &QueueHandle<Self>) {
}
}
impl Dispatch<ZwpVirtualKeyboardManagerV1, ()> for RegistryState {
fn event(
_: &mut Self,
_: &ZwpVirtualKeyboardManagerV1,
_: zwp_virtual_keyboard_manager_v1::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
}
}
impl Dispatch<ZwpVirtualKeyboardV1, ()> for RegistryState {
fn event(
_: &mut Self,
_: &ZwpVirtualKeyboardV1,
_: zwp_virtual_keyboard_v1::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
}
}
struct Inner {
connection: Connection,
keyboard: ZwpVirtualKeyboardV1,
ctrl_bit: u32,
shift_bit: u32,
started: Instant,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Request {
Modifiers(u32),
Key(u32, u32),
}
fn combo_requests(shortcut: Shortcut, ctrl_bit: u32, shift_bit: u32) -> Vec<Request> {
let shift = matches!(shortcut, Shortcut::CtrlShiftV);
let mods = ctrl_bit | if shift { shift_bit } else { 0 };
let mut requests = vec![Request::Modifiers(mods), Request::Key(KEY_LEFTCTRL, KEY_STATE_PRESSED)];
if shift {
requests.push(Request::Key(KEY_LEFTSHIFT, KEY_STATE_PRESSED));
}
requests.push(Request::Key(KEY_V, KEY_STATE_PRESSED));
requests.push(Request::Key(KEY_V, KEY_STATE_RELEASED));
if shift {
requests.push(Request::Key(KEY_LEFTSHIFT, KEY_STATE_RELEASED));
}
requests.push(Request::Key(KEY_LEFTCTRL, KEY_STATE_RELEASED));
requests.push(Request::Modifiers(0));
requests
}
impl Inner {
fn send_combo(&mut self, shortcut: Shortcut) -> bool {
let time = self.started.elapsed().as_millis() as u32;
for request in combo_requests(shortcut, self.ctrl_bit, self.shift_bit) {
match request {
Request::Modifiers(mods) => self.keyboard.modifiers(mods, 0, 0, 0),
Request::Key(keycode, state) => self.keyboard.key(time, keycode, state),
}
}
if let Err(e) = self.connection.flush() {
tracing::warn!(error = %e, "failed to flush a synthesized paste; the clipboard is still set");
return false;
}
let bounded = std::sync::mpsc::channel();
let connection = self.connection.clone();
std::thread::spawn(move || {
let _ = bounded.0.send(connection.roundtrip());
});
match bounded.1.recv_timeout(ROUNDTRIP_TIMEOUT) {
Ok(Ok(_)) => true,
Ok(Err(e)) => {
tracing::warn!(error = %e, "the compositor closed the connection while taking a synthesized paste");
false
}
Err(_) => {
tracing::warn!("the compositor did not acknowledge a synthesized paste in time");
true
}
}
}
}
pub struct WaylandPaster {
inner: Option<Mutex<Inner>>,
}
impl WaylandPaster {
pub fn connect() -> anyhow::Result<Self> {
match try_connect() {
Ok(inner) => Ok(WaylandPaster {
inner: Some(Mutex::new(inner)),
}),
Err(e) => {
tracing::info!(
error = %e,
"zwp-virtual-keyboard-manager-v1 unavailable; paste synthesis disabled, clipboard still works"
);
Ok(WaylandPaster { inner: None })
}
}
}
}
const ROUNDTRIP_TIMEOUT: std::time::Duration = std::time::Duration::from_millis(500);
impl crate::paste::PasteSynthesizer for WaylandPaster {
fn paste(&self, shortcut: Shortcut) -> PasteOutcome {
let Some(inner) = &self.inner else {
return PasteOutcome::Unavailable;
};
let mut inner = inner.lock().unwrap_or_else(|e| e.into_inner());
if inner.send_combo(shortcut) {
PasteOutcome::Dispatched
} else {
PasteOutcome::Unavailable
}
}
}
fn try_connect() -> anyhow::Result<Inner> {
let connection = Connection::connect_to_env()?;
let display = connection.display();
let mut event_queue = connection.new_event_queue::<RegistryState>();
let qh = event_queue.handle();
let mut state = RegistryState {
manager: None,
seat: None,
};
let _registry = display.get_registry(&qh, ());
event_queue.roundtrip(&mut state)?;
let manager = state.manager.ok_or_else(|| {
anyhow::anyhow!("compositor does not advertise zwp-virtual-keyboard-manager-v1")
})?;
let seat = state
.seat
.ok_or_else(|| anyhow::anyhow!("compositor advertises the virtual keyboard manager but no wl_seat"))?;
let keyboard = manager.create_virtual_keyboard(&seat, &qh, ());
let (keymap_text, ctrl_bit, shift_bit) = compile_keymap()?;
upload_keymap(&keyboard, &keymap_text)?;
connection.flush()?;
Ok(Inner {
connection,
keyboard,
ctrl_bit,
shift_bit,
started: Instant::now(),
})
}
fn compile_keymap() -> anyhow::Result<(String, u32, u32)> {
let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
let keymap = xkb::Keymap::new_from_names(
&context,
"evdev",
"",
"us",
"",
None,
xkb::KEYMAP_COMPILE_NO_FLAGS,
)
.ok_or_else(|| anyhow::anyhow!("libxkbcommon could not compile a default \"us\" keymap"))?;
let ctrl_index = keymap.mod_get_index(xkb::MOD_NAME_CTRL);
if ctrl_index == xkb::MOD_INVALID {
anyhow::bail!("compiled keymap has no Control modifier");
}
let shift_index = keymap.mod_get_index(xkb::MOD_NAME_SHIFT);
if shift_index == xkb::MOD_INVALID {
anyhow::bail!("compiled keymap has no Shift modifier");
}
Ok((
keymap.get_as_string(xkb::KEYMAP_FORMAT_TEXT_V1),
1u32 << ctrl_index,
1u32 << shift_index,
))
}
fn upload_keymap(keyboard: &ZwpVirtualKeyboardV1, text: &str) -> anyhow::Result<()> {
use std::io::Write;
let mut file = tempfile::tempfile()?;
file.write_all(text.as_bytes())?;
file.flush()?;
keyboard.keymap(KEYMAP_FORMAT_XKB_V1, file.as_fd(), text.len() as u32);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_control_bit_is_read_back_from_the_compiled_keymap_not_assumed() {
let (text, ctrl_bit, shift_bit) = compile_keymap().expect("the system's \"us\" keymap must compile");
assert!(!text.is_empty());
assert!(text.contains("xkb_keymap"));
assert_ne!(ctrl_bit, 0, "Control must resolve to some non-zero bit");
assert_ne!(shift_bit, 0, "Shift must resolve to some non-zero bit");
assert_ne!(ctrl_bit, shift_bit, "Control and Shift must not resolve to the same bit");
assert!(text.to_lowercase().contains("control"));
}
const CTRL_BIT: u32 = 0b0100;
const SHIFT_BIT: u32 = 0b0001;
#[test]
fn every_pressed_key_is_released_for_ctrl_shift_v() {
let requests = combo_requests(Shortcut::CtrlShiftV, CTRL_BIT, SHIFT_BIT);
for key in [KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_V] {
let presses = requests.iter().filter(|r| **r == Request::Key(key, KEY_STATE_PRESSED)).count();
let releases = requests.iter().filter(|r| **r == Request::Key(key, KEY_STATE_RELEASED)).count();
assert_eq!(presses, 1, "key {key} must be pressed exactly once");
assert_eq!(releases, 1, "key {key} must be released exactly once");
}
}
#[test]
fn ctrl_v_never_presses_or_bit_sets_shift() {
let requests = combo_requests(Shortcut::CtrlV, CTRL_BIT, SHIFT_BIT);
assert!(!requests.contains(&Request::Key(KEY_LEFTSHIFT, KEY_STATE_PRESSED)));
assert!(!requests.contains(&Request::Key(KEY_LEFTSHIFT, KEY_STATE_RELEASED)));
for request in &requests {
if let Request::Modifiers(mods) = request {
assert_eq!(mods & SHIFT_BIT, 0, "Shift's bit must never be set for plain Ctrl+V");
}
}
}
#[test]
fn modifiers_are_set_first_and_cleared_last_for_both_shortcuts() {
for shortcut in [Shortcut::CtrlV, Shortcut::CtrlShiftV] {
let requests = combo_requests(shortcut, CTRL_BIT, SHIFT_BIT);
let first = requests.first().copied().unwrap();
let last = requests.last().copied().unwrap();
assert!(matches!(first, Request::Modifiers(mods) if mods != 0), "{shortcut:?}: first request must set modifiers");
assert_eq!(last, Request::Modifiers(0), "{shortcut:?}: last request must clear every modifier");
for middle in &requests[1..requests.len() - 1] {
assert!(matches!(middle, Request::Key(_, _)));
}
}
}
#[test]
fn ctrl_shift_v_sets_both_bits_in_the_same_modifiers_request() {
let requests = combo_requests(Shortcut::CtrlShiftV, CTRL_BIT, SHIFT_BIT);
let Request::Modifiers(mods) = requests[0] else { panic!("expected a Modifiers request first") };
assert_eq!(mods, CTRL_BIT | SHIFT_BIT);
}
}