Struct InputBackend 

pub struct InputBackend { /* private fields */ }

Every usable input device, read together.

Implementations

impl InputBackend

pub fn open_all(surface: Size) -> Result<Self, EvdevError>

Opens every pointer, touch and keyboard device the process can read.

Devices that cannot be opened are skipped rather than fatal: a machine with one unreadable node and one good keyboard should still take input.

pub fn devices(&self) -> &[InputDevice]

The devices that were opened.

pub fn set_layout(&mut self, layout: &'static Layout)

Reads every keyboard with layout.

Defaults to layout::US, because KeyCode names US positions and a different default would make the two disagree out of the box. A panel shipped to Norway sets this once at startup; there is no runtime layout switching to discover, because a kiosk has one keyboard and it does not change.

pub fn set_layout_from_system(&mut self) -> (&'static Layout, LayoutSource)

Reads every keyboard with the layout this system is configured for.

Checks DENISE_KEYMAP, then XKB_DEFAULT_LAYOUT, then the console keyboard configuration files distributions actually write — so a Pi whose /etc/conf.d/loadkmap says Norwegian gets Norwegian without anyone having to remember an environment variable.

Returns what was chosen and where it came from, which is worth logging: a system configured for a layout Denise has no table for falls back to US, and that is far easier to diagnose when the panel says so.

pub fn raw_fds(&self) -> Vec<RawFd>

Descriptors to wait on.

Hand these, plus the DRM device’s, to poll/epoll so the process sleeps until either input arrives or the display retires a flip.

pub fn resize(&mut self, size: Size)

Tells every device the surface changed size.

pub fn pointer(&self) -> Point

The pointer position shared by all pointing devices.

pub fn last_event_age(&self) -> Option<Duration>

How long the most recently read event had been waiting.

The kernel timestamps an event when the driver receives it, so this is the delay between the hardware reporting and this process reading — time spent queued, which no measurement taken after the read can see. None until something has been read.

A frame loop keeping up reads events within a millisecond or so of the kernel taking them. A growing figure means the loop is falling behind and is drawing positions the user has already moved on from.

Trait Implementations

impl Debug for InputBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InputSource for InputBackend

fn poll(&mut self, out: &mut Vec<InputEvent>)

Appends every pending event to out, leaving existing contents alone.