editor.rs

extern crate termion;
use std::io::{Write, Stdout, Stdin, stdout, stdin};
use termion::cursor;
use termion::event::{Key, Event};
use termion::input::TermRead;
use termion::raw::{IntoRawMode, RawTerminal};
use termion::screen::AlternateScreen;


pub struct Editor<'a> {
    screen: &'a mut AlternateScreen<Stdout>,
    stdin:  &'a mut Stdin,
    stdout: &'a mut RawTerminal<Stdout>,
    size: (u16, u16)
}

impl<'a> Editor<'a> {
    pub fn new() -> Result<Editor<'a>, &'static str> {
        let mut screen = AlternateScreen::from(stdout());
        let mut stdin = stdin();
        let mut stdout = stdout().into_raw_mode().unwrap();

        let size = match termion::terminal_size() {
            Ok((w,h)) => (w, h),
            Err(e) => return Err("Couldn't fetch the terminal size")
        };

        Ok(Editor {
            screen: screen,
            stdin:  stdin,
            stdout: stdout,
            size: size
        })
    }

    pub fn run(&mut self) {

        self.screen.flush().unwrap();

        for c in self.stdin.events() {
            let evt = c.unwrap();
            match evt {
                Event::Key(Key::Char(ch)) => {
                    write!(self.stdout, "{}", ch).unwrap();
                },
                Event::Key(Key::Esc) => break,
                _ => (),
            };
            self.screen.flush().unwrap();
        }
    }
}