aboutsummaryrefslogtreecommitdiffstats
path: root/zellij-server/src/panes
diff options
context:
space:
mode:
authorAram Drevekenin <aram@poor.dev>2022-03-18 10:32:43 +0100
committerGitHub <noreply@github.com>2022-03-18 10:32:43 +0100
commitab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e (patch)
tree165a49ba935694a11f8816b2e68a401b6ddf23e3 /zellij-server/src/panes
parentUpdate `rust-toolchain` (#1236) (diff)
downloadsl0ppij-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.rs899
-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.rs2
-rw-r--r--zellij-server/src/panes/tiled_panes/mod.rs1035
-rw-r--r--zellij-server/src/panes/tiled_panes/pane_resizer.rs246
-rw-r--r--zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs1740
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
+ }
+}