rewrite stuff to handle arrow key input, wip buffering/windowing for render

2 files changed, 204 insertions, 60 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 673a8a6..ea084a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,5 +16,5 @@ test = false
 bench = false
 
 [dependencies]
-"terminal_size" = "0.1.7"
 "termios" = "0.2.2"
+"termion" = "1.4.0"
diff --git a/main.rs b/main.rs
index fa22374..1b935c8 100644
--- a/main.rs
+++ b/main.rs
@@ -1,28 +1,34 @@
+use std::cmp::{min, max};
 use std::io;
 use std::io::{Seek, SeekFrom};
 use std::fs;
 use std::fmt::Write;
 use std::io::Read;
 use std::env;
-use std::path::Path;
+//use std::path::Path;
 
 extern crate termios;
 use termios::{Termios, TCSANOW, ECHO, ICANON, tcsetattr};
 
-extern crate terminal_size;
-use terminal_size::{Width, Height, terminal_size};
+extern crate termion;
+use termion::{color, input};
+use termion::input::TermRead;
+use termion::event::{Event, Key};
 
 fn main() {
     println!("hello");
-    if let Some((Width(w), Height(h))) = terminal_size() {
-        if let Some(arg1) = env::args().nth(1) {
-            println!("You would like to work with {}.", arg1);
-            launch_interface(w, h, &arg1);
-        } else {
-            usage();
+    match termion::terminal_size() {
+        Ok((w, h)) => {
+            if let Some(arg1) = env::args().nth(1) {
+                println!("You would like to work with {}.", arg1);
+                launch_interface(w, h, arg1.clone());
+            } else {
+                usage();
+            }
+        }
+        Err(e) => {
+            println!("{}", e);
         }
-    } else {
-        println!("Wasn't able to get terminal dimensions for some reason");
     }
 }
 
@@ -30,80 +36,215 @@ fn usage() {
     println!("usage: this_thing filename");
 }
 
-fn launch_interface(w: u16, h: u16, filename: &String) {
-    println!("Launching interface with width {} and height {}...", w, h);
+struct Program {
+    filename: String,
+    filelen: u64,
+    width: u16,
+    row_size: u16,
+    height: u16,
+    seek: u64,
+    cursor: u64,
+    old_term: Termios,
+    new_term: Termios,
+    buf: Vec<u8>
+}
+
+impl Program {
+    fn inc_cursor(&mut self, amount: u64) {
+        if self.filelen - self.cursor < amount {
+            self.cursor = self.filelen - 1;
+        } else {
+            self.cursor += amount;
+        }
+        self.recalculate_seek();
+    }
+    fn dec_cursor(&mut self, amount: u64) {
+        if self.cursor < amount {
+            self.cursor = 0;
+        } else {
+            self.cursor -= amount;
+        }
+        self.recalculate_seek();
+    }
+    fn recalculate_seek(&mut self) {
+        let old_seek = self.seek;
+        let bufsize = self.height as u64 * self.width as u64;
+        let render_lim = (self.row_size as u64) * (self.height as u64 - 1); // this shouldn't be decided here...
+        if self.cursor + render_lim > self.seek + bufsize { // know a priori that buf size is height * width. TODO: fix.
+            println!("aaaa");
+            // we've sought past the end, so reset seek to what would have been the start of this
+            // display and it'll all work out from here.
+            self.seek = self.cursor - (self.cursor % self.row_size as u64);
+        } else if self.cursor < self.seek {
+            println!("bbbb");
+            // we've sought before the start, so reset seek to just before. ideally, populate a
+            // buffer for like 1k before, but lazy.
+            self.seek = self.cursor - (self.cursor % self.row_size as u64);
+        }
+
+        // repopulate buf..
+        if self.seek != old_seek {
+            self.buf = populate_buf(&self.filename, self.seek, bufsize);
+        }
+    }
+}
 
-    // 4 = columns per group, 3 = xx xx xx xx , ...
-    // + (x + 7) / 8 is for ascii at the end of line, rounded up to 8 characters
-    // width = 8-20 + (3 * 4) * x + (x + 7) / 8
-    // 8 * width = 87 + 57x
-    // x = (8 * width -  87) / 57
-    let hex_cols = (w * 8 - 87) / 57;
-    println!("0x________: {}  {}", hex_cols, hex_cols);
+fn launch_interface(w: u16, h: u16, filename: String) {
     match fs::metadata(&filename) {
         Ok(fs_meta) => {
             println!("{} is {} bytes, and is it readable? {}", filename, fs_meta.len(), true);
             let termios = Termios::from_fd(0).unwrap();
 
             let mut new_termios = termios.clone();
+
             // fix terminal to not echo, thanks
             new_termios.c_lflag &= !(ICANON | ECHO);
-            tcsetattr(0, TCSANOW, &mut new_termios).unwrap();
 
-            interface_loop(w, h, filename);
+            let initial_buf = populate_buf(&filename, 0, w as u64 * h as u64);
+
+            let mut state = Program {
+                filename: filename,
+                filelen: fs_meta.len(),
+                width: w,
+    // let col_width = 4;
+    // w = 10 + 1 + 1 + 4 * 3 * x + x + 1 + 4 * x
+    // w = 13 + 17 * x
+    // w - 13 / 17 = x
+                row_size: ((w - 13) / 17) * 4,
+                height: h,
+                old_term: termios,
+                new_term: new_termios,
+                cursor: 0,
+                seek: 0,
+                buf: initial_buf
+            };
+
+            tcsetattr(0, TCSANOW, &state.new_term).unwrap();
+
+            interface_loop(&mut state);
 
-            tcsetattr(0, TCSANOW, &termios).unwrap();
+            tcsetattr(0, TCSANOW, &state.old_term).unwrap();
         },
         Err(e) => 
-            println!("{} does not exist.", filename),
+            println!("{} does not exist. ({})", filename, e),
     }
 }
 
-fn interface_loop(w: u16, h: u16, filename: &String) {
-    let mut cursor: u64 = 0;
-    let mut buffer = [0; 0x200];
-    populate_buf(filename, cursor, &mut buffer);
-    render_interface(w, h, cursor, &buffer);
+fn interface_loop(state: &mut Program) {
+//    let buffer = populate_buf(&state.filename, state.cursor, state.width as u64 * state.height as u64); // sw*h over-estimates by about a factor of.. 4?
+    render_interface(state);
 
     let stdin = io::stdin();
 
-    for byte in stdin.lock().bytes() {
-        match byte {
-            Ok(value) => {
-                render_interface(w, h, cursor, &buffer);
-            },
-            Err(e) => {
-                println!("Err: {}", e);
+//    for input in KeyboardInput::from_stdin(&stdin.lock().bytes()) {
+    for input in stdin.events() {
+        match input.unwrap() {
+            Event::Key(Key::Up) => {
+                let amount = state.row_size; // why can't this be inlined?
+                state.dec_cursor(amount as u64);
+            }
+            Event::Key(Key::Down) => {
+                let amount = state.row_size;
+                state.inc_cursor(amount as u64);
+            }
+            Event::Key(Key::Left) => {
+                state.dec_cursor(1);
+            }
+            Event::Key(Key::Right) => {
+                state.inc_cursor(1);
+            }
+            Event::Key(Key::PageDown) => {
+                let amount = (state.row_size as u64) * (state.height as u64 - 1);
+                state.inc_cursor(amount);
+            }
+            Event::Key(Key::PageUp) => {
+                let amount = (state.row_size as u64) * (state.height as u64 - 1);
+                state.dec_cursor(amount);
+            }
+            u => {
+                println!("Got {:?}", u);
+                break;
             }
         }
+        render_interface(state);
+    }
+}
+
+/*
+struct KeyboardInput {
+    
+}
+
+impl KeyboardInput {
+    fn from_stdin(x: &Iterator<Item = io::Result<u8>>) -> KeyboardInput {
+        let x = KeyboardInput { };
+        x
+    }
+}
+
+impl Iterator for KeyboardInput {
+    type Item = KeyInfo;
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(0)
     }
 }
+*/
 
 fn ascii_or_dot(c: u8) -> u8 {
     let u = c as char;
-    if (u >= 'a' && u <= 'z' || u >= '0' && u <= '9' || u >= 'A' && u <= 'Z' || u == '~' || u == '!' || u == '@' || u == '#' || u == '$' || u == '%' || u == '^' || u == '&' || u == '*' || u == '(' || u == ')' || u == '_' || u == '+' || u == '{' || u == '}' || u == '|' || u == ':' || u == '"' || u == '>' || u == '?' || u == '-' || u == '=' || u == '[' || u == ']' || u == '\\' || u == ';' || u == '\'' || u == '.' || u == '/' || u == '<' || u == ',' || u == '`') { c } else { '.' as u8 }
+    if
+        u >= 'a' && u <= 'z' ||
+        u >= '0' && u <= '9' ||
+        u >= 'A' && u <= 'Z' ||
+        u == '~' || u == '!' ||
+        u == '@' || u == '#' ||
+        u == '$' || u == '%' ||
+        u == '^' || u == '&' ||
+        u == '*' || u == '(' ||
+        u == ')' || u == '_' ||
+        u == '+' || u == '{' ||
+        u == '}' || u == '|' ||
+        u == ':' || u == '"' ||
+        u == '>' || u == '?' ||
+        u == '-' || u == '=' ||
+        u == '[' || u == ']' ||
+        u == '\\' || u == ';' ||
+        u == '\'' || u == '.' ||
+        u == '/' || u == '<' ||
+        u == ',' || u == '`' {
+        c
+    } else {
+        '.' as u8
+    }
 }
 
-fn render_interface(w: u16, h: u16, cursor: u64, buffer: &[u8]) {
-    println!("Dimensions: {}x{}    Cursor: {}   cursor_pos: ({}, {})", w, h, cursor, 0, 0);
-    let addr_width = 8;
-    // w = 10 + 1 + 1 + 4 * 3 * x + x + 1 + 4 * x
-    // w = 13 + 17 * x
-    // w - 13 / 17 = x
-    let cols = (w - 13) / 17;
-    let col_width = 4;
+fn render_interface(state: &Program) {
+    println!("Dimensions: {}x{}    Seek: {}, Cursor: {}  - file: {}, {} bytes", state.width, state.height, state.seek, state.cursor, state.filename, state.filelen);
+    //let addr_width = 8;
 //    let ascii = bytes_width * cols;
 
-    let mut idx: usize = 0;
-    for i in 1..(h-1) {
+    let buffer = &state.buf;
+
+    let start = (state.cursor - state.seek) as usize;
+    let mut idx: usize = start;
+    let col_width = 4;
+    for i in 1..(state.height-1) {
         let mut hex_line = String::new();
         let mut ascii_line = String::new();
-        for col in 0..cols {
-            for c in 0..col_width {
-                if (idx < buffer.len()) {
+        for _ in 0..(state.row_size / 4) {
+            for _ in 0..col_width {
+                if idx < buffer.len() {
                     let chr = buffer[idx];
+                    if idx as u64 + state.seek == state.cursor {
+                        write!(&mut hex_line, "\x1b[33m").unwrap();
+                        write!(&mut ascii_line, "\x1b[33m").unwrap();
+                    }
                     write!(&mut hex_line, "{:02x} ", chr).unwrap();
                     write!(&mut ascii_line, "{}", ascii_or_dot(chr) as char).unwrap();
+                    if idx as u64 + state.seek == state.cursor {
+                        write!(&mut hex_line, "\x1b[0m").unwrap();
+                        write!(&mut ascii_line, "\x1b[0m").unwrap();
+                    }
                 } else {
                     write!(&mut hex_line, "   ").unwrap();
                     write!(&mut ascii_line, " ").unwrap();
@@ -113,7 +254,7 @@ fn render_interface(w: u16, h: u16, cursor: u64, buffer: &[u8]) {
             write!(&mut hex_line, " ").unwrap();
         }
 
-        let lineaddr = ((i as u64) - 1) * (cols as u64 * 4);
+        let lineaddr = start as u64 + ((i as u64) - 1) * (state.row_size as u64);
         let addr = if (lineaddr as usize) < buffer.len() {
             format!("0x{:08x}:", lineaddr)
         } else {
@@ -123,18 +264,21 @@ fn render_interface(w: u16, h: u16, cursor: u64, buffer: &[u8]) {
     }
 }
 
-fn populate_buf(arg: &String, cursor: u64, buffer: &mut [u8]) {
+fn populate_buf(arg: &String, seek: u64, count: u64) -> Vec<u8> {
     match fs::File::open(&arg) {
         Ok(mut fd) => {
             /*..*/
-            fd.seek(SeekFrom::Start(cursor));
-            fd.read(buffer);
-            for b in buffer.into_iter() {
-                print!("{:02x}", b);
-            }
-            println!("");
+            fd.seek(SeekFrom::Start(seek)).unwrap();
+            fd
+                .bytes()
+                .take(count as usize)
+                .map(|r| r.unwrap()) // lazy
+                .collect()
         },
         Err(_) =>
-            println!("Failed to open {}", arg)
+        {
+            println!("Failed to open {}", arg);
+            panic!();
+        }
     }
 }