cb5975f235
This patch is simply meant to mark the beginning of the newest phase for the tui build. I've 100% settled on using termion as the backend and marking what is done so far Renderer side: Termion has a similar issue where moving data happens very quietly so its best if the two (renderer and cache) have the their data to use as they please Cache Side: Basically we own the data we're using because we constantly have to mutate data ourselves Config in the middle: Mutable but only from the rendering side because the cache is completely transient It technically to own its data but it does anyway because the render(backend) likes to consume data like there's no tomorrow
96 lines
2.4 KiB
Rust
96 lines
2.4 KiB
Rust
use std::io;
|
|
use std::sync::mpsc;
|
|
use std::sync::{
|
|
atomic::{AtomicBool, Ordering},
|
|
Arc,
|
|
};
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
use termion::event::Key;
|
|
use termion::input::TermRead;
|
|
|
|
pub enum Event<I> {
|
|
Input(I),
|
|
Tick,
|
|
}
|
|
|
|
/// A small event handler that wrap termion input and tick events. Each event
|
|
/// type is handled in its own thread and returned to a common `Receiver`
|
|
pub struct Events {
|
|
rx: mpsc::Receiver<Event<Key>>,
|
|
input_handle: thread::JoinHandle<()>,
|
|
ignore_exit_key: Arc<AtomicBool>,
|
|
tick_handle: thread::JoinHandle<()>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct Config {
|
|
pub exit_key: Key,
|
|
pub tick_rate: Duration,
|
|
}
|
|
|
|
impl Default for Config {
|
|
fn default() -> Config {
|
|
Config {
|
|
exit_key: Key::Char('q'),
|
|
tick_rate: Duration::from_millis(250),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Events {
|
|
pub fn new() -> Events {
|
|
Events::with_config(Config::default())
|
|
}
|
|
|
|
pub fn with_config(config: Config) -> Events {
|
|
let (tx, rx) = mpsc::channel();
|
|
let ignore_exit_key = Arc::new(AtomicBool::new(false));
|
|
let input_handle = {
|
|
let tx = tx.clone();
|
|
let ignore_exit_key = ignore_exit_key.clone();
|
|
thread::spawn(move || {
|
|
let stdin = io::stdin();
|
|
for evt in stdin.keys() {
|
|
if let Ok(key) = evt {
|
|
if let Err(err) = tx.send(Event::Input(key)) {
|
|
eprintln!("{}", err);
|
|
return;
|
|
}
|
|
if !ignore_exit_key.load(Ordering::Relaxed) && key == config.exit_key {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
})
|
|
};
|
|
let tick_handle = {
|
|
thread::spawn(move || loop {
|
|
if tx.send(Event::Tick).is_err() {
|
|
break;
|
|
}
|
|
thread::sleep(config.tick_rate);
|
|
})
|
|
};
|
|
Events {
|
|
rx,
|
|
ignore_exit_key,
|
|
input_handle,
|
|
tick_handle,
|
|
}
|
|
}
|
|
|
|
pub fn next(&self) -> Result<Event<Key>, mpsc::RecvError> {
|
|
self.rx.recv()
|
|
}
|
|
|
|
pub fn disable_exit_key(&mut self) {
|
|
self.ignore_exit_key.store(true, Ordering::Relaxed);
|
|
}
|
|
|
|
pub fn enable_exit_key(&mut self) {
|
|
self.ignore_exit_key.store(false, Ordering::Relaxed);
|
|
}
|
|
}
|