Upload spectral-core/src/term.rs

spectral-core/src/term.rs

@@ -0,0 +1,572 @@
+use crate::ansi::Perform;
+use crate::cell::CellFlags;
+use crate::color::ANSI_COLORS;
+use crate::config::{Config, CursorStyle};
+use crate::damage::Damage;
+use crate::grid::Grid;
+
+pub struct Terminal {
+    pub grid: Grid,
+    pub config: Config,
+
+    pub cursor_style: CursorStyle,
+    pub cursor_visible: bool,
+    pub auto_wrap: bool,
+    pub insert_mode: bool,
+    pub reverse_video: bool,
+    pub origin_mode: bool,
+    pub bracketed_paste: bool,
+    pub focus_tracking: bool,
+    pub mouse_tracking: bool,
+
+    pub fg_color: u32,
+    pub bg_color: u32,
+    pub sgr_flags: CellFlags,
+
+    pub damage: Damage,
+    pub cursor_blink_phase: bool,
+    pub dirty_cursor: bool,
+}
+
+impl Terminal {
+    pub fn new(config: Config) -> Self {
+        let mut grid = Grid::new(config.cols, config.rows, config.scrollback_limit);
+        grid.clear_screen();
+        let cfg = config.clone();
+        Self {
+            grid,
+            config,
+            cursor_style: cfg.cursor_style,
+            cursor_visible: true,
+            auto_wrap: true,
+            insert_mode: false,
+            reverse_video: false,
+            origin_mode: false,
+            bracketed_paste: false,
+            focus_tracking: false,
+            mouse_tracking: false,
+            fg_color: cfg.foreground_color,
+            bg_color: cfg.background_color,
+            sgr_flags: CellFlags::empty(),
+            damage: Damage::Full,
+            cursor_blink_phase: true,
+            dirty_cursor: true,
+        }
+    }
+
+    pub fn feed(&mut self, bytes: &[u8]) {
+        let mut parser = crate::ansi::Parser::new();
+        parser.advance(self, bytes);
+    }
+
+    pub fn resize(&mut self, cols: usize, rows: usize) {
+        self.grid.resize(cols, rows);
+        self.damage = Damage::Full;
+    }
+
+    pub fn tick_blink(&mut self) {
+        if self.config.cursor_blink {
+            self.cursor_blink_phase = !self.cursor_blink_phase;
+            self.dirty_cursor = true;
+        }
+    }
+
+    fn write_char(&mut self, ch: char) {
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+
+        if let Some(line) = self.grid.line_mut(row) {
+            if let Some(cell) = line.cells.get_mut(col) {
+                cell.ch = ch;
+                cell.fg = self.fg_color;
+                cell.bg = self.bg_color;
+                cell.flags = self.sgr_flags;
+                line.dirty = true;
+                self.damage.add_line(row, col, col + 1);
+            }
+        }
+
+        if self.grid.cursor_col + 1 < self.grid.cols {
+            self.grid.cursor_col += 1;
+        } else if self.auto_wrap {
+            self.grid.cursor_col = 0;
+            if self.grid.cursor_row + 1 >= self.grid.bottom_margin + 1 {
+                self.grid.scroll_up(1);
+            } else {
+                self.grid.cursor_row += 1;
+            }
+        }
+    }
+}
+
+impl Perform for Terminal {
+    fn print(&mut self, ch: char) {
+        self.write_char(ch);
+    }
+
+    fn execute(&mut self, byte: u8) {
+        match byte {
+            0x07 => { }
+            0x08 => {
+                if self.grid.cursor_col > 0 {
+                    self.grid.cursor_col -= 1;
+                }
+            }
+            0x09 => {
+                let next_tab = ((self.grid.cursor_col / 8) + 1) * 8;
+                self.grid.cursor_col = next_tab.min(self.grid.cols - 1);
+            }
+            0x0A | 0x0B | 0x0C => {
+                if self.grid.cursor_row + 1 >= self.grid.bottom_margin + 1 {
+                    self.grid.scroll_up(1);
+                } else {
+                    self.grid.cursor_row += 1;
+                }
+            }
+            0x0D => {
+                self.grid.cursor_col = 0;
+            }
+            0x0E => { }
+            0x0F => { }
+            _ => {}
+        }
+    }
+
+    fn csi_dispatch(&mut self, params: &[u16], _intermediates: &[u8], _ignore: bool, action: char) {
+        match action {
+            'm' => self.handle_sgr(params),
+            'H' | 'f' => self.handle_cup(params),
+            'J' => self.handle_ed(params),
+            'K' => self.handle_el(params),
+            'A' => self.handle_cuu(params),
+            'B' => self.handle_cud(params),
+            'C' => self.handle_cuf(params),
+            'D' => self.handle_cub(params),
+            'E' => self.handle_cnl(params),
+            'F' => self.handle_cpl(params),
+            'G' => self.handle_cha(params),
+            'd' => self.handle_vpa(params),
+            'n' => self.handle_dsr(params),
+            'h' => self.handle_sm(params),
+            'l' => self.handle_rm(params),
+            'r' => self.handle_decstbm(params),
+            'L' => self.handle_il(params),
+            'M' => self.handle_dl(params),
+            'P' => self.handle_dch(params),
+            '@' => self.handle_ich(params),
+            'X' => self.handle_ech(params),
+            'c' => self.handle_da(params),
+            'g' => self.handle_tbc(params),
+            _ => {}
+        }
+    }
+
+    fn esc_dispatch(&mut self, _intermediates: &[u8], _ignore: bool, byte: u8) {
+        match byte {
+            b'c' => {
+                *self = Terminal::new(self.config.clone());
+            }
+            b'7' => {
+                self.grid.saved_cursor_row = self.grid.cursor_row;
+                self.grid.saved_cursor_col = self.grid.cursor_col;
+            }
+            b'8' => {
+                self.grid.cursor_row = self.grid.saved_cursor_row;
+                self.grid.cursor_col = self.grid.saved_cursor_col;
+            }
+            b'M' => {
+                if self.grid.cursor_row == self.grid.top_margin {
+                    self.grid.scroll_down(1);
+                } else if self.grid.cursor_row > 0 {
+                    self.grid.cursor_row -= 1;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn osc_dispatch(&mut self, params: &[&[u8]]) {
+        if params.is_empty() {
+            return;
+        }
+        let param0 = std::str::from_utf8(params[0]).unwrap_or("");
+        match param0.parse::<u32>() {
+            Ok(0) | Ok(2) => { }
+            Ok(7) => { }
+            Ok(8) => { }
+            Ok(52) => { }
+            _ => { }
+        }
+    }
+
+    fn dcs_hook(&mut self, _params: &[u16], _intermediates: &[u8], _ignore: bool, _action: char) {}
+    fn dcs_put(&mut self, _byte: u8) {}
+    fn dcs_unhook(&mut self) {}
+}
+
+macro_rules! param_or {
+    ($params:expr, $idx:expr, $default:expr) => {
+        $params.get($idx).copied().filter(|&v| v != 0).unwrap_or($default)
+    };
+}
+
+impl Terminal {
+    fn handle_sgr(&mut self, params: &[u16]) {
+        if params.is_empty() {
+            self.fg_color = self.config.foreground_color;
+            self.bg_color = self.config.background_color;
+            self.sgr_flags = CellFlags::empty();
+            return;
+        }
+
+        let mut i = 0;
+        while i < params.len() {
+            match params[i] {
+                0 => {
+                    self.fg_color = self.config.foreground_color;
+                    self.bg_color = self.config.background_color;
+                    self.sgr_flags = CellFlags::empty();
+                }
+                1 => self.sgr_flags.insert(CellFlags::BOLD),
+                3 => self.sgr_flags.insert(CellFlags::ITALIC),
+                4 => self.sgr_flags.insert(CellFlags::UNDERLINE),
+                5 | 6 => self.sgr_flags.insert(CellFlags::BLINK),
+                7 => self.sgr_flags.insert(CellFlags::REVERSE),
+                8 => self.sgr_flags.insert(CellFlags::HIDDEN),
+                9 => self.sgr_flags.insert(CellFlags::STRIKETHROUGH),
+                21 => self.sgr_flags.remove(CellFlags::BOLD),
+                22 => self.sgr_flags.remove(CellFlags::BOLD),
+                23 => self.sgr_flags.remove(CellFlags::ITALIC),
+                24 => self.sgr_flags.remove(CellFlags::UNDERLINE),
+                25 => self.sgr_flags.remove(CellFlags::BLINK),
+                27 => self.sgr_flags.remove(CellFlags::REVERSE),
+                28 => self.sgr_flags.remove(CellFlags::HIDDEN),
+                29 => self.sgr_flags.remove(CellFlags::STRIKETHROUGH),
+                30..=37 => {
+                    let idx = (params[i] - 30) as usize;
+                    self.fg_color = ANSI_COLORS[idx];
+                }
+                38 => {
+                    if let Some(color) = self.parse_extended_color(params, &mut i) {
+                        self.fg_color = color;
+                    }
+                }
+                39 => self.fg_color = self.config.foreground_color,
+                40..=47 => {
+                    let idx = (params[i] - 40) as usize;
+                    self.bg_color = ANSI_COLORS[idx];
+                }
+                48 => {
+                    if let Some(color) = self.parse_extended_color(params, &mut i) {
+                        self.bg_color = color;
+                    }
+                }
+                49 => self.bg_color = self.config.background_color,
+                90..=97 => {
+                    let idx = (params[i] - 90 + 8) as usize;
+                    self.fg_color = ANSI_COLORS[idx];
+                }
+                100..=107 => {
+                    let idx = (params[i] - 100 + 8) as usize;
+                    self.bg_color = ANSI_COLORS[idx];
+                }
+                _ => {}
+            }
+            i += 1;
+        }
+    }
+
+    fn parse_extended_color(&self, params: &[u16], i: &mut usize) -> Option<u32> {
+        *i += 1;
+        match params.get(*i)? {
+            2 => {
+                *i += 1;
+                let r = params.get(*i).copied().unwrap_or(0) as u32;
+                *i += 1;
+                let g = params.get(*i).copied().unwrap_or(0) as u32;
+                *i += 1;
+                let b = params.get(*i).copied().unwrap_or(0) as u32;
+                Some(0xFF_000000 | (r << 16) | (g << 8) | b)
+            }
+            5 => {
+                *i += 1;
+                let idx = params.get(*i).copied().unwrap_or(0) as usize;
+                Some(extended_256_color(idx))
+            }
+            _ => None,
+        }
+    }
+
+    fn handle_cup(&mut self, params: &[u16]) {
+        let row = param_or!(params, 0, 1).saturating_sub(1) as usize;
+        let col = param_or!(params, 1, 1).saturating_sub(1) as usize;
+        let base = if self.origin_mode { self.grid.top_margin } else { 0 };
+        self.grid.cursor_row = (base + row).min(self.grid.rows.saturating_sub(1));
+        self.grid.cursor_col = col.min(self.grid.cols.saturating_sub(1));
+    }
+
+    fn handle_ed(&mut self, params: &[u16]) {
+        let mode = param_or!(params, 0, 0);
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+
+        match mode {
+            0 => {
+                self.grid.clear_line_right(row, col);
+                for r in (row + 1)..self.grid.rows {
+                    self.grid.clear_line(r);
+                }
+                self.damage = Damage::Full;
+            }
+            1 => {
+                self.grid.clear_line_left(row, col);
+                for r in 0..row {
+                    self.grid.clear_line(r);
+                }
+                self.damage = Damage::Full;
+            }
+            2 | 3 => {
+                self.grid.clear_screen();
+                if mode == 3 {
+                    self.grid.scrollback.clear();
+                }
+                self.damage = Damage::Full;
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_el(&mut self, params: &[u16]) {
+        let mode = param_or!(params, 0, 0);
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+
+        match mode {
+            0 => self.grid.clear_line_right(row, col),
+            1 => self.grid.clear_line_left(row, col),
+            2 => self.grid.clear_line(row),
+            _ => {}
+        }
+    }
+
+    fn handle_cuu(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let top = if self.origin_mode { self.grid.top_margin } else { 0 };
+        self.grid.cursor_row = self.grid.cursor_row.saturating_sub(n).max(top);
+    }
+
+    fn handle_cud(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let bottom = if self.origin_mode {
+            self.grid.bottom_margin
+        } else {
+            self.grid.rows.saturating_sub(1)
+        };
+        self.grid.cursor_row = (self.grid.cursor_row + n).min(bottom);
+    }
+
+    fn handle_cuf(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        self.grid.cursor_col = (self.grid.cursor_col + n).min(self.grid.cols.saturating_sub(1));
+    }
+
+    fn handle_cub(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        self.grid.cursor_col = self.grid.cursor_col.saturating_sub(n);
+    }
+
+    fn handle_cnl(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        self.grid.cursor_col = 0;
+        self.handle_cud(&[n as u16]);
+    }
+
+    fn handle_cpl(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        self.grid.cursor_col = 0;
+        self.handle_cuu(&[n as u16]);
+    }
+
+    fn handle_cha(&mut self, params: &[u16]) {
+        let col = param_or!(params, 0, 1).saturating_sub(1) as usize;
+        self.grid.cursor_col = col.min(self.grid.cols.saturating_sub(1));
+    }
+
+    fn handle_vpa(&mut self, params: &[u16]) {
+        let row = param_or!(params, 0, 1).saturating_sub(1) as usize;
+        let base = if self.origin_mode { self.grid.top_margin } else { 0 };
+        self.grid.cursor_row = (base + row).min(self.grid.rows.saturating_sub(1));
+    }
+
+    fn handle_dsr(&mut self, _params: &[u16]) { }
+
+    fn handle_sm(&mut self, params: &[u16]) {
+        for &param in params {
+            match param {
+                1 => { }
+                7 => self.auto_wrap = true,
+                25 => self.cursor_visible = true,
+                1049 => { }
+                1000 => self.mouse_tracking = true,
+                1002 => self.mouse_tracking = true,
+                1004 => self.focus_tracking = true,
+                2004 => self.bracketed_paste = true,
+                _ => {}
+            }
+        }
+    }
+
+    fn handle_rm(&mut self, params: &[u16]) {
+        for &param in params {
+            match param {
+                7 => self.auto_wrap = false,
+                25 => self.cursor_visible = false,
+                1049 => { }
+                1000 => self.mouse_tracking = false,
+                1002 => self.mouse_tracking = false,
+                1004 => self.focus_tracking = false,
+                2004 => self.bracketed_paste = false,
+                _ => {}
+            }
+        }
+    }
+
+    fn handle_decstbm(&mut self, params: &[u16]) {
+        let top = param_or!(params, 0, 1).saturating_sub(1) as usize;
+        let bottom = param_or!(params, 1, self.grid.rows as u16) as usize;
+        if top < bottom && bottom <= self.grid.rows {
+            self.grid.top_margin = top;
+            self.grid.bottom_margin = bottom.saturating_sub(1);
+            self.grid.cursor_row = top;
+            self.grid.cursor_col = 0;
+        }
+    }
+
+    fn handle_il(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let row = self.grid.cursor_row;
+        let top = self.grid.top_margin;
+        let bottom = self.grid.bottom_margin;
+        let cols = self.grid.cols;
+
+        for _ in 0..n {
+            if row <= bottom {
+                self.grid.lines.remove(bottom);
+                let mut new_line = crate::grid::Line::new(cols);
+                new_line.dirty = true;
+                self.grid.lines.insert(row, new_line);
+            }
+        }
+        for i in top..=bottom {
+            if let Some(line) = self.grid.lines.get_mut(i) {
+                line.dirty = true;
+            }
+        }
+        self.damage = Damage::Full;
+    }
+
+    fn handle_dl(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let row = self.grid.cursor_row;
+        let top = self.grid.top_margin;
+        let bottom = self.grid.bottom_margin;
+        let cols = self.grid.cols;
+
+        for _ in 0..n {
+            if row <= bottom {
+                self.grid.lines.remove(row);
+                let mut new_line = crate::grid::Line::new(cols);
+                new_line.dirty = true;
+                self.grid.lines.insert(bottom, new_line);
+            }
+        }
+        for i in top..=bottom {
+            if let Some(line) = self.grid.lines.get_mut(i) {
+                line.dirty = true;
+            }
+        }
+        self.damage = Damage::Full;
+    }
+
+    fn handle_dch(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+        let cols = self.grid.cols;
+        if let Some(line) = self.grid.line_mut(row) {
+            for i in col..cols.saturating_sub(n) {
+                line.cells[i] = line.cells[i + n].clone();
+            }
+            for i in (cols.saturating_sub(n))..cols {
+                line.cells[i].reset();
+            }
+            line.dirty = true;
+            self.damage.add_line(row, col, cols);
+        }
+    }
+
+    fn handle_ich(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+        let cols = self.grid.cols;
+        if let Some(line) = self.grid.line_mut(row) {
+            let shift_count = (cols - col).saturating_sub(n);
+            for i in (0..shift_count).rev() {
+                line.cells[col + i + n] = line.cells[col + i].clone();
+            }
+            let clear_end = col + n.min(cols - col);
+            for i in col..clear_end {
+                line.cells[i].reset();
+            }
+            line.dirty = true;
+            self.damage.add_line(row, col, cols);
+        }
+    }
+
+    fn handle_ech(&mut self, params: &[u16]) {
+        let n = param_or!(params, 0, 1) as usize;
+        let row = self.grid.cursor_row;
+        let col = self.grid.cursor_col;
+        let end = (col + n).min(self.grid.cols);
+        if let Some(line) = self.grid.line_mut(row) {
+            for i in col..end {
+                line.cells[i].reset();
+            }
+            line.dirty = true;
+            self.damage.add_line(row, col, end);
+        }
+    }
+
+    fn handle_da(&mut self, _params: &[u16]) { }
+
+    fn handle_tbc(&mut self, _params: &[u16]) { }
+}
+
+fn extended_256_color(idx: usize) -> u32 {
+    const TABLE: [u32; 216] = {
+        let mut table = [0u32; 216];
+        let mut i = 0usize;
+        while i < 216 {
+            let r = (i / 36) % 6;
+            let g = (i / 6) % 6;
+            let b = i % 6;
+            let rv = if r > 0 { 55 + r * 40 } else { 0 };
+            let gv = if g > 0 { 55 + g * 40 } else { 0 };
+            let bv = if b > 0 { 55 + b * 40 } else { 0 };
+            table[i] = 0xFF_000000 | ((rv as u32) << 16) | ((gv as u32) << 8) | (bv as u32);
+            i += 1;
+        }
+        table
+    };
+
+    if idx < 16 {
+        ANSI_COLORS[idx]
+    } else if idx < 232 {
+        TABLE[idx - 16]
+    } else {
+        let v = 8 + (idx - 232) * 10;
+        let v = v as u32;
+        0xFF_000000 | (v << 16) | (v << 8) | v
+    }
+}