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/tab.rs | |
| 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/tab.rs')
| -rw-r--r-- | src/tab.rs | 1798 |
1 files changed, 0 insertions, 1798 deletions
diff --git a/src/tab.rs b/src/tab.rs deleted file mode 100644 index 6c65958f..00000000 --- a/src/tab.rs +++ /dev/null @@ -1,1798 +0,0 @@ -use crate::panes::{PaneId, PositionAndSize, TerminalPane}; -use crate::pty_bus::{PtyInstruction, VteEvent}; -use crate::{boundaries::Boundaries, panes::PluginPane}; -use crate::{layout::Layout, wasm_vm::PluginInstruction}; -use crate::{os_input_output::OsApi, utils::shared::pad_to_size}; -use crate::{AppInstruction, SenderWithContext}; -use std::os::unix::io::RawFd; -use std::{ - cmp::Reverse, - collections::{BTreeMap, HashSet}, -}; -use std::{io::Write, sync::mpsc::channel}; - -/* - * Tab - * - * this holds multiple panes (currently terminal panes) which are currently displayed - * when this tab is active. - * it tracks their coordinates (x/y) and size, as well as how they should be resized - * - */ - -const CURSOR_HEIGHT_WIDTH_RATIO: usize = 4; // this is not accurate and kind of a magic number, TODO: look into this - -type BorderAndPaneIds = (usize, Vec<PaneId>); - -fn split_vertically_with_gap(rect: &PositionAndSize) -> (PositionAndSize, PositionAndSize) { - let width_of_each_half = (rect.columns - 1) / 2; - let mut first_rect = *rect; - let mut second_rect = *rect; - if rect.columns % 2 == 0 { - first_rect.columns = width_of_each_half + 1; - } else { - first_rect.columns = width_of_each_half; - } - second_rect.x = first_rect.x + first_rect.columns + 1; - second_rect.columns = width_of_each_half; - (first_rect, second_rect) -} - -fn split_horizontally_with_gap(rect: &PositionAndSize) -> (PositionAndSize, PositionAndSize) { - let height_of_each_half = (rect.rows - 1) / 2; - let mut first_rect = *rect; - let mut second_rect = *rect; - if rect.rows % 2 == 0 { - first_rect.rows = height_of_each_half + 1; - } else { - first_rect.rows = height_of_each_half; - } - second_rect.y = first_rect.y + first_rect.rows + 1; - second_rect.rows = height_of_each_half; - (first_rect, second_rect) -} - -pub struct Tab { - pub index: usize, - panes: BTreeMap<PaneId, Box<dyn Pane>>, - panes_to_hide: HashSet<PaneId>, - active_terminal: Option<PaneId>, - max_panes: Option<usize>, - full_screen_ws: PositionAndSize, - fullscreen_is_active: bool, - os_api: Box<dyn OsApi>, - pub send_pty_instructions: SenderWithContext<PtyInstruction>, - pub send_plugin_instructions: SenderWithContext<PluginInstruction>, - pub send_app_instructions: SenderWithContext<AppInstruction>, -} - -// FIXME: Use a struct that has a pane_type enum, to reduce all of the duplication -pub trait Pane { - fn x(&self) -> usize; - fn y(&self) -> usize; - fn rows(&self) -> usize; - fn columns(&self) -> usize; - fn reset_size_and_position_override(&mut self); - fn change_pos_and_size(&mut self, position_and_size: &PositionAndSize); - fn override_size_and_position(&mut self, x: usize, y: usize, size: &PositionAndSize); - fn handle_event(&mut self, event: VteEvent); - fn cursor_coordinates(&self) -> Option<(usize, usize)>; - fn adjust_input_to_terminal(&self, input_bytes: Vec<u8>) -> Vec<u8>; - - fn position_and_size_override(&self) -> Option<PositionAndSize>; - fn should_render(&self) -> bool; - fn set_should_render(&mut self, should_render: bool); - fn selectable(&self) -> bool; - fn set_selectable(&mut self, selectable: bool); - fn render(&mut self) -> Option<String>; - fn pid(&self) -> PaneId; - fn reduce_height_down(&mut self, count: usize); - fn increase_height_down(&mut self, count: usize); - fn increase_height_up(&mut self, count: usize); - fn reduce_height_up(&mut self, count: usize); - fn increase_width_right(&mut self, count: usize); - fn reduce_width_right(&mut self, count: usize); - fn reduce_width_left(&mut self, count: usize); - fn increase_width_left(&mut self, count: usize); - fn scroll_up(&mut self, count: usize); - fn scroll_down(&mut self, count: usize); - fn clear_scroll(&mut self); - - fn right_boundary_x_coords(&self) -> usize { - self.x() + self.columns() - } - fn bottom_boundary_y_coords(&self) -> usize { - self.y() + self.rows() - } - fn is_directly_right_of(&self, other: &dyn Pane) -> bool { - self.x() == other.x() + other.columns() + 1 - } - fn is_directly_left_of(&self, other: &dyn Pane) -> bool { - self.x() + self.columns() + 1 == other.x() - } - fn is_directly_below(&self, other: &dyn Pane) -> bool { - self.y() == other.y() + other.rows() + 1 - } - fn is_directly_above(&self, other: &dyn Pane) -> bool { - self.y() + self.rows() + 1 == other.y() - } - fn horizontally_overlaps_with(&self, other: &dyn Pane) -> bool { - (self.y() >= other.y() && self.y() <= (other.y() + other.rows())) - || ((self.y() + self.rows()) <= (other.y() + other.rows()) - && (self.y() + self.rows()) > other.y()) - || (self.y() <= other.y() && (self.y() + self.rows() >= (other.y() + other.rows()))) - || (other.y() <= self.y() && (other.y() + other.rows() >= (self.y() + self.rows()))) - } - fn get_horizontal_overlap_with(&self, other: &dyn Pane) -> usize { - std::cmp::min(self.y() + self.rows(), other.y() + other.rows()) - - std::cmp::max(self.y(), other.y()) - } - fn vertically_overlaps_with(&self, other: &dyn Pane) -> bool { - (self.x() >= other.x() && self.x() <= (other.x() + other.columns())) - || ((self.x() + self.columns()) <= (other.x() + other.columns()) - && (self.x() + self.columns()) > other.x()) - || (self.x() <= other.x() - && (self.x() + self.columns() >= (other.x() + other.columns()))) - || (other.x() <= self.x() - && (other.x() + other.columns() >= (self.x() + self.columns()))) - } - fn get_vertical_overlap_with(&self, other: &dyn Pane) -> usize { - std::cmp::min(self.x() + self.columns(), other.x() + other.columns()) - - std::cmp::max(self.x(), other.x()) - } -} - -impl Tab { - // FIXME: Too many arguments here! Maybe bundle all of the senders for the whole program in a struct? - pub fn new( - index: usize, - full_screen_ws: &PositionAndSize, - mut os_api: Box<dyn OsApi>, - send_pty_instructions: SenderWithContext<PtyInstruction>, - send_plugin_instructions: SenderWithContext<PluginInstruction>, - send_app_instructions: SenderWithContext<AppInstruction>, - max_panes: Option<usize>, - pane_id: Option<PaneId>, - ) -> Self { - let panes = if let Some(PaneId::Terminal(pid)) = pane_id { - let new_terminal = TerminalPane::new(pid, *full_screen_ws); - os_api.set_terminal_size_using_fd( - new_terminal.pid, - new_terminal.columns() as u16, - new_terminal.rows() as u16, - ); - let mut panes: BTreeMap<PaneId, Box<dyn Pane>> = BTreeMap::new(); - panes.insert(PaneId::Terminal(pid), Box::new(new_terminal)); - panes - } else { - BTreeMap::new() - }; - Tab { - index, - panes, - max_panes, - panes_to_hide: HashSet::new(), - active_terminal: pane_id, - full_screen_ws: *full_screen_ws, - fullscreen_is_active: false, - os_api, - send_app_instructions, - send_pty_instructions, - send_plugin_instructions, - } - } - - pub fn apply_layout(&mut self, layout: Layout, new_pids: Vec<RawFd>) { - // TODO: this should be an attribute on Screen instead of full_screen_ws - let free_space = PositionAndSize { - x: 0, - y: 0, - rows: self.full_screen_ws.rows, - columns: self.full_screen_ws.columns, - }; - self.panes_to_hide.clear(); - let positions_in_layout = layout.position_panes_in_space(&free_space); - let mut positions_and_size = positions_in_layout.iter(); - for (pane_kind, terminal_pane) in self.panes.iter_mut() { - // for now the layout only supports terminal panes - if let PaneId::Terminal(pid) = pane_kind { - match positions_and_size.next() { - Some((_, position_and_size)) => { - terminal_pane.reset_size_and_position_override(); - terminal_pane.change_pos_and_size(&position_and_size); - self.os_api.set_terminal_size_using_fd( - *pid, - position_and_size.columns as u16, - position_and_size.rows as u16, - ); - } - None => { - // we filled the entire layout, no room for this pane - // TODO: handle active terminal - self.panes_to_hide.insert(PaneId::Terminal(*pid)); - } - } - } - } - let mut new_pids = new_pids.iter(); - for (layout, position_and_size) in positions_and_size { - // Just a regular terminal - if let Some(plugin) = &layout.plugin { - let (pid_tx, pid_rx) = channel(); - self.send_plugin_instructions - .send(PluginInstruction::Load(pid_tx, plugin.clone())) - .unwrap(); - let pid = pid_rx.recv().unwrap(); - let new_plugin = PluginPane::new( - pid, - *position_and_size, - self.send_plugin_instructions.clone(), - ); - self.panes.insert(PaneId::Plugin(pid), Box::new(new_plugin)); - } else { - // there are still panes left to fill, use the pids we received in this method - let pid = new_pids.next().unwrap(); // if this crashes it means we got less pids than there are panes in this layout - let new_terminal = TerminalPane::new(*pid, *position_and_size); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - new_terminal.columns() as u16, - new_terminal.rows() as u16, - ); - self.panes - .insert(PaneId::Terminal(*pid), Box::new(new_terminal)); - } - } - for unused_pid in new_pids { - // this is a bit of a hack and happens because we don't have any central location that - // can query the screen as to how many panes it needs to create a layout - // fixing this will require a bit of an architecture change - self.send_pty_instructions - .send(PtyInstruction::ClosePane(PaneId::Terminal(*unused_pid))) - .unwrap(); - } - self.active_terminal = self.panes.iter().map(|(id, _)| id.to_owned()).next(); - self.render(); - } - pub fn new_pane(&mut self, pid: PaneId) { - self.close_down_to_max_terminals(); - if self.fullscreen_is_active { - self.toggle_active_pane_fullscreen(); - } - if !self.has_panes() { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - let new_terminal = TerminalPane::new(term_pid, self.full_screen_ws); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - new_terminal.columns() as u16, - new_terminal.rows() as u16, - ); - self.panes.insert(pid, Box::new(new_terminal)); - self.active_terminal = Some(pid); - } - } else { - // TODO: check minimum size of active terminal - - let (_longest_edge, terminal_id_to_split) = self.get_panes().fold( - (0, PaneId::Terminal(0)), // FIXME: This is a bit hacky, try to use a maximum method? - |(current_longest_edge, current_terminal_id_to_split), id_and_terminal_to_check| { - let (id_of_terminal_to_check, terminal_to_check) = id_and_terminal_to_check; - let terminal_size = (terminal_to_check.rows() * CURSOR_HEIGHT_WIDTH_RATIO) - * terminal_to_check.columns(); - if terminal_size > current_longest_edge { - (terminal_size, *id_of_terminal_to_check) - } else { - (current_longest_edge, current_terminal_id_to_split) - } - }, - ); - let terminal_to_split = self.panes.get_mut(&terminal_id_to_split).unwrap(); - let terminal_ws = PositionAndSize { - rows: terminal_to_split.rows(), - columns: terminal_to_split.columns(), - x: terminal_to_split.x(), - y: terminal_to_split.y(), - }; - if terminal_to_split.rows() * CURSOR_HEIGHT_WIDTH_RATIO > terminal_to_split.columns() { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - let (top_winsize, bottom_winsize) = split_horizontally_with_gap(&terminal_ws); - let new_terminal = TerminalPane::new(term_pid, bottom_winsize); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - bottom_winsize.columns as u16, - bottom_winsize.rows as u16, - ); - terminal_to_split.change_pos_and_size(&top_winsize); - self.panes.insert(pid, Box::new(new_terminal)); - if let PaneId::Terminal(terminal_id_to_split) = terminal_id_to_split { - self.os_api.set_terminal_size_using_fd( - terminal_id_to_split, - top_winsize.columns as u16, - top_winsize.rows as u16, - ); - } - self.active_terminal = Some(pid); - } - } else { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - let (left_winszie, right_winsize) = split_vertically_with_gap(&terminal_ws); - let new_terminal = TerminalPane::new(term_pid, right_winsize); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - right_winsize.columns as u16, - right_winsize.rows as u16, - ); - terminal_to_split.change_pos_and_size(&left_winszie); - self.panes.insert(pid, Box::new(new_terminal)); - if let PaneId::Terminal(terminal_id_to_split) = terminal_id_to_split { - self.os_api.set_terminal_size_using_fd( - terminal_id_to_split, - left_winszie.columns as u16, - left_winszie.rows as u16, - ); - } - } - } - self.active_terminal = Some(pid); - self.render(); - } - } - pub fn horizontal_split(&mut self, pid: PaneId) { - self.close_down_to_max_terminals(); - if self.fullscreen_is_active { - self.toggle_active_pane_fullscreen(); - } - if !self.has_panes() { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - let new_terminal = TerminalPane::new(term_pid, self.full_screen_ws); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - new_terminal.columns() as u16, - new_terminal.rows() as u16, - ); - self.panes.insert(pid, Box::new(new_terminal)); - self.active_terminal = Some(pid); - } - } else { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - // TODO: check minimum size of active terminal - let active_pane_id = &self.get_active_pane_id().unwrap(); - let active_pane = self.panes.get_mut(active_pane_id).unwrap(); - let terminal_ws = PositionAndSize { - x: active_pane.x(), - y: active_pane.y(), - rows: active_pane.rows(), - columns: active_pane.columns(), - }; - let (top_winsize, bottom_winsize) = split_horizontally_with_gap(&terminal_ws); - - active_pane.change_pos_and_size(&top_winsize); - - let new_terminal = TerminalPane::new(term_pid, bottom_winsize); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - bottom_winsize.columns as u16, - bottom_winsize.rows as u16, - ); - self.panes.insert(pid, Box::new(new_terminal)); - - if let PaneId::Terminal(active_terminal_pid) = active_pane_id { - self.os_api.set_terminal_size_using_fd( - *active_terminal_pid, - top_winsize.columns as u16, - top_winsize.rows as u16, - ); - } - - self.active_terminal = Some(pid); - self.render(); - } - } - } - pub fn vertical_split(&mut self, pid: PaneId) { - self.close_down_to_max_terminals(); - if self.fullscreen_is_active { - self.toggle_active_pane_fullscreen(); - } - if !self.has_panes() { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - let new_terminal = TerminalPane::new(term_pid, self.full_screen_ws); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - new_terminal.columns() as u16, - new_terminal.rows() as u16, - ); - self.panes.insert(pid, Box::new(new_terminal)); - self.active_terminal = Some(pid); - } - } else { - // FIXME: This could use a second look - if let PaneId::Terminal(term_pid) = pid { - // TODO: check minimum size of active terminal - let active_pane_id = &self.get_active_pane_id().unwrap(); - let active_pane = self.panes.get_mut(active_pane_id).unwrap(); - let terminal_ws = PositionAndSize { - x: active_pane.x(), - y: active_pane.y(), - rows: active_pane.rows(), - columns: active_pane.columns(), - }; - let (left_winsize, right_winsize) = split_vertically_with_gap(&terminal_ws); - - active_pane.change_pos_and_size(&left_winsize); - - let new_terminal = TerminalPane::new(term_pid, right_winsize); - self.os_api.set_terminal_size_using_fd( - new_terminal.pid, - right_winsize.columns as u16, - right_winsize.rows as u16, - ); - self.panes.insert(pid, Box::new(new_terminal)); - - if let PaneId::Terminal(active_terminal_pid) = active_pane_id { - self.os_api.set_terminal_size_using_fd( - *active_terminal_pid, - left_winsize.columns as u16, - left_winsize.rows as u16, - ); - } - - self.active_terminal = Some(pid); - self.render(); - } - } - } - pub fn get_active_pane(&self) -> Option<&dyn Pane> { - // FIXME: Could use Option::map() here - match self.get_active_pane_id() { - Some(active_pane) => self.panes.get(&active_pane).map(Box::as_ref), - None => None, - } - } - fn get_active_pane_id(&self) -> Option<PaneId> { - self.active_terminal - } - fn get_active_terminal_id(&self) -> Option<RawFd> { - // FIXME: Is there a better way to do this? - if let Some(PaneId::Terminal(pid)) = self.active_terminal { - Some(pid) - } else { - None - } - } - pub fn handle_pty_event(&mut self, pid: RawFd, event: VteEvent) { - // if we don't have the terminal in self.terminals it's probably because - // of a race condition where the terminal was created in pty_bus but has not - // yet been created in Screen. These events are currently not buffered, so - // if you're debugging seemingly randomly missing stdout data, this is - // the reason - if let Some(terminal_output) = self.panes.get_mut(&PaneId::Terminal(pid)) { - terminal_output.handle_event(event); - } - } - pub fn write_to_active_terminal(&mut self, input_bytes: Vec<u8>) { - match self.get_active_pane_id() { - Some(PaneId::Terminal(active_terminal_id)) => { - let active_terminal = self.get_active_pane().unwrap(); - let mut adjusted_input = active_terminal.adjust_input_to_terminal(input_bytes); - self.os_api - .write_to_tty_stdin(active_terminal_id, &mut adjusted_input) - .expect("failed to write to terminal"); - self.os_api - .tcdrain(active_terminal_id) - .expect("failed to drain terminal"); - } - Some(PaneId::Plugin(pid)) => { - self.send_plugin_instructions - .send(PluginInstruction::Input(pid, input_bytes)) - .unwrap(); - } - _ => {} - } - } - pub fn get_active_terminal_cursor_position(&self) -> Option<(usize, usize)> { - // (x, y) - let active_terminal = &self.get_active_pane()?; - active_terminal - .cursor_coordinates() - .map(|(x_in_terminal, y_in_terminal)| { - let x = active_terminal.x() + x_in_terminal; - let y = active_terminal.y() + y_in_terminal; - (x, y) - }) - } - pub fn toggle_active_pane_fullscreen(&mut self) { - if let Some(active_pane_id) = self.get_active_pane_id() { - if self - .get_active_pane() - .unwrap() - .position_and_size_override() - .is_some() - { - for terminal_id in self.panes_to_hide.iter() { - self.panes - .get_mut(terminal_id) - .unwrap() - .set_should_render(true); - } - self.panes_to_hide.clear(); - let active_terminal = self.panes.get_mut(&active_pane_id).unwrap(); - active_terminal.reset_size_and_position_override(); - } else { - let terminals = self.get_panes(); - let all_ids_except_current = - terminals.filter_map( - |(&id, _)| { - if id != active_pane_id { - Some(id) - } else { - None - } - }, - ); - self.panes_to_hide = all_ids_except_current.collect(); - let active_terminal = self.panes.get_mut(&active_pane_id).unwrap(); - active_terminal.override_size_and_position(0, 0, &self.full_screen_ws); - } - let active_terminal = self.panes.get(&active_pane_id).unwrap(); - if let PaneId::Terminal(active_pid) = active_pane_id { - self.os_api.set_terminal_size_using_fd( - active_pid, - active_terminal.columns() as u16, - active_terminal.rows() as u16, - ); - } - self.render(); - self.toggle_fullscreen_is_active(); - } - } - pub fn toggle_fullscreen_is_active(&mut self) { - self.fullscreen_is_active = !self.fullscreen_is_active; - } - pub fn render(&mut self) { - if self.active_terminal.is_none() { - // we might not have an active terminal if we closed the last pane - // in that case, we should not render as the app is exiting - return; - } - let mut stdout = self.os_api.get_stdout_writer(); - let mut boundaries = Boundaries::new( - self.full_screen_ws.columns as u16, - self.full_screen_ws.rows as u16, - ); - for (kind, terminal) in self.panes.iter_mut() { - if !self.panes_to_hide.contains(&terminal.pid()) { - boundaries.add_rect(terminal.as_ref()); - if let Some(vte_output) = terminal.render() { - let vte_output = if let PaneId::Terminal(_) = kind { - vte_output - } else { - pad_to_size(&vte_output, terminal.rows(), terminal.columns()) - }; - // FIXME: Use Termion for cursor and style clearing? - write!( - stdout, - "\u{1b}[{};{}H\u{1b}[m{}", - terminal.y() + 1, - terminal.x() + 1, - vte_output - ) - .expect("cannot write to stdout"); - } - } - } - - // TODO: only render (and calculate) boundaries if there was a resize - let vte_output = boundaries.vte_output(); - stdout - .write_all(&vte_output.as_bytes()) - .expect("cannot write to stdout"); - - match self.get_active_terminal_cursor_position() { - Some((cursor_position_x, cursor_position_y)) => { - let show_cursor = "\u{1b}[?25h"; - let goto_cursor_position = format!( - "\u{1b}[{};{}H\u{1b}[m", - cursor_position_y + 1, - cursor_position_x + 1 - ); // goto row/col - stdout - .write_all(&show_cursor.as_bytes()) - .expect("cannot write to stdout"); - stdout - .write_all(&goto_cursor_position.as_bytes()) - .expect("cannot write to stdout"); - stdout.flush().expect("could not flush"); - } - None => { - let hide_cursor = "\u{1b}[?25l"; - stdout - .write_all(&hide_cursor.as_bytes()) - .expect("cannot write to stdout"); - stdout.flush().expect("could not flush"); - } - } - } - fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> { - self.panes.iter() - } - // FIXME: This is some shameful duplication... - fn get_selectable_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> { - self.panes.iter().filter(|(_, p)| p.selectable()) - } - fn has_panes(&self) -> bool { - let mut all_terminals = self.get_panes(); - all_terminals.next().is_some() - } - fn has_selectable_panes(&self) -> bool { - let mut all_terminals = self.get_selectable_panes(); - all_terminals.next().is_some() - } - fn next_active_pane(&self, panes: Vec<PaneId>) -> Option<PaneId> { - panes - .into_iter() - .rev() - .find(|pid| self.panes.get(pid).unwrap().selectable()) - } - fn pane_ids_directly_left_of(&self, id: &PaneId) -> Option<Vec<PaneId>> { - let mut ids = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - if terminal_to_check.x() == 0 { - return None; - } - for (&pid, terminal) in self.get_panes() { - if terminal.x() + terminal.columns() == terminal_to_check.x() - 1 { - ids.push(pid); - } - } - if ids.is_empty() { - None - } else { - Some(ids) - } - } - fn pane_ids_directly_right_of(&self, id: &PaneId) -> Option<Vec<PaneId>> { - let mut ids = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - for (&pid, terminal) in self.get_panes() { - if terminal.x() == terminal_to_check.x() + terminal_to_check.columns() + 1 { - ids.push(pid); - } - } - if ids.is_empty() { - None - } else { - Some(ids) - } - } - fn pane_ids_directly_below(&self, id: &PaneId) -> Option<Vec<PaneId>> { - let mut ids = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - for (&pid, terminal) in self.get_panes() { - if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() + 1 { - ids.push(pid); - } - } - if ids.is_empty() { - None - } else { - Some(ids) - } - } - fn pane_ids_directly_above(&self, id: &PaneId) -> Option<Vec<PaneId>> { - let mut ids = vec![]; - let terminal_to_check = self.panes.get(id).unwrap(); - for (&pid, terminal) in self.get_panes() { - if terminal.y() + terminal.rows() + 1 == terminal_to_check.y() { - ids.push(pid); - } - } - if ids.is_empty() { - None - } else { - Some(ids) - } - } - fn panes_top_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { - self.panes - .keys() - .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) - .filter(|terminal| terminal.pid() != pane.pid() && terminal.y() == pane.y()) - .collect() - } - fn panes_bottom_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { - self.panes - .keys() - .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) - .filter(|terminal| { - terminal.pid() != pane.pid() - && terminal.y() + terminal.rows() == pane.y() + pane.rows() - }) - .collect() - } - fn panes_right_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { - self.panes - .keys() - .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) - .filter(|terminal| { - terminal.pid() != pane.pid() - && terminal.x() + terminal.columns() == pane.x() + pane.columns() - }) - .collect() - } - fn panes_left_aligned_with_pane(&self, pane: &dyn Pane) -> Vec<&dyn Pane> { - self.panes - .keys() - .map(|t_id| self.panes.get(&t_id).unwrap().as_ref()) - .filter(|terminal| terminal.pid() != pane.pid() && terminal.x() == pane.x()) - .collect() - } - fn right_aligned_contiguous_panes_above( - &self, - id: &PaneId, - terminal_borders_to_the_right: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self - .panes - .get(id) - .expect("terminal id does not exist") - .as_ref(); - let mut right_aligned_terminals = self.panes_right_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - right_aligned_terminals.sort_by_key(|a| Reverse(a.y())); - for terminal in right_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.y() + terminal.rows() + 1 == terminal_to_check.y() { - terminals.push(terminal); - } - } - // top-most border aligned with a pane border to the right - let mut top_resize_border = 0; - for terminal in &terminals { - let bottom_terminal_boundary = terminal.y() + terminal.rows(); - if terminal_borders_to_the_right - .get(&(bottom_terminal_boundary + 1)) - .is_some() - && top_resize_border < bottom_terminal_boundary - { - top_resize_border = bottom_terminal_boundary + 1; - } - } - terminals.retain(|terminal| terminal.y() >= top_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let top_resize_border = if terminals.is_empty() { - terminal_to_check.y() - } else { - top_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (top_resize_border, terminal_ids) - } - fn right_aligned_contiguous_panes_below( - &self, - id: &PaneId, - terminal_borders_to_the_right: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self - .panes - .get(id) - .expect("terminal id does not exist") - .as_ref(); - let mut right_aligned_terminals = self.panes_right_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - right_aligned_terminals.sort_by_key(|a| a.y()); - for terminal in right_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() + 1 { - terminals.push(terminal); - } - } - // bottom-most border aligned with a pane border to the right - let mut bottom_resize_border = self.full_screen_ws.rows; - for terminal in &terminals { - let top_terminal_boundary = terminal.y(); - if terminal_borders_to_the_right - .get(&(top_terminal_boundary)) - .is_some() - && top_terminal_boundary < bottom_resize_border - { - bottom_resize_border = top_terminal_boundary; - } - } - terminals.retain(|terminal| terminal.y() + terminal.rows() <= bottom_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let bottom_resize_border = if terminals.is_empty() { - terminal_to_check.y() + terminal_to_check.rows() - } else { - bottom_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (bottom_resize_border, terminal_ids) - } - fn left_aligned_contiguous_panes_above( - &self, - id: &PaneId, - terminal_borders_to_the_left: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self - .panes - .get(id) - .expect("terminal id does not exist") - .as_ref(); - let mut left_aligned_terminals = self.panes_left_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - left_aligned_terminals.sort_by_key(|a| Reverse(a.y())); - for terminal in left_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.y() + terminal.rows() + 1 == terminal_to_check.y() { - terminals.push(terminal); - } - } - // top-most border aligned with a pane border to the right - let mut top_resize_border = 0; - for terminal in &terminals { - let bottom_terminal_boundary = terminal.y() + terminal.rows(); - if terminal_borders_to_the_left - .get(&(bottom_terminal_boundary + 1)) - .is_some() - && top_resize_border < bottom_terminal_boundary - { - top_resize_border = bottom_terminal_boundary + 1; - } - } - terminals.retain(|terminal| terminal.y() >= top_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let top_resize_border = if terminals.is_empty() { - terminal_to_check.y() - } else { - top_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (top_resize_border, terminal_ids) - } - fn left_aligned_contiguous_panes_below( - &self, - id: &PaneId, - terminal_borders_to_the_left: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self - .panes - .get(id) - .expect("terminal id does not exist") - .as_ref(); - let mut left_aligned_terminals = self.panes_left_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - left_aligned_terminals.sort_by_key(|a| a.y()); - for terminal in left_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() + 1 { - terminals.push(terminal); - } - } - // bottom-most border aligned with a pane border to the left - let mut bottom_resize_border = self.full_screen_ws.rows; - for terminal in &terminals { - let top_terminal_boundary = terminal.y(); - if terminal_borders_to_the_left - .get(&(top_terminal_boundary)) - .is_some() - && top_terminal_boundary < bottom_resize_border - { - bottom_resize_border = top_terminal_boundary; - } - } - terminals.retain(|terminal| { - // terminal.y() + terminal.rows() < bottom_resize_border - terminal.y() + terminal.rows() <= bottom_resize_border - }); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let bottom_resize_border = if terminals.is_empty() { - terminal_to_check.y() + terminal_to_check.rows() - } else { - bottom_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (bottom_resize_border, terminal_ids) - } - fn top_aligned_contiguous_panes_to_the_left( - &self, - id: &PaneId, - terminal_borders_above: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self - .panes - .get(id) - .expect("terminal id does not exist") - .as_ref(); - let mut top_aligned_terminals = self.panes_top_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - top_aligned_terminals.sort_by_key(|a| Reverse(a.x())); - for terminal in top_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.x() + terminal.columns() + 1 == terminal_to_check.x() { - terminals.push(terminal); - } - } - // leftmost border aligned with a pane border above - let mut left_resize_border = 0; - for terminal in &terminals { - let right_terminal_boundary = terminal.x() + terminal.columns(); - if terminal_borders_above - .get(&(right_terminal_boundary + 1)) - .is_some() - && left_resize_border < right_terminal_boundary - { - left_resize_border = right_terminal_boundary + 1; - } - } - terminals.retain(|terminal| terminal.x() >= left_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let left_resize_border = if terminals.is_empty() { - terminal_to_check.x() - } else { - left_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (left_resize_border, terminal_ids) - } - fn top_aligned_contiguous_panes_to_the_right( - &self, - id: &PaneId, - terminal_borders_above: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap().as_ref(); - let mut top_aligned_terminals = self.panes_top_aligned_with_pane(terminal_to_check); - // terminals that are next to each other up to current - top_aligned_terminals.sort_by_key(|a| a.x()); - for terminal in top_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.x() == terminal_to_check.x() + terminal_to_check.columns() + 1 { - terminals.push(terminal); - } - } - // rightmost border aligned with a pane border above - let mut right_resize_border = self.full_screen_ws.columns; - for terminal in &terminals { - let left_terminal_boundary = terminal.x(); - if terminal_borders_above - .get(&left_terminal_boundary) - .is_some() - && right_resize_border > left_terminal_boundary - { - right_resize_border = left_terminal_boundary; - } - } - terminals.retain(|terminal| terminal.x() + terminal.columns() <= right_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let right_resize_border = if terminals.is_empty() { - terminal_to_check.x() + terminal_to_check.columns() - } else { - right_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (right_resize_border, terminal_ids) - } - fn bottom_aligned_contiguous_panes_to_the_left( - &self, - id: &PaneId, - terminal_borders_below: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap().as_ref(); - let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(terminal_to_check); - bottom_aligned_terminals.sort_by_key(|a| Reverse(a.x())); - // terminals that are next to each other up to current - for terminal in bottom_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.x() + terminal.columns() + 1 == terminal_to_check.x() { - terminals.push(terminal); - } - } - // leftmost border aligned with a pane border above - let mut left_resize_border = 0; - for terminal in &terminals { - let right_terminal_boundary = terminal.x() + terminal.columns(); - if terminal_borders_below - .get(&(right_terminal_boundary + 1)) - .is_some() - && left_resize_border < right_terminal_boundary - { - left_resize_border = right_terminal_boundary + 1; - } - } - terminals.retain(|terminal| terminal.x() >= left_resize_border); - // if there are no adjacent panes to resize, we use the border of the main pane we're - // resizing - let left_resize_border = if terminals.is_empty() { - terminal_to_check.x() - } else { - left_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (left_resize_border, terminal_ids) - } - fn bottom_aligned_contiguous_panes_to_the_right( - &self, - id: &PaneId, - terminal_borders_below: &HashSet<usize>, - ) -> BorderAndPaneIds { - let mut terminals = vec![]; - let terminal_to_check = self.panes.get(id).unwrap().as_ref(); - let mut bottom_aligned_terminals = self.panes_bottom_aligned_with_pane(terminal_to_check); - bottom_aligned_terminals.sort_by_key(|a| a.x()); - // terminals that are next to each other up to current - for terminal in bottom_aligned_terminals { - let terminal_to_check = terminals.last().unwrap_or(&terminal_to_check); - if terminal.x() == terminal_to_check.x() + terminal_to_check.columns() + 1 { - terminals.push(terminal); - } - } - // leftmost border aligned with a pane border above - let mut right_resize_border = self.full_screen_ws.columns; - for terminal in &terminals { - let left_terminal_boundary = terminal.x(); - if terminal_borders_below - .get(&left_terminal_boundary) - .is_some() - && right_resize_border > left_terminal_boundary - { - right_resize_border = left_terminal_boundary; - } - } - terminals.retain(|terminal| terminal.x() + terminal.columns() <= right_resize_border); - let right_resize_border = if terminals.is_empty() { - terminal_to_check.x() + terminal_to_check.columns() - } else { - right_resize_border - }; - let terminal_ids: Vec<PaneId> = terminals.iter().map(|t| t.pid()).collect(); - (right_resize_border, terminal_ids) - } - fn reduce_pane_height_down(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.reduce_height_down(count); - if let PaneId::Terminal(pid) = id { - self.os_api.set_terminal_size_using_fd( - *pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn reduce_pane_height_up(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.reduce_height_up(count); - if let PaneId::Terminal(pid) = id { - self.os_api.set_terminal_size_using_fd( - *pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn increase_pane_height_down(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.increase_height_down(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn increase_pane_height_up(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.increase_height_up(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn increase_pane_width_right(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.increase_width_right(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn increase_pane_width_left(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.increase_width_left(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn reduce_pane_width_right(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.reduce_width_right(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn reduce_pane_width_left(&mut self, id: &PaneId, count: usize) { - let terminal = self.panes.get_mut(id).unwrap(); - terminal.reduce_width_left(count); - if let PaneId::Terminal(pid) = terminal.pid() { - self.os_api.set_terminal_size_using_fd( - pid, - terminal.columns() as u16, - terminal.rows() as u16, - ); - } - } - fn pane_is_between_vertical_borders( - &self, - id: &PaneId, - left_border_x: usize, - right_border_x: usize, - ) -> bool { - let terminal = self - .panes - .get(id) - .expect("could not find terminal to check between borders"); - terminal.x() >= left_border_x && terminal.x() + terminal.columns() <= right_border_x - } - fn pane_is_between_horizontal_borders( - &self, - id: &PaneId, - top_border_y: usize, - bottom_border_y: usize, - ) -> bool { - let terminal = self - .panes - .get(id) - .expect("could not find terminal to check between borders"); - terminal.y() >= top_border_y && terminal.y() + terminal.rows() <= bottom_border_y - } - fn reduce_pane_and_surroundings_up(&mut self, id: &PaneId, count: usize) { - let mut terminals_below = self - .pane_ids_directly_below(&id) - .expect("can't reduce pane size up if there are no terminals below"); - let terminal_borders_below: HashSet<usize> = terminals_below - .iter() - .map(|t| self.panes.get(t).unwrap().x()) - .collect(); - let (left_resize_border, terminals_to_the_left) = - self.bottom_aligned_contiguous_panes_to_the_left(&id, &terminal_borders_below); - let (right_resize_border, terminals_to_the_right) = - self.bottom_aligned_contiguous_panes_to_the_right(&id, &terminal_borders_below); - terminals_below.retain(|t| { - self.pane_is_between_vertical_borders(t, left_resize_border, right_resize_border) - }); - self.reduce_pane_height_up(&id, count); - for terminal_id in terminals_below { - self.increase_pane_height_up(&terminal_id, count); - } - for terminal_id in terminals_to_the_left - .iter() - .chain(terminals_to_the_right.iter()) - { - self.reduce_pane_height_up(&terminal_id, count); - } - } - fn reduce_pane_and_surroundings_down(&mut self, id: &PaneId, count: usize) { - let mut terminals_above = self - .pane_ids_directly_above(&id) - .expect("can't reduce pane size down if there are no terminals above"); - let terminal_borders_above: HashSet<usize> = terminals_above - .iter() - .map(|t| self.panes.get(t).unwrap().x()) - .collect(); - let (left_resize_border, terminals_to_the_left) = - self.top_aligned_contiguous_panes_to_the_left(&id, &terminal_borders_above); - let (right_resize_border, terminals_to_the_right) = - self.top_aligned_contiguous_panes_to_the_right(&id, &terminal_borders_above); - terminals_above.retain(|t| { - self.pane_is_between_vertical_borders(t, left_resize_border, right_resize_border) - }); - self.reduce_pane_height_down(&id, count); - for terminal_id in terminals_above { - self.increase_pane_height_down(&terminal_id, count); - } - for terminal_id in terminals_to_the_left - .iter() - .chain(terminals_to_the_right.iter()) - { - self.reduce_pane_height_down(&terminal_id, count); - } - } - fn reduce_pane_and_surroundings_right(&mut self, id: &PaneId, count: usize) { - let mut terminals_to_the_left = self - .pane_ids_directly_left_of(&id) - .expect("can't reduce pane size right if there are no terminals to the left"); - let terminal_borders_to_the_left: HashSet<usize> = terminals_to_the_left - .iter() - .map(|t| self.panes.get(t).unwrap().y()) - .collect(); - let (top_resize_border, terminals_above) = - self.left_aligned_contiguous_panes_above(&id, &terminal_borders_to_the_left); - let (bottom_resize_border, terminals_below) = - self.left_aligned_contiguous_panes_below(&id, &terminal_borders_to_the_left); - terminals_to_the_left.retain(|t| { - self.pane_is_between_horizontal_borders(t, top_resize_border, bottom_resize_border) - }); - self.reduce_pane_width_right(&id, count); - for terminal_id in terminals_to_the_left { - self.increase_pane_width_right(&terminal_id, count); - } - for terminal_id in terminals_above.iter().chain(terminals_below.iter()) { - self.reduce_pane_width_right(&terminal_id, count); - } - } - fn reduce_pane_and_surroundings_left(&mut self, id: &PaneId, count: usize) { - let mut terminals_to_the_right = self - .pane_ids_directly_right_of(&id) - .expect("can't reduce pane size left if there are no terminals to the right"); - let terminal_borders_to_the_right: HashSet<usize> = terminals_to_the_right - .iter() - .map(|t| self.panes.get(t).unwrap().y()) - .collect(); - let (top_resize_border, terminals_above) = - self.right_aligned_contiguous_panes_above(&id, &terminal_borders_to_the_right); - let (bottom_resize_border, terminals_below) = - self.right_aligned_contiguous_panes_below(&id, &terminal_borders_to_the_right); - terminals_to_the_right.retain(|t| { - self.pane_is_between_horizontal_borders(t, top_resize_border, bottom_resize_border) - }); - self.reduce_pane_width_left(&id, count); - for terminal_id in terminals_to_the_right { - self.increase_pane_width_left(&terminal_id, count); - } - for terminal_id in terminals_above.iter().chain(terminals_below.iter()) { - self.reduce_pane_width_left(&terminal_id, count); - } - } - fn increase_pane_and_surroundings_up(&mut self, id: &PaneId, count: usize) { - let mut terminals_above = self - .pane_ids_directly_above(&id) - .expect("can't increase pane size up if there are no terminals above"); - let terminal_borders_above: HashSet<usize> = terminals_above - .iter() - .map(|t| self.panes.get(t).unwrap().x()) - .collect(); - let (left_resize_border, terminals_to_the_left) = - self.top_aligned_contiguous_panes_to_the_left(&id, &terminal_borders_above); - let (right_resize_border, terminals_to_the_right) = - self.top_aligned_contiguous_panes_to_the_right(&id, &terminal_borders_above); - terminals_above.retain(|t| { - self.pane_is_between_vertical_borders(t, left_resize_border, right_resize_border) - }); - self.increase_pane_height_up(&id, count); - for terminal_id in terminals_above { - self.reduce_pane_height_up(&terminal_id, count); - } - for terminal_id in terminals_to_the_left - .iter() - .chain(terminals_to_the_right.iter()) - { - self.increase_pane_height_up(&terminal_id, count); - } - } - fn increase_pane_and_surroundings_down(&mut self, id: &PaneId, count: usize) { - let mut terminals_below = self - .pane_ids_directly_below(&id) - .expect("can't increase pane size down if there are no terminals below"); - let terminal_borders_below: HashSet<usize> = terminals_below - .iter() - .map(|t| self.panes.get(t).unwrap().x()) - .collect(); - let (left_resize_border, terminals_to_the_left) = - self.bottom_aligned_contiguous_panes_to_the_left(&id, &terminal_borders_below); - let (right_resize_border, terminals_to_the_right) = - self.bottom_aligned_contiguous_panes_to_the_right(&id, &terminal_borders_below); - terminals_below.retain(|t| { - self.pane_is_between_vertical_borders(t, left_resize_border, right_resize_border) - }); - self.increase_pane_height_down(&id, count); - for terminal_id in terminals_below { - self.reduce_pane_height_down(&terminal_id, count); - } - for terminal_id in terminals_to_the_left - .iter() - .chain(terminals_to_the_right.iter()) - { - self.increase_pane_height_down(&terminal_id, count); - } - } - fn increase_pane_and_surroundings_right(&mut self, id: &PaneId, count: usize) { - let mut terminals_to_the_right = self - .pane_ids_directly_right_of(&id) - .expect("can't increase pane size right if there are no terminals to the right"); - let terminal_borders_to_the_right: HashSet<usize> = terminals_to_the_right - .iter() - .map(|t| self.panes.get(t).unwrap().y()) - .collect(); - let (top_resize_border, terminals_above) = - self.right_aligned_contiguous_panes_above(&id, &terminal_borders_to_the_right); - let (bottom_resize_border, terminals_below) = - self.right_aligned_contiguous_panes_below(&id, &terminal_borders_to_the_right); - terminals_to_the_right.retain(|t| { - self.pane_is_between_horizontal_borders(t, top_resize_border, bottom_resize_border) - }); - self.increase_pane_width_right(&id, count); - for terminal_id in terminals_to_the_right { - self.reduce_pane_width_right(&terminal_id, count); - } - for terminal_id in terminals_above.iter().chain(terminals_below.iter()) { - self.increase_pane_width_right(&terminal_id, count); - } - } - fn increase_pane_and_surroundings_left(&mut self, id: &PaneId, count: usize) { - let mut terminals_to_the_left = self - .pane_ids_directly_left_of(&id) - .expect("can't increase pane size right if there are no terminals to the right"); - let terminal_borders_to_the_left: HashSet<usize> = terminals_to_the_left - .iter() - .map(|t| self.panes.get(t).unwrap().y()) - .collect(); - let (top_resize_border, terminals_above) = - self.left_aligned_contiguous_panes_above(&id, &terminal_borders_to_the_left); - let (bottom_resize_border, terminals_below) = - self.left_aligned_contiguous_panes_below(&id, &terminal_borders_to_the_left); - terminals_to_the_left.retain(|t| { - self.pane_is_between_horizontal_borders(t, top_resize_border, bottom_resize_border) - }); - self.increase_pane_width_left(&id, count); - for terminal_id in terminals_to_the_left { - self.reduce_pane_width_left(&terminal_id, count); - } - for terminal_id in terminals_above.iter().chain(terminals_below.iter()) { - self.increase_pane_width_left(&terminal_id, count); - } - } - fn panes_exist_above(&self, pane_id: &PaneId) -> bool { - let pane = self.panes.get(pane_id).expect("pane does not exist"); - pane.y() > 0 - } - fn panes_exist_below(&self, pane_id: &PaneId) -> bool { - let pane = self.panes.get(pane_id).expect("pane does not exist"); - pane.y() + pane.rows() < self.full_screen_ws.rows - } - fn panes_exist_to_the_right(&self, pane_id: &PaneId) -> bool { - let pane = self.panes.get(pane_id).expect("pane does not exist"); - pane.x() + pane.columns() < self.full_screen_ws.columns - } - fn panes_exist_to_the_left(&self, pane_id: &PaneId) -> bool { - let pane = self.panes.get(pane_id).expect("pane does not exist"); - pane.x() > 0 - } - pub fn resize_right(&mut self) { - // TODO: find out by how much we actually reduced and only reduce by that much - let count = 10; - if let Some(active_pane_id) = self.get_active_pane_id() { - if self.panes_exist_to_the_right(&active_pane_id) { - self.increase_pane_and_surroundings_right(&active_pane_id, count); - } else if self.panes_exist_to_the_left(&active_pane_id) { - self.reduce_pane_and_surroundings_right(&active_pane_id, count); - } - self.render(); - } - } - pub fn resize_left(&mut self) { - // TODO: find out by how much we actually reduced and only reduce by that much - let count = 10; - if let Some(active_pane_id) = self.get_active_pane_id() { - if self.panes_exist_to_the_right(&active_pane_id) { - self.reduce_pane_and_surroundings_left(&active_pane_id, count); - } else if self.panes_exist_to_the_left(&active_pane_id) { - self.increase_pane_and_surroundings_left(&active_pane_id, count); - } - self.render(); - } - } - pub fn resize_down(&mut self) { - // TODO: find out by how much we actually reduced and only reduce by that much - let count = 2; - if let Some(active_pane_id) = self.get_active_pane_id() { - if self.panes_exist_above(&active_pane_id) { - self.reduce_pane_and_surroundings_down(&active_pane_id, count); - } else if self.panes_exist_below(&active_pane_id) { - self.increase_pane_and_surroundings_down(&active_pane_id, count); - } - self.render(); - } - } - pub fn resize_up(&mut self) { - // TODO: find out by how much we actually reduced and only reduce by that much - let count = 2; - if let Some(active_pane_id) = self.get_active_pane_id() { - if self.panes_exist_above(&active_pane_id) { - self.increase_pane_and_surroundings_up(&active_pane_id, count); - } else if self.panes_exist_below(&active_pane_id) { - self.reduce_pane_and_surroundings_up(&active_pane_id, count); - } - self.render(); - } - } - pub fn move_focus(&mut self) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let active_terminal_id = self.get_active_pane_id().unwrap(); - let terminal_ids: Vec<PaneId> = self.get_selectable_panes().map(|(&pid, _)| pid).collect(); // TODO: better, no allocations - let first_terminal = terminal_ids.get(0).unwrap(); - let active_terminal_id_position = terminal_ids - .iter() - .position(|id| id == &active_terminal_id) - .unwrap(); - if let Some(next_terminal) = terminal_ids.get(active_terminal_id_position + 1) { - self.active_terminal = Some(*next_terminal); - } else { - self.active_terminal = Some(*first_terminal); - } - self.render(); - } - pub fn move_focus_left(&mut self) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let active_terminal = self.get_active_pane(); - if let Some(active) = active_terminal { - let terminals = self.get_selectable_panes(); - let next_index = terminals - .enumerate() - .filter(|(_, (_, c))| { - c.is_directly_left_of(active) && c.horizontally_overlaps_with(active) - }) - .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(active)) - .map(|(_, (pid, _))| pid); - match next_index { - Some(&p) => { - self.active_terminal = Some(p); - } - None => { - self.active_terminal = Some(active.pid()); - } - } - } else { - self.active_terminal = Some(active_terminal.unwrap().pid()); - } - self.render(); - } - pub fn move_focus_down(&mut self) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let active_terminal = self.get_active_pane(); - if let Some(active) = active_terminal { - let terminals = self.get_selectable_panes(); - let next_index = terminals - .enumerate() - .filter(|(_, (_, c))| { - c.is_directly_below(active) && c.vertically_overlaps_with(active) - }) - .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(active)) - .map(|(_, (pid, _))| pid); - match next_index { - Some(&p) => { - self.active_terminal = Some(p); - } - None => { - self.active_terminal = Some(active.pid()); - } - } - } else { - self.active_terminal = Some(active_terminal.unwrap().pid()); - } - self.render(); - } - pub fn move_focus_up(&mut self) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let active_terminal = self.get_active_pane(); - if let Some(active) = active_terminal { - let terminals = self.get_selectable_panes(); - let next_index = terminals - .enumerate() - .filter(|(_, (_, c))| { - c.is_directly_above(active) && c.vertically_overlaps_with(active) - }) - .max_by_key(|(_, (_, c))| c.get_vertical_overlap_with(active)) - .map(|(_, (pid, _))| pid); - match next_index { - Some(&p) => { - self.active_terminal = Some(p); - } - None => { - self.active_terminal = Some(active.pid()); - } - } - } else { - self.active_terminal = Some(active_terminal.unwrap().pid()); - } - self.render(); - } - pub fn move_focus_right(&mut self) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let active_terminal = self.get_active_pane(); - if let Some(active) = active_terminal { - let terminals = self.get_selectable_panes(); - let next_index = terminals - .enumerate() - .filter(|(_, (_, c))| { - c.is_directly_right_of(active) && c.horizontally_overlaps_with(active) - }) - .max_by_key(|(_, (_, c))| c.get_horizontal_overlap_with(active)) - .map(|(_, (pid, _))| pid); - match next_index { - Some(&p) => { - self.active_terminal = Some(p); - } - None => { - self.active_terminal = Some(active.pid()); - } - } - } else { - self.active_terminal = Some(active_terminal.unwrap().pid()); - } - self.render(); - } - fn horizontal_borders(&self, terminals: &[PaneId]) -> HashSet<usize> { - terminals.iter().fold(HashSet::new(), |mut borders, t| { - let terminal = self.panes.get(t).unwrap(); - borders.insert(terminal.y()); - borders.insert(terminal.y() + terminal.rows() + 1); // 1 for the border width - borders - }) - } - fn vertical_borders(&self, terminals: &[PaneId]) -> HashSet<usize> { - terminals.iter().fold(HashSet::new(), |mut borders, t| { - let terminal = self.panes.get(t).unwrap(); - borders.insert(terminal.x()); - borders.insert(terminal.x() + terminal.columns() + 1); // 1 for the border width - borders - }) - } - fn panes_to_the_left_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { - if let Some(terminal) = self.panes.get(&id) { - let upper_close_border = terminal.y(); - let lower_close_border = terminal.y() + terminal.rows() + 1; - - if let Some(mut terminals_to_the_left) = self.pane_ids_directly_left_of(&id) { - let terminal_borders_to_the_left = self.horizontal_borders(&terminals_to_the_left); - if terminal_borders_to_the_left.contains(&upper_close_border) - && terminal_borders_to_the_left.contains(&lower_close_border) - { - terminals_to_the_left.retain(|t| { - self.pane_is_between_horizontal_borders( - t, - upper_close_border, - lower_close_border, - ) - }); - return Some(terminals_to_the_left); - } - } - } - None - } - fn panes_to_the_right_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { - if let Some(terminal) = self.panes.get(&id) { - let upper_close_border = terminal.y(); - let lower_close_border = terminal.y() + terminal.rows() + 1; - - if let Some(mut terminals_to_the_right) = self.pane_ids_directly_right_of(&id) { - let terminal_borders_to_the_right = - self.horizontal_borders(&terminals_to_the_right); - if terminal_borders_to_the_right.contains(&upper_close_border) - && terminal_borders_to_the_right.contains(&lower_close_border) - { - terminals_to_the_right.retain(|t| { - self.pane_is_between_horizontal_borders( - t, - upper_close_border, - lower_close_border, - ) - }); - return Some(terminals_to_the_right); - } - } - } - None - } - fn panes_above_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { - if let Some(terminal) = self.panes.get(&id) { - let left_close_border = terminal.x(); - let right_close_border = terminal.x() + terminal.columns() + 1; - - if let Some(mut terminals_above) = self.pane_ids_directly_above(&id) { - let terminal_borders_above = self.vertical_borders(&terminals_above); - if terminal_borders_above.contains(&left_close_border) - && terminal_borders_above.contains(&right_close_border) - { - terminals_above.retain(|t| { - self.pane_is_between_vertical_borders( - t, - left_close_border, - right_close_border, - ) - }); - return Some(terminals_above); - } - } - } - None - } - fn panes_below_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { - if let Some(terminal) = self.panes.get(&id) { - let left_close_border = terminal.x(); - let right_close_border = terminal.x() + terminal.columns() + 1; - - if let Some(mut terminals_below) = self.pane_ids_directly_below(&id) { - let terminal_borders_below = self.vertical_borders(&terminals_below); - if terminal_borders_below.contains(&left_close_border) - && terminal_borders_below.contains(&right_close_border) - { - terminals_below.retain(|t| { - self.pane_is_between_vertical_borders( - t, - left_close_border, - right_close_border, - ) - }); - return Some(terminals_below); - } - } - } - None - } - fn close_down_to_max_terminals(&mut self) { - if let Some(max_panes) = self.max_panes { - let terminals = self.get_pane_ids(); - for &pid in terminals.iter().skip(max_panes - 1) { - self.send_pty_instructions - .send(PtyInstruction::ClosePane(pid)) - .unwrap(); - self.close_pane_without_rerender(pid); - } - } - } - pub fn get_pane_ids(&self) -> Vec<PaneId> { - self.get_panes().map(|(&pid, _)| pid).collect() - } - pub fn set_pane_selectable(&mut self, id: PaneId, selectable: bool) { - if let Some(pane) = self.panes.get_mut(&id) { - pane.set_selectable(selectable); - if self.get_active_pane_id() == Some(id) && !selectable { - self.active_terminal = self.next_active_pane(self.get_pane_ids()) - } - } - } - pub fn close_pane(&mut self, id: PaneId) { - if self.panes.get(&id).is_some() { - self.close_pane_without_rerender(id); - } - } - pub fn close_pane_without_rerender(&mut self, id: PaneId) { - if let Some(terminal_to_close) = self.panes.get(&id) { - let terminal_to_close_width = terminal_to_close.columns(); - let terminal_to_close_height = terminal_to_close.rows(); - if let Some(terminals) = self.panes_to_the_left_between_aligning_borders(id) { - for terminal_id in terminals.iter() { - self.increase_pane_width_right(&terminal_id, terminal_to_close_width + 1); - // 1 for the border - } - if self.active_terminal == Some(id) { - self.active_terminal = self.next_active_pane(terminals); - } - } else if let Some(terminals) = self.panes_to_the_right_between_aligning_borders(id) { - for terminal_id in terminals.iter() { - self.increase_pane_width_left(&terminal_id, terminal_to_close_width + 1); - // 1 for the border - } - if self.active_terminal == Some(id) { - self.active_terminal = self.next_active_pane(terminals); - } - } else if let Some(terminals) = self.panes_above_between_aligning_borders(id) { - for terminal_id in terminals.iter() { - self.increase_pane_height_down(&terminal_id, terminal_to_close_height + 1); - // 1 for the border - } - if self.active_terminal == Some(id) { - self.active_terminal = self.next_active_pane(terminals); - } - } else if let Some(terminals) = self.panes_below_between_aligning_borders(id) { - for terminal_id in terminals.iter() { - self.increase_pane_height_up(&terminal_id, terminal_to_close_height + 1); - // 1 for the border - } - if self.active_terminal == Some(id) { - self.active_terminal = self.next_active_pane(terminals); - } - } else { - } - self.panes.remove(&id); - if self.active_terminal.is_none() { - self.active_terminal = self.next_active_pane(self.get_pane_ids()); - } - } - } - pub fn close_focused_pane(&mut self) { - if let Some(active_pane_id) = self.get_active_pane_id() { - self.close_pane(active_pane_id); - self.send_pty_instructions - .send(PtyInstruction::ClosePane(active_pane_id)) - .unwrap(); - } - } - pub fn scroll_active_terminal_up(&mut self) { - if let Some(active_terminal_id) = self.get_active_terminal_id() { - let active_terminal = self - .panes - .get_mut(&PaneId::Terminal(active_terminal_id)) - .unwrap(); - active_terminal.scroll_up(1); - self.render(); - } - } - pub fn scroll_active_terminal_down(&mut self) { - if let Some(active_terminal_id) = self.get_active_terminal_id() { - let active_terminal = self - .panes - .get_mut(&PaneId::Terminal(active_terminal_id)) - .unwrap(); - active_terminal.scroll_down(1); - self.render(); - } - } - pub fn clear_active_terminal_scroll(&mut self) { - if let Some(active_terminal_id) = self.get_active_terminal_id() { - let active_terminal = self - .panes - .get_mut(&PaneId::Terminal(active_terminal_id)) - .unwrap(); - active_terminal.clear_scroll(); - } - } -} |
