rs-kilo/src/editor.rs

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

use std::io;
use std::io::prelude::*;
use std::io::BufReader;

/// Main structure for the editor
///
/// impl blocks are split similarly to the original C implementation
#[derive(Debug, Default)]
pub struct Editor {
    screen_cols: usize,
    screen_rows: usize,
    output_buffer: String,
}

// init
impl Editor {
    pub fn new() -> Self {
        let mut instance = Self::default();
        let size = instance.get_window_size();
        instance.screen_cols = size.cols as usize;
        instance.screen_rows = size.rows as usize;

        instance
    }
}

// Terminal
impl Editor {
    fn read_key(&mut self) -> Option<Vec<char>> {
        let stdin = io::stdin();
        let stdin = stdin.lock();
        let mut in_str = String::new();
        let mut input = BufReader::with_capacity(3, stdin);
        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 get_cursor_position(&mut self) -> TermSize {
        let stdout = io::stdout();
        let mut handle = stdout.lock();
        let buffer = String::from("\x1b[6n").into_bytes();
        handle.write(&buffer).unwrap();

        let stdin = io::stdin();
        let stdin = stdin.lock();
        let mut in_buf = String::new().into_bytes();
        let mut input = BufReader::with_capacity(32, stdin);
        input.read_until('R' as u8, &mut in_buf).unwrap();

        // @TODO Find a solution to retrieve the cursor coordinates
        unimplemented!();
    }

    fn get_window_size(&mut self) -> TermSize {
        match get_term_size() {
            Some(size) => size,
            None => {
                let stdout = io::stdout();
                let mut handle = stdout.lock();
                let buffer = String::from("\x1b[999C\x1b[999B").into_bytes();
                handle.write(&buffer).unwrap();

                self.get_cursor_position()
            }
        }
    }
}

// Input
impl Editor {
    /// Route user input to the appropriate handler method
    pub fn process_keypress(&mut self) -> Option<()> {
        match self.read_key() {
            // Just continue the input loop on an "empty" keypress
            None => Some(()),
            Some(chars) => {
                let first = chars[0];

                if first == ctrl_key('q') {
                    clear_and_reset();

                    // Break out of the input loop
                    return None;
                }

                print!("{:?}\r\n", chars);

                // Continue the main input loop
                Some(())
            }
        }
    }
}

// Output
impl Editor {
    /// Equivalent of the abAppend function
    /// in the original tutorial, just appends
    /// to the `output_buffer` String in the
    /// editor struct.
    fn append_out(&mut self, str: &str) {
        self.output_buffer.push_str(str);
    }

    fn draw_rows(&mut self) {
        for y in 0..self.screen_rows {
            if y == (self.screen_rows / 3) {
                let mut welcome = format!("Kilo editor -- version {}", env!("CARGO_PKG_VERSION"));
                if welcome.len() > self.screen_cols {
                    welcome.truncate(self.screen_cols)
                }

                // Center welcome message
                let mut padding = (self.screen_cols - welcome.len()) / 2;
                if padding > 0 {
                    self.append_out("~");
                    padding -= 1;
                }
                while padding > 0 {
                    self.append_out(" ");
                    padding -=1;
                }

                self.append_out(&welcome);
            } else {
                self.append_out("~");
            }


            self.append_out("\x1b[K");
            if y < (self.screen_rows as usize - 1) {
                self.append_out("\r\n");
            }
        }
    }

    pub fn refresh_screen(&mut self) {
        self.output_buffer.clear();

        //  Hide cursor, reposition cursor
        self.append_out("\x1b[?25l");
        self.append_out("\x1b[H");

        self.draw_rows();

        self.append_out("\x1b[H");
        self.append_out("\x1b[?25h");

        let stdout = io::stdout();
        let mut handle = stdout.lock();
        handle.write_all(&self.output_buffer.as_bytes()).unwrap();
    }
}