zach/zterm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f6a5e23f3dea0ca4793dad983eb72156ec641790
zterm/src/terminal.rs
T
Zacharias-Brohn f6a5e23f3d fixed atlas size, font rendering, etc.
2025-12-19 13:53:41 +01:00

2487 lines
99 KiB
Rust
Raw Blame History

//! Terminal state management and escape sequence handling.
use crate::graphics::{GraphicsCommand, ImageStorage};
use crate::keyboard::{query_response, KeyboardState};
use crate::vt_parser::{CsiParams, Handler, Parser};
use unicode_width::UnicodeWidthChar;
/// Commands that the terminal can send to the application.
/// These are triggered by special escape sequences from programs like Neovim.
#[derive(Clone, Debug, PartialEq)]
pub enum TerminalCommand {
/// Navigate to a neighboring pane in the given direction.
/// Triggered by OSC 51;navigate;<direction> ST
NavigatePane(Direction),
/// Set custom statusline content for this pane.
/// Triggered by OSC 51;statusline;<content> ST
/// Empty content clears the statusline (restores default).
SetStatusline(Option<String>),
}
/// Direction for pane navigation.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Direction {
Up,
Down,
Left,
Right,
}
/// A single cell in the terminal grid.
#[derive(Clone, Copy, Debug)]
pub struct Cell {
pub character: char,
pub fg_color: Color,
pub bg_color: Color,
pub bold: bool,
pub italic: bool,
/// Underline style: 0=none, 1=single, 2=double, 3=curly, 4=dotted, 5=dashed
pub underline_style: u8,
/// Strikethrough decoration
pub strikethrough: bool,
/// If true, this cell is the continuation of a wide (double-width) character.
/// The actual character is stored in the previous cell.
pub wide_continuation: bool,
}
impl Default for Cell {
fn default() -> Self {
Self {
character: ' ',
fg_color: Color::Default,
bg_color: Color::Default,
bold: false,
italic: false,
underline_style: 0,
strikethrough: false,
wide_continuation: false,
}
}
}
/// Terminal colors.
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub enum Color {
#[default]
Default,
Rgb(u8, u8, u8),
Indexed(u8),
}
/// Cursor shape styles (DECSCUSR).
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub enum CursorShape {
/// Blinking block (and default)
#[default]
BlinkingBlock,
/// Steady block
SteadyBlock,
/// Blinking underline
BlinkingUnderline,
/// Steady underline
SteadyUnderline,
/// Blinking bar (beam)
BlinkingBar,
/// Steady bar (beam)
SteadyBar,
}
/// Mouse tracking mode - determines what mouse events are reported to the application.
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub enum MouseTrackingMode {
/// No mouse tracking (terminal handles selection).
#[default]
None,
/// X10 compatibility mode - only report button press (mode 9).
X10,
/// Normal tracking mode - report button press and release (mode 1000).
Normal,
/// Button-event tracking - report press, release, and motion while button pressed (mode 1002).
ButtonEvent,
/// Any-event tracking - report all motion events (mode 1003).
AnyEvent,
}
/// Mouse encoding format - how mouse events are encoded.
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub enum MouseEncoding {
/// Default X10 encoding (limited to 223 rows/cols).
#[default]
X10,
/// UTF-8 encoding (mode 1005) - deprecated, rarely used.
Utf8,
/// SGR extended encoding (mode 1006) - most common modern format.
Sgr,
/// URXVT encoding (mode 1015) - rarely used.
Urxvt,
}
/// Color palette with 256 colors + default fg/bg.
#[derive(Clone)]
pub struct ColorPalette {
/// 256 indexed colors (ANSI 0-15 + 216 color cube + 24 grayscale).
pub colors: [[u8; 3]; 256],
/// Default foreground color.
pub default_fg: [u8; 3],
/// Default background color.
pub default_bg: [u8; 3],
}
impl Default for ColorPalette {
fn default() -> Self {
let mut colors = [[0u8; 3]; 256];
// Standard ANSI colors (0-7)
colors[0] = [0, 0, 0]; // Black
colors[1] = [204, 0, 0]; // Red
colors[2] = [0, 204, 0]; // Green
colors[3] = [204, 204, 0]; // Yellow
colors[4] = [0, 0, 204]; // Blue
colors[5] = [204, 0, 204]; // Magenta
colors[6] = [0, 204, 204]; // Cyan
colors[7] = [204, 204, 204]; // White
// Bright ANSI colors (8-15)
colors[8] = [102, 102, 102]; // Bright Black (Gray)
colors[9] = [255, 0, 0]; // Bright Red
colors[10] = [0, 255, 0]; // Bright Green
colors[11] = [255, 255, 0]; // Bright Yellow
colors[12] = [0, 0, 255]; // Bright Blue
colors[13] = [255, 0, 255]; // Bright Magenta
colors[14] = [0, 255, 255]; // Bright Cyan
colors[15] = [255, 255, 255]; // Bright White
// 216 color cube (16-231)
for r in 0..6 {
for g in 0..6 {
for b in 0..6 {
let idx = 16 + r * 36 + g * 6 + b;
let to_val = |c: usize| if c == 0 { 0 } else { (55 + c * 40) as u8 };
colors[idx] = [to_val(r), to_val(g), to_val(b)];
}
}
}
// 24 grayscale colors (232-255)
for i in 0..24 {
let gray = (8 + i * 10) as u8;
colors[232 + i] = [gray, gray, gray];
}
Self {
colors,
default_fg: [230, 230, 230], // Light gray
default_bg: [26, 26, 26], // Dark gray
}
}
}
impl ColorPalette {
/// Parse a color specification like "#RRGGBB" or "rgb:RR/GG/BB".
pub fn parse_color_spec(spec: &str) -> Option<[u8; 3]> {
let spec = spec.trim();
if let Some(hex) = spec.strip_prefix('#') {
// #RRGGBB format
if hex.len() == 6 {
let r = u8::from_str_radix(&hex[0..2], 16).ok()?;
let g = u8::from_str_radix(&hex[2..4], 16).ok()?;
let b = u8::from_str_radix(&hex[4..6], 16).ok()?;
return Some([r, g, b]);
}
} else if let Some(rgb) = spec.strip_prefix("rgb:") {
// rgb:RR/GG/BB or rgb:RRRR/GGGG/BBBB format
let parts: Vec<&str> = rgb.split('/').collect();
if parts.len() == 3 {
let parse_component = |s: &str| -> Option<u8> {
let val = u16::from_str_radix(s, 16).ok()?;
// Scale to 8-bit if it's a 16-bit value
Some(if s.len() > 2 { (val >> 8) as u8 } else { val as u8 })
};
let r = parse_component(parts[0])?;
let g = parse_component(parts[1])?;
let b = parse_component(parts[2])?;
return Some([r, g, b]);
}
}
None
}
/// Get RGBA for a color, using the palette for indexed colors.
pub fn to_rgba(&self, color: &Color) -> [f32; 4] {
match color {
Color::Default => {
let [r, g, b] = self.default_fg;
[r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0]
}
Color::Rgb(r, g, b) => [*r as f32 / 255.0, *g as f32 / 255.0, *b as f32 / 255.0, 1.0],
Color::Indexed(idx) => {
let [r, g, b] = self.colors[*idx as usize];
[r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0]
}
}
}
/// Get RGBA for background, using palette default_bg for Color::Default.
pub fn to_rgba_bg(&self, color: &Color) -> [f32; 4] {
match color {
Color::Default => {
let [r, g, b] = self.default_bg;
[r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0]
}
Color::Rgb(r, g, b) => [*r as f32 / 255.0, *g as f32 / 255.0, *b as f32 / 255.0, 1.0],
Color::Indexed(idx) => {
let [r, g, b] = self.colors[*idx as usize];
[r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0]
}
}
}
}
/// Saved cursor state for DECSC/DECRC.
#[derive(Clone, Debug, Default)]
struct SavedCursor {
col: usize,
row: usize,
fg: Color,
bg: Color,
bold: bool,
italic: bool,
underline_style: u8,
strikethrough: bool,
}
/// Alternate screen buffer state.
#[derive(Clone)]
struct AlternateScreen {
grid: Vec<Vec<Cell>>,
line_map: Vec<usize>,
cursor_col: usize,
cursor_row: usize,
saved_cursor: SavedCursor,
scroll_top: usize,
scroll_bottom: usize,
}
/// Timing stats for performance debugging.
#[derive(Debug, Default)]
pub struct ProcessingStats {
/// Total time spent in scroll_up operations (nanoseconds).
pub scroll_up_ns: u64,
/// Number of scroll_up calls.
pub scroll_up_count: u32,
/// Total time spent in scrollback operations (nanoseconds).
pub scrollback_ns: u64,
/// Time in VecDeque pop_front.
pub pop_front_ns: u64,
/// Time in VecDeque push_back.
pub push_back_ns: u64,
/// Time in mem::swap.
pub swap_ns: u64,
/// Total time spent in line clearing (nanoseconds).
pub clear_line_ns: u64,
/// Total time spent in text handler (nanoseconds).
pub text_handler_ns: u64,
/// Number of characters processed.
pub chars_processed: u32,
}
impl ProcessingStats {
pub fn reset(&mut self) {
*self = Self::default();
}
pub fn log_if_slow(&self, threshold_ms: u64) {
let total_ms = (self.scroll_up_ns + self.text_handler_ns) / 1_000_000;
if total_ms >= threshold_ms {
log::info!(
"TIMING: scroll_up={:.2}ms ({}x), scrollback={:.2}ms [pop={:.2}ms swap={:.2}ms push={:.2}ms], clear={:.2}ms, text={:.2}ms, chars={}",
self.scroll_up_ns as f64 / 1_000_000.0,
self.scroll_up_count,
self.scrollback_ns as f64 / 1_000_000.0,
self.pop_front_ns as f64 / 1_000_000.0,
self.swap_ns as f64 / 1_000_000.0,
self.push_back_ns as f64 / 1_000_000.0,
self.clear_line_ns as f64 / 1_000_000.0,
self.text_handler_ns as f64 / 1_000_000.0,
self.chars_processed,
);
}
}
}
/// Kitty-style ring buffer for scrollback history.
///
/// Pre-allocates all lines upfront to avoid allocation during scrolling.
/// Uses modulo arithmetic for O(1) operations with no memory allocation or
/// pointer chasing - just simple index arithmetic like Kitty's historybuf.
///
/// Key insight from Kitty: When the buffer is full, instead of pop_front + push_back
/// (which involves linked-list-style pointer updates in VecDeque), we just:
/// 1. Calculate the insertion slot with modulo arithmetic
/// 2. Increment the start pointer (also with modulo)
///
/// This eliminates all per-scroll overhead that was causing timing variance.
pub struct ScrollbackBuffer {
/// Pre-allocated line storage. All lines are allocated upfront.
lines: Vec<Vec<Cell>>,
/// Index of the oldest line (start of valid data).
start: usize,
/// Number of valid lines currently stored.
count: usize,
/// Maximum capacity (same as lines.len()).
capacity: usize,
}
impl ScrollbackBuffer {
/// Creates a new scrollback buffer with the given capacity.
/// Lines are allocated lazily as needed to avoid slow startup.
pub fn new(capacity: usize) -> Self {
// Don't pre-allocate lines - allocate them lazily as content is added
// This avoids allocating and zeroing potentially 20MB+ of memory at startup
let lines = Vec::with_capacity(capacity.min(1024)); // Start with reasonable capacity
Self {
lines,
start: 0,
count: 0,
capacity,
}
}
/// Returns the number of lines currently stored.
#[inline]
pub fn len(&self) -> usize {
self.count
}
/// Returns true if the buffer is empty.
#[inline]
pub fn is_empty(&self) -> bool {
self.count == 0
}
/// Returns true if the buffer is at capacity.
#[inline]
pub fn is_full(&self) -> bool {
self.count == self.capacity
}
/// Push a line into the buffer, returning a mutable reference to write into.
///
/// If the buffer is full, the oldest line is overwritten and its slot is returned
/// for reuse (the caller can swap content into it).
///
/// Lines are allocated lazily on first use to avoid slow startup.
#[inline]
pub fn push(&mut self, cols: usize) -> &mut Vec<Cell> {
if self.capacity == 0 {
// Shouldn't happen in normal use, but handle gracefully
panic!("Cannot push to zero-capacity scrollback buffer");
}
// Calculate insertion index: (start + count) % capacity
// This is where the new line goes
let idx = (self.start + self.count) % self.capacity;
if self.count == self.capacity {
// Buffer is full - we're overwriting the oldest line
// Advance start to point to the new oldest line
self.start = (self.start + 1) % self.capacity;
// count stays the same
} else {
// Buffer not full yet - allocate new line if needed
if idx >= self.lines.len() {
// Grow the lines vector and allocate the new line
self.lines.push(vec![Cell::default(); cols]);
}
self.count += 1;
}
&mut self.lines[idx]
}
/// Get a line by logical index (0 = oldest, count-1 = newest).
/// Returns None if index is out of bounds.
#[inline]
pub fn get(&self, index: usize) -> Option<&Vec<Cell>> {
if index >= self.count {
return None;
}
// Map logical index to physical index
let physical_idx = (self.start + index) % self.capacity;
Some(&self.lines[physical_idx])
}
/// Clear all lines from the buffer.
/// Note: This doesn't deallocate - lines stay allocated for reuse.
#[inline]
pub fn clear(&mut self) {
self.start = 0;
self.count = 0;
// Lines remain allocated but logically empty
}
}
/// The terminal grid state.
pub struct Terminal {
/// Grid of cells (row-major order).
/// Access via line_map for correct visual ordering.
pub grid: Vec<Vec<Cell>>,
/// Maps visual row index to actual grid row index.
/// This allows O(1) scrolling by rotating indices instead of moving cells.
line_map: Vec<usize>,
/// Number of columns.
pub cols: usize,
/// Number of rows.
pub rows: usize,
/// Current cursor column (0-indexed).
pub cursor_col: usize,
/// Current cursor row (0-indexed).
pub cursor_row: usize,
/// Cursor visibility.
pub cursor_visible: bool,
/// Cursor shape (block, underline, bar).
pub cursor_shape: CursorShape,
/// Current foreground color for new text.
pub current_fg: Color,
/// Current background color for new text.
pub current_bg: Color,
/// Current bold state.
pub current_bold: bool,
/// Current italic state.
pub current_italic: bool,
/// Current underline style (0=none, 1=single, 2=double, 3=curly, 4=dotted, 5=dashed).
pub current_underline_style: u8,
/// Current strikethrough state.
pub current_strikethrough: bool,
/// Whether the terminal content has changed.
pub dirty: bool,
/// Bitmap of dirty lines - bit N is set if line N needs redrawing.
/// Supports up to 256 lines (4 x u64).
pub dirty_lines: [u64; 4],
/// Scroll region top (0-indexed, inclusive).
scroll_top: usize,
/// Scroll region bottom (0-indexed, inclusive).
scroll_bottom: usize,
/// Kitty keyboard protocol state.
pub keyboard: KeyboardState,
/// Response queue (bytes to send back to PTY).
response_queue: Vec<u8>,
/// Color palette (can be modified by OSC sequences).
pub palette: ColorPalette,
/// Scrollback buffer (lines that scrolled off the top).
/// Uses a Kitty-style ring buffer for O(1) operations with no allocation.
pub scrollback: ScrollbackBuffer,
/// Current scroll offset (0 = viewing live terminal, >0 = viewing history).
pub scroll_offset: usize,
/// Mouse tracking mode (what events to report to application).
pub mouse_tracking: MouseTrackingMode,
/// Mouse encoding format (how to encode mouse events).
pub mouse_encoding: MouseEncoding,
/// Saved cursor state (DECSC/DECRC).
saved_cursor: SavedCursor,
/// Alternate screen buffer (for fullscreen apps like vim, less).
alternate_screen: Option<AlternateScreen>,
/// Whether we're currently using the alternate screen.
pub using_alternate_screen: bool,
/// Application cursor keys mode (DECCKM) - arrows send ESC O instead of ESC [.
pub application_cursor_keys: bool,
/// Auto-wrap mode (DECAWM) - wrap at end of line.
auto_wrap: bool,
/// Bracketed paste mode - wrap pasted text with escape sequences.
pub bracketed_paste: bool,
/// Focus event reporting mode.
pub focus_reporting: bool,
/// Synchronized output mode (for reducing flicker).
synchronized_output: bool,
/// Pool of pre-allocated empty lines to avoid allocation during scrolling.
/// When we need a new line, we pop from this pool instead of allocating.
line_pool: Vec<Vec<Cell>>,
/// VT parser for escape sequence handling.
parser: Option<Parser>,
/// Performance timing stats (for debugging).
pub stats: ProcessingStats,
/// Command queue for terminal-to-application communication.
/// Commands are added by OSC handlers and consumed by the application.
command_queue: Vec<TerminalCommand>,
/// Image storage for Kitty graphics protocol.
pub image_storage: ImageStorage,
/// Cell width in pixels (for image sizing).
pub cell_width: f32,
/// Cell height in pixels (for image sizing).
pub cell_height: f32,
}
impl Terminal {
/// Default scrollback limit (10,000 lines for better cache performance).
pub const DEFAULT_SCROLLBACK_LIMIT: usize = 10_000;
/// Size of the line pool for recycling allocations.
/// This avoids allocation during the first N scrolls before scrollback is full.
const LINE_POOL_SIZE: usize = 64;
/// Creates a new terminal with the given dimensions and scrollback limit.
pub fn new(cols: usize, rows: usize, scrollback_limit: usize) -> Self {
log::info!("Terminal::new: cols={}, rows={}, scroll_bottom={}", cols, rows, rows.saturating_sub(1));
let grid = vec![vec![Cell::default(); cols]; rows];
let line_map: Vec<usize> = (0..rows).collect();
// Pre-allocate a pool of empty lines to avoid allocation during scrolling
let line_pool: Vec<Vec<Cell>> = (0..Self::LINE_POOL_SIZE)
.map(|_| vec![Cell::default(); cols])
.collect();
Self {
grid,
line_map,
cols,
rows,
cursor_col: 0,
cursor_row: 0,
cursor_visible: true,
cursor_shape: CursorShape::default(),
current_fg: Color::Default,
current_bg: Color::Default,
current_bold: false,
current_italic: false,
current_underline_style: 0,
current_strikethrough: false,
dirty: true,
dirty_lines: [!0u64; 4], // All lines dirty initially
scroll_top: 0,
scroll_bottom: rows.saturating_sub(1),
keyboard: KeyboardState::new(),
response_queue: Vec::new(),
palette: ColorPalette::default(),
scrollback: ScrollbackBuffer::new(scrollback_limit),
scroll_offset: 0,
mouse_tracking: MouseTrackingMode::default(),
mouse_encoding: MouseEncoding::default(),
saved_cursor: SavedCursor::default(),
alternate_screen: None,
using_alternate_screen: false,
application_cursor_keys: false,
auto_wrap: true, // Auto-wrap is on by default
bracketed_paste: false,
focus_reporting: false,
synchronized_output: false,
line_pool,
parser: Some(Parser::new()),
stats: ProcessingStats::default(),
command_queue: Vec::new(),
image_storage: ImageStorage::new(),
cell_width: 10.0, // Default, will be set by renderer
cell_height: 20.0, // Default, will be set by renderer
}
}
/// Return a line to the pool for reuse (if pool isn't full).
#[allow(dead_code)]
#[inline]
fn return_line_to_pool(&mut self, line: Vec<Cell>) {
if self.line_pool.len() < Self::LINE_POOL_SIZE {
self.line_pool.push(line);
}
// Otherwise, let the line be dropped
}
/// Mark a specific line as dirty (needs redrawing).
#[inline]
pub fn mark_line_dirty(&mut self, line: usize) {
if line < 256 {
let word = line / 64;
let bit = line % 64;
self.dirty_lines[word] |= 1u64 << bit;
}
}
/// Mark all lines as dirty.
#[inline]
pub fn mark_all_lines_dirty(&mut self) {
self.dirty_lines = [!0u64; 4];
}
/// Check if a line is dirty.
#[inline]
pub fn is_line_dirty(&self, line: usize) -> bool {
if line < 256 {
let word = line / 64;
let bit = line % 64;
(self.dirty_lines[word] & (1u64 << bit)) != 0
} else {
true // Lines beyond 256 are always considered dirty
}
}
/// Clear all dirty line flags.
#[inline]
pub fn clear_dirty_lines(&mut self) {
self.dirty_lines = [0u64; 4];
}
/// Take all pending commands from the queue.
/// Returns an empty Vec if no commands are pending.
#[inline]
pub fn take_commands(&mut self) -> Vec<TerminalCommand> {
std::mem::take(&mut self.command_queue)
}
/// Get the dirty lines bitmap (for passing to shm).
#[inline]
pub fn get_dirty_lines(&self) -> u64 {
// Return first 64 lines worth of dirty bits (most common case)
self.dirty_lines[0]
}
/// Check if synchronized output mode is active (rendering should be suppressed).
/// This is set by CSI 2026 or DCS pending mode (=1s/=2s).
#[inline]
pub fn is_synchronized(&self) -> bool {
self.synchronized_output
}
/// Get the actual grid row index for a visual row.
#[inline]
pub fn grid_row(&self, visual_row: usize) -> usize {
self.line_map[visual_row]
}
/// Get a reference to a row by visual index.
#[inline]
pub fn row(&self, visual_row: usize) -> &Vec<Cell> {
&self.grid[self.line_map[visual_row]]
}
/// Get a mutable reference to a row by visual index.
#[inline]
pub fn row_mut(&mut self, visual_row: usize) -> &mut Vec<Cell> {
let idx = self.line_map[visual_row];
&mut self.grid[idx]
}
/// Clear a row (by actual grid index, not visual).
#[inline]
fn clear_grid_row(&mut self, grid_row: usize) {
let blank = self.blank_cell();
let row = &mut self.grid[grid_row];
// Ensure row has correct width (may differ after swap with scrollback post-resize)
row.resize(self.cols, blank.clone());
row.fill(blank);
}
/// Create a blank cell with the current background color (BCE - Background Color Erase).
#[inline]
fn blank_cell(&self) -> Cell {
Cell {
character: ' ',
fg_color: Color::Default,
bg_color: self.current_bg,
bold: false,
italic: false,
underline_style: 0,
strikethrough: false,
wide_continuation: false,
}
}
/// Takes any pending response bytes to send to the PTY.
pub fn take_response(&mut self) -> Option<Vec<u8>> {
if self.response_queue.is_empty() {
None
} else {
Some(std::mem::take(&mut self.response_queue))
}
}
/// Processes raw bytes from the PTY using the internal VT parser.
/// Uses Kitty-style architecture: UTF-8 decode until ESC, then parse escape sequences.
pub fn process(&mut self, bytes: &[u8]) {
// We need to temporarily take ownership of the parser to satisfy the borrow checker,
// since parse() needs &mut self for both parser and handler (Terminal).
// Use Option::take to avoid creating a new default parser each time.
if let Some(mut parser) = self.parser.take() {
parser.parse(bytes, self);
self.parser = Some(parser);
}
self.dirty = true;
}
/// Resizes the terminal grid.
pub fn resize(&mut self, cols: usize, rows: usize) {
if cols == self.cols && rows == self.rows {
return;
}
log::info!("Terminal::resize: {}x{} -> {}x{}", self.cols, self.rows, cols, rows);
let old_cols = self.cols;
let old_rows = self.rows;
// Create new grid
let mut new_grid = vec![vec![Cell::default(); cols]; rows];
// Copy existing content using line_map for correct visual ordering
for visual_row in 0..rows.min(self.rows) {
let old_grid_row = self.line_map[visual_row];
// Use actual row length - may differ from self.cols after scrollback swap
let old_row_len = self.grid[old_grid_row].len();
for col in 0..cols.min(old_row_len) {
new_grid[visual_row][col] = self.grid[old_grid_row][col].clone();
}
}
self.grid = new_grid;
// Reset line_map to identity (0, 1, 2, ...)
self.line_map = (0..rows).collect();
self.cols = cols;
self.rows = rows;
// Reset scroll region to full screen
self.scroll_top = 0;
self.scroll_bottom = rows.saturating_sub(1);
// Adjust cursor position
self.cursor_col = self.cursor_col.min(cols.saturating_sub(1));
self.cursor_row = self.cursor_row.min(rows.saturating_sub(1));
// Also resize the saved alternate screen if it exists
if let Some(ref mut saved) = self.alternate_screen {
let mut new_saved_grid = vec![vec![Cell::default(); cols]; rows];
for visual_row in 0..rows.min(old_rows) {
let old_grid_row = saved.line_map.get(visual_row).copied().unwrap_or(visual_row);
if old_grid_row < saved.grid.len() {
for col in 0..cols.min(old_cols) {
if col < saved.grid[old_grid_row].len() {
new_saved_grid[visual_row][col] = saved.grid[old_grid_row][col].clone();
}
}
}
}
saved.grid = new_saved_grid;
saved.line_map = (0..rows).collect();
saved.cursor_col = saved.cursor_col.min(cols.saturating_sub(1));
saved.cursor_row = saved.cursor_row.min(rows.saturating_sub(1));
saved.scroll_top = 0;
saved.scroll_bottom = rows.saturating_sub(1);
}
self.dirty = true;
self.mark_all_lines_dirty();
}
/// Switch to alternate screen buffer.
fn enter_alternate_screen(&mut self) {
if self.using_alternate_screen {
return; // Already in alternate screen
}
// Save main screen state
self.alternate_screen = Some(AlternateScreen {
grid: self.grid.clone(),
line_map: self.line_map.clone(),
cursor_col: self.cursor_col,
cursor_row: self.cursor_row,
saved_cursor: self.saved_cursor.clone(),
scroll_top: self.scroll_top,
scroll_bottom: self.scroll_bottom,
});
// Clear the screen for alternate buffer
self.grid = vec![vec![Cell::default(); self.cols]; self.rows];
self.line_map = (0..self.rows).collect();
self.cursor_col = 0;
self.cursor_row = 0;
// Reset scroll region to full screen for alternate buffer
self.scroll_top = 0;
self.scroll_bottom = self.rows.saturating_sub(1);
// Reset scroll offset (can't view scrollback in alternate screen)
self.scroll_offset = 0;
self.using_alternate_screen = true;
self.mark_all_lines_dirty();
self.dirty = true;
log::debug!(
"Entered alternate screen buffer: rows={}, cols={}, scroll_region={}-{}, dirty_lines={:016x}{:016x}{:016x}{:016x}",
self.rows, self.cols, self.scroll_top, self.scroll_bottom,
self.dirty_lines[3], self.dirty_lines[2], self.dirty_lines[1], self.dirty_lines[0]
);
}
/// Switch back to main screen buffer.
fn leave_alternate_screen(&mut self) {
if !self.using_alternate_screen {
return; // Not in alternate screen
}
if let Some(saved) = self.alternate_screen.take() {
self.grid = saved.grid;
self.line_map = saved.line_map;
self.saved_cursor = saved.saved_cursor;
self.scroll_top = saved.scroll_top;
self.scroll_bottom = saved.scroll_bottom;
// Clamp cursor positions to current grid dimensions (defensive)
self.cursor_col = saved.cursor_col.min(self.cols.saturating_sub(1));
self.cursor_row = saved.cursor_row.min(self.rows.saturating_sub(1));
}
self.using_alternate_screen = false;
self.mark_all_lines_dirty();
log::debug!("Left alternate screen buffer");
}
/// Scrolls the scroll region up by n lines.
/// Uses line_map rotation for O(n) instead of O(n*cols) cell copying.
fn scroll_up(&mut self, n: usize) {
let region_size = self.scroll_bottom - self.scroll_top + 1;
let n = n.min(region_size);
self.stats.scroll_up_count += n as u32;
for _ in 0..n {
// Save the top line's grid index before rotation
let recycled_grid_row = self.line_map[self.scroll_top];
// Save to scrollback only if scrolling from the very top of the screen
// AND not in alternate screen mode (alternate screen never uses scrollback)
// AND scrollback is enabled (capacity > 0)
if self.scroll_top == 0 && !self.using_alternate_screen && self.scrollback.capacity > 0 {
// Get a slot in the ring buffer - this is O(1) with just modulo arithmetic
// If buffer is full, this overwrites the oldest line (perfect for our swap)
let cols = self.cols;
let dest = self.scrollback.push(cols);
// Swap grid row content into scrollback slot
// The scrollback slot's old content (if any) moves to the grid row
std::mem::swap(&mut self.grid[recycled_grid_row], dest);
// Clear the grid row (now contains old scrollback data or empty)
self.clear_grid_row(recycled_grid_row);
} else {
// Not saving to scrollback - just clear the line
self.clear_grid_row(recycled_grid_row);
}
// Rotate line_map: shift all indices up within scroll region using memmove
self.line_map.copy_within(self.scroll_top + 1..=self.scroll_bottom, self.scroll_top);
self.line_map[self.scroll_bottom] = recycled_grid_row;
}
// Mark all lines dirty with a single bitmask operation instead of loop
self.mark_region_dirty(self.scroll_top, self.scroll_bottom);
}
/// Mark a range of lines as dirty efficiently.
#[inline]
fn mark_region_dirty(&mut self, start: usize, end: usize) {
// For small regions (< 64 lines), this is faster than individual calls
for line in start..=end.min(255) {
let word = line / 64;
let bit = line % 64;
self.dirty_lines[word] |= 1u64 << bit;
}
}
/// Scrolls the scroll region down by n lines.
/// Uses line_map rotation for O(n) instead of O(n*cols) cell copying.
fn scroll_down(&mut self, n: usize) {
let region_size = self.scroll_bottom - self.scroll_top + 1;
let n = n.min(region_size);
for _ in 0..n {
// Save the bottom line's grid index before rotation
let recycled_grid_row = self.line_map[self.scroll_bottom];
// Rotate line_map: shift all indices down within scroll region using memmove
self.line_map.copy_within(self.scroll_top..self.scroll_bottom, self.scroll_top + 1);
self.line_map[self.scroll_top] = recycled_grid_row;
// Clear the recycled line (now at visual top of scroll region)
self.clear_grid_row(recycled_grid_row);
}
// Mark all lines in the scroll region as dirty.
self.mark_region_dirty(self.scroll_top, self.scroll_bottom);
}
/// Scrolls the viewport up (into scrollback history) by n lines.
/// Returns the new scroll offset.
/// Note: Scrollback is disabled in alternate screen mode.
pub fn scroll_viewport_up(&mut self, n: usize) -> usize {
// Alternate screen has no scrollback
if self.using_alternate_screen {
return 0;
}
let max_offset = self.scrollback.len();
let new_offset = (self.scroll_offset + n).min(max_offset);
if new_offset != self.scroll_offset {
self.scroll_offset = new_offset;
self.dirty = true;
self.mark_all_lines_dirty(); // All visible content changes when scrolling
}
self.scroll_offset
}
/// Scrolls the viewport down (toward live terminal) by n lines.
/// Returns the new scroll offset.
/// Note: Scrollback is disabled in alternate screen mode.
pub fn scroll_viewport_down(&mut self, n: usize) -> usize {
// Alternate screen has no scrollback
if self.using_alternate_screen {
return 0;
}
let new_offset = self.scroll_offset.saturating_sub(n);
if new_offset != self.scroll_offset {
self.scroll_offset = new_offset;
self.dirty = true;
self.mark_all_lines_dirty(); // All visible content changes when scrolling
}
self.scroll_offset
}
/// Resets viewport to show live terminal (scroll_offset = 0).
pub fn reset_scroll(&mut self) {
if self.scroll_offset != 0 {
self.scroll_offset = 0;
self.dirty = true;
self.mark_all_lines_dirty(); // All visible content changes when scrolling
}
}
/// Scroll the viewport by the given number of lines.
/// Positive values scroll up (into history), negative values scroll down (toward live).
pub fn scroll(&mut self, lines: i32) {
if lines > 0 {
self.scroll_viewport_up(lines as usize);
} else if lines < 0 {
self.scroll_viewport_down((-lines) as usize);
}
}
/// Encode a mouse event based on current tracking mode and encoding.
/// Returns the escape sequence to send to the application, or empty vec if no tracking.
pub fn encode_mouse(
&self,
button: u8,
col: u16,
row: u16,
pressed: bool,
is_motion: bool,
modifiers: u8,
) -> Vec<u8> {
// Check if we should report this event based on tracking mode
match self.mouse_tracking {
MouseTrackingMode::None => return Vec::new(),
MouseTrackingMode::X10 => {
// X10 only reports button press, not release or motion
if !pressed || is_motion {
return Vec::new();
}
}
MouseTrackingMode::Normal => {
// Normal reports press and release, not motion
if is_motion {
return Vec::new();
}
}
MouseTrackingMode::ButtonEvent => {
// Button-event reports press, release, and motion while button pressed
// The is_motion flag indicates motion events
}
MouseTrackingMode::AnyEvent => {
// Any-event reports all motion
}
}
// Build the button code
// Bits 0-1: button (0=left, 1=middle, 2=right, 3=release)
// Bit 2: shift
// Bit 3: meta/alt
// Bit 4: control
// Bits 5-6: 00=press, 01=motion with button, 10=scroll
let mut cb = button;
// Handle release
if !pressed && !is_motion {
// For SGR encoding, we keep the button number
// For X10/UTF-8 encoding, release is button 3
if self.mouse_encoding != MouseEncoding::Sgr {
cb = 3;
}
}
// Add modifiers
cb |= modifiers << 2;
// Add motion flag
if is_motion {
cb |= 32;
}
// Convert to 1-based coordinates
let col = col.saturating_add(1);
let row = row.saturating_add(1);
match self.mouse_encoding {
MouseEncoding::X10 => {
// X10 encoding: ESC [ M Cb Cx Cy
// Each value is encoded as a byte with 32 added
// Limited to 223 columns/rows
let cb = (cb + 32).min(255);
let cx = ((col as u8).min(223) + 32).min(255);
let cy = ((row as u8).min(223) + 32).min(255);
vec![0x1b, b'[', b'M', cb, cx, cy]
}
MouseEncoding::Utf8 => {
// UTF-8 encoding: ESC [ M Cb Cx Cy
// Values > 127 are UTF-8 encoded
// This is deprecated and rarely used
let cb = cb + 32;
let cx = (col as u8).saturating_add(32);
let cy = (row as u8).saturating_add(32);
vec![0x1b, b'[', b'M', cb, cx, cy]
}
MouseEncoding::Sgr => {
// SGR encoding: ESC [ < Cb ; Cx ; Cy M/m
// M for press, m for release
// Most modern and recommended format
let suffix = if pressed { b'M' } else { b'm' };
format!("\x1b[<{};{};{}{}", cb, col, row, suffix as char).into_bytes()
}
MouseEncoding::Urxvt => {
// URXVT encoding: ESC [ Cb ; Cx ; Cy M
// Similar to SGR but uses decimal with offset
let cb = cb + 32;
format!("\x1b[{};{};{}M", cb, col, row).into_bytes()
}
}
}
/// Returns the visible rows accounting for scroll offset.
/// This combines scrollback lines with the current grid.
pub fn visible_rows(&self) -> Vec<&Vec<Cell>> {
let mut rows = Vec::with_capacity(self.rows);
if self.scroll_offset == 0 {
// No scrollback viewing, just return the grid via line_map
for visual_row in 0..self.rows {
rows.push(&self.grid[self.line_map[visual_row]]);
}
} else {
// We're viewing scrollback
// scroll_offset = how many lines back we're looking
let scrollback_len = self.scrollback.len();
for i in 0..self.rows {
// Calculate which line to show
// If scroll_offset = 5, we want to show 5 lines from scrollback at the top
let lines_from_scrollback = self.scroll_offset.min(self.rows);
if i < lines_from_scrollback {
// This row comes from scrollback
// Use ring buffer's get() method with logical index
let scrollback_idx = scrollback_len - self.scroll_offset + i;
if let Some(line) = self.scrollback.get(scrollback_idx) {
rows.push(line);
} else {
// Shouldn't happen, but fall back to grid
rows.push(&self.grid[self.line_map[i]]);
}
} else {
// This row comes from the grid
let grid_visual_idx = i - lines_from_scrollback;
if grid_visual_idx < self.rows {
rows.push(&self.grid[self.line_map[grid_visual_idx]]);
}
}
}
}
rows
}
/// Inserts n blank lines at the cursor position, scrolling lines below down.
/// Uses line_map rotation for efficiency.
fn insert_lines(&mut self, n: usize) {
if self.cursor_row < self.scroll_top || self.cursor_row > self.scroll_bottom {
return;
}
let n = n.min(self.scroll_bottom - self.cursor_row + 1);
for _ in 0..n {
// Save the bottom line's grid index before rotation
let recycled_grid_row = self.line_map[self.scroll_bottom];
// Rotate line_map: shift lines from cursor to bottom down by 1
// The bottom line becomes the new line at cursor position
for i in (self.cursor_row + 1..=self.scroll_bottom).rev() {
self.line_map[i] = self.line_map[i - 1];
}
self.line_map[self.cursor_row] = recycled_grid_row;
// Clear the recycled line (now at cursor position)
self.clear_grid_row(recycled_grid_row);
// Mark affected lines dirty
for line in self.cursor_row..=self.scroll_bottom {
self.mark_line_dirty(line);
}
}
}
/// Deletes n lines at the cursor position, scrolling lines below up.
/// Uses line_map rotation for efficiency.
fn delete_lines(&mut self, n: usize) {
if self.cursor_row < self.scroll_top || self.cursor_row > self.scroll_bottom {
return;
}
let n = n.min(self.scroll_bottom - self.cursor_row + 1);
for _ in 0..n {
// Save the line at cursor's grid index before rotation
let recycled_grid_row = self.line_map[self.cursor_row];
// Rotate line_map: shift lines from cursor to bottom up by 1
// The cursor line becomes the new bottom line
for i in self.cursor_row..self.scroll_bottom {
self.line_map[i] = self.line_map[i + 1];
}
self.line_map[self.scroll_bottom] = recycled_grid_row;
// Clear the recycled line (now at bottom of scroll region)
self.clear_grid_row(recycled_grid_row);
// Mark affected lines dirty
for line in self.cursor_row..=self.scroll_bottom {
self.mark_line_dirty(line);
}
}
}
/// Inserts n blank characters at the cursor, shifting existing chars right.
fn insert_characters(&mut self, n: usize) {
let grid_row = self.line_map[self.cursor_row];
let blank = self.blank_cell();
let row = &mut self.grid[grid_row];
let n = n.min(self.cols - self.cursor_col);
// Remove n characters from the end
for _ in 0..n {
row.pop();
}
// Insert n blank characters at cursor position
for _ in 0..n {
row.insert(self.cursor_col, blank);
}
self.mark_line_dirty(self.cursor_row);
}
/// Deletes n characters at the cursor, shifting remaining chars left.
fn delete_characters(&mut self, n: usize) {
let grid_row = self.line_map[self.cursor_row];
let blank = self.blank_cell();
let row = &mut self.grid[grid_row];
let n = n.min(self.cols - self.cursor_col);
// Remove n characters at cursor position
for _ in 0..n {
if self.cursor_col < row.len() {
row.remove(self.cursor_col);
}
}
// Pad with blank characters at the end
while row.len() < self.cols {
row.push(blank);
}
self.mark_line_dirty(self.cursor_row);
}
/// Erases n characters at the cursor (replaces with spaces, doesn't shift).
fn erase_characters(&mut self, n: usize) {
let grid_row = self.line_map[self.cursor_row];
let n = n.min(self.cols - self.cursor_col);
let blank = self.blank_cell();
for i in 0..n {
if self.cursor_col + i < self.cols {
self.grid[grid_row][self.cursor_col + i] = blank;
}
}
self.mark_line_dirty(self.cursor_row);
}
/// Clears the current line from cursor to end.
fn clear_line_from_cursor(&mut self) {
let grid_row = self.line_map[self.cursor_row];
let blank = self.blank_cell();
for col in self.cursor_col..self.cols {
self.grid[grid_row][col] = blank;
}
self.mark_line_dirty(self.cursor_row);
}
/// Clears the entire screen, pushing current content to scrollback first (main screen only).
fn clear_screen(&mut self) {
// Push all visible lines to scrollback before clearing
// This preserves the content in history so the user can scroll back to see it
// BUT: Only do this for main screen, not alternate screen
// AND only if scrollback is enabled
if !self.using_alternate_screen && self.scrollback.capacity > 0 {
for visual_row in 0..self.rows {
let grid_row = self.line_map[visual_row];
// Get a slot in the ring buffer and swap content into it
let cols = self.cols;
let dest = self.scrollback.push(cols);
std::mem::swap(&mut self.grid[grid_row], dest);
}
}
// Now clear the grid with BCE
let blank = self.blank_cell();
for row in &mut self.grid {
row.fill(blank);
}
self.mark_all_lines_dirty();
self.cursor_col = 0;
self.cursor_row = 0;
}
}
impl Handler for Terminal {
/// Handle a chunk of decoded text (Unicode codepoints).
/// This includes control characters (0x00-0x1F except ESC).
fn text(&mut self, chars: &[char]) {
// Cache the current line to avoid repeated line_map lookups
let mut cached_row = self.cursor_row;
let mut grid_row = self.line_map[cached_row];
// Mark the initial line as dirty (like Kitty's init_text_loop_line)
self.mark_line_dirty(cached_row);
for &c in chars {
match c {
// Bell
'\x07' => {
// BEL - ignore for now (could trigger visual bell)
}
// Backspace
'\x08' => {
if self.cursor_col > 0 {
self.cursor_col -= 1;
}
}
// Tab
'\x09' => {
let next_tab = (self.cursor_col / 8 + 1) * 8;
self.cursor_col = next_tab.min(self.cols - 1);
}
// Line feed, Vertical tab, Form feed
'\x0A' | '\x0B' | '\x0C' => {
let old_row = self.cursor_row;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
log::trace!("LF: scrolled at row {}, now at scroll_bottom {}", old_row, self.cursor_row);
}
// Update cache after line change
cached_row = self.cursor_row;
grid_row = self.line_map[cached_row];
// Mark the new line as dirty
self.mark_line_dirty(cached_row);
}
// Carriage return
'\x0D' => {
self.cursor_col = 0;
}
// Fast path for printable ASCII (0x20-0x7E) - like Kitty
// ASCII is always width 1, never zero-width, never wide
c if c >= ' ' && c <= '~' => {
// Handle wrap
if self.cursor_col >= self.cols {
if self.auto_wrap {
self.cursor_col = 0;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
cached_row = self.cursor_row;
grid_row = self.line_map[cached_row];
self.mark_line_dirty(cached_row);
} else {
self.cursor_col = self.cols - 1;
}
}
// Write character directly - no wide char handling needed for ASCII
self.grid[grid_row][self.cursor_col] = Cell {
character: c,
fg_color: self.current_fg,
bg_color: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
wide_continuation: false,
};
self.cursor_col += 1;
}
// Slow path for non-ASCII printable characters (including all Unicode)
c if c > '~' => {
// Determine character width using Unicode Standard Annex #11
let char_width = c.width().unwrap_or(1);
// Skip zero-width characters (combining marks, etc.)
if char_width == 0 {
// TODO: Handle combining characters
continue;
}
// Handle wrap
if self.cursor_col >= self.cols {
if self.auto_wrap {
self.cursor_col = 0;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
// Update cache after line change
cached_row = self.cursor_row;
grid_row = self.line_map[cached_row];
// Mark the new line as dirty
self.mark_line_dirty(cached_row);
} else {
self.cursor_col = self.cols - 1;
}
}
// For double-width characters at end of line, wrap first
if char_width == 2 && self.cursor_col == self.cols - 1 {
if self.auto_wrap {
self.grid[grid_row][self.cursor_col] = Cell::default();
self.cursor_col = 0;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
cached_row = self.cursor_row;
grid_row = self.line_map[cached_row];
// Mark the new line as dirty
self.mark_line_dirty(cached_row);
} else {
continue; // Can't fit
}
}
// Write character directly using cached grid_row
// Safety: ensure grid row has correct width (may differ after scrollback swap)
if self.grid[grid_row].len() != self.cols {
self.grid[grid_row].resize(self.cols, Cell::default());
}
// Handle overwriting wide character cells
if self.grid[grid_row][self.cursor_col].wide_continuation && self.cursor_col > 0 {
self.grid[grid_row][self.cursor_col - 1] = Cell::default();
}
if char_width == 1 && self.cursor_col + 1 < self.cols
&& self.grid[grid_row][self.cursor_col + 1].wide_continuation {
self.grid[grid_row][self.cursor_col + 1] = Cell::default();
}
self.grid[grid_row][self.cursor_col] = Cell {
character: c,
fg_color: self.current_fg,
bg_color: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
wide_continuation: false,
};
self.cursor_col += 1;
// For double-width, write continuation cell
if char_width == 2 && self.cursor_col < self.cols {
if self.cursor_col + 1 < self.cols
&& self.grid[grid_row][self.cursor_col + 1].wide_continuation {
self.grid[grid_row][self.cursor_col + 1] = Cell::default();
}
self.grid[grid_row][self.cursor_col] = Cell {
character: c,
fg_color: self.current_fg,
bg_color: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
wide_continuation: false,
};
self.cursor_col += 1;
}
}
// Other control chars - ignore
_ => {}
}
}
// Dirty lines are marked incrementally above - no need for mark_all_lines_dirty()
}
/// Handle control characters embedded in escape sequences.
fn control(&mut self, byte: u8) {
match byte {
0x08 => {
if self.cursor_col > 0 {
self.cursor_col -= 1;
}
}
0x09 => {
let next_tab = (self.cursor_col / 8 + 1) * 8;
self.cursor_col = next_tab.min(self.cols - 1);
}
0x0A | 0x0B | 0x0C => {
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
}
0x0D => {
self.cursor_col = 0;
}
_ => {}
}
}
/// Handle a complete OSC sequence.
fn osc(&mut self, data: &[u8]) {
// Parse OSC format: "number;content" or "number;arg;content"
// Split on ';'
let parts: Vec<&[u8]> = data.splitn(3, |&b| b == b';').collect();
if parts.is_empty() {
return;
}
// First part is the OSC number
let osc_num = match std::str::from_utf8(parts[0]) {
Ok(s) => s.parse::<u32>().unwrap_or(u32::MAX),
Err(_) => return,
};
match osc_num {
// OSC 0, 1, 2 - Set window title (ignore for now)
0 | 1 | 2 => {}
// OSC 4 - Set/query indexed color
4 => {
// Format: OSC 4;index;color ST
if parts.len() >= 3 {
if let Ok(index_str) = std::str::from_utf8(parts[1]) {
if let Ok(index) = index_str.parse::<u8>() {
if let Ok(color_spec) = std::str::from_utf8(parts[2]) {
if let Some(rgb) = ColorPalette::parse_color_spec(color_spec) {
self.palette.colors[index as usize] = rgb;
log::debug!("OSC 4: Set color {} to {:?}", index, rgb);
}
}
}
}
}
}
// OSC 10 - Set/query default foreground color
10 => {
if parts.len() >= 2 {
if let Ok(color_spec) = std::str::from_utf8(parts[1]) {
if let Some(rgb) = ColorPalette::parse_color_spec(color_spec) {
self.palette.default_fg = rgb;
log::debug!("OSC 10: Set default foreground to {:?}", rgb);
}
}
}
}
// OSC 11 - Set/query default background color
11 => {
if parts.len() >= 2 {
if let Ok(color_spec) = std::str::from_utf8(parts[1]) {
if let Some(rgb) = ColorPalette::parse_color_spec(color_spec) {
self.palette.default_bg = rgb;
log::debug!("OSC 11: Set default background to {:?}", rgb);
}
}
}
}
// OSC 51 - ZTerm custom commands
// Format: OSC 51;command;args ST
// Currently supported:
// OSC 51;navigate;up/down/left/right ST - Navigate to neighboring pane
// OSC 51;statusline;<content> ST - Set custom statusline (empty to clear)
51 => {
if parts.len() >= 2 {
if let Ok(command) = std::str::from_utf8(parts[1]) {
match command {
"navigate" => {
if parts.len() >= 3 {
if let Ok(direction_str) = std::str::from_utf8(parts[2]) {
let direction = match direction_str {
"up" => Some(Direction::Up),
"down" => Some(Direction::Down),
"left" => Some(Direction::Left),
"right" => Some(Direction::Right),
_ => None,
};
if let Some(dir) = direction {
log::debug!("OSC 51: Navigate {:?}", dir);
self.command_queue.push(TerminalCommand::NavigatePane(dir));
}
}
}
}
"statusline" => {
// OSC 51;statusline;<content> ST
// If content is empty or missing, clear the statusline
// Content may be base64-encoded (prefixed with "b64:") to avoid
// escape sequence interpretation issues in the terminal
let prefix = b"51;statusline;";
let raw_content = if data.len() > prefix.len() && data.starts_with(prefix) {
std::str::from_utf8(&data[prefix.len()..]).ok().map(|s| s.to_string())
} else if parts.len() >= 3 {
std::str::from_utf8(parts[2]).ok().map(|s| s.to_string())
} else {
None
};
// Decode base64 if prefixed with "b64:"
let content = raw_content.and_then(|s| {
if let Some(encoded) = s.strip_prefix("b64:") {
use base64::Engine;
base64::engine::general_purpose::STANDARD
.decode(encoded)
.ok()
.and_then(|bytes| String::from_utf8(bytes).ok())
} else {
Some(s)
}
});
let statusline = content.filter(|s| !s.is_empty());
log::info!("OSC 51: Set statusline: {:?}", statusline.as_ref().map(|s| format!("{} bytes", s.len())));
self.command_queue.push(TerminalCommand::SetStatusline(statusline));
}
_ => {
log::debug!("OSC 51: Unknown command '{}'", command);
}
}
}
}
}
_ => {
log::debug!("Unhandled OSC {}", osc_num);
}
}
}
/// Handle an APC (Application Program Command) sequence.
/// Used for Kitty graphics protocol.
fn apc(&mut self, data: &[u8]) {
self.handle_apc(data);
}
/// Handle a DCS (Device Control String) sequence.
/// Used for pending mode (synchronized output via DCS).
fn dcs(&mut self, data: &[u8]) {
// DCS pending mode: =1s to start, =2s to stop
// This is an alternative to CSI 2026 for synchronized output
if data.len() >= 3 && data[0] == b'=' && data[2] == b's' {
match data[1] {
b'1' => {
// Start pending mode (pause rendering)
if self.synchronized_output {
log::warn!("Pending mode start requested while already in pending mode");
}
self.synchronized_output = true;
log::trace!("DCS pending mode started (=1s)");
}
b'2' => {
// Stop pending mode (resume rendering)
if !self.synchronized_output {
log::warn!("Pending mode stop requested while not in pending mode");
}
self.synchronized_output = false;
self.dirty = true; // Force a redraw
log::trace!("DCS pending mode stopped (=2s)");
}
_ => {
log::debug!("Unknown DCS pending mode command: {:?}", data);
}
}
} else {
log::debug!("Unhandled DCS sequence: {:?}",
std::str::from_utf8(data).unwrap_or("<invalid utf8>"));
}
}
/// Handle a complete CSI sequence.
fn csi(&mut self, params: &CsiParams) {
let action = params.final_char as char;
let primary = params.primary;
let secondary = params.secondary;
match action {
// Cursor Up
'A' => {
let n = params.get(0, 1).max(1) as usize;
let old_row = self.cursor_row;
self.cursor_row = self.cursor_row.saturating_sub(n);
log::trace!("CSI A: cursor up {} from row {} to {}", n, old_row, self.cursor_row);
}
// Cursor Down
'B' => {
let n = params.get(0, 1).max(1) as usize;
let old_row = self.cursor_row;
self.cursor_row = (self.cursor_row + n).min(self.rows - 1);
log::trace!("CSI B: cursor down {} from row {} to {}", n, old_row, self.cursor_row);
}
// Cursor Forward
'C' => {
let n = params.get(0, 1).max(1) as usize;
let old_col = self.cursor_col;
self.cursor_col = (self.cursor_col + n).min(self.cols - 1);
log::trace!("CSI C: cursor forward {} from col {} to {}", n, old_col, self.cursor_col);
}
// Cursor Back
'D' => {
let n = params.get(0, 1).max(1) as usize;
self.cursor_col = self.cursor_col.saturating_sub(n);
}
// Cursor Next Line (CNL)
'E' => {
let n = params.get(0, 1).max(1) as usize;
self.cursor_col = 0;
self.cursor_row = (self.cursor_row + n).min(self.rows - 1);
}
// Cursor Previous Line (CPL)
'F' => {
let n = params.get(0, 1).max(1) as usize;
self.cursor_col = 0;
self.cursor_row = self.cursor_row.saturating_sub(n);
}
// Cursor Horizontal Absolute (CHA)
'G' => {
let col = params.get(0, 1).max(1) as usize;
let old_col = self.cursor_col;
self.cursor_col = (col - 1).min(self.cols - 1);
log::trace!("CSI G: cursor to col {} (was {})", self.cursor_col, old_col);
}
// Cursor Position
'H' | 'f' => {
let row = params.get(0, 1).max(1) as usize;
let col = params.get(1, 1).max(1) as usize;
self.cursor_row = (row - 1).min(self.rows - 1);
self.cursor_col = (col - 1).min(self.cols - 1);
}
// Erase in Display
'J' => {
let mode = params.get(0, 0);
let blank = self.blank_cell();
match mode {
0 => {
// Clear from cursor to end of screen
self.clear_line_from_cursor();
for visual_row in (self.cursor_row + 1)..self.rows {
let grid_row = self.line_map[visual_row];
self.grid[grid_row].fill(blank);
self.mark_line_dirty(visual_row);
}
}
1 => {
// Clear from start to cursor
for visual_row in 0..self.cursor_row {
let grid_row = self.line_map[visual_row];
self.grid[grid_row].fill(blank);
self.mark_line_dirty(visual_row);
}
let cursor_grid_row = self.line_map[self.cursor_row];
for col in 0..=self.cursor_col {
self.grid[cursor_grid_row][col] = blank;
}
self.mark_line_dirty(self.cursor_row);
}
2 | 3 => {
// Clear entire screen
self.clear_screen();
}
_ => {}
}
}
// Erase in Line
'K' => {
let mode = params.get(0, 0);
let blank = self.blank_cell();
match mode {
0 => self.clear_line_from_cursor(),
1 => {
let grid_row = self.line_map[self.cursor_row];
for col in 0..=self.cursor_col {
self.grid[grid_row][col] = blank;
}
self.mark_line_dirty(self.cursor_row);
}
2 => {
let grid_row = self.line_map[self.cursor_row];
self.grid[grid_row].fill(blank);
self.mark_line_dirty(self.cursor_row);
}
_ => {}
}
}
// Insert Lines (IL)
'L' => {
let n = params.get(0, 1).max(1) as usize;
self.insert_lines(n);
}
// Delete Lines (DL)
'M' => {
let n = params.get(0, 1).max(1) as usize;
self.delete_lines(n);
}
// Delete Characters (DCH)
'P' => {
let n = params.get(0, 1).max(1) as usize;
self.delete_characters(n);
}
// Scroll Up (SU)
'S' => {
let n = params.get(0, 1).max(1) as usize;
self.scroll_up(n);
}
// Scroll Down (SD)
'T' => {
let n = params.get(0, 1).max(1) as usize;
self.scroll_down(n);
}
// Erase Characters (ECH)
'X' => {
let n = params.get(0, 1).max(1) as usize;
self.erase_characters(n);
}
// Insert Characters (ICH)
'@' => {
let n = params.get(0, 1).max(1) as usize;
self.insert_characters(n);
}
// Repeat preceding character (REP)
'b' => {
let n = params.get(0, 1).max(1) as usize;
if self.cursor_col > 0 {
let grid_row = self.line_map[self.cursor_row];
let last_char = self.grid[grid_row][self.cursor_col - 1].character;
for _ in 0..n {
self.print_char(last_char);
}
}
}
// Device Attributes (DA)
'c' => {
if primary == 0 || primary == b'?' {
// Primary DA - respond as VT220
self.response_queue.extend_from_slice(b"\x1b[?62;c");
} else if primary == b'>' {
// Secondary DA - respond with terminal version
self.response_queue.extend_from_slice(b"\x1b[>0;0;0c");
}
}
// Vertical Position Absolute (VPA)
'd' => {
let row = params.get(0, 1).max(1) as usize;
self.cursor_row = (row - 1).min(self.rows - 1);
}
// SGR (Select Graphic Rendition)
'm' => {
self.handle_sgr(params);
}
// Device Status Report (DSR)
'n' => {
let param = params.get(0, 0);
match param {
5 => {
// Status report - respond with "OK"
self.response_queue.extend_from_slice(b"\x1b[0n");
}
6 => {
// Cursor position report
let response = format!("\x1b[{};{}R", self.cursor_row + 1, self.cursor_col + 1);
self.response_queue.extend_from_slice(response.as_bytes());
}
_ => {}
}
}
// DECSCUSR - Set Cursor Style (CSI Ps SP q)
// Also handle CSI q (no space) as reset to default
'q' => {
if secondary == b' ' || secondary == 0 {
let style = params.get(0, 0);
self.cursor_shape = match style {
0 | 1 => CursorShape::BlinkingBlock,
2 => CursorShape::SteadyBlock,
3 => CursorShape::BlinkingUnderline,
4 => CursorShape::SteadyUnderline,
5 => CursorShape::BlinkingBar,
6 => CursorShape::SteadyBar,
_ => CursorShape::BlinkingBlock,
};
}
}
// Set Scrolling Region (DECSTBM)
'r' => {
let top = params.get(0, 1).max(1) as usize;
let bottom = params.get(1, self.rows as i32).max(1) as usize;
self.scroll_top = (top - 1).min(self.rows - 1);
self.scroll_bottom = (bottom - 1).min(self.rows - 1);
if self.scroll_top > self.scroll_bottom {
std::mem::swap(&mut self.scroll_top, &mut self.scroll_bottom);
}
// Move cursor to home position
self.cursor_row = 0;
self.cursor_col = 0;
}
// Window manipulation (CSI Ps t) - XTWINOPS
't' => {
let ps = params.get(0, 0);
match ps {
14 => {
// Report text area size in pixels: CSI 4 ; height ; width t
let pixel_height = (self.rows as f32 * self.cell_height) as u32;
let pixel_width = (self.cols as f32 * self.cell_width) as u32;
let response = format!("\x1b[4;{};{}t", pixel_height, pixel_width);
self.response_queue.extend_from_slice(response.as_bytes());
log::debug!("XTWINOPS 14: Reported text area size {}x{} pixels", pixel_width, pixel_height);
}
16 => {
// Report cell size in pixels: CSI 6 ; height ; width t
let cell_h = self.cell_height as u32;
let cell_w = self.cell_width as u32;
let response = format!("\x1b[6;{};{}t", cell_h, cell_w);
self.response_queue.extend_from_slice(response.as_bytes());
log::debug!("XTWINOPS 16: Reported cell size {}x{} pixels", cell_w, cell_h);
}
18 => {
// Report text area size in characters: CSI 8 ; rows ; cols t
let response = format!("\x1b[8;{};{}t", self.rows, self.cols);
self.response_queue.extend_from_slice(response.as_bytes());
log::debug!("XTWINOPS 18: Reported text area size {}x{} chars", self.cols, self.rows);
}
22 | 23 => {
// Save/restore window title - ignore
}
_ => {
log::trace!("Window manipulation: ps={}", ps);
}
}
}
// Kitty keyboard protocol
'u' => {
self.handle_keyboard_protocol_csi(params);
}
// DEC Private Mode Set (CSI ? Ps h)
'h' if primary == b'?' => {
self.handle_dec_private_mode_set(params);
}
// DEC Private Mode Reset (CSI ? Ps l)
'l' if primary == b'?' => {
self.handle_dec_private_mode_reset(params);
}
_ => {
log::debug!(
"Unhandled CSI: action='{}' primary={} secondary={} params={:?}",
action, primary, secondary, &params.params[..params.num_params]
);
}
}
}
fn save_cursor(&mut self) {
self.saved_cursor = SavedCursor {
col: self.cursor_col,
row: self.cursor_row,
fg: self.current_fg,
bg: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
};
log::debug!("ESC 7: Cursor saved at ({}, {})", self.cursor_col, self.cursor_row);
}
fn restore_cursor(&mut self) {
self.cursor_col = self.saved_cursor.col.min(self.cols.saturating_sub(1));
self.cursor_row = self.saved_cursor.row.min(self.rows.saturating_sub(1));
self.current_fg = self.saved_cursor.fg;
self.current_bg = self.saved_cursor.bg;
self.current_bold = self.saved_cursor.bold;
self.current_italic = self.saved_cursor.italic;
self.current_underline_style = self.saved_cursor.underline_style;
self.current_strikethrough = self.saved_cursor.strikethrough;
log::debug!("ESC 8: Cursor restored to ({}, {})", self.cursor_col, self.cursor_row);
}
fn reset(&mut self) {
self.current_fg = Color::Default;
self.current_bg = Color::Default;
self.current_bold = false;
self.current_italic = false;
self.current_underline_style = 0;
self.current_strikethrough = false;
self.cursor_col = 0;
self.cursor_row = 0;
self.cursor_visible = true;
self.cursor_shape = CursorShape::default();
self.scroll_top = 0;
self.scroll_bottom = self.rows.saturating_sub(1);
self.mouse_tracking = MouseTrackingMode::None;
self.mouse_encoding = MouseEncoding::X10;
self.application_cursor_keys = false;
self.auto_wrap = true;
self.bracketed_paste = false;
self.focus_reporting = false;
self.synchronized_output = false;
if self.using_alternate_screen {
self.leave_alternate_screen();
}
for row in &mut self.grid {
for cell in row {
*cell = Cell::default();
}
}
self.mark_all_lines_dirty();
log::debug!("ESC c: Full terminal reset");
}
fn index(&mut self) {
if self.cursor_row >= self.scroll_bottom {
self.scroll_up(1);
} else {
self.cursor_row += 1;
}
}
fn newline(&mut self) {
self.cursor_col = 0;
if self.cursor_row >= self.scroll_bottom {
self.scroll_up(1);
} else {
self.cursor_row += 1;
}
}
fn reverse_index(&mut self) {
if self.cursor_row <= self.scroll_top {
self.scroll_down(1);
} else {
self.cursor_row -= 1;
}
}
fn set_tab_stop(&mut self) {
// HTS - default tab stops every 8 columns
}
fn set_keypad_mode(&mut self, application: bool) {
if application {
log::debug!("ESC =: Application keypad mode");
} else {
log::debug!("ESC >: Normal keypad mode");
}
}
fn designate_charset(&mut self, _set: u8, _charset: u8) {
// UTF-8 internally, no-op
}
fn screen_alignment(&mut self) {
for visual_row in 0..self.rows {
let grid_row = self.line_map[visual_row];
for cell in &mut self.grid[grid_row] {
*cell = Cell {
character: 'E',
fg_color: Color::Default,
bg_color: Color::Default,
bold: false,
italic: false,
underline_style: 0,
strikethrough: false,
wide_continuation: false,
};
}
self.mark_line_dirty(visual_row);
}
}
}
impl Terminal {
/// Print a single character at the cursor position.
/// Handles double-width characters (emoji, CJK) by occupying two cells.
#[inline]
fn print_char(&mut self, c: char) {
// Determine character width using Unicode Standard Annex #11
// Width 2 = double-width (emoji, CJK, etc.)
// Width 1 = normal width
// Width 0 = combining/non-spacing marks (handled separately)
let char_width = c.width().unwrap_or(1);
// Skip zero-width characters (combining marks, etc.)
if char_width == 0 {
// TODO: Handle combining characters by attaching to previous cell
return;
}
// Check if we need to wrap before printing
if self.cursor_col >= self.cols {
if self.auto_wrap {
self.cursor_col = 0;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
} else {
self.cursor_col = self.cols - 1;
}
}
// For double-width characters, check if there's room
// If at the last column, we need to wrap first
if char_width == 2 && self.cursor_col == self.cols - 1 {
if self.auto_wrap {
// Write a space in the last column and wrap
let grid_row = self.line_map[self.cursor_row];
self.grid[grid_row][self.cursor_col] = Cell::default();
self.cursor_col = 0;
self.cursor_row += 1;
if self.cursor_row > self.scroll_bottom {
self.scroll_up(1);
self.cursor_row = self.scroll_bottom;
}
} else {
// Can't fit, don't print
return;
}
}
let grid_row = self.line_map[self.cursor_row];
// If we're overwriting a wide character's continuation cell,
// we need to clear the first cell of that wide character
if self.grid[grid_row][self.cursor_col].wide_continuation && self.cursor_col > 0 {
self.grid[grid_row][self.cursor_col - 1] = Cell::default();
}
// If we're overwriting the first cell of a wide character,
// we need to clear its continuation cell
if char_width == 1 && self.cursor_col + 1 < self.cols
&& self.grid[grid_row][self.cursor_col + 1].wide_continuation {
self.grid[grid_row][self.cursor_col + 1] = Cell::default();
}
// Write the character to the first cell
self.grid[grid_row][self.cursor_col] = Cell {
character: c,
fg_color: self.current_fg,
bg_color: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
wide_continuation: false,
};
self.mark_line_dirty(self.cursor_row);
self.cursor_col += 1;
// For double-width characters, write a continuation marker to the second cell
if char_width == 2 && self.cursor_col < self.cols {
// If the next cell is the first cell of another wide character,
// clear its continuation cell
if self.cursor_col + 1 < self.cols
&& self.grid[grid_row][self.cursor_col + 1].wide_continuation {
self.grid[grid_row][self.cursor_col + 1] = Cell::default();
}
self.grid[grid_row][self.cursor_col] = Cell {
character: ' ', // Placeholder - renderer will skip this
fg_color: self.current_fg,
bg_color: self.current_bg,
bold: self.current_bold,
italic: self.current_italic,
underline_style: self.current_underline_style,
strikethrough: self.current_strikethrough,
wide_continuation: true,
};
self.cursor_col += 1;
}
}
/// Handle SGR (Select Graphic Rendition) parameters.
fn handle_sgr(&mut self, params: &CsiParams) {
if params.num_params == 0 {
self.current_fg = Color::Default;
self.current_bg = Color::Default;
self.current_bold = false;
self.current_italic = false;
self.current_underline_style = 0;
self.current_strikethrough = false;
return;
}
let mut i = 0;
while i < params.num_params {
let code = params.params[i];
match code {
0 => {
self.current_fg = Color::Default;
self.current_bg = Color::Default;
self.current_bold = false;
self.current_italic = false;
self.current_underline_style = 0;
self.current_strikethrough = false;
}
1 => self.current_bold = true,
3 => self.current_italic = true,
4 => {
// Check for sub-parameter (4:x format for underline style)
if i + 1 < params.num_params && params.is_sub_param[i + 1] {
let style = params.params[i + 1];
// 0=none, 1=single, 2=double, 3=curly, 4=dotted, 5=dashed
self.current_underline_style = (style as u8).min(5);
i += 1;
} else {
// Plain SGR 4 = single underline
self.current_underline_style = 1;
}
}
7 => std::mem::swap(&mut self.current_fg, &mut self.current_bg),
9 => self.current_strikethrough = true,
22 => self.current_bold = false,
23 => self.current_italic = false,
24 => self.current_underline_style = 0,
27 => std::mem::swap(&mut self.current_fg, &mut self.current_bg),
29 => self.current_strikethrough = false,
30..=37 => self.current_fg = Color::Indexed((code - 30) as u8),
38 => {
// Extended foreground color
if i + 1 < params.num_params && params.is_sub_param[i + 1] {
let mode = params.params[i + 1];
if mode == 5 && i + 2 < params.num_params {
self.current_fg = Color::Indexed(params.params[i + 2] as u8);
i += 2;
} else if mode == 2 && i + 4 < params.num_params {
self.current_fg = Color::Rgb(
params.params[i + 2] as u8,
params.params[i + 3] as u8,
params.params[i + 4] as u8,
);
i += 4;
}
} else if i + 2 < params.num_params {
let mode = params.params[i + 1];
if mode == 5 {
self.current_fg = Color::Indexed(params.params[i + 2] as u8);
i += 2;
} else if mode == 2 && i + 4 < params.num_params {
self.current_fg = Color::Rgb(
params.params[i + 2] as u8,
params.params[i + 3] as u8,
params.params[i + 4] as u8,
);
i += 4;
}
}
}
39 => self.current_fg = Color::Default,
40..=47 => self.current_bg = Color::Indexed((code - 40) as u8),
48 => {
// Extended background color
if i + 1 < params.num_params && params.is_sub_param[i + 1] {
let mode = params.params[i + 1];
if mode == 5 && i + 2 < params.num_params {
self.current_bg = Color::Indexed(params.params[i + 2] as u8);
i += 2;
} else if mode == 2 && i + 4 < params.num_params {
self.current_bg = Color::Rgb(
params.params[i + 2] as u8,
params.params[i + 3] as u8,
params.params[i + 4] as u8,
);
i += 4;
}
} else if i + 2 < params.num_params {
let mode = params.params[i + 1];
if mode == 5 {
self.current_bg = Color::Indexed(params.params[i + 2] as u8);
i += 2;
} else if mode == 2 && i + 4 < params.num_params {
self.current_bg = Color::Rgb(
params.params[i + 2] as u8,
params.params[i + 3] as u8,
params.params[i + 4] as u8,
);
i += 4;
}
}
}
49 => self.current_bg = Color::Default,
90..=97 => self.current_fg = Color::Indexed((code - 90 + 8) as u8),
100..=107 => self.current_bg = Color::Indexed((code - 100 + 8) as u8),
_ => {}
}
i += 1;
}
}
/// Handle Kitty keyboard protocol CSI sequences.
fn handle_keyboard_protocol_csi(&mut self, params: &CsiParams) {
match params.primary {
b'?' => {
let response = query_response(self.keyboard.flags());
self.response_queue.extend(response);
}
b'=' => {
let flags = params.get(0, 0) as u8;
let mode = params.get(1, 1) as u8;
self.keyboard.set_flags(flags, mode);
log::debug!("Keyboard flags set to {:?} (mode {})", self.keyboard.flags(), mode);
}
b'>' => {
let flags = if params.num_params == 0 {
None
} else {
Some(params.params[0] as u8)
};
self.keyboard.push(flags);
log::debug!("Keyboard flags pushed: {:?}", self.keyboard.flags());
}
b'<' => {
let count = params.get(0, 1) as usize;
self.keyboard.pop(count);
log::debug!("Keyboard flags popped: {:?}", self.keyboard.flags());
}
_ => {}
}
}
/// Handle DEC private mode set (CSI ? Ps h).
fn handle_dec_private_mode_set(&mut self, params: &CsiParams) {
for i in 0..params.num_params {
match params.params[i] {
1 => {
self.application_cursor_keys = true;
log::debug!("DECCKM: Application cursor keys enabled");
}
7 => {
self.auto_wrap = true;
log::debug!("DECAWM: Auto-wrap enabled");
}
9 => {
self.mouse_tracking = MouseTrackingMode::X10;
log::debug!("Mouse tracking: X10 mode enabled");
}
25 => {
self.cursor_visible = true;
log::debug!("DECTCEM: cursor visible");
}
47 => self.enter_alternate_screen(),
1000 => {
self.mouse_tracking = MouseTrackingMode::Normal;
log::debug!("Mouse tracking: Normal mode enabled");
}
1002 => {
self.mouse_tracking = MouseTrackingMode::ButtonEvent;
log::debug!("Mouse tracking: Button-event mode enabled");
}
1003 => {
self.mouse_tracking = MouseTrackingMode::AnyEvent;
log::debug!("Mouse tracking: Any-event mode enabled");
}
1004 => {
self.focus_reporting = true;
log::debug!("Focus event reporting enabled");
}
1005 => {
self.mouse_encoding = MouseEncoding::Utf8;
log::debug!("Mouse encoding: UTF-8");
}
1006 => {
self.mouse_encoding = MouseEncoding::Sgr;
log::debug!("Mouse encoding: SGR");
}
1015 => {
self.mouse_encoding = MouseEncoding::Urxvt;
log::debug!("Mouse encoding: URXVT");
}
1047 => self.enter_alternate_screen(),
1048 => Handler::save_cursor(self),
1049 => {
Handler::save_cursor(self);
self.enter_alternate_screen();
}
2004 => {
self.bracketed_paste = true;
log::debug!("Bracketed paste mode enabled");
}
2026 => {
self.synchronized_output = true;
log::trace!("Synchronized output enabled");
}
_ => log::debug!("Unhandled DEC private mode set: {}", params.params[i]),
}
}
}
/// Handle DEC private mode reset (CSI ? Ps l).
fn handle_dec_private_mode_reset(&mut self, params: &CsiParams) {
for i in 0..params.num_params {
match params.params[i] {
1 => {
self.application_cursor_keys = false;
log::debug!("DECCKM: Normal cursor keys enabled");
}
7 => {
self.auto_wrap = false;
log::debug!("DECAWM: Auto-wrap disabled");
}
9 => {
if self.mouse_tracking == MouseTrackingMode::X10 {
self.mouse_tracking = MouseTrackingMode::None;
log::debug!("Mouse tracking: X10 mode disabled");
}
}
25 => {
self.cursor_visible = false;
log::debug!("DECTCEM: cursor hidden");
}
47 => self.leave_alternate_screen(),
1000 => {
if self.mouse_tracking == MouseTrackingMode::Normal {
self.mouse_tracking = MouseTrackingMode::None;
log::debug!("Mouse tracking: Normal mode disabled");
}
}
1002 => {
if self.mouse_tracking == MouseTrackingMode::ButtonEvent {
self.mouse_tracking = MouseTrackingMode::None;
log::debug!("Mouse tracking: Button-event mode disabled");
}
}
1003 => {
if self.mouse_tracking == MouseTrackingMode::AnyEvent {
self.mouse_tracking = MouseTrackingMode::None;
log::debug!("Mouse tracking: Any-event mode disabled");
}
}
1004 => {
self.focus_reporting = false;
log::debug!("Focus event reporting disabled");
}
1005 => {
if self.mouse_encoding == MouseEncoding::Utf8 {
self.mouse_encoding = MouseEncoding::X10;
log::debug!("Mouse encoding: reset to X10");
}
}
1006 => {
if self.mouse_encoding == MouseEncoding::Sgr {
self.mouse_encoding = MouseEncoding::X10;
log::debug!("Mouse encoding: reset to X10");
}
}
1015 => {
if self.mouse_encoding == MouseEncoding::Urxvt {
self.mouse_encoding = MouseEncoding::X10;
log::debug!("Mouse encoding: reset to X10");
}
}
1047 => self.leave_alternate_screen(),
1048 => Handler::restore_cursor(self),
1049 => {
self.leave_alternate_screen();
Handler::restore_cursor(self);
}
2004 => {
self.bracketed_paste = false;
log::debug!("Bracketed paste mode disabled");
}
2026 => {
self.synchronized_output = false;
log::trace!("Synchronized output disabled");
}
_ => log::debug!("Unhandled DEC private mode reset: {}", params.params[i]),
}
}
}
/// Set cell dimensions (called by renderer after font metrics are calculated).
pub fn set_cell_size(&mut self, width: f32, height: f32) {
self.cell_width = width;
self.cell_height = height;
}
/// Handle an APC (Application Program Command) sequence.
/// This is used for the Kitty graphics protocol.
fn handle_apc(&mut self, data: &[u8]) {
// Kitty graphics protocol: APC starts with 'G'
if let Some(cmd) = GraphicsCommand::parse(data) {
log::debug!(
"Graphics command: action={:?} format={:?} id={:?} size={}x{:?} C={} U={}",
cmd.action,
cmd.format,
cmd.image_id,
cmd.width.unwrap_or(0),
cmd.height,
cmd.cursor_movement,
cmd.unicode_placeholder
);
// Convert cursor_row to absolute row (accounting for scrollback)
// This allows images to scroll with terminal content
let absolute_row = self.scrollback.len() + self.cursor_row;
// Process the command
let (response, placement_result) = self.image_storage.process_command(
cmd,
self.cursor_col,
absolute_row,
self.cell_width,
self.cell_height,
);
// Queue the response to send back to the application
if let Some(resp) = response {
self.response_queue.extend_from_slice(resp.as_bytes());
}
// Move cursor after image placement per Kitty protocol spec:
// "After placing an image on the screen the cursor must be moved to the
// right by the number of cols in the image placement rectangle and down
// by the number of rows in the image placement rectangle."
// However, if C=1 was specified, don't move the cursor.
if let Some(placement) = placement_result {
if !placement.suppress_cursor_move && !placement.virtual_placement {
// Move cursor down by (rows - 1) since we're already on the first row
// Then set cursor to the column after the image
let new_row = self.cursor_row + placement.rows.saturating_sub(1);
if new_row >= self.rows {
// Need to scroll
let scroll_amount = new_row - self.rows + 1;
self.scroll_up(scroll_amount);
self.cursor_row = self.rows - 1;
} else {
self.cursor_row = new_row;
}
// Move cursor to after the image (or stay at column 0 of next line)
// Per protocol, cursor ends at the last row of the image
log::debug!(
"Cursor moved after image placement: row={} (moved {} rows)",
self.cursor_row, placement.rows.saturating_sub(1)
);
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink