Struct Seat 

pub struct Seat { /* private fields */ }

Available on crate feature libinput only.

Every input device on one seat.

Poll AsFd, call dispatch when it is readable, and act on what comes back. Nothing is delivered through a callback: an event loop that has to reason about what a handler might re-enter is harder than one that gets a list.

Implementations

impl Seat

pub fn open(options: &SeatOptions) -> Result<Self, InputError>

Open the seat, opening its devices directly.

Needs read access to /dev/input/event*, which outside a login session means root or the input group. For devices that survive a VT switch, use Seat::open_with and route through a session instead.

Everything typed on this machine comes through here, including into other applications: an evdev reader is a keylogger that happens to be asked politely. That is inherent to the interface – it is why the permission is restricted – and it is worth being deliberate about where the events go.

Errors

InputError::Seat if libinput cannot enumerate the seat through udev. An unknown seat name is not an error; see SeatOptions::seat.

Examples found in repository

examples/input.rs (line 29)

fn main() {
    let mut seat = match Seat::open(&SeatOptions::default()) {
        Ok(seat) => seat,
        Err(error) => {
            eprintln!("{error}");
            std::process::exit(1);
        }
    };
    let mut keyboard = Keyboard::from_names(&KeymapNames::default()).expect("keymap");
    let mut repeater = KeyRepeater::new(RepeatConfig::default()).expect("timer");

    let started = Instant::now();
    let mut events = Vec::new();
    let mut repeats: Vec<KeyEvent> = Vec::new();
    let mut leds = keyboard.leds();

    loop {
        {
            let seat_fd = seat.as_fd();
            let timer_fd = repeater.fd();
            let mut fds = [
                PollFd::new(&seat_fd, PollFlags::IN),
                PollFd::new(&timer_fd, PollFlags::IN),
            ];
            let timeout = Duration::from_secs(30).try_into().expect("timeout");
            if poll(&mut fds, Some(&timeout)).expect("poll") == 0 {
                println!("nothing for thirty seconds");
                return;
            }
        }

        let now = u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);

        events.clear();
        seat.dispatch(&mut events).expect("dispatch");
        for event in &mut events {
            match event {
                InputEvent::Key(key) => {
                    keyboard.process_key(key);
                    repeater.on_key(key, keyboard.should_repeat(key.key));
                    if report(key) {
                        return;
                    }
                }
                other => println!("{other:?}"),
            }
        }

        repeats.clear();
        repeater.dispatch(now, &mut repeats).expect("repeat");
        for key in &mut repeats {
            // Resolved, not replayed: a Shift pressed since the key went down
            // changes what this types.
            keyboard.resolve(key);
            report(key);
        }

        let current = keyboard.leds();
        if current != leds {
            seat.set_leds(current);
            leds = current;
        }
    }
}

pub fn open_with( options: &SeatOptions, opener: impl LibinputInterface + 'static, ) -> Result<Self, InputError>

Open the seat, opening its devices through opener.

The hook libinput calls for every privileged open and its matching close. Implement LibinputInterface over a drmkit_session::Session and every /dev/input/event* libinput touches gets the same revocable lifetime as the DRM device – which is what makes a VT switch give the keyboard back.

Errors

As Seat::open.

pub fn dispatch(&mut self, out: &mut Vec<InputEvent>) -> Result<(), InputError>

Read whatever the devices have to say, appending to out.

Device arrivals and departures are handled here and not reported: they are this type’s bookkeeping, and a consumer that wants to know which devices exist has udev for it.

Errors

InputError::Dispatch if libinput cannot read its descriptor.

Examples found in repository

examples/input.rs (line 62)

fn main() {
    let mut seat = match Seat::open(&SeatOptions::default()) {
        Ok(seat) => seat,
        Err(error) => {
            eprintln!("{error}");
            std::process::exit(1);
        }
    };
    let mut keyboard = Keyboard::from_names(&KeymapNames::default()).expect("keymap");
    let mut repeater = KeyRepeater::new(RepeatConfig::default()).expect("timer");

    let started = Instant::now();
    let mut events = Vec::new();
    let mut repeats: Vec<KeyEvent> = Vec::new();
    let mut leds = keyboard.leds();

    loop {
        {
            let seat_fd = seat.as_fd();
            let timer_fd = repeater.fd();
            let mut fds = [
                PollFd::new(&seat_fd, PollFlags::IN),
                PollFd::new(&timer_fd, PollFlags::IN),
            ];
            let timeout = Duration::from_secs(30).try_into().expect("timeout");
            if poll(&mut fds, Some(&timeout)).expect("poll") == 0 {
                println!("nothing for thirty seconds");
                return;
            }
        }

        let now = u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);

        events.clear();
        seat.dispatch(&mut events).expect("dispatch");
        for event in &mut events {
            match event {
                InputEvent::Key(key) => {
                    keyboard.process_key(key);
                    repeater.on_key(key, keyboard.should_repeat(key.key));
                    if report(key) {
                        return;
                    }
                }
                other => println!("{other:?}"),
            }
        }

        repeats.clear();
        repeater.dispatch(now, &mut repeats).expect("repeat");
        for key in &mut repeats {
            // Resolved, not replayed: a Shift pressed since the key went down
            // changes what this types.
            keyboard.resolve(key);
            report(key);
        }

        let current = keyboard.leds();
        if current != leds {
            seat.set_leds(current);
            leds = current;
        }
    }
}

pub fn suspend(&mut self)

Close every device, keeping the seat.

For a session pause. The descriptors are about to stop working, and libinput reading a revoked one produces a stream of errors rather than events.

pub fn resume(&mut self) -> Result<(), InputError>

Reopen everything after a suspend.

Devices arrive as ordinary additions on the next dispatch, and the lights are restored with them.

Errors

InputError::Seat if libinput cannot re-enumerate.

pub fn set_leds(&mut self, leds: Leds)

Drive the lock lights on every keyboard.

xkb owns the latch and the device owns the light; this is the wire between them. Read Keyboard::leds after a key and push it here when it has changed.

Examples found in repository

examples/input.rs (line 87)

fn main() {
    let mut seat = match Seat::open(&SeatOptions::default()) {
        Ok(seat) => seat,
        Err(error) => {
            eprintln!("{error}");
            std::process::exit(1);
        }
    };
    let mut keyboard = Keyboard::from_names(&KeymapNames::default()).expect("keymap");
    let mut repeater = KeyRepeater::new(RepeatConfig::default()).expect("timer");

    let started = Instant::now();
    let mut events = Vec::new();
    let mut repeats: Vec<KeyEvent> = Vec::new();
    let mut leds = keyboard.leds();

    loop {
        {
            let seat_fd = seat.as_fd();
            let timer_fd = repeater.fd();
            let mut fds = [
                PollFd::new(&seat_fd, PollFlags::IN),
                PollFd::new(&timer_fd, PollFlags::IN),
            ];
            let timeout = Duration::from_secs(30).try_into().expect("timeout");
            if poll(&mut fds, Some(&timeout)).expect("poll") == 0 {
                println!("nothing for thirty seconds");
                return;
            }
        }

        let now = u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);

        events.clear();
        seat.dispatch(&mut events).expect("dispatch");
        for event in &mut events {
            match event {
                InputEvent::Key(key) => {
                    keyboard.process_key(key);
                    repeater.on_key(key, keyboard.should_repeat(key.key));
                    if report(key) {
                        return;
                    }
                }
                other => println!("{other:?}"),
            }
        }

        repeats.clear();
        repeater.dispatch(now, &mut repeats).expect("repeat");
        for key in &mut repeats {
            // Resolved, not replayed: a Shift pressed since the key went down
            // changes what this types.
            keyboard.resolve(key);
            report(key);
        }

        let current = keyboard.leds();
        if current != leds {
            seat.set_leds(current);
            leds = current;
        }
    }
}

pub fn keyboard_count(&self) -> usize

How many keyboard-capable devices are on the seat.

Trait Implementations

impl AsFd for Seat

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl Debug for Seat

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

Formats the value using the given formatter.