Merge branch 'main' of https://github.com/rustbox/esp32c3-vgaterm into refactor/nom-it-up

Author: sethp

Cargo.toml

@@ -66,8 +66,9 @@ unroll = "0.1.5"
 
 [features]
 default    = ["background"]
-perf_log   = []
 background = []
+perf_log   = []
+op_log     = []
 
 [patch.crates-io]
 # TODO: automate these updates

src/display.rs

@@ -1,4 +1,4 @@
-use core::convert::Infallible;
+use core::{cmp::Ordering, convert::Infallible};
 
 use alloc::{
     collections::VecDeque,
@@ -422,6 +422,23 @@ impl TextDisplay {
         let amount = amount % ROWS as isize;
         self.top = ((self.top as isize + amount) % ROWS as isize) as usize;
 
+        let b = [' '; COLUMNS];
+        let s = String::from_iter(b);
+
+        match amount.cmp(&0) {
+            Ordering::Greater => {
+                for i in ROWS - amount as usize..ROWS {
+                    self.write_text(i, 0, &s);
+                }
+            }
+            Ordering::Less => {
+                let amt = amount.unsigned_abs();
+                for i in 0..amt {
+                    self.write_text(i, 0, &s);
+                }
+            }
+            _ => {}
+        }
         self.dirty_all();
     }
 

src/terminal.rs

@@ -1,13 +1,12 @@
 use crate::{
     ansi::{self, EraseMode, Op, OpStr},
     color::Rgb3,
-    display::{self, TextDisplay, ROWS},
+    display::{self, TextDisplay, COLUMNS, ROWS},
     CHARACTER_DRAW_CYCLES,
 };
 use alloc::string::String;
 use embedded_graphics::prelude::DrawTarget;
 use esp32c3_hal::systimer::SystemTimer;
-use esp_println::println;
 
 pub const IROWS: isize = display::ROWS as isize;
 pub const ICOLS: isize = display::COLUMNS as isize;
@@ -63,6 +62,18 @@ impl CursorPos {
     }
 }
 
+enum VerticalLocation {
+    Middle,
+    Top,
+    Bottom,
+}
+
+enum HorizontalLocation {
+    Middle,
+    Left,
+    Right,
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct Cursor {
     pub pos: CursorPos,
@@ -91,8 +102,20 @@ impl Cursor {
         *self
     }
 
-    fn is_at_bottom(&self) -> bool {
-        self.pos.row() == ROWS - 1
+    fn location(&self) -> (VerticalLocation, HorizontalLocation) {
+        const BOT: usize = ROWS - 1;
+        const RIGHT: usize = COLUMNS - 1;
+        let vert = match self.pos.row() {
+            BOT => VerticalLocation::Bottom,
+            0 => VerticalLocation::Top,
+            _ => VerticalLocation::Middle,
+        };
+        let horz = match self.pos.col() {
+            RIGHT => HorizontalLocation::Right,
+            0 => HorizontalLocation::Left,
+            _ => HorizontalLocation::Middle,
+        };
+        (vert, horz)
     }
 
     fn set_highlight(&self, text: &mut TextDisplay) {
@@ -216,52 +239,68 @@ impl TextField {
                     .write(self.cursor.pos.row(), self.cursor.pos.col(), t);
                 self.move_cursor(0, 1);
             }
-            '\n' => {
-                if self.cursor.is_at_bottom() {
+            '\n' => match self.cursor.location() {
+                (VerticalLocation::Bottom, _) => {
                     self.cursor.unset_highlight(&mut self.text);
                     self.text.scroll_down(1);
                     self.move_cursor(0, -(self.cursor.pos.col() as isize))
-                } else {
-                    self.move_cursor(1, -(self.cursor.pos.col() as isize))
                 }
-            }
+                _ => self.move_cursor(1, -(self.cursor.pos.col() as isize)),
+            },
             '\r' => self.move_cursor(0, -(self.cursor.pos.col() as isize)),
             _ => {
                 for c in t.escape_default() {
                     self.text.write(self.cursor.pos.0, self.cursor.pos.1, c);
-                    self.move_cursor(0, 1);
+                    match self.cursor.location() {
+                        (_, HorizontalLocation::Left | HorizontalLocation::Middle) => {
+                            self.move_cursor(0, 1);
+                        }
+                        (
+                            VerticalLocation::Top | VerticalLocation::Middle,
+                            HorizontalLocation::Right,
+                        ) => self.move_cursor(1, -(self.cursor.pos.col() as isize)),
+                        (VerticalLocation::Bottom, HorizontalLocation::Right) => {
+                            self.cursor.unset_highlight(&mut self.text);
+                            self.text.scroll_down(1);
+                            self.cursor.set_highlight(&mut self.text);
+                            self.move_cursor(0, -(self.cursor.pos.col() as isize));
+                        }
+                    }
                 }
             }
         }
     }
 
     fn handle_op(&mut self, op: Op) {
-        use core::cmp::min;
-        use Op::*;
-        match &op {
-            TextOp(v) => println!(
-                "TextOp({:?}{}) [{}]",
-                &v[..min(v.len(), 5)],
-                if v.len() > 5 { "..." } else { "" },
-                v.len()
-            ),
-            DecPrivateSet(v) => {
-                println!(
-                    "DecPrivateSet({:?}{}) [{}]",
+        #[cfg(feature = "op_log")]
+        {
+            use core::cmp::min;
+            use Op::*;
+            match &op {
+                TextOp(v) => println!(
+                    "TextOp({:?}{}) [{}]",
                     &v[..min(v.len(), 5)],
                     if v.len() > 5 { "..." } else { "" },
                     v.len()
-                )
-            }
-            DecPrivateReset(v) => {
-                println!(
-                    "DecPrivateReset({:?}{}) [{}]",
-                    &v[..min(v.len(), 5)],
-                    if v.len() > 5 { "..." } else { "" },
-                    v.len()
-                )
+                ),
+                DecPrivateSet(v) => {
+                    println!(
+                        "DecPrivateSet({:?}{}) [{}]",
+                        &v[..min(v.len(), 5)],
+                        if v.len() > 5 { "..." } else { "" },
+                        v.len()
+                    )
+                }
+                DecPrivateReset(v) => {
+                    println!(
+                        "DecPrivateReset({:?}{}) [{}]",
+                        &v[..min(v.len(), 5)],
+                        if v.len() > 5 { "..." } else { "" },
+                        v.len()
+                    )
+                }
+                _ => println!("{:?}", op),
             }
-            _ => println!("{:?}", op),
         }
         match op {
             MoveCursorAbs { x, y } => {
@@ -274,7 +313,13 @@ impl TextField {
                 self.move_cursor(0, x as isize - self.cursor.pos.col() as isize);
             }
             MoveCursorDelta { dx, dy } => {
-                self.move_cursor(dy, dx);
+                // Constrain dx and dy so that the result added to the current position
+                // stays within the window
+                let x = (self.cursor.pos.col() as isize + dx).clamp(0, COLUMNS as isize - 1)
+                    - self.cursor.pos.col() as isize;
+                let y = (self.cursor.pos.row() as isize + dy).clamp(0, ROWS as isize - 1)
+                    - self.cursor.pos.row() as isize;
+                self.move_cursor(y, x);
             }
             MoveCursorBeginningAndLine { dy } => {
                 self.move_cursor(dy, -(self.cursor.pos.col() as isize));

src/video.rs

@@ -81,7 +81,7 @@ pub fn transmit_chunk() {
     spi::start_transmit(data);
     crate::perf::Measure::stop([start_xmit]);
 
-    timer::start_timer0_callback(1565, timer_callback);
+    timer::start_timer0_callback(1500, timer_callback);
     crate::perf::Measure::stop([xmit_chunk]);
     crate::perf::Measure::flush([start_xmit, tx_wait, xmit_chunk]);
 }