FichteFoll/tracc
1
0
Fork 0
forked from kageru/tracc
Code Issues Pull Requests Releases Wiki Activity

Don’t use copied input handling from the examples

This commit is contained in:
kageru 2020-01-23 23:26:18 +01:00
parent 4fa4764cd4
commit 78cb4bb1cb
Signed by untrusted user: kageru
GPG Key ID: 8282A2BEA4ADA3D2
2 changed files with 29 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/events/mod.rs
View File

@ -1,77 +0,0 @@
// This file was copied from https://github.com/fdehau/tui-rs/blob/master/examples/util/event.rs
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),
}
/// 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<()>,
}
#[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() {
match evt {
Ok(key) => {
if let Err(_) = tx.send(Event::Input(key)) {
return;
}
if !ignore_exit_key.load(Ordering::Relaxed) && key == config.exit_key {
return;
}
}
Err(_) => {}
}
}
})
};
Events {
rx,
input_handle,
}
}
pub fn next(&self) -> Result<Event<Key>, mpsc::RecvError> {
self.rx.recv()
}
}

60
src/main.rs
View File

@ -1,13 +1,12 @@
use std::io;
use termion::event::Key;
use termion::raw::IntoRawMode;
use termion::input::TermRead;
use tui::backend::Backend;
use tui::backend::TermionBackend;
use tui::style::{Color, Style};
use tui::widgets::*;
use tui::Terminal;
mod events;
use events::{Event, Events};
mod tracc;
use tracc::Tracc;
@ -18,45 +17,44 @@ pub enum Mode {
fn main() -> Result<(), io::Error> {
let stdout = io::stdout().into_raw_mode()?;
let mut inputs = io::stdin().keys();
let backend = TermionBackend::new(stdout);
let mut terminal = Terminal::new(backend)?;
let mut tracc = Tracc::new();
terminal.hide_cursor()?;
terminal.clear()?;
let events = Events::new();
loop {
refresh(&mut terminal, &tracc)?;
// I need to find a better way to handle inputs. This is awful.
match events.next().expect("input ded?") {
Event::Input(input) => match tracc.mode {
Mode::Normal => match input {
Key::Char('q') => break,
Key::Char('j') => tracc.selection_down(),
Key::Char('k') => tracc.selection_up(),
Key::Char('o') => {
tracc.insert();
tracc.set_mode(Mode::Insert, &mut terminal)?;
let input = inputs.next().unwrap().expect("input ded?");
match tracc.mode {
Mode::Normal => match input {
Key::Char('q') => break,
Key::Char('j') => tracc.selection_down(),
Key::Char('k') => tracc.selection_up(),
Key::Char('o') => {
tracc.insert();
tracc.set_mode(Mode::Insert, &mut terminal)?;
}
Key::Char('a') => tracc.set_mode(Mode::Insert, &mut terminal)?,
Key::Char('A') => tracc.set_mode(Mode::Insert, &mut terminal)?,
Key::Char(' ') => tracc.toggle_current(),
// dd
Key::Char('d') => {
if let Key::Char('d') = inputs.next().unwrap().unwrap() {
tracc.remove_current()
}
Key::Char('a') => tracc.set_mode(Mode::Insert, &mut terminal)?,
Key::Char('A') => tracc.set_mode(Mode::Insert, &mut terminal)?,
Key::Char(' ') => tracc.toggle_current(),
// dd
Key::Char('d') => {
if let Event::Input(Key::Char('d')) = events.next().unwrap() {
tracc.remove_current()
}
}
_ => (),
},
Mode::Insert => match input {
Key::Char('\n') => tracc.set_mode(Mode::Normal, &mut terminal)?,
Key::Esc => tracc.set_mode(Mode::Normal, &mut terminal)?,
Key::Backspace => tracc.current_pop(),
Key::Char(x) => tracc.append_to_current(x),
_ => (),
},
}
_ => (),
},
}
Mode::Insert => match input {
Key::Char('\n') => tracc.set_mode(Mode::Normal, &mut terminal)?,
Key::Esc => tracc.set_mode(Mode::Normal, &mut terminal)?,
Key::Backspace => tracc.current_pop(),
Key::Char(x) => tracc.append_to_current(x),
_ => (),
},
};
}
Ok(())
}