minui 0.6.0

A minimalist Rust framework for building terminal UIs (TUIs) in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! App runner example showing automatic timed updates (fixed tick rate).
//!
//! This demonstrates using the `App` wrapper to handle the main loop, timing,
//! and rendering automatically. Compare this to `basic_usage.rs` to see the difference
//! between manual event loops and the app runner approach.
//!
//! Features shown:
//! - Fixed tick rate for smooth movement / simple animation
//! - Automatic state management
//! - Keyboard input handling
//! - Clean separation of update and draw logic

use minui::{App, Event, KeyKind};
use std::time::Duration;

/// App state - just a position that moves around
struct MyCoolApp {
    x: u16,
    y: u16,
}

fn main() -> minui::Result<()> {
    // Start with player at position (5, 5)
    let initial_state = MyCoolApp { x: 5, y: 5 };

    // Enable a fixed frame rate (timed updates) every 100ms
    let mut app = App::new(initial_state)?.with_frame_rate(Duration::from_millis(100));

    // Run the main loop with update and draw functions
    app.run(
        // Update function: handle events and modify state
        // Return false to exit, true to continue
        |state, event| {
            match event {
                // Prefer modifier-aware key events (the keyboard handler may emit these for most keys).
                Event::KeyWithModifiers(k) => match k.key {
                    KeyKind::Char('q') => return false,
                    KeyKind::Up => state.y = state.y.saturating_sub(1),
                    KeyKind::Down => state.y += 1,
                    KeyKind::Left => state.x = state.x.saturating_sub(1),
                    KeyKind::Right => state.x += 1,
                    _ => {}
                },

                // Legacy fallback.
                Event::Character('q') => return false,

                Event::KeyUp => state.y = state.y.saturating_sub(1),
                Event::KeyDown => state.y += 1,
                Event::KeyLeft => state.x = state.x.saturating_sub(1),
                Event::KeyRight => state.x += 1,

                Event::Frame => {
                    // Automatic movement every frame event (100ms)
                    state.x += 1;
                }
                _ => {}
            }
            // Keep running
            true
        },
        // Draw function: render the current state
        |state, window| {
            window.write_str(state.y, state.x, "@")?;
            window.write_str(0, 0, "Press 'q' to quit")?;
            window.flush()?;
            Ok(())
        },
    )?;

    Ok(())
}