termion/src/input.rs

127 lines
3.6 KiB
Rust
Raw Normal View History

use std::io::{Read, Write};
2016-03-08 07:51:34 +00:00
use {IntoRawMode, TerminalError};
#[cfg(feature = "nightly")]
2016-03-09 10:38:43 +00:00
use std::io::{Chars, CharsError};
/// A key.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Key {
/// Backspace.
Backspace,
/// Left arrow.
Left,
/// Right arrow.
Right,
/// Up arrow.
Up,
/// Down arrow.
Down,
/// Normal character.
Char(char),
2016-03-10 14:12:59 +00:00
/// 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),
/// Invalid character code.
Invalid,
// TODO handle errors better?
/// IO error.
Error,
}
/// An iterator over input keys.
#[cfg(feature = "nightly")]
2016-03-09 10:38:43 +00:00
pub struct Keys<I> {
chars: I,
}
#[cfg(feature = "nightly")]
2016-03-09 10:38:43 +00:00
impl<I: Iterator<Item = Result<char, CharsError>>> Iterator for Keys<I> {
type Item = Key;
fn next(&mut self) -> Option<Key> {
match self.chars.next() {
Some(Ok('\x1B')) => Some(match self.chars.next() {
Some(Ok('[')) => match self.chars.next() {
Some(Ok('D')) => Key::Left,
Some(Ok('C')) => Key::Right,
Some(Ok('A')) => Key::Up,
Some(Ok('B')) => Key::Down,
_ => Key::Invalid,
},
Some(Ok(c)) => Key::Alt(c),
Some(Err(_)) | None => Key::Invalid,
}),
Some(Ok('\x7F')) => Some(Key::Backspace),
2016-03-10 14:12:59 +00:00
Some(Ok(c @ '\x10' ... '\x1A')) => Some(Key::Ctrl((c as u8 - 0x10 + b'p') as char)),
Some(Ok(c @ '\x01' ... '\x04')) => Some(Key::Ctrl((c as u8 - 0x1 + b'a') as char)),
Some(Ok(c @ '\x1C' ... '\x1F')) => Some(Key::Ctrl((c as u8 - 0x1C + b'4') as char)),
Some(Ok('\x06')) => Some(Key::Alt('f')),
Some(Ok(c)) => Some(Key::Char(c)),
None => None,
Some(Err(_)) => Some(Key::Error),
}
}
}
/// Extension to `Read` trait.
2016-03-08 20:39:24 +00:00
pub trait TermRead {
/// An iterator over key inputs.
#[cfg(feature = "nightly")]
2016-03-09 10:38:43 +00:00
fn keys(self) -> Keys<Chars<Self>> where Self: Sized;
/// Read a password.
2016-03-08 09:08:50 +00:00
///
/// EOT and ETX will abort the prompt, returning `None`. Newline or carriage return will
/// complete the password input.
2016-03-08 07:51:34 +00:00
fn read_passwd<W: Write>(&mut self, writer: &mut W) -> Result<Option<String>, TerminalError>;
}
2016-03-08 20:39:24 +00:00
impl<R: Read> TermRead for R {
#[cfg(feature = "nightly")]
2016-03-09 10:38:43 +00:00
fn keys(self) -> Keys<Chars<R>> {
Keys {
chars: self.chars(),
}
}
2016-03-08 07:51:34 +00:00
fn read_passwd<W: Write>(&mut self, writer: &mut W) -> Result<Option<String>, TerminalError> {
let _raw = try!(writer.into_raw_mode());
let mut passbuf = Vec::with_capacity(30);
for c in self.bytes() {
2016-03-08 07:51:34 +00:00
match c {
Err(_) => return Err(TerminalError::StdinError),
Ok(0) | Ok(3) | Ok(4) => return Ok(None),
Ok(b'\n') | Ok(b'\r') => break,
Ok(c) => passbuf.push(c),
}
}
2016-03-08 10:58:48 +00:00
let passwd = try!(String::from_utf8(passbuf).map_err(|_| TerminalError::UnicodeError));
Ok(Some(passwd))
}
}
2016-03-09 16:18:31 +00:00
#[cfg(test)]
mod test {
#[cfg(feature = "nightly")]
#[test]
fn test_keys() {
2016-03-09 18:17:00 +00:00
use {TermRead, Key};
2016-03-09 16:18:31 +00:00
let mut i = b"\x1Bayo\x7F\x1B[D".keys();
assert_eq!(i.next(), Some(Key::Alt('a')));
assert_eq!(i.next(), Some(Key::Char('y')));
assert_eq!(i.next(), Some(Key::Char('o')));
assert_eq!(i.next(), Some(Key::Backspace));
assert_eq!(i.next(), Some(Key::Left));
assert_eq!(i.next(), None);
}
}