Struct Worker 

struct Worker {
    context: Context,
    converter: EiEventConverter,
    devices: Vec<Device>,
    last_serial: u32,
    mod_refs: HashMap<u32, u32>,
    pressed: HashMap<u32, (u32, Vec<u32>)>,
}

Fields

context: Context

converter: EiEventConverter

devices: Vec<Device>

last_serial: u32

mod_refs: HashMap<u32, u32>

Held modifier evdev keycodes and their press count, so a key that synthesized a modifier releases exactly what it added.

pressed: HashMap<u32, (u32, Vec<u32>)>

Per xkb keycode, the evdev key and synthesized modifiers its press emitted, replayed on release so a mid-stream keymap read cannot desync it.

Implementations

impl Worker

fn run( context: Context, wake_rd: OwnedFd, queue: Arc<Mutex<Vec<Cmd>>>, alive: Arc<AtomicBool>, ready: Arc<(Mutex<Option<Result<(), String>>>, Condvar)>, )

fn signal( ready: &Arc<(Mutex<Option<Result<(), String>>>, Condvar)>, result: Result<(), String>, )

fn has(&self, f: impl Fn(&Device) -> bool) -> bool

fn poll(&self, wake_fd: i32, timeout: i32) -> bool

Block until the socket or the wake pipe is readable (or timeout ms elapses, -1 for no limit); false on a poll error that should end the session.

fn pump_socket(&mut self) -> Result<(), ()>

Read and dispatch whatever the server sent; Err on a closed or broken socket.

fn handle(&mut self, event: EiEvent)

fn find_mut(&mut self, device: &Device) -> Option<&mut Device>

fn drain(&mut self, queue: &Arc<Mutex<Vec<Cmd>>>)

fn emit(&mut self, cmd: Cmd)

fn emit_key(&mut self, xkb_keycode: u32, keysym: Option<u32>, pressed: bool)

fn resolve_key( &self, index: usize, xkb_keycode: u32, keysym: Option<u32>, ) -> (u32, Vec<u32>)

The evdev keycode and modifier evdev keycodes to press this key with: its base keysym placed in the compositor’s own keymap where that keymap carries it, else the raw keycode.

fn ready_index(&self, want: impl Fn(&Device) -> bool) -> Option<usize>

The lowest-indexed resumed device matching want.

fn start(&mut self, index: usize)

fn frame(&mut self, index: usize)