mirror of https://github.com/fdehau/tui-rs
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
102 lines
2.5 KiB
Rust
102 lines
2.5 KiB
Rust
mod demo;
|
|
#[allow(dead_code)]
|
|
mod util;
|
|
|
|
use crate::demo::{ui, App};
|
|
use argh::FromArgs;
|
|
use std::{error::Error, io, sync::mpsc, thread, time::Duration};
|
|
use termion::{
|
|
event::Key,
|
|
input::{MouseTerminal, TermRead},
|
|
raw::IntoRawMode,
|
|
screen::AlternateScreen,
|
|
};
|
|
use tui::{
|
|
backend::{Backend, TermionBackend},
|
|
Terminal,
|
|
};
|
|
|
|
/// Termion demo
|
|
#[derive(Debug, FromArgs)]
|
|
struct Cli {
|
|
/// time in ms between two ticks.
|
|
#[argh(option, default = "250")]
|
|
tick_rate: u64,
|
|
/// whether unicode symbols are used to improve the overall look of the app
|
|
#[argh(option, default = "true")]
|
|
enhanced_graphics: bool,
|
|
}
|
|
|
|
fn main() -> Result<(), Box<dyn Error>> {
|
|
let cli: Cli = argh::from_env();
|
|
|
|
// setup terminal
|
|
let stdout = io::stdout().into_raw_mode()?;
|
|
let stdout = MouseTerminal::from(stdout);
|
|
let stdout = AlternateScreen::from(stdout);
|
|
let backend = TermionBackend::new(stdout);
|
|
let mut terminal = Terminal::new(backend)?;
|
|
|
|
// create app and run it
|
|
let tick_rate = Duration::from_millis(cli.tick_rate);
|
|
let app = App::new("Termion demo", cli.enhanced_graphics);
|
|
run_app(&mut terminal, app, tick_rate)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn run_app<B: Backend>(
|
|
terminal: &mut Terminal<B>,
|
|
mut app: App,
|
|
tick_rate: Duration,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
let events = events(tick_rate);
|
|
loop {
|
|
terminal.draw(|f| ui::draw(f, &mut app))?;
|
|
|
|
match events.recv()? {
|
|
Event::Input(key) => match key {
|
|
Key::Char(c) => app.on_key(c),
|
|
Key::Up => app.on_up(),
|
|
Key::Down => app.on_down(),
|
|
Key::Left => app.on_left(),
|
|
Key::Right => app.on_right(),
|
|
_ => {}
|
|
},
|
|
Event::Tick => app.on_tick(),
|
|
}
|
|
if app.should_quit {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
|
|
enum Event {
|
|
Input(Key),
|
|
Tick,
|
|
}
|
|
|
|
fn events(tick_rate: Duration) -> mpsc::Receiver<Event> {
|
|
let (tx, rx) = mpsc::channel();
|
|
let keys_tx = tx.clone();
|
|
thread::spawn(move || {
|
|
let stdin = io::stdin();
|
|
for evt in stdin.keys() {
|
|
if let Ok(key) = evt {
|
|
if let Err(err) = keys_tx.send(Event::Input(key)) {
|
|
eprintln!("{}", err);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
thread::spawn(move || loop {
|
|
if let Err(err) = tx.send(Event::Tick) {
|
|
eprintln!("{}", err);
|
|
break;
|
|
}
|
|
thread::sleep(tick_rate);
|
|
});
|
|
rx
|
|
}
|