Struct ascii_forge::input::Input

pub struct Input { /* private fields */ }

Implementations

impl Input

pub fn update(&mut self)

Clears just used events.

pub fn register_event(&mut self, event: Event)

pub fn register_key(&mut self, key_event: KeyEvent)

pub fn register_mouse(&mut self, mouse_event: MouseEvent)

pub fn pressed(&self, event: &KeyEvent) -> bool

Examples found in repository

examples/inline.rs (line 42)

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}

pub fn code(&self, code: KeyCode) -> bool

Examples found in repository

examples/confirmation.rs (line 10)

pub fn confirmation() -> io::Result<bool> {
    let mut window = Window::init_inline(1)?;

    loop {
        render!(window, vec2(0, 0) => [ "Are You Sure? (`y` / `n`)" ]);

        if window.input().code(KeyCode::Char('y')) || window.input().code(KeyCode::Char('Y')) {
            return Ok(true);
        }
        if window.input().code(KeyCode::Char('n')) || window.input().code(KeyCode::Char('N')) {
            return Ok(false);
        }

        // Update the window
        window.update(Duration::from_millis(1000))?;
    }
}

examples/simple.rs (line 31)

fn main() -> io::Result<()> {
    // Will init the window for you, handling all required procedures.
    let mut window = Window::init()?;

    // Ask the system to handle panics for us.
    handle_panics();

    loop {
        // Ask the window to draw, handle events, and fix sizing issues.
        // Duration is the time for which to poll events before re-rendering.
        window.update(Duration::from_millis(200))?;

        // Render elements to the window
        render!(
            window,
            vec2(0, 0) => [ "Hello World!" ],
            vec2(0, 1) => [ "Press `Enter` to exit!".red() ],
            vec2(0, 2) => [
                "Render ".red(),
                "Multiple ".yellow(),
                "Elements ",
                "In one go!".to_string()
            ],
        );

        // Check if the Enter Key was pressed, and exit the app if it was.
        if window.input().code(KeyCode::Enter) {
            break;
        }
    }

    // Restore the window, enabling the window to function normally again
    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
    window.restore()
}

pub fn mouse_just_pressed(&self, button: &MouseButton) -> bool

pub fn mouse_pressed(&self, button: &MouseButton) -> bool

pub fn mouse_just_released(&self, button: &MouseButton) -> bool

Trait Implementations

impl Debug for Input

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

Formats the value using the given formatter.

impl Default for Input

fn default() -> Input

Returns the “default value” for a type.