use ratatui::style::Style;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Cell {
pub ch: char,
pub style: Style,
}
impl Default for Cell {
fn default() -> Self {
Cell {
ch: ' ',
style: Style::default(),
}
}
}
#[derive(Debug, Clone)]
pub struct TermGrid {
rows: Vec<Vec<Cell>>,
scrollback_cap: usize,
visible: usize,
cols: usize,
cursor_row: usize,
cursor_col: usize,
view_offset: usize,
}
impl TermGrid {
pub fn new(cols: usize, rows: usize) -> Self {
Self::scrollback(cols, rows, 0)
}
pub fn scrollback(cols: usize, visible: usize, scrollback_cap: usize) -> Self {
TermGrid {
rows: vec![vec![Cell::default(); cols]; visible],
scrollback_cap,
visible,
cols,
cursor_row: 0,
cursor_col: 0,
view_offset: 0,
}
}
pub fn rows(&self) -> usize {
self.visible
}
pub fn cols(&self) -> usize {
self.cols
}
pub fn cursor(&self) -> (usize, usize) {
(
self.cursor_row.saturating_sub(self.scrollback_len()),
self.cursor_col,
)
}
pub fn cursor_in_view(&self) -> Option<usize> {
let rel = self.cursor_row as i64 - self.view_start() as i64;
if rel >= 0 && (rel as usize) < self.visible {
Some(rel as usize)
} else {
None
}
}
pub fn scrollback_len(&self) -> usize {
self.rows.len().saturating_sub(self.visible)
}
pub fn scroll_offset(&self) -> usize {
self.view_offset
}
pub fn scroll_viewport(&mut self, delta: i64) {
let max = self.scrollback_len() as i64;
self.view_offset = (self.view_offset as i64 + delta).clamp(0, max) as usize;
}
pub fn reset_viewport(&mut self) {
self.view_offset = 0;
}
fn view_start(&self) -> usize {
self.rows
.len()
.saturating_sub(self.visible + self.view_offset)
}
pub fn cell(&self, row: usize, col: usize) -> Option<&Cell> {
let abs = row + self.view_start();
self.rows.get(abs).and_then(|r| r.get(col))
}
pub fn put(&mut self, ch: char, style: Style) {
if self.cols == 0 || self.visible == 0 {
return;
}
if self.cursor_col >= self.cols {
self.cursor_col = 0;
self.cursor_row += 1;
}
self.ensure_cursor_row();
let row = &mut self.rows[self.cursor_row];
row[self.cursor_col] = Cell { ch, style };
self.cursor_col += 1;
}
pub fn linefeed(&mut self) {
if self.visible == 0 {
return;
}
self.cursor_row += 1;
self.ensure_cursor_row();
}
pub fn newline(&mut self) {
self.linefeed();
self.cursor_col = 0;
}
pub fn carriage_return(&mut self) {
self.cursor_col = 0;
}
#[allow(dead_code)]
pub fn backspace(&mut self) {
self.cursor_col = self.cursor_col.saturating_sub(1);
}
pub fn tab(&mut self) {
if self.cols == 0 {
return;
}
let next = (self.cursor_col / 8 + 1) * 8;
if next >= self.cols {
self.cursor_col = 0;
self.newline();
} else {
self.cursor_col = next;
}
}
pub fn scroll_up(&mut self, n: usize) {
let before_len = self.rows.len();
for _ in 0..n {
if self.rows.len() >= self.scrollback_cap + self.visible {
self.rows.remove(0);
self.cursor_row = self.cursor_row.saturating_sub(1);
}
self.rows.push(vec![Cell::default(); self.cols]);
}
if self.view_offset > 0 {
self.view_offset += self.rows.len() - before_len;
}
}
pub fn resize(&mut self, cols: usize, visible: usize) {
for row in &mut self.rows {
row.resize(cols, Cell::default());
}
while self.rows.len() < visible {
self.rows.push(vec![Cell::default(); cols]);
}
self.cols = cols;
self.visible = visible;
self.view_offset = self.view_offset.min(self.scrollback_len());
let base = self.scrollback_len();
self.cursor_row = self.cursor_row.min(base + visible.saturating_sub(1));
self.cursor_col = self.cursor_col.min(cols.saturating_sub(1));
}
pub fn move_to(&mut self, row: usize, col: usize) {
let base = self.scrollback_len();
self.cursor_row = (base + row).min(base + self.visible.saturating_sub(1));
self.cursor_col = col.min(self.cols.saturating_sub(1));
}
pub fn move_cursor(&mut self, drow: i64, dcol: i64) {
let base = self.scrollback_len() as i64;
let row = (self.cursor_row as i64 + drow).clamp(base, base + self.visible as i64 - 1);
self.cursor_row = row as usize;
self.cursor_col = (self.cursor_col as i64 + dcol).clamp(0, self.cols as i64 - 1) as usize;
}
pub fn erase_in_display(&mut self, mode: u16) {
let start = self.scrollback_len();
let (fr, to) = match mode {
0 => (self.cursor_row, self.rows.len()),
1 => (start, self.cursor_row + 1),
2 | 3 => (start, self.rows.len()),
_ => return,
};
for row in self.rows.iter_mut().take(to).skip(fr) {
for cell in row.iter_mut() {
*cell = Cell::default();
}
}
if mode == 3 {
let visible_rows: Vec<Vec<Cell>> = self.rows.drain(start..).collect();
self.rows = visible_rows;
self.view_offset = 0;
}
}
pub fn erase_in_line(&mut self, mode: u16) {
let (fr, to) = match mode {
0 => (self.cursor_col, self.cols),
1 => (0, (self.cursor_col + 1).min(self.cols)),
2 => (0, self.cols),
_ => return,
};
if let Some(row) = self.rows.get_mut(self.cursor_row) {
for cell in row.iter_mut().take(to).skip(fr) {
*cell = Cell::default();
}
}
}
pub fn text_projection(&self) -> Vec<String> {
let start = self.view_start();
let end = (start + self.visible).min(self.rows.len());
self.rows[start..end]
.iter()
.map(|r| {
let s: String = r.iter().map(|c| c.ch).collect();
s.trim_end().to_string()
})
.collect()
}
fn ensure_cursor_row(&mut self) {
if self.visible == 0 {
return;
}
let last = self.scrollback_len() + self.visible - 1;
if self.cursor_row > last {
self.scroll_up(self.cursor_row - last);
self.cursor_row = self.scrollback_len() + self.visible - 1;
}
}
}
#[cfg(test)]
impl TermGrid {
fn visible_rows_hint(&self) -> usize {
self.visible
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_grid_has_default_cells() {
let g = TermGrid::new(4, 2);
assert_eq!(g.rows(), 2);
assert_eq!(g.cols(), 4);
assert_eq!(g.cell(0, 0), Some(&Cell::default()));
assert_eq!(g.cursor(), (0, 0));
}
#[test]
fn put_advances_cursor_and_wraps() {
let mut g = TermGrid::new(4, 2);
for ch in "ABCDE".chars() {
g.put(ch, Style::default());
}
assert_eq!(g.cursor(), (1, 1));
assert_eq!(g.cell(0, 0).unwrap().ch, 'A');
assert_eq!(g.cell(1, 0).unwrap().ch, 'E');
}
#[test]
fn newline_and_linefeed() {
let mut g = TermGrid::new(4, 2);
g.put('x', Style::default());
g.put('y', Style::default());
g.newline();
assert_eq!(g.cursor(), (1, 0));
g.put('z', Style::default());
g.linefeed(); assert_eq!(g.cursor(), (1, 1));
}
#[test]
fn viewport_offset_clamps_and_resets() {
let mut g = TermGrid::scrollback(4, 2, 10);
for i in 0..6u8 {
g.put(char::from(b'0' + i), Style::default());
g.newline();
}
assert_eq!(g.scrollback_len(), 5);
g.scroll_viewport(100); assert_eq!(g.scroll_offset(), 5);
g.scroll_viewport(-100); assert_eq!(g.scroll_offset(), 0);
g.scroll_viewport(3);
g.reset_viewport();
assert_eq!(g.scroll_offset(), 0);
}
#[test]
fn viewport_anchors_while_output_arrives() {
let mut g = TermGrid::scrollback(4, 2, 100);
for i in 0..6u8 {
g.put(char::from(b'0' + i), Style::default());
g.newline();
}
g.scroll_viewport(5); g.put('x', Style::default());
g.newline();
g.put('y', Style::default());
g.newline();
assert_eq!(
g.scroll_offset(),
7,
"offset grows with new rows (anchored)"
);
assert_eq!(
g.cell(0, 0).unwrap().ch,
'0',
"top visible row is still the oldest"
);
}
#[test]
fn cursor_hidden_when_viewport_in_history() {
let mut g = TermGrid::scrollback(4, 2, 100);
for i in 0..6u8 {
g.put(char::from(b'0' + i), Style::default());
g.newline();
}
assert!(g.cursor_in_view().is_some(), "live view shows the cursor");
g.scroll_viewport(3);
assert!(
g.cursor_in_view().is_none(),
"history view hides the cursor"
);
}
#[test]
fn writing_past_bottom_scrolls() {
let mut g = TermGrid::scrollback(4, 2, 10);
for i in 0..6u8 {
g.put(char::from(b'0' + i), Style::default());
g.newline();
}
assert_eq!(g.visible_rows_hint(), 2);
assert_eq!(g.scrollback_len(), 5);
assert_eq!(g.cell(0, 0).unwrap().ch, '5');
assert_eq!(g.cell(1, 0).unwrap().ch, ' ');
}
#[test]
fn text_projection_trims_trailing_spaces() {
let mut g = TermGrid::new(4, 2);
g.put('h', Style::default());
g.put('i', Style::default());
assert_eq!(g.text_projection(), vec!["hi".to_string(), String::new()]);
let empty = TermGrid::new(4, 2);
assert_eq!(empty.text_projection(), vec![String::new(), String::new()]);
}
#[test]
fn erase_in_display_clears_screen_keeps_cursor() {
let mut g = TermGrid::new(4, 2);
g.put('a', Style::default());
g.put('b', Style::default());
g.erase_in_display(2);
assert_eq!(g.text_projection(), vec![String::new(), String::new()]);
assert_eq!(g.cursor(), (0, 2));
}
#[test]
fn move_cursor_clamps_to_visible_area() {
let mut g = TermGrid::new(10, 3);
g.move_cursor(99, 0); assert_eq!(g.cursor(), (2, 0));
g.move_cursor(0, 99); assert_eq!(g.cursor(), (2, 9));
g.move_cursor(-99, -99); assert_eq!(g.cursor(), (0, 0));
}
#[test]
fn tab_advances_to_multiple_of_eight() {
let mut g = TermGrid::new(20, 2);
g.tab();
assert_eq!(g.cursor(), (0, 8));
g.tab();
assert_eq!(g.cursor(), (0, 16));
}
#[test]
fn erase_in_line_modes() {
let mut g = TermGrid::new(10, 1);
for ch in "0123456789".chars() {
g.put(ch, Style::default());
}
g.carriage_return();
g.move_cursor(0, 5);
g.erase_in_line(0); assert_eq!(g.text_projection(), vec!["01234".to_string()]);
g.erase_in_line(2); assert_eq!(g.text_projection(), vec![String::new()]);
}
}