Files
app__cliphoard/src/platform/linux/x11_events.rs

191 lines
6.4 KiB
Rust

use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use anyhow::{Context, Result};
use x11rb::{
connection::Connection,
protocol::{
xfixes::{self, ConnectionExt as _},
xproto::{self, ConnectionExt as _},
Event,
},
rust_connection::RustConnection,
};
pub struct X11ClipboardWatcher {
changed: Arc<AtomicBool>,
}
impl X11ClipboardWatcher {
pub fn start() -> Result<Self> {
let (connection, screen) = RustConnection::connect(None)
.context("failed to connect to X11 for clipboard events")?;
let root = connection.setup().roots[screen].root;
let clipboard = connection.intern_atom(false, b"CLIPBOARD")?.reply()?.atom;
xfixes::query_version(&connection, 5, 0)?
.reply()
.context("XFixes clipboard events are unavailable")?;
xfixes::select_selection_input(
&connection,
root,
clipboard,
xfixes::SelectionEventMask::SET_SELECTION_OWNER,
)?
.check()?;
connection.flush()?;
let changed = Arc::new(AtomicBool::new(true));
let signal = Arc::clone(&changed);
std::thread::Builder::new()
.name("clipbhoard-x11-clipboard".into())
.spawn(move || watch_events(connection, signal))
.context("failed to start X11 clipboard event thread")?;
Ok(Self { changed })
}
pub fn take_changed(&self) -> bool {
self.changed.swap(false, Ordering::AcqRel)
}
}
fn watch_events(connection: RustConnection, changed: Arc<AtomicBool>) {
loop {
match connection.wait_for_event() {
Ok(Event::XfixesSelectionNotify(_)) => {
changed.store(true, Ordering::Release);
}
Ok(_) => {}
Err(error) => {
tracing::error!(%error, "X11 clipboard event stream stopped");
break;
}
}
}
}
pub struct X11Hotkey {
triggered: Arc<AtomicBool>,
}
impl X11Hotkey {
pub fn start(shortcut: &str) -> Result<Self> {
let (connection, screen) = RustConnection::connect(None)
.context("failed to connect to X11 for global shortcut")?;
let root = connection.setup().roots[screen].root;
let (keysym, modifiers) = parse_shortcut(shortcut)?;
let keycode = keycode_for_keysym(&connection, keysym)?;
let grab_modifiers = grab_modifier_variants(modifiers);
for grab_modifier in &grab_modifiers {
connection
.grab_key(
false,
root,
*grab_modifier,
keycode,
xproto::GrabMode::ASYNC,
xproto::GrabMode::ASYNC,
)?
.check()
.with_context(|| {
format!(
"failed to register global shortcut '{shortcut}' (it may already be registered)"
)
})?;
}
connection.flush()?;
let triggered = Arc::new(AtomicBool::new(false));
let signal = Arc::clone(&triggered);
std::thread::Builder::new()
.name("clipbhoard-x11-hotkey".into())
.spawn(move || {
watch_hotkey(connection, root, keycode, grab_modifiers, modifiers, signal)
})
.context("failed to start X11 hotkey thread")?;
Ok(Self { triggered })
}
pub fn take_triggered(&self) -> bool {
self.triggered.swap(false, Ordering::AcqRel)
}
}
fn watch_hotkey(
connection: RustConnection,
root: xproto::Window,
keycode: xproto::Keycode,
grab_modifiers: Vec<xproto::ModMask>,
modifiers: xproto::ModMask,
triggered: Arc<AtomicBool>,
) {
while let Ok(event) = connection.wait_for_event() {
if let Event::KeyPress(event) = event {
if event.detail == keycode && event.state.bits() & modifiers.bits() == modifiers.bits()
{
triggered.store(true, Ordering::Release);
}
}
}
for grab_modifier in grab_modifiers {
let _ = connection.ungrab_key(keycode, root, grab_modifier);
}
let _ = connection.flush();
}
fn grab_modifier_variants(modifiers: xproto::ModMask) -> Vec<xproto::ModMask> {
let locks = [
xproto::ModMask::from(0u8),
xproto::ModMask::M2,
xproto::ModMask::LOCK,
xproto::ModMask::M5,
xproto::ModMask::M2 | xproto::ModMask::LOCK,
xproto::ModMask::M2 | xproto::ModMask::M5,
xproto::ModMask::LOCK | xproto::ModMask::M5,
xproto::ModMask::M2 | xproto::ModMask::LOCK | xproto::ModMask::M5,
];
locks.into_iter().map(|lock| modifiers | lock).collect()
}
fn keycode_for_keysym(
connection: &RustConnection,
keysym: xproto::Keysym,
) -> Result<xproto::Keycode> {
let setup = connection.setup();
let first = setup.min_keycode;
let count = setup.max_keycode.saturating_sub(first).saturating_add(1);
let mapping = connection.get_keyboard_mapping(first, count)?.reply()?;
let per_key = mapping.keysyms_per_keycode as usize;
for (offset, keysyms) in mapping.keysyms.chunks(per_key).enumerate() {
if keysyms.iter().any(|candidate| *candidate == keysym) {
return Ok(first + offset as u8);
}
}
anyhow::bail!("could not resolve the V keycode from the X11 keyboard mapping")
}
fn parse_shortcut(shortcut: &str) -> Result<(xproto::Keysym, xproto::ModMask)> {
let parts: Vec<_> = shortcut.split('+').map(str::trim).collect();
let key = parts
.last()
.filter(|key| key.chars().count() == 1)
.context("global shortcut must end with one key, for example Super+V")?;
let key_char = key.chars().next().unwrap().to_ascii_uppercase();
let keysym = key_char as u32;
let mut modifiers = xproto::ModMask::from(0u8);
for modifier in &parts[..parts.len().saturating_sub(1)] {
modifiers |= match modifier.to_ascii_lowercase().as_str() {
"super" | "meta" | "win" | "windows" => xproto::ModMask::M4,
"ctrl" | "control" => xproto::ModMask::CONTROL,
"alt" => xproto::ModMask::M1,
"shift" => xproto::ModMask::SHIFT,
_ => anyhow::bail!("unsupported modifier '{modifier}' in shortcut '{shortcut}'"),
};
}
if modifiers.bits() == 0 {
anyhow::bail!("global shortcut must include a modifier: '{shortcut}'")
}
Ok((keysym, modifiers))
}