Merge pull request #14 from Neotron-Compute/fix_scroll

Author: thejpster

src/lib.rs

@@ -34,14 +34,32 @@ static mut SERIAL_CONSOLE: Option<SerialConsole> = None;
 
 static OS_MENU: menu::Menu<Ctx> = menu::Menu {
     label: "root",
-    items: &[&menu::Item {
-        item_type: menu::ItemType::Callback {
-            function: cmd_mem,
-            parameters: &[],
+    items: &[
+        &menu::Item {
+            item_type: menu::ItemType::Callback {
+                function: cmd_mem,
+                parameters: &[],
+            },
+            command: "mem",
+            help: Some("Show memory regions"),
         },
-        command: "mem",
-        help: Some("Show memory regions"),
-    }],
+        &menu::Item {
+            item_type: menu::ItemType::Callback {
+                function: cmd_clear,
+                parameters: &[],
+            },
+            command: "clear",
+            help: Some("Clear the screen"),
+        },
+        &menu::Item {
+            item_type: menu::ItemType::Callback {
+                function: cmd_fill,
+                parameters: &[],
+            },
+            command: "fill",
+            help: Some("Fill the screen with characters"),
+        },
+    ],
     entry: None,
     exit: None,
 };
@@ -264,6 +282,34 @@ fn cmd_mem(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _co
     }
 }
 
+/// Called when the "clear" command is executed.
+fn cmd_clear(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _context: &mut Ctx) {
+    if let Some(ref mut console) = unsafe { &mut VGA_CONSOLE } {
+        console.clear();
+    }
+}
+
+/// Called when the "fill" command is executed.
+fn cmd_fill(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _context: &mut Ctx) {
+    if let Some(ref mut console) = unsafe { &mut VGA_CONSOLE } {
+        console.clear();
+    }
+    let api = API.get();
+    let mode = (api.video_get_mode)();
+    let (Some(width), Some(height)) = (mode.text_width(), mode.text_height()) else {
+        println!("Unable to get console size");
+        return;
+    };
+    // A range of printable ASCII compatible characters
+    let mut char_cycle = (' '..='~').cycle();
+    // Scroll two screen fulls
+    for _row in 0..height * 2 {
+        for _col in 0..width {
+            print!("{}", char_cycle.next().unwrap());
+        }
+    }
+}
+
 /// Called when we have a panic.
 #[inline(never)]
 #[panic_handler]

src/vgaconsole.rs

@@ -34,31 +34,40 @@ impl VgaConsole {
         self.row += 1;
     }
 
+    fn reset_cursor(&mut self) {
+        self.row = 0;
+        self.col = 0;
+    }
+
     fn scroll_as_required(&mut self) {
-        if self.col == self.width {
+        assert!(self.row <= self.height);
+        if self.col >= self.width {
             self.col = 0;
             self.row += 1;
         }
         if self.row == self.height {
-            self.row = self.height - 1;
+            self.row -= 1;
             self.scroll_page();
         }
     }
 
     pub fn clear(&mut self) {
         for row in 0..self.height {
             for col in 0..self.width {
-                self.row = row;
-                self.col = col;
-                self.write(b' ', Some(Self::DEFAULT_ATTR));
+                self.write_at(row, col, b' ', Some(Self::DEFAULT_ATTR));
             }
         }
-        self.row = 0;
-        self.col = 0;
+        self.reset_cursor();
     }
 
     fn write(&mut self, glyph: u8, attr: Option<u8>) {
-        let offset = ((self.row * self.width) + self.col) * 2;
+        self.write_at(self.row, self.col, glyph, attr);
+    }
+
+    fn write_at(&mut self, row: isize, col: isize, glyph: u8, attr: Option<u8>) {
+        assert!(row < self.height, "{} >= {}?", row, self.height);
+        assert!(col < self.width, "{} => {}?", col, self.width);
+        let offset = ((row * self.width) + col) * 2;
         unsafe { core::ptr::write_volatile(self.addr.offset(offset), glyph) };
         if let Some(a) = attr {
             unsafe { core::ptr::write_volatile(self.addr.offset(offset + 1), a) };
@@ -68,17 +77,16 @@ impl VgaConsole {
     fn scroll_page(&mut self) {
         let row_len_bytes = self.width * 2;
         unsafe {
+            // Scroll rows[1..=height-1] to become rows[0..=height-2].
             core::ptr::copy(
                 self.addr.offset(row_len_bytes),
                 self.addr,
                 (row_len_bytes * (self.height - 1)) as usize,
             );
-            // Blank bottom line
+            // Blank the bottom line of the screen (rows[height-1]).
             for col in 0..self.width {
-                self.col = col;
-                self.write(b' ', Some(Self::DEFAULT_ATTR));
+                self.write_at(self.height - 1, col, b' ', Some(Self::DEFAULT_ATTR));
             }
-            self.col = 0;
         }
     }
 
@@ -228,8 +236,12 @@ impl VgaConsole {
 impl core::fmt::Write for VgaConsole {
     fn write_str(&mut self, data: &str) -> core::fmt::Result {
         for ch in data.chars() {
+            self.scroll_as_required();
             match ch {
                 '\u{0008}' => {
+                    // This is a backspace, so we go back one character (if we
+                    // can). We expect the caller to provide "\u{0008} \u{0008}"
+                    // to actually erase the char then move the cursor over it.
                     if self.col > 0 {
                         self.col -= 1;
                     }
@@ -242,7 +254,6 @@ impl core::fmt::Write for VgaConsole {
                     self.move_char_down();
                 }
                 _ => {
-                    self.scroll_as_required();
                     self.write(Self::map_char_to_glyph(ch), None);
                     self.move_char_right();
                 }