1abe3a6eaShanjiezhou use crate::{ 2*1496ba7bSLoGin driver::{ 3*1496ba7bSLoGin uart::uart_device::{c_uart_send, c_uart_send_str, UartPort}, 4*1496ba7bSLoGin video::video_refresh_manager, 5*1496ba7bSLoGin }, 6*1496ba7bSLoGin kdebug, kinfo, 7*1496ba7bSLoGin libs::{ 8*1496ba7bSLoGin lib_ui::font::FONT_8x16, 9*1496ba7bSLoGin rwlock::RwLock, 10*1496ba7bSLoGin spinlock::{SpinLock, SpinLockGuard}, 11*1496ba7bSLoGin }, 12abe3a6eaShanjiezhou syscall::SystemError, 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 }; 22abe3a6eaShanjiezhou 23abe3a6eaShanjiezhou use super::{ 24abe3a6eaShanjiezhou screen_manager::{ 25*1496ba7bSLoGin scm_register, ScmBuffer, ScmBufferInfo, ScmFramworkType, ScmUiFramework, 26*1496ba7bSLoGin ScmUiFrameworkMetadata, 27abe3a6eaShanjiezhou }, 28abe3a6eaShanjiezhou textui_no_alloc::no_init_textui_putchar_window, 29abe3a6eaShanjiezhou }; 30abe3a6eaShanjiezhou 31abe3a6eaShanjiezhou /// 声明全局的TEXTUI_FRAMEWORK 32*1496ba7bSLoGin static mut __TEXTUI_FRAMEWORK: Option<Arc<TextUiFramework>> = None; 33abe3a6eaShanjiezhou 34abe3a6eaShanjiezhou /// 每个字符的宽度和高度(像素) 35abe3a6eaShanjiezhou pub const TEXTUI_CHAR_WIDTH: u32 = 8; 36abe3a6eaShanjiezhou 37abe3a6eaShanjiezhou pub const TEXTUI_CHAR_HEIGHT: u32 = 16; 38abe3a6eaShanjiezhou 39abe3a6eaShanjiezhou pub static mut TEXTUI_IS_INIT: bool = false; 40abe3a6eaShanjiezhou 41abe3a6eaShanjiezhou pub static ENABLE_PUT_TO_WINDOW: AtomicBool = AtomicBool::new(true); 42abe3a6eaShanjiezhou 43abe3a6eaShanjiezhou /// 获取TEXTUI_FRAMEWORK的可变实例 44*1496ba7bSLoGin pub fn textui_framework() -> Arc<TextUiFramework> { 45*1496ba7bSLoGin unsafe { 46*1496ba7bSLoGin return __TEXTUI_FRAMEWORK 47*1496ba7bSLoGin .as_ref() 48*1496ba7bSLoGin .expect("Textui framework has not been initialized yet!") 49*1496ba7bSLoGin .clone(); 50abe3a6eaShanjiezhou } 51*1496ba7bSLoGin } 52*1496ba7bSLoGin 53abe3a6eaShanjiezhou /// 初始化TEXTUI_FRAMEWORK 54abe3a6eaShanjiezhou pub unsafe fn textui_framwork_init() { 55abe3a6eaShanjiezhou if __TEXTUI_FRAMEWORK.is_none() { 56abe3a6eaShanjiezhou kinfo!("textuiframework init"); 57abe3a6eaShanjiezhou let metadata = ScmUiFrameworkMetadata::new("TextUI".to_string(), ScmFramworkType::Text); 58*1496ba7bSLoGin kdebug!("textui metadata: {:?}", metadata); 59abe3a6eaShanjiezhou // 为textui框架生成第一个窗口 60*1496ba7bSLoGin let vlines_num = (metadata.buf_info().height() / TEXTUI_CHAR_HEIGHT) as usize; 61abe3a6eaShanjiezhou 62*1496ba7bSLoGin let chars_num = (metadata.buf_info().width() / TEXTUI_CHAR_WIDTH) as usize; 63abe3a6eaShanjiezhou 64abe3a6eaShanjiezhou let initial_window = TextuiWindow::new( 65abe3a6eaShanjiezhou WindowFlag::TEXTUI_CHROMATIC, 66abe3a6eaShanjiezhou vlines_num as i32, 67abe3a6eaShanjiezhou chars_num as i32, 68abe3a6eaShanjiezhou ); 69abe3a6eaShanjiezhou 70abe3a6eaShanjiezhou let current_window: Arc<SpinLock<TextuiWindow>> = Arc::new(SpinLock::new(initial_window)); 71abe3a6eaShanjiezhou 72abe3a6eaShanjiezhou let default_window = current_window.clone(); 73abe3a6eaShanjiezhou 74abe3a6eaShanjiezhou // 生成窗口链表,并把上面窗口添加进textui框架的窗口链表中 75abe3a6eaShanjiezhou let window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>> = 76abe3a6eaShanjiezhou Arc::new(SpinLock::new(LinkedList::new())); 77abe3a6eaShanjiezhou window_list.lock().push_back(current_window.clone()); 78abe3a6eaShanjiezhou 79*1496ba7bSLoGin __TEXTUI_FRAMEWORK = Some(Arc::new(TextUiFramework::new( 80abe3a6eaShanjiezhou metadata, 81abe3a6eaShanjiezhou window_list, 82abe3a6eaShanjiezhou current_window, 83abe3a6eaShanjiezhou default_window, 84abe3a6eaShanjiezhou ))); 85*1496ba7bSLoGin 86*1496ba7bSLoGin scm_register(textui_framework()).expect("register textui framework failed"); 87*1496ba7bSLoGin kdebug!("textui framework init success"); 88*1496ba7bSLoGin 89*1496ba7bSLoGin c_uart_send_str( 90*1496ba7bSLoGin UartPort::COM1.to_u16(), 91*1496ba7bSLoGin "\ntext ui initialized\n\0".as_ptr(), 92*1496ba7bSLoGin ); 93*1496ba7bSLoGin unsafe { TEXTUI_IS_INIT = true }; 94abe3a6eaShanjiezhou } else { 95abe3a6eaShanjiezhou panic!("Try to init TEXTUI_FRAMEWORK twice!"); 96abe3a6eaShanjiezhou } 97abe3a6eaShanjiezhou } 98abe3a6eaShanjiezhou // window标志位 99abe3a6eaShanjiezhou bitflags! { 100abe3a6eaShanjiezhou pub struct WindowFlag: u8 { 101abe3a6eaShanjiezhou // 采用彩色字符 102abe3a6eaShanjiezhou const TEXTUI_CHROMATIC = 1 << 0; 103abe3a6eaShanjiezhou } 104abe3a6eaShanjiezhou } 105abe3a6eaShanjiezhou 106abe3a6eaShanjiezhou /** 107abe3a6eaShanjiezhou * @brief 黑白字符对象 108abe3a6eaShanjiezhou * 109abe3a6eaShanjiezhou */ 110abe3a6eaShanjiezhou #[derive(Clone, Debug)] 111abe3a6eaShanjiezhou struct TextuiCharNormal { 112abe3a6eaShanjiezhou _data: u8, 113abe3a6eaShanjiezhou } 114abe3a6eaShanjiezhou 115abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash, Default)] 116abe3a6eaShanjiezhou pub struct LineId(i32); 117abe3a6eaShanjiezhou impl LineId { 118abe3a6eaShanjiezhou pub fn new(num: i32) -> Self { 119abe3a6eaShanjiezhou LineId(num) 120abe3a6eaShanjiezhou } 121abe3a6eaShanjiezhou 122abe3a6eaShanjiezhou pub fn check(&self, max: i32) -> bool { 123abe3a6eaShanjiezhou self.0 < max && self.0 >= 0 124abe3a6eaShanjiezhou } 125abe3a6eaShanjiezhou 126abe3a6eaShanjiezhou pub fn data(&self) -> i32 { 127abe3a6eaShanjiezhou self.0 128abe3a6eaShanjiezhou } 129abe3a6eaShanjiezhou } 130abe3a6eaShanjiezhou impl Add<i32> for LineId { 131abe3a6eaShanjiezhou type Output = LineId; 132abe3a6eaShanjiezhou fn add(self, rhs: i32) -> Self::Output { 133abe3a6eaShanjiezhou LineId::new(self.0 + rhs) 134abe3a6eaShanjiezhou } 135abe3a6eaShanjiezhou } 136abe3a6eaShanjiezhou impl Sub<i32> for LineId { 137abe3a6eaShanjiezhou type Output = LineId; 138abe3a6eaShanjiezhou 139abe3a6eaShanjiezhou fn sub(self, rhs: i32) -> Self::Output { 140abe3a6eaShanjiezhou LineId::new(self.0 - rhs) 141abe3a6eaShanjiezhou } 142abe3a6eaShanjiezhou } 143abe3a6eaShanjiezhou 144abe3a6eaShanjiezhou impl Into<i32> for LineId { 145abe3a6eaShanjiezhou fn into(self) -> i32 { 146abe3a6eaShanjiezhou self.0.clone() 147abe3a6eaShanjiezhou } 148abe3a6eaShanjiezhou } 149abe3a6eaShanjiezhou impl Into<u32> for LineId { 150abe3a6eaShanjiezhou fn into(self) -> u32 { 151abe3a6eaShanjiezhou self.0.clone() as u32 152abe3a6eaShanjiezhou } 153abe3a6eaShanjiezhou } 154abe3a6eaShanjiezhou impl Into<usize> for LineId { 155abe3a6eaShanjiezhou fn into(self) -> usize { 156abe3a6eaShanjiezhou self.0.clone() as usize 157abe3a6eaShanjiezhou } 158abe3a6eaShanjiezhou } 159abe3a6eaShanjiezhou impl Sub<LineId> for LineId { 160abe3a6eaShanjiezhou type Output = LineId; 161abe3a6eaShanjiezhou 162abe3a6eaShanjiezhou fn sub(mut self, rhs: LineId) -> Self::Output { 163abe3a6eaShanjiezhou self.0 -= rhs.0; 164abe3a6eaShanjiezhou return self; 165abe3a6eaShanjiezhou } 166abe3a6eaShanjiezhou } 167abe3a6eaShanjiezhou impl AddAssign<LineId> for LineId { 168abe3a6eaShanjiezhou fn add_assign(&mut self, rhs: LineId) { 169abe3a6eaShanjiezhou self.0 += rhs.0; 170abe3a6eaShanjiezhou } 171abe3a6eaShanjiezhou } 172abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash, Default)] 173abe3a6eaShanjiezhou pub struct LineIndex(i32); 174abe3a6eaShanjiezhou impl LineIndex { 175abe3a6eaShanjiezhou pub fn new(num: i32) -> Self { 176abe3a6eaShanjiezhou LineIndex(num) 177abe3a6eaShanjiezhou } 178abe3a6eaShanjiezhou pub fn check(&self, chars_per_line: i32) -> bool { 179abe3a6eaShanjiezhou self.0 < chars_per_line && self.0 >= 0 180abe3a6eaShanjiezhou } 181abe3a6eaShanjiezhou } 182abe3a6eaShanjiezhou impl Add<LineIndex> for LineIndex { 183abe3a6eaShanjiezhou type Output = LineIndex; 184abe3a6eaShanjiezhou 185abe3a6eaShanjiezhou fn add(self, rhs: LineIndex) -> Self::Output { 186abe3a6eaShanjiezhou LineIndex::new(self.0 + rhs.0) 187abe3a6eaShanjiezhou } 188abe3a6eaShanjiezhou } 189abe3a6eaShanjiezhou impl Add<i32> for LineIndex { 190abe3a6eaShanjiezhou // type Output = Self; 191abe3a6eaShanjiezhou type Output = LineIndex; 192abe3a6eaShanjiezhou 193abe3a6eaShanjiezhou fn add(self, rhs: i32) -> Self::Output { 194abe3a6eaShanjiezhou LineIndex::new(self.0 + rhs) 195abe3a6eaShanjiezhou } 196abe3a6eaShanjiezhou } 197abe3a6eaShanjiezhou impl Sub<i32> for LineIndex { 198abe3a6eaShanjiezhou type Output = LineIndex; 199abe3a6eaShanjiezhou 200abe3a6eaShanjiezhou fn sub(self, rhs: i32) -> Self::Output { 201abe3a6eaShanjiezhou LineIndex::new(self.0 - rhs) 202abe3a6eaShanjiezhou } 203abe3a6eaShanjiezhou } 204abe3a6eaShanjiezhou 205abe3a6eaShanjiezhou impl Into<i32> for LineIndex { 206abe3a6eaShanjiezhou fn into(self) -> i32 { 207abe3a6eaShanjiezhou self.0.clone() 208abe3a6eaShanjiezhou } 209abe3a6eaShanjiezhou } 210abe3a6eaShanjiezhou impl Into<u32> for LineIndex { 211abe3a6eaShanjiezhou fn into(self) -> u32 { 212abe3a6eaShanjiezhou self.0.clone() as u32 213abe3a6eaShanjiezhou } 214abe3a6eaShanjiezhou } 215abe3a6eaShanjiezhou impl Into<usize> for LineIndex { 216abe3a6eaShanjiezhou fn into(self) -> usize { 217abe3a6eaShanjiezhou self.0.clone() as usize 218abe3a6eaShanjiezhou } 219abe3a6eaShanjiezhou } 220abe3a6eaShanjiezhou #[derive(Copy, Clone, Debug)] 221abe3a6eaShanjiezhou pub struct FontColor(u32); 222abe3a6eaShanjiezhou #[allow(dead_code)] 223abe3a6eaShanjiezhou impl FontColor { 224abe3a6eaShanjiezhou pub const BLUE: FontColor = FontColor::new(0, 0, 0xff); 225abe3a6eaShanjiezhou pub const RED: FontColor = FontColor::new(0xff, 0, 0); 226abe3a6eaShanjiezhou pub const GREEN: FontColor = FontColor::new(0, 0xff, 0); 227abe3a6eaShanjiezhou pub const WHITE: FontColor = FontColor::new(0xff, 0xff, 0xff); 228abe3a6eaShanjiezhou pub const BLACK: FontColor = FontColor::new(0, 0, 0); 229abe3a6eaShanjiezhou pub const YELLOW: FontColor = FontColor::new(0xff, 0xff, 0); 230abe3a6eaShanjiezhou pub const ORANGE: FontColor = FontColor::new(0xff, 0x80, 0); 231abe3a6eaShanjiezhou pub const INDIGO: FontColor = FontColor::new(0x00, 0xff, 0xff); 232abe3a6eaShanjiezhou pub const PURPLE: FontColor = FontColor::new(0x80, 0x00, 0xff); 233abe3a6eaShanjiezhou 234abe3a6eaShanjiezhou pub const fn new(r: u8, g: u8, b: u8) -> Self { 235abe3a6eaShanjiezhou let val = ((r as u32) << 16) | ((g as u32) << 8) | (b as u32); 236abe3a6eaShanjiezhou return FontColor(val & 0x00ffffff); 237abe3a6eaShanjiezhou } 238abe3a6eaShanjiezhou } 239abe3a6eaShanjiezhou 240abe3a6eaShanjiezhou impl From<u32> for FontColor { 241abe3a6eaShanjiezhou fn from(value: u32) -> Self { 242abe3a6eaShanjiezhou return Self(value & 0x00ffffff); 243abe3a6eaShanjiezhou } 244abe3a6eaShanjiezhou } 245abe3a6eaShanjiezhou impl Into<usize> for FontColor { 246abe3a6eaShanjiezhou fn into(self) -> usize { 247abe3a6eaShanjiezhou self.0.clone() as usize 248abe3a6eaShanjiezhou } 249abe3a6eaShanjiezhou } 250abe3a6eaShanjiezhou impl Into<u32> for FontColor { 251abe3a6eaShanjiezhou fn into(self) -> u32 { 252abe3a6eaShanjiezhou self.0.clone() 253abe3a6eaShanjiezhou } 254abe3a6eaShanjiezhou } 255abe3a6eaShanjiezhou impl Into<u16> for FontColor { 256abe3a6eaShanjiezhou fn into(self) -> u16 { 257abe3a6eaShanjiezhou self.0.clone() as u16 258abe3a6eaShanjiezhou } 259abe3a6eaShanjiezhou } 260abe3a6eaShanjiezhou impl Into<u64> for FontColor { 261abe3a6eaShanjiezhou fn into(self) -> u64 { 262abe3a6eaShanjiezhou self.0.clone() as u64 263abe3a6eaShanjiezhou } 264abe3a6eaShanjiezhou } 265abe3a6eaShanjiezhou 266abe3a6eaShanjiezhou /// 彩色字符对象 267abe3a6eaShanjiezhou 268abe3a6eaShanjiezhou #[derive(Clone, Debug, Copy)] 269abe3a6eaShanjiezhou pub struct TextuiCharChromatic { 270abe3a6eaShanjiezhou c: Option<char>, 271abe3a6eaShanjiezhou 272abe3a6eaShanjiezhou // 前景色 273abe3a6eaShanjiezhou frcolor: FontColor, // rgb 274abe3a6eaShanjiezhou 275abe3a6eaShanjiezhou // 背景色 276abe3a6eaShanjiezhou bkcolor: FontColor, // rgb 277abe3a6eaShanjiezhou } 278abe3a6eaShanjiezhou 279abe3a6eaShanjiezhou #[derive(Debug)] 280*1496ba7bSLoGin pub struct TextuiBuf<'a> { 281*1496ba7bSLoGin buf: Option<&'a mut [u32]>, 282*1496ba7bSLoGin guard: Option<SpinLockGuard<'a, Box<[u32]>>>, 283*1496ba7bSLoGin } 284abe3a6eaShanjiezhou 285abe3a6eaShanjiezhou impl TextuiBuf<'_> { 286*1496ba7bSLoGin pub fn new(buf: &mut ScmBufferInfo) -> TextuiBuf { 287*1496ba7bSLoGin let len = buf.buf_size() / 4; 288*1496ba7bSLoGin 289*1496ba7bSLoGin match &buf.buf { 290*1496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 291*1496ba7bSLoGin return TextuiBuf { 292*1496ba7bSLoGin buf: Some(unsafe { 293*1496ba7bSLoGin core::slice::from_raw_parts_mut(vaddr.data() as *mut u32, len) 294*1496ba7bSLoGin }), 295*1496ba7bSLoGin guard: None, 296*1496ba7bSLoGin }; 297*1496ba7bSLoGin } 298*1496ba7bSLoGin 299*1496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 300*1496ba7bSLoGin let guard: SpinLockGuard<'_, Box<[u32]>> = double_buffer.lock(); 301*1496ba7bSLoGin 302*1496ba7bSLoGin return TextuiBuf { 303*1496ba7bSLoGin buf: None, 304*1496ba7bSLoGin guard: Some(guard), 305*1496ba7bSLoGin }; 306*1496ba7bSLoGin } 307*1496ba7bSLoGin } 308*1496ba7bSLoGin } 309*1496ba7bSLoGin 310*1496ba7bSLoGin pub fn buf_mut(&mut self) -> &mut [u32] { 311*1496ba7bSLoGin if let Some(buf) = &mut self.buf { 312*1496ba7bSLoGin return buf; 313*1496ba7bSLoGin } else { 314*1496ba7bSLoGin return self.guard.as_mut().unwrap().as_mut(); 315*1496ba7bSLoGin } 316abe3a6eaShanjiezhou } 317abe3a6eaShanjiezhou pub fn put_color_in_pixel(&mut self, color: u32, index: usize) { 318*1496ba7bSLoGin let buf: &mut [u32] = self.buf_mut(); 319abe3a6eaShanjiezhou buf[index] = color; 320abe3a6eaShanjiezhou } 321abe3a6eaShanjiezhou pub fn get_index_of_next_line(now_index: usize) -> usize { 322*1496ba7bSLoGin textui_framework().metadata.read().buf_info().width() as usize + now_index 323abe3a6eaShanjiezhou } 324abe3a6eaShanjiezhou pub fn get_index_by_x_y(x: usize, y: usize) -> usize { 325*1496ba7bSLoGin textui_framework().metadata.read().buf_info().width() as usize * y + x 326abe3a6eaShanjiezhou } 327abe3a6eaShanjiezhou pub fn get_start_index_by_lineid_lineindex(lineid: LineId, lineindex: LineIndex) -> usize { 328abe3a6eaShanjiezhou // x 左上角列像素点位置 329abe3a6eaShanjiezhou // y 左上角行像素点位置 330abe3a6eaShanjiezhou let index_x: u32 = lineindex.into(); 331abe3a6eaShanjiezhou let x: u32 = index_x * TEXTUI_CHAR_WIDTH; 332abe3a6eaShanjiezhou 333abe3a6eaShanjiezhou let id_y: u32 = lineid.into(); 334abe3a6eaShanjiezhou let y: u32 = id_y * TEXTUI_CHAR_HEIGHT; 335abe3a6eaShanjiezhou 336abe3a6eaShanjiezhou TextuiBuf::get_index_by_x_y(x as usize, y as usize) 337abe3a6eaShanjiezhou } 338abe3a6eaShanjiezhou } 339abe3a6eaShanjiezhou 340abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 341abe3a6eaShanjiezhou pub struct Font([u8; 16]); 342abe3a6eaShanjiezhou impl Font { 343abe3a6eaShanjiezhou #[inline] 344abe3a6eaShanjiezhou pub fn get_font(character: char) -> Font { 345abe3a6eaShanjiezhou let x = FONT_8x16.char_map(character); 346abe3a6eaShanjiezhou 347abe3a6eaShanjiezhou let mut data = [0u8; 16]; 348abe3a6eaShanjiezhou data.copy_from_slice(x); 349abe3a6eaShanjiezhou return Font(data); 350abe3a6eaShanjiezhou } 351abe3a6eaShanjiezhou pub fn is_frcolor(&self, height: usize, width: usize) -> bool { 352abe3a6eaShanjiezhou let w = self.0[height]; 353abe3a6eaShanjiezhou let testbit = 1 << (8 - width); 354abe3a6eaShanjiezhou w & testbit != 0 355abe3a6eaShanjiezhou } 356abe3a6eaShanjiezhou } 357abe3a6eaShanjiezhou 358abe3a6eaShanjiezhou impl TextuiCharChromatic { 359abe3a6eaShanjiezhou pub fn new(c: Option<char>, frcolor: FontColor, bkcolor: FontColor) -> Self { 360abe3a6eaShanjiezhou TextuiCharChromatic { 361abe3a6eaShanjiezhou c, 362abe3a6eaShanjiezhou frcolor, 363abe3a6eaShanjiezhou bkcolor, 364abe3a6eaShanjiezhou } 365abe3a6eaShanjiezhou } 366abe3a6eaShanjiezhou 367abe3a6eaShanjiezhou /// 将该字符对象输出到缓冲区 368abe3a6eaShanjiezhou /// ## 参数 369abe3a6eaShanjiezhou /// -line_id 要放入的真实行号 370abe3a6eaShanjiezhou /// -index 要放入的真实列号 371abe3a6eaShanjiezhou pub fn textui_refresh_character( 372abe3a6eaShanjiezhou &self, 373abe3a6eaShanjiezhou lineid: LineId, 374abe3a6eaShanjiezhou lineindex: LineIndex, 375abe3a6eaShanjiezhou ) -> Result<i32, SystemError> { 376abe3a6eaShanjiezhou // 找到要渲染的字符的像素点数据 377abe3a6eaShanjiezhou 378abe3a6eaShanjiezhou let font: Font = Font::get_font(self.c.unwrap_or(' ')); 379abe3a6eaShanjiezhou 380abe3a6eaShanjiezhou let mut count = TextuiBuf::get_start_index_by_lineid_lineindex(lineid, lineindex); 381abe3a6eaShanjiezhou 382*1496ba7bSLoGin let mut _binding = textui_framework().metadata.read().buf_info(); 383*1496ba7bSLoGin 384*1496ba7bSLoGin let mut buf = TextuiBuf::new(&mut _binding); 385*1496ba7bSLoGin 386abe3a6eaShanjiezhou // 在缓冲区画出一个字体,每个字体有TEXTUI_CHAR_HEIGHT行,TEXTUI_CHAR_WIDTH列个像素点 387abe3a6eaShanjiezhou for i in 0..TEXTUI_CHAR_HEIGHT { 388abe3a6eaShanjiezhou let start = count; 389abe3a6eaShanjiezhou for j in 0..TEXTUI_CHAR_WIDTH { 390abe3a6eaShanjiezhou if font.is_frcolor(i as usize, j as usize) { 391abe3a6eaShanjiezhou // 字,显示前景色 392abe3a6eaShanjiezhou buf.put_color_in_pixel(self.frcolor.into(), count); 393abe3a6eaShanjiezhou } else { 394abe3a6eaShanjiezhou // 背景色 395abe3a6eaShanjiezhou buf.put_color_in_pixel(self.bkcolor.into(), count); 396abe3a6eaShanjiezhou } 397abe3a6eaShanjiezhou count += 1; 398abe3a6eaShanjiezhou } 399abe3a6eaShanjiezhou count = TextuiBuf::get_index_of_next_line(start); 400abe3a6eaShanjiezhou } 401abe3a6eaShanjiezhou 402abe3a6eaShanjiezhou return Ok(0); 403abe3a6eaShanjiezhou } 404abe3a6eaShanjiezhou 405abe3a6eaShanjiezhou pub fn no_init_textui_render_chromatic(&self, lineid: LineId, lineindex: LineIndex) { 406abe3a6eaShanjiezhou // 找到要渲染的字符的像素点数据 407abe3a6eaShanjiezhou let font = Font::get_font(self.c.unwrap_or(' ')); 408abe3a6eaShanjiezhou 409abe3a6eaShanjiezhou // x 左上角列像素点位置 410abe3a6eaShanjiezhou // y 左上角行像素点位置 411abe3a6eaShanjiezhou let index_x: u32 = lineindex.into(); 412abe3a6eaShanjiezhou let x: u32 = index_x * TEXTUI_CHAR_WIDTH; 413abe3a6eaShanjiezhou 414abe3a6eaShanjiezhou let id_y: u32 = lineid.into(); 415abe3a6eaShanjiezhou let y: u32 = id_y * TEXTUI_CHAR_HEIGHT; 416*1496ba7bSLoGin 417*1496ba7bSLoGin let buf_width = video_refresh_manager().device_buffer().width(); 418abe3a6eaShanjiezhou // 找到输入缓冲区的起始地址位置 419*1496ba7bSLoGin let buf_start = 420*1496ba7bSLoGin if let ScmBuffer::DeviceBuffer(vaddr) = video_refresh_manager().device_buffer().buf { 421*1496ba7bSLoGin vaddr 422*1496ba7bSLoGin } else { 423*1496ba7bSLoGin panic!("device buffer is not init"); 424*1496ba7bSLoGin }; 425abe3a6eaShanjiezhou 426abe3a6eaShanjiezhou let mut testbit: u32; // 用来测试特定行的某列是背景还是字体本身 427abe3a6eaShanjiezhou 428abe3a6eaShanjiezhou // 在缓冲区画出一个字体,每个字体有TEXTUI_CHAR_HEIGHT行,TEXTUI_CHAR_WIDTH列个像素点 429abe3a6eaShanjiezhou for i in 0..TEXTUI_CHAR_HEIGHT { 430abe3a6eaShanjiezhou // 计算出帧缓冲区每一行打印的起始位置的地址(起始位置+(y+i)*缓冲区的宽度+x) 431abe3a6eaShanjiezhou 432*1496ba7bSLoGin let mut addr: *mut u32 = 433*1496ba7bSLoGin (buf_start + buf_width as usize * 4 * (y as usize + i as usize) + 4 * x as usize) 434*1496ba7bSLoGin .data() as *mut u32; 435abe3a6eaShanjiezhou 436abe3a6eaShanjiezhou testbit = 1 << (TEXTUI_CHAR_WIDTH + 1); 437abe3a6eaShanjiezhou 438abe3a6eaShanjiezhou for _j in 0..TEXTUI_CHAR_WIDTH { 439abe3a6eaShanjiezhou //从左往右逐个测试相应位 440abe3a6eaShanjiezhou testbit >>= 1; 441abe3a6eaShanjiezhou if (font.0[i as usize] & testbit as u8) != 0 { 442abe3a6eaShanjiezhou unsafe { *addr = self.frcolor.into() }; // 字,显示前景色 443abe3a6eaShanjiezhou } else { 444abe3a6eaShanjiezhou unsafe { *addr = self.bkcolor.into() }; // 背景色 445abe3a6eaShanjiezhou } 446abe3a6eaShanjiezhou 447abe3a6eaShanjiezhou unsafe { 448abe3a6eaShanjiezhou addr = (addr.offset(1)) as *mut u32; 449abe3a6eaShanjiezhou } 450abe3a6eaShanjiezhou } 451abe3a6eaShanjiezhou } 452abe3a6eaShanjiezhou } 453abe3a6eaShanjiezhou } 454abe3a6eaShanjiezhou 455abe3a6eaShanjiezhou /// 单色显示的虚拟行结构体 456abe3a6eaShanjiezhou 457abe3a6eaShanjiezhou #[derive(Clone, Debug, Default)] 458abe3a6eaShanjiezhou pub struct TextuiVlineNormal { 459abe3a6eaShanjiezhou _characters: Vec<TextuiCharNormal>, // 字符对象数组 460abe3a6eaShanjiezhou _index: i16, // 当前操作的位置 461abe3a6eaShanjiezhou } 462abe3a6eaShanjiezhou /// 彩色显示的虚拟行结构体 463abe3a6eaShanjiezhou 464abe3a6eaShanjiezhou #[derive(Clone, Debug, Default)] 465abe3a6eaShanjiezhou pub struct TextuiVlineChromatic { 466abe3a6eaShanjiezhou chars: Vec<TextuiCharChromatic>, // 字符对象数组 467abe3a6eaShanjiezhou index: LineIndex, // 当前操作的位置 468abe3a6eaShanjiezhou } 469abe3a6eaShanjiezhou impl TextuiVlineChromatic { 470abe3a6eaShanjiezhou pub fn new(char_num: usize) -> Self { 471abe3a6eaShanjiezhou let mut r = TextuiVlineChromatic { 472abe3a6eaShanjiezhou chars: Vec::with_capacity(char_num), 473abe3a6eaShanjiezhou index: LineIndex::new(0), 474abe3a6eaShanjiezhou }; 475abe3a6eaShanjiezhou 476abe3a6eaShanjiezhou for _ in 0..char_num { 477abe3a6eaShanjiezhou r.chars.push(TextuiCharChromatic::new( 478abe3a6eaShanjiezhou None, 479abe3a6eaShanjiezhou FontColor::BLACK, 480abe3a6eaShanjiezhou FontColor::BLACK, 481abe3a6eaShanjiezhou )); 482abe3a6eaShanjiezhou } 483abe3a6eaShanjiezhou 484abe3a6eaShanjiezhou return r; 485abe3a6eaShanjiezhou } 486abe3a6eaShanjiezhou } 487abe3a6eaShanjiezhou 488abe3a6eaShanjiezhou #[derive(Clone, Debug)] 489abe3a6eaShanjiezhou pub enum TextuiVline { 490abe3a6eaShanjiezhou Chromatic(TextuiVlineChromatic), 491abe3a6eaShanjiezhou _Normal(TextuiVlineNormal), 492abe3a6eaShanjiezhou } 493abe3a6eaShanjiezhou 494abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 495abe3a6eaShanjiezhou pub struct WindowId(u32); 496abe3a6eaShanjiezhou 497abe3a6eaShanjiezhou impl WindowId { 498abe3a6eaShanjiezhou pub fn new() -> Self { 499abe3a6eaShanjiezhou static MAX_ID: AtomicU32 = AtomicU32::new(0); 500abe3a6eaShanjiezhou return WindowId(MAX_ID.fetch_add(1, Ordering::SeqCst)); 501abe3a6eaShanjiezhou } 502abe3a6eaShanjiezhou } 503abe3a6eaShanjiezhou #[allow(dead_code)] 504abe3a6eaShanjiezhou #[derive(Clone, Debug)] 505abe3a6eaShanjiezhou pub struct TextuiWindow { 506abe3a6eaShanjiezhou // 虚拟行是个循环表,头和尾相接 507abe3a6eaShanjiezhou id: WindowId, 508abe3a6eaShanjiezhou // 虚拟行总数 509abe3a6eaShanjiezhou vline_sum: i32, 510abe3a6eaShanjiezhou // 当前已经使用了的虚拟行总数(即在已经输入到缓冲区(之后显示在屏幕上)的虚拟行数量) 511abe3a6eaShanjiezhou vlines_used: i32, 512abe3a6eaShanjiezhou // 位于最顶上的那一个虚拟行的行号 513abe3a6eaShanjiezhou top_vline: LineId, 514abe3a6eaShanjiezhou // 储存虚拟行的数组 515abe3a6eaShanjiezhou vlines: Vec<TextuiVline>, 516abe3a6eaShanjiezhou // 正在操作的vline 517abe3a6eaShanjiezhou vline_operating: LineId, 518abe3a6eaShanjiezhou // 每行最大容纳的字符数 519abe3a6eaShanjiezhou chars_per_line: i32, 520abe3a6eaShanjiezhou // 窗口flag 521abe3a6eaShanjiezhou flags: WindowFlag, 522abe3a6eaShanjiezhou } 523abe3a6eaShanjiezhou 524abe3a6eaShanjiezhou impl TextuiWindow { 525abe3a6eaShanjiezhou /// 使用参数初始化window对象 526abe3a6eaShanjiezhou /// ## 参数 527abe3a6eaShanjiezhou /// 528abe3a6eaShanjiezhou /// -flags 标志位 529abe3a6eaShanjiezhou /// -vlines_num 虚拟行的总数 530abe3a6eaShanjiezhou /// -chars_num 每行最大的字符数 531abe3a6eaShanjiezhou 532abe3a6eaShanjiezhou pub fn new(flags: WindowFlag, vlines_num: i32, chars_num: i32) -> Self { 533abe3a6eaShanjiezhou let mut initial_vlines = Vec::new(); 534abe3a6eaShanjiezhou 535abe3a6eaShanjiezhou for _ in 0..vlines_num { 536abe3a6eaShanjiezhou let vline = TextuiVlineChromatic::new(chars_num as usize); 537abe3a6eaShanjiezhou 538abe3a6eaShanjiezhou initial_vlines.push(TextuiVline::Chromatic(vline)); 539abe3a6eaShanjiezhou } 540abe3a6eaShanjiezhou TextuiWindow { 541abe3a6eaShanjiezhou id: WindowId::new(), 542abe3a6eaShanjiezhou flags, 543abe3a6eaShanjiezhou vline_sum: vlines_num, 544abe3a6eaShanjiezhou vlines_used: 1, 545abe3a6eaShanjiezhou top_vline: LineId::new(0), 546abe3a6eaShanjiezhou vlines: initial_vlines, 547abe3a6eaShanjiezhou vline_operating: LineId::new(0), 548abe3a6eaShanjiezhou chars_per_line: chars_num, 549abe3a6eaShanjiezhou } 550abe3a6eaShanjiezhou } 551abe3a6eaShanjiezhou 552abe3a6eaShanjiezhou /// 刷新某个窗口的缓冲区的某个虚拟行的连续n个字符对象 553abe3a6eaShanjiezhou /// ## 参数 554abe3a6eaShanjiezhou /// - window 窗口结构体 555abe3a6eaShanjiezhou /// - vline_id 要刷新的虚拟行号 556abe3a6eaShanjiezhou /// - start 起始字符号 557abe3a6eaShanjiezhou /// - count 要刷新的字符数量 558abe3a6eaShanjiezhou 559abe3a6eaShanjiezhou fn textui_refresh_characters( 560abe3a6eaShanjiezhou &mut self, 561abe3a6eaShanjiezhou vline_id: LineId, 562abe3a6eaShanjiezhou start: LineIndex, 563abe3a6eaShanjiezhou count: i32, 564abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 565abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 566abe3a6eaShanjiezhou 567abe3a6eaShanjiezhou // 判断虚拟行参数是否合法 568abe3a6eaShanjiezhou if unlikely( 569abe3a6eaShanjiezhou !vline_id.check(self.vline_sum) 570abe3a6eaShanjiezhou || (<LineIndex as Into<i32>>::into(start) + count) > self.chars_per_line, 571abe3a6eaShanjiezhou ) { 572abe3a6eaShanjiezhou return Err(SystemError::EINVAL); 573abe3a6eaShanjiezhou } 574abe3a6eaShanjiezhou // 计算虚拟行对应的真实行(即要渲染的行) 575abe3a6eaShanjiezhou let mut actual_line_id = vline_id - self.top_vline; //为正说明虚拟行不在真实行显示的区域上面 576abe3a6eaShanjiezhou 577abe3a6eaShanjiezhou if <LineId as Into<i32>>::into(actual_line_id) < 0 { 578abe3a6eaShanjiezhou //真实行数小于虚拟行数,则需要加上真实行数的位置,以便正确计算真实行 579abe3a6eaShanjiezhou actual_line_id = actual_line_id + actual_line_sum; 580abe3a6eaShanjiezhou } 581abe3a6eaShanjiezhou 582abe3a6eaShanjiezhou // 将此窗口的某个虚拟行的连续n个字符对象往缓存区写入 583abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 584abe3a6eaShanjiezhou let vline = &mut self.vlines[<LineId as Into<usize>>::into(vline_id)]; 585abe3a6eaShanjiezhou let mut i = 0; 586abe3a6eaShanjiezhou let mut index = start; 587abe3a6eaShanjiezhou 588abe3a6eaShanjiezhou while i < count { 589abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = vline { 590abe3a6eaShanjiezhou vline.chars[<LineIndex as Into<usize>>::into(index)] 591abe3a6eaShanjiezhou .textui_refresh_character(actual_line_id, index)?; 592abe3a6eaShanjiezhou 593abe3a6eaShanjiezhou index = index + 1; 594abe3a6eaShanjiezhou } 595abe3a6eaShanjiezhou i += 1; 596abe3a6eaShanjiezhou } 597abe3a6eaShanjiezhou } 598abe3a6eaShanjiezhou 599abe3a6eaShanjiezhou return Ok(()); 600abe3a6eaShanjiezhou } 601abe3a6eaShanjiezhou 602abe3a6eaShanjiezhou /// 重新渲染某个窗口的某个虚拟行 603abe3a6eaShanjiezhou /// ## 参数 604abe3a6eaShanjiezhou 605abe3a6eaShanjiezhou /// - window 窗口结构体 606abe3a6eaShanjiezhou /// - vline_id 虚拟行号 607abe3a6eaShanjiezhou 608abe3a6eaShanjiezhou fn textui_refresh_vline(&mut self, vline_id: LineId) -> Result<(), SystemError> { 609abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 610abe3a6eaShanjiezhou return self.textui_refresh_characters( 611abe3a6eaShanjiezhou vline_id, 612abe3a6eaShanjiezhou LineIndex::new(0), 613abe3a6eaShanjiezhou self.chars_per_line, 614abe3a6eaShanjiezhou ); 615abe3a6eaShanjiezhou } else { 616abe3a6eaShanjiezhou //todo支持纯文本字符() 617abe3a6eaShanjiezhou todo!(); 618abe3a6eaShanjiezhou } 619abe3a6eaShanjiezhou } 620abe3a6eaShanjiezhou 621abe3a6eaShanjiezhou // 刷新某个窗口的start 到start + count行(即将这些行输入到缓冲区) 622abe3a6eaShanjiezhou fn textui_refresh_vlines(&mut self, start: LineId, count: i32) -> Result<i32, SystemError> { 623abe3a6eaShanjiezhou let mut refresh_count = count; 624abe3a6eaShanjiezhou for i in <LineId as Into<i32>>::into(start) 625abe3a6eaShanjiezhou ..(self.vline_sum).min(<LineId as Into<i32>>::into(start) + count) 626abe3a6eaShanjiezhou { 627abe3a6eaShanjiezhou self.textui_refresh_vline(LineId::new(i))?; 628abe3a6eaShanjiezhou refresh_count -= 1; 629abe3a6eaShanjiezhou } 630abe3a6eaShanjiezhou //因为虚拟行是循环表 631abe3a6eaShanjiezhou let mut refresh_start = 0; 632abe3a6eaShanjiezhou while refresh_count > 0 { 633abe3a6eaShanjiezhou self.textui_refresh_vline(LineId::new(refresh_start))?; 634abe3a6eaShanjiezhou refresh_start += 1; 635abe3a6eaShanjiezhou refresh_count -= 1; 636abe3a6eaShanjiezhou } 637abe3a6eaShanjiezhou return Ok(0); 638abe3a6eaShanjiezhou } 639abe3a6eaShanjiezhou 640abe3a6eaShanjiezhou /// 往某个窗口的缓冲区的某个虚拟行插入换行 641abe3a6eaShanjiezhou /// ## 参数 642abe3a6eaShanjiezhou /// - window 窗口结构体 643abe3a6eaShanjiezhou /// - vline_id 虚拟行号 644abe3a6eaShanjiezhou 645abe3a6eaShanjiezhou fn textui_new_line(&mut self) -> Result<i32, SystemError> { 646abe3a6eaShanjiezhou // todo: 支持在两个虚拟行之间插入一个新行 647abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 648abe3a6eaShanjiezhou self.vline_operating = self.vline_operating + 1; 649abe3a6eaShanjiezhou //如果已经到了最大行数,则重新从0开始 650abe3a6eaShanjiezhou if !self.vline_operating.check(self.vline_sum) { 651abe3a6eaShanjiezhou self.vline_operating = LineId::new(0); 652abe3a6eaShanjiezhou } 653abe3a6eaShanjiezhou 654abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 655abe3a6eaShanjiezhou &mut (self.vlines[<LineId as Into<usize>>::into(self.vline_operating)]) 656abe3a6eaShanjiezhou { 657abe3a6eaShanjiezhou for i in 0..self.chars_per_line { 658abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(i as usize) { 659abe3a6eaShanjiezhou v_char.c = None; 660abe3a6eaShanjiezhou v_char.frcolor = FontColor::BLACK; 661abe3a6eaShanjiezhou v_char.bkcolor = FontColor::BLACK; 662abe3a6eaShanjiezhou } 663abe3a6eaShanjiezhou } 664abe3a6eaShanjiezhou vline.index = LineIndex::new(0); 665abe3a6eaShanjiezhou } 666abe3a6eaShanjiezhou // 当已经使用的虚拟行总数等于真实行总数时,说明窗口中已经显示的文本行数已经达到了窗口的最大容量。这时,如果继续在窗口中添加新的文本,就会导致文本溢出窗口而无法显示。因此,需要往下滚动屏幕来显示更多的文本。 667abe3a6eaShanjiezhou 668abe3a6eaShanjiezhou if self.vlines_used == actual_line_sum { 669abe3a6eaShanjiezhou self.top_vline = self.top_vline + 1; 670abe3a6eaShanjiezhou 671abe3a6eaShanjiezhou if !self.top_vline.check(self.vline_sum) { 672abe3a6eaShanjiezhou self.top_vline = LineId::new(0); 673abe3a6eaShanjiezhou } 674abe3a6eaShanjiezhou 675abe3a6eaShanjiezhou // 刷新所有行 676abe3a6eaShanjiezhou self.textui_refresh_vlines(self.top_vline, actual_line_sum)?; 677abe3a6eaShanjiezhou } else { 678abe3a6eaShanjiezhou //换行说明上一行已经在缓冲区中,所以已经使用的虚拟行总数+1 679abe3a6eaShanjiezhou self.vlines_used += 1; 680abe3a6eaShanjiezhou } 681abe3a6eaShanjiezhou 682abe3a6eaShanjiezhou return Ok(0); 683abe3a6eaShanjiezhou } 684abe3a6eaShanjiezhou 685abe3a6eaShanjiezhou /// 真正向窗口的缓冲区上输入字符的函数(位置为window.vline_operating,window.vline_operating.index) 686abe3a6eaShanjiezhou /// ## 参数 687abe3a6eaShanjiezhou /// - window 688abe3a6eaShanjiezhou /// - character 689abe3a6eaShanjiezhou 690abe3a6eaShanjiezhou fn true_textui_putchar_window( 691abe3a6eaShanjiezhou &mut self, 692abe3a6eaShanjiezhou character: char, 693abe3a6eaShanjiezhou frcolor: FontColor, 694abe3a6eaShanjiezhou bkcolor: FontColor, 695abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 696abe3a6eaShanjiezhou // 启用彩色字符 697abe3a6eaShanjiezhou if self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 698abe3a6eaShanjiezhou let mut line_index = LineIndex::new(0); //操作的列号 699abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 700abe3a6eaShanjiezhou &mut (self.vlines[<LineId as Into<usize>>::into(self.vline_operating)]) 701abe3a6eaShanjiezhou { 702abe3a6eaShanjiezhou let index = <LineIndex as Into<usize>>::into(vline.index); 703abe3a6eaShanjiezhou 704abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(index) { 705abe3a6eaShanjiezhou v_char.c = Some(character); 706abe3a6eaShanjiezhou v_char.frcolor = frcolor; 707abe3a6eaShanjiezhou v_char.bkcolor = bkcolor; 708abe3a6eaShanjiezhou } 709abe3a6eaShanjiezhou line_index = vline.index; 710abe3a6eaShanjiezhou vline.index = vline.index + 1; 711abe3a6eaShanjiezhou } 712abe3a6eaShanjiezhou 713abe3a6eaShanjiezhou self.textui_refresh_characters(self.vline_operating, line_index, 1)?; 714abe3a6eaShanjiezhou 715abe3a6eaShanjiezhou // 加入光标后,因为会识别光标,所以需超过该行最大字符数才能创建新行 716abe3a6eaShanjiezhou if !line_index.check(self.chars_per_line - 1) { 717abe3a6eaShanjiezhou self.textui_new_line()?; 718abe3a6eaShanjiezhou } 719abe3a6eaShanjiezhou } else { 720abe3a6eaShanjiezhou // todo: 支持纯文本字符 721abe3a6eaShanjiezhou todo!(); 722abe3a6eaShanjiezhou } 723abe3a6eaShanjiezhou return Ok(()); 724abe3a6eaShanjiezhou } 725abe3a6eaShanjiezhou /// 根据输入的一个字符在窗口上输出 726abe3a6eaShanjiezhou /// ## 参数 727abe3a6eaShanjiezhou 728abe3a6eaShanjiezhou /// - window 窗口 729abe3a6eaShanjiezhou /// - character 字符 730abe3a6eaShanjiezhou /// - FRcolor 前景色(RGB) 731abe3a6eaShanjiezhou /// - BKcolor 背景色(RGB) 732abe3a6eaShanjiezhou 733abe3a6eaShanjiezhou fn textui_putchar_window( 734abe3a6eaShanjiezhou &mut self, 735abe3a6eaShanjiezhou character: char, 736abe3a6eaShanjiezhou frcolor: FontColor, 737abe3a6eaShanjiezhou bkcolor: FontColor, 738abe3a6eaShanjiezhou is_enable_window: bool, 739abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 740abe3a6eaShanjiezhou let actual_line_sum = textui_framework().actual_line.load(Ordering::SeqCst); 741abe3a6eaShanjiezhou 742abe3a6eaShanjiezhou //字符'\0'代表ASCII码表中的空字符,表示字符串的结尾 743abe3a6eaShanjiezhou if unlikely(character == '\0') { 744abe3a6eaShanjiezhou return Ok(()); 745abe3a6eaShanjiezhou } 746abe3a6eaShanjiezhou 747abe3a6eaShanjiezhou if unlikely(character == '\r') { 748abe3a6eaShanjiezhou return Ok(()); 749abe3a6eaShanjiezhou } 750abe3a6eaShanjiezhou 751abe3a6eaShanjiezhou // 暂不支持纯文本窗口 752abe3a6eaShanjiezhou if !self.flags.contains(WindowFlag::TEXTUI_CHROMATIC) { 753abe3a6eaShanjiezhou return Ok(()); 754abe3a6eaShanjiezhou } 755abe3a6eaShanjiezhou 756abe3a6eaShanjiezhou //进行换行操作 757abe3a6eaShanjiezhou if character == '\n' { 758abe3a6eaShanjiezhou // 换行时还需要输出\r 759abe3a6eaShanjiezhou c_uart_send(UartPort::COM1.to_u16(), b'\r'); 760abe3a6eaShanjiezhou if is_enable_window == true { 761abe3a6eaShanjiezhou self.textui_new_line()?; 762abe3a6eaShanjiezhou } 763abe3a6eaShanjiezhou return Ok(()); 764abe3a6eaShanjiezhou } 765abe3a6eaShanjiezhou // 输出制表符 766abe3a6eaShanjiezhou else if character == '\t' { 767abe3a6eaShanjiezhou if is_enable_window == true { 768abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 769abe3a6eaShanjiezhou &self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 770abe3a6eaShanjiezhou { 771abe3a6eaShanjiezhou //打印的空格数(注意将每行分成一个个表格,每个表格为8个字符) 772abe3a6eaShanjiezhou let mut space_to_print = 8 - <LineIndex as Into<usize>>::into(vline.index) % 8; 773abe3a6eaShanjiezhou while space_to_print > 0 { 774abe3a6eaShanjiezhou self.true_textui_putchar_window(' ', frcolor, bkcolor)?; 775abe3a6eaShanjiezhou space_to_print -= 1; 776abe3a6eaShanjiezhou } 777abe3a6eaShanjiezhou } 778abe3a6eaShanjiezhou } 779abe3a6eaShanjiezhou } 780abe3a6eaShanjiezhou // 字符 '\x08' 代表 ASCII 码中的退格字符。它在输出中的作用是将光标向左移动一个位置,并在该位置上输出后续的字符,从而实现字符的删除或替换。 781abe3a6eaShanjiezhou else if character == '\x08' { 782abe3a6eaShanjiezhou if is_enable_window == true { 783abe3a6eaShanjiezhou let mut tmp = LineIndex(0); 784abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 785abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 786abe3a6eaShanjiezhou { 787abe3a6eaShanjiezhou vline.index = vline.index - 1; 788abe3a6eaShanjiezhou tmp = vline.index; 789abe3a6eaShanjiezhou } 790abe3a6eaShanjiezhou if <LineIndex as Into<i32>>::into(tmp) >= 0 { 791abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 792abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 793abe3a6eaShanjiezhou { 794abe3a6eaShanjiezhou if let Some(v_char) = 795abe3a6eaShanjiezhou vline.chars.get_mut(<LineIndex as Into<usize>>::into(tmp)) 796abe3a6eaShanjiezhou { 797abe3a6eaShanjiezhou v_char.c = Some(' '); 798abe3a6eaShanjiezhou 799abe3a6eaShanjiezhou v_char.bkcolor = bkcolor; 800abe3a6eaShanjiezhou } 801abe3a6eaShanjiezhou } 802abe3a6eaShanjiezhou return self.textui_refresh_characters(self.vline_operating, tmp, 1); 803abe3a6eaShanjiezhou } 804abe3a6eaShanjiezhou // 需要向上缩一行 805abe3a6eaShanjiezhou if <LineIndex as Into<i32>>::into(tmp) < 0 { 806abe3a6eaShanjiezhou // 当前行为空,需要重新刷新 807abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 808abe3a6eaShanjiezhou &mut self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 809abe3a6eaShanjiezhou { 810abe3a6eaShanjiezhou vline.index = LineIndex::new(0); 811abe3a6eaShanjiezhou for i in 0..self.chars_per_line { 812abe3a6eaShanjiezhou if let Some(v_char) = vline.chars.get_mut(i as usize) { 813abe3a6eaShanjiezhou v_char.c = None; 814abe3a6eaShanjiezhou v_char.frcolor = FontColor::BLACK; 815abe3a6eaShanjiezhou v_char.bkcolor = FontColor::BLACK; 816abe3a6eaShanjiezhou } 817abe3a6eaShanjiezhou } 818abe3a6eaShanjiezhou } 819abe3a6eaShanjiezhou // 上缩一行 820abe3a6eaShanjiezhou self.vline_operating = self.vline_operating - 1; 821abe3a6eaShanjiezhou if self.vline_operating.data() < 0 { 822abe3a6eaShanjiezhou self.vline_operating = LineId(self.vline_sum - 1); 823abe3a6eaShanjiezhou } 824abe3a6eaShanjiezhou 825abe3a6eaShanjiezhou // 考虑是否向上滚动(在top_vline上退格) 826abe3a6eaShanjiezhou if self.vlines_used > actual_line_sum { 827abe3a6eaShanjiezhou self.top_vline = self.top_vline - 1; 828abe3a6eaShanjiezhou if <LineId as Into<i32>>::into(self.top_vline) < 0 { 829abe3a6eaShanjiezhou self.top_vline = LineId(self.vline_sum - 1); 830abe3a6eaShanjiezhou } 831abe3a6eaShanjiezhou } 832abe3a6eaShanjiezhou //因为上缩一行所以显示在屏幕中的虚拟行少一 833abe3a6eaShanjiezhou self.vlines_used -= 1; 834abe3a6eaShanjiezhou self.textui_refresh_vlines(self.top_vline, actual_line_sum)?; 835abe3a6eaShanjiezhou } 836abe3a6eaShanjiezhou } 837abe3a6eaShanjiezhou } else { 838abe3a6eaShanjiezhou // 输出其他字符 839abe3a6eaShanjiezhou 840abe3a6eaShanjiezhou c_uart_send(UartPort::COM1.to_u16(), character as u8); 841abe3a6eaShanjiezhou 842abe3a6eaShanjiezhou if is_enable_window == true { 843abe3a6eaShanjiezhou if let TextuiVline::Chromatic(vline) = 844abe3a6eaShanjiezhou &self.vlines[<LineId as Into<usize>>::into(self.vline_operating)] 845abe3a6eaShanjiezhou { 846abe3a6eaShanjiezhou if !vline.index.check(self.chars_per_line) { 847abe3a6eaShanjiezhou self.textui_new_line()?; 848abe3a6eaShanjiezhou } 849abe3a6eaShanjiezhou 850abe3a6eaShanjiezhou return self.true_textui_putchar_window(character, frcolor, bkcolor); 851abe3a6eaShanjiezhou } 852abe3a6eaShanjiezhou } 853abe3a6eaShanjiezhou } 854abe3a6eaShanjiezhou 855abe3a6eaShanjiezhou return Ok(()); 856abe3a6eaShanjiezhou } 857abe3a6eaShanjiezhou } 858abe3a6eaShanjiezhou impl Default for TextuiWindow { 859abe3a6eaShanjiezhou fn default() -> Self { 860abe3a6eaShanjiezhou TextuiWindow { 861abe3a6eaShanjiezhou id: WindowId(0), 862abe3a6eaShanjiezhou flags: WindowFlag::TEXTUI_CHROMATIC, 863abe3a6eaShanjiezhou vline_sum: 0, 864abe3a6eaShanjiezhou vlines_used: 1, 865abe3a6eaShanjiezhou top_vline: LineId::new(0), 866abe3a6eaShanjiezhou vlines: Vec::new(), 867abe3a6eaShanjiezhou vline_operating: LineId::new(0), 868abe3a6eaShanjiezhou chars_per_line: 0, 869abe3a6eaShanjiezhou } 870abe3a6eaShanjiezhou } 871abe3a6eaShanjiezhou } 872abe3a6eaShanjiezhou #[allow(dead_code)] 873abe3a6eaShanjiezhou #[derive(Debug)] 874abe3a6eaShanjiezhou pub struct TextUiFramework { 875*1496ba7bSLoGin metadata: RwLock<ScmUiFrameworkMetadata>, 876abe3a6eaShanjiezhou window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>>, 877abe3a6eaShanjiezhou actual_line: AtomicI32, // 真实行的数量(textui的帧缓冲区能容纳的内容的行数) 878abe3a6eaShanjiezhou current_window: Arc<SpinLock<TextuiWindow>>, // 当前的主窗口 879abe3a6eaShanjiezhou default_window: Arc<SpinLock<TextuiWindow>>, // 默认print到的窗口 880abe3a6eaShanjiezhou } 881abe3a6eaShanjiezhou 882abe3a6eaShanjiezhou impl TextUiFramework { 883abe3a6eaShanjiezhou pub fn new( 884abe3a6eaShanjiezhou metadata: ScmUiFrameworkMetadata, 885abe3a6eaShanjiezhou window_list: Arc<SpinLock<LinkedList<Arc<SpinLock<TextuiWindow>>>>>, 886abe3a6eaShanjiezhou current_window: Arc<SpinLock<TextuiWindow>>, 887abe3a6eaShanjiezhou default_window: Arc<SpinLock<TextuiWindow>>, 888abe3a6eaShanjiezhou ) -> Self { 889abe3a6eaShanjiezhou let actual_line = 890*1496ba7bSLoGin AtomicI32::new((&metadata.buf_info().height() / TEXTUI_CHAR_HEIGHT) as i32); 891abe3a6eaShanjiezhou let inner = TextUiFramework { 892*1496ba7bSLoGin metadata: RwLock::new(metadata), 893abe3a6eaShanjiezhou window_list, 894abe3a6eaShanjiezhou actual_line, 895abe3a6eaShanjiezhou current_window, 896abe3a6eaShanjiezhou default_window, 897abe3a6eaShanjiezhou }; 898abe3a6eaShanjiezhou return inner; 899abe3a6eaShanjiezhou } 900abe3a6eaShanjiezhou } 901abe3a6eaShanjiezhou 902*1496ba7bSLoGin impl ScmUiFramework for TextUiFramework { 903abe3a6eaShanjiezhou // 安装ui框架的回调函数 904abe3a6eaShanjiezhou fn install(&self) -> Result<i32, SystemError> { 905abe3a6eaShanjiezhou c_uart_send_str( 906abe3a6eaShanjiezhou UartPort::COM1.to_u16(), 907abe3a6eaShanjiezhou "\ntextui_install_handler\n\0".as_ptr(), 908abe3a6eaShanjiezhou ); 909abe3a6eaShanjiezhou return Ok(0); 910abe3a6eaShanjiezhou } 911abe3a6eaShanjiezhou // 卸载ui框架的回调函数 912abe3a6eaShanjiezhou fn uninstall(&self) -> Result<i32, SystemError> { 913abe3a6eaShanjiezhou return Ok(0); 914abe3a6eaShanjiezhou } 915abe3a6eaShanjiezhou // 启用ui框架的回调函数 916abe3a6eaShanjiezhou fn enable(&self) -> Result<i32, SystemError> { 917abe3a6eaShanjiezhou ENABLE_PUT_TO_WINDOW.store(true, Ordering::SeqCst); 918abe3a6eaShanjiezhou return Ok(0); 919abe3a6eaShanjiezhou } 920abe3a6eaShanjiezhou // 禁用ui框架的回调函数 921abe3a6eaShanjiezhou fn disable(&self) -> Result<i32, SystemError> { 922abe3a6eaShanjiezhou ENABLE_PUT_TO_WINDOW.store(false, Ordering::SeqCst); 923abe3a6eaShanjiezhou 924abe3a6eaShanjiezhou return Ok(0); 925abe3a6eaShanjiezhou } 926abe3a6eaShanjiezhou // 改变ui框架的帧缓冲区的回调函数 927abe3a6eaShanjiezhou fn change(&self, buf_info: ScmBufferInfo) -> Result<i32, SystemError> { 928*1496ba7bSLoGin let old_buf = textui_framework().metadata.read().buf_info(); 929*1496ba7bSLoGin 930*1496ba7bSLoGin textui_framework().metadata.write().set_buf_info(buf_info); 931*1496ba7bSLoGin 932*1496ba7bSLoGin let mut new_buf = textui_framework().metadata.read().buf_info(); 933*1496ba7bSLoGin 934*1496ba7bSLoGin new_buf.copy_from_nonoverlapping(&old_buf); 935*1496ba7bSLoGin kdebug!("textui change buf_info: old: {:?}", old_buf); 936*1496ba7bSLoGin kdebug!("textui change buf_info: new: {:?}", new_buf); 937*1496ba7bSLoGin 938abe3a6eaShanjiezhou return Ok(0); 939abe3a6eaShanjiezhou } 940abe3a6eaShanjiezhou /// 获取ScmUiFramework的元数据 941abe3a6eaShanjiezhou /// ## 返回值 942abe3a6eaShanjiezhou /// 943abe3a6eaShanjiezhou /// -成功:Ok(ScmUiFramework的元数据) 944abe3a6eaShanjiezhou /// -失败:Err(错误码) 945abe3a6eaShanjiezhou fn metadata(&self) -> Result<ScmUiFrameworkMetadata, SystemError> { 946*1496ba7bSLoGin let metadata = self.metadata.read().clone(); 947abe3a6eaShanjiezhou 948abe3a6eaShanjiezhou return Ok(metadata); 949abe3a6eaShanjiezhou } 950abe3a6eaShanjiezhou } 951abe3a6eaShanjiezhou 952abe3a6eaShanjiezhou /// Mapping from characters to glyph indices. 953abe3a6eaShanjiezhou pub trait GlyphMapping: Sync { 954abe3a6eaShanjiezhou /// Maps a character to a glyph index. 955abe3a6eaShanjiezhou /// 956abe3a6eaShanjiezhou /// If `c` isn't included in the font the index of a suitable replacement glyph is returned. 957abe3a6eaShanjiezhou fn index(&self, c: char) -> usize; 958abe3a6eaShanjiezhou } 959abe3a6eaShanjiezhou 960abe3a6eaShanjiezhou impl<F> GlyphMapping for F 961abe3a6eaShanjiezhou where 962abe3a6eaShanjiezhou F: Sync + Fn(char) -> usize, 963abe3a6eaShanjiezhou { 964abe3a6eaShanjiezhou fn index(&self, c: char) -> usize { 965abe3a6eaShanjiezhou self(c) 966abe3a6eaShanjiezhou } 967abe3a6eaShanjiezhou } 968abe3a6eaShanjiezhou 969abe3a6eaShanjiezhou /// 在默认窗口上输出一个字符 970abe3a6eaShanjiezhou /// ## 参数 971abe3a6eaShanjiezhou /// - character 字符 972abe3a6eaShanjiezhou /// - FRcolor 前景色(RGB) 973abe3a6eaShanjiezhou /// - BKcolor 背景色(RGB) 974abe3a6eaShanjiezhou 975abe3a6eaShanjiezhou #[no_mangle] 976abe3a6eaShanjiezhou pub extern "C" fn rs_textui_putchar(character: u8, fr_color: u32, bk_color: u32) -> i32 { 977abe3a6eaShanjiezhou return textui_putchar( 978abe3a6eaShanjiezhou character as char, 979abe3a6eaShanjiezhou FontColor::from(fr_color), 980abe3a6eaShanjiezhou FontColor::from(bk_color), 981abe3a6eaShanjiezhou ) 982abe3a6eaShanjiezhou .map(|_| 0) 983abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 984abe3a6eaShanjiezhou } 985abe3a6eaShanjiezhou 986abe3a6eaShanjiezhou pub fn textui_putchar( 987abe3a6eaShanjiezhou character: char, 988abe3a6eaShanjiezhou fr_color: FontColor, 989abe3a6eaShanjiezhou bk_color: FontColor, 990abe3a6eaShanjiezhou ) -> Result<(), SystemError> { 991abe3a6eaShanjiezhou if unsafe { TEXTUI_IS_INIT } { 992abe3a6eaShanjiezhou return textui_framework() 993abe3a6eaShanjiezhou .current_window 994abe3a6eaShanjiezhou .lock() 995abe3a6eaShanjiezhou .textui_putchar_window( 996abe3a6eaShanjiezhou character, 997abe3a6eaShanjiezhou fr_color, 998abe3a6eaShanjiezhou bk_color, 999abe3a6eaShanjiezhou ENABLE_PUT_TO_WINDOW.load(Ordering::SeqCst), 1000abe3a6eaShanjiezhou ); 1001abe3a6eaShanjiezhou } else { 1002abe3a6eaShanjiezhou //未初始化暴力输出 1003abe3a6eaShanjiezhou return no_init_textui_putchar_window( 1004abe3a6eaShanjiezhou character, 1005abe3a6eaShanjiezhou fr_color, 1006abe3a6eaShanjiezhou bk_color, 1007abe3a6eaShanjiezhou ENABLE_PUT_TO_WINDOW.load(Ordering::SeqCst), 1008abe3a6eaShanjiezhou ); 1009abe3a6eaShanjiezhou } 1010abe3a6eaShanjiezhou } 1011abe3a6eaShanjiezhou 1012abe3a6eaShanjiezhou /// 初始化text ui框架 1013abe3a6eaShanjiezhou 1014abe3a6eaShanjiezhou #[no_mangle] 1015abe3a6eaShanjiezhou pub extern "C" fn rs_textui_init() -> i32 { 1016abe3a6eaShanjiezhou let r = textui_init().unwrap_or_else(|e| e.to_posix_errno()); 1017abe3a6eaShanjiezhou if r.is_negative() { 1018abe3a6eaShanjiezhou c_uart_send_str(UartPort::COM1.to_u16(), "textui init failed.\n\0".as_ptr()); 1019abe3a6eaShanjiezhou } 1020abe3a6eaShanjiezhou return r; 1021abe3a6eaShanjiezhou } 1022abe3a6eaShanjiezhou 1023abe3a6eaShanjiezhou fn textui_init() -> Result<i32, SystemError> { 1024abe3a6eaShanjiezhou unsafe { textui_framwork_init() }; 1025abe3a6eaShanjiezhou 1026abe3a6eaShanjiezhou return Ok(0); 1027abe3a6eaShanjiezhou } 1028