Struct CuX11Backend 

pub struct CuX11Backend {
    conn: RustConnection,
    root: u32,
    has_xfixes: bool,
    reverse_keymap: RefCell<Option<ServerKeymap>>,
}

Fields

conn: RustConnection

root: u32

has_xfixes: bool

reverse_keymap: RefCell<Option<ServerKeymap>>

Reverse map of the SERVER keymap, built lazily from GetKeyboardMapping and kept for this backend’s lifetime — one request (the backend is per-request), so a setxkbmap switch is seen by the next request.

Implementations

impl CuX11Backend

pub fn connect() -> Result<Self, String>

Connect to the X server named by DISPLAY and negotiate XTEST (required for any injection). XFixes is optional and only gates cursor compositing in screenshots.

fn build_reverse_keymap(&self) -> ServerKeymap

Build the reverse view of the server’s current keymap from GetKeyboardMapping.

Column -> (group, level) convention, as observed on XKB-compat servers (Xvfb/Xorg under setxkbmap de: keycode 24 = q Q q Q at Greek_OMEGA at): columns 0/1 are group-1 plain/Shift, columns 2/3 mirror them as core group 2, and columns 4/5 carry group-1 levels 3/4 (AltGr, Shift+AltGr). Columns 4/5 are consulted only when the map carries a level-3 modifier key to synthesize; columns 2/3 (group 2) never are.

fn fake_input(&self, kind: u8, detail: u8, root: u32, x: i16, y: i16)

Fire one XTEST fake event and flush so it reaches the server before the action layer’s inter-event pacing sleep, matching the immediacy of real input.

fn root_geometry(&self) -> Result<(u16, u16), String>

fn sync(&self) -> Result<(), String>

One server round trip, forcing everything already sent on this connection to be processed before the next request is issued (the XSync idiom).

fn type_with_transient_binds( &self, keysyms: &[u32], seq: &mut dyn FnMut(&HashMap<u32, u32>), ) -> Result<(), String>

Bind keysyms onto spare keycodes and run seq with the keysym -> keycode map, choose/bind/inject atomically under a server grab; then, after a settle window, restore the spares under a second grab. The settle exists because clients translate a keycode by RE-FETCHING the keymap when they process the bind’s MappingNotify — a fetch the grab itself blocks — so a restore issued inside the first grab would be what they read back and every transient key would translate to nothing (observed with xterm). Once seq has run, every failure is logged and swallowed so the caller never re-runs the sequence.

fn restore_transient_binds( &self, span_lo: u32, count: u8, per: usize, bound_syms: &[u32], chosen: &[u32], ) -> Result<(), String>

Return the transiently bound spares to all-NoSymbol with ONE conditional ChangeKeyboardMapping under its own grab. The span is re-fetched under that grab and only spares still carrying OUR content are cleared; a keycode another client (selkies’ allocator) claimed during the settle window keeps that client’s content — this restore can never clobber a foreign binding.

Trait Implementations

impl CuBackend for CuX11Backend

fn name(&self) -> &'static str

fn fb_size(&self) -> Result<(i32, i32), String>

fn key(&self, scancode: u32, pressed: bool)

fn mouse_move(&self, x: f64, y: f64)

fn button(&self, btn: CuButton, pressed: bool)

fn scroll(&self, dx: f64, dy: f64)

fn screenshot_png(&self, display: u32) -> Result<Vec<u8>, String>

PNG of one display’s framebuffer; 0 = the primary. Unknown ids are an error.

fn cursor_pos(&self) -> Result<(f64, f64), String>

fn resolve_keysyms(&self, keysyms: &[u32]) -> Vec<(u32, u32)>

Resolve keysyms against the backend’s ACTIVE keymap: one (keycode, shift level) per input keysym, (0, 0) where the keymap cannot produce it. Level bit 0 = Shift, bit 1 = AltGr — the order xkb two/four-level key types use. Wayland resolves through the compositor’s keymap policy (overlay-binding what the base lacks); X11 through the server’s own GetKeyboardMapping.

fn altgr_keycode(&self) -> u32

Keycode synthesized around AltGr-level hits (level bit 1). The default is the pc105 right-Alt position the compositor’s seat keymap binds to ISO_Level3_Shift; the X11 backend overrides it with the level-3 modifier key found in the server’s keymap (0 = none, in which case resolve_keysyms reports no AltGr levels).

fn with_transient_keysyms( &self, keysyms: &[u32], seq: &mut dyn FnMut(&HashMap<u32, u32>), )

Run seq with every keysym in keysyms (which resolve_keysyms could not place) made temporarily typeable, when the backend can arrange that; seq receives keysym -> keycode for the transient bindings (empty when none could be arranged, in which case those keysyms simply stay untypeable). Wayland’s resolve_keysyms already overlay-binds anything the base keymap lacks, so the default runs seq with no bindings; the X11 backend overrides this with a grab-atomic spare-keycode remap.

fn display_fb_size(&self, display: u32) -> Result<(i32, i32), String>

One display’s framebuffer size; 0 = the primary. Unknown ids are an error. The X11 backend serves only the root (display 0); Wayland resolves any live output id.

impl Drop for CuX11Backend

fn drop(&mut self)

Closing the connection can race the server’s client teardown against still-buffered fake-input requests (observed as lost button releases); one round trip forces the server to consume everything sent on this connection before it goes away.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.