rs-kilo/src/editor.rs

//! Editor functionality
use crate::helpers::*;

use nix::sys::termios::Termios;
use nix::unistd::read;

use std::io;
use std::io::prelude::*;
use std::io::{BufReader, Error, Stdin};
use std::str::Chars;

use term_parser::{Action, ActionIter};

/// Main structure for the editor
pub struct Editor {

}

// init
impl Editor {
    pub fn new() -> Self {
        Editor {
        }
    }
}

// Terminal
impl Editor {
    fn read_key(&mut self) -> Option<Vec<char>> {
        let stdin = io::stdin();
        let mut in_str = String::new();
        let mut input = BufReader::new(stdin.take(1));
        input.read_to_string(&mut in_str).unwrap();

        let mut output: Vec<char> = vec![];

        for char in in_str.chars() {
            output.push(char);
        }

        if output.len() == 0 {
            return None
        }

        return Some(output)
    }

    fn read_term_code(&mut self) -> ActionIter<BufReader<Stdin>> {
        let stdin = io::stdin();
        let buffer = BufReader::new(stdin);
        let term_code_iter = ActionIter::new(buffer);

        /*
        for term_code in self.read_term_code() {
            let term_code = match term_code {
                Ok(code) => code,
                Err(e) => panic!("{:?}\r\n", e),
            };
            print!("{:?}\r\n", term_code);
        }
        */

        term_code_iter
    }
}

// Input
impl Editor {
    pub fn process_keypress(&mut self) -> Option<()> {
        let chars= self.read_key();

        // No input, just continue
        if chars.is_none() {
            return Some(())
        }
        let chars = chars.unwrap();

        if chars.len() == 1 {
            let char = chars[0];

            if char == CTRL_KEY('q') {
                // Break out of the input loop
                return None;
            }

            // Echo characters
            if char.is_ascii_control() {
                print!("{}\r\n", char as u8);
            } else {
                print!("{} ('{}')\r\n", char as u8, char);
            }

        } else {
            print!("{:?}\r\n", chars);
            // Handle escape sequences
        }

        Some(())
    }
}

const fn CTRL_KEY(c: char) -> char {
    let key = c as u8;

    (key & 0x1f) as char
}