Struct console_input::keypress::Input

#[non_exhaustive]
pub struct Input {
    pub frame_skip: bool,
    pub event: Option<Event>,
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

frame_skip: bool

Returns true if the next frame should be skipped due to the previous frame taking too long

event: Option<Event>

Implementations

impl Input

pub fn read() -> Self

Wait to get an input. When raw mode is disabled, the input will only be registered after enter is pressed. Call enable_raw_mode() to avoid having to press enter

Examples found in repository

examples/single-char-input.rs (line 13)

fn main() {
    keypress::enable_raw_mode();

    loop {
        if let Some(Event::Key(key_event)) = Input::read().exit_on_kb_interrupt().event {
            match key_event {
                KeyEvent {
                    code: KeyCode::Char(char),
                    ..
                } => printr!("You pressed the {} key!", char),
                KeyEvent {
                    code: KeyCode::Enter,
                    kind: KeyEventKind::Press,
                    ..
                } => printr!("You pressed enter!"),
                _ => (),
            }
        }
    }
}

pub fn sleep_for_input(dur: Duration) -> Self

Spend the given duration attempted to get a keyboard press. Returns None if no event found within time limit. This function will always take the given duration to execute, even if an event is captured sooner than intended

pub fn sleep_fps_and_get_input(fps: f32, elapsed: Duration) -> Self

sleep for 1/fps given the passed fps argument, taking away the pass elapsed value to account for however long it took your gameloop to run. The returned bool is true if elapsed was more than 1/fps, in which case you should attempt to skip the next frame the best that you can

This function is intended to be inserted into MainLoopRoot::sleep_and_get_input_data in gemini-engine

pub fn as_tuple(&self) -> (bool, Option<Event>)

Generate a tuple from the input. Ideal to plug into gemini-engine’s MainLoopRoot::sleep_and_get_input_data

pub fn exit_on_kb_interrupt(self) -> Self

If this input was a Ctrl+C (Keyboard Interrupt), exit immediately. Consumes the original Input but returns it immediately, so is intended to be used like this:

// Will get the input but exit the process if the input was `Ctrl+C`
let input = Input::read()
    .exit_on_kb_interrupt();

Examples found in repository

examples/single-char-input.rs (line 13)

fn main() {
    keypress::enable_raw_mode();

    loop {
        if let Some(Event::Key(key_event)) = Input::read().exit_on_kb_interrupt().event {
            match key_event {
                KeyEvent {
                    code: KeyCode::Char(char),
                    ..
                } => printr!("You pressed the {} key!", char),
                KeyEvent {
                    code: KeyCode::Enter,
                    kind: KeyEventKind::Press,
                    ..
                } => printr!("You pressed enter!"),
                _ => (),
            }
        }
    }
}

Trait Implementations

impl Clone for Input

fn clone(&self) -> Input

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Input

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

Formats the value using the given formatter.