aboutsummaryrefslogtreecommitdiffstats
path: root/src/panes
diff options
context:
space:
mode:
authordenis <denismaximov98@gmail.com>2021-01-24 18:38:46 +0200
committerdenis <denismaximov98@gmail.com>2021-01-24 18:38:46 +0200
commitb23ef332c7531b8e9bb202bd25e7f37fd157c22c (patch)
tree2ad09a6173e8528a91c37609e00c59d9b8a0b04b /src/panes
parentMerge branch 'main' into server-client (diff)
downloadsl0ppij-b23ef332c7531b8e9bb202bd25e7f37fd157c22c.tar.gz
sl0ppij-b23ef332c7531b8e9bb202bd25e7f37fd157c22c.tar.xz
sl0ppij-b23ef332c7531b8e9bb202bd25e7f37fd157c22c.zip
wip: restructing in progress, to prep for server-client
Diffstat (limited to 'src/panes')
-rw-r--r--src/panes/grid.rs820
-rw-r--r--src/panes/mod.rs9
-rw-r--r--src/panes/plugin_pane.rs175
-rw-r--r--src/panes/terminal_character.rs572
-rw-r--r--src/panes/terminal_pane.rs664
5 files changed, 0 insertions, 2240 deletions
diff --git a/src/panes/grid.rs b/src/panes/grid.rs
deleted file mode 100644
index 062b5c3a..00000000
--- a/src/panes/grid.rs
+++ /dev/null
@@ -1,820 +0,0 @@
-use std::{
- cmp::Ordering,
- fmt::{self, Debug, Formatter},
-};
-
-use crate::panes::terminal_character::{
- CharacterStyles, TerminalCharacter, EMPTY_TERMINAL_CHARACTER,
-};
-
-fn get_top_non_canonical_rows(rows: &mut Vec<Row>) -> Vec<Row> {
- let mut index_of_last_non_canonical_row = None;
- for (i, row) in rows.iter().enumerate() {
- if row.is_canonical {
- break;
- } else {
- index_of_last_non_canonical_row = Some(i);
- }
- }
- match index_of_last_non_canonical_row {
- Some(index_of_last_non_canonical_row) => {
- rows.drain(..=index_of_last_non_canonical_row).collect()
- }
- None => vec![],
- }
-}
-
-fn get_bottom_canonical_row_and_wraps(rows: &mut Vec<Row>) -> Vec<Row> {
- let mut index_of_last_non_canonical_row = None;
- for (i, row) in rows.iter().enumerate().rev() {
- if row.is_canonical {
- index_of_last_non_canonical_row = Some(i);
- break;
- } else {
- index_of_last_non_canonical_row = Some(i);
- }
- }
- match index_of_last_non_canonical_row {
- Some(index_of_last_non_canonical_row) => {
- rows.drain(index_of_last_non_canonical_row..).collect()
- }
- None => vec![],
- }
-}
-
-fn transfer_rows_down(
- source: &mut Vec<Row>,
- destination: &mut Vec<Row>,
- count: usize,
- max_src_width: Option<usize>,
- max_dst_width: Option<usize>,
-) {
- let mut next_lines: Vec<Row> = vec![];
- let mut lines_added_to_destination: isize = 0;
- loop {
- if lines_added_to_destination as usize == count {
- break;
- }
- if next_lines.is_empty() {
- match source.pop() {
- Some(next_line) => {
- let mut top_non_canonical_rows_in_dst = get_top_non_canonical_rows(destination);
- lines_added_to_destination -= top_non_canonical_rows_in_dst.len() as isize;
- next_lines.push(next_line);
- next_lines.append(&mut top_non_canonical_rows_in_dst);
- next_lines = match max_dst_width {
- Some(max_row_width) => {
- Row::from_rows(next_lines).split_to_rows_of_length(max_row_width)
- }
- None => vec![Row::from_rows(next_lines)],
- };
- }
- None => break, // no more rows
- }
- }
- destination.insert(0, next_lines.pop().unwrap());
- lines_added_to_destination += 1;
- }
- if !next_lines.is_empty() {
- match max_src_width {
- Some(max_row_width) => {
- let mut excess_rows =
- Row::from_rows(next_lines).split_to_rows_of_length(max_row_width);
- source.append(&mut excess_rows);
- }
- None => {
- let excess_row = Row::from_rows(next_lines);
- source.push(excess_row);
- }
- }
- }
-}
-
-fn transfer_rows_up(
- source: &mut Vec<Row>,
- destination: &mut Vec<Row>,
- count: usize,
- max_src_width: Option<usize>,
- max_dst_width: Option<usize>,
-) {
- let mut next_lines: Vec<Row> = vec![];
- for _ in 0..count {
- if next_lines.is_empty() {
- if !source.is_empty() {
- let next_line = source.remove(0);
- if !next_line.is_canonical {
- let mut bottom_canonical_row_and_wraps_in_dst =
- get_bottom_canonical_row_and_wraps(destination);
- next_lines.append(&mut bottom_canonical_row_and_wraps_in_dst);
- }
- next_lines.push(next_line);
- next_lines = match max_dst_width {
- Some(max_row_width) => {
- Row::from_rows(next_lines).split_to_rows_of_length(max_row_width)
- }
- None => vec![Row::from_rows(next_lines)],
- };
- } else {
- break; // no more rows
- }
- }
- destination.push(next_lines.remove(0));
- }
- if !next_lines.is_empty() {
- match max_src_width {
- Some(max_row_width) => {
- let excess_rows = Row::from_rows(next_lines).split_to_rows_of_length(max_row_width);
- for row in excess_rows {
- source.insert(0, row);
- }
- }
- None => {
- let excess_row = Row::from_rows(next_lines);
- source.insert(0, excess_row);
- }
- }
- }
-}
-
-#[derive(Clone)]
-pub struct Grid {
- lines_above: Vec<Row>,
- viewport: Vec<Row>,
- lines_below: Vec<Row>,
- cursor: Cursor,
- scroll_region: Option<(usize, usize)>,
- pub width: usize,
- pub height: usize,
-}
-
-impl Debug for Grid {
- fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- for (i, row) in self.viewport.iter().enumerate() {
- if row.is_canonical {
- writeln!(f, "{:?} (C): {:?}", i, row)?;
- } else {
- writeln!(f, "{:?} (W): {:?}", i, row)?;
- }
- }
- Ok(())
- }
-}
-
-impl Grid {
- pub fn new(rows: usize, columns: usize) -> Self {
- Grid {
- lines_above: vec![],
- viewport: vec![],
- lines_below: vec![],
- cursor: Cursor::new(0, 0),
- scroll_region: None,
- width: columns,
- height: rows,
- }
- }
- fn cursor_canonical_line_index(&self) -> usize {
- let mut cursor_canonical_line_index = 0;
- let mut canonical_lines_traversed = 0;
- for (i, line) in self.viewport.iter().enumerate() {
- if line.is_canonical {
- cursor_canonical_line_index = canonical_lines_traversed;
- canonical_lines_traversed += 1;
- }
- if i == self.cursor.y {
- break;
- }
- }
- cursor_canonical_line_index
- }
- // TODO: merge these two funtions
- fn cursor_index_in_canonical_line(&self) -> usize {
- let mut cursor_canonical_line_index = 0;
- let mut cursor_index_in_canonical_line = 0;
- for (i, line) in self.viewport.iter().enumerate() {
- if line.is_canonical {
- cursor_canonical_line_index = i;
- }
- if i == self.cursor.y {
- let line_wrap_position_in_line = self.cursor.y - cursor_canonical_line_index;
- cursor_index_in_canonical_line = line_wrap_position_in_line + self.cursor.x;
- break;
- }
- }
- cursor_index_in_canonical_line
- }
- fn canonical_line_y_coordinates(&self, canonical_line_index: usize) -> usize {
- let mut canonical_lines_traversed = 0;
- let mut y_coordinates = 0;
- for (i, line) in self.viewport.iter().enumerate() {
- if line.is_canonical {
- canonical_lines_traversed += 1;
- if canonical_lines_traversed == canonical_line_index + 1 {
- y_coordinates = i;
- break;
- }
- }
- }
- y_coordinates
- }
- pub fn scroll_up_one_line(&mut self) {
- if !self.lines_above.is_empty() && self.viewport.len() == self.height {
- let line_to_push_down = self.viewport.pop().unwrap();
- self.lines_below.insert(0, line_to_push_down);
- let line_to_insert_at_viewport_top = self.lines_above.pop().unwrap();
- self.viewport.insert(0, line_to_insert_at_viewport_top);
- }
- }
- pub fn scroll_down_one_line(&mut self) {
- if !self.lines_below.is_empty() && self.viewport.len() == self.height {
- let mut line_to_push_up = self.viewport.remove(0);
- if line_to_push_up.is_canonical {
- self.lines_above.push(line_to_push_up);
- } else {
- let mut last_line_above = self.lines_above.pop().unwrap();
- last_line_above.append(&mut line_to_push_up.columns);
- self.lines_above.push(last_line_above);
- }
- let line_to_insert_at_viewport_bottom = self.lines_below.remove(0);
- self.viewport.push(line_to_insert_at_viewport_bottom);
- }
- }
- pub fn change_size(&mut self, new_rows: usize, new_columns: usize) {
- if new_columns != self.width {
- let mut cursor_canonical_line_index = self.cursor_canonical_line_index();
- let cursor_index_in_canonical_line = self.cursor_index_in_canonical_line();
- let mut viewport_canonical_lines = vec![];
- for mut row in self.viewport.drain(..) {
- if !row.is_canonical
- && viewport_canonical_lines.is_empty()
- && !self.lines_above.is_empty()
- {
- let mut first_line_above = self.lines_above.pop().unwrap();
- first_line_above.append(&mut row.columns);
- viewport_canonical_lines.push(first_line_above);
- cursor_canonical_line_index += 1;
- } else if row.is_canonical {
- viewport_canonical_lines.push(row);
- } else {
- match viewport_canonical_lines.last_mut() {
- Some(last_line) => {
- last_line.append(&mut row.columns);
- }
- None => {
- // the state is corrupted somehow
- // this is a bug and I'm not yet sure why it happens
- // usually it fixes itself and is a result of some race
- // TODO: investigate why this happens and solve it
- return;
- }
- }
- }
- }
- let mut new_viewport_rows = vec![];
- for mut canonical_line in viewport_canonical_lines {
- let mut canonical_line_parts: Vec<Row> = vec![];
- if canonical_line.columns.is_empty() {
- canonical_line_parts.push(Row::new().canonical());
- }
- while !canonical_line.columns.is_empty() {
- let next_wrap = if canonical_line.len() > new_columns {
- canonical_line.columns.drain(..new_columns)
- } else {
- canonical_line.columns.drain(..)
- };
- let row = Row::from_columns(next_wrap.collect());
- // if there are no more parts, this row is canonical as long as it originally
- // was canonical (it might not have been for example if it's the first row in
- // the viewport, and the actual canonical row is above it in the scrollback)
- let row = if canonical_line_parts.is_empty() && canonical_line.is_canonical {
- row.canonical()
- } else {
- row
- };
- canonical_line_parts.push(row);
- }
- new_viewport_rows.append(&mut canonical_line_parts);
- }
- self.viewport = new_viewport_rows;
-
- let mut new_cursor_y = self.canonical_line_y_coordinates(cursor_canonical_line_index);
- let new_cursor_x = (cursor_index_in_canonical_line / new_columns)
- + (cursor_index_in_canonical_line % new_columns);
- let current_viewport_row_count = self.viewport.len();
- match current_viewport_row_count.cmp(&self.height) {
- Ordering::Less => {
- let row_count_to_transfer = self.height - current_viewport_row_count;
- transfer_rows_down(
- &mut self.lines_above,
- &mut self.viewport,
- row_count_to_transfer,
- None,
- Some(new_columns),
- );
- let rows_pulled = self.viewport.len() - current_viewport_row_count;
- new_cursor_y += rows_pulled;
- }
- Ordering::Greater => {
- let row_count_to_transfer = current_viewport_row_count - self.height;
- if row_count_to_transfer > new_cursor_y {
- new_cursor_y = 0;
- } else {
- new_cursor_y -= row_count_to_transfer;
- }
- transfer_rows_up(
- &mut self.viewport,
- &mut self.lines_above,
- row_count_to_transfer,
- Some(new_columns),
- None,
- );
- }
- Ordering::Equal => {}
- }
- self.cursor.y = new_cursor_y;
- self.cursor.x = new_cursor_x;
- }
- if new_rows != self.height {
- let current_viewport_row_count = self.viewport.len();
- match current_viewport_row_count.cmp(&new_rows) {
- Ordering::Less => {
- let row_count_to_transfer = new_rows - current_viewport_row_count;
- transfer_rows_down(
- &mut self.lines_above,
- &mut self.viewport,
- row_count_to_transfer,
- None,
- Some(new_columns),
- );
- let rows_pulled = self.viewport.len() - current_viewport_row_count;
- self.cursor.y += rows_pulled;
- }
- Ordering::Greater => {
- let row_count_to_transfer = current_viewport_row_count - new_rows;
- if row_count_to_transfer > self.cursor.y {
- self.cursor.y = 0;
- } else {
- self.cursor.y -= row_count_to_transfer;
- }
- transfer_rows_up(
- &mut self.viewport,
- &mut self.lines_above,
- row_count_to_transfer,
- Some(new_columns),
- None,
- );
- }
- Ordering::Equal => {}
- }
- }
- self.height = new_rows;
- self.width = new_columns;
- if self.scroll_region.is_some() {
- self.set_scroll_region_to_viewport_size();
- }
- }
- pub fn as_character_lines(&self) -> Vec<Vec<TerminalCharacter>> {
- let mut lines: Vec<Vec<TerminalCharacter>> = self
- .viewport
- .iter()
- .map(|r| {
- let mut line: Vec<TerminalCharacter> = r.columns.iter().copied().collect();
- // pad line
- line.resize(self.width, EMPTY_TERMINAL_CHARACTER);
- line
- })
- .collect();
- let empty_row = vec![EMPTY_TERMINAL_CHARACTER; self.width];
- for _ in lines.len()..self.height {
- lines.push(empty_row.clone());
- }
- lines
- }
- pub fn cursor_coordinates(&self) -> Option<(usize, usize)> {
- if self.cursor.is_hidden {
- None
- } else {
- Some((self.cursor.x, self.cursor.y))
- }
- }
- pub fn move_viewport_up(&mut self, count: usize) {
- for _ in 0..count {
- self.scroll_up_one_line();
- }
- }
- pub fn move_viewport_down(&mut self, count: usize) {
- for _ in 0..count {
- self.scroll_down_one_line();
- }
- }
- pub fn reset_viewport(&mut self) {
- let row_count_below = self.lines_below.len();
- for _ in 0..row_count_below {
- self.scroll_down_one_line();
- }
- }
- pub fn rotate_scroll_region_up(&mut self, _count: usize) {
- // TBD
- }
- pub fn rotate_scroll_region_down(&mut self, _count: usize) {
- // TBD
- }
- pub fn add_canonical_line(&mut self) {
- if let Some((scroll_region_top, scroll_region_bottom)) = self.scroll_region {
- if self.cursor.y == scroll_region_bottom {
- // end of scroll region
- // when we have a scroll region set and we're at its bottom
- // we need to delete its first line, thus shifting all lines in it upwards
- // then we add an empty line at its end which will be filled by the application
- // controlling the scroll region (presumably filled by whatever comes next in the
- // scroll buffer, but that's not something we control)
- self.viewport.remove(scroll_region_top);
- self.viewport
- .insert(scroll_region_bottom, Row::new().canonical());
- return;
- }
- }
- if self.viewport.len() <= self.cursor.y + 1 {
- let new_row = Row::new().canonical();
- self.viewport.push(new_row);
- }
- if self.cursor.y == self.height - 1 {
- let row_count_to_transfer = 1;
- transfer_rows_up(
- &mut self.viewport,
- &mut self.lines_above,
- row_count_to_transfer,
- Some(self.width),
- None,
- );
- } else {
- self.cursor.y += 1;
- }
- }
- pub fn move_cursor_to_beginning_of_line(&mut self) {
- self.cursor.x = 0;
- }
- pub fn move_cursor_backwards(&mut self, count: usize) {
- if self.cursor.x > count {
- self.cursor.x -= count;
- } else {
- self.cursor.x = 0;
- }
- }
- pub fn insert_character_at_cursor_position(&mut self, terminal_character: TerminalCharacter) {
- match self.viewport.get_mut(self.cursor.y) {
- Some(row) => row.add_character_at(terminal_character, self.cursor.x),
- None => {
- // pad lines until cursor if they do not exist
- for _ in self.viewport.len()..self.cursor.y {
- self.viewport.push(Row::new().canonical());
- }
- self.viewport
- .push(Row::new().with_character(terminal_character).canonical());
- }
- }
- }
- pub fn add_character(&mut self, terminal_character: TerminalCharacter) {
- // TODO: try to separate adding characters from moving the cursors in this function
- if self.cursor.x < self.width {
- self.insert_character_at_cursor_position(terminal_character);
- } else {
- // line wrap
- self.cursor.x = 0;
- if self.cursor.y == self.height - 1 {
- let row_count_to_transfer = 1;
- transfer_rows_up(
- &mut self.viewport,
- &mut self.lines_above,
- row_count_to_transfer,
- Some(self.width),
- None,
- );
- let wrapped_row = Row::new();
- self.viewport.push(wrapped_row);
- } else {
- self.cursor.y += 1;
- if self.viewport.len() <= self.cursor.y {
- let line_wrapped_row = Row::new();
- self.viewport.push(line_wrapped_row);
- }
- }
- self.insert_character_at_cursor_position(terminal_character);
- }
- self.move_cursor_forward_until_edge(1);
- }
- pub fn move_cursor_forward_until_edge(&mut self, count: usize) {
- let count_to_move = std::cmp::min(count, self.width - (self.cursor.x));
- self.cursor.x += count_to_move;
- }
- pub fn replace_characters_in_line_after_cursor(&mut self, replace_with: TerminalCharacter) {
- self.viewport
- .get_mut(self.cursor.y)
- .unwrap()
- .truncate(self.cursor.x);
- if self.cursor.x < self.width - 1 {
- let mut characters_to_append = vec![replace_with; self.width - self.cursor.x];
- self.viewport
- .get_mut(self.cursor.y)
- .unwrap()
- .append(&mut characters_to_append);
- }
- }
- pub fn replace_characters_in_line_before_cursor(&mut self, replace_with: TerminalCharacter) {
- let line_part = vec![replace_with; self.cursor.x];
- let row = self.viewport.get_mut(self.cursor.y).unwrap();
- row.replace_beginning_with(line_part);
- }
- pub fn clear_all_after_cursor(&mut self, replace_with: TerminalCharacter) {
- let cursor_row = self.viewport.get_mut(self.cursor.y).unwrap();
- cursor_row.truncate(self.cursor.x);
- let mut replace_with_columns_in_cursor_row = vec![replace_with; self.width - self.cursor.x];
- cursor_row.append(&mut replace_with_columns_in_cursor_row);
-
- let replace_with_columns = vec![replace_with; self.width];
- self.replace_characters_in_line_after_cursor(replace_with);
- for row in self.viewport.iter_mut().skip(self.cursor.y + 1) {
- row.replace_columns(replace_with_columns.clone());
- }
- }
- pub fn clear_cursor_line(&mut self) {
- self.viewport.get_mut(self.cursor.y).unwrap().truncate(0);
- }
- pub fn clear_all(&mut self, replace_with: TerminalCharacter) {
- let replace_with_columns = vec![replace_with; self.width];
- self.replace_characters_in_line_after_cursor(replace_with);
- for row in self.viewport.iter_mut() {
- row.replace_columns(replace_with_columns.clone());
- }
- }
- fn pad_current_line_until(&mut self, position: usize) {
- let current_row = self.viewport.get_mut(self.cursor.y).unwrap();
- for _ in current_row.len()..position {
- current_row.push(EMPTY_TERMINAL_CHARACTER);
- }
- }
- fn pad_lines_until(&mut self, position: usize) {
- for _ in self.viewport.len()..position {
- self.viewport.push(Row::new().canonical());
- }
- }
- pub fn move_cursor_to(&mut self, x: usize, y: usize) {
- self.cursor.x = x;
- self.cursor.y = y;
- self.pad_lines_until(self.cursor.y + 1);
- self.pad_current_line_until(self.cursor.x);
- }
- pub fn move_cursor_up(&mut self, count: usize) {
- self.cursor.y = if self.cursor.y < count {
- 0
- } else {
- self.cursor.y - count
- };
- }
- pub fn move_cursor_up_with_scrolling(&mut self, count: usize) {
- let (scroll_region_top, scroll_region_bottom) =
- self.scroll_region.unwrap_or((0, self.height - 1));
- for _ in 0..count {
- let current_line_index = self.cursor.y;
- if current_line_index == scroll_region_top {
- // if we're at the top line, we create a new line and remove the last line that
- // would otherwise overflow
- self.viewport.remove(scroll_region_bottom);
- self.viewport.insert(current_line_index, Row::new()); // TODO: .canonical() ?
- } else if current_line_index > scroll_region_top
- && current_line_index <= scroll_region_bottom
- {
- self.move_cursor_up(count);
- }
- }
- }
- pub fn move_cursor_down(&mut self, count: usize) {
- let lines_to_add = if self.cursor.y + count > self.height - 1 {
- (self.cursor.y + count) - (self.height - 1)
- } else {
- 0
- };
- self.cursor.y = if self.cursor.y + count > self.height - 1 {
- self.height - 1
- } else {
- self.cursor.y + count
- };
- for _ in 0..lines_to_add {
- self.add_canonical_line();
- }
- self.pad_lines_until(self.cursor.y);
- }
- pub fn move_cursor_back(&mut self, count: usize) {
- if self.cursor.x < count {
- self.cursor.x = 0;
- } else {
- self.cursor.x -= count;
- }
- }
- pub fn hide_cursor(&mut self) {
- self.cursor.is_hidden = true;
- }
- pub fn show_cursor(&mut self) {
- self.cursor.is_hidden = false;
- }
- pub fn set_scroll_region(&mut self, top_line_index: usize, bottom_line_index: usize) {
- self.scroll_region = Some((top_line_index, bottom_line_index));
- }
- pub fn clear_scroll_region(&mut self) {
- self.scroll_region = None;
- }
- pub fn set_scroll_region_to_viewport_size(&mut self) {
- self.scroll_region = Some((0, self.height - 1));
- }
- pub fn delete_lines_in_scroll_region(&mut self, count: usize) {
- if let Some((scroll_region_top, scroll_region_bottom)) = self.scroll_region {
- let current_line_index = self.cursor.y;
- if current_line_index >= scroll_region_top && current_line_index <= scroll_region_bottom
- {
- // when deleting lines inside the scroll region, we must make sure it stays the
- // same size (and that other lines below it aren't shifted inside it)
- // so we delete the current line(s) and add an empty line at the end of the scroll
- // region
- for _ in 0..count {
- self.viewport.remove(current_line_index);
- self.viewport
- .insert(scroll_region_bottom, Row::new().canonical());
- }
- }
- }
- }
- pub fn add_empty_lines_in_scroll_region(&mut self, count: usize) {
- if let Some((scroll_region_top, scroll_region_bottom)) = self.scroll_region {
- let current_line_index = self.cursor.y;
- if current_line_index >= scroll_region_top && current_line_index <= scroll_region_bottom
- {
- // when adding empty lines inside the scroll region, we must make sure it stays the
- // same size and that lines don't "leak" outside of it
- // so we add an empty line where the cursor currently is, and delete the last line
- // of the scroll region
- for _ in 0..count {
- self.viewport.remove(scroll_region_bottom);
- self.viewport
- .insert(current_line_index, Row::new().canonical());
- }
- }
- }
- }
- pub fn move_cursor_to_column(&mut self, column: usize) {
- self.cursor.x = column;
- self.pad_current_line_until(self.cursor.x);
- }
- pub fn move_cursor_to_line(&mut self, line: usize) {
- self.cursor.y = line;
- self.pad_lines_until(self.cursor.y + 1);
- self.pad_current_line_until(self.cursor.x);
- }
- pub fn replace_with_empty_chars(&mut self, count: usize, empty_char_style: CharacterStyles) {
- let mut empty_character = EMPTY_TERMINAL_CHARACTER;
- empty_character.styles = empty_char_style;
- let pad_until = std::cmp::min(self.width, self.cursor.x + count);
- self.pad_current_line_until(pad_until);
- let current_row = self.viewport.get_mut(self.cursor.y).unwrap();
- for i in 0..count {
- current_row.replace_character_at(empty_character, self.cursor.x + i);
- }
- }
- pub fn erase_characters(&mut self, count: usize, empty_char_style: CharacterStyles) {
- let mut empty_character = EMPTY_TERMINAL_CHARACTER;
- empty_character.styles = empty_char_style;
- let current_row = self.viewport.get_mut(self.cursor.y).unwrap();
- for _ in 0..count {
- current_row.delete_character(self.cursor.x);
- }
- let mut empty_space_to_append = vec![empty_character; count];
- self.viewport
- .get_mut(self.cursor.y)
- .unwrap()
- .append(&mut empty_space_to_append);
- }
-}
-
-#[derive(Clone)]
-pub struct Row {
- pub columns: Vec<TerminalCharacter>,
- pub is_canonical: bool,
-}
-
-impl Debug for Row {
- fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- for character in &self.columns {
- write!(f, "{:?}", character)?;
- }
- Ok(())
- }
-}
-
-impl Row {
- pub fn new() -> Self {
- Row {
- columns: vec![],
- is_canonical: false,
- }
- }
- pub fn from_columns(columns: Vec<TerminalCharacter>) -> Self {
- Row {
- columns,
- is_canonical: false,
- }
- }
- pub fn from_rows(mut rows: Vec<Row>) -> Self {
- if rows.is_empty() {
- Row::new()
- } else {
- let mut first_row = rows.remove(0);
- for row in rows.iter_mut() {
- first_row.append(&mut row.columns);
- }
- first_row
- }
- }
- pub fn with_character(mut self, terminal_character: TerminalCharacter) -> Self {
- self.columns.push(terminal_character);
- self
- }
- pub fn canonical(mut self) -> Self {
- self.is_canonical = true;
- self
- }
- pub fn add_character_at(&mut self, terminal_character: TerminalCharacter, x: usize) {
- match self.columns.len().cmp(&x) {
- Ordering::Equal => self.columns.push(terminal_character),
- Ordering::Less => {
- self.columns.resize(x, EMPTY_TERMINAL_CHARACTER);
- self.columns.push(terminal_character);
- }
- Ordering::Greater => {
- // this is much more performant than remove/insert
- self.columns.push(terminal_character);
- self.columns.swap_remove(x);
- }
- }
- }
- pub fn replace_character_at(&mut self, terminal_character: TerminalCharacter, x: usize) {
- // this is much more performant than remove/insert
- self.columns.push(terminal_character);
- self.columns.swap_remove(x);
- }
- pub fn replace_columns(&mut self, columns: Vec<TerminalCharacter>) {
- self.columns = columns;
- }
- pub fn push(&mut self, terminal_character: TerminalCharacter) {
- self.columns.push(terminal_character);
- }
- pub fn truncate(&mut self, x: usize) {
- self.columns.truncate(x);
- }
- pub fn append(&mut self, to_append: &mut Vec<TerminalCharacter>) {
- self.columns.append(to_append);
- }
- pub fn replace_beginning_with(&mut self, mut line_part: Vec<TerminalCharacter>) {
- drop(self.columns.drain(0..line_part.len()));
- line_part.append(&mut self.columns);
- self.columns = line_part;
- }
- pub fn len(&self) -> usize {
- self.columns.len()
- }
- pub fn delete_character(&mut self, x: usize) {
- self.columns.remove(x);
- }
- pub fn split_to_rows_of_length(&mut self, max_row_length: usize) -> Vec<Row> {
- let mut parts: Vec<Row> = vec![];
- let mut current_part: Vec<TerminalCharacter> = vec![];
- for character in self.columns.drain(..) {
- if current_part.len() == max_row_length {
- parts.push(Row::from_columns(current_part));
- current_part = vec![];
- }
- current_part.push(character);
- }
- if !current_part.is_empty() {
- parts.push(Row::from_columns(current_part))
- };
- if !parts.is_empty() && self.is_canonical {
- parts.get_mut(0).unwrap().is_canonical = true;
- }
- parts
- }
-}
-
-#[derive(Clone, Debug)]
-pub struct Cursor {
- x: usize,
- y: usize,
- is_hidden: bool,
-}
-
-impl Cursor {
- pub fn new(x: usize, y: usize) -> Self {
- Cursor {
- x,
- y,
- is_hidden: false,
- }
- }
-}
diff --git a/src/panes/mod.rs b/src/panes/mod.rs
deleted file mode 100644
index 4e7d6e80..00000000
--- a/src/panes/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-mod grid;
-mod plugin_pane;
-mod terminal_character;
-mod terminal_pane;
-
-pub use grid::*;
-pub use plugin_pane::*;
-pub use terminal_character::*;
-pub use terminal_pane::*;
diff --git a/src/panes/plugin_pane.rs b/src/panes/plugin_pane.rs
deleted file mode 100644
index a93ff8c0..00000000
--- a/src/panes/plugin_pane.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-#![allow(clippy::clippy::if_same_then_else)]
-
-use crate::{pty_bus::VteEvent, tab::Pane, wasm_vm::PluginInstruction, SenderWithContext};
-
-use std::{sync::mpsc::channel, unimplemented};
-
-use crate::panes::{PaneId, PositionAndSize};
-
-pub struct PluginPane {
- pub pid: u32,
- pub should_render: bool,
- pub selectable: bool,
- pub position_and_size: PositionAndSize,
- pub position_and_size_override: Option<PositionAndSize>,
- pub send_plugin_instructions: SenderWithContext<PluginInstruction>,
-}
-
-impl PluginPane {
- pub fn new(
- pid: u32,
- position_and_size: PositionAndSize,
- send_plugin_instructions: SenderWithContext<PluginInstruction>,
- ) -> Self {
- Self {
- pid,
- should_render: true,
- selectable: true,
- position_and_size,
- position_and_size_override: None,
- send_plugin_instructions,
- }
- }
-}
-
-impl Pane for PluginPane {
- // FIXME: These position and size things should all be moved to default trait implementations,
- // with something like a get_pos_and_sz() method underpinning all of them. Alternatively and
- // preferably, just use an enum and not a trait object
- fn x(&self) -> usize {
- self.position_and_size_override
- .unwrap_or(self.position_and_size)
- .x
- }
- fn y(&self) -> usize {
- self.position_and_size_override
- .unwrap_or(self.position_and_size)
- .y
- }
- fn rows(&self) -> usize {
- self.position_and_size_override
- .unwrap_or(self.position_and_size)
- .rows
- }
- fn columns(&self) -> usize {
- self.position_and_size_override
- .unwrap_or(self.position_and_size)
- .columns
- }
- fn reset_size_and_position_override(&mut self) {
- self.position_and_size_override = None;
- self.should_render = true;
- }
- fn change_pos_and_size(&mut self, position_and_size: &PositionAndSize) {
- self.position_and_size = *position_and_size;
- self.should_render = true;
- }
- // FIXME: This is obviously a bit outdated and needs the x and y moved into `size`
- fn override_size_and_position(&mut self, x: usize, y: usize, size: &PositionAndSize) {
- let position_and_size_override = PositionAndSize {
- x,
- y,
- rows: size.rows,
- columns: size.columns,
- };
- self.position_and_size_override = Some(position_and_size_override);
- self.should_render = true;
- }
- fn handle_event(&mut self, _event: VteEvent) {
- unimplemented!()
- }
- fn cursor_coordinates(&self) -> Option<(usize, usize)> {
- None
- }
- fn adjust_input_to_terminal(&self, _input_bytes: Vec<u8>) -> Vec<u8> {
- unimplemented!() // FIXME: Shouldn't need this implmented?
- }
-
- fn position_and_size_override(&self) -> Option<PositionAndSize> {
- self.position_and_size_override
- }
- fn should_render(&self) -> bool {
- self.should_render
- }
- fn set_should_render(&mut self, should_render: bool) {
- self.should_render = should_render;
- }
- fn selectable(&self) -> bool {
- self.selectable
- }
- fn set_selectable(&mut self, selectable: bool) {
- self.selectable = selectable;
- }
- fn render(&mut self) -> Option<String> {
- // if self.should_render {
- if true {
- // while checking should_render rather than rendering each pane every time
- // is more performant, it causes some problems when the pane to the left should be
- // rendered and has wide characters (eg. Chinese characters or emoji)
- // as a (hopefully) temporary hack, we render all panes until we find a better solution
- let (buf_tx, buf_rx) = channel();
-
- self.send_plugin_instructions
- .send(PluginInstruction::Draw(
- buf_tx,
- self.pid,
- self.rows(),
- self.columns(),
- ))
- .unwrap();
-
- self.should_render = false;
- Some(buf_rx.recv().unwrap())
- } else {
- None
- }
- }
- fn pid(&self) -> PaneId {
- PaneId::Plugin(self.pid)
- }
- fn reduce_height_down(&mut self, count: usize) {
- self.position_and_size.y += count;
- self.position_and_size.rows -= count;
- self.should_render = true;
- }
- fn increase_height_down(&mut self, count: usize) {
- self.position_and_size.rows += count;
- self.should_render = true;
- }
- fn increase_height_up(&mut self, count: usize) {
- self.position_and_size.y -= count;
- self.position_and_size.rows += count;
- self.should_render = true;
- }
- fn reduce_height_up(&mut self, count: usize) {
- self.position_and_size.rows -= count;
- self.should_render = true;
- }
- fn reduce_width_right(&mut self, count: usize) {
- self.position_and_size.x += count;
- self.position_and_size.columns -= count;
- self.should_render = true;
- }
- fn reduce_width_left(&mut self, count: usize) {
- self.position_and_size.columns -= count;
- self.should_render = true;
- }
- fn increase_width_left(&mut self, count: usize) {
- self.position_and_size.x -= count;
- self.position_and_size.columns += count;
- self.should_render = true;
- }
- fn increase_width_right(&mut self, count: usize) {
- self.position_and_size.columns += count;
- self.should_render = true;
- }
- fn scroll_up(&mut self, _count: usize) {
- unimplemented!()
- }
- fn scroll_down(&mut self, _count: usize) {
- unimplemented!()
- }
- fn clear_scroll(&mut self) {
- unimplemented!()
- }
-}
diff --git a/src/panes/terminal_character.rs b/src/panes/terminal_character.rs
deleted file mode 100644
index 80c3162b..00000000
--- a/src/panes/terminal_character.rs
+++ /dev/null
@@ -1,572 +0,0 @@
-use crate::utils::logging::debug_log_to_file;
-use ::std::fmt::{self, Debug, Display, Formatter};
-
-pub const EMPTY_TERMINAL_CHARACTER: TerminalCharacter = TerminalCharacter {
- character: ' ',
- styles: CharacterStyles {
- foreground: Some(AnsiCode::Reset),
- background: Some(AnsiCode::Reset),
- strike: Some(AnsiCode::Reset),
- hidden: Some(AnsiCode::Reset),
- reverse: Some(AnsiCode::Reset),
- slow_blink: Some(AnsiCode::Reset),
- fast_blink: Some(AnsiCode::Reset),
- underline: Some(AnsiCode::Reset),
- bold: Some(AnsiCode::Reset),
- dim: Some(AnsiCode::Reset),
- italic: Some(AnsiCode::Reset),
- },
-};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AnsiCode {
- On,
- Reset,
- NamedColor(NamedColor),
- RGBCode((u8, u8, u8)),
- ColorIndex(u8),
-}
-
-#[derive(Clone, Copy, Eq, PartialEq, Debug)]
-pub enum NamedColor {
- Black,
- Red,
- Green,
- Yellow,
- Blue,
- Magenta,
- Cyan,
- White,
-}
-
-impl NamedColor {
- fn to_foreground_ansi_code(&self) -> String {
- match self {
- NamedColor::Black => format!("{}", 30),
- NamedColor::Red => format!("{}", 31),
- NamedColor::Green => format!("{}", 32),
- NamedColor::Yellow => format!("{}", 33),
- NamedColor::Blue => format!("{}", 34),
- NamedColor::Magenta => format!("{}", 35),
- NamedColor::Cyan => format!("{}", 36),
- NamedColor::White => format!("{}", 37),
- }
- }
- fn to_background_ansi_code(&self) -> String {
- match self {
- NamedColor::Black => format!("{}", 40),
- NamedColor::Red => format!("{}", 41),
- NamedColor::Green => format!("{}", 42),
- NamedColor::Yellow => format!("{}", 43),
- NamedColor::Blue => format!("{}", 44),
- NamedColor::Magenta => format!("{}", 45),
- NamedColor::Cyan => format!("{}", 46),
- NamedColor::White => format!("{}", 47),
- }
- }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct CharacterStyles {
- pub foreground: Option<AnsiCode>,
- pub background: Option<AnsiCode>,
- pub strike: Option<AnsiCode>,
- pub hidden: Option<AnsiCode>,
- pub reverse: Option<AnsiCode>,
- pub slow_blink: Option<AnsiCode>,
- pub fast_blink: Option<AnsiCode>,
- pub underline: Option<AnsiCode>,
- pub bold: Option<AnsiCode>,
- pub dim: Option<AnsiCode>,
- pub italic: Option<AnsiCode>,
-}
-
-impl CharacterStyles {
- pub fn new() -> Self {
- CharacterStyles {
- foreground: None,
- background: None,
- strike: None,
- hidden: None,
- reverse: None,
- slow_blink: None,
- fast_blink: None,
- underline: None,
- bold: None,
- dim: None,
- italic: None,
- }
- }
- pub fn foreground(mut self, foreground_code: Option<AnsiCode>) -> Self {
- self.foreground = foreground_code;
- self
- }
- pub fn background(mut self, background_code: Option<AnsiCode>) -> Self {
- self.background = background_code;
- self
- }
- pub fn bold(mut self, bold_code: Option<AnsiCode>) -> Self {
- self.bold = bold_code;
- self
- }
- pub fn dim(mut self, dim_code: Option<AnsiCode>) -> Self {
- self.dim = dim_code;
- self
- }
- pub fn italic(mut self, italic_code: Option<AnsiCode>) -> Self {
- self.italic = italic_code;
- self
- }
- pub fn underline(mut self, underline_code: Option<AnsiCode>) -> Self {
- self.underline = underline_code;
- self
- }
- pub fn blink_slow(mut self, slow_blink_code: Option<AnsiCode>) -> Self {
- self.slow_blink = slow_blink_code;
- self
- }
- pub fn blink_fast(mut self, fast_blink_code: Option<AnsiCode>) -> Self {
- self.fast_blink = fast_blink_code;
- self
- }
- pub fn reverse(mut self, reverse_code: Option<AnsiCode>) -> Self {
- self.reverse = reverse_code;
- self
- }
- pub fn hidden(mut self, hidden_code: Option<AnsiCode>) -> Self {
- self.hidden = hidden_code;
- self
- }
- pub fn strike(mut self, strike_code: Option<AnsiCode>) -> Self {
- self.strike = strike_code;
- self
- }
- pub fn clear(&mut self) {
- self.foreground = None;
- self.background = None;
- self.strike = None;
- self.hidden = None;
- self.reverse = None;
- self.slow_blink = None;
- self.fast_blink = None;
- self.underline = None;
- self.bold = None;
- self.dim = None;
- self.italic = None;
- }
- pub fn update_and_return_diff(
- &mut self,
- new_styles: &CharacterStyles,
- ) -> Option<CharacterStyles> {
- let mut diff: Option<CharacterStyles> = None;
-
- if new_styles.foreground == Some(AnsiCode::Reset)
- && new_styles.background == Some(AnsiCode::Reset)
- && new_styles.strike == Some(AnsiCode::Reset)
- && new_styles.hidden == Some(AnsiCode::Reset)
- && new_styles.reverse == Some(AnsiCode::Reset)
- && new_styles.fast_blink == Some(AnsiCode::Reset)
- && new_styles.slow_blink == Some(AnsiCode::Reset)
- && new_styles.underline == Some(AnsiCode::Reset)
- && new_styles.bold == Some(AnsiCode::Reset)
- && new_styles.dim == Some(AnsiCode::Reset)
- && new_styles.italic == Some(AnsiCode::Reset)
- {
- self.foreground = Some(AnsiCode::Reset);
- self.background = Some(AnsiCode::Reset);
- self.strike = Some(AnsiCode::Reset);
- self.hidden = Some(AnsiCode::Reset);
- self.reverse = Some(AnsiCode::Reset);
- self.fast_blink = Some(AnsiCode::Reset);
- self.slow_blink = Some(AnsiCode::Reset);
- self.underline = Some(AnsiCode::Reset);
- self.bold = Some(AnsiCode::Reset);
- self.dim = Some(AnsiCode::Reset);
- self.italic = Some(AnsiCode::Reset);
- return Some(*new_styles);
- };
-
- if self.foreground != new_styles.foreground {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.foreground(new_styles.foreground));
- self.foreground = new_styles.foreground;
- } else {
- diff = Some(CharacterStyles::new().foreground(new_styles.foreground));
- self.foreground = new_styles.foreground;
- }
- }
- if self.background != new_styles.background {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.background(new_styles.background));
- self.background = new_styles.background;
- } else {
- diff = Some(CharacterStyles::new().background(new_styles.background));
- self.background = new_styles.background;
- }
- }
- if self.strike != new_styles.strike {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.strike(new_styles.strike));
- self.strike = new_styles.strike;
- } else {
- diff = Some(CharacterStyles::new().strike(new_styles.strike));
- self.strike = new_styles.strike;
- }
- }
- if self.hidden != new_styles.hidden {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.hidden(new_styles.hidden));
- self.hidden = new_styles.hidden;
- } else {
- diff = Some(CharacterStyles::new().hidden(new_styles.hidden));
- self.hidden = new_styles.hidden;
- }
- }
- if self.reverse != new_styles.reverse {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.reverse(new_styles.reverse));
- self.reverse = new_styles.reverse;
- } else {
- diff = Some(CharacterStyles::new().reverse(new_styles.reverse));
- self.reverse = new_styles.reverse;
- }
- }
- if self.slow_blink != new_styles.slow_blink {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.blink_slow(new_styles.slow_blink));
- self.slow_blink = new_styles.slow_blink;
- } else {
- diff = Some(CharacterStyles::new().blink_slow(new_styles.slow_blink));
- self.slow_blink = new_styles.slow_blink;
- }
- }
- if self.fast_blink != new_styles.fast_blink {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.blink_fast(new_styles.fast_blink));
- self.fast_blink = new_styles.fast_blink;
- } else {
- diff = Some(CharacterStyles::new().blink_fast(new_styles.fast_blink));
- self.fast_blink = new_styles.fast_blink;
- }
- }
- if self.underline != new_styles.underline {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.underline(new_styles.underline));
- self.underline = new_styles.underline;
- } else {
- diff = Some(CharacterStyles::new().underline(new_styles.underline));
- self.underline = new_styles.underline;
- }
- }
- if self.bold != new_styles.bold {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.bold(new_styles.bold));
- self.bold = new_styles.bold;
- } else {
- diff = Some(CharacterStyles::new().bold(new_styles.bold));
- self.bold = new_styles.bold;
- }
- }
- if self.dim != new_styles.dim {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.dim(new_styles.dim));
- self.dim = new_styles.dim;
- } else {
- diff = Some(CharacterStyles::new().dim(new_styles.dim));
- self.dim = new_styles.dim;
- }
- }
- if self.italic != new_styles.italic {
- if let Some(new_diff) = diff.as_mut() {
- diff = Some(new_diff.italic(new_styles.italic));
- self.italic = new_styles.italic;
- } else {
- diff = Some(CharacterStyles::new().italic(new_styles.italic));
- self.italic = new_styles.italic;
- }
- }
- diff
- }
- pub fn reset_all(&mut self) {
- self.foreground = Some(AnsiCode::Reset);
- self.background = Some(AnsiCode::Reset);
- self.bold = Some(AnsiCode::Reset);
- self.dim = Some(AnsiCode::Reset);
- self.italic = Some(AnsiCode::Reset);
- self.underline = Some(AnsiCode::Reset);
- self.slow_blink = Some(AnsiCode::Reset);
- self.fast_blink = Some(AnsiCode::Reset);
- self.reverse = Some(AnsiCode::Reset);
- self.hidden = Some(AnsiCode::Reset);
- self.strike = Some(AnsiCode::Reset);
- }
- pub fn add_style_from_ansi_params(&mut self, ansi_params: &[i64]) {
- let mut params_used = 1; // if there's a parameter, it is always used
- match ansi_params {
- [] | [0, ..] => self.reset_all(),
- [1, ..] => *self = self.bold(Some(AnsiCode::On)),
- [2, ..] => *self = self.dim(Some(AnsiCode::On)),
- [3, ..] => *self = self.italic(Some(AnsiCode::On)),
- [4, ..] => *self = self.underline(Some(AnsiCode::On)),
- [5, ..] => *self = self.blink_slow(Some(AnsiCode::On)),
- [6, ..] => *self = self.blink_fast(Some(AnsiCode::On)),
- [7, ..] => *self = self.reverse(Some(AnsiCode::On)),
- [8, ..] => *self = self.hidden(Some(AnsiCode::On)),
- [9, ..] => *self = self.strike(Some(AnsiCode::On)),
- [21, ..] => *self = self.bold(Some(AnsiCode::Reset)),
- [22, ..] => {
- *self = self.bold(Some(AnsiCode::Reset));
- *self = self.dim(Some(AnsiCode::Reset));
- }
- [23, ..] => *self = self.italic(Some(AnsiCode::Reset)),
- [24, ..] => *self = self.underline(Some(AnsiCode::Reset)),
- [25, ..] => {
- *self = self.blink_slow(Some(AnsiCode::Reset));
- *self = self.blink_fast(Some(AnsiCode::Reset));
- }
- [27, ..] => *self = self.reverse(Some(AnsiCode::Reset)),
- [28, ..] => *self = self.hidden(Some(AnsiCode::Reset)),
- [29, ..] => *self = self.strike(Some(AnsiCode::Reset)),
- [30, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Black))),
- [31, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Red))),
- [32, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Green))),
- [33, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Yellow))),
- [34, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Blue))),
- [35, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Magenta))),
- [36, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::Cyan))),
- [37, ..] => *self = self.foreground(Some(AnsiCode::NamedColor(NamedColor::White))),
- [38, 2, ..] => {
- let ansi_code = AnsiCode::RGBCode((
- *ansi_params.get(2).unwrap() as u8,
- *ansi_params.get(3).unwrap() as u8,
- *ansi_params.get(4).unwrap() as u8,
- ));
- *self = self.foreground(Some(ansi_code));
- params_used += 4 // one for the indicator (2 in this case) and three for the rgb code
- }
- [38, 5, ..] => {
- let ansi_code = AnsiCode::ColorIndex(*ansi_params.get(2).unwrap() as u8);
- *self = self.foreground(Some(ansi_code));
- params_used += 2 // one for the indicator (5 in this case) and one for the color index
- }
- [38, ..] => {
- // this is a bug
- // it means we got a color encoding we don't know how to handle (or is invalid)
- params_used += 1; // even if it's a bug, let's not create an endless loop, eh?
- }
- [39, ..] => *self = self.foreground(Some(AnsiCode::Reset)),
- [40, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Black))),
- [41, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Red))),
- [42, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Green))),
- [43, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Yellow))),
- [44, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Blue))),
- [45, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Magenta))),
- [46, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::Cyan))),
- [47, ..] => *self = self.background(Some(AnsiCode::NamedColor(NamedColor::White))),
- [48, 2, ..] => {
- let ansi_code = AnsiCode::RGBCode((
- *ansi_params.get(2).unwrap() as u8,
- *ansi_params.get(3).unwrap() as u8,
- *ansi_params.get(4).unwrap() as u8,
- ));
- *self = self.background(Some(ansi_code));
- params_used += 4 // one for the indicator (2 in this case) and three for the rgb code
- }
- [48, 5, ..] => {
- let ansi_code = AnsiCode::ColorIndex(*ansi_params.get(2).unwrap() as u8);
- *self = self.background(Some(ansi_code));
- params_used += 2 // one for the indicator (5 in this case) and one for the color index
- }
- [48, ..] => {
- // this is a bug
- // it means we got a color encoding we don't know how to handle (or is invalid)
- params_used += 1; // even if it's a bug, let's not create an endless loop, eh?
- }
- [49, ..] => *self = self.background(Some(AnsiCode::Reset)),
- _ => {
- // if this happens, it's a bug
- let _ = debug_log_to_file(format!("unhandled csi m code {:?}", ansi_params));
- return;
- }
- }
- if let Some(next_params) = ansi_params.get(params_used..) {
- if !next_params.is_empty() {
- self.add_style_from_ansi_params(next_params);
- }
- }
- }
-}
-
-impl Display for CharacterStyles {
- fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- if self.foreground == Some(AnsiCode::Reset)
- && self.background == Some(AnsiCode::Reset)
- && self.strike == Some(AnsiCode::Reset)
- && self.hidden == Some(AnsiCode::Reset)
- && self.reverse == Some(AnsiCode::Reset)
- && self.fast_blink == Some(AnsiCode::Reset)
- && self.slow_blink == Some(AnsiCode::Reset)
- && self.underline == Some(AnsiCode::Reset)
- && self.bold == Some(AnsiCode::Reset)
- && self.dim == Some(AnsiCode::Reset)
- && self.italic == Some(AnsiCode::Reset)
- {
- write!(f, "\u{1b}[m")?; // reset all
- return Ok(());
- }
- if let Some(ansi_code) = self.foreground {
- match ansi_code {
- AnsiCode::RGBCode((r, g, b)) => {
- write!(f, "\u{1b}[38;2;{};{};{}m", r, g, b)?;
- }
- AnsiCode::ColorIndex(color_index) => {
- write!(f, "\u{1b}[38;5;{}m", color_index)?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[39m")?;
- }
- AnsiCode::NamedColor(named_color) => {
- write!(f, "\u{1b}[{}m", named_color.to_foreground_ansi_code())?;
- }
- _ => {}
- }
- };
- if let Some(ansi_code) = self.background {
- match ansi_code {
- AnsiCode::RGBCode((r, g, b)) => {
- write!(f, "\u{1b}[48;2;{};{};{}m", r, g, b)?;
- }
- AnsiCode::ColorIndex(color_index) => {
- write!(f, "\u{1b}[48;5;{}m", color_index)?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[49m")?;
- }
- AnsiCode::NamedColor(named_color) => {
- write!(f, "\u{1b}[{}m", named_color.to_background_ansi_code())?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.strike {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[9m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[29m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.hidden {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[8m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[28m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.reverse {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[7m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[27m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.fast_blink {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[6m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[25m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.slow_blink {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[5m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[25m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.bold {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[1m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[22m\u{1b}[24m")?;
- // TODO: this cancels bold + underline, if this behaviour is indeed correct, we
- // need to properly handle it in the struct methods etc like dim
- }
- _ => {}
- }
- }
- // notice the order is important here, bold must be before underline
- // because the bold reset also resets underline, and would override it
- // otherwise
- if let Some(ansi_code) = self.underline {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[4m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[24m")?;
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.dim {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[2m")?;
- }
- AnsiCode::Reset => {
- if let Some(AnsiCode::Reset) = self.bold {
- // we only reset dim if both dim and bold should be reset
- write!(f, "\u{1b}[22m")?;
- }
- }
- _ => {}
- }
- }
- if let Some(ansi_code) = self.italic {
- match ansi_code {
- AnsiCode::On => {
- write!(f, "\u{1b}[3m")?;
- }
- AnsiCode::Reset => {
- write!(f, "\u{1b}[23m")?;
- }
- _ => {}
- }
- };
- Ok(())
- }
-}
-
-#[derive(Clone, Copy)]
-pub struct TerminalCharacter {
- pub character: char,
- pub styles: CharacterStyles,
-}
-
-impl ::std::fmt::Debug for TerminalCharacter {
- fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- write!(f, "{}", self.character)
- }
-}
diff --git a/src/panes/terminal_pane.rs b/src/panes/terminal_pane.rs
deleted file mode 100644
index 853ae064..00000000
--- a/src/panes/terminal_pane.rs
+++ /dev/null
@@ -1,664 +0,0 @@
-#![allow(clippy::clippy::if_same_then_else)]
-
-use crate::tab::Pane;
-use ::nix::pty::Winsize;
-use ::std::os::unix::io::RawFd;
-use ::vte::Perform;
-use std::fmt::Debug;
-
-use crate::panes::grid::Grid;
-use crate::panes::terminal_character::{
- CharacterStyles, TerminalCharacter, EMPTY_TERMINAL_CHARACTER,
-};
-use crate::utils::logging::debug_log_to_file;
-use crate::VteEvent;
-
-#[derive(PartialEq, Eq, Ord, PartialOrd, Hash, Clone, Copy, Debug)]
-pub enum PaneId {
- Terminal(RawFd),
- Plugin(u32), // FIXME: Drop the trait object, make this a wrapper for the struct?
-}
-#[derive(Clone, Copy, Debug, Default)]
-pub struct PositionAndSize {
- pub x: usize,
- pub y: usize,
- pub rows: usize,
- pub columns: usize,
-}
-
-impl From<Winsize> for PositionAndSize {
- fn from(winsize: Winsize) -> PositionAndSize {
- PositionAndSize {
- columns: winsize.ws_col as usize,
- rows: winsize.ws_row as usize,
- ..Default::default()
- }
- }
-}
-
-#[derive(Debug)]
-pub struct TerminalPane {
- pub grid: Grid,
- pub alternative_grid: Option<Grid>, // for 1049h/l instructions which tell us to switch between these two
- pub pid: RawFd,
- pub should_render: bool,
- pub selectable: bool,
- pub position_and_size: PositionAndSize,
- pub position_and_size_override: Option<PositionAndSize>,
- pub cursor_key_mode: bool, // DECCKM - when set, cursor keys should send ANSI direction codes (eg. "OD") instead of the arrow keys (eg. "")
- pending_styles: CharacterStyles,
- clear_viewport_before_rendering: bool,
-}
-
-impl Pane for TerminalPane {
- fn x(&self) -> usize {
- self.get_x()
- }
- fn y(&self) -> usize {
- self.get_y()
- }
- fn rows(&self) -> usize {
- self.get_rows()
- }
- fn columns(&self) -> usize {
- self.get_columns()
- }
- fn reset_size_and_position_override(&mut self) {
- self.position_and_size_override = None;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn change_pos_and_size(&mut self, position_and_size: &PositionAndSize) {
- self.position_and_size.columns = position_and_size.columns;
- self.position_and_size.rows = position_and_size.rows;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn override_size_and_position(&mut self, x: usize, y: usize, size: &PositionAndSize) {
- let position_and_size_override = PositionAndSize {
- x,
- y,
- rows: size.rows,
- columns: size.columns,
- };
- self.position_and_size_override = Some(position_and_size_override);
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn handle_event(&mut self, event: VteEvent) {
- match event {
- VteEvent::Print(c) => {
- self.print(c);
- self.mark_for_rerender();
- }
- VteEvent::Execute(byte) => {
- self.execute(byte);
- }
- VteEvent::Hook(params, intermediates, ignore, c) => {
- self.hook(&params, &intermediates, ignore, c);
- }
- VteEvent::Put(byte) => {
- self.put(byte);
- }
- VteEvent::Unhook => {
- self.unhook();
- }
- VteEvent::OscDispatch(params, bell_terminated) => {
- let params: Vec<&[u8]> = params.iter().map(|p| &p[..]).collect();
- self.osc_dispatch(&params[..], bell_terminated);
- }
- VteEvent::CsiDispatch(params, intermediates, ignore, c) => {
- self.csi_dispatch(&params, &intermediates, ignore, c);
- }
- VteEvent::EscDispatch(intermediates, ignore, byte) => {
- self.esc_dispatch(&intermediates, ignore, byte);
- }
- }
- }
- fn cursor_coordinates(&self) -> Option<(usize, usize)> {
- // (x, y)
- self.grid.cursor_coordinates()
- }
- fn adjust_input_to_terminal(&self, input_bytes: Vec<u8>) -> Vec<u8> {
- // there are some cases in which the terminal state means that input sent to it
- // needs to be adjusted.
- // here we match against those cases - if need be, we adjust the input and if not
- // we send back the original input
- match input_bytes.as_slice() {
- [27, 91, 68] => {
- // left arrow
- if self.cursor_key_mode {
- // please note that in the line below, there is an ANSI escape code (27) at the beginning of the string,
- // some editors will not show this
- return "OD".as_bytes().to_vec();
- }
- }
- [27, 91, 67] => {
- // right arrow
- if self.cursor_key_mode {
- // please note that in the line below, there is an ANSI escape code (27) at the beginning of the string,
- // some editors will not show this
- return "OC".as_bytes().to_vec();
- }
- }
- [27, 91, 65] => {
- // up arrow
- if self.cursor_key_mode {
- // please note that in the line below, there is an ANSI escape code (27) at the beginning of the string,
- // some editors will not show this
- return "OA".as_bytes().to_vec();
- }
- }
- [27, 91, 66] => {
- // down arrow
- if self.cursor_key_mode {
- // please note that in the line below, there is an ANSI escape code (27) at the beginning of the string,
- // some editors will not show this
- return "OB".as_bytes().to_vec();
- }
- }
- _ => {}
- };
- input_bytes
- }
-
- fn position_and_size_override(&self) -> Option<PositionAndSize> {
- self.position_and_size_override
- }
- fn should_render(&self) -> bool {
- self.should_render
- }
- fn set_should_render(&mut self, should_render: bool) {
- self.should_render = should_render;
- }
- fn selectable(&self) -> bool {
- self.selectable
- }
- fn set_selectable(&mut self, selectable: bool) {
- self.selectable = selectable;
- }
- fn render(&mut self) -> Option<String> {
- // if self.should_render {
- if true {
- // while checking should_render rather than rendering each pane every time
- // is more performant, it causes some problems when the pane to the left should be
- // rendered and has wide characters (eg. Chinese characters or emoji)
- // as a (hopefully) temporary hack, we render all panes until we find a better solution
- let mut vte_output = String::new();
- let buffer_lines = &self.read_buffer_as_lines();
- let display_cols = self.get_columns();
- let mut character_styles = CharacterStyles::new();
- if self.clear_viewport_before_rendering {
- for line_index in 0..self.grid.height {
- let x = self.get_x();
- let y = self.get_y();
- vte_output = format!(
- "{}\u{1b}[{};{}H\u{1b}[m",
- vte_output,
- y + line_index + 1,
- x + 1
- ); // goto row/col and reset styles
- for _col_index in 0..self.grid.width {
- vte_output.push(EMPTY_TERMINAL_CHARACTER.character);
- }
- }
- self.clear_viewport_before_rendering = false;
- }
- for (row, line) in buffer_lines.iter().enumerate() {
- let x = self.get_x();
- let y = self.get_y();
- vte_output = format!("{}\u{1b}[{};{}H\u{1b}[m", vte_output, y + row + 1, x + 1); // goto row/col and reset styles
- for (col, t_character) in line.iter().enumerate() {
- if col < display_cols {
- // in some cases (eg. while resizing) some characters will spill over
- // before they are corrected by the shell (for the prompt) or by reflowing
- // lines
- if let Some(new_styles) =
- character_styles.update_and_return_diff(&t_character.styles)
- {
- // the terminal keeps the previous styles as long as we're in the same
- // line, so we only want to update the new styles here (this also
- // includes resetting previous styles as needed)
- vte_output = format!("{}{}", vte_output, new_styles);
- }
- vte_output.push(t_character.character);
- }
- }
- character_styles.clear();
- }
- self.mark_for_rerender();
- Some(vte_output)
- } else {
- None
- }
- }
- fn pid(&self) -> PaneId {
- PaneId::Terminal(self.pid)
- }
- fn reduce_height_down(&mut self, count: usize) {
- self.position_and_size.y += count;
- self.position_and_size.rows -= count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn increase_height_down(&mut self, count: usize) {
- self.position_and_size.rows += count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn increase_height_up(&mut self, count: usize) {
- self.position_and_size.y -= count;
- self.position_and_size.rows += count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn reduce_height_up(&mut self, count: usize) {
- self.position_and_size.rows -= count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn reduce_width_right(&mut self, count: usize) {
- self.position_and_size.x += count;
- self.position_and_size.columns -= count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn reduce_width_left(&mut self, count: usize) {
- self.position_and_size.columns -= count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn increase_width_left(&mut self, count: usize) {
- self.position_and_size.x -= count;
- self.position_and_size.columns += count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn increase_width_right(&mut self, count: usize) {
- self.position_and_size.columns += count;
- self.reflow_lines();
- self.mark_for_rerender();
- }
- fn scroll_up(&mut self, count: usize) {
- self.grid.move_viewport_up(count);
- self.mark_for_rerender();
- }
- fn scroll_down(&mut self, count: usize) {
- self.grid.move_viewport_down(count);
- self.mark_for_rerender();
- }
- fn clear_scroll(&mut self) {
- self.grid.reset_viewport();
- self.mark_for_rerender();
- }
-}
-
-impl TerminalPane {
- pub fn new(pid: RawFd, position_and_size: PositionAndSize) -> TerminalPane {
- let grid = Grid::new(position_and_size.rows, position_and_size.columns);
- let pending_styles = CharacterStyles::new();
-
- TerminalPane {
- pid,
- grid,
- alternative_grid: None,
- should_render: true,
- selectable: true,
- pending_styles,
- position_and_size,
- position_and_size_override: None,
- cursor_key_mode: false,
- clear_viewport_before_rendering: false,
- }
- }
- pub fn mark_for_rerender(&mut self) {
- self.should_render = true;
- }
- pub fn get_x(&self) -> usize {
- match self.position_and_size_override {
- Some(position_and_size_override) => position_and_size_override.x,
- None => self.position_and_size.x as usize,
- }
- }
- pub fn get_y(&self) -> usize {
- match self.position_and_size_override {
- Some(position_and_size_override) => position_and_size_override.y,
- None => self.position_and_size.y as usize,
- }
- }
- pub fn get_columns(&self) -> usize {
- match &self.position_and_size_override.as_ref() {
- Some(position_and_size_override) => position_and_size_override.columns,
- None => self.position_and_size.columns as usize,
- }
- }
- pub fn get_rows(&self) -> usize {
- match &self.position_and_size_override.as_ref() {
- Some(position_and_size_override) => position_and_size_override.rows,
- None => self.position_and_size.rows as usize,
- }
- }
- fn reflow_lines(&mut self) {
- let rows = self.get_rows();
- let columns = self.get_columns();
- self.grid.change_size(rows, columns);
- if let Some(alternative_grid) = self.alternative_grid.as_mut() {
- alternative_grid.change_size(rows, columns);
- }
- }
-
- pub fn read_buffer_as_lines(&self) -> Vec<Vec<TerminalCharacter>> {
- self.grid.as_character_lines()
- }
- #[cfg(test)]
- pub fn cursor_coordinates(&self) -> Option<(usize, usize)> {
- // (x, y)
- self.grid.cursor_coordinates()
- }
- pub fn rotate_scroll_region_up(&mut self, count: usize) {
- self.grid.rotate_scroll_region_up(count);
- self.mark_for_rerender();
- }
- pub fn rotate_scroll_region_down(&mut self, count: usize) {
- self.grid.rotate_scroll_region_down(count);
- self.mark_for_rerender();
- }
- fn add_newline(&mut self) {
- self.grid.add_canonical_line();
- // self.reset_all_ansi_codes(); // TODO: find out if we should be resetting here or not
- self.mark_for_rerender();
- }
- fn move_to_beginning_of_line(&mut self) {
- self.grid.move_cursor_to_beginning_of_line();
- }
- fn move_cursor_backwards(&mut self, count: usize) {
- self.grid.move_cursor_backwards(count);
- }
- fn _reset_all_ansi_codes(&mut self) {
- self.pending_styles.clear();
- }
-}
-
-impl vte::Perform for TerminalPane {
- fn print(&mut self, c: char) {
- // apparently, building TerminalCharacter like this without a "new" method
- // is a little faster
- let terminal_character = TerminalCharacter {
- character: c,
- styles: self.pending_styles,
- };
- self.grid.add_character(terminal_character);
- }
-
- fn execute(&mut self, byte: u8) {
- match byte {
- 8 => {
- // backspace
- self.move_cursor_backwards(1);
- }
- 9 => {
- // tab
- let terminal_tab_character = TerminalCharacter {
- character: '\t',
- styles: self.pending_styles,
- };
- // TODO: handle better with line wrapping
- self.grid.add_character(terminal_tab_character);
- }
- 10 => {
- // 0a, newline
- self.add_newline();
- }
- 13 => {
- // 0d, carriage return
- self.move_to_beginning_of_line();
- }
- _ => {}
- }
- }
-
- fn hook(&mut self, _params: &[i64], _intermediates: &[u8], _ignore: bool, _c: char) {
- // TBD
- }
-
- fn put(&mut self, _byte: u8) {
- // TBD
- }
-
- fn unhook(&mut self) {
- // TBD
- }
-
- fn osc_dispatch(&mut self, _params: &[&[u8]], _bell_terminated: bool) {
- // TBD
- }
-
- fn csi_dispatch(&mut self, params: &[i64], _intermediates: &[u8], _ignore: bool, c: char) {
- if c == 'm' {
- self.pending_styles.add_style_from_ansi_params(params);
- } else if c == 'C' {
- // move cursor forward
- let move_by = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid.move_cursor_forward_until_edge(move_by);
- } else if c == 'K' {
- // clear line (0 => right, 1 => left, 2 => all)
- if params[0] == 0 {
- let mut char_to_replace = EMPTY_TERMINAL_CHARACTER;
- char_to_replace.styles = self.pending_styles;
- self.grid
- .replace_characters_in_line_after_cursor(char_to_replace);
- } else if params[0] == 1 {
- let mut char_to_replace = EMPTY_TERMINAL_CHARACTER;
- char_to_replace.styles = self.pending_styles;
- self.grid
- .replace_characters_in_line_before_cursor(char_to_replace);
- } else if params[0] == 2 {
- self.grid.clear_cursor_line();
- }
- } else if c == 'J' {
- // clear all (0 => below, 1 => above, 2 => all, 3 => saved)
- let mut char_to_replace = EMPTY_TERMINAL_CHARACTER;
- char_to_replace.styles = self.pending_styles;
- if params[0] == 0 {
- self.grid.clear_all_after_cursor(char_to_replace);
- } else if params[0] == 2 {
- self.grid.clear_all(char_to_replace);
- }
- // TODO: implement 1
- } else if c == 'H' {
- // goto row/col
- // we subtract 1 from the row/column because these are 1 indexed
- // (except when they are 0, in which case they should be 1
- // don't look at me, I don't make the rules)
- let (row, col) = if params.len() == 1 {
- if params[0] == 0 {
- (0, params[0] as usize)
- } else {
- (params[0] as usize - 1, params[0] as usize)
- }
- } else if params[0] == 0 {
- (0, params[1] as usize - 1)
- } else {
- (params[0] as usize - 1, params[1] as usize - 1)
- };
- self.grid.move_cursor_to(col, row);
- } else if c == 'A' {
- // move cursor up until edge of screen
- let move_up_count = if params[0] == 0 { 1 } else { params[0] };
- self.grid.move_cursor_up(move_up_count as usize);
- } else if c == 'B' {
- // move cursor down until edge of screen
- let move_down_count = if params[0] == 0 { 1 } else { params[0] };
- self.grid.move_cursor_down(move_down_count as usize);
- } else if c == 'D' {
- let move_back_count = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid.move_cursor_back(move_back_count);
- } else if c == 'l' {
- let first_intermediate_is_questionmark = match _intermediates.get(0) {
- Some(b'?') => true,
- None => false,
- _ => false,
- };
- if first_intermediate_is_questionmark {
- match params.get(0) {
- Some(&1049) => {
- if let Some(alternative_grid) = self.alternative_grid.as_mut() {
- std::mem::swap(&mut self.grid, alternative_grid);
- }
- self.alternative_grid = None;
- self.clear_viewport_before_rendering = true;
- self.mark_for_rerender();
- }
- Some(&25) => {
- self.grid.hide_cursor();
- self.mark_for_rerender();
- }
- Some(&1) => {
- self.cursor_key_mode = false;
- }
- _ => {}
- };
- }
- } else if c == 'h' {
- let first_intermediate_is_questionmark = match _intermediates.get(0) {
- Some(b'?') => true,
- None => false,
- _ => false,
- };
- if first_intermediate_is_questionmark {
- match params.get(0) {
- Some(&25) => {
- self.grid.show_cursor();
- self.mark_for_rerender();
- }
- Some(&1049) => {
- let columns = self
- .position_and_size_override
- .map(|x| x.columns)
- .unwrap_or(self.position_and_size.columns);
- let rows = self
- .position_and_size_override
- .map(|x| x.rows)
- .unwrap_or(self.position_and_size.rows);
- let current_grid =
- std::mem::replace(&mut self.grid, Grid::new(rows, columns));
- self.alternative_grid = Some(current_grid);
- self.clear_viewport_before_rendering = true;
- }
- Some(&1) => {
- self.cursor_key_mode = true;
- }
- _ => {}
- };
- }
- } else if c == 'r' {
- if params.len() > 1 {
- // minus 1 because these are 1 indexed
- let top_line_index = params[0] as usize - 1;
- let bottom_line_index = params[1] as usize - 1;
- self.grid
- .set_scroll_region(top_line_index, bottom_line_index);
- self.grid.show_cursor();
- } else {
- self.grid.clear_scroll_region();
- }
- } else if c == 't' {
- // TBD - title?
- } else if c == 'n' {
- // TBD - device status report
- } else if c == 'c' {
- // TBD - identify terminal
- } else if c == 'M' {
- // delete lines if currently inside scroll region
- let line_count_to_delete = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid
- .delete_lines_in_scroll_region(line_count_to_delete);
- } else if c == 'L' {
- // insert blank lines if inside scroll region
- let line_count_to_add = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid
- .add_empty_lines_in_scroll_region(line_count_to_add);
- } else if c == 'q' {
- // ignore for now to run on mac
- } else if c == 'G' {
- let column = if params[0] == 0 {
- 0
- } else {
- params[0] as usize - 1
- };
- self.grid.move_cursor_to_column(column);
- } else if c == 'd' {
- // goto line
- let line = if params[0] == 0 {
- 1
- } else {
- // minus 1 because this is 1 indexed
- params[0] as usize - 1
- };
- self.grid.move_cursor_to_line(line);
- } else if c == 'P' {
- // erase characters
- let count = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid.erase_characters(count, self.pending_styles);
- } else if c == 'X' {
- // erase characters and replace with empty characters of current style
- let count = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid
- .replace_with_empty_chars(count, self.pending_styles);
- } else if c == 'T' {
- /*
- * 124 54 T SD
- * Scroll down, new lines inserted at top of screen
- * [4T = Scroll down 4, bring previous lines back into view
- */
- let line_count: i64 = *params.get(0).expect("A number of lines was expected.");
-
- if line_count >= 0 {
- self.rotate_scroll_region_up(line_count as usize);
- } else {
- self.rotate_scroll_region_down(line_count.abs() as usize);
- }
- } else if c == 'S' {
- // move scroll up
- let count = if params[0] == 0 {
- 1
- } else {
- params[0] as usize
- };
- self.grid.delete_lines_in_scroll_region(count);
- self.grid.add_empty_lines_in_scroll_region(count);
- } else {
- let _ = debug_log_to_file(format!("Unhandled csi: {}->{:?}", c, params));
- }
- }
-
- fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) {
- if let (b'M', None) = (byte, intermediates.get(0)) {
- self.grid.move_cursor_up_with_scrolling(1);
- }
- }
-}