Struct KeyRepeater 

pub struct KeyRepeater { /* private fields */ }

Auto-repeat driven by a timer the caller polls.

Register fd on the same epoll as everything else, feed every real key event to on_key, and call dispatch when the descriptor is readable.

The decisions live in Repeat; this is the timer around them.

Implementations

impl KeyRepeater

pub fn new(config: RepeatConfig) -> Result<Self, InputError>

Create a repeater with its own timer.

Errors

InputError::Config for a zero interval, which would leave the timer firing as fast as the kernel can wake the loop. A zero delay is allowed and means the first repeat lands on the next tick.

InputError::Timer if the timer cannot be created.

Examples found in repository

examples/input.rs (line 37)

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 fd(&self) -> BorrowedFd<'_>

The descriptor to poll. Readable when a repeat is due.

Examples found in repository

examples/input.rs (line 47)

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 const fn held_key(&self) -> Option<u32>

The key currently repeating.

pub fn on_key(&mut self, event: &KeyEvent, repeats: bool)

Feed a real key event.

repeats is the keymap’s answer for this key; see Repeat::on_key.

Examples found in repository

examples/input.rs (line 67)

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 cancel(&mut self)

Stop repeating, and stop the timer.

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

Drain the timer and append whatever repeats are due.

Nothing is appended if no key is held, or if the descriptor had nothing to say. The events carry only the key – run them through Keyboard::resolve for sym and utf8.

Errors

InputError::Timer if the timer cannot be read. EAGAIN is not one: a descriptor that was not ready simply produces nothing.

Examples found in repository

examples/input.rs (line 77)

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;
        }
    }
}

Trait Implementations

impl Debug for KeyRepeater

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

Formats the value using the given formatter.