107 lines
2.7 KiB
Rust
107 lines
2.7 KiB
Rust
use termion::event::Key as TermionKey;
|
|
use termion::input::TermRead;
|
|
use chan;
|
|
use std::io;
|
|
|
|
|
|
#[derive(Debug)]
|
|
pub enum Key {
|
|
/// Backspace.
|
|
Backspace,
|
|
/// Left arrow.
|
|
Left,
|
|
/// Right arrow.
|
|
Right,
|
|
/// Up arrow.
|
|
Up,
|
|
/// Down arrow.
|
|
Down,
|
|
/// Home key.
|
|
Home,
|
|
/// End key.
|
|
End,
|
|
/// Page Up key.
|
|
PageUp,
|
|
/// Page Down key.
|
|
PageDown,
|
|
/// Delete key.
|
|
Delete,
|
|
/// Insert key.
|
|
Insert,
|
|
/// Function keys.
|
|
///
|
|
/// Only function keys 1 through 12 are supported.
|
|
F(u8),
|
|
/// Normal character.
|
|
Char(char),
|
|
/// Alt modified character.
|
|
Alt(char),
|
|
/// Ctrl modified character.
|
|
///
|
|
/// Note that certain keys may not be modifiable with `ctrl`, due to limitations of terminals.
|
|
Ctrl(char),
|
|
/// Null byte.
|
|
Null,
|
|
/// Esc key.
|
|
Esc,
|
|
}
|
|
|
|
impl From<TermionKey> for Key {
|
|
fn from(k: TermionKey) -> Self {
|
|
match k {
|
|
TermionKey::Backspace => Key::Backspace,
|
|
TermionKey::Left => Key::Left,
|
|
TermionKey::Right => Key::Right,
|
|
TermionKey::Up => Key::Up,
|
|
TermionKey::Down => Key::Down,
|
|
TermionKey::Home => Key::Home,
|
|
TermionKey::End => Key::End,
|
|
TermionKey::PageUp => Key::PageUp,
|
|
TermionKey::PageDown => Key::PageDown,
|
|
TermionKey::Delete => Key::Delete,
|
|
TermionKey::Insert => Key::Insert,
|
|
TermionKey::F(u) => Key::F(u),
|
|
TermionKey::Char(c) => Key::Char(c),
|
|
TermionKey::Alt(c) => Key::Alt(c),
|
|
TermionKey::Ctrl(c) => Key::Ctrl(c),
|
|
TermionKey::Null => Key::Null,
|
|
TermionKey::Esc => Key::Esc,
|
|
_ => Key::Char(' '),
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we fork (for example start $EDITOR) we want the input-thread to stop reading from stdin. The
|
|
* best way I came up with right now is to send a signal to the thread that is read in the first
|
|
* input in stdin after the fork, and then the thread kills itself. The parent process spawns a new
|
|
* input-thread when the child returns.
|
|
*
|
|
* The main loop uses try_wait_on_child() to check if child has exited.
|
|
*/
|
|
pub fn get_events(
|
|
stdin: io::Stdin,
|
|
mut closure: impl FnMut(Key),
|
|
mut exit: impl FnMut(),
|
|
rx: chan::Receiver<bool>,
|
|
) -> () {
|
|
for c in stdin.keys() {
|
|
chan_select! {
|
|
default => {},
|
|
rx.recv() -> val => {
|
|
if let Some(true) = val {
|
|
exit();
|
|
return;
|
|
} else if let Some(false) = val {
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
if let Ok(k) = c {
|
|
closure(Key::from(k));
|
|
}
|
|
}
|
|
}
|