191 lines
6.4 KiB
Rust
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))
|
|
}
|