feat(kernel): 实现统一控制台trait并集成anaxa构建系统

Author: moyanj

.github/workflows/test.yml

@@ -23,6 +23,9 @@ jobs:
         with:
           targets: x86_64-unknown-none
 
+      - name: Setup Anaxa Build System
+        run: cargo install cargo-anaxa
+
       - name: Cache Rust dependencies
         uses: actions/cache@v4
         with:

kernel/src/main.rs

@@ -20,7 +20,7 @@
 #[macro_use]
 extern crate proka_kernel;
 extern crate alloc;
-use proka_kernel::BASE_REVISION;
+use proka_kernel::{output::console::CONSOLE, BASE_REVISION};
 /* The Kernel main code */
 // The normal one
 #[unsafe(no_mangle)]
@@ -71,6 +71,7 @@ pub extern "C" fn kernel_main() -> ! {
 
     let time = proka_kernel::libs::time::time_since_boot();
     println!("Time since boot: {time}");
+    CONSOLE.lock().cursor_show();
 
     loop {
         let mut buf = [0u8; 1];

kernel/src/output/console/console_bitfont.rs

@@ -283,3 +283,87 @@ impl Write for BitfontConsole {
         Ok(())
     }
 }
+
+// Implement the unified [`Console`] trait
+impl crate::output::console::Console for BitfontConsole {
+    fn clear(&mut self) {
+        self.position = (0, 0);
+        unsafe {
+            core::ptr::write_bytes(self.address, 0, (self.height * self.pitch) as usize);
+        }
+    }
+
+    fn set_fg_color(&mut self, color: Color) {
+        self.fg_color = color;
+    }
+
+    fn set_bg_color(&mut self, color: Color) {
+        self.bg_color = color;
+    }
+
+    fn get_fg_color(&self) -> Color {
+        self.fg_color
+    }
+
+    fn get_bg_color(&self) -> Color {
+        self.bg_color
+    }
+
+    fn put_char(&mut self, ch: char) {
+        // 将 char 转换为 u8，如果是 ASCII 范围内的字符
+        if ch.is_ascii() {
+            self.print_char(ch as u8);
+        } else {
+            // 对于非 ASCII 字符，打印替换字符 '?'
+            self.print_char(b'?');
+        }
+    }
+
+    fn cursor_up(&mut self, _lines: u32) {
+        // TODO: Implement cursor up
+        let y = self.position.1.saturating_sub(FONT_H * _lines as u64);
+        self.position.1 = y;
+    }
+
+    fn cursor_down(&mut self, _lines: u32) {
+        // TODO: Implement cursor down
+        let new_y = self.position.1 + FONT_H * _lines as u64;
+        if new_y + FONT_H <= self.height {
+            self.position.1 = new_y;
+        }
+    }
+
+    fn cursor_left(&mut self, _cols: u32) {
+        // TODO: Implement cursor left
+        let x = self.position.0.saturating_sub(FONT_W * _cols as u64);
+        self.position.0 = x;
+    }
+
+    fn cursor_right(&mut self, _cols: u32) {
+        // TODO: Implement cursor right
+        let new_x = self.position.0 + FONT_W * _cols as u64;
+        if new_x + FONT_W <= self.width {
+            self.position.0 = new_x;
+        }
+    }
+
+    fn set_cursor_pos(&mut self, x: u32, y: u32) {
+        self.position.0 = (x as u64 * FONT_W).min(self.width - FONT_W);
+        self.position.1 = (y as u64 * FONT_H).min(self.height - FONT_H);
+    }
+
+    fn get_cursor_pos(&self) -> (u32, u32) {
+        (
+            (self.position.0 / FONT_W) as u32,
+            (self.position.1 / FONT_H) as u32,
+        )
+    }
+
+    fn cursor_hide(&mut self) {
+        // TODO: Implement cursor hide
+    }
+
+    fn cursor_show(&mut self) {
+        // TODO: Implement cursor show
+    }
+}

kernel/src/output/console/console_ttf.rs

@@ -155,7 +155,7 @@ impl<'a> TtfConsole<'a> {
             font_baseline: 0.0,
             cursor_needs_redraw: true,
             glyph_cache: GlyphCache::new(GLYPH_CACHE_SIZE),
-            hidden_cursor: false,
+            hidden_cursor: true,
             ansi_parse_state: AnsiParseState::Normal,
             ansi_params: [0; MAX_ANSI_PARAMS],
             ansi_param_count: 0,
@@ -377,7 +377,8 @@ impl<'a> TtfConsole<'a> {
         }
     }
 
-    pub fn put_char(&mut self, ch: char) {
+    /// 将字符写入当前光标位置（不移动光标）
+    fn put_char_impl(&mut self, ch: char) {
         self.ensure_buffer_capacity();
 
         let current_buf_y = (self.cursor_y + self.scroll_offset_y as u32) as usize;
@@ -615,7 +616,7 @@ impl<'a> TtfConsole<'a> {
                     spaces_to_add = TAB_SPACES as u32;
                 }
                 for _ in 0..spaces_to_add {
-                    self.put_char(' ');
+                    self.put_char_impl(' ');
                     self.cursor_x += 1;
                     if self.cursor_x >= self.width_chars {
                         self.cursor_x = 0;
@@ -626,7 +627,7 @@ impl<'a> TtfConsole<'a> {
                 }
             }
             _ => {
-                self.put_char(c);
+                self.put_char_impl(c);
                 self.cursor_x += 1;
                 if self.cursor_x >= self.width_chars {
                     self.cursor_x = 0;
@@ -780,3 +781,124 @@ impl Write for TtfConsole<'_> {
         Ok(())
     }
 }
+
+// Implement the unified [`Console`] trait
+impl<'a> crate::output::console::Console for TtfConsole<'a> {
+    fn clear(&mut self) {
+        self.buffer.fill(None);
+        self.cursor_x = 0;
+        self.cursor_y = 0;
+        self.scroll_offset_y = 0;
+        self.cursor_needs_redraw = true;
+        self.redraw();
+    }
+
+    fn set_fg_color(&mut self, color: Color) {
+        if self.current_color != color {
+            self.current_color = color;
+            self.cursor_needs_redraw = true;
+        }
+    }
+
+    fn set_bg_color(&mut self, color: Color) {
+        if self.current_bg_color != color {
+            self.current_bg_color = color;
+            self.renderer.set_clear_color(color);
+            self.cursor_needs_redraw = true;
+            self.redraw();
+        }
+    }
+
+    fn get_fg_color(&self) -> Color {
+        self.current_color
+    }
+
+    fn get_bg_color(&self) -> Color {
+        self.current_bg_color
+    }
+
+    fn put_char(&mut self, ch: char) {
+        // 使用现有的 handle_normal_char 方法处理字符
+        // 但对于普通字符，直接调用 put_char 并更新位置
+        match ch {
+            '\n' => {
+                self.cursor_x = 0;
+                self.cursor_y += 1;
+                self.ensure_buffer_capacity();
+            }
+            '\r' => {
+                self.cursor_x = 0;
+            }
+            '\t' => {
+                let mut spaces_to_add = TAB_SPACES as u32 - (self.cursor_x % TAB_SPACES as u32);
+                if spaces_to_add == 0 {
+                    spaces_to_add = TAB_SPACES as u32;
+                }
+                for _ in 0..spaces_to_add {
+                    self.put_char_impl(' ');
+                    self.cursor_x += 1;
+                    if self.cursor_x >= self.width_chars {
+                        self.cursor_x = 0;
+                        self.cursor_y += 1;
+                        self.ensure_buffer_capacity();
+                        break;
+                    }
+                }
+            }
+            _ => {
+                self.put_char_impl(ch);
+                self.cursor_x += 1;
+                if self.cursor_x >= self.width_chars {
+                    self.cursor_x = 0;
+                    self.cursor_y += 1;
+                    self.ensure_buffer_capacity();
+                }
+            }
+        }
+        self.cursor_needs_redraw = true;
+        self.draw_cursor();
+        self.renderer.present();
+    }
+
+    fn cursor_up(&mut self, lines: u32) {
+        self.cursor_y = self.cursor_y.saturating_sub(lines);
+        self.cursor_needs_redraw = true;
+    }
+
+    fn cursor_down(&mut self, lines: u32) {
+        self.cursor_y = (self.cursor_y + lines).min(self.height_chars - 1);
+        self.ensure_buffer_capacity();
+        self.cursor_needs_redraw = true;
+    }
+
+    fn cursor_left(&mut self, cols: u32) {
+        self.cursor_x = self.cursor_x.saturating_sub(cols);
+        self.cursor_needs_redraw = true;
+    }
+
+    fn cursor_right(&mut self, cols: u32) {
+        self.cursor_x = (self.cursor_x + cols).min(self.width_chars - 1);
+        self.cursor_needs_redraw = true;
+    }
+
+    fn set_cursor_pos(&mut self, x: u32, y: u32) {
+        self.cursor_x = x.min(self.width_chars - 1);
+        self.cursor_y = y;
+        self.ensure_buffer_capacity();
+        self.cursor_needs_redraw = true;
+    }
+
+    fn get_cursor_pos(&self) -> (u32, u32) {
+        (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;
+    }
+}

kernel/src/output/console/mod.rs

@@ -2,6 +2,8 @@ use core::fmt::{self, Write};
 use lazy_static::lazy_static;
 use spin::Mutex;
 
+use crate::graphics::Color;
+
 #[cfg(ENABLE_BITFONT_CONSOLE)]
 pub mod console_bitfont;
 #[cfg(ENABLE_TTF_CONSOLE)]
@@ -12,47 +14,70 @@ pub use console_bitfont::BitfontConsole;
 #[cfg(ENABLE_TTF_CONSOLE)]
 pub use console_ttf::TtfConsole;
 
-pub enum ConsoleImpl<'a> {
-    #[cfg(ENABLE_BITFONT_CONSOLE)]
-    Bitfont(BitfontConsole, core::marker::PhantomData<&'a ()>),
-    #[cfg(ENABLE_TTF_CONSOLE)]
-    Ttf(TtfConsole<'a>),
-    #[cfg(not(any(ENABLE_BITFONT_CONSOLE, ENABLE_TTF_CONSOLE)))]
-    None(core::marker::PhantomData<&'a ()>),
-}
+/// 统一的 Console trait，定义所有 console 实现的通用接口
+pub trait Console: Write {
+    /// 清除屏幕
+    fn clear(&mut self);
 
-impl Write for ConsoleImpl<'_> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        match self {
-            #[cfg(ENABLE_BITFONT_CONSOLE)]
-            ConsoleImpl::Bitfont(c, _) => c.write_str(s),
-            #[cfg(ENABLE_TTF_CONSOLE)]
-            ConsoleImpl::Ttf(c) => c.write_str(s),
-            #[cfg(not(any(ENABLE_BITFONT_CONSOLE, ENABLE_TTF_CONSOLE)))]
-            ConsoleImpl::None(_) => Ok(()),
-        }
-    }
+    /// 设置前景色
+    fn set_fg_color(&mut self, color: Color);
+
+    /// 设置背景色
+    fn set_bg_color(&mut self, color: Color);
+
+    /// 获取当前前景色
+    fn get_fg_color(&self) -> Color;
+
+    /// 获取当前背景色
+    fn get_bg_color(&self) -> Color;
+
+    /// 打印单个字符
+    fn put_char(&mut self, ch: char);
+
+    /// 光标上移
+    fn cursor_up(&mut self, lines: u32);
+
+    /// 光标下移
+    fn cursor_down(&mut self, lines: u32);
+
+    /// 光标左移
+    fn cursor_left(&mut self, cols: u32);
+
+    /// 光标右移
+    fn cursor_right(&mut self, cols: u32);
+
+    /// 设置光标位置
+    fn set_cursor_pos(&mut self, x: u32, y: u32);
+
+    /// 获取光标位置
+    fn get_cursor_pos(&self) -> (u32, u32);
+
+    /// 隐藏光标
+    fn cursor_hide(&mut self);
+
+    /// 显示光标
+    fn cursor_show(&mut self);
 }
 
+pub type ConsoleImpl<'a> = alloc::boxed::Box<dyn Console + Send + 'a>;
+
 lazy_static! {
     pub static ref CONSOLE: Mutex<ConsoleImpl<'static>> = {
         let console_type = crate::config::DEFAULT_CONSOLE_TYPE;
         #[cfg(ENABLE_TTF_CONSOLE)]
         if console_type == "ttf" {
-            return Mutex::new(ConsoleImpl::Ttf(TtfConsole::init()));
+            return Mutex::new(alloc::boxed::Box::new(TtfConsole::init()));
         }
         #[cfg(ENABLE_BITFONT_CONSOLE)]
         if console_type == "bitfont" {
-            return Mutex::new(ConsoleImpl::Bitfont(BitfontConsole::init(), core::marker::PhantomData));
+            return Mutex::new(alloc::boxed::Box::new(BitfontConsole::init()));
         }
 
         // Fallback
         #[cfg(ENABLE_BITFONT_CONSOLE)]
-        return Mutex::new(ConsoleImpl::Bitfont(BitfontConsole::init(), core::marker::PhantomData));
+        return Mutex::new(alloc::boxed::Box::new(BitfontConsole::init()));
         #[cfg(all(not(ENABLE_BITFONT_CONSOLE), ENABLE_TTF_CONSOLE))]
-        return Mutex::new(ConsoleImpl::Ttf(TtfConsole::init()));
-        #[cfg(not(any(ENABLE_BITFONT_CONSOLE, ENABLE_TTF_CONSOLE)))]
-        return Mutex::new(ConsoleImpl::None(core::marker::PhantomData));
+        return Mutex::new(alloc::boxed::Box::new(TtfConsole::init()));
     };
 }
 
@@ -76,10 +101,11 @@ pub fn select_console(t: ConsoleType) {
     let mut console = CONSOLE.lock();
     *console = match t {
         #[cfg(ENABLE_BITFONT_CONSOLE)]
-        ConsoleType::Bitfont => {
-            ConsoleImpl::Bitfont(BitfontConsole::init(), core::marker::PhantomData)
-        }
+        ConsoleType::Bitfont => alloc::boxed::Box::new(BitfontConsole::init()),
         #[cfg(ENABLE_TTF_CONSOLE)]
-        ConsoleType::Ttf => ConsoleImpl::Ttf(TtfConsole::init()),
+        ConsoleType::Ttf => alloc::boxed::Box::new(TtfConsole::init()),
     };
 }
+
+#[cfg(not(any(ENABLE_BITFONT_CONSOLE, ENABLE_TTF_CONSOLE)))]
+compile_error!("At least one console implementation must be enabled");