diff options
| author | denis <denismaximov98@gmail.com> | 2021-01-24 18:38:46 +0200 |
|---|---|---|
| committer | denis <denismaximov98@gmail.com> | 2021-01-24 18:38:46 +0200 |
| commit | b23ef332c7531b8e9bb202bd25e7f37fd157c22c (patch) | |
| tree | 2ad09a6173e8528a91c37609e00c59d9b8a0b04b /src/panes | |
| parent | Merge branch 'main' into server-client (diff) | |
| download | sl0ppij-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.rs | 820 | ||||
| -rw-r--r-- | src/panes/mod.rs | 9 | ||||
| -rw-r--r-- | src/panes/plugin_pane.rs | 175 | ||||
| -rw-r--r-- | src/panes/terminal_character.rs | 572 | ||||
| -rw-r--r-- | src/panes/terminal_pane.rs | 664 |
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. "[D") - 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(¶ms, &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(¶ms[..], bell_terminated); - } - VteEvent::CsiDispatch(params, intermediates, ignore, c) => { - self.csi_dispatch(¶ms, &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); - } - } -} |
