diff options
| author | Aram Drevekenin <aram@poor.dev> | 2022-03-18 10:32:43 +0100 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2022-03-18 10:32:43 +0100 |
| commit | ab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e (patch) | |
| tree | 165a49ba935694a11f8816b2e68a401b6ddf23e3 /zellij-server/src/panes | |
| parent | Update `rust-toolchain` (#1236) (diff) | |
| download | sl0ppij-ab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e.tar.gz sl0ppij-ab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e.tar.xz sl0ppij-ab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e.zip | |
refactor(tab): move tiled panes to their own module (#1239)
* work
* tests passing
* simplify render state
* move more stuff to state
* moved tiled panes outside
* move files around
* style(fmt): rustfmt
Diffstat (limited to 'zellij-server/src/panes')
| -rw-r--r-- | zellij-server/src/panes/floating_panes/floating_pane_grid.rs | 899 | ||||
| -rw-r--r-- | zellij-server/src/panes/floating_panes/mod.rs (renamed from zellij-server/src/panes/floating_panes.rs) | 109 | ||||
| -rw-r--r-- | zellij-server/src/panes/mod.rs | 2 | ||||
| -rw-r--r-- | zellij-server/src/panes/tiled_panes/mod.rs | 1035 | ||||
| -rw-r--r-- | zellij-server/src/panes/tiled_panes/pane_resizer.rs | 246 | ||||
| -rw-r--r-- | zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs | 1740 |
6 files changed, 4001 insertions, 30 deletions
diff --git a/zellij-server/src/panes/floating_panes/floating_pane_grid.rs b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs new file mode 100644 index 00000000..31d0d6ff --- /dev/null +++ b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs @@ -0,0 +1,899 @@ +use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; +use crate::{panes::PaneId, tab::Pane}; +use std::cmp::Ordering; +use std::collections::HashMap; +use zellij_utils::pane_size::{Dimension, PaneGeom, Size, Viewport}; + +use std::cell::RefCell; +use std::rc::Rc; + +const RESIZE_INCREMENT_WIDTH: usize = 5; +const RESIZE_INCREMENT_HEIGHT: usize = 2; +const MOVE_INCREMENT_HORIZONTAL: usize = 10; +const MOVE_INCREMENT_VERTICAL: usize = 5; + +const MAX_PANES: usize = 100; + +pub struct FloatingPaneGrid<'a> { + panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>, + desired_pane_positions: Rc<RefCell<&'a mut HashMap<PaneId, PaneGeom>>>, + display_area: Size, // includes all panes (including eg. the status bar and tab bar in the default layout) + viewport: Viewport, // includes all non-UI panes +} + +impl<'a> FloatingPaneGrid<'a> { + pub fn new( + panes: impl IntoIterator<Item = (&'a PaneId, &'a mut Box<dyn Pane>)>, + desired_pane_positions: &'a mut HashMap<PaneId, PaneGeom>, + display_area: Size, + viewport: Viewport, + ) -> Self { + let panes: HashMap<_, _> = panes.into_iter().map(|(p_id, p)| (*p_id, p)).collect(); + FloatingPaneGrid { + panes: Rc::new(RefCell::new(panes)), + desired_pane_positions: Rc::new(RefCell::new(desired_pane_positions)), + display_area, + viewport, + } + } + pub fn move_pane_by(&mut self, pane_id: PaneId, x: isize, y: isize) { + // true => succeeded to move, false => failed to move + let new_pane_position = { + let mut panes = self.panes.borrow_mut(); + let pane = panes + .iter_mut() + .find(|(p_id, _p)| **p_id == pane_id) + .unwrap() + .1; + let mut new_pane_position = pane.position_and_size(); + let min_x = self.viewport.x as isize; + let min_y = self.viewport.y as isize; + let max_x = (self.viewport.cols + self.viewport.x) + .saturating_sub(new_pane_position.cols.as_usize()); + let max_y = (self.viewport.rows + self.viewport.y) + .saturating_sub(new_pane_position.rows.as_usize()); + let new_x = std::cmp::max(min_x, new_pane_position.x as isize + x); + let new_x = std::cmp::min(new_x, max_x as isize); + let new_y = std::cmp::max(min_y, new_pane_position.y as isize + y); + let new_y = std::cmp::min(new_y, max_y as isize); + new_pane_position.x = new_x as usize; + new_pane_position.y = new_y as usize; + new_pane_position + }; + self.set_pane_geom(pane_id, new_pane_position); + } + fn set_pane_geom(&mut self, pane_id: PaneId, new_pane_geom: PaneGeom) { + let mut panes = self.panes.borrow_mut(); + let pane = panes + .iter_mut() + .find(|(p_id, _p)| **p_id == pane_id) + .unwrap() + .1; + pane.set_geom(new_pane_geom); + let mut desired_pane_positions = self.desired_pane_positions.borrow_mut(); + desired_pane_positions.insert(pane_id, new_pane_geom); + } + pub fn resize(&mut self, space: Size) { + let mut panes = self.panes.borrow_mut(); + let desired_pane_positions = self.desired_pane_positions.borrow(); + + // account for the difference between the viewport (including non-ui pane items which we + // do not want to override) and the display_area, which is the area we can go over + let display_size_row_difference = self.display_area.rows.saturating_sub(self.viewport.rows); + let display_size_column_difference = + self.display_area.cols.saturating_sub(self.viewport.cols); + + let mut new_viewport = self.viewport; + new_viewport.cols = space.cols.saturating_sub(display_size_column_difference); + new_viewport.rows = space.rows.saturating_sub(display_size_row_difference); + + for (pane_id, pane) in panes.iter_mut() { + let mut new_pane_geom = pane.current_geom(); + let desired_pane_geom = desired_pane_positions.get(pane_id).unwrap(); + let desired_pane_geom_is_inside_viewport = + pane_geom_is_inside_viewport(&new_viewport, desired_pane_geom); + let pane_is_in_desired_position = new_pane_geom == *desired_pane_geom; + if pane_is_in_desired_position && desired_pane_geom_is_inside_viewport { + continue; + } else if desired_pane_geom_is_inside_viewport { + pane.set_geom(*desired_pane_geom); + } else { + let pane_right_side = new_pane_geom.x + new_pane_geom.cols.as_usize(); + let pane_bottom_side = new_pane_geom.y + new_pane_geom.rows.as_usize(); + let viewport_right_side = new_viewport.x + new_viewport.cols; + let viewport_bottom_side = new_viewport.y + new_viewport.rows; + let excess_width = pane_right_side.saturating_sub(viewport_right_side); + let excess_height = pane_bottom_side.saturating_sub(viewport_bottom_side); + let extra_width = viewport_right_side.saturating_sub(pane_right_side); + let extra_height = viewport_bottom_side.saturating_sub(pane_bottom_side); + + // handle shrink width + if excess_width > 0 && new_pane_geom.x.saturating_sub(excess_width) > new_viewport.x + { + new_pane_geom.x = new_pane_geom.x.saturating_sub(excess_width); + } else if excess_width > 0 + && new_pane_geom.cols.as_usize().saturating_sub(excess_width) + > MIN_TERMINAL_WIDTH + { + new_pane_geom + .cols + .set_inner(new_pane_geom.cols.as_usize().saturating_sub(excess_width)); + } else if excess_width > 0 { + let reduce_x_by = new_pane_geom.x.saturating_sub(new_viewport.x); + let reduced_width = new_pane_geom + .cols + .as_usize() + .saturating_sub(excess_width.saturating_sub(reduce_x_by)); + new_pane_geom.x = new_viewport.x; + new_pane_geom + .cols + .set_inner(std::cmp::max(reduced_width, MIN_TERMINAL_WIDTH)); + } + + // handle shrink height + if excess_height > 0 + && new_pane_geom.y.saturating_sub(excess_height) > new_viewport.y + { + new_pane_geom.y = new_pane_geom.y.saturating_sub(excess_height); + } else if excess_height > 0 + && new_pane_geom.rows.as_usize().saturating_sub(excess_height) + > MIN_TERMINAL_HEIGHT + { + new_pane_geom + .rows + .set_inner(new_pane_geom.rows.as_usize().saturating_sub(excess_height)); + } else if excess_height > 0 { + let reduce_y_by = new_pane_geom.y.saturating_sub(new_viewport.y); + let reduced_height = new_pane_geom + .rows + .as_usize() + .saturating_sub(excess_height.saturating_sub(reduce_y_by)); + new_pane_geom.y = new_viewport.y; + new_pane_geom + .rows + .set_inner(std::cmp::max(reduced_height, MIN_TERMINAL_HEIGHT)); + } + + // handle expand width + if extra_width > 0 { + let max_right_coords = new_viewport.x + new_viewport.cols; + if new_pane_geom.x < desired_pane_geom.x { + if desired_pane_geom.x + new_pane_geom.cols.as_usize() <= max_right_coords { + new_pane_geom.x = desired_pane_geom.x + } else if new_pane_geom.x + new_pane_geom.cols.as_usize() + extra_width + < max_right_coords + { + new_pane_geom.x += extra_width; + } else { + new_pane_geom.x = + max_right_coords.saturating_sub(new_pane_geom.cols.as_usize()); + } + } + if new_pane_geom.cols.as_usize() < desired_pane_geom.cols.as_usize() { + if new_pane_geom.x + desired_pane_geom.cols.as_usize() <= max_right_coords { + new_pane_geom + .cols + .set_inner(desired_pane_geom.cols.as_usize()); + } else if new_pane_geom.x + new_pane_geom.cols.as_usize() + extra_width + < max_right_coords + { + new_pane_geom + .cols + .set_inner(new_pane_geom.cols.as_usize() + extra_width); + } else { + new_pane_geom.cols.set_inner( + new_pane_geom.cols.as_usize() + + (max_right_coords + - (new_pane_geom.x + new_pane_geom.cols.as_usize())), + ); + } + } + } + + // handle expand height + if extra_height > 0 { + let max_bottom_coords = new_viewport.y + new_viewport.rows; + if new_pane_geom.y < desired_pane_geom.y { + if desired_pane_geom.y + new_pane_geom.rows.as_usize() <= max_bottom_coords + { + new_pane_geom.y = desired_pane_geom.y + } else if new_pane_geom.y + new_pane_geom.rows.as_usize() + extra_height + < max_bottom_coords + { + new_pane_geom.y += extra_height; + } else { + new_pane_geom.y = + max_bottom_coords.saturating_sub(new_pane_geom.rows.as_usize()); + } + } + if new_pane_geom.rows.as_usize() < desired_pane_geom.rows.as_usize() { + if new_pane_geom.y + desired_pane_geom.rows.as_usize() <= max_bottom_coords + { + new_pane_geom + .rows + .set_inner(desired_pane_geom.rows.as_usize()); + } else if new_pane_geom.y + new_pane_geom.rows.as_usize() + extra_height + < max_bottom_coords + { + new_pane_geom + .rows + .set_inner(new_pane_geom.rows.as_usize() + extra_height); + } else { + new_pane_geom.rows.set_inner( + new_pane_geom.rows.as_usize() + + (max_bottom_coords + - (new_pane_geom.y + new_pane_geom.rows.as_usize())), + ); + } + } + } + pane.set_geom(new_pane_geom); + } + } + } + pub fn move_pane_left(&mut self, pane_id: &PaneId) { + if let Some(move_by) = self.can_move_pane_left(pane_id, MOVE_INCREMENT_HORIZONTAL) { + self.move_pane_position_left(pane_id, move_by); + } + } + pub fn move_pane_right(&mut self, pane_id: &PaneId) { + if let Some(move_by) = self.can_move_pane_right(pane_id, MOVE_INCREMENT_HORIZONTAL) { + self.move_pane_position_right(pane_id, move_by); + } + } + pub fn move_pane_down(&mut self, pane_id: &PaneId) { + if let Some(move_by) = self.can_move_pane_down(pane_id, MOVE_INCREMENT_VERTICAL) { + self.move_pane_position_down(pane_id, move_by); + } + } + pub fn move_pane_up(&mut self, pane_id: &PaneId) { + if let Some(move_by) = self.can_move_pane_up(pane_id, MOVE_INCREMENT_VERTICAL) { + self.move_pane_position_up(pane_id, move_by); + } + } + fn can_move_pane_left(&self, pane_id: &PaneId, move_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_until_left_screen_edge = pane.x().saturating_sub(self.viewport.x); + if space_until_left_screen_edge >= move_by { + Some(move_by) + } else if space_until_left_screen_edge > 0 { + Some(space_until_left_screen_edge) + } else { + None + } + } + fn can_move_pane_right(&self, pane_id: &PaneId, move_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_until_right_screen_edge = + (self.viewport.x + self.viewport.cols).saturating_sub(pane.x() + pane.cols()); + if space_until_right_screen_edge >= move_by { + Some(move_by) + } else if space_until_right_screen_edge > 0 { + Some(space_until_right_screen_edge) + } else { + None + } + } + fn can_move_pane_up(&self, pane_id: &PaneId, move_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_until_top_screen_edge = pane.y().saturating_sub(self.viewport.y); + if space_until_top_screen_edge >= move_by { + Some(move_by) + } else if space_until_top_screen_edge > 0 { + Some(space_until_top_screen_edge) + } else { + None + } + } + fn can_move_pane_down(&self, pane_id: &PaneId, move_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_until_bottom_screen_edge = + (self.viewport.y + self.viewport.rows).saturating_sub(pane.y() + pane.rows()); + if space_until_bottom_screen_edge >= move_by { + Some(move_by) + } else if space_until_bottom_screen_edge > 0 { + Some(space_until_bottom_screen_edge) + } else { + None + } + } + fn move_pane_position_left(&mut self, pane_id: &PaneId, move_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(pane_id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.x -= move_by; + current_geom + }; + self.set_pane_geom(*pane_id, new_pane_geom); + } + fn move_pane_position_right(&mut self, pane_id: &PaneId, move_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(pane_id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.x += move_by; + current_geom + }; + self.set_pane_geom(*pane_id, new_pane_geom); + } + fn move_pane_position_down(&mut self, pane_id: &PaneId, move_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(pane_id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.y += move_by; + current_geom + }; + self.set_pane_geom(*pane_id, new_pane_geom); + } + fn move_pane_position_up(&mut self, pane_id: &PaneId, move_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(pane_id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.y -= move_by; + current_geom + }; + self.set_pane_geom(*pane_id, new_pane_geom); + } + pub fn resize_pane_left(&'a mut self, pane_id: &PaneId) { + if let Some(increase_by) = self.can_increase_pane_size_left(pane_id, RESIZE_INCREMENT_WIDTH) + { + self.increase_pane_size_left(pane_id, increase_by); + } else if let Some(decrease_by) = + self.can_decrease_pane_size_left(pane_id, RESIZE_INCREMENT_WIDTH) + { + self.decrease_pane_size_left(pane_id, decrease_by); + } + } + pub fn resize_pane_right(&mut self, pane_id: &PaneId) { + if let Some(increase_by) = + self.can_increase_pane_size_right(pane_id, RESIZE_INCREMENT_WIDTH) + { + self.increase_pane_size_right(pane_id, increase_by); + } else if let Some(decrease_by) = + self.can_decrease_pane_size_right(pane_id, RESIZE_INCREMENT_WIDTH) + { + self.decrease_pane_size_right(pane_id, decrease_by); + } + } + pub fn resize_pane_down(&mut self, pane_id: &PaneId) { + if let Some(increase_by) = + self.can_increase_pane_size_down(pane_id, RESIZE_INCREMENT_HEIGHT) + { + self.increase_pane_size_down(pane_id, increase_by); + } else if let Some(decrease_by) = + self.can_decrease_pane_size_down(pane_id, RESIZE_INCREMENT_HEIGHT) + { + self.decrease_pane_size_down(pane_id, decrease_by); + } + } + pub fn resize_pane_up(&mut self, pane_id: &PaneId) { + if let Some(increase_by) = self.can_increase_pane_size_up(pane_id, RESIZE_INCREMENT_HEIGHT) + { + self.increase_pane_size_up(pane_id, increase_by); + } else if let Some(decrease_by) = + self.can_decrease_pane_size_up(pane_id, RESIZE_INCREMENT_HEIGHT) + { + self.decrease_pane_size_up(pane_id, decrease_by); + } + } + pub fn resize_increase(&mut self, pane_id: &PaneId) { + if let Some(increase_by) = + self.can_increase_pane_size_left(pane_id, RESIZE_INCREMENT_WIDTH / 2) + { + self.increase_pane_size_left(pane_id, increase_by); + } + if let Some(increase_by) = + self.can_increase_pane_size_right(pane_id, RESIZE_INCREMENT_WIDTH / 2) + { + self.increase_pane_size_right(pane_id, increase_by); + } + if let Some(increase_by) = + self.can_increase_pane_size_down(pane_id, RESIZE_INCREMENT_HEIGHT / 2) + { + self.increase_pane_size_down(pane_id, increase_by); + } + if let Some(increase_by) = + self.can_increase_pane_size_up(pane_id, RESIZE_INCREMENT_HEIGHT / 2) + { + self.increase_pane_size_up(pane_id, increase_by); + } + } + pub fn resize_decrease(&mut self, pane_id: &PaneId) { + if let Some(decrease_by) = + self.can_decrease_pane_size_left(pane_id, RESIZE_INCREMENT_WIDTH / 2) + { + self.decrease_pane_size_left(pane_id, decrease_by); + } + if let Some(decrease_by) = + self.can_decrease_pane_size_right(pane_id, RESIZE_INCREMENT_WIDTH / 2) + { + self.decrease_pane_size_right(pane_id, decrease_by); + } + if let Some(decrease_by) = + self.can_decrease_pane_size_down(pane_id, RESIZE_INCREMENT_HEIGHT / 2) + { + self.decrease_pane_size_down(pane_id, decrease_by); + } + if let Some(decrease_by) = + self.can_decrease_pane_size_up(pane_id, RESIZE_INCREMENT_HEIGHT / 2) + { + self.decrease_pane_size_up(pane_id, decrease_by); + } + } + fn can_increase_pane_size_left( + &self, + pane_id: &PaneId, + max_increase_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let distance_to_left_edge = pane.x().saturating_sub(self.viewport.x); + if distance_to_left_edge.saturating_sub(max_increase_by) > 0 { + Some(max_increase_by) + } else if distance_to_left_edge > 0 { + Some(distance_to_left_edge) + } else { + None + } + } + fn can_decrease_pane_size_left( + &self, + pane_id: &PaneId, + max_decrease_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_left_to_decrease = pane.cols().saturating_sub(MIN_TERMINAL_WIDTH); + if space_left_to_decrease.saturating_sub(max_decrease_by) > 0 { + Some(max_decrease_by) + } else if space_left_to_decrease > 0 { + Some(space_left_to_decrease) + } else { + None + } + } + fn can_increase_pane_size_right( + &self, + pane_id: &PaneId, + max_increase_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let distance_to_right_edge = + (self.viewport.x + self.viewport.cols).saturating_sub(pane.x() + pane.cols()); + if pane.x() + pane.cols() + max_increase_by < self.viewport.cols { + Some(max_increase_by) + } else if distance_to_right_edge > 0 { + Some(distance_to_right_edge) + } else { + None + } + } + fn can_decrease_pane_size_right( + &self, + pane_id: &PaneId, + max_decrease_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_left_to_decrease = pane.cols().saturating_sub(MIN_TERMINAL_WIDTH); + let pane_right_edge = pane.x() + pane.cols(); + if space_left_to_decrease.saturating_sub(max_decrease_by) > 0 + && pane.x() + max_decrease_by <= pane_right_edge + MIN_TERMINAL_WIDTH + { + Some(max_decrease_by) + } else if space_left_to_decrease > 0 + && pane.x() + max_decrease_by <= pane_right_edge + MIN_TERMINAL_WIDTH + { + Some(space_left_to_decrease) + } else { + None + } + } + fn can_increase_pane_size_down( + &self, + pane_id: &PaneId, + max_increase_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let distance_to_bottom_edge = + (self.viewport.y + self.viewport.rows).saturating_sub(pane.y() + pane.rows()); + if pane.y() + pane.rows() + max_increase_by < self.viewport.rows { + Some(max_increase_by) + } else if distance_to_bottom_edge > 0 { + Some(distance_to_bottom_edge) + } else { + None + } + } + fn can_decrease_pane_size_down( + &self, + pane_id: &PaneId, + max_decrease_by: usize, + ) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_left_to_decrease = pane.rows().saturating_sub(MIN_TERMINAL_HEIGHT); + let pane_bottom_edge = pane.y() + pane.rows(); + if space_left_to_decrease.saturating_sub(max_decrease_by) > 0 + && pane.y() + max_decrease_by <= pane_bottom_edge + MIN_TERMINAL_HEIGHT + { + Some(max_decrease_by) + } else if space_left_to_decrease > 0 + && pane.y() + max_decrease_by <= pane_bottom_edge + MIN_TERMINAL_HEIGHT + { + Some(space_left_to_decrease) + } else { + None + } + } + fn can_increase_pane_size_up(&self, pane_id: &PaneId, max_increase_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let distance_to_top_edge = pane.y().saturating_sub(self.viewport.y); + if distance_to_top_edge.saturating_sub(max_increase_by) > 0 { + Some(max_increase_by) + } else if distance_to_top_edge > 0 { + Some(distance_to_top_edge) + } else { + None + } + } + fn can_decrease_pane_size_up(&self, pane_id: &PaneId, max_decrease_by: usize) -> Option<usize> { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + let space_left_to_decrease = pane.rows().saturating_sub(MIN_TERMINAL_HEIGHT); + if space_left_to_decrease.saturating_sub(max_decrease_by) > 0 { + Some(max_decrease_by) + } else if space_left_to_decrease > 0 { + Some(space_left_to_decrease) + } else { + None + } + } + fn increase_pane_size_left(&mut self, id: &PaneId, increase_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.x -= increase_by; + current_geom + .cols + .set_inner(current_geom.cols.as_usize() + increase_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn decrease_pane_size_left(&mut self, id: &PaneId, decrease_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom + .cols + .set_inner(current_geom.cols.as_usize() - decrease_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn increase_pane_size_right(&mut self, id: &PaneId, increase_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom + .cols + .set_inner(current_geom.cols.as_usize() + increase_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn decrease_pane_size_right(&mut self, id: &PaneId, decrease_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.x += decrease_by; + current_geom + .cols + .set_inner(current_geom.cols.as_usize() - decrease_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn increase_pane_size_down(&mut self, id: &PaneId, increase_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom + .rows + .set_inner(current_geom.rows.as_usize() + increase_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn decrease_pane_size_down(&mut self, id: &PaneId, decrease_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.y += decrease_by; + current_geom + .rows + .set_inner(current_geom.rows.as_usize() - decrease_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn increase_pane_size_up(&mut self, id: &PaneId, increase_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom.y -= increase_by; + current_geom + .rows + .set_inner(current_geom.rows.as_usize() + increase_by); + pane.set_geom(current_geom); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + fn decrease_pane_size_up(&mut self, id: &PaneId, decrease_by: usize) { + let new_pane_geom = { + let mut panes = self.panes.borrow_mut(); + let pane = panes.get_mut(id).unwrap(); + let mut current_geom = pane.position_and_size(); + current_geom + .rows + .set_inner(current_geom.rows.as_usize() - decrease_by); + current_geom + }; + self.set_pane_geom(*id, new_pane_geom); + } + pub fn next_selectable_pane_id_to_the_left(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_left_of(Box::as_ref(current_pane)) + && c.horizontally_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by(|(_, (_, a)), (_, (_, b))| { + let x_comparison = a.x().cmp(&b.x()); + match x_comparison { + Ordering::Equal => a.y().cmp(&b.y()), + _ => x_comparison, + } + }) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_below(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_below(Box::as_ref(current_pane)) + && c.vertically_overlaps_with(Box::as_ref(current_pane)) + }) + .min_by(|(_, (_, a)), (_, (_, b))| { + let y_comparison = a.y().cmp(&b.y()); + match y_comparison { + Ordering::Equal => b.x().cmp(&a.x()), + _ => y_comparison, + } + }) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_above(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_above(Box::as_ref(current_pane)) + && c.vertically_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by(|(_, (_, a)), (_, (_, b))| { + let y_comparison = a.y().cmp(&b.y()); + match y_comparison { + Ordering::Equal => b.x().cmp(&a.x()), + _ => y_comparison, + } + }) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_to_the_right(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_right_of(Box::as_ref(current_pane)) + && c.horizontally_overlaps_with(Box::as_ref(current_pane)) + }) + .min_by(|(_, (_, a)), (_, (_, b))| { + let x_comparison = a.x().cmp(&b.x()); + match x_comparison { + Ordering::Equal => a.y().cmp(&b.y()), + _ => x_comparison, + } + }) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn find_room_for_new_pane(&self) -> Option<PaneGeom> { + let panes = self.panes.borrow(); + let pane_geoms: Vec<PaneGeom> = panes.values().map(|p| p.position_and_size()).collect(); + for offset in 0..MAX_PANES / 5 { + let half_size_middle_geom = half_size_middle_geom(&self.viewport, offset); + let half_size_top_left_geom = half_size_top_left_geom(&self.viewport, offset); + let half_size_top_right_geom = half_size_top_right_geom(&self.viewport, offset); + let half_size_bottom_left_geom = half_size_bottom_left_geom(&self.viewport, offset); + let half_size_bottom_right_geom = half_size_bottom_right_geom(&self.viewport, offset); + if pane_geom_is_big_enough(&half_size_middle_geom) + && pane_geom_is_unoccupied_and_inside_viewport( + &self.viewport, + &half_size_middle_geom, + &pane_geoms, + ) + { + return Some(half_size_middle_geom); + } else if pane_geom_is_big_enough(&half_size_top_left_geom) + && pane_geom_is_unoccupied_and_inside_viewport( + &self.viewport, + &half_size_top_left_geom, + &pane_geoms, + ) + { + return Some(half_size_top_left_geom); + } else if pane_geom_is_big_enough(&half_size_top_right_geom) + && pane_geom_is_unoccupied_and_inside_viewport( + &self.viewport, + &half_size_top_right_geom, + &pane_geoms, + ) + { + return Some(half_size_top_right_geom); + } else if pane_geom_is_big_enough(&half_size_bottom_left_geom) + && pane_geom_is_unoccupied_and_inside_viewport( + &self.viewport, + &half_size_bottom_left_geom, + &pane_geoms, + ) + { + return Some(half_size_bottom_left_geom); + } else if pane_geom_is_big_enough(&half_size_bottom_right_geom) + && pane_geom_is_unoccupied_and_inside_viewport( + &self.viewport, + &half_size_bottom_right_geom, + &pane_geoms, + ) + { + return Some(half_size_bottom_right_geom); + } + } + None + } +} + +fn half_size_middle_geom(space: &Viewport, offset: usize) -> PaneGeom { + let mut geom = PaneGeom { + x: space.x + (space.cols as f64 / 4.0).round() as usize + offset, + y: space.y + (space.rows as f64 / 4.0).round() as usize + offset, + cols: Dimension::fixed(space.cols / 2), + rows: Dimension::fixed(space.rows / 2), + }; + geom.cols.set_inner(space.cols / 2); + geom.rows.set_inner(space.rows / 2); + geom +} + +fn half_size_top_left_geom(space: &Viewport, offset: usize) -> PaneGeom { + let mut geom = PaneGeom { + x: space.x + 2 + offset, + y: space.y + 2 + offset, + cols: Dimension::fixed(space.cols / 3), + rows: Dimension::fixed(space.rows / 3), + }; + geom.cols.set_inner(space.cols / 3); + geom.rows.set_inner(space.rows / 3); + geom +} + +fn half_size_top_right_geom(space: &Viewport, offset: usize) -> PaneGeom { + let mut geom = PaneGeom { + x: ((space.x + space.cols) - (space.cols / 3) - 2).saturating_sub(offset), + y: space.y + 2 + offset, + cols: Dimension::fixed(space.cols / 3), + rows: Dimension::fixed(space.rows / 3), + }; + geom.cols.set_inner(space.cols / 3); + geom.rows.set_inner(space.rows / 3); + geom +} + +fn half_size_bottom_left_geom(space: &Viewport, offset: usize) -> PaneGeom { + let mut geom = PaneGeom { + x: space.x + 2 + offset, + y: ((space.y + space.rows) - (space.rows / 3) - 2).saturating_sub(offset), + cols: Dimension::fixed(space.cols / 3), + rows: Dimension::fixed(space.rows / 3), + }; + geom.cols.set_inner(space.cols / 3); + geom.rows.set_inner(space.rows / 3); + geom +} + +fn half_size_bottom_right_geom(space: &Viewport, offset: usize) -> PaneGeom { + let mut geom = PaneGeom { + x: ((space.x + space.cols) - (space.cols / 3) - 2).saturating_sub(offset), + y: ((space.y + space.rows) - (space.rows / 3) - 2).saturating_sub(offset), + cols: Dimension::fixed(space.cols / 3), + rows: Dimension::fixed(space.rows / 3), + }; + geom.cols.set_inner(space.cols / 3); + geom.rows.set_inner(space.rows / 3); + geom +} + +fn pane_geom_is_inside_viewport(viewport: &Viewport, geom: &PaneGeom) -> bool { + geom.y >= viewport.y + && geom.y + geom.rows.as_usize() <= viewport.y + viewport.rows + && geom.x >= viewport.x + && geom.x + geom.cols.as_usize() <= viewport.x + viewport.cols +} + +fn pane_geom_is_big_enough(geom: &PaneGeom) -> bool { + geom.rows.as_usize() >= MIN_TERMINAL_HEIGHT && geom.cols.as_usize() >= MIN_TERMINAL_WIDTH +} + +fn pane_geom_is_unoccupied_and_inside_viewport( + viewport: &Viewport, + geom: &PaneGeom, + existing_geoms: &[PaneGeom], +) -> bool { + pane_geom_is_inside_viewport(viewport, geom) && !existing_geoms.iter().any(|p| p == geom) +} diff --git a/zellij-server/src/panes/floating_panes.rs b/zellij-server/src/panes/floating_panes/mod.rs index c88bcba9..99cf7e9d 100644 --- a/zellij-server/src/panes/floating_panes.rs +++ b/zellij-server/src/panes/floating_panes/mod.rs @@ -1,7 +1,9 @@ +mod floating_pane_grid; + use zellij_utils::{position::Position, zellij_tile}; -use crate::tab::floating_pane_grid::FloatingPaneGrid; use crate::tab::Pane; +use floating_pane_grid::FloatingPaneGrid; use crate::{ os_input_output::ServerOsApi, @@ -35,6 +37,12 @@ pub struct FloatingPanes { panes: BTreeMap<PaneId, Box<dyn Pane>>, display_area: Rc<RefCell<Size>>, viewport: Rc<RefCell<Viewport>>, + connected_clients: Rc<RefCell<HashSet<ClientId>>>, + connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>, + mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>, + default_mode_info: ModeInfo, + colors: Palette, + session_is_mirrored: bool, desired_pane_positions: HashMap<PaneId, PaneGeom>, // this represents the positions of panes the user moved with intention, rather than by resizing the terminal window z_indices: Vec<PaneId>, active_panes: HashMap<ClientId, PaneId>, @@ -44,11 +52,26 @@ pub struct FloatingPanes { #[allow(clippy::borrowed_box)] impl FloatingPanes { - pub fn new(display_area: Rc<RefCell<Size>>, viewport: Rc<RefCell<Viewport>>) -> Self { + pub fn new( + display_area: Rc<RefCell<Size>>, + viewport: Rc<RefCell<Viewport>>, + connected_clients: Rc<RefCell<HashSet<ClientId>>>, + connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>, + mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>, + session_is_mirrored: bool, + default_mode_info: ModeInfo, + colors: Palette, + ) -> Self { FloatingPanes { panes: BTreeMap::new(), display_area, viewport, + connected_clients, + connected_clients_in_app, + mode_info, + session_is_mirrored, + default_mode_info, + colors, desired_pane_positions: HashMap::new(), z_indices: vec![], show_panes: false, @@ -56,13 +79,17 @@ impl FloatingPanes { pane_being_moved_with_mouse: None, } } - pub fn stack(&self) -> FloatingPanesStack { - let layers = self - .z_indices - .iter() - .map(|pane_id| self.panes.get(pane_id).unwrap().position_and_size()) - .collect(); - FloatingPanesStack { layers } + pub fn stack(&self) -> Option<FloatingPanesStack> { + if self.panes_are_visible() { + let layers = self + .z_indices + .iter() + .map(|pane_id| self.panes.get(pane_id).unwrap().position_and_size()) + .collect(); + Some(FloatingPanesStack { layers }) + } else { + None + } } pub fn pane_ids(&self) -> impl Iterator<Item = &PaneId> { self.panes.keys() @@ -151,17 +178,9 @@ impl FloatingPanes { resize_pty!(pane, os_api); } } - #[allow(clippy::too_many_arguments)] - pub fn render( - &mut self, - connected_clients_in_app: &Rc<RefCell<HashSet<ClientId>>>, - connected_clients: &HashSet<ClientId>, - mode_info: &HashMap<ClientId, ModeInfo>, - default_mode_info: &ModeInfo, - session_is_mirrored: bool, - output: &mut Output, - colors: Palette, - ) { + pub fn render(&mut self, output: &mut Output) { + let connected_clients: Vec<ClientId> = + { self.connected_clients.borrow().iter().copied().collect() }; let mut floating_panes: Vec<_> = self.panes.iter_mut().collect(); floating_panes.sort_by(|(a_id, _a_pane), (b_id, _b_pane)| { self.z_indices @@ -173,25 +192,35 @@ impl FloatingPanes { for (z_index, (kind, pane)) in floating_panes.iter_mut().enumerate() { let mut active_panes = self.active_panes.clone(); - let multiple_users_exist_in_session = { connected_clients_in_app.borrow().len() > 1 }; - active_panes.retain(|c_id, _| connected_clients.contains(c_id)); + let multiple_users_exist_in_session = + { self.connected_clients_in_app.borrow().len() > 1 }; + active_panes.retain(|c_id, _| self.connected_clients.borrow().contains(c_id)); let mut pane_contents_and_ui = PaneContentsAndUi::new( pane, output, - colors, + self.colors, &active_panes, multiple_users_exist_in_session, Some(z_index + 1), // +1 because 0 is reserved for non-floating panes ); - for &client_id in connected_clients { - let client_mode = mode_info.get(&client_id).unwrap_or(default_mode_info).mode; - pane_contents_and_ui.render_pane_frame(client_id, client_mode, session_is_mirrored); + for client_id in &connected_clients { + let client_mode = self + .mode_info + .borrow() + .get(&client_id) + .unwrap_or(&self.default_mode_info) + .mode; + pane_contents_and_ui.render_pane_frame( + *client_id, + client_mode, + self.session_is_mirrored, + ); if let PaneId::Plugin(..) = kind { - pane_contents_and_ui.render_pane_contents_for_client(client_id); + pane_contents_and_ui.render_pane_contents_for_client(*client_id); } // this is done for panes that don't have their own cursor (eg. panes of // another user) - pane_contents_and_ui.render_fake_cursor_if_needed(client_id); + pane_contents_and_ui.render_fake_cursor_if_needed(*client_id); } if let PaneId::Terminal(..) = kind { pane_contents_and_ui @@ -719,18 +748,32 @@ impl FloatingPanes { } } } - pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) { - self.active_panes.insert(client_id, pane_id); + pub fn focus_pane_for_all_clients(&mut self, pane_id: PaneId) { + let connected_clients: Vec<ClientId> = + self.connected_clients.borrow().iter().copied().collect(); + for client_id in connected_clients { + self.active_panes.insert(client_id, pane_id); + } self.z_indices.retain(|p_id| *p_id != pane_id); self.z_indices.push(pane_id); self.set_pane_active_at(pane_id); self.set_force_render(); } + pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) { + self.active_panes.insert(client_id, pane_id); + self.focus_pane_for_all_clients(pane_id); + } pub fn defocus_pane(&mut self, pane_id: PaneId, client_id: ClientId) { self.z_indices.retain(|p_id| *p_id != pane_id); self.active_panes.remove(&client_id); self.set_force_render(); } + pub fn get_pane(&self, pane_id: PaneId) -> Option<&Box<dyn Pane>> { + self.panes.get(&pane_id) + } + pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box<dyn Pane>> { + self.panes.get_mut(&pane_id) + } pub fn get_pane_id_at(&self, point: &Position, search_selectable: bool) -> Option<PaneId> { if search_selectable { // TODO: better - loop through z-indices and check each one if it contains the point @@ -825,4 +868,10 @@ impl FloatingPanes { }; self.pane_being_moved_with_mouse = None; } + pub fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> { + self.active_panes.get(&client_id).copied() + } + pub fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> { + self.panes.iter() + } } diff --git a/zellij-server/src/panes/mod.rs b/zellij-server/src/panes/mod.rs index d3fd0807..b9e7d8d0 100644 --- a/zellij-server/src/panes/mod.rs +++ b/zellij-server/src/panes/mod.rs @@ -6,6 +6,7 @@ mod plugin_pane; pub mod selection; pub mod terminal_character; mod terminal_pane; +mod tiled_panes; pub use alacritty_functions::*; pub use floating_panes::*; @@ -14,3 +15,4 @@ pub use link_handler::*; pub(crate) use plugin_pane::*; pub(crate) use terminal_character::*; pub use terminal_pane::*; +pub use tiled_panes::*; diff --git a/zellij-server/src/panes/tiled_panes/mod.rs b/zellij-server/src/panes/tiled_panes/mod.rs new file mode 100644 index 00000000..dc755af4 --- /dev/null +++ b/zellij-server/src/panes/tiled_panes/mod.rs @@ -0,0 +1,1035 @@ +mod pane_resizer; +mod tiled_pane_grid; + +use zellij_utils::zellij_tile; + +use crate::tab::{Pane, MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; +use tiled_pane_grid::{split, TiledPaneGrid}; + +use crate::{ + os_input_output::ServerOsApi, output::Output, panes::PaneId, ui::boundaries::Boundaries, + ui::pane_contents_and_ui::PaneContentsAndUi, ClientId, +}; +use std::cell::RefCell; +use std::collections::{BTreeMap, HashMap, HashSet}; +use std::rc::Rc; +use std::time::Instant; +use zellij_tile::data::{ModeInfo, Palette}; +use zellij_utils::{ + input::layout::Direction, + pane_size::{Offset, PaneGeom, Size, Viewport}, +}; + +macro_rules! resize_pty { + ($pane:expr, $os_input:expr) => { + if let PaneId::Terminal(ref pid) = $pane.pid() { + // FIXME: This `set_terminal_size_using_fd` call would be best in + // `TerminalPane::reflow_lines` + $os_input.set_terminal_size_using_fd( + *pid, + $pane.get_content_columns() as u16, + $pane.get_content_rows() as u16, + ); + } + }; +} + +fn pane_content_offset(position_and_size: &PaneGeom, viewport: &Viewport) -> (usize, usize) { + // (columns_offset, rows_offset) + // if the pane is not on the bottom or right edge on the screen, we need to reserve one space + // from its content to leave room for the boundary between it and the next pane (if it doesn't + // draw its own frame) + let columns_offset = if position_and_size.x + position_and_size.cols.as_usize() < viewport.cols + { + 1 + } else { + 0 + }; + let rows_offset = if position_and_size.y + position_and_size.rows.as_usize() < viewport.rows { + 1 + } else { + 0 + }; + (columns_offset, rows_offset) +} + +pub struct TiledPanes { + pub panes: BTreeMap<PaneId, Box<dyn Pane>>, + display_area: Rc<RefCell<Size>>, + viewport: Rc<RefCell<Viewport>>, + connected_clients: Rc<RefCell<HashSet<ClientId>>>, + connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>, + mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>, + default_mode_info: ModeInfo, + colors: Palette, + session_is_mirrored: bool, + active_panes: HashMap<ClientId, PaneId>, + draw_pane_frames: bool, + panes_to_hide: HashSet<PaneId>, + fullscreen_is_active: bool, + os_api: Box<dyn ServerOsApi>, +} + +impl TiledPanes { + pub fn new( + display_area: Rc<RefCell<Size>>, + viewport: Rc<RefCell<Viewport>>, + connected_clients: Rc<RefCell<HashSet<ClientId>>>, + connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>, + mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>, + session_is_mirrored: bool, + draw_pane_frames: bool, + default_mode_info: ModeInfo, + colors: Palette, + os_api: Box<dyn ServerOsApi>, + ) -> Self { + TiledPanes { + panes: BTreeMap::new(), + display_area, + viewport, + connected_clients, + connected_clients_in_app, + mode_info, + default_mode_info, + colors, + session_is_mirrored, + active_panes: HashMap::new(), + draw_pane_frames, + panes_to_hide: HashSet::new(), + fullscreen_is_active: false, + os_api, + } + } + pub fn add_pane_with_existing_geom(&mut self, pane_id: PaneId, pane: Box<dyn Pane>) { + self.panes.insert(pane_id, pane); + } + pub fn insert_pane(&mut self, pane_id: PaneId, mut pane: Box<dyn Pane>) { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let pane_id_and_split_direction = pane_grid.find_room_for_new_pane(); + if let Some((pane_id_to_split, split_direction)) = pane_id_and_split_direction { + // this unwrap is safe because floating panes should not be visible if there are no floating panes + let pane_to_split = self.panes.get_mut(&pane_id_to_split).unwrap(); + let size_of_both_panes = pane_to_split.position_and_size(); + if let Some((first_geom, second_geom)) = split(split_direction, &size_of_both_panes) { + pane_to_split.set_geom(first_geom); + pane.set_geom(second_geom); + self.panes.insert(pane_id, pane); + // ¯\_(ツ)_/¯ + let relayout_direction = match split_direction { + Direction::Vertical => Direction::Horizontal, + Direction::Horizontal => Direction::Vertical, + }; + self.relayout(relayout_direction); + } + } + } + pub fn has_room_for_new_pane(&mut self) -> bool { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.find_room_for_new_pane().is_some() + } + pub fn fixed_pane_geoms(&self) -> Vec<Viewport> { + self.panes + .values() + .filter_map(|p| { + let geom = p.position_and_size(); + if geom.cols.is_fixed() || geom.rows.is_fixed() { + Some(geom.into()) + } else { + None + } + }) + .collect() + } + pub fn first_selectable_pane_id(&self) -> Option<PaneId> { + self.panes + .iter() + .filter(|(_id, pane)| pane.selectable()) + .map(|(id, _)| id.to_owned()) + .next() + } + pub fn pane_ids(&self) -> impl Iterator<Item = &PaneId> { + self.panes.keys() + } + pub fn relayout(&mut self, direction: Direction) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let result = match direction { + Direction::Horizontal => { + pane_grid.layout(direction, (*self.display_area.borrow()).cols) + } + Direction::Vertical => pane_grid.layout(direction, (*self.display_area.borrow()).rows), + }; + if let Err(e) = &result { + log::error!("{:?} relayout of the tab failed: {}", direction, e); + } + self.set_pane_frames(self.draw_pane_frames); + } + pub fn set_pane_frames(&mut self, draw_pane_frames: bool) { + self.draw_pane_frames = draw_pane_frames; + let viewport = *self.viewport.borrow(); + for pane in self.panes.values_mut() { + if !pane.borderless() { + pane.set_frame(draw_pane_frames); + } + + #[allow(clippy::if_same_then_else)] + if draw_pane_frames & !pane.borderless() { + // there's definitely a frame around this pane, offset its contents + pane.set_content_offset(Offset::frame(1)); + } else if draw_pane_frames && pane.borderless() { + // there's no frame around this pane, and the tab isn't handling the boundaries + // between panes (they each draw their own frames as they please) + // this one doesn't - do not offset its content + pane.set_content_offset(Offset::default()); + } else if !is_inside_viewport(&viewport, pane) { + // this pane is outside the viewport and has no border - it should not have an offset + pane.set_content_offset(Offset::default()); + } else { + // no draw_pane_frames and this pane should have a separation to other panes + // according to its position in the viewport (eg. no separation if its at the + // viewport bottom) - offset its content accordingly + let position_and_size = pane.current_geom(); + let (pane_columns_offset, pane_rows_offset) = + pane_content_offset(&position_and_size, &viewport); + pane.set_content_offset(Offset::shift(pane_rows_offset, pane_columns_offset)); + } + + resize_pty!(pane, &mut self.os_api); + } + } + pub fn can_split_pane_horizontally(&mut self, client_id: ClientId) -> bool { + if let Some(active_pane_id) = &self.active_panes.get(&client_id) { + if let Some(active_pane) = self.panes.get_mut(active_pane_id) { + let full_pane_size = active_pane.position_and_size(); + if full_pane_size.rows.as_usize() < MIN_TERMINAL_HEIGHT * 2 { + return false; + } else { + return split(Direction::Horizontal, &full_pane_size).is_some(); + } + } + } + false + } + pub fn can_split_pane_vertically(&mut self, client_id: ClientId) -> bool { + if let Some(active_pane_id) = &self.active_panes.get(&client_id) { + if let Some(active_pane) = self.panes.get_mut(active_pane_id) { + let full_pane_size = active_pane.position_and_size(); + if full_pane_size.cols.as_usize() < MIN_TERMINAL_WIDTH * 2 { + return false; + } + return split(Direction::Vertical, &full_pane_size).is_some(); + } + } + false + } + pub fn split_pane_horizontally( + &mut self, + pid: PaneId, + mut new_pane: Box<dyn Pane>, + client_id: ClientId, + ) { + let active_pane_id = &self.active_panes.get(&client_id).unwrap(); + let active_pane = self.panes.get_mut(active_pane_id).unwrap(); + let full_pane_size = active_pane.position_and_size(); + if let Some((top_winsize, bottom_winsize)) = split(Direction::Horizontal, &full_pane_size) { + active_pane.set_geom(top_winsize); + new_pane.set_geom(bottom_winsize); + self.panes.insert(pid, new_pane); + self.relayout(Direction::Vertical); + } + } + pub fn split_pane_vertically( + &mut self, + pid: PaneId, + mut new_pane: Box<dyn Pane>, + client_id: ClientId, + ) { + let active_pane_id = &self.active_panes.get(&client_id).unwrap(); + let active_pane = self.panes.get_mut(active_pane_id).unwrap(); + let full_pane_size = active_pane.position_and_size(); + if let Some((left_winsize, right_winsize)) = split(Direction::Vertical, &full_pane_size) { + active_pane.set_geom(left_winsize); + new_pane.set_geom(right_winsize); + self.panes.insert(pid, new_pane); + self.relayout(Direction::Horizontal); + } + } + pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) { + self.active_panes.insert(client_id, pane_id); + if self.session_is_mirrored { + // move all clients + let connected_clients: Vec<ClientId> = + self.connected_clients.borrow().iter().copied().collect(); + for client_id in connected_clients { + self.active_panes.insert(client_id, pane_id); + } + } + } + pub fn clear_active_panes(&mut self) { + self.active_panes.clear(); + } + pub fn first_active_pane_id(&self) -> Option<PaneId> { + self.connected_clients + .borrow() + .iter() + .next() + .and_then(|first_client_id| self.active_panes.get(first_client_id).copied()) + } + pub fn focused_pane_id(&self, client_id: ClientId) -> Option<PaneId> { + self.active_panes.get(&client_id).copied() + } + pub fn get_pane(&self, pane_id: PaneId) -> Option<&Box<dyn Pane>> { + self.panes.get(&pane_id) + } + pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box<dyn Pane>> { + self.panes.get_mut(&pane_id) + } + pub fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> { + self.active_panes.get(&client_id).copied() + } + pub fn panes_contain(&self, pane_id: &PaneId) -> bool { + self.panes.contains_key(pane_id) + } + pub fn set_force_render(&mut self) { + for pane in self.panes.values_mut() { + pane.set_should_render(true); + pane.set_should_render_boundaries(true); + pane.render_full_viewport(); + } + } + pub fn has_active_panes(&self) -> bool { + !self.active_panes.is_empty() + } + pub fn has_panes(&self) -> bool { + !self.panes.is_empty() + } + pub fn render(&mut self, output: &mut Output) { + let connected_clients: Vec<ClientId> = + { self.connected_clients.borrow().iter().copied().collect() }; + let multiple_users_exist_in_session = { self.connected_clients_in_app.borrow().len() > 1 }; + let mut client_id_to_boundaries: HashMap<ClientId, Boundaries> = HashMap::new(); + let active_panes = if self.session_is_mirrored { + HashMap::new() + } else { + self.active_panes + .iter() + .filter(|(client_id, _pane_id)| connected_clients.contains(client_id)) + .map(|(client_id, pane_id)| (*client_id, *pane_id)) + .collect() + }; + for (kind, pane) in self.panes.iter_mut() { + if !self.panes_to_hide.contains(&pane.pid()) { + let mut pane_contents_and_ui = PaneContentsAndUi::new( + pane, + output, + self.colors, + &active_panes, + multiple_users_exist_in_session, + None, + ); + for client_id in &connected_clients { + let client_mode = self + .mode_info + .borrow() + .get(&client_id) + .unwrap_or(&self.default_mode_info) + .mode; + if let PaneId::Plugin(..) = kind { + pane_contents_and_ui.render_pane_contents_for_client(*client_id); + } + if self.draw_pane_frames { + pane_contents_and_ui.render_pane_frame( + *client_id, + client_mode, + self.session_is_mirrored, + ); + } else { + let boundaries = client_id_to_boundaries + .entry(*client_id) + .or_insert_with(|| Boundaries::new(*self.viewport.borrow())); + pane_contents_and_ui.render_pane_boundaries( + *client_id, + client_mode, + boundaries, + self.session_is_mirrored, + ); + } + pane_contents_and_ui.render_terminal_title_if_needed(*client_id, client_mode); + // this is done for panes that don't have their own cursor (eg. panes of + // another user) + pane_contents_and_ui.render_fake_cursor_if_needed(*client_id); + } + if let PaneId::Terminal(..) = kind { + pane_contents_and_ui.render_pane_contents_to_multiple_clients( + connected_clients.iter().copied(), + ); + } + } + } + // render boundaries if needed + for (client_id, boundaries) in &mut client_id_to_boundaries { + // TODO: add some conditional rendering here so this isn't rendered for every character + output.add_character_chunks_to_client(*client_id, boundaries.render(), None); + } + } + pub fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> { + self.panes.iter() + } + pub fn resize(&mut self, new_screen_size: Size) { + // this is blocked out to appease the borrow checker + { + let mut display_area = self.display_area.borrow_mut(); + let mut viewport = self.viewport.borrow_mut(); + let panes = self + .panes + .iter_mut() + .filter(|(pid, _)| !self.panes_to_hide.contains(pid)); + let Size { rows, cols } = new_screen_size; + let mut pane_grid = TiledPaneGrid::new(panes, *display_area, *viewport); + if pane_grid.layout(Direction::Horizontal, cols).is_ok() { + let column_difference = cols as isize - display_area.cols as isize; + // FIXME: Should the viewport be an Offset? + viewport.cols = (viewport.cols as isize + column_difference) as usize; + display_area.cols = cols; + } else { + log::error!("Failed to horizontally resize the tab!!!"); + } + if pane_grid.layout(Direction::Vertical, rows).is_ok() { + let row_difference = rows as isize - display_area.rows as isize; + viewport.rows = (viewport.rows as isize + row_difference) as usize; + display_area.rows = rows; + } else { + log::error!("Failed to vertically resize the tab!!!"); + } + } + self.set_pane_frames(self.draw_pane_frames); + } + pub fn resize_active_pane_left(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_pane_left(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn resize_active_pane_right(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_pane_right(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn resize_active_pane_up(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_pane_up(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn resize_active_pane_down(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_pane_down(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn resize_active_pane_increase(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_increase(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn resize_active_pane_decrease(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + pane_grid.resize_decrease(&active_pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + } + } + pub fn focus_next_pane(&mut self, client_id: ClientId) { + let connected_clients: Vec<ClientId> = + { self.connected_clients.borrow().iter().copied().collect() }; + let active_pane_id = self.get_active_pane_id(client_id).unwrap(); + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_active_pane_id = pane_grid.next_selectable_pane_id(&active_pane_id); + for client_id in connected_clients { + self.active_panes.insert(client_id, next_active_pane_id); + } + self.set_pane_active_at(next_active_pane_id); + } + pub fn focus_previous_pane(&mut self, client_id: ClientId) { + let connected_clients: Vec<ClientId> = + { self.connected_clients.borrow().iter().copied().collect() }; + let active_pane_id = self.get_active_pane_id(client_id).unwrap(); + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_active_pane_id = pane_grid.previous_selectable_pane_id(&active_pane_id); + for client_id in connected_clients { + self.active_panes.insert(client_id, next_active_pane_id); + } + self.set_pane_active_at(next_active_pane_id); + } + fn set_pane_active_at(&mut self, pane_id: PaneId) { + if let Some(pane) = self.get_pane_mut(pane_id) { + pane.set_active_at(Instant::now()); + } + } + pub fn move_focus_left(&mut self, client_id: ClientId) -> bool { + match self.get_active_pane_id(client_id) { + Some(active_pane_id) => { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id); + match next_index { + Some(p) => { + // render previously active pane so that its frame does not remain actively + // colored + let previously_active_pane = self + .panes + .get_mut(self.active_panes.get(&client_id).unwrap()) + .unwrap(); + + previously_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + previously_active_pane.render_full_viewport(); + + let next_active_pane = self.panes.get_mut(&p).unwrap(); + next_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + next_active_pane.render_full_viewport(); + + self.focus_pane(p, client_id); + self.set_pane_active_at(p); + + return true; + } + None => { + return false; + } + } + } + None => { + return false; + } + } + } + pub fn move_focus_down(&mut self, client_id: ClientId) -> bool { + match self.get_active_pane_id(client_id) { + Some(active_pane_id) => { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id); + match next_index { + Some(p) => { + // render previously active pane so that its frame does not remain actively + // colored + let previously_active_pane = self + .panes + .get_mut(self.active_panes.get(&client_id).unwrap()) + .unwrap(); + + previously_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + previously_active_pane.render_full_viewport(); + + let next_active_pane = self.panes.get_mut(&p).unwrap(); + next_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + next_active_pane.render_full_viewport(); + + self.focus_pane(p, client_id); + self.set_pane_active_at(p); + + return true; + } + None => { + return false; + } + } + } + None => { + return false; + } + } + } + pub fn move_focus_up(&mut self, client_id: ClientId) -> bool { + match self.get_active_pane_id(client_id) { + Some(active_pane_id) => { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id); + match next_index { + Some(p) => { + // render previously active pane so that its frame does not remain actively + // colored + let previously_active_pane = self + .panes + .get_mut(self.active_panes.get(&client_id).unwrap()) + .unwrap(); + + previously_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + previously_active_pane.render_full_viewport(); + + let next_active_pane = self.panes.get_mut(&p).unwrap(); + next_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + next_active_pane.render_full_viewport(); + + self.focus_pane(p, client_id); + self.set_pane_active_at(p); + + return true; + } + None => { + return false; + } + } + } + None => { + return false; + } + } + } + pub fn move_focus_right(&mut self, client_id: ClientId) -> bool { + match self.get_active_pane_id(client_id) { + Some(active_pane_id) => { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id); + match next_index { + Some(p) => { + // render previously active pane so that its frame does not remain actively + // colored + let previously_active_pane = self + .panes + .get_mut(self.active_panes.get(&client_id).unwrap()) + .unwrap(); + + previously_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + previously_active_pane.render_full_viewport(); + + let next_active_pane = self.panes.get_mut(&p).unwrap(); + next_active_pane.set_should_render(true); + // we render the full viewport to remove any ui elements that might have been + // there before (eg. another user's cursor) + next_active_pane.render_full_viewport(); + + self.focus_pane(p, client_id); + self.set_pane_active_at(p); + + return true; + } + None => { + return false; + } + } + } + None => { + return false; + } + } + } + pub fn move_active_pane(&mut self, client_id: ClientId) { + let active_pane_id = self.get_active_pane_id(client_id).unwrap(); + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let new_position_id = pane_grid.next_selectable_pane_id(&active_pane_id); + let current_position = self.panes.get(&active_pane_id).unwrap(); + let prev_geom = current_position.position_and_size(); + let prev_geom_override = current_position.geom_override(); + + let new_position = self.panes.get_mut(&new_position_id).unwrap(); + let next_geom = new_position.position_and_size(); + let next_geom_override = new_position.geom_override(); + new_position.set_geom(prev_geom); + if let Some(geom) = prev_geom_override { + new_position.get_geom_override(geom); + } + resize_pty!(new_position, &mut self.os_api); + new_position.set_should_render(true); + + let current_position = self.panes.get_mut(&active_pane_id).unwrap(); + current_position.set_geom(next_geom); + if let Some(geom) = next_geom_override { + current_position.get_geom_override(geom); + } + resize_pty!(current_position, &mut self.os_api); + current_position.set_should_render(true); + } + pub fn move_active_pane_down(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id); + if let Some(p) = next_index { + let active_pane_id = self.active_panes.get(&client_id).unwrap(); + let current_position = self.panes.get(active_pane_id).unwrap(); + let prev_geom = current_position.position_and_size(); + let prev_geom_override = current_position.geom_override(); + + let new_position = self.panes.get_mut(&p).unwrap(); + let next_geom = new_position.position_and_size(); + let next_geom_override = new_position.geom_override(); + new_position.set_geom(prev_geom); + if let Some(geom) = prev_geom_override { + new_position.get_geom_override(geom); + } + resize_pty!(new_position, &mut self.os_api); + new_position.set_should_render(true); + + let current_position = self.panes.get_mut(active_pane_id).unwrap(); + current_position.set_geom(next_geom); + if let Some(geom) = next_geom_override { + current_position.get_geom_override(geom); + } + resize_pty!(current_position, &mut self.os_api); + current_position.set_should_render(true); + } + } + } + pub fn move_active_pane_left(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id); + if let Some(p) = next_index { + let active_pane_id = self.active_panes.get(&client_id).unwrap(); + let current_position = self.panes.get(active_pane_id).unwrap(); + let prev_geom = current_position.position_and_size(); + let prev_geom_override = current_position.geom_override(); + + let new_position = self.panes.get_mut(&p).unwrap(); + let next_geom = new_position.position_and_size(); + let next_geom_override = new_position.geom_override(); + new_position.set_geom(prev_geom); + if let Some(geom) = prev_geom_override { + new_position.get_geom_override(geom); + } + resize_pty!(new_position, &mut self.os_api); + new_position.set_should_render(true); + + let current_position = self.panes.get_mut(active_pane_id).unwrap(); + current_position.set_geom(next_geom); + if let Some(geom) = next_geom_override { + current_position.get_geom_override(geom); + } + resize_pty!(current_position, &mut self.os_api); + current_position.set_should_render(true); + } + } + } + pub fn move_active_pane_right(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id); + if let Some(p) = next_index { + let active_pane_id = self.active_panes.get(&client_id).unwrap(); + let current_position = self.panes.get(active_pane_id).unwrap(); + let prev_geom = current_position.position_and_size(); + let prev_geom_override = current_position.geom_override(); + + let new_position = self.panes.get_mut(&p).unwrap(); + let next_geom = new_position.position_and_size(); + let next_geom_override = new_position.geom_override(); + new_position.set_geom(prev_geom); + if let Some(geom) = prev_geom_override { + new_position.get_geom_override(geom); + } + resize_pty!(new_position, &mut self.os_api); + new_position.set_should_render(true); + + let current_position = self.panes.get_mut(active_pane_id).unwrap(); + current_position.set_geom(next_geom); + if let Some(geom) = next_geom_override { + current_position.get_geom_override(geom); + } + resize_pty!(current_position, &mut self.os_api); + current_position.set_should_render(true); + } + } + } + pub fn move_active_pane_up(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + let pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id); + if let Some(p) = next_index { + let active_pane_id = self.active_panes.get(&client_id).unwrap(); + let current_position = self.panes.get(active_pane_id).unwrap(); + let prev_geom = current_position.position_and_size(); + let prev_geom_override = current_position.geom_override(); + + let new_position = self.panes.get_mut(&p).unwrap(); + let next_geom = new_position.position_and_size(); + let next_geom_override = new_position.geom_override(); + new_position.set_geom(prev_geom); + if let Some(geom) = prev_geom_override { + new_position.get_geom_override(geom); + } + resize_pty!(new_position, &mut self.os_api); + new_position.set_should_render(true); + + let current_position = self.panes.get_mut(active_pane_id).unwrap(); + current_position.set_geom(next_geom); + if let Some(geom) = next_geom_override { + current_position.get_geom_override(geom); + } + resize_pty!(current_position, &mut self.os_api); + current_position.set_should_render(true); + } + } + } + pub fn move_clients_out_of_pane(&mut self, pane_id: PaneId) { + let active_panes: Vec<(ClientId, PaneId)> = self + .active_panes + .iter() + .map(|(cid, pid)| (*cid, *pid)) + .collect(); + match self + .panes + .iter() + .find(|(p_id, p)| **p_id != pane_id && p.selectable()) + .map(|(p_id, _p)| p_id) + { + Some(next_active_pane) => { + for (client_id, active_pane_id) in active_panes { + if active_pane_id == pane_id { + self.active_panes.insert(client_id, *next_active_pane); + } + } + } + None => self.active_panes.clear(), + } + } + pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<Box<dyn Pane>> { + let mut pane_grid = TiledPaneGrid::new( + &mut self.panes, + *self.display_area.borrow(), + *self.viewport.borrow(), + ); + if pane_grid.fill_space_over_pane(pane_id) { + // successfully filled space over pane + let closed_pane = self.panes.remove(&pane_id); + self.move_clients_out_of_pane(pane_id); + for pane in self.panes.values_mut() { + resize_pty!(pane, &mut self.os_api); + } + closed_pane + } else { + self.panes.remove(&pane_id); + // this is a bit of a roundabout way to say: this is the last pane and so the tab + // should be destroyed + self.active_panes.clear(); + None + } + } + pub fn panes_to_hide_contains(&self, pane_id: PaneId) -> bool { + self.panes_to_hide.contains(&pane_id) + } + pub fn fullscreen_is_active(&self) -> bool { + self.fullscreen_is_active + } + pub fn unset_fullscreen(&mut self) { + if self.fullscreen_is_active { + let first_client_id = { + let connected_clients = self.connected_clients.borrow(); + *connected_clients.iter().next().unwrap() + }; + let active_pane_id = self.get_active_pane_id(first_client_id).unwrap(); + let panes_to_hide: Vec<_> = self.panes_to_hide.iter().copied().collect(); + for pane_id in panes_to_hide { + let pane = self.get_pane_mut(pane_id).unwrap(); + pane.set_should_render(true); + pane.set_should_render_boundaries(true); + } + let viewport_pane_ids: Vec<_> = self + .panes + .keys() + .copied() + .into_iter() + .filter(|id| { + !is_inside_viewport(&*self.viewport.borrow(), self.get_pane(*id).unwrap()) + }) + .collect(); + for pid in viewport_pane_ids { + let viewport_pane = self.get_pane_mut(pid).unwrap(); + viewport_pane.reset_size_and_position_override(); + } + self.panes_to_hide.clear(); + let active_terminal = self.get_pane_mut(active_pane_id).unwrap(); + active_terminal.reset_size_and_position_override(); + self.set_force_render(); + let display_area = *self.display_area.borrow(); + self.resize(display_area); + self.fullscreen_is_active = false; + } + } + pub fn toggle_active_pane_fullscreen(&mut self, client_id: ClientId) { + if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + if self.fullscreen_is_active { + self.unset_fullscreen(); + } else { + let pane_ids_to_hide = self.panes.iter().filter_map(|(&id, _pane)| { + if id != active_pane_id + && is_inside_viewport(&*self.viewport.borrow(), self.get_pane(id).unwrap()) + { + Some(id) + } else { + None + } + }); + self.panes_to_hide = pane_ids_to_hide.collect(); + if self.panes_to_hide.is_empty() { + // nothing to do, pane is already as fullscreen as it can be, let's bail + return; + } else { + // For all of the panes outside of the viewport staying on the fullscreen + // screen, switch them to using override positions as well so that the resize + // system doesn't get confused by viewport and old panes that no longer line up + let viewport_pane_ids: Vec<_> = self + .panes + .keys() + .copied() + .into_iter() + .filter(|id| { + !is_inside_viewport( + &*self.viewport.borrow(), + self.get_pane(*id).unwrap(), + ) + }) + .collect(); + for pid in viewport_pane_ids { + let viewport_pane = self.get_pane_mut(pid).unwrap(); + viewport_pane.get_geom_override(viewport_pane.position_and_size()); + } + let viewport = { *self.viewport.borrow() }; + let active_terminal = self.get_pane_mut(active_pane_id).unwrap(); + let full_screen_geom = PaneGeom { + x: viewport.x, + y: viewport.y, + ..Default::default() + }; + active_terminal.get_geom_override(full_screen_geom); + } + let connected_client_list: Vec<ClientId> = + { self.connected_clients.borrow().iter().copied().collect() }; + for client_id in connected_client_list { + self.focus_pane(active_pane_id, client_id); + } + self.set_force_render(); + let display_area = *self.display_area.borrow(); + self.resize(display_area); + self.fullscreen_is_active = true; + } + } + } + pub fn panes_to_hide_count(&self) -> usize { + self.panes_to_hide.len() + } +} + +#[allow(clippy::borrowed_box)] +pub fn is_inside_viewport(viewport: &Viewport, pane: &Box<dyn Pane>) -> bool { + let pane_position_and_size = pane.current_geom(); + pane_position_and_size.y >= viewport.y + && pane_position_and_size.y + pane_position_and_size.rows.as_usize() + <= viewport.y + viewport.rows +} + +pub fn pane_geom_is_inside_viewport(viewport: &Viewport, geom: &PaneGeom) -> bool { + geom.y >= viewport.y + && geom.y + geom.rows.as_usize() <= viewport.y + viewport.rows + && geom.x >= viewport.x + && geom.x + geom.cols.as_usize() <= viewport.x + viewport.cols +} diff --git a/zellij-server/src/panes/tiled_panes/pane_resizer.rs b/zellij-server/src/panes/tiled_panes/pane_resizer.rs new file mode 100644 index 00000000..7264c49a --- /dev/null +++ b/zellij-server/src/panes/tiled_panes/pane_resizer.rs @@ -0,0 +1,246 @@ +use crate::{panes::PaneId, tab::Pane}; +use cassowary::{ + strength::{REQUIRED, STRONG}, + Expression, Solver, Variable, + WeightedRelation::EQ, +}; +use std::cell::RefCell; +use std::collections::{HashMap, HashSet}; +use std::rc::Rc; +use zellij_utils::{ + input::layout::Direction, + pane_size::{Constraint, Dimension, PaneGeom}, +}; + +pub struct PaneResizer<'a> { + panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>, + vars: HashMap<PaneId, Variable>, + solver: Solver, +} + +// FIXME: Just hold a mutable Pane reference instead of the PaneId, fixed, pos, and size? +// Do this after panes are no longer trait-objects! +#[derive(Debug, Clone, Copy)] +struct Span { + pid: PaneId, + direction: Direction, + pos: usize, + size: Dimension, + size_var: Variable, +} + +type Grid = Vec<Vec<Span>>; + +impl<'a> PaneResizer<'a> { + pub fn new(panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>) -> Self { + let mut vars = HashMap::new(); + for &k in panes.borrow().keys() { + vars.insert(k, Variable::new()); + } + PaneResizer { + panes, + vars, + solver: Solver::new(), + } + } + + pub fn layout(&mut self, direction: Direction, space: usize) -> Result<(), String> { + self.solver.reset(); + let grid = self.solve(direction, space)?; + let spans = self.discretize_spans(grid, space)?; + self.apply_spans(spans); + Ok(()) + } + + fn solve(&mut self, direction: Direction, space: usize) -> Result<Grid, String> { + let grid: Grid = self + .grid_boundaries(direction) + .into_iter() + .map(|b| self.spans_in_boundary(direction, b)) + .collect(); + + let constraints: HashSet<_> = grid + .iter() + .flat_map(|s| constrain_spans(space, s)) + .collect(); + + self.solver + .add_constraints(&constraints) + .map_err(|e| format!("{:?}", e))?; + + Ok(grid) + } + + fn discretize_spans(&mut self, mut grid: Grid, space: usize) -> Result<Vec<Span>, String> { + let mut rounded_sizes: HashMap<_, _> = grid + .iter() + .flatten() + .map(|s| { + ( + s.size_var, + stable_round(self.solver.get_value(s.size_var)) as isize, + ) + }) + .collect(); + + // Round f64 pane sizes to usize without gaps or overlap + let mut finalised = Vec::new(); + for spans in &mut grid { + let rounded_size: isize = spans.iter().map(|s| rounded_sizes[&s.size_var]).sum(); + let mut error = space as isize - rounded_size; + let mut flex_spans: Vec<_> = spans + .iter_mut() + .filter(|s| !s.size.is_fixed() && !finalised.contains(&s.pid)) + .collect(); + flex_spans.sort_by_key(|s| rounded_sizes[&s.size_var]); + if error < 0 { + flex_spans.reverse(); + } + for span in flex_spans { + rounded_sizes + .entry(span.size_var) + .and_modify(|s| *s += error.signum()); + error -= error.signum(); + } + finalised.extend(spans.iter().map(|s| s.pid)); + } + + // Update span positions based on their rounded sizes + for spans in &mut grid { + let mut offset = 0; + for span in spans { + span.pos = offset; + let sz = rounded_sizes[&span.size_var]; + if sz < 1 { + return Err("Ran out of room for spans".into()); + } + span.size.set_inner(sz as usize); + offset += span.size.as_usize(); + } + } + + Ok(grid.into_iter().flatten().collect()) + } + + fn apply_spans(&mut self, spans: Vec<Span>) { + let mut panes = self.panes.borrow_mut(); + for span in spans { + let pane = panes.get_mut(&span.pid).unwrap(); + let new_geom = match span.direction { + Direction::Horizontal => PaneGeom { + x: span.pos, + cols: span.size, + ..pane.current_geom() + }, + Direction::Vertical => PaneGeom { + y: span.pos, + rows: span.size, + ..pane.current_geom() + }, + }; + if pane.geom_override().is_some() { + pane.get_geom_override(new_geom); + } else { + pane.set_geom(new_geom); + } + } + } + + // FIXME: Functions like this should have unit tests! + fn grid_boundaries(&self, direction: Direction) -> Vec<(usize, usize)> { + // Select the spans running *perpendicular* to the direction of resize + let spans: Vec<Span> = self + .panes + .borrow() + .values() + .map(|p| self.get_span(!direction, p.as_ref())) + .collect(); + + let mut last_edge = 0; + let mut bounds = Vec::new(); + let mut edges: Vec<usize> = spans.iter().map(|s| s.pos + s.size.as_usize()).collect(); + edges.sort_unstable(); + edges.dedup(); + for next in edges { + let next_edge = next; + bounds.push((last_edge, next_edge)); + last_edge = next_edge; + } + bounds + } + + fn spans_in_boundary(&self, direction: Direction, boundary: (usize, usize)) -> Vec<Span> { + let bwn = |v, (s, e)| s <= v && v < e; + let mut spans: Vec<_> = self + .panes + .borrow() + .values() + .filter(|p| { + let s = self.get_span(!direction, p.as_ref()); + let span_bounds = (s.pos, s.pos + s.size.as_usize()); + bwn(span_bounds.0, boundary) + || (bwn(boundary.0, span_bounds) + && (bwn(boundary.1, span_bounds) || boundary.1 == span_bounds.1)) + }) + .map(|p| self.get_span(direction, p.as_ref())) + .collect(); + spans.sort_unstable_by_key(|s| s.pos); + spans + } + + fn get_span(&self, direction: Direction, pane: &dyn Pane) -> Span { + let pas = pane.current_geom(); + // let size_var = self.vars[&pane.pid()]; + let size_var = *self.vars.get(&pane.pid()).unwrap(); + match direction { + Direction::Horizontal => Span { + pid: pane.pid(), + direction, + pos: pas.x, + size: pas.cols, + size_var, + }, + Direction::Vertical => Span { + pid: pane.pid(), + direction, + pos: pas.y, + size: pas.rows, + size_var, + }, + } + } +} + +fn constrain_spans(space: usize, spans: &[Span]) -> HashSet<cassowary::Constraint> { + let mut constraints = HashSet::new(); + + // Calculating "flexible" space (space not consumed by fixed-size spans) + let new_flex_space = spans.iter().fold(space, |a, s| { + if let Constraint::Fixed(sz) = s.size.constraint { + a.saturating_sub(sz) + } else { + a + } + }); + + // Spans must use all of the available space + let full_size = spans + .iter() + .fold(Expression::from_constant(0.0), |acc, s| acc + s.size_var); + constraints.insert(full_size | EQ(REQUIRED) | space as f64); + + // Try to maintain ratios and lock non-flexible sizes + for span in spans { + match span.size.constraint { + Constraint::Fixed(s) => constraints.insert(span.size_var | EQ(REQUIRED) | s as f64), + Constraint::Percent(p) => constraints + .insert((span.size_var / new_flex_space as f64) | EQ(STRONG) | (p / 100.0)), + }; + } + + constraints +} + +fn stable_round(x: f64) -> f64 { + ((x * 100.0).round() / 100.0).round() +} diff --git a/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs new file mode 100644 index 00000000..5bbaf65a --- /dev/null +++ b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs @@ -0,0 +1,1740 @@ +use super::is_inside_viewport; +use super::pane_resizer::PaneResizer; +use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; +use crate::{panes::PaneId, tab::Pane}; +use std::cmp::Reverse; +use std::collections::{HashMap, HashSet}; +use zellij_utils::{ + input::layout::Direction, + pane_size::{Dimension, PaneGeom, Size, Viewport}, +}; + +use std::cell::RefCell; +use std::rc::Rc; + +const RESIZE_PERCENT: f64 = 5.0; +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>); + +pub struct TiledPaneGrid<'a> { + panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>, + display_area: Size, // includes all panes (including eg. the status bar and tab bar in the default layout) + viewport: Viewport, // includes all non-UI panes +} + +impl<'a> TiledPaneGrid<'a> { + pub fn new( + panes: impl IntoIterator<Item = (&'a PaneId, &'a mut Box<dyn Pane>)>, + display_area: Size, + viewport: Viewport, + ) -> Self { + let panes: HashMap<_, _> = panes.into_iter().map(|(p_id, p)| (*p_id, p)).collect(); + TiledPaneGrid { + panes: Rc::new(RefCell::new(panes)), + display_area, + viewport, + } + } + + pub fn layout(&mut self, direction: Direction, space: usize) -> Result<(), String> { + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + pane_resizer.layout(direction, space) + } + pub fn resize_pane_left(&'a mut self, pane_id: &PaneId) { + // TODO: find out by how much we actually reduced and only reduce by that much + if self.can_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT) { + self.increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + // let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + } else if self.can_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT) { + self.reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + } + } + pub fn resize_pane_right(&mut self, pane_id: &PaneId) { + // TODO: find out by how much we actually reduced and only reduce by that much + if self.can_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT) { + self.increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + } else if self.can_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT) { + self.reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + } + } + pub fn resize_pane_down(&mut self, pane_id: &PaneId) { + // TODO: find out by how much we actually reduced and only reduce by that much + if self.can_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT) { + self.increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + } else if self.can_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT) { + self.reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + } + } + pub fn resize_pane_up(&mut self, pane_id: &PaneId) { + // TODO: find out by how much we actually reduced and only reduce by that much + if self.can_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT) { + self.increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + } else if self.can_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT) { + self.reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + } + } + pub fn resize_increase(&mut self, pane_id: &PaneId) { + if self.try_increase_pane_and_surroundings_right_and_down(pane_id) { + return; + } + if self.try_increase_pane_and_surroundings_left_and_down(pane_id) { + return; + } + if self.try_increase_pane_and_surroundings_right_and_up(pane_id) { + return; + } + if self.try_increase_pane_and_surroundings_left_and_up(pane_id) { + return; + } + + if self.try_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT) { + return; + } + if self.try_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT) { + return; + } + if self.try_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT) { + return; + } + self.try_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + } + pub fn resize_decrease(&mut self, pane_id: &PaneId) { + if self.try_reduce_pane_and_surroundings_left_and_up(pane_id) { + return; + } + if self.try_reduce_pane_and_surroundings_right_and_up(pane_id) { + return; + } + if self.try_reduce_pane_and_surroundings_right_and_down(pane_id) { + return; + } + if self.try_reduce_pane_and_surroundings_left_and_down(pane_id) { + return; + } + if self.try_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT) { + return; + } + if self.try_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT) { + return; + } + if self.try_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT) { + return; + } + self.try_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + } + fn can_increase_pane_and_surroundings_right(&self, pane_id: &PaneId, increase_by: f64) -> bool { + let panes = self.panes.borrow(); + if let Some(panes_to_the_right) = self.pane_ids_directly_right_of(pane_id) { + panes_to_the_right.iter().all(|id| { + let p = panes.get(id).unwrap(); + if let Some(cols) = p.position_and_size().cols.as_percent() { + let current_fixed_cols = p.position_and_size().cols.as_usize(); + let will_reduce_by = + ((self.display_area.cols as f64 / 100.0) * increase_by) as usize; + cols - increase_by >= RESIZE_PERCENT + && current_fixed_cols.saturating_sub(will_reduce_by) >= p.min_width() + } else { + false + } + }) + } else { + false + } + } + fn can_increase_pane_and_surroundings_left(&self, pane_id: &PaneId, increase_by: f64) -> bool { + let panes = self.panes.borrow(); + if let Some(panes_to_the_left) = self.pane_ids_directly_left_of(pane_id) { + panes_to_the_left.iter().all(|id| { + let p = panes.get(id).unwrap(); + if let Some(cols) = p.position_and_size().cols.as_percent() { + let current_fixed_cols = p.position_and_size().cols.as_usize(); + let will_reduce_by = + ((self.display_area.cols as f64 / 100.0) * increase_by) as usize; + cols - increase_by >= RESIZE_PERCENT + && current_fixed_cols.saturating_sub(will_reduce_by) >= p.min_width() + } else { + false + } + }) + } else { + false + } + } + fn can_increase_pane_and_surroundings_down(&self, pane_id: &PaneId, increase_by: f64) -> bool { + let panes = self.panes.borrow(); + if let Some(panes_below) = self.pane_ids_directly_below(pane_id) { + panes_below.iter().all(|id| { + let p = panes.get(id).unwrap(); + if let Some(rows) = p.position_and_size().rows.as_percent() { + let current_fixed_rows = p.position_and_size().rows.as_usize(); + let will_reduce_by = + ((self.display_area.rows as f64 / 100.0) * increase_by) as usize; + rows - increase_by >= RESIZE_PERCENT + && current_fixed_rows.saturating_sub(will_reduce_by) >= p.min_height() + } else { + false + } + }) + } else { + false + } + } + + fn can_increase_pane_and_surroundings_up(&self, pane_id: &PaneId, increase_by: f64) -> bool { + let panes = self.panes.borrow(); + if let Some(panes_above) = self.pane_ids_directly_above(pane_id) { + panes_above.iter().all(|id| { + let p = panes.get(id).unwrap(); + if let Some(rows) = p.position_and_size().rows.as_percent() { + let current_fixed_rows = p.position_and_size().rows.as_usize(); + let will_reduce_by = + ((self.display_area.rows as f64 / 100.0) * increase_by) as usize; + rows - increase_by >= RESIZE_PERCENT + && current_fixed_rows.saturating_sub(will_reduce_by) >= p.min_height() + } else { + false + } + }) + } else { + false + } + } + fn can_reduce_pane_and_surroundings_right(&self, pane_id: &PaneId, reduce_by: f64) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + if let Some(cols) = pane.position_and_size().cols.as_percent() { + let current_fixed_cols = pane.position_and_size().cols.as_usize(); + let will_reduce_by = ((self.display_area.cols as f64 / 100.0) * reduce_by) as usize; + let ids_left = self.pane_ids_directly_left_of(pane_id); + let flexible_left = self.ids_are_flexible(Direction::Horizontal, ids_left); + cols - reduce_by >= RESIZE_PERCENT + && flexible_left + && current_fixed_cols.saturating_sub(will_reduce_by) >= pane.min_width() + } else { + false + } + } + fn can_reduce_pane_and_surroundings_left(&self, pane_id: &PaneId, reduce_by: f64) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + if let Some(cols) = pane.position_and_size().cols.as_percent() { + let current_fixed_cols = pane.position_and_size().cols.as_usize(); + let will_reduce_by = ((self.display_area.cols as f64 / 100.0) * reduce_by) as usize; + let ids_right = self.pane_ids_directly_right_of(pane_id); + let flexible_right = self.ids_are_flexible(Direction::Horizontal, ids_right); + cols - reduce_by >= RESIZE_PERCENT + && flexible_right + && current_fixed_cols.saturating_sub(will_reduce_by) >= pane.min_width() + } else { + false + } + } + fn can_reduce_pane_and_surroundings_down(&self, pane_id: &PaneId, reduce_by: f64) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + if let Some(rows) = pane.position_and_size().rows.as_percent() { + let current_fixed_rows = pane.position_and_size().rows.as_usize(); + let will_reduce_by = ((self.display_area.rows as f64 / 100.0) * reduce_by) as usize; + let ids_above = self.pane_ids_directly_above(pane_id); + let flexible_above = self.ids_are_flexible(Direction::Vertical, ids_above); + rows - reduce_by >= RESIZE_PERCENT + && flexible_above + && current_fixed_rows.saturating_sub(will_reduce_by) >= pane.min_height() + } else { + false + } + } + fn can_reduce_pane_and_surroundings_up(&self, pane_id: &PaneId, reduce_by: f64) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(pane_id).unwrap(); + if let Some(rows) = pane.position_and_size().rows.as_percent() { + let current_fixed_rows = pane.position_and_size().rows.as_usize(); + let will_reduce_by = ((self.display_area.rows as f64 / 100.0) * reduce_by) as usize; + let ids_below = self.pane_ids_directly_below(pane_id); + let flexible_below = self.ids_are_flexible(Direction::Vertical, ids_below); + rows - reduce_by >= RESIZE_PERCENT + && flexible_below + && current_fixed_rows.saturating_sub(will_reduce_by) >= pane.min_height() + } else { + false + } + } + fn reduce_pane_height(&mut self, id: &PaneId, percent: f64) { + let mut panes = self.panes.borrow_mut(); + let terminal = panes.get_mut(id).unwrap(); + terminal.reduce_height(percent); + } + fn increase_pane_height(&mut self, id: &PaneId, percent: f64) { + let mut panes = self.panes.borrow_mut(); + let terminal = panes.get_mut(id).unwrap(); + terminal.increase_height(percent); + } + fn increase_pane_width(&mut self, id: &PaneId, percent: f64) { + let mut panes = self.panes.borrow_mut(); + let terminal = panes.get_mut(id).unwrap(); + terminal.increase_width(percent); + } + fn reduce_pane_width(&mut self, id: &PaneId, percent: f64) { + let mut panes = self.panes.borrow_mut(); + let terminal = panes.get_mut(id).unwrap(); + terminal.reduce_width(percent); + } + fn increase_pane_and_surroundings_up(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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(id, percent); + for terminal_id in terminals_above { + self.reduce_pane_height(&terminal_id, percent); + } + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + self.increase_pane_height(terminal_id, percent); + } + } + fn increase_pane_and_surroundings_down(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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(id, percent); + for terminal_id in terminals_below { + self.reduce_pane_height(&terminal_id, percent); + } + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + self.increase_pane_height(terminal_id, percent); + } + } + fn increase_pane_and_surroundings_right(&mut self, id: &PaneId, percent: f64) { + 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| { + return self.panes.borrow().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(id, percent); + for terminal_id in terminals_to_the_right { + self.reduce_pane_width(&terminal_id, percent); + } + for terminal_id in terminals_above.iter().chain(&terminals_below) { + self.increase_pane_width(terminal_id, percent); + } + } + fn increase_pane_and_surroundings_left(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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(id, percent); + for terminal_id in terminals_to_the_left { + self.reduce_pane_width(&terminal_id, percent); + } + for terminal_id in terminals_above.iter().chain(&terminals_below) { + self.increase_pane_width(terminal_id, percent); + } + } + fn reduce_pane_and_surroundings_up(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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) + }); + + // FIXME: This checks that we aren't violating the resize constraints of the aligned panes + // above and below this one. This should be moved to a `can_resize` function eventually. + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + let panes = self.panes.borrow(); + let pane = panes.get(terminal_id).unwrap(); + if pane.current_geom().rows.as_percent().unwrap() - percent < RESIZE_PERCENT { + return; + } + } + + self.reduce_pane_height(id, percent); + for terminal_id in terminals_below { + self.increase_pane_height(&terminal_id, percent); + } + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + self.reduce_pane_height(terminal_id, percent); + } + } + fn reduce_pane_and_surroundings_down(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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) + }); + + // FIXME: This checks that we aren't violating the resize constraints of the aligned panes + // above and below this one. This should be moved to a `can_resize` function eventually. + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + let panes = self.panes.borrow(); + let pane = panes.get(terminal_id).unwrap(); + if pane.current_geom().rows.as_percent().unwrap() - percent < RESIZE_PERCENT { + return; + } + } + + self.reduce_pane_height(id, percent); + for terminal_id in terminals_above { + self.increase_pane_height(&terminal_id, percent); + } + for terminal_id in terminals_to_the_left.iter().chain(&terminals_to_the_right) { + self.reduce_pane_height(terminal_id, percent); + } + } + fn reduce_pane_and_surroundings_right(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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) + }); + + // FIXME: This checks that we aren't violating the resize constraints of the aligned panes + // above and below this one. This should be moved to a `can_resize` function eventually. + for terminal_id in terminals_above.iter().chain(&terminals_below) { + let panes = self.panes.borrow(); + let pane = panes.get(terminal_id).unwrap(); + if pane.current_geom().cols.as_percent().unwrap() - percent < RESIZE_PERCENT { + return; + } + } + + self.reduce_pane_width(id, percent); + for terminal_id in terminals_to_the_left { + self.increase_pane_width(&terminal_id, percent); + } + for terminal_id in terminals_above.iter().chain(&terminals_below) { + self.reduce_pane_width(terminal_id, percent); + } + } + fn reduce_pane_and_surroundings_left(&mut self, id: &PaneId, percent: f64) { + 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.borrow().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) + }); + + // FIXME: This checks that we aren't violating the resize constraints of the aligned panes + // above and below this one. This should be moved to a `can_resize` function eventually. + for terminal_id in terminals_above.iter().chain(&terminals_below) { + let panes = self.panes.borrow(); + let pane = panes.get(terminal_id).unwrap(); + if pane.current_geom().cols.as_percent().unwrap() - percent < RESIZE_PERCENT { + return; + } + } + + self.reduce_pane_width(id, percent); + for terminal_id in terminals_to_the_right { + self.increase_pane_width(&terminal_id, percent); + } + for terminal_id in terminals_above.iter().chain(&terminals_below) { + self.reduce_pane_width(terminal_id, percent); + } + } + fn pane_ids_directly_left_of(&self, id: &PaneId) -> Option<Vec<PaneId>> { + let panes = self.panes.borrow(); + let mut ids = vec![]; + let terminal_to_check = panes.get(id).unwrap(); + if terminal_to_check.x() == 0 { + return None; + } + // for (&pid, terminal) in self.get_panes() { + for (&pid, terminal) in panes.iter() { + if terminal.x() + terminal.cols() == terminal_to_check.x() { + 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 panes = self.panes.borrow(); + let terminal_to_check = panes.get(id).unwrap(); + // for (&pid, terminal) in self.get_panes() { + for (&pid, terminal) in panes.iter() { + if terminal.x() == terminal_to_check.x() + terminal_to_check.cols() { + 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 panes = self.panes.borrow(); + let terminal_to_check = panes.get(id).unwrap(); + // for (&pid, terminal) in self.get_panes() { + for (&pid, terminal) in panes.iter() { + if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() { + 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 panes = self.panes.borrow(); + let terminal_to_check = panes.get(id).unwrap(); + // for (&pid, terminal) in self.get_panes() { + for (&pid, terminal) in panes.iter() { + if terminal.y() + terminal.rows() == terminal_to_check.y() { + ids.push(pid); + } + } + if ids.is_empty() { + None + } else { + Some(ids) + } + } + fn pane_ids_top_aligned_with_pane_id(&self, pane_id: &PaneId) -> Vec<PaneId> { + let panes = self.panes.borrow(); + let pane_to_check = panes.get(pane_id).unwrap(); + panes + .iter() + .filter(|(p_id, p)| *p_id != pane_id && p.y() == pane_to_check.y()) + .map(|(p_id, _p)| *p_id) + .collect() + } + fn pane_ids_bottom_aligned_with_pane_id(&self, pane_id: &PaneId) -> Vec<PaneId> { + let panes = self.panes.borrow(); + let pane_to_check = panes.get(pane_id).unwrap(); + panes + .iter() + .filter(|(p_id, p)| { + *p_id != pane_id && p.y() + p.rows() == pane_to_check.y() + pane_to_check.rows() + }) + .map(|(p_id, _p)| *p_id) + .collect() + } + fn pane_ids_right_aligned_with_pane_id(&self, pane_id: &PaneId) -> Vec<PaneId> { + let panes = self.panes.borrow(); + let pane_to_check = panes.get(pane_id).unwrap(); + panes + .iter() + .filter(|(p_id, p)| { + *p_id != pane_id && p.x() + p.cols() == pane_to_check.x() + pane_to_check.cols() + }) + .map(|(p_id, _p)| *p_id) + .collect() + } + fn pane_ids_left_aligned_with_pane_id(&self, pane_id: &PaneId) -> Vec<PaneId> { + let panes = self.panes.borrow(); + let pane_to_check = panes.get(pane_id).unwrap(); + panes + .iter() + .filter(|(p_id, p)| *p_id != pane_id && p.x() == pane_to_check.x()) + .map(|(p_id, _p)| *p_id) + .collect() + } + fn right_aligned_contiguous_panes_above( + &self, + id: &PaneId, + pane_borders_to_the_right: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut right_aligned_panes: Vec<_> = self + .pane_ids_right_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + right_aligned_panes.sort_by_key(|a| Reverse(a.y())); + for pane in right_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.y() + pane.rows() == pane_to_check.y() { + result_panes.push(pane); + } + } + // top-most border aligned with a pane border to the right + let mut top_resize_border = 0; + for pane in &result_panes { + let bottom_pane_boundary = pane.y() + pane.rows(); + if pane_borders_to_the_right + .get(&bottom_pane_boundary) + .is_some() + && top_resize_border < bottom_pane_boundary + { + top_resize_border = bottom_pane_boundary; + } + } + result_panes.retain(|pane| pane.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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.y() + } else { + top_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (top_resize_border, pane_ids) + } + fn right_aligned_contiguous_panes_below( + &self, + id: &PaneId, + pane_borders_to_the_right: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut right_aligned_panes: Vec<_> = self + .pane_ids_right_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + right_aligned_panes.sort_by_key(|a| a.y()); + for pane in right_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.y() == pane_to_check.y() + pane_to_check.rows() { + result_panes.push(pane); + } + } + // bottom-most border aligned with a pane border to the right + let mut bottom_resize_border = self.viewport.y + self.viewport.rows; + for pane in &result_panes { + let top_pane_boundary = pane.y(); + if pane_borders_to_the_right + .get(&(top_pane_boundary)) + .is_some() + && top_pane_boundary < bottom_resize_border + { + bottom_resize_border = top_pane_boundary; + } + } + result_panes.retain(|pane| pane.y() + pane.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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.y() + pane_to_check.rows() + } else { + bottom_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (bottom_resize_border, pane_ids) + } + fn left_aligned_contiguous_panes_above( + &self, + id: &PaneId, + pane_borders_to_the_left: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut left_aligned_panes: Vec<_> = self + .pane_ids_left_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + left_aligned_panes.sort_by_key(|a| Reverse(a.y())); + for pane in left_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.y() + pane.rows() == pane_to_check.y() { + result_panes.push(pane); + } + } + // top-most border aligned with a pane border to the right + let mut top_resize_border = 0; + for pane in &result_panes { + let bottom_pane_boundary = pane.y() + pane.rows(); + if pane_borders_to_the_left + .get(&bottom_pane_boundary) + .is_some() + && top_resize_border < bottom_pane_boundary + { + top_resize_border = bottom_pane_boundary; + } + } + result_panes.retain(|pane| pane.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 panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.y() + } else { + top_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (top_resize_border, pane_ids) + } + fn left_aligned_contiguous_panes_below( + &self, + id: &PaneId, + pane_borders_to_the_left: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut left_aligned_panes: Vec<_> = self + .pane_ids_left_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + left_aligned_panes.sort_by_key(|a| a.y()); + for pane in left_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.y() == pane_to_check.y() + pane_to_check.rows() { + result_panes.push(pane); + } + } + // bottom-most border aligned with a pane border to the left + let mut bottom_resize_border = self.viewport.y + self.viewport.rows; + for pane in &result_panes { + let top_pane_boundary = pane.y(); + if pane_borders_to_the_left.get(&(top_pane_boundary)).is_some() + && top_pane_boundary < bottom_resize_border + { + bottom_resize_border = top_pane_boundary; + } + } + result_panes.retain(|pane| pane.y() + pane.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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.y() + pane_to_check.rows() + } else { + bottom_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (bottom_resize_border, pane_ids) + } + fn top_aligned_contiguous_panes_to_the_left( + &self, + id: &PaneId, + pane_borders_above: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut top_aligned_panes: Vec<_> = self + .pane_ids_top_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + top_aligned_panes.sort_by_key(|a| Reverse(a.x())); + for pane in top_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.x() + pane.cols() == pane_to_check.x() { + result_panes.push(pane); + } + } + // leftmost border aligned with a pane border above + let mut left_resize_border = 0; + for pane in &result_panes { + let right_pane_boundary = pane.x() + pane.cols(); + if pane_borders_above.get(&right_pane_boundary).is_some() + && left_resize_border < right_pane_boundary + { + left_resize_border = right_pane_boundary + } + } + result_panes.retain(|pane| pane.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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.x() + } else { + left_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (left_resize_border, pane_ids) + } + fn top_aligned_contiguous_panes_to_the_right( + &self, + id: &PaneId, + pane_borders_above: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut top_aligned_panes: Vec<_> = self + .pane_ids_top_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + // panes that are next to each other up to current + top_aligned_panes.sort_by_key(|a| a.x()); + for pane in top_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.x() == pane_to_check.x() + pane_to_check.cols() { + result_panes.push(pane); + } + } + // rightmost border aligned with a pane border above + let mut right_resize_border = self.viewport.x + self.viewport.cols; + for pane in &result_panes { + let left_pane_boundary = pane.x(); + if pane_borders_above.get(&left_pane_boundary).is_some() + && right_resize_border > left_pane_boundary + { + right_resize_border = left_pane_boundary; + } + } + result_panes.retain(|pane| pane.x() + pane.cols() <= 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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.x() + pane_to_check.cols() + } else { + right_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (right_resize_border, pane_ids) + } + fn bottom_aligned_contiguous_panes_to_the_left( + &self, + id: &PaneId, + pane_borders_below: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut bottom_aligned_panes: Vec<_> = self + .pane_ids_bottom_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + bottom_aligned_panes.sort_by_key(|a| Reverse(a.x())); + // panes that are next to each other up to current + for pane in bottom_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.x() + pane.cols() == pane_to_check.x() { + result_panes.push(pane); + } + } + // leftmost border aligned with a pane border above + let mut left_resize_border = 0; + for pane in &result_panes { + let right_pane_boundary = pane.x() + pane.cols(); + if pane_borders_below.get(&right_pane_boundary).is_some() + && left_resize_border < right_pane_boundary + { + left_resize_border = right_pane_boundary; + } + } + result_panes.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 result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.x() + } else { + left_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (left_resize_border, pane_ids) + } + fn bottom_aligned_contiguous_panes_to_the_right( + &self, + id: &PaneId, + pane_borders_below: &HashSet<usize>, + ) -> BorderAndPaneIds { + let panes = self.panes.borrow(); + let mut result_panes = vec![]; + let mut bottom_aligned_panes: Vec<_> = self + .pane_ids_bottom_aligned_with_pane_id(id) + .iter() + .map(|p_id| panes.get(p_id).unwrap()) + .collect(); + bottom_aligned_panes.sort_by_key(|a| a.x()); + // panes that are next to each other up to current + for pane in bottom_aligned_panes { + let pane_to_check = panes.get(id).unwrap(); + let pane_to_check = result_panes.last().unwrap_or(&pane_to_check); + if pane.x() == pane_to_check.x() + pane_to_check.cols() { + result_panes.push(pane); + } + } + // leftmost border aligned with a pane border above + let mut right_resize_border = self.viewport.x + self.viewport.cols; + for pane in &result_panes { + let left_pane_boundary = pane.x(); + if pane_borders_below.get(&left_pane_boundary).is_some() + && right_resize_border > left_pane_boundary + { + right_resize_border = left_pane_boundary; + } + } + result_panes.retain(|terminal| terminal.x() + terminal.cols() <= right_resize_border); + let right_resize_border = if result_panes.is_empty() { + let pane_to_check = panes.get(id).unwrap(); + pane_to_check.x() + pane_to_check.cols() + } else { + right_resize_border + }; + let pane_ids: Vec<PaneId> = result_panes.iter().map(|t| t.pid()).collect(); + (right_resize_border, pane_ids) + } + fn ids_are_flexible(&self, direction: Direction, pane_ids: Option<Vec<PaneId>>) -> bool { + let panes = self.panes.borrow(); + pane_ids.is_some() + && pane_ids.unwrap().iter().all(|id| { + let pane_to_check = panes.get(id).unwrap(); + let geom = pane_to_check.current_geom(); + let dimension = match direction { + Direction::Vertical => geom.rows, + Direction::Horizontal => geom.cols, + }; + !dimension.is_fixed() + }) + } + fn pane_is_between_vertical_borders( + &self, + id: &PaneId, + left_border_x: usize, + right_border_x: usize, + ) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(id).unwrap(); + pane.x() >= left_border_x && pane.x() + pane.cols() <= right_border_x + } + fn pane_is_between_horizontal_borders( + &self, + id: &PaneId, + top_border_y: usize, + bottom_border_y: usize, + ) -> bool { + let panes = self.panes.borrow(); + let pane = panes.get(id).unwrap(); + pane.y() >= top_border_y && pane.y() + pane.rows() <= bottom_border_y + } + fn try_increase_pane_and_surroundings_right( + &mut self, + pane_id: &PaneId, + reduce_by: f64, + ) -> bool { + if self.can_increase_pane_and_surroundings_right(pane_id, reduce_by) { + self.increase_pane_and_surroundings_right(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + return true; + } + false + } + fn try_increase_pane_and_surroundings_left( + &mut self, + pane_id: &PaneId, + reduce_by: f64, + ) -> bool { + if self.can_increase_pane_and_surroundings_left(pane_id, reduce_by) { + self.increase_pane_and_surroundings_left(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + return true; + } + false + } + fn try_increase_pane_and_surroundings_up(&mut self, pane_id: &PaneId, reduce_by: f64) -> bool { + if self.can_increase_pane_and_surroundings_up(pane_id, reduce_by) { + self.increase_pane_and_surroundings_up(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + return true; + } + false + } + fn try_increase_pane_and_surroundings_down( + &mut self, + pane_id: &PaneId, + reduce_by: f64, + ) -> bool { + if self.can_increase_pane_and_surroundings_down(pane_id, reduce_by) { + self.increase_pane_and_surroundings_down(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + return true; + } + false + } + fn try_increase_pane_and_surroundings_right_and_up(&mut self, pane_id: &PaneId) -> bool { + let can_increase_pane_right = + self.can_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let can_increase_pane_up = + self.can_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if can_increase_pane_right && can_increase_pane_up { + let pane_above_with_right_aligned_border = self + .viewport_pane_ids_directly_above(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() + active_pane.cols() == pane.x() + }); + self.try_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + self.try_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if let Some(pane_above_with_right_aligned_border) = pane_above_with_right_aligned_border + { + self.try_reduce_pane_and_surroundings_right( + &pane_above_with_right_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_increase_pane_and_surroundings_left_and_up(&mut self, pane_id: &PaneId) -> bool { + let can_increase_pane_left = + self.can_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + let can_increase_pane_up = + self.can_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if can_increase_pane_left && can_increase_pane_up { + let pane_above_with_left_aligned_border = self + .viewport_pane_ids_directly_above(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() == pane.x() + pane.cols() + }); + self.try_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + self.try_increase_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if let Some(pane_above_with_left_aligned_border) = pane_above_with_left_aligned_border { + self.try_reduce_pane_and_surroundings_left( + &pane_above_with_left_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_increase_pane_and_surroundings_right_and_down(&mut self, pane_id: &PaneId) -> bool { + let can_increase_pane_right = + self.can_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let can_increase_pane_down = + self.can_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if can_increase_pane_right && can_increase_pane_down { + let pane_below_with_right_aligned_border = self + .viewport_pane_ids_directly_below(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() + active_pane.cols() == pane.x() + }); + self.try_increase_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + self.try_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if let Some(pane_below_with_right_aligned_border) = pane_below_with_right_aligned_border + { + self.try_reduce_pane_and_surroundings_right( + &pane_below_with_right_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_increase_pane_and_surroundings_left_and_down(&mut self, pane_id: &PaneId) -> bool { + let can_increase_pane_left = + self.can_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + let can_increase_pane_down = + self.can_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if can_increase_pane_left && can_increase_pane_down { + let pane_below_with_left_aligned_border = self + .viewport_pane_ids_directly_below(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() == pane.x() + pane.cols() + }); + self.try_increase_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + self.try_increase_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if let Some(pane_below_with_left_aligned_border) = pane_below_with_left_aligned_border { + self.try_reduce_pane_and_surroundings_left( + &pane_below_with_left_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_reduce_pane_and_surroundings_right_and_up(&mut self, pane_id: &PaneId) -> bool { + let can_reduce_pane_right = + self.can_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let can_reduce_pane_up = self.can_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if can_reduce_pane_right && can_reduce_pane_up { + let pane_below_with_left_aligned_border = self + .viewport_pane_ids_directly_below(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() == pane.x() + pane.cols() + }); + self.try_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + self.try_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if let Some(pane_below_with_left_aligned_border) = pane_below_with_left_aligned_border { + self.try_increase_pane_and_surroundings_right( + &pane_below_with_left_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_reduce_pane_and_surroundings_left_and_up(&mut self, pane_id: &PaneId) -> bool { + let can_reduce_pane_left = + self.can_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + let can_reduce_pane_up = self.can_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if can_reduce_pane_left && can_reduce_pane_up { + let pane_below_with_right_aligned_border = self + .viewport_pane_ids_directly_below(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() + active_pane.cols() == pane.x() + }); + self.try_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + self.try_reduce_pane_and_surroundings_up(pane_id, RESIZE_PERCENT); + if let Some(pane_below_with_right_aligned_border) = pane_below_with_right_aligned_border + { + self.try_increase_pane_and_surroundings_left( + &pane_below_with_right_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_reduce_pane_and_surroundings_right_and_down(&mut self, pane_id: &PaneId) -> bool { + let can_reduce_pane_right = + self.can_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + let can_reduce_pane_down = + self.can_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if can_reduce_pane_right && can_reduce_pane_down { + let pane_above_with_left_aligned_border = self + .viewport_pane_ids_directly_above(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() == pane.x() + pane.cols() + }); + self.try_reduce_pane_and_surroundings_right(pane_id, RESIZE_PERCENT); + self.try_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if let Some(pane_above_with_left_aligned_border) = pane_above_with_left_aligned_border { + self.try_increase_pane_and_surroundings_right( + &pane_above_with_left_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_reduce_pane_and_surroundings_left_and_down(&mut self, pane_id: &PaneId) -> bool { + let can_reduce_pane_left = + self.can_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + let can_reduce_pane_down = + self.can_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if can_reduce_pane_left && can_reduce_pane_down { + let pane_above_with_right_aligned_border = self + .viewport_pane_ids_directly_above(pane_id) + .iter() + .copied() + .find(|p_id| { + let panes = self.panes.borrow(); + let pane = panes.get(p_id).unwrap(); + let active_pane = panes.get(pane_id).unwrap(); + active_pane.x() + active_pane.cols() == pane.x() + }); + self.try_reduce_pane_and_surroundings_left(pane_id, RESIZE_PERCENT); + self.try_reduce_pane_and_surroundings_down(pane_id, RESIZE_PERCENT); + if let Some(pane_above_with_right_aligned_border) = pane_above_with_right_aligned_border + { + self.try_increase_pane_and_surroundings_left( + &pane_above_with_right_aligned_border, + RESIZE_PERCENT, + ); + } + true + } else { + false + } + } + fn try_reduce_pane_and_surroundings_right(&mut self, pane_id: &PaneId, reduce_by: f64) -> bool { + if self.can_reduce_pane_and_surroundings_right(pane_id, reduce_by) { + self.reduce_pane_and_surroundings_right(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + return true; + } + false + } + fn try_reduce_pane_and_surroundings_left(&mut self, pane_id: &PaneId, reduce_by: f64) -> bool { + if self.can_reduce_pane_and_surroundings_left(pane_id, reduce_by) { + self.reduce_pane_and_surroundings_left(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Horizontal, self.display_area.cols); + return true; + } + false + } + fn try_reduce_pane_and_surroundings_up(&mut self, pane_id: &PaneId, reduce_by: f64) -> bool { + if self.can_reduce_pane_and_surroundings_up(pane_id, reduce_by) { + self.reduce_pane_and_surroundings_up(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + return true; + } + false + } + fn try_reduce_pane_and_surroundings_down(&mut self, pane_id: &PaneId, reduce_by: f64) -> bool { + if self.can_reduce_pane_and_surroundings_down(pane_id, reduce_by) { + self.reduce_pane_and_surroundings_down(pane_id, reduce_by); + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(Direction::Vertical, self.display_area.rows); + return true; + } + false + } + fn viewport_pane_ids_directly_above(&self, pane_id: &PaneId) -> Vec<PaneId> { + self.pane_ids_directly_above(pane_id) + .unwrap_or_default() + .into_iter() + .filter(|id| self.is_inside_viewport(id)) + .collect() + } + fn viewport_pane_ids_directly_below(&self, pane_id: &PaneId) -> Vec<PaneId> { + self.pane_ids_directly_below(pane_id) + .unwrap_or_default() + .into_iter() + .filter(|id| self.is_inside_viewport(id)) + .collect() + } + fn is_inside_viewport(&self, pane_id: &PaneId) -> bool { + is_inside_viewport(&self.viewport, self.panes.borrow().get(pane_id).unwrap()) + } + pub fn next_selectable_pane_id(&self, current_pane_id: &PaneId) -> PaneId { + let panes = self.panes.borrow(); + let mut panes: Vec<(&PaneId, &&mut Box<dyn Pane>)> = + panes.iter().filter(|(_, p)| p.selectable()).collect(); + panes.sort_by(|(_a_id, a_pane), (_b_id, b_pane)| { + if a_pane.y() == b_pane.y() { + a_pane.x().cmp(&b_pane.x()) + } else { + a_pane.y().cmp(&b_pane.y()) + } + }); + let active_pane_position = panes + .iter() + .position(|(id, _)| *id == current_pane_id) // TODO: better + .unwrap(); + + let next_active_pane_id = panes + .get(active_pane_position + 1) + .or_else(|| panes.get(0)) + .map(|p| *p.0) + .unwrap(); + next_active_pane_id + } + pub fn previous_selectable_pane_id(&self, current_pane_id: &PaneId) -> PaneId { + let panes = self.panes.borrow(); + let mut panes: Vec<(&PaneId, &&mut Box<dyn Pane>)> = + panes.iter().filter(|(_, p)| p.selectable()).collect(); + panes.sort_by(|(_a_id, a_pane), (_b_id, b_pane)| { + if a_pane.y() == b_pane.y() { + a_pane.x().cmp(&b_pane.x()) + } else { + a_pane.y().cmp(&b_pane.y()) + } + }); + let last_pane = panes.last().unwrap(); + let active_pane_position = panes + .iter() + .position(|(id, _)| *id == current_pane_id) // TODO: better + .unwrap(); + + let previous_active_pane_id = if active_pane_position == 0 { + *last_pane.0 + } else { + *panes.get(active_pane_position - 1).unwrap().0 + }; + previous_active_pane_id + } + pub fn next_selectable_pane_id_to_the_left(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_directly_left_of(Box::as_ref(current_pane)) + && c.horizontally_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by_key(|(_, (_, c))| c.active_at()) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_below(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_directly_below(Box::as_ref(current_pane)) + && c.vertically_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by_key(|(_, (_, c))| c.active_at()) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_above(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_directly_above(Box::as_ref(current_pane)) + && c.vertically_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by_key(|(_, (_, c))| c.active_at()) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + pub fn next_selectable_pane_id_to_the_right(&self, current_pane_id: &PaneId) -> Option<PaneId> { + let panes = self.panes.borrow(); + let current_pane = panes.get(current_pane_id)?; + let panes: Vec<(PaneId, &&mut Box<dyn Pane>)> = panes + .iter() + .filter(|(_, p)| p.selectable()) + .map(|(p_id, p)| (*p_id, p)) + .collect(); + let next_index = panes + .iter() + .enumerate() + .filter(|(_, (_, c))| { + c.is_directly_right_of(Box::as_ref(current_pane)) + && c.horizontally_overlaps_with(Box::as_ref(current_pane)) + }) + .max_by_key(|(_, (_, c))| c.active_at()) + .map(|(_, (pid, _))| pid) + .copied(); + next_index + } + fn horizontal_borders(&self, pane_ids: &[PaneId]) -> HashSet<usize> { + pane_ids.iter().fold(HashSet::new(), |mut borders, p| { + let panes = self.panes.borrow(); + let pane = panes.get(p).unwrap(); + borders.insert(pane.y()); + borders.insert(pane.y() + pane.rows()); + borders + }) + } + fn vertical_borders(&self, pane_ids: &[PaneId]) -> HashSet<usize> { + pane_ids.iter().fold(HashSet::new(), |mut borders, p| { + let panes = self.panes.borrow(); + let pane = panes.get(p).unwrap(); + borders.insert(pane.x()); + borders.insert(pane.x() + pane.cols()); + borders + }) + } + fn panes_to_the_left_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { + let panes = self.panes.borrow(); + if let Some(pane) = panes.get(&id) { + let upper_close_border = pane.y(); + let lower_close_border = pane.y() + pane.rows(); + + if let Some(panes_to_the_left) = self.pane_ids_directly_left_of(&id) { + let mut selectable_panes: Vec<_> = panes_to_the_left + .into_iter() + .filter(|pid| panes.get(pid).unwrap().selectable()) + .collect(); + let pane_borders_to_the_left = self.horizontal_borders(&selectable_panes); + if pane_borders_to_the_left.contains(&upper_close_border) + && pane_borders_to_the_left.contains(&lower_close_border) + { + selectable_panes.retain(|t| { + self.pane_is_between_horizontal_borders( + t, + upper_close_border, + lower_close_border, + ) + }); + return Some(selectable_panes); + } + } + } + None + } + fn panes_to_the_right_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { + let panes = self.panes.borrow(); + if let Some(pane) = panes.get(&id) { + let upper_close_border = pane.y(); + let lower_close_border = pane.y() + pane.rows(); + + if let Some(panes_to_the_right) = self.pane_ids_directly_right_of(&id) { + let mut selectable_panes: Vec<_> = panes_to_the_right + .into_iter() + .filter(|pid| panes.get(pid).unwrap().selectable()) + .collect(); + let pane_borders_to_the_right = self.horizontal_borders(&selectable_panes); + if pane_borders_to_the_right.contains(&upper_close_border) + && pane_borders_to_the_right.contains(&lower_close_border) + { + selectable_panes.retain(|t| { + self.pane_is_between_horizontal_borders( + t, + upper_close_border, + lower_close_border, + ) + }); + return Some(selectable_panes); + } + } + } + None + } + fn panes_above_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { + let panes = self.panes.borrow(); + if let Some(pane) = panes.get(&id) { + let left_close_border = pane.x(); + let right_close_border = pane.x() + pane.cols(); + + if let Some(panes_above) = self.pane_ids_directly_above(&id) { + let mut selectable_panes: Vec<_> = panes_above + .into_iter() + .filter(|pid| panes.get(pid).unwrap().selectable()) + .collect(); + let pane_borders_above = self.vertical_borders(&selectable_panes); + if pane_borders_above.contains(&left_close_border) + && pane_borders_above.contains(&right_close_border) + { + selectable_panes.retain(|t| { + self.pane_is_between_vertical_borders( + t, + left_close_border, + right_close_border, + ) + }); + return Some(selectable_panes); + } + } + } + None + } + fn panes_below_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> { + let panes = self.panes.borrow(); + if let Some(pane) = panes.get(&id) { + let left_close_border = pane.x(); + let right_close_border = pane.x() + pane.cols(); + + if let Some(panes_below) = self.pane_ids_directly_below(&id) { + let mut selectable_panes: Vec<_> = panes_below + .into_iter() + .filter(|pid| panes[pid].selectable()) + .collect(); + let pane_borders_below = self.vertical_borders(&selectable_panes); + if pane_borders_below.contains(&left_close_border) + && pane_borders_below.contains(&right_close_border) + { + selectable_panes.retain(|t| { + self.pane_is_between_vertical_borders( + t, + left_close_border, + right_close_border, + ) + }); + return Some(selectable_panes); + } + } + } + None + } + fn find_panes_to_grow(&self, id: PaneId) -> Option<(Vec<PaneId>, Direction)> { + if let Some(panes) = self + .panes_to_the_left_between_aligning_borders(id) + .or_else(|| self.panes_to_the_right_between_aligning_borders(id)) + { + return Some((panes, Direction::Horizontal)); + } + + if let Some(panes) = self + .panes_above_between_aligning_borders(id) + .or_else(|| self.panes_below_between_aligning_borders(id)) + { + return Some((panes, Direction::Vertical)); + } + + None + } + fn grow_panes(&mut self, panes: &[PaneId], direction: Direction, (width, height): (f64, f64)) { + match direction { + Direction::Horizontal => { + for pane_id in panes { + self.increase_pane_width(pane_id, width); + } + } + Direction::Vertical => { + for pane_id in panes { + self.increase_pane_height(pane_id, height); + } + } + }; + } + pub fn fill_space_over_pane(&mut self, id: PaneId) -> bool { + // true => successfully filled space over pane + // false => didn't succeed, so didn't do anything + let (freed_width, freed_height) = { + let panes = self.panes.borrow_mut(); + let pane_to_close = panes.get(&id).unwrap(); + let freed_space = pane_to_close.position_and_size(); + let freed_width = freed_space.cols.as_percent(); + let freed_height = freed_space.rows.as_percent(); + (freed_width, freed_height) + }; + if let (Some(freed_width), Some(freed_height)) = (freed_width, freed_height) { + if let Some((panes_to_grow, direction)) = self.find_panes_to_grow(id) { + self.grow_panes(&panes_to_grow, direction, (freed_width, freed_height)); + let side_length = match direction { + Direction::Vertical => self.display_area.rows, + Direction::Horizontal => self.display_area.cols, + }; + { + let mut panes = self.panes.borrow_mut(); + (*panes).remove(&id); + } + let mut pane_resizer = PaneResizer::new(self.panes.clone()); + let _ = pane_resizer.layout(direction, side_length); + return true; + } + } + false + } + pub fn find_room_for_new_pane(&self) -> Option<(PaneId, Direction)> { + let panes = self.panes.borrow(); + let pane_sequence: Vec<(&PaneId, &&mut Box<dyn Pane>)> = + panes.iter().filter(|(_, p)| p.selectable()).collect(); + let (_largest_pane_size, pane_id_to_split) = pane_sequence.iter().fold( + (0, None), + |(current_largest_pane_size, current_pane_id_to_split), id_and_pane_to_check| { + let (id_of_pane_to_check, pane_to_check) = id_and_pane_to_check; + let pane_size = + (pane_to_check.rows() * CURSOR_HEIGHT_WIDTH_RATIO) * pane_to_check.cols(); + let pane_can_be_split = pane_to_check.cols() >= MIN_TERMINAL_WIDTH + && pane_to_check.rows() >= MIN_TERMINAL_HEIGHT + && ((pane_to_check.cols() > pane_to_check.min_width() * 2) + || (pane_to_check.rows() > pane_to_check.min_height() * 2)); + if pane_can_be_split && pane_size > current_largest_pane_size { + (pane_size, Some(*id_of_pane_to_check)) + } else { + (current_largest_pane_size, current_pane_id_to_split) + } + }, + ); + pane_id_to_split.and_then(|t_id_to_split| { + let pane_to_split = panes.get(t_id_to_split).unwrap(); + let direction = if pane_to_split.rows() * CURSOR_HEIGHT_WIDTH_RATIO + > pane_to_split.cols() + && pane_to_split.rows() > pane_to_split.min_height() * 2 + { + Some(Direction::Horizontal) + } else if pane_to_split.cols() > pane_to_split.min_width() * 2 { + Some(Direction::Vertical) + } else { + None + }; + + direction.map(|direction| (*t_id_to_split, direction)) + }) + } +} + +pub fn split(direction: Direction, rect: &PaneGeom) -> Option<(PaneGeom, PaneGeom)> { + let space = match direction { + Direction::Vertical => rect.cols, + Direction::Horizontal => rect.rows, + }; + if let Some(p) = space.as_percent() { + let first_rect = match direction { + Direction::Vertical => PaneGeom { + cols: Dimension::percent(p / 2.0), + ..*rect + }, + Direction::Horizontal => PaneGeom { + rows: Dimension::percent(p / 2.0), + ..*rect + }, + }; + let second_rect = match direction { + Direction::Vertical => PaneGeom { + x: first_rect.x + 1, + cols: first_rect.cols, + ..*rect + }, + Direction::Horizontal => PaneGeom { + y: first_rect.y + 1, + rows: first_rect.rows, + ..*rect + }, + }; + Some((first_rect, second_rect)) + } else { + None + } +} |
