Merge pull request #29 from Neotron-Compute/colour-screen-fill-command

Colour screen fill command

Author: thejpster

build.sh

@@ -8,14 +8,18 @@ mkdir -p ${RELEASE_DIR}
 
 # Build the embedded binaries for each core type and each flash layout
 for TARGET_ARCH in thumbv6m-none-eabi thumbv7m-none-eabi thumbv7em-none-eabi; do
+  echo "TARGET is ${TARGET_ARCH}"
   for BINARY in flash0002 flash0802 flash1002; do
-    # objcopy will do the build for us first
+    echo "BINARY is ${BINARY}"
+    cargo build --verbose --release --target=${TARGET_ARCH} --bin ${BINARY}
+    # objcopy would do the build for us first, but it doesn't have good build output
     cargo objcopy --verbose --release --target=${TARGET_ARCH} --bin ${BINARY} -- -O binary ${RELEASE_DIR}/${TARGET_ARCH}-${BINARY}-libneotron_os.bin
     # Keep the ELF file too (for debugging)
     cp ./target/${TARGET_ARCH}/release/${BINARY} ${RELEASE_DIR}/${TARGET_ARCH}-${BINARY}-libneotron_os.elf
   done
 done
 
 # Build the host version
+echo "Building HOST"
 cargo build --verbose --lib --release --target=x86_64-unknown-linux-gnu
 cp ./target/x86_64-unknown-linux-gnu/release/libneotron_os.so ${RELEASE_DIR}/x86_64-unknown-linux-gnu-libneotron_os.so

src/commands/screen.rs

@@ -1,6 +1,8 @@
 //! Screen-related commands for Neotron OS
 
-use crate::{print, println, Ctx, API, VGA_CONSOLE};
+use neotron_common_bios::video::{Attr, TextBackgroundColour, TextForegroundColour};
+
+use crate::{println, Ctx, API, VGA_CONSOLE};
 
 pub static CLEAR_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
@@ -31,19 +33,39 @@ fn clear(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx:
 fn fill(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &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());
+        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 = (b' '..=b'~').cycle();
+        let mut remaining = height * width;
+
+        // Scroll two screen fulls
+        'outer: for bg in (0..=7).cycle() {
+            let bg_colour = TextBackgroundColour::new(bg).unwrap();
+            for fg in 1..=15 {
+                if fg == bg {
+                    continue;
+                }
+                let fg_colour = TextForegroundColour::new(fg).unwrap();
+                remaining -= 1;
+                if remaining == 0 {
+                    break 'outer;
+                }
+                let attr = Attr::new(fg_colour, bg_colour, false);
+                let glyph = char_cycle.next().unwrap();
+                console.set_attr(attr);
+                console.write_bstr(&[glyph]);
+            }
         }
+        let attr = Attr::new(
+            TextForegroundColour::WHITE,
+            TextBackgroundColour::BLACK,
+            false,
+        );
+        console.set_attr(attr);
     }
 }

src/vgaconsole.rs

@@ -5,13 +5,13 @@
 
 use neotron_common_bios::video::{Attr, TextBackgroundColour, TextForegroundColour};
 
-#[derive(Debug)]
 pub struct VgaConsole {
     addr: *mut u8,
     width: isize,
     height: isize,
     row: isize,
     col: isize,
+    attr: Attr,
 }
 
 impl VgaConsole {
@@ -29,6 +29,7 @@ impl VgaConsole {
             height,
             row: 0,
             col: 0,
+            attr: Self::DEFAULT_ATTR,
         }
     }
 
@@ -60,24 +61,56 @@ impl VgaConsole {
     pub fn clear(&mut self) {
         for row in 0..self.height {
             for col in 0..self.width {
-                self.write_at(row, col, b' ', Some(Self::DEFAULT_ATTR));
+                self.write_at(row, col, b' ');
             }
         }
         self.reset_cursor();
     }
 
-    fn write(&mut self, glyph: u8, attr: Option<Attr>) {
-        self.write_at(self.row, self.col, glyph, attr);
+    pub fn write_bstr(&mut self, bstr: &[u8]) {
+        for b in bstr {
+            self.scroll_as_required();
+            match b {
+                0x08 => {
+                    // 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;
+                    }
+                }
+                b'\r' => {
+                    self.col = 0;
+                }
+                b'\n' => {
+                    self.col = 0;
+                    self.move_char_down();
+                }
+                _ => {
+                    self.write(*b);
+                    self.move_char_right();
+                }
+            }
+        }
     }
 
-    fn write_at(&mut self, row: isize, col: isize, glyph: u8, attr: Option<Attr>) {
+    /// Set the default attribute for any future text.
+    pub fn set_attr(&mut self, attr: Attr) {
+        self.attr = attr;
+    }
+
+    /// Put a glyph at the next position on the screen.
+    fn write(&mut self, glyph: u8) {
+        self.write_at(self.row, self.col, glyph);
+    }
+
+    /// Put a glyph at a given position on the screen.
+    fn write_at(&mut self, row: isize, col: isize, glyph: 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.0) };
-        }
+        unsafe { core::ptr::write_volatile(self.addr.offset(offset + 1), self.attr.as_u8()) };
     }
 
     fn scroll_page(&mut self) {
@@ -91,7 +124,7 @@ impl VgaConsole {
             );
             // Blank the bottom line of the screen (rows[height-1]).
             for col in 0..self.width {
-                self.write_at(self.height - 1, col, b' ', Some(Self::DEFAULT_ATTR));
+                self.write_at(self.height - 1, col, b' ');
             }
         }
     }
@@ -260,7 +293,7 @@ impl core::fmt::Write for VgaConsole {
                     self.move_char_down();
                 }
                 _ => {
-                    self.write(Self::map_char_to_glyph(ch), None);
+                    self.write(Self::map_char_to_glyph(ch));
                     self.move_char_right();
                 }
             }