feat(cursor): 实现了光标闪烁功能（bitmap only)

Author: zhangxuan2011

kernel/src/main.rs

@@ -21,7 +21,7 @@
 extern crate proka_kernel;
 extern crate alloc;
 
-use proka_kernel::{output::console::CONSOLE, BASE_REVISION};
+use proka_kernel::{BASE_REVISION, output::console::CONSOLE};
 /* The Kernel main code */
 // The normal one
 #[unsafe(no_mangle)]
@@ -57,13 +57,17 @@ pub extern "C" fn kernel_main() -> ! {
             proka_kernel::interrupts::apic::TIMER_VECTOR,
             "Timer",
             |_context| {
+                use proka_kernel::output::console::BITFONT_CURSOR_VISIBLE;
                 use core::sync::atomic::{AtomicU64, Ordering};
                 static TICKS: AtomicU64 = AtomicU64::new(0);
                 let t = TICKS.fetch_add(1, Ordering::Relaxed);
-                if t > 0 && t % 100 == 0 {
-                    println!("System Tick: {}s", t / 100);
+                if t > 0 && t % 20 == 0 {
+                    unsafe {
+                        let current = BITFONT_CURSOR_VISIBLE.load(Ordering::Relaxed);
+                        BITFONT_CURSOR_VISIBLE.store(!current, Ordering::Relaxed);
+                        CONSOLE.lock().show_cursor(!current);
+                    }
                 }
-
                 proka_kernel::interrupts::apic::registry::IrqResult::Handled
             },
         )
@@ -105,10 +109,7 @@ pub extern "C" fn kernel_main() -> ! {
 
     let time = proka_kernel::libs::time::time_since_boot();
     println!("Time since boot: {time}");
-    x86_64::instructions::interrupts::without_interrupts(|| {
-        CONSOLE.lock().cursor_show();
-    });
-
+    
     let shell = proka_kernel::libs::shell::Shell::new();
     shell.run("keyboard");
 

kernel/src/output/console/console_bitfont.rs

@@ -1,15 +1,18 @@
 extern crate alloc;
 
 use crate::graphics::{color, Color};
-use crate::output::font8x16::FONT8X16;
+use crate::output::font8x16::{CURSOR_UNDERLINE, FONT8X16};
 use crate::FRAMEBUFFER_REQUEST;
 use alloc::{vec, vec::Vec};
 use core::fmt::{self, Write};
+use core::sync::atomic::AtomicBool;
 
 // Constants
 const FONT_W: u64 = 8;
 const FONT_H: u64 = 16;
 
+pub static mut CURSOR_VISIBLE: AtomicBool = AtomicBool::new(false);
+
 /// The ANSI parse status
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum ParseState {
@@ -313,6 +316,42 @@ impl BitfontConsole {
         self.current_param = 0;
     }
 
+    /// draw a cursor at the current position.
+    pub fn draw_cursor(&mut self, is_visible: bool) {
+        let start_x = self.position.0;
+        let start_y = self.position.1;
+
+        for line in 0..FONT_H {
+            for i in 0..FONT_W {
+                let mask = 0x80 >> i;
+                let x = start_x + i;
+                let y = start_y + line;
+
+                if x < self.width && y < self.height {
+                    let pixel_offset = y * self.pitch + x * 4;
+
+                    if CURSOR_UNDERLINE[line as usize] & mask != 0 {
+                        if is_visible {
+                            unsafe {
+                                self.address
+                                    .add(pixel_offset as usize)
+                                    .cast::<u32>()
+                                    .write(self.fg_color.to_u32(true));
+                            }
+                        } else {
+                            unsafe {
+                                self.address
+                                    .add(pixel_offset as usize)
+                                    .cast::<u32>()
+                                    .write(self.bg_color.to_u32(true));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /// Print a string to console.
     pub fn print_string(&mut self, s: &str) {
         for c in s.bytes() {
@@ -431,11 +470,7 @@ impl crate::output::console::Console for BitfontConsole {
         )
     }
 
-    fn cursor_hide(&mut self) {
-        // TODO: Implement cursor hide
-    }
-
-    fn cursor_show(&mut self) {
-        // TODO: Implement cursor show
+    fn show_cursor(&mut self, is_visible: bool) {
+        self.draw_cursor(is_visible);
     }
 }

kernel/src/output/console/console_ttf.rs

@@ -5,13 +5,17 @@ use crate::FRAMEBUFFER_REQUEST;
 use ab_glyph::{Font, FontRef, PxScale, ScaleFont};
 use alloc::{collections::BTreeMap, vec, vec::Vec};
 use core::fmt::{self, Write};
+use core::sync::atomic::AtomicBool;
 use lazy_static::lazy_static;
 
 pub const DEFAULT_FONT_SIZE: f32 = 10.0;
 pub const TAB_SPACES: usize = 4;
 pub const GLYPH_CACHE_SIZE: usize = 95; // ASCII printable characters
 pub const MAX_ANSI_PARAMS: usize = 8;
 
+pub const CURSOR_VISIBLE: AtomicBool = AtomicBool::new(true);
+
+
 // The default font writer
 lazy_static! {
     pub static ref DEFAULT_FONT: FontRef<'static> = {
@@ -997,13 +1001,7 @@ impl<'a> crate::output::console::Console for TtfConsole<'a> {
         (self.cursor_x, self.cursor_y)
     }
 
-    fn cursor_hide(&mut self) {
-        self.hidden_cursor = true;
-        self.cursor_needs_redraw = true;
-    }
-
-    fn cursor_show(&mut self) {
-        self.hidden_cursor = false;
-        self.cursor_needs_redraw = true;
+    fn show_cursor(&mut self, _is_visible: bool) {
+        self.draw_cursor();
     }
 }

kernel/src/output/console/mod.rs

@@ -14,6 +14,12 @@ pub use console_bitfont::BitfontConsole;
 #[cfg(ENABLE_TTF_CONSOLE)]
 pub use console_ttf::TtfConsole;
 
+#[cfg(ENABLE_BITFONT_CONSOLE)]
+pub use console_bitfont::CURSOR_VISIBLE as BITFONT_CURSOR_VISIBLE;
+
+#[cfg(ENABLE_TTF_CONSOLE)]
+pub use console_ttf::CURSOR_VISIBLE as TTF_CURSOR_VISIBLE;
+
 /// General [`Console`] trait, which defined generic APIs.
 pub trait Console: Write {
     /// Clean screen
@@ -52,11 +58,8 @@ pub trait Console: Write {
     /// Get current cursor posision
     fn get_cursor_pos(&self) -> (u32, u32);
 
-    /// Hide cursor
-    fn cursor_hide(&mut self);
-
-    /// Show cursor
-    fn cursor_show(&mut self);
+    /// Draw cursor at current position
+    fn show_cursor(&mut self, is_visible: bool);
 }
 
 pub type ConsoleImpl<'a> = alloc::boxed::Box<dyn Console + Send + 'a>;

kernel/src/output/font8x16.rs

@@ -517,3 +517,8 @@ pub const FONT8X16: [[u8; 16]; 128] = [
         0x00,
     ], // 0x7F, delete
 ];
+
+/// The definition of the cursor, which is using underline style.
+pub const CURSOR_UNDERLINE: [u8; 16] = [
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+];