1abe3a6eaShanjiezhou use crate::{ 21496ba7bSLoGin driver::{ 352da9a59SGnoCiYeH serial::serial8250::send_to_default_serial8250_port, 4f3b05a97SGnoCiYeH tty::{tty_port::TTY_PORTS, virtual_terminal::virtual_console::CURRENT_VCNUM}, 552da9a59SGnoCiYeH video::video_refresh_manager, 61496ba7bSLoGin }, 71496ba7bSLoGin kdebug, kinfo, 81496ba7bSLoGin libs::{ 91496ba7bSLoGin lib_ui::font::FONT_8x16, 101496ba7bSLoGin rwlock::RwLock, 111496ba7bSLoGin spinlock::{SpinLock, SpinLockGuard}, 121496ba7bSLoGin }, 13abe3a6eaShanjiezhou }; 14abe3a6eaShanjiezhou use alloc::{boxed::Box, collections::LinkedList, string::ToString}; 15abe3a6eaShanjiezhou use alloc::{sync::Arc, vec::Vec}; 16abe3a6eaShanjiezhou use core::{ 17abe3a6eaShanjiezhou fmt::Debug, 18abe3a6eaShanjiezhou intrinsics::unlikely, 19abe3a6eaShanjiezhou ops::{Add, AddAssign, Sub}, 20abe3a6eaShanjiezhou sync::atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering}, 21abe3a6eaShanjiezhou }; 2291e9d4abSLoGin use system_error::SystemError; 23abe3a6eaShanjiezhou 24abe3a6eaShanjiezhou use super::{ 25abe3a6eaShanjiezhou screen_manager::{ 261496ba7bSLoGin scm_register, ScmBuffer, ScmBufferInfo, ScmFramworkType, ScmUiFramework, 271496ba7bSLoGin ScmUiFrameworkMetadata, 28abe3a6eaShanjiezhou }, 29abe3a6eaShanjiezhou textui_no_alloc::no_init_textui_putchar_window, 30abe3a6eaShanjiezhou }; 31abe3a6eaShanjiezhou 32abe3a6eaShanjiezhou /// 声明全局的TEXTUI_FRAMEWORK 331496ba7bSLoGin static mut __TEXTUI_FRAMEWORK: Option<Arc<TextUiFramework>> = None; 34abe3a6eaShanjiezhou 35abe3a6eaShanjiezhou /// 每个字符的宽度和高度(像素) 36abe3a6eaShanjiezhou pub const TEXTUI_CHAR_WIDTH: u32 = 8; 37abe3a6eaShanjiezhou 38abe3a6eaShanjiezhou pub const TEXTUI_CHAR_HEIGHT: u32 = 16; 39abe3a6eaShanjiezhou 40abe3a6eaShanjiezhou pub static mut TEXTUI_IS_INIT: bool = false; 41abe3a6eaShanjiezhou 421a72a751SLoGin static ENABLE_PUT_TO_WINDOW: AtomicBool = AtomicBool::new(false); 431a72a751SLoGin 441a72a751SLoGin /// 启用将文本输出到窗口的功能。 451a72a751SLoGin pub fn textui_enable_put_to_window() { 461a72a751SLoGin ENABLE_PUT_TO_WINDOW.store(true, Ordering::SeqCst); 471a72a751SLoGin } 481a72a751SLoGin 491a72a751SLoGin /// 禁用将文本输出到窗口的功能。 501a72a751SLoGin pub fn textui_disable_put_to_window() { 511a72a751SLoGin ENABLE_PUT_TO_WINDOW.store(false, Ordering::SeqCst); 521a72a751SLoGin } 531a72a751SLoGin 541a72a751SLoGin /// 检查是否启用了将文本输出到窗口的功能。 551a72a751SLoGin /// 561a72a751SLoGin /// # 返回 571a72a751SLoGin /// 如果启用了将文本输出到窗口的功能,则返回 `true`,否则返回 `false`。 581a72a751SLoGin pub fn textui_is_enable_put_to_window() -> bool { 591a72a751SLoGin ENABLE_PUT_TO_WINDOW.load(Ordering::SeqCst) 601a72a751SLoGin } 61abe3a6eaShanjiezhou 62abe3a6eaShanjiezhou /// 获取TEXTUI_FRAMEWORK的可变实例 631496ba7bSLoGin pub fn textui_framework() -> Arc<TextUiFramework> { 641496ba7bSLoGin unsafe { 651496ba7bSLoGin return __TEXTUI_FRAMEWORK 661496ba7bSLoGin .as_ref() 671496ba7bSLoGin .expect("Textui framework has not been initialized yet!") 681496ba7bSLoGin .clone(); 69abe3a6eaShanjiezhou } 701496ba7bSLoGin } 711496ba7bSLoGin 72abe3a6eaShanjiezhou /// 初始化TEXTUI_FRAMEWORK 735b59005fSLoGin fn textui_framwork_init() { 745b59005fSLoGin if unsafe { __TEXTUI_FRAMEWORK.is_none() } { 75abe3a6eaShanjiezhou kinfo!("textuiframework init"); 76abe3a6eaShanjiezhou let metadata = ScmUiFrameworkMetadata::new("TextUI".to_string(), ScmFramworkType::Text); 771496ba7bSLoGin kdebug!("textui metadata: {:?}", metadata); 78abe3a6eaShanjiezhou // 为textui框架生成第一个窗口 791496ba7bSLoGin let vlines_num = (metadata.buf_info().height() / TEXTUI_CHAR_HEIGHT) as usize; 80abe3a6eaShanjiezhou 811496ba7bSLoGin let chars_num = (metadata.buf_info().width() / TEXTUI_CHAR_WIDTH) as usize; 82abe3a6eaShanjiezhou 83abe3a6eaShanjiezhou let initial_window = TextuiWindow::new( 84abe3a6eaShanjiezhou WindowFlag::TEXTUI_CHROMATIC, 85abe3a6eaShanjiezhou vlines_num as i32, 86abe3a6eaShanjiezhou chars_num as i32, 87abe3a6eaShanjiezhou ); 88abe3a6eaShanjiezhou 89abe3a6eaShanjiezhou let current_window: Arc<SpinLock<TextuiWindow>> = Arc::new(SpinLock::new(initial_window)); 90abe3a6eaShanjiezhou 91abe3a6eaShanjiezhou let default_window = current_window.clone(); 92abe3a6eaShanjiezhou 93abe3a6eaShanjiezhou // 生成窗口链表,并把上面窗口添加进textui框架的窗口链表中 94abe3a6eaShanjiezhou let window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>> = 95abe3a6eaShanjiezhou Arc::new(SpinLock::new(LinkedList::new())); 96abe3a6eaShanjiezhou window_list.lock().push_back(current_window.clone()); 97abe3a6eaShanjiezhou 985b59005fSLoGin unsafe { 991496ba7bSLoGin __TEXTUI_FRAMEWORK = Some(Arc::new(TextUiFramework::new( 100abe3a6eaShanjiezhou metadata, 101abe3a6eaShanjiezhou window_list, 102abe3a6eaShanjiezhou current_window, 103abe3a6eaShanjiezhou default_window, 1045b59005fSLoGin ))) 1055b59005fSLoGin }; 1061496ba7bSLoGin 1071496ba7bSLoGin scm_register(textui_framework()).expect("register textui framework failed"); 1081496ba7bSLoGin kdebug!("textui framework init success"); 1091496ba7bSLoGin 110a03c4f9dSLoGin send_to_default_serial8250_port("\ntext ui initialized\n\0".as_bytes()); 1111496ba7bSLoGin unsafe { TEXTUI_IS_INIT = true }; 112abe3a6eaShanjiezhou } else { 113abe3a6eaShanjiezhou panic!("Try to init TEXTUI_FRAMEWORK twice!"); 114abe3a6eaShanjiezhou } 115abe3a6eaShanjiezhou } 116abe3a6eaShanjiezhou // window标志位 117abe3a6eaShanjiezhou bitflags! { 118abe3a6eaShanjiezhou pub struct WindowFlag: u8 { 119abe3a6eaShanjiezhou // 采用彩色字符 120abe3a6eaShanjiezhou const TEXTUI_CHROMATIC = 1 << 0; 121abe3a6eaShanjiezhou } 122abe3a6eaShanjiezhou } 123abe3a6eaShanjiezhou 124abe3a6eaShanjiezhou /** 125abe3a6eaShanjiezhou * @brief 黑白字符对象 126abe3a6eaShanjiezhou * 127abe3a6eaShanjiezhou */ 128abe3a6eaShanjiezhou #[derive(Clone, Debug)] 129abe3a6eaShanjiezhou struct TextuiCharNormal { 130abe3a6eaShanjiezhou _data: u8, 131abe3a6eaShanjiezhou } 132abe3a6eaShanjiezhou 133abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash, Default)] 134abe3a6eaShanjiezhou pub struct LineId(i32); 135abe3a6eaShanjiezhou impl LineId { 136abe3a6eaShanjiezhou pub fn new(num: i32) -> Self { 137abe3a6eaShanjiezhou LineId(num) 138abe3a6eaShanjiezhou } 139abe3a6eaShanjiezhou 140abe3a6eaShanjiezhou pub fn check(&self, max: i32) -> bool { 141abe3a6eaShanjiezhou self.0 < max && self.0 >= 0 142abe3a6eaShanjiezhou } 143abe3a6eaShanjiezhou 144abe3a6eaShanjiezhou pub fn data(&self) -> i32 { 145abe3a6eaShanjiezhou self.0 146abe3a6eaShanjiezhou } 147abe3a6eaShanjiezhou } 148abe3a6eaShanjiezhou impl Add<i32> for LineId { 149abe3a6eaShanjiezhou type Output = LineId; 150abe3a6eaShanjiezhou fn add(self, rhs: i32) -> Self::Output { 151abe3a6eaShanjiezhou LineId::new(self.0 + rhs) 152abe3a6eaShanjiezhou } 153abe3a6eaShanjiezhou } 154abe3a6eaShanjiezhou impl Sub<i32> for LineId { 155abe3a6eaShanjiezhou type Output = LineId; 156abe3a6eaShanjiezhou 157abe3a6eaShanjiezhou fn sub(self, rhs: i32) -> Self::Output { 158abe3a6eaShanjiezhou LineId::new(self.0 - rhs) 159abe3a6eaShanjiezhou } 160abe3a6eaShanjiezhou } 161*b5b571e0SLoGin impl From<LineId> for i32 { 162*b5b571e0SLoGin fn from(value: LineId) -> Self { 163*b5b571e0SLoGin value.0 164abe3a6eaShanjiezhou } 165abe3a6eaShanjiezhou } 166*b5b571e0SLoGin impl From<LineId> for u32 { 167*b5b571e0SLoGin fn from(value: LineId) -> Self { 168*b5b571e0SLoGin value.0 as u32 169abe3a6eaShanjiezhou } 170abe3a6eaShanjiezhou } 171*b5b571e0SLoGin impl From<LineId> for usize { 172*b5b571e0SLoGin fn from(value: LineId) -> Self { 173*b5b571e0SLoGin value.0 as usize 174abe3a6eaShanjiezhou } 175abe3a6eaShanjiezhou } 176abe3a6eaShanjiezhou impl Sub<LineId> for LineId { 177abe3a6eaShanjiezhou type Output = LineId; 178abe3a6eaShanjiezhou 179abe3a6eaShanjiezhou fn sub(mut self, rhs: LineId) -> Self::Output { 180abe3a6eaShanjiezhou self.0 -= rhs.0; 181abe3a6eaShanjiezhou return self; 182abe3a6eaShanjiezhou } 183abe3a6eaShanjiezhou } 184abe3a6eaShanjiezhou impl AddAssign<LineId> for LineId { 185abe3a6eaShanjiezhou fn add_assign(&mut self, rhs: LineId) { 186abe3a6eaShanjiezhou self.0 += rhs.0; 187abe3a6eaShanjiezhou } 188abe3a6eaShanjiezhou } 189abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash, Default)] 190abe3a6eaShanjiezhou pub struct LineIndex(i32); 191abe3a6eaShanjiezhou impl LineIndex { 192abe3a6eaShanjiezhou pub fn new(num: i32) -> Self { 193abe3a6eaShanjiezhou LineIndex(num) 194abe3a6eaShanjiezhou } 195abe3a6eaShanjiezhou pub fn check(&self, chars_per_line: i32) -> bool { 196abe3a6eaShanjiezhou self.0 < chars_per_line && self.0 >= 0 197abe3a6eaShanjiezhou } 198abe3a6eaShanjiezhou } 199abe3a6eaShanjiezhou impl Add<LineIndex> for LineIndex { 200abe3a6eaShanjiezhou type Output = LineIndex; 201abe3a6eaShanjiezhou 202abe3a6eaShanjiezhou fn add(self, rhs: LineIndex) -> Self::Output { 203abe3a6eaShanjiezhou LineIndex::new(self.0 + rhs.0) 204abe3a6eaShanjiezhou } 205abe3a6eaShanjiezhou } 206abe3a6eaShanjiezhou impl Add<i32> for LineIndex { 207abe3a6eaShanjiezhou // type Output = Self; 208abe3a6eaShanjiezhou type Output = LineIndex; 209abe3a6eaShanjiezhou 210abe3a6eaShanjiezhou fn add(self, rhs: i32) -> Self::Output { 211abe3a6eaShanjiezhou LineIndex::new(self.0 + rhs) 212abe3a6eaShanjiezhou } 213abe3a6eaShanjiezhou } 214abe3a6eaShanjiezhou impl Sub<i32> for LineIndex { 215abe3a6eaShanjiezhou type Output = LineIndex; 216abe3a6eaShanjiezhou 217abe3a6eaShanjiezhou fn sub(self, rhs: i32) -> Self::Output { 218abe3a6eaShanjiezhou LineIndex::new(self.0 - rhs) 219abe3a6eaShanjiezhou } 220abe3a6eaShanjiezhou } 221abe3a6eaShanjiezhou 222*b5b571e0SLoGin impl From<LineIndex> for i32 { 223*b5b571e0SLoGin fn from(val: LineIndex) -> Self { 224*b5b571e0SLoGin val.0 225abe3a6eaShanjiezhou } 226abe3a6eaShanjiezhou } 227*b5b571e0SLoGin impl From<LineIndex> for u32 { 228*b5b571e0SLoGin fn from(value: LineIndex) -> Self { 229*b5b571e0SLoGin value.0 as u32 230abe3a6eaShanjiezhou } 231abe3a6eaShanjiezhou } 232*b5b571e0SLoGin impl From<LineIndex> for usize { 233*b5b571e0SLoGin fn from(value: LineIndex) -> Self { 234*b5b571e0SLoGin value.0 as usize 235abe3a6eaShanjiezhou } 236abe3a6eaShanjiezhou } 237abe3a6eaShanjiezhou #[derive(Copy, Clone, Debug)] 238abe3a6eaShanjiezhou pub struct FontColor(u32); 239abe3a6eaShanjiezhou #[allow(dead_code)] 240abe3a6eaShanjiezhou impl FontColor { 241abe3a6eaShanjiezhou pub const BLUE: FontColor = FontColor::new(0, 0, 0xff); 242abe3a6eaShanjiezhou pub const RED: FontColor = FontColor::new(0xff, 0, 0); 243abe3a6eaShanjiezhou pub const GREEN: FontColor = FontColor::new(0, 0xff, 0); 244abe3a6eaShanjiezhou pub const WHITE: FontColor = FontColor::new(0xff, 0xff, 0xff); 245abe3a6eaShanjiezhou pub const BLACK: FontColor = FontColor::new(0, 0, 0); 246abe3a6eaShanjiezhou pub const YELLOW: FontColor = FontColor::new(0xff, 0xff, 0); 247abe3a6eaShanjiezhou pub const ORANGE: FontColor = FontColor::new(0xff, 0x80, 0); 248abe3a6eaShanjiezhou pub const INDIGO: FontColor = FontColor::new(0x00, 0xff, 0xff); 249abe3a6eaShanjiezhou pub const PURPLE: FontColor = FontColor::new(0x80, 0x00, 0xff); 250abe3a6eaShanjiezhou 251abe3a6eaShanjiezhou pub const fn new(r: u8, g: u8, b: u8) -> Self { 252abe3a6eaShanjiezhou let val = ((r as u32) << 16) | ((g as u32) << 8) | (b as u32); 253abe3a6eaShanjiezhou return FontColor(val & 0x00ffffff); 254abe3a6eaShanjiezhou } 255abe3a6eaShanjiezhou } 256abe3a6eaShanjiezhou 257abe3a6eaShanjiezhou impl From<u32> for FontColor { 258abe3a6eaShanjiezhou fn from(value: u32) -> Self { 259abe3a6eaShanjiezhou return Self(value & 0x00ffffff); 260abe3a6eaShanjiezhou } 261abe3a6eaShanjiezhou } 262*b5b571e0SLoGin impl From<FontColor> for usize { 263*b5b571e0SLoGin fn from(value: FontColor) -> Self { 264*b5b571e0SLoGin value.0 as usize 265abe3a6eaShanjiezhou } 266abe3a6eaShanjiezhou } 267*b5b571e0SLoGin impl From<FontColor> for u32 { 268*b5b571e0SLoGin fn from(value: FontColor) -> Self { 269*b5b571e0SLoGin value.0 270abe3a6eaShanjiezhou } 271abe3a6eaShanjiezhou } 272*b5b571e0SLoGin impl From<FontColor> for u16 { 273*b5b571e0SLoGin fn from(value: FontColor) -> Self { 274*b5b571e0SLoGin value.0 as u16 275abe3a6eaShanjiezhou } 276abe3a6eaShanjiezhou } 277*b5b571e0SLoGin impl From<FontColor> for u64 { 278*b5b571e0SLoGin fn from(value: FontColor) -> Self { 279*b5b571e0SLoGin value.0 as u64 280abe3a6eaShanjiezhou } 281abe3a6eaShanjiezhou } 282abe3a6eaShanjiezhou 283abe3a6eaShanjiezhou /// 彩色字符对象 284abe3a6eaShanjiezhou 285abe3a6eaShanjiezhou #[derive(Clone, Debug, Copy)] 286abe3a6eaShanjiezhou pub struct TextuiCharChromatic { 287abe3a6eaShanjiezhou c: Option<char>, 288abe3a6eaShanjiezhou 289abe3a6eaShanjiezhou // 前景色 290abe3a6eaShanjiezhou frcolor: FontColor, // rgb 291abe3a6eaShanjiezhou 292abe3a6eaShanjiezhou // 背景色 293abe3a6eaShanjiezhou bkcolor: FontColor, // rgb 294abe3a6eaShanjiezhou } 295abe3a6eaShanjiezhou 296abe3a6eaShanjiezhou #[derive(Debug)] 2971496ba7bSLoGin pub struct TextuiBuf<'a> { 2981496ba7bSLoGin buf: Option<&'a mut [u32]>, 2991496ba7bSLoGin guard: Option<SpinLockGuard<'a, Box<[u32]>>>, 3001496ba7bSLoGin } 301abe3a6eaShanjiezhou 302abe3a6eaShanjiezhou impl TextuiBuf<'_> { 3031496ba7bSLoGin pub fn new(buf: &mut ScmBufferInfo) -> TextuiBuf { 3041496ba7bSLoGin let len = buf.buf_size() / 4; 3051496ba7bSLoGin 3061496ba7bSLoGin match &buf.buf { 3071496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 3081496ba7bSLoGin return TextuiBuf { 3091496ba7bSLoGin buf: Some(unsafe { 3101496ba7bSLoGin core::slice::from_raw_parts_mut(vaddr.data() as *mut u32, len) 3111496ba7bSLoGin }), 3121496ba7bSLoGin guard: None, 3131496ba7bSLoGin }; 3141496ba7bSLoGin } 3151496ba7bSLoGin 3161496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 3171496ba7bSLoGin let guard: SpinLockGuard<'_, Box<[u32]>> = double_buffer.lock(); 3181496ba7bSLoGin 3191496ba7bSLoGin return TextuiBuf { 3201496ba7bSLoGin buf: None, 3211496ba7bSLoGin guard: Some(guard), 3221496ba7bSLoGin }; 3231496ba7bSLoGin } 3241496ba7bSLoGin } 3251496ba7bSLoGin } 3261496ba7bSLoGin 3271496ba7bSLoGin pub fn buf_mut(&mut self) -> &mut [u32] { 3281496ba7bSLoGin if let Some(buf) = &mut self.buf { 3291496ba7bSLoGin return buf; 3301496ba7bSLoGin } else { 3311496ba7bSLoGin return self.guard.as_mut().unwrap().as_mut(); 3321496ba7bSLoGin } 333abe3a6eaShanjiezhou } 334abe3a6eaShanjiezhou pub fn put_color_in_pixel(&mut self, color: u32, index: usize) { 3351496ba7bSLoGin let buf: &mut [u32] = self.buf_mut(); 336abe3a6eaShanjiezhou buf[index] = color; 337abe3a6eaShanjiezhou } 338abe3a6eaShanjiezhou pub fn get_index_of_next_line(now_index: usize) -> usize { 3391496ba7bSLoGin textui_framework().metadata.read().buf_info().width() as usize + now_index 340abe3a6eaShanjiezhou } 341abe3a6eaShanjiezhou pub fn get_index_by_x_y(x: usize, y: usize) -> usize { 3421496ba7bSLoGin textui_framework().metadata.read().buf_info().width() as usize * y + x 343abe3a6eaShanjiezhou } 344abe3a6eaShanjiezhou pub fn get_start_index_by_lineid_lineindex(lineid: LineId, lineindex: LineIndex) -> usize { 345abe3a6eaShanjiezhou // x 左上角列像素点位置 346abe3a6eaShanjiezhou // y 左上角行像素点位置 347abe3a6eaShanjiezhou let index_x: u32 = lineindex.into(); 348abe3a6eaShanjiezhou let x: u32 = index_x * TEXTUI_CHAR_WIDTH; 349abe3a6eaShanjiezhou 350abe3a6eaShanjiezhou let id_y: u32 = lineid.into(); 351abe3a6eaShanjiezhou let y: u32 = id_y * TEXTUI_CHAR_HEIGHT; 352abe3a6eaShanjiezhou 353abe3a6eaShanjiezhou TextuiBuf::get_index_by_x_y(x as usize, y as usize) 354abe3a6eaShanjiezhou } 355abe3a6eaShanjiezhou } 356abe3a6eaShanjiezhou 357abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 358abe3a6eaShanjiezhou pub struct Font([u8; 16]); 359abe3a6eaShanjiezhou impl Font { 360abe3a6eaShanjiezhou #[inline] 361abe3a6eaShanjiezhou pub fn get_font(character: char) -> Font { 362abe3a6eaShanjiezhou let x = FONT_8x16.char_map(character); 363abe3a6eaShanjiezhou 364abe3a6eaShanjiezhou let mut data = [0u8; 16]; 365abe3a6eaShanjiezhou data.copy_from_slice(x); 366abe3a6eaShanjiezhou return Font(data); 367abe3a6eaShanjiezhou } 368abe3a6eaShanjiezhou pub fn is_frcolor(&self, height: usize, width: usize) -> bool { 369abe3a6eaShanjiezhou let w = self.0[height]; 370abe3a6eaShanjiezhou let testbit = 1 << (8 - width); 371abe3a6eaShanjiezhou w & testbit != 0 372abe3a6eaShanjiezhou } 373abe3a6eaShanjiezhou } 374abe3a6eaShanjiezhou 375abe3a6eaShanjiezhou impl TextuiCharChromatic { 376abe3a6eaShanjiezhou pub fn new(c: Option<char>, frcolor: FontColor, bkcolor: FontColor) -> Self { 377abe3a6eaShanjiezhou TextuiCharChromatic { 378abe3a6eaShanjiezhou c, 379abe3a6eaShanjiezhou frcolor, 380abe3a6eaShanjiezhou bkcolor, 381abe3a6eaShanjiezhou } 382abe3a6eaShanjiezhou } 383abe3a6eaShanjiezhou 384abe3a6eaShanjiezhou /// 将该字符对象输出到缓冲区 385abe3a6eaShanjiezhou /// ## 参数 386abe3a6eaShanjiezhou /// -line_id 要放入的真实行号 387abe3a6eaShanjiezhou /// -index 要放入的真实列号 388abe3a6eaShanjiezhou pub fn textui_refresh_character( 389abe3a6eaShanjiezhou &self, 390abe3a6eaShanjiezhou lineid: LineId, 391abe3a6eaShanjiezhou lineindex: LineIndex, 392abe3a6eaShanjiezhou ) -> Result<i32, SystemError> { 393abe3a6eaShanjiezhou // 找到要渲染的字符的像素点数据 394abe3a6eaShanjiezhou 395abe3a6eaShanjiezhou let font: Font = Font::get_font(self.c.unwrap_or(' ')); 396abe3a6eaShanjiezhou 397abe3a6eaShanjiezhou let mut count = TextuiBuf::get_start_index_by_lineid_lineindex(lineid, lineindex); 398abe3a6eaShanjiezhou 3991496ba7bSLoGin let mut _binding = textui_framework().metadata.read().buf_info(); 4001496ba7bSLoGin 4011496ba7bSLoGin let mut buf = TextuiBuf::new(&mut _binding); 4021496ba7bSLoGin 403abe3a6eaShanjiezhou // 在缓冲区画出一个字体,每个字体有TEXTUI_CHAR_HEIGHT行,TEXTUI_CHAR_WIDTH列个像素点 404abe3a6eaShanjiezhou for i in 0..TEXTUI_CHAR_HEIGHT { 405abe3a6eaShanjiezhou let start = count; 406abe3a6eaShanjiezhou for j in 0..TEXTUI_CHAR_WIDTH { 407abe3a6eaShanjiezhou if font.is_frcolor(i as usize, j as usize) { 408abe3a6eaShanjiezhou // 字,显示前景色 409abe3a6eaShanjiezhou buf.put_color_in_pixel(self.frcolor.into(), count); 410abe3a6eaShanjiezhou } else { 411abe3a6eaShanjiezhou // 背景色 412abe3a6eaShanjiezhou buf.put_color_in_pixel(self.bkcolor.into(), count); 413abe3a6eaShanjiezhou } 414abe3a6eaShanjiezhou count += 1; 415abe3a6eaShanjiezhou } 416abe3a6eaShanjiezhou count = TextuiBuf::get_index_of_next_line(start); 417abe3a6eaShanjiezhou } 418abe3a6eaShanjiezhou 419abe3a6eaShanjiezhou return Ok(0); 420abe3a6eaShanjiezhou } 421abe3a6eaShanjiezhou 422abe3a6eaShanjiezhou pub fn no_init_textui_render_chromatic(&self, lineid: LineId, lineindex: LineIndex) { 423abe3a6eaShanjiezhou // 找到要渲染的字符的像素点数据 424abe3a6eaShanjiezhou let font = Font::get_font(self.c.unwrap_or(' ')); 425abe3a6eaShanjiezhou 426abe3a6eaShanjiezhou // x 左上角列像素点位置 427abe3a6eaShanjiezhou // y 左上角行像素点位置 428abe3a6eaShanjiezhou let index_x: u32 = lineindex.into(); 429abe3a6eaShanjiezhou let x: u32 = index_x * TEXTUI_CHAR_WIDTH; 430abe3a6eaShanjiezhou 431abe3a6eaShanjiezhou let id_y: u32 = lineid.into(); 432abe3a6eaShanjiezhou let y: u32 = id_y * TEXTUI_CHAR_HEIGHT; 4331496ba7bSLoGin 4341496ba7bSLoGin let buf_width = video_refresh_manager().device_buffer().width(); 435abe3a6eaShanjiezhou // 找到输入缓冲区的起始地址位置 4361496ba7bSLoGin let buf_start = 4371496ba7bSLoGin if let ScmBuffer::DeviceBuffer(vaddr) = video_refresh_manager().device_buffer().buf { 4381496ba7bSLoGin vaddr 4391496ba7bSLoGin } else { 4401496ba7bSLoGin panic!("device buffer is not init"); 4411496ba7bSLoGin }; 442abe3a6eaShanjiezhou 443abe3a6eaShanjiezhou let mut testbit: u32; // 用来测试特定行的某列是背景还是字体本身 444abe3a6eaShanjiezhou 445abe3a6eaShanjiezhou // 在缓冲区画出一个字体,每个字体有TEXTUI_CHAR_HEIGHT行,TEXTUI_CHAR_WIDTH列个像素点 446abe3a6eaShanjiezhou for i in 0..TEXTUI_CHAR_HEIGHT { 447abe3a6eaShanjiezhou // 计算出帧缓冲区每一行打印的起始位置的地址(起始位置+(y+i)*缓冲区的宽度+x) 448abe3a6eaShanjiezhou 4491496ba7bSLoGin let mut addr: *mut u32 = 4501496ba7bSLoGin (buf_start + buf_width as usize * 4 * (y as usize + i as usize) + 4 * x as usize) 4511496ba7bSLoGin .data() as *mut u32; 452abe3a6eaShanjiezhou 453abe3a6eaShanjiezhou testbit = 1 << (TEXTUI_CHAR_WIDTH + 1); 454abe3a6eaShanjiezhou 455abe3a6eaShanjiezhou for _j in 0..TEXTUI_CHAR_WIDTH { 456abe3a6eaShanjiezhou //从左往右逐个测试相应位 457abe3a6eaShanjiezhou testbit >>= 1; 458abe3a6eaShanjiezhou if (font.0[i as usize] & testbit as u8) != 0 { 459abe3a6eaShanjiezhou unsafe { *addr = self.frcolor.into() }; // 字,显示前景色 460abe3a6eaShanjiezhou } else { 461abe3a6eaShanjiezhou unsafe { *addr = self.bkcolor.into() }; // 背景色 462abe3a6eaShanjiezhou } 463abe3a6eaShanjiezhou 464abe3a6eaShanjiezhou unsafe { 465*b5b571e0SLoGin addr = addr.offset(1); 466abe3a6eaShanjiezhou } 467abe3a6eaShanjiezhou } 468abe3a6eaShanjiezhou } 469abe3a6eaShanjiezhou } 470abe3a6eaShanjiezhou } 471abe3a6eaShanjiezhou 472abe3a6eaShanjiezhou /// 单色显示的虚拟行结构体 473abe3a6eaShanjiezhou 474abe3a6eaShanjiezhou #[derive(Clone, Debug, Default)] 475abe3a6eaShanjiezhou pub struct TextuiVlineNormal { 476abe3a6eaShanjiezhou _characters: Vec<TextuiCharNormal>, // 字符对象数组 477abe3a6eaShanjiezhou _index: i16, // 当前操作的位置 478abe3a6eaShanjiezhou } 479abe3a6eaShanjiezhou /// 彩色显示的虚拟行结构体 480abe3a6eaShanjiezhou 481abe3a6eaShanjiezhou #[derive(Clone, Debug, Default)] 482abe3a6eaShanjiezhou pub struct TextuiVlineChromatic { 483abe3a6eaShanjiezhou chars: Vec<TextuiCharChromatic>, // 字符对象数组 484abe3a6eaShanjiezhou index: LineIndex, // 当前操作的位置 485abe3a6eaShanjiezhou } 486abe3a6eaShanjiezhou impl TextuiVlineChromatic { 487abe3a6eaShanjiezhou pub fn new(char_num: usize) -> Self { 488abe3a6eaShanjiezhou let mut r = TextuiVlineChromatic { 489abe3a6eaShanjiezhou chars: Vec::with_capacity(char_num), 490abe3a6eaShanjiezhou index: LineIndex::new(0), 491abe3a6eaShanjiezhou }; 492abe3a6eaShanjiezhou 493abe3a6eaShanjiezhou for _ in 0..char_num { 494abe3a6eaShanjiezhou r.chars.push(TextuiCharChromatic::new( 495abe3a6eaShanjiezhou None, 496abe3a6eaShanjiezhou FontColor::BLACK, 497abe3a6eaShanjiezhou FontColor::BLACK, 498abe3a6eaShanjiezhou )); 499abe3a6eaShanjiezhou } 500abe3a6eaShanjiezhou 501abe3a6eaShanjiezhou return r; 502abe3a6eaShanjiezhou } 503abe3a6eaShanjiezhou } 504abe3a6eaShanjiezhou 505abe3a6eaShanjiezhou #[derive(Clone, Debug)] 506abe3a6eaShanjiezhou pub enum TextuiVline { 507abe3a6eaShanjiezhou Chromatic(TextuiVlineChromatic), 508abe3a6eaShanjiezhou _Normal(TextuiVlineNormal), 509abe3a6eaShanjiezhou } 510abe3a6eaShanjiezhou 511abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 512abe3a6eaShanjiezhou pub struct WindowId(u32); 513abe3a6eaShanjiezhou 514abe3a6eaShanjiezhou impl WindowId { 515abe3a6eaShanjiezhou pub fn new() -> Self { 516abe3a6eaShanjiezhou static MAX_ID: AtomicU32 = AtomicU32::new(0); 517abe3a6eaShanjiezhou return WindowId(MAX_ID.fetch_add(1, Ordering::SeqCst)); 518abe3a6eaShanjiezhou } 519abe3a6eaShanjiezhou } 520abe3a6eaShanjiezhou #[allow(dead_code)] 521abe3a6eaShanjiezhou #[derive(Clone, Debug)] 522abe3a6eaShanjiezhou pub struct TextuiWindow { 523abe3a6eaShanjiezhou // 虚拟行是个循环表,头和尾相接 524abe3a6eaShanjiezhou id: WindowId, 525abe3a6eaShanjiezhou // 虚拟行总数 526abe3a6eaShanjiezhou vline_sum: i32, 527abe3a6eaShanjiezhou // 当前已经使用了的虚拟行总数(即在已经输入到缓冲区(之后显示在屏幕上)的虚拟行数量) 528abe3a6eaShanjiezhou vlines_used: i32, 529abe3a6eaShanjiezhou // 位于最顶上的那一个虚拟行的行号 530abe3a6eaShanjiezhou top_vline: LineId, 531abe3a6eaShanjiezhou // 储存虚拟行的数组 532abe3a6eaShanjiezhou vlines: Vec<TextuiVline>, 533abe3a6eaShanjiezhou // 正在操作的vline 534abe3a6eaShanjiezhou vline_operating: LineId, 535abe3a6eaShanjiezhou // 每行最大容纳的字符数 536abe3a6eaShanjiezhou chars_per_line: i32, 537abe3a6eaShanjiezhou // 窗口flag 538abe3a6eaShanjiezhou flags: WindowFlag, 539abe3a6eaShanjiezhou } 540abe3a6eaShanjiezhou 541abe3a6eaShanjiezhou impl TextuiWindow { 542abe3a6eaShanjiezhou /// 使用参数初始化window对象 543abe3a6eaShanjiezhou /// ## 参数 544abe3a6eaShanjiezhou /// 545abe3a6eaShanjiezhou /// -flags 标志位 546abe3a6eaShanjiezhou /// -vlines_num 虚拟行的总数 547abe3a6eaShanjiezhou /// -chars_num 每行最大的字符数 548abe3a6eaShanjiezhou 549abe3a6eaShanjiezhou pub fn new(flags: WindowFlag, vlines_num: i32, chars_num: i32) -> Self { 550abe3a6eaShanjiezhou let mut initial_vlines = Vec::new(); 551abe3a6eaShanjiezhou 552abe3a6eaShanjiezhou for _ in 0..vlines_num { 553abe3a6eaShanjiezhou let vline = TextuiVlineChromatic::new(chars_num as usize); 554abe3a6eaShanjiezhou 555abe3a6eaShanjiezhou initial_vlines.push(TextuiVline::Chromatic(vline)); 556abe3a6eaShanjiezhou } 557abe3a6eaShanjiezhou TextuiWindow { 558abe3a6eaShanjiezhou id: WindowId::new(), 559abe3a6eaShanjiezhou flags, 560abe3a6eaShanjiezhou vline_sum: vlines_num, 561abe3a6eaShanjiezhou vlines_used: 1, 562abe3a6eaShanjiezhou top_vline: LineId::new(0), 563abe3a6eaShanjiezhou vlines: initial_vlines, 564abe3a6eaShanjiezhou vline_operating: LineId::new(0), 565abe3a6eaShanjiezhou chars_per_line: chars_num, 566abe3a6eaShanjiezhou } 567abe3a6eaShanjiezhou } 568abe3a6eaShanjiezhou 569abe3a6eaShanjiezhou /// 刷新某个窗口的缓冲区的某个虚拟行的连续n个字符对象 570abe3a6eaShanjiezhou /// ## 参数 571abe3a6eaShanjiezhou /// - window 窗口结构体 572abe3a6eaShanjiezhou /// - vline_id 要刷新的虚拟行号 573abe3a6eaShanjiezhou /// - start 起始字符号 574abe3a6eaShanjiezhou /// - count 要刷新的字符数量 575abe3a6eaShanjiezhou 576abe3a6eaShanjiezhou fn textui_refresh_characters( 577abe3a6eaShanjiezhou &mut self, 578abe3a6eaShanjiezhou vline_id: LineId, 579abe3a6eaShanjiezhou start: LineIndex, 580abe3a6eaShanjiezhou count: i32, 581abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 582abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 583abe3a6eaShanjiezhou 584abe3a6eaShanjiezhou // 判断虚拟行参数是否合法 585abe3a6eaShanjiezhou if unlikely( 586abe3a6eaShanjiezhou !vline_id.check(self.vline_sum) 587abe3a6eaShanjiezhou || (<LineIndex as Into<i32>>::into(start) + count) > self.chars_per_line, 588abe3a6eaShanjiezhou ) { 589abe3a6eaShanjiezhou return Err(SystemError::EINVAL); 590abe3a6eaShanjiezhou } 591abe3a6eaShanjiezhou // 计算虚拟行对应的真实行(即要渲染的行) 592abe3a6eaShanjiezhou let mut actual_line_id = vline_id - self.top_vline; //为正说明虚拟行不在真实行显示的区域上面 593abe3a6eaShanjiezhou 594abe3a6eaShanjiezhou if <LineId as Into<i32>>::into(actual_line_id) < 0 { 595abe3a6eaShanjiezhou //真实行数小于虚拟行数,则需要加上真实行数的位置,以便正确计算真实行 596abe3a6eaShanjiezhou actual_line_id = actual_line_id + actual_line_sum; 597abe3a6eaShanjiezhou } 598abe3a6eaShanjiezhou 599abe3a6eaShanjiezhou // 将此窗口的某个虚拟行的连续n个字符对象往缓存区写入 600abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 601abe3a6eaShanjiezhou let vline = &mut self.vlines[<LineId as Into<usize>>::into(vline_id)]; 602abe3a6eaShanjiezhou let mut i = 0; 603abe3a6eaShanjiezhou let mut index = start; 604abe3a6eaShanjiezhou 605abe3a6eaShanjiezhou while i < count { 606abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = vline { 607abe3a6eaShanjiezhou vline.chars[<LineIndex as Into<usize>>::into(index)] 608abe3a6eaShanjiezhou .textui_refresh_character(actual_line_id, index)?; 609abe3a6eaShanjiezhou 610abe3a6eaShanjiezhou index = index + 1; 611abe3a6eaShanjiezhou } 612abe3a6eaShanjiezhou i += 1; 613abe3a6eaShanjiezhou } 614abe3a6eaShanjiezhou } 615abe3a6eaShanjiezhou 616abe3a6eaShanjiezhou return Ok(()); 617abe3a6eaShanjiezhou } 618abe3a6eaShanjiezhou 619abe3a6eaShanjiezhou /// 重新渲染某个窗口的某个虚拟行 620abe3a6eaShanjiezhou /// ## 参数 621abe3a6eaShanjiezhou 622abe3a6eaShanjiezhou /// - window 窗口结构体 623abe3a6eaShanjiezhou /// - vline_id 虚拟行号 624abe3a6eaShanjiezhou 625abe3a6eaShanjiezhou fn textui_refresh_vline(&mut self, vline_id: LineId) -> Result<(), SystemError> { 626abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 627abe3a6eaShanjiezhou return self.textui_refresh_characters( 628abe3a6eaShanjiezhou vline_id, 629abe3a6eaShanjiezhou LineIndex::new(0), 630abe3a6eaShanjiezhou self.chars_per_line, 631abe3a6eaShanjiezhou ); 632abe3a6eaShanjiezhou } else { 633abe3a6eaShanjiezhou //todo支持纯文本字符() 634abe3a6eaShanjiezhou todo!(); 635abe3a6eaShanjiezhou } 636abe3a6eaShanjiezhou } 637abe3a6eaShanjiezhou 638abe3a6eaShanjiezhou // 刷新某个窗口的start 到start + count行(即将这些行输入到缓冲区) 639abe3a6eaShanjiezhou fn textui_refresh_vlines(&mut self, start: LineId, count: i32) -> Result<i32, SystemError> { 640abe3a6eaShanjiezhou let mut refresh_count = count; 641abe3a6eaShanjiezhou for i in <LineId as Into<i32>>::into(start) 642abe3a6eaShanjiezhou ..(self.vline_sum).min(<LineId as Into<i32>>::into(start) + count) 643abe3a6eaShanjiezhou { 644abe3a6eaShanjiezhou self.textui_refresh_vline(LineId::new(i))?; 645abe3a6eaShanjiezhou refresh_count -= 1; 646abe3a6eaShanjiezhou } 647abe3a6eaShanjiezhou //因为虚拟行是循环表 648abe3a6eaShanjiezhou let mut refresh_start = 0; 649abe3a6eaShanjiezhou while refresh_count > 0 { 650abe3a6eaShanjiezhou self.textui_refresh_vline(LineId::new(refresh_start))?; 651abe3a6eaShanjiezhou refresh_start += 1; 652abe3a6eaShanjiezhou refresh_count -= 1; 653abe3a6eaShanjiezhou } 654abe3a6eaShanjiezhou return Ok(0); 655abe3a6eaShanjiezhou } 656abe3a6eaShanjiezhou 657abe3a6eaShanjiezhou /// 往某个窗口的缓冲区的某个虚拟行插入换行 658abe3a6eaShanjiezhou /// ## 参数 659abe3a6eaShanjiezhou /// - window 窗口结构体 660abe3a6eaShanjiezhou /// - vline_id 虚拟行号 661abe3a6eaShanjiezhou 662abe3a6eaShanjiezhou fn textui_new_line(&mut self) -> Result<i32, SystemError> { 663abe3a6eaShanjiezhou // todo: 支持在两个虚拟行之间插入一个新行 664abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 665abe3a6eaShanjiezhou self.vline_operating = self.vline_operating + 1; 666abe3a6eaShanjiezhou //如果已经到了最大行数,则重新从0开始 667abe3a6eaShanjiezhou if !self.vline_operating.check(self.vline_sum) { 668abe3a6eaShanjiezhou self.vline_operating = LineId::new(0); 669abe3a6eaShanjiezhou } 670abe3a6eaShanjiezhou 671abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 672abe3a6eaShanjiezhou &mut (self.vlines[<LineId as Into<usize>>::into(self.vline_operating)]) 673abe3a6eaShanjiezhou { 674abe3a6eaShanjiezhou for i in 0..self.chars_per_line { 675abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(i as usize) { 676abe3a6eaShanjiezhou v_char.c = None; 677abe3a6eaShanjiezhou v_char.frcolor = FontColor::BLACK; 678abe3a6eaShanjiezhou v_char.bkcolor = FontColor::BLACK; 679abe3a6eaShanjiezhou } 680abe3a6eaShanjiezhou } 681abe3a6eaShanjiezhou vline.index = LineIndex::new(0); 682abe3a6eaShanjiezhou } 683abe3a6eaShanjiezhou // 当已经使用的虚拟行总数等于真实行总数时,说明窗口中已经显示的文本行数已经达到了窗口的最大容量。这时,如果继续在窗口中添加新的文本,就会导致文本溢出窗口而无法显示。因此,需要往下滚动屏幕来显示更多的文本。 684abe3a6eaShanjiezhou 685abe3a6eaShanjiezhou if self.vlines_used == actual_line_sum { 686abe3a6eaShanjiezhou self.top_vline = self.top_vline + 1; 687abe3a6eaShanjiezhou 688abe3a6eaShanjiezhou if !self.top_vline.check(self.vline_sum) { 689abe3a6eaShanjiezhou self.top_vline = LineId::new(0); 690abe3a6eaShanjiezhou } 691abe3a6eaShanjiezhou 692abe3a6eaShanjiezhou // 刷新所有行 693abe3a6eaShanjiezhou self.textui_refresh_vlines(self.top_vline, actual_line_sum)?; 694abe3a6eaShanjiezhou } else { 695abe3a6eaShanjiezhou //换行说明上一行已经在缓冲区中,所以已经使用的虚拟行总数+1 696abe3a6eaShanjiezhou self.vlines_used += 1; 697abe3a6eaShanjiezhou } 698abe3a6eaShanjiezhou 699abe3a6eaShanjiezhou return Ok(0); 700abe3a6eaShanjiezhou } 701abe3a6eaShanjiezhou 702abe3a6eaShanjiezhou /// 真正向窗口的缓冲区上输入字符的函数(位置为window.vline_operating,window.vline_operating.index) 703abe3a6eaShanjiezhou /// ## 参数 704abe3a6eaShanjiezhou /// - window 705abe3a6eaShanjiezhou /// - character 706abe3a6eaShanjiezhou 707abe3a6eaShanjiezhou fn true_textui_putchar_window( 708abe3a6eaShanjiezhou &mut self, 709abe3a6eaShanjiezhou character: char, 710abe3a6eaShanjiezhou frcolor: FontColor, 711abe3a6eaShanjiezhou bkcolor: FontColor, 712abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 713abe3a6eaShanjiezhou // 启用彩色字符 714abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 715abe3a6eaShanjiezhou let mut line_index = LineIndex::new(0); //操作的列号 716abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 717abe3a6eaShanjiezhou &mut (self.vlines[<LineId as Into<usize>>::into(self.vline_operating)]) 718abe3a6eaShanjiezhou { 719abe3a6eaShanjiezhou let index = <LineIndex as Into<usize>>::into(vline.index); 720abe3a6eaShanjiezhou 721abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(index) { 722abe3a6eaShanjiezhou v_char.c = Some(character); 723abe3a6eaShanjiezhou v_char.frcolor = frcolor; 724abe3a6eaShanjiezhou v_char.bkcolor = bkcolor; 725abe3a6eaShanjiezhou } 726abe3a6eaShanjiezhou line_index = vline.index; 727abe3a6eaShanjiezhou vline.index = vline.index + 1; 728abe3a6eaShanjiezhou } 729abe3a6eaShanjiezhou 730abe3a6eaShanjiezhou self.textui_refresh_characters(self.vline_operating, line_index, 1)?; 731abe3a6eaShanjiezhou 732abe3a6eaShanjiezhou // 加入光标后,因为会识别光标,所以需超过该行最大字符数才能创建新行 733abe3a6eaShanjiezhou if !line_index.check(self.chars_per_line - 1) { 734abe3a6eaShanjiezhou self.textui_new_line()?; 735abe3a6eaShanjiezhou } 736abe3a6eaShanjiezhou } else { 737abe3a6eaShanjiezhou // todo: 支持纯文本字符 738abe3a6eaShanjiezhou todo!(); 739abe3a6eaShanjiezhou } 740abe3a6eaShanjiezhou return Ok(()); 741abe3a6eaShanjiezhou } 742abe3a6eaShanjiezhou /// 根据输入的一个字符在窗口上输出 743abe3a6eaShanjiezhou /// ## 参数 744abe3a6eaShanjiezhou 745abe3a6eaShanjiezhou /// - window 窗口 746abe3a6eaShanjiezhou /// - character 字符 747abe3a6eaShanjiezhou /// - FRcolor 前景色(RGB) 748abe3a6eaShanjiezhou /// - BKcolor 背景色(RGB) 749abe3a6eaShanjiezhou 750abe3a6eaShanjiezhou fn textui_putchar_window( 751abe3a6eaShanjiezhou &mut self, 752abe3a6eaShanjiezhou character: char, 753abe3a6eaShanjiezhou frcolor: FontColor, 754abe3a6eaShanjiezhou bkcolor: FontColor, 755abe3a6eaShanjiezhou is_enable_window: bool, 756abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 757abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 758abe3a6eaShanjiezhou 759abe3a6eaShanjiezhou //字符'\0'代表ASCII码表中的空字符,表示字符串的结尾 760abe3a6eaShanjiezhou if unlikely(character == '\0') { 761abe3a6eaShanjiezhou return Ok(()); 762abe3a6eaShanjiezhou } 763abe3a6eaShanjiezhou 764abe3a6eaShanjiezhou if unlikely(character == '\r') { 765abe3a6eaShanjiezhou return Ok(()); 766abe3a6eaShanjiezhou } 767abe3a6eaShanjiezhou 768abe3a6eaShanjiezhou // 暂不支持纯文本窗口 769abe3a6eaShanjiezhou if !self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 770abe3a6eaShanjiezhou return Ok(()); 771abe3a6eaShanjiezhou } 772a0c98cd4SJomo send_to_default_serial8250_port(&[character as u8]); 773abe3a6eaShanjiezhou 774abe3a6eaShanjiezhou //进行换行操作 775abe3a6eaShanjiezhou if character == '\n' { 776abe3a6eaShanjiezhou // 换行时还需要输出\r 777a03c4f9dSLoGin send_to_default_serial8250_port(&[b'\r']); 778*b5b571e0SLoGin if is_enable_window { 779abe3a6eaShanjiezhou self.textui_new_line()?; 780abe3a6eaShanjiezhou } 781abe3a6eaShanjiezhou return Ok(()); 782abe3a6eaShanjiezhou } 783abe3a6eaShanjiezhou // 输出制表符 784abe3a6eaShanjiezhou else if character == '\t' { 785*b5b571e0SLoGin if is_enable_window { 786abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 787abe3a6eaShanjiezhou &self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 788abe3a6eaShanjiezhou { 789abe3a6eaShanjiezhou //打印的空格数(注意将每行分成一个个表格,每个表格为8个字符) 790abe3a6eaShanjiezhou let mut space_to_print = 8 - <LineIndex as Into<usize>>::into(vline.index) % 8; 791abe3a6eaShanjiezhou while space_to_print > 0 { 792abe3a6eaShanjiezhou self.true_textui_putchar_window(' ', frcolor, bkcolor)?; 793abe3a6eaShanjiezhou space_to_print -= 1; 794abe3a6eaShanjiezhou } 795abe3a6eaShanjiezhou } 796abe3a6eaShanjiezhou } 797abe3a6eaShanjiezhou } 798abe3a6eaShanjiezhou // 字符 '\x08' 代表 ASCII 码中的退格字符。它在输出中的作用是将光标向左移动一个位置,并在该位置上输出后续的字符,从而实现字符的删除或替换。 799abe3a6eaShanjiezhou else if character == '\x08' { 800*b5b571e0SLoGin if is_enable_window { 801abe3a6eaShanjiezhou let mut tmp = LineIndex(0); 802abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 803abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 804abe3a6eaShanjiezhou { 805abe3a6eaShanjiezhou vline.index = vline.index - 1; 806abe3a6eaShanjiezhou tmp = vline.index; 807abe3a6eaShanjiezhou } 808abe3a6eaShanjiezhou if <LineIndex as Into<i32>>::into(tmp) >= 0 { 809abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 810abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 811abe3a6eaShanjiezhou { 812abe3a6eaShanjiezhou if let Some(v_char) = 813abe3a6eaShanjiezhou vline.chars.get_mut(<LineIndex as Into<usize>>::into(tmp)) 814abe3a6eaShanjiezhou { 815abe3a6eaShanjiezhou v_char.c = Some(' '); 816abe3a6eaShanjiezhou 817abe3a6eaShanjiezhou v_char.bkcolor = bkcolor; 818abe3a6eaShanjiezhou } 819abe3a6eaShanjiezhou } 820abe3a6eaShanjiezhou return self.textui_refresh_characters(self.vline_operating, tmp, 1); 821abe3a6eaShanjiezhou } 822abe3a6eaShanjiezhou // 需要向上缩一行 823abe3a6eaShanjiezhou if <LineIndex as Into<i32>>::into(tmp) < 0 { 824abe3a6eaShanjiezhou // 当前行为空,需要重新刷新 825abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 826abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 827abe3a6eaShanjiezhou { 828abe3a6eaShanjiezhou vline.index = LineIndex::new(0); 829abe3a6eaShanjiezhou for i in 0..self.chars_per_line { 830abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(i as usize) { 831abe3a6eaShanjiezhou v_char.c = None; 832abe3a6eaShanjiezhou v_char.frcolor = FontColor::BLACK; 833abe3a6eaShanjiezhou v_char.bkcolor = FontColor::BLACK; 834abe3a6eaShanjiezhou } 835abe3a6eaShanjiezhou } 836abe3a6eaShanjiezhou } 837abe3a6eaShanjiezhou // 上缩一行 838abe3a6eaShanjiezhou self.vline_operating = self.vline_operating - 1; 839abe3a6eaShanjiezhou if self.vline_operating.data() < 0 { 840abe3a6eaShanjiezhou self.vline_operating = LineId(self.vline_sum - 1); 841abe3a6eaShanjiezhou } 842abe3a6eaShanjiezhou 843abe3a6eaShanjiezhou // 考虑是否向上滚动(在top_vline上退格) 844abe3a6eaShanjiezhou if self.vlines_used > actual_line_sum { 845abe3a6eaShanjiezhou self.top_vline = self.top_vline - 1; 846abe3a6eaShanjiezhou if <LineId as Into<i32>>::into(self.top_vline) < 0 { 847abe3a6eaShanjiezhou self.top_vline = LineId(self.vline_sum - 1); 848abe3a6eaShanjiezhou } 849abe3a6eaShanjiezhou } 850abe3a6eaShanjiezhou //因为上缩一行所以显示在屏幕中的虚拟行少一 851abe3a6eaShanjiezhou self.vlines_used -= 1; 852abe3a6eaShanjiezhou self.textui_refresh_vlines(self.top_vline, actual_line_sum)?; 853abe3a6eaShanjiezhou } 854abe3a6eaShanjiezhou } 855*b5b571e0SLoGin } else if is_enable_window { 856abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 857abe3a6eaShanjiezhou &self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 858abe3a6eaShanjiezhou { 859abe3a6eaShanjiezhou if !vline.index.check(self.chars_per_line) { 860abe3a6eaShanjiezhou self.textui_new_line()?; 861abe3a6eaShanjiezhou } 862abe3a6eaShanjiezhou 863abe3a6eaShanjiezhou return self.true_textui_putchar_window(character, frcolor, bkcolor); 864abe3a6eaShanjiezhou } 865abe3a6eaShanjiezhou } 866abe3a6eaShanjiezhou 867abe3a6eaShanjiezhou return Ok(()); 868abe3a6eaShanjiezhou } 869abe3a6eaShanjiezhou } 870abe3a6eaShanjiezhou impl Default for TextuiWindow { 871abe3a6eaShanjiezhou fn default() -> Self { 872abe3a6eaShanjiezhou TextuiWindow { 873abe3a6eaShanjiezhou id: WindowId(0), 874abe3a6eaShanjiezhou flags: WindowFlag::TEXTUI_CHROMATIC, 875abe3a6eaShanjiezhou vline_sum: 0, 876abe3a6eaShanjiezhou vlines_used: 1, 877abe3a6eaShanjiezhou top_vline: LineId::new(0), 878abe3a6eaShanjiezhou vlines: Vec::new(), 879abe3a6eaShanjiezhou vline_operating: LineId::new(0), 880abe3a6eaShanjiezhou chars_per_line: 0, 881abe3a6eaShanjiezhou } 882abe3a6eaShanjiezhou } 883abe3a6eaShanjiezhou } 884abe3a6eaShanjiezhou #[allow(dead_code)] 885abe3a6eaShanjiezhou #[derive(Debug)] 886abe3a6eaShanjiezhou pub struct TextUiFramework { 8871496ba7bSLoGin metadata: RwLock<ScmUiFrameworkMetadata>, 888abe3a6eaShanjiezhou window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>>, 889abe3a6eaShanjiezhou actual_line: AtomicI32, // 真实行的数量(textui的帧缓冲区能容纳的内容的行数) 890abe3a6eaShanjiezhou current_window: Arc<SpinLock<TextuiWindow>>, // 当前的主窗口 891abe3a6eaShanjiezhou default_window: Arc<SpinLock<TextuiWindow>>, // 默认print到的窗口 892abe3a6eaShanjiezhou } 893abe3a6eaShanjiezhou 894abe3a6eaShanjiezhou impl TextUiFramework { 895abe3a6eaShanjiezhou pub fn new( 896abe3a6eaShanjiezhou metadata: ScmUiFrameworkMetadata, 897abe3a6eaShanjiezhou window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>>, 898abe3a6eaShanjiezhou current_window: Arc<SpinLock<TextuiWindow>>, 899abe3a6eaShanjiezhou default_window: Arc<SpinLock<TextuiWindow>>, 900abe3a6eaShanjiezhou ) -> Self { 901abe3a6eaShanjiezhou let actual_line = 902*b5b571e0SLoGin AtomicI32::new((metadata.buf_info().height() / TEXTUI_CHAR_HEIGHT) as i32); 903abe3a6eaShanjiezhou let inner = TextUiFramework { 9041496ba7bSLoGin metadata: RwLock::new(metadata), 905abe3a6eaShanjiezhou window_list, 906abe3a6eaShanjiezhou actual_line, 907abe3a6eaShanjiezhou current_window, 908abe3a6eaShanjiezhou default_window, 909abe3a6eaShanjiezhou }; 910abe3a6eaShanjiezhou return inner; 911abe3a6eaShanjiezhou } 912abe3a6eaShanjiezhou } 913abe3a6eaShanjiezhou 9141496ba7bSLoGin impl ScmUiFramework for TextUiFramework { 915abe3a6eaShanjiezhou // 安装ui框架的回调函数 916abe3a6eaShanjiezhou fn install(&self) -> Result<i32, SystemError> { 917a03c4f9dSLoGin send_to_default_serial8250_port("\ntextui_install_handler\n\0".as_bytes()); 918abe3a6eaShanjiezhou return Ok(0); 919abe3a6eaShanjiezhou } 920abe3a6eaShanjiezhou // 卸载ui框架的回调函数 921abe3a6eaShanjiezhou fn uninstall(&self) -> Result<i32, SystemError> { 922abe3a6eaShanjiezhou return Ok(0); 923abe3a6eaShanjiezhou } 924abe3a6eaShanjiezhou // 启用ui框架的回调函数 925abe3a6eaShanjiezhou fn enable(&self) -> Result<i32, SystemError> { 9261a72a751SLoGin textui_enable_put_to_window(); 927abe3a6eaShanjiezhou return Ok(0); 928abe3a6eaShanjiezhou } 929abe3a6eaShanjiezhou // 禁用ui框架的回调函数 930abe3a6eaShanjiezhou fn disable(&self) -> Result<i32, SystemError> { 9311a72a751SLoGin textui_disable_put_to_window(); 932abe3a6eaShanjiezhou 933abe3a6eaShanjiezhou return Ok(0); 934abe3a6eaShanjiezhou } 935abe3a6eaShanjiezhou // 改变ui框架的帧缓冲区的回调函数 936abe3a6eaShanjiezhou fn change(&self, buf_info: ScmBufferInfo) -> Result<i32, SystemError> { 9371496ba7bSLoGin let old_buf = textui_framework().metadata.read().buf_info(); 9381496ba7bSLoGin 9391496ba7bSLoGin textui_framework().metadata.write().set_buf_info(buf_info); 9401496ba7bSLoGin 9411496ba7bSLoGin let mut new_buf = textui_framework().metadata.read().buf_info(); 9421496ba7bSLoGin 9431496ba7bSLoGin new_buf.copy_from_nonoverlapping(&old_buf); 9441496ba7bSLoGin kdebug!("textui change buf_info: old: {:?}", old_buf); 9451496ba7bSLoGin kdebug!("textui change buf_info: new: {:?}", new_buf); 9461496ba7bSLoGin 947abe3a6eaShanjiezhou return Ok(0); 948abe3a6eaShanjiezhou } 949abe3a6eaShanjiezhou /// 获取ScmUiFramework的元数据 950abe3a6eaShanjiezhou /// ## 返回值 951abe3a6eaShanjiezhou /// 952abe3a6eaShanjiezhou /// -成功:Ok(ScmUiFramework的元数据) 953abe3a6eaShanjiezhou /// -失败:Err(错误码) 954abe3a6eaShanjiezhou fn metadata(&self) -> Result<ScmUiFrameworkMetadata, SystemError> { 9551496ba7bSLoGin let metadata = self.metadata.read().clone(); 956abe3a6eaShanjiezhou 957abe3a6eaShanjiezhou return Ok(metadata); 958abe3a6eaShanjiezhou } 959abe3a6eaShanjiezhou } 960abe3a6eaShanjiezhou 961abe3a6eaShanjiezhou /// Mapping from characters to glyph indices. 962abe3a6eaShanjiezhou pub trait GlyphMapping: Sync { 963abe3a6eaShanjiezhou /// Maps a character to a glyph index. 964abe3a6eaShanjiezhou /// 965abe3a6eaShanjiezhou /// If `c` isn't included in the font the index of a suitable replacement glyph is returned. 966abe3a6eaShanjiezhou fn index(&self, c: char) -> usize; 967abe3a6eaShanjiezhou } 968abe3a6eaShanjiezhou 969abe3a6eaShanjiezhou impl<F> GlyphMapping for F 970abe3a6eaShanjiezhou where 971abe3a6eaShanjiezhou F: Sync + Fn(char) -> usize, 972abe3a6eaShanjiezhou { 973abe3a6eaShanjiezhou fn index(&self, c: char) -> usize { 974abe3a6eaShanjiezhou self(c) 975abe3a6eaShanjiezhou } 976abe3a6eaShanjiezhou } 977abe3a6eaShanjiezhou 978abe3a6eaShanjiezhou /// 在默认窗口上输出一个字符 979abe3a6eaShanjiezhou /// ## 参数 980abe3a6eaShanjiezhou /// - character 字符 981abe3a6eaShanjiezhou /// - FRcolor 前景色(RGB) 982abe3a6eaShanjiezhou /// - BKcolor 背景色(RGB) 983abe3a6eaShanjiezhou 984abe3a6eaShanjiezhou #[no_mangle] 985abe3a6eaShanjiezhou pub extern "C" fn rs_textui_putchar(character: u8, fr_color: u32, bk_color: u32) -> i32 { 98652da9a59SGnoCiYeH let current_vcnum = CURRENT_VCNUM.load(Ordering::SeqCst); 98752da9a59SGnoCiYeH if current_vcnum != -1 { 98852da9a59SGnoCiYeH // tty已经初始化了之后才输出到屏幕 98952da9a59SGnoCiYeH let fr = (fr_color & 0x00ff0000) >> 16; 99052da9a59SGnoCiYeH let fg = (fr_color & 0x0000ff00) >> 8; 99152da9a59SGnoCiYeH let fb = fr_color & 0x000000ff; 99252da9a59SGnoCiYeH let br = (bk_color & 0x00ff0000) >> 16; 99352da9a59SGnoCiYeH let bg = (bk_color & 0x0000ff00) >> 8; 99452da9a59SGnoCiYeH let bb = bk_color & 0x000000ff; 99552da9a59SGnoCiYeH let buf = format!( 99652da9a59SGnoCiYeH "\x1B[38;2;{fr};{fg};{fb};48;2;{br};{bg};{bb}m{}\x1B[0m", 99752da9a59SGnoCiYeH character as char 99852da9a59SGnoCiYeH ); 99952da9a59SGnoCiYeH let port = TTY_PORTS[current_vcnum as usize].clone(); 100052da9a59SGnoCiYeH let tty = port.port_data().tty(); 1001*b5b571e0SLoGin if let Some(tty) = tty { 1002f3b05a97SGnoCiYeH send_to_default_serial8250_port(&[character]); 100352da9a59SGnoCiYeH return tty 1004f3b05a97SGnoCiYeH .write_without_serial(buf.as_bytes(), buf.len()) 100552da9a59SGnoCiYeH .map(|_| 0) 100652da9a59SGnoCiYeH .unwrap_or_else(|e| e.to_posix_errno()); 100752da9a59SGnoCiYeH } 100852da9a59SGnoCiYeH } 1009abe3a6eaShanjiezhou return textui_putchar( 1010abe3a6eaShanjiezhou character as char, 1011abe3a6eaShanjiezhou FontColor::from(fr_color), 1012abe3a6eaShanjiezhou FontColor::from(bk_color), 1013abe3a6eaShanjiezhou ) 1014abe3a6eaShanjiezhou .map(|_| 0) 1015abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 1016abe3a6eaShanjiezhou } 1017abe3a6eaShanjiezhou 1018abe3a6eaShanjiezhou pub fn textui_putchar( 1019abe3a6eaShanjiezhou character: char, 1020abe3a6eaShanjiezhou fr_color: FontColor, 1021abe3a6eaShanjiezhou bk_color: FontColor, 1022abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 1023abe3a6eaShanjiezhou if unsafe { TEXTUI_IS_INIT } { 1024abe3a6eaShanjiezhou return textui_framework() 1025abe3a6eaShanjiezhou .current_window 1026e2841179SLoGin .lock_irqsave() 1027abe3a6eaShanjiezhou .textui_putchar_window( 1028abe3a6eaShanjiezhou character, 1029abe3a6eaShanjiezhou fr_color, 1030abe3a6eaShanjiezhou bk_color, 10311a72a751SLoGin textui_is_enable_put_to_window(), 1032abe3a6eaShanjiezhou ); 1033abe3a6eaShanjiezhou } else { 1034abe3a6eaShanjiezhou //未初始化暴力输出 1035abe3a6eaShanjiezhou return no_init_textui_putchar_window( 1036abe3a6eaShanjiezhou character, 1037abe3a6eaShanjiezhou fr_color, 1038abe3a6eaShanjiezhou bk_color, 10391a72a751SLoGin textui_is_enable_put_to_window(), 1040abe3a6eaShanjiezhou ); 1041abe3a6eaShanjiezhou } 1042abe3a6eaShanjiezhou } 1043abe3a6eaShanjiezhou 1044fbe6becdSLoGin /// 向默认窗口输出一个字符串 1045fbe6becdSLoGin pub fn textui_putstr( 1046fbe6becdSLoGin string: &str, 1047fbe6becdSLoGin fr_color: FontColor, 1048fbe6becdSLoGin bk_color: FontColor, 1049fbe6becdSLoGin ) -> Result<(), SystemError> { 1050fbe6becdSLoGin let window = if unsafe { TEXTUI_IS_INIT } { 1051fbe6becdSLoGin let fw = textui_framework(); 1052fbe6becdSLoGin let w = fw.current_window.clone(); 1053fbe6becdSLoGin Some(w) 1054fbe6becdSLoGin } else { 1055fbe6becdSLoGin None 1056fbe6becdSLoGin }; 1057fbe6becdSLoGin 1058e2841179SLoGin let mut guard = window.as_ref().map(|w| w.lock_irqsave()); 1059fbe6becdSLoGin 1060fbe6becdSLoGin for character in string.chars() { 1061fbe6becdSLoGin if unsafe { TEXTUI_IS_INIT } { 1062fbe6becdSLoGin guard.as_mut().unwrap().textui_putchar_window( 1063fbe6becdSLoGin character, 1064fbe6becdSLoGin fr_color, 1065fbe6becdSLoGin bk_color, 10661a72a751SLoGin textui_is_enable_put_to_window(), 1067fbe6becdSLoGin )?; 1068fbe6becdSLoGin } else { 1069fbe6becdSLoGin no_init_textui_putchar_window( 1070fbe6becdSLoGin character, 1071fbe6becdSLoGin fr_color, 1072fbe6becdSLoGin bk_color, 10731a72a751SLoGin textui_is_enable_put_to_window(), 1074fbe6becdSLoGin )?; 1075fbe6becdSLoGin } 1076fbe6becdSLoGin } 1077fbe6becdSLoGin 1078fbe6becdSLoGin return Ok(()); 1079fbe6becdSLoGin } 1080fbe6becdSLoGin 1081abe3a6eaShanjiezhou /// 初始化text ui框架 10825b59005fSLoGin #[inline(never)] 10835b59005fSLoGin pub fn textui_init() -> Result<i32, SystemError> { 1084338f6903SLoGin #[cfg(target_arch = "x86_64")] 10855b59005fSLoGin textui_framwork_init(); 1086abe3a6eaShanjiezhou 1087abe3a6eaShanjiezhou return Ok(0); 1088abe3a6eaShanjiezhou } 1089