From ab74b9974ac73dbae9dfdd4f87f8a3c0bf89e69e Mon Sep 17 00:00:00 2001 From: Aram Drevekenin Date: Fri, 18 Mar 2022 10:32:43 +0100 Subject: [PATCH] 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 --- src/tests/e2e/cases.rs | 1 + .../floating_panes}/floating_pane_grid.rs | 347 +- .../mod.rs} | 109 +- zellij-server/src/panes/mod.rs | 2 + zellij-server/src/panes/tiled_panes/mod.rs | 1035 +++++ .../tiled_panes}/pane_resizer.rs | 0 .../tiled_panes}/tiled_pane_grid.rs | 3 +- zellij-server/src/screen.rs | 14 +- zellij-server/src/tab/mod.rs | 1591 ++------ ...tegration_tests__drag_pane_with_mouse.snap | 4 +- ...ration_tests__five_new_floating_panes.snap | 4 +- ...tests__mark_text_inside_floating_pane.snap | 4 +- ..._tests__move_floating_pane_focus_down.snap | 4 +- ..._tests__move_floating_pane_focus_left.snap | 4 +- ...tests__move_floating_pane_focus_right.snap | 4 +- ...on_tests__move_floating_pane_focus_up.snap | 4 +- ...__move_floating_pane_focus_with_mouse.snap | 4 +- ...tests__resize_tab_with_floating_panes.snap | 4 +- ...ing_panes_horizontally_and_vertically.snap | 4 +- ...ntally_and_vertically_and_expand_back.snap | 4 +- zellij-server/src/tab/unit/tab_tests.rs | 3422 +++++++++++------ zellij-server/src/unit/screen_tests.rs | 5 +- 22 files changed, 3827 insertions(+), 2746 deletions(-) rename zellij-server/src/{tab => panes/floating_panes}/floating_pane_grid.rs (73%) rename zellij-server/src/panes/{floating_panes.rs => floating_panes/mod.rs} (91%) create mode 100644 zellij-server/src/panes/tiled_panes/mod.rs rename zellij-server/src/{tab => panes/tiled_panes}/pane_resizer.rs (100%) rename zellij-server/src/{tab => panes/tiled_panes}/tiled_pane_grid.rs (99%) diff --git a/src/tests/e2e/cases.rs b/src/tests/e2e/cases.rs index f3a181be..8bb4d898 100644 --- a/src/tests/e2e/cases.rs +++ b/src/tests/e2e/cases.rs @@ -477,6 +477,7 @@ pub fn close_tab() { let mut step_is_complete = false; if remote_terminal.cursor_position_is(3, 2) && !remote_terminal.snapshot_contains("Tab #2") + && remote_terminal.tip_appears() { // cursor is in the first tab again step_is_complete = true; diff --git a/zellij-server/src/tab/floating_pane_grid.rs b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs similarity index 73% rename from zellij-server/src/tab/floating_pane_grid.rs rename to zellij-server/src/panes/floating_panes/floating_pane_grid.rs index 18248342..31d0d6ff 100644 --- a/zellij-server/src/tab/floating_pane_grid.rs +++ b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs @@ -1,12 +1,8 @@ -use super::pane_resizer::PaneResizer; use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; use crate::{panes::PaneId, tab::Pane}; use std::cmp::Ordering; -use std::collections::{HashMap, HashSet}; -use zellij_utils::{ - input::layout::Direction, - pane_size::{Dimension, PaneGeom, Size, Viewport}, -}; +use std::collections::HashMap; +use zellij_utils::pane_size::{Dimension, PaneGeom, Size, Viewport}; use std::cell::RefCell; use std::rc::Rc; @@ -40,11 +36,6 @@ impl<'a> FloatingPaneGrid<'a> { 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 move_pane_by(&mut self, pane_id: PaneId, x: isize, y: isize) { // true => succeeded to move, false => failed to move let new_pane_position = { @@ -568,16 +559,6 @@ impl<'a> FloatingPaneGrid<'a> { None } } - 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 increase_pane_size_left(&mut self, id: &PaneId, increase_by: usize) { let new_pane_geom = { let mut panes = self.panes.borrow_mut(); @@ -679,140 +660,6 @@ impl<'a> FloatingPaneGrid<'a> { }; self.set_pane_geom(*id, new_pane_geom); } - fn pane_ids_directly_left_of(&self, id: &PaneId) -> Option> { - 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> { - 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> { - 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> { - 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_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 - } - pub fn next_selectable_pane_id(&self, current_pane_id: &PaneId) -> PaneId { - let panes = self.panes.borrow(); - let mut panes: Vec<(&PaneId, &&mut Box)> = - 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)> = - 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 { let panes = self.panes.borrow(); let current_pane = panes.get(current_pane_id)?; @@ -917,196 +764,6 @@ impl<'a> FloatingPaneGrid<'a> { .copied(); next_index } - fn horizontal_borders(&self, pane_ids: &[PaneId]) -> HashSet { - 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 { - 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> { - 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> { - 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> { - 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> { - 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, 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 { let panes = self.panes.borrow(); let pane_geoms: Vec = panes.values().map(|p| p.position_and_size()).collect(); diff --git a/zellij-server/src/panes/floating_panes.rs b/zellij-server/src/panes/floating_panes/mod.rs similarity index 91% rename from zellij-server/src/panes/floating_panes.rs rename to 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>, display_area: Rc>, viewport: Rc>, + connected_clients: Rc>>, + connected_clients_in_app: Rc>>, + mode_info: Rc>>, + default_mode_info: ModeInfo, + colors: Palette, + session_is_mirrored: bool, desired_pane_positions: HashMap, // this represents the positions of panes the user moved with intention, rather than by resizing the terminal window z_indices: Vec, active_panes: HashMap, @@ -44,11 +52,26 @@ pub struct FloatingPanes { #[allow(clippy::borrowed_box)] impl FloatingPanes { - pub fn new(display_area: Rc>, viewport: Rc>) -> Self { + pub fn new( + display_area: Rc>, + viewport: Rc>, + connected_clients: Rc>>, + connected_clients_in_app: Rc>>, + mode_info: Rc>>, + 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 { + 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 { 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>>, - connected_clients: &HashSet, - mode_info: &HashMap, - 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 = + { 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 = + 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> { + self.panes.get(&pane_id) + } + pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box> { + self.panes.get_mut(&pane_id) + } pub fn get_pane_id_at(&self, point: &Position, search_selectable: bool) -> Option { 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 { + self.active_panes.get(&client_id).copied() + } + pub fn get_panes(&self) -> impl Iterator)> { + 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>, + display_area: Rc>, + viewport: Rc>, + connected_clients: Rc>>, + connected_clients_in_app: Rc>>, + mode_info: Rc>>, + default_mode_info: ModeInfo, + colors: Palette, + session_is_mirrored: bool, + active_panes: HashMap, + draw_pane_frames: bool, + panes_to_hide: HashSet, + fullscreen_is_active: bool, + os_api: Box, +} + +impl TiledPanes { + pub fn new( + display_area: Rc>, + viewport: Rc>, + connected_clients: Rc>>, + connected_clients_in_app: Rc>>, + mode_info: Rc>>, + session_is_mirrored: bool, + draw_pane_frames: bool, + default_mode_info: ModeInfo, + colors: Palette, + os_api: Box, + ) -> 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) { + self.panes.insert(pane_id, pane); + } + pub fn insert_pane(&mut self, pane_id: PaneId, mut pane: Box) { + 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 { + 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 { + self.panes + .iter() + .filter(|(_id, pane)| pane.selectable()) + .map(|(id, _)| id.to_owned()) + .next() + } + pub fn pane_ids(&self) -> impl Iterator { + 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, + 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, + 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 = + 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 { + 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 { + self.active_panes.get(&client_id).copied() + } + pub fn get_pane(&self, pane_id: PaneId) -> Option<&Box> { + self.panes.get(&pane_id) + } + pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box> { + self.panes.get_mut(&pane_id) + } + pub fn get_active_pane_id(&self, client_id: ClientId) -> Option { + 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 = + { 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 = 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)> { + 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 = + { 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 = + { 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> { + 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 = + { 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) -> 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/tab/pane_resizer.rs b/zellij-server/src/panes/tiled_panes/pane_resizer.rs similarity index 100% rename from zellij-server/src/tab/pane_resizer.rs rename to zellij-server/src/panes/tiled_panes/pane_resizer.rs diff --git a/zellij-server/src/tab/tiled_pane_grid.rs b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs similarity index 99% rename from zellij-server/src/tab/tiled_pane_grid.rs rename to zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs index 827c5771..5bbaf65a 100644 --- a/zellij-server/src/tab/tiled_pane_grid.rs +++ b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs @@ -1,5 +1,6 @@ +use super::is_inside_viewport; use super::pane_resizer::PaneResizer; -use crate::tab::{is_inside_viewport, MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; +use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH}; use crate::{panes::PaneId, tab::Pane}; use std::cmp::Reverse; use std::collections::{HashMap, HashSet}; diff --git a/zellij-server/src/screen.rs b/zellij-server/src/screen.rs index 5a3f0279..8ba6cccf 100644 --- a/zellij-server/src/screen.rs +++ b/zellij-server/src/screen.rs @@ -428,7 +428,7 @@ impl Screen { let size = self.size; let overlay = self.overlay.clone(); for (tab_index, tab) in &mut self.tabs { - if tab.has_active_panes() { + if tab.has_selectable_panes() { let vte_overlay = overlay.generate_overlay(size); tab.render(&mut output, Some(vte_overlay)); } else { @@ -567,11 +567,9 @@ impl Screen { } pub fn remove_client(&mut self, client_id: ClientId) { self.tabs.iter_mut().for_each(|(_, tab)| { - if tab.active_panes.get(&client_id).is_some() { - tab.remove_client(client_id); - if tab.has_no_connected_clients() { - tab.visible(false); - } + tab.remove_client(client_id); + if tab.has_no_connected_clients() { + tab.visible(false); } }); if self.active_tab_indices.contains_key(&client_id) { @@ -604,7 +602,7 @@ impl Screen { position: tab.position, name: tab.name.clone(), active: *active_tab_index == tab.index, - panes_to_hide: tab.panes_to_hide.len(), + panes_to_hide: tab.panes_to_hide_count(), is_fullscreen_active: tab.is_fullscreen_active(), is_sync_panes_active: tab.is_sync_panes_active(), are_floating_panes_visible: tab.are_floating_panes_visible(), @@ -874,7 +872,7 @@ pub(crate) fn screen_thread_main( screen .get_active_tab_mut(client_id) .unwrap() - .move_focus(client_id); + .focus_next_pane(client_id); screen.render(); } diff --git a/zellij-server/src/tab/mod.rs b/zellij-server/src/tab/mod.rs index e33141f6..18a6ef72 100644 --- a/zellij-server/src/tab/mod.rs +++ b/zellij-server/src/tab/mod.rs @@ -3,9 +3,6 @@ mod clipboard; mod copy_command; -pub mod floating_pane_grid; -pub mod pane_resizer; -pub mod tiled_pane_grid; use copy_command::CopyCommand; use zellij_utils::input::options::Clipboard; @@ -13,37 +10,33 @@ use zellij_utils::position::{Column, Line}; use zellij_utils::{position::Position, serde, zellij_tile}; use crate::ui::pane_boundaries_frame::FrameParams; -use tiled_pane_grid::{split, TiledPaneGrid}; use self::clipboard::ClipboardProvider; use crate::{ os_input_output::ServerOsApi, output::{CharacterChunk, Output}, - panes::FloatingPanes, + panes::{FloatingPanes, TiledPanes}, panes::{LinkHandler, PaneId, PluginPane, TerminalPane}, pty::{ClientOrTabIndex, PtyInstruction, VteBytes}, thread_bus::ThreadSenders, - ui::boundaries::Boundaries, - ui::pane_contents_and_ui::PaneContentsAndUi, wasm_vm::PluginInstruction, ClientId, ServerInstruction, }; use serde::{Deserialize, Serialize}; use std::cell::RefCell; -use std::cmp::Reverse; use std::os::unix::io::RawFd; use std::rc::Rc; use std::sync::mpsc::channel; use std::time::Instant; use std::{ - collections::{BTreeMap, HashMap, HashSet}, + collections::{HashMap, HashSet}, str, }; use zellij_tile::data::{Event, InputMode, ModeInfo, Palette, PaletteColor}; use zellij_utils::{ input::{ command::TerminalAction, - layout::{Direction, Layout, Run}, + layout::{Layout, Run}, parse_keys, }, pane_size::{Offset, PaneGeom, Size, Viewport}, @@ -69,48 +62,24 @@ pub const MIN_TERMINAL_WIDTH: usize = 5; const MAX_PENDING_VTE_EVENTS: usize = 7000; -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(crate) struct Tab { pub index: usize, pub position: usize, pub name: String, - panes: BTreeMap>, + tiled_panes: TiledPanes, floating_panes: FloatingPanes, - pub panes_to_hide: HashSet, - pub active_panes: HashMap, max_panes: Option, viewport: Rc>, // includes all non-UI panes display_area: Rc>, // includes all panes (including eg. the status bar and tab bar in the default layout) - fullscreen_is_active: bool, os_api: Box, pub senders: ThreadSenders, synchronize_is_active: bool, should_clear_display_before_rendering: bool, - mode_info: HashMap, + mode_info: Rc>>, default_mode_info: ModeInfo, pub colors: Palette, - connected_clients_in_app: Rc>>, // TODO: combine this and connected_clients - connected_clients: HashSet, + connected_clients: Rc>>, draw_pane_frames: bool, - session_is_mirrored: bool, pending_vte_events: HashMap>, pub selecting_with_mouse: bool, // this is only pub for the tests TODO: remove this once we combine write_text_to_clipboard with render link_handler: Rc>, @@ -303,7 +272,7 @@ impl Tab { os_api: Box, senders: ThreadSenders, max_panes: Option, - mode_info: ModeInfo, + default_mode_info: ModeInfo, colors: Palette, draw_pane_frames: bool, connected_clients_in_app: Rc>>, @@ -312,8 +281,6 @@ impl Tab { copy_command: Option, copy_clipboard: Clipboard, ) -> Self { - let panes = BTreeMap::new(); - let name = if name.is_empty() { format!("Tab #{}", index + 1) } else { @@ -325,7 +292,31 @@ impl Tab { let viewport: Viewport = display_area.into(); let viewport = Rc::new(RefCell::new(viewport)); let display_area = Rc::new(RefCell::new(display_area)); - let floating_panes = FloatingPanes::new(display_area.clone(), viewport.clone()); + let connected_clients = Rc::new(RefCell::new(connected_clients)); + let mode_info = Rc::new(RefCell::new(HashMap::new())); + + let tiled_panes = TiledPanes::new( + display_area.clone(), + viewport.clone(), + connected_clients.clone(), + connected_clients_in_app.clone(), + mode_info.clone(), + session_is_mirrored, + draw_pane_frames, + default_mode_info.clone(), + colors, + os_api.clone(), + ); + let floating_panes = FloatingPanes::new( + display_area.clone(), + viewport.clone(), + connected_clients.clone(), + connected_clients_in_app.clone(), + mode_info.clone(), + session_is_mirrored, + default_mode_info.clone(), + colors, + ); let clipboard_provider = match copy_command { Some(command) => ClipboardProvider::Command(CopyCommand::new(command)), @@ -335,26 +326,21 @@ impl Tab { Tab { index, position, - panes, + tiled_panes, floating_panes, name, max_panes, - panes_to_hide: HashSet::new(), - active_panes: HashMap::new(), viewport, display_area, - fullscreen_is_active: false, synchronize_is_active: false, os_api, senders, should_clear_display_before_rendering: false, - mode_info: HashMap::new(), - default_mode_info: mode_info, + mode_info, + default_mode_info, colors, draw_pane_frames, - session_is_mirrored, pending_vte_events: HashMap::new(), - connected_clients_in_app, connected_clients, selecting_with_mouse: false, link_handler: Rc::new(RefCell::new(LinkHandler::new())), @@ -370,7 +356,11 @@ impl Tab { tab_index: usize, client_id: ClientId, ) { - // TODO: this should be an attribute on Screen instead of full_screen_ws + if self.tiled_panes.has_panes() { + log::error!( + "Applying a layout to a tab with existing panes - this is not yet supported!" + ); + } let (viewport_cols, viewport_rows) = { let viewport = self.viewport.borrow(); (viewport.cols, viewport.rows) @@ -379,26 +369,9 @@ impl Tab { free_space.cols.set_inner(viewport_cols); free_space.rows.set_inner(viewport_rows); - self.panes_to_hide.clear(); let positions_in_layout = layout.position_panes_in_space(&free_space); - let mut positions_and_size = positions_in_layout.iter(); - for (pane_kind, terminal_pane) in &mut self.panes { - // for now the layout only supports terminal panes - if let PaneId::Terminal(pid) = pane_kind { - match positions_and_size.next() { - Some(&(_, position_and_size)) => { - terminal_pane.reset_size_and_position_override(); - terminal_pane.set_geom(position_and_size); - } - None => { - // we filled the entire layout, no room for this pane - // TODO: handle active terminal - self.panes_to_hide.insert(PaneId::Terminal(*pid)); - } - } - } - } + let positions_and_size = positions_in_layout.iter(); let mut new_pids = new_pids.iter(); let mut focus_pane_id: Option = None; @@ -425,7 +398,8 @@ impl Tab { layout.pane_name.clone().unwrap_or_default(), ); new_plugin.set_borderless(layout.borderless); - self.panes.insert(PaneId::Plugin(pid), Box::new(new_plugin)); + self.tiled_panes + .add_pane_with_existing_geom(PaneId::Plugin(pid), Box::new(new_plugin)); set_focus_pane_id(layout, PaneId::Plugin(pid)); } else { // there are still panes left to fill, use the pids we received in this method @@ -440,8 +414,8 @@ impl Tab { self.link_handler.clone(), ); new_pane.set_borderless(layout.borderless); - self.panes - .insert(PaneId::Terminal(*pid), Box::new(new_pane)); + self.tiled_panes + .add_pane_with_existing_geom(PaneId::Terminal(*pid), Box::new(new_pane)); set_focus_pane_id(layout, PaneId::Terminal(*pid)); } } @@ -460,59 +434,35 @@ impl Tab { *display_area }; self.resize_whole_tab(display_area); - let boundary_geom: Vec<_> = 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(); - for geom in boundary_geom { + let boundary_geoms = self.tiled_panes.fixed_pane_geoms(); + for geom in boundary_geoms { self.offset_viewport(&geom) } - self.set_pane_frames(self.draw_pane_frames); - - let mut active_pane = |pane_id: PaneId| { - let connected_clients: Vec = self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, pane_id); - } - }; + self.tiled_panes.set_pane_frames(self.draw_pane_frames); + self.should_clear_display_before_rendering = true; if let Some(pane_id) = focus_pane_id { self.focus_pane_id = Some(pane_id); - active_pane(pane_id); + self.tiled_panes.focus_pane(pane_id, client_id); } else { // This is the end of the nasty viewport hack... - let next_selectable_pane_id = self - .panes - .iter() - .filter(|(_id, pane)| pane.selectable()) - .map(|(id, _)| id.to_owned()) - .next(); + let next_selectable_pane_id = self.tiled_panes.first_selectable_pane_id(); match next_selectable_pane_id { Some(active_pane_id) => { - active_pane(active_pane_id); + self.tiled_panes.focus_pane(active_pane_id, client_id); } None => { // this is very likely a configuration error (layout with no selectable panes) - self.active_panes.clear(); + self.tiled_panes.clear_active_panes(); } } } } pub fn update_input_modes(&mut self) { // this updates all plugins with the client's input mode - for client_id in &self.connected_clients { - let mode_info = self - .mode_info - .get(client_id) - .unwrap_or(&self.default_mode_info); + let mode_infos = self.mode_info.borrow(); + for client_id in self.connected_clients.borrow().iter() { + let mode_info = mode_infos.get(client_id).unwrap_or(&self.default_mode_info); self.senders .send_to_plugin(PluginInstruction::Update( None, @@ -523,64 +473,58 @@ impl Tab { } } pub fn add_client(&mut self, client_id: ClientId, mode_info: Option) { - let first_connected_client = self.connected_clients.iter().next(); - match first_connected_client { - Some(first_client_id) => { - let first_active_pane_id = *self.active_panes.get(first_client_id).unwrap(); - if self.floating_panes.panes_are_visible() { - if let Some(first_active_floating_pane_id) = - self.floating_panes.first_active_floating_pane_id() - { - self.floating_panes - .focus_pane(first_active_floating_pane_id, client_id); - } - } - self.connected_clients.insert(client_id); - self.active_panes.insert(client_id, first_active_pane_id); - self.mode_info.insert( - client_id, - mode_info.unwrap_or_else(|| self.default_mode_info.clone()), - ); + let other_clients_exist_in_tab = { !self.connected_clients.borrow().is_empty() }; + if other_clients_exist_in_tab { + if let Some(first_active_floating_pane_id) = + self.floating_panes.first_active_floating_pane_id() + { + self.floating_panes + .focus_pane(first_active_floating_pane_id, client_id); } - None => { - let mut pane_ids: Vec = self.panes.keys().copied().collect(); - if pane_ids.is_empty() { - // no panes here, bye bye - return; - } - self.active_panes.insert( - client_id, - self.focus_pane_id.unwrap_or_else(|| { - pane_ids.sort(); // TODO: make this predictable - pane_ids.retain(|p| !self.panes_to_hide.contains(p)); - *pane_ids.get(0).unwrap() - }), - ); - self.connected_clients.insert(client_id); - self.mode_info.insert( - client_id, - mode_info.unwrap_or_else(|| self.default_mode_info.clone()), - ); + if let Some(first_active_tiled_pane_id) = self.tiled_panes.first_active_pane_id() { + self.tiled_panes + .focus_pane(first_active_tiled_pane_id, client_id); } + self.connected_clients.borrow_mut().insert(client_id); + self.mode_info.borrow_mut().insert( + client_id, + mode_info.unwrap_or_else(|| self.default_mode_info.clone()), + ); + } else { + let mut pane_ids: Vec = self.tiled_panes.pane_ids().copied().collect(); + if pane_ids.is_empty() { + // no panes here, bye bye + return; + } + let focus_pane_id = self.focus_pane_id.unwrap_or_else(|| { + pane_ids.sort(); // TODO: make this predictable + pane_ids.retain(|p| !self.tiled_panes.panes_to_hide_contains(*p)); + *pane_ids.get(0).unwrap() + }); + self.tiled_panes.focus_pane(focus_pane_id, client_id); + self.connected_clients.borrow_mut().insert(client_id); + self.mode_info.borrow_mut().insert( + client_id, + mode_info.unwrap_or_else(|| self.default_mode_info.clone()), + ); } - // TODO: we might be able to avoid this, we do this so that newly connected clients will - // necessarily get a full render self.set_force_render(); self.update_input_modes(); } pub fn change_mode_info(&mut self, mode_info: ModeInfo, client_id: ClientId) { - self.mode_info.insert(client_id, mode_info); + self.mode_info.borrow_mut().insert(client_id, mode_info); } pub fn add_multiple_clients(&mut self, client_ids_to_mode_infos: Vec<(ClientId, ModeInfo)>) { for (client_id, client_mode_info) in client_ids_to_mode_infos { self.add_client(client_id, None); - self.mode_info.insert(client_id, client_mode_info); + self.mode_info + .borrow_mut() + .insert(client_id, client_mode_info); } } pub fn remove_client(&mut self, client_id: ClientId) { self.focus_pane_id = None; - self.active_panes.remove(&client_id); - self.connected_clients.remove(&client_id); + self.connected_clients.borrow_mut().remove(&client_id); self.set_force_render(); } pub fn drain_connected_clients( @@ -589,8 +533,8 @@ impl Tab { ) -> Vec<(ClientId, ModeInfo)> { // None => all clients let mut client_ids_to_mode_infos = vec![]; - let clients_to_drain = - clients_to_drain.unwrap_or_else(|| self.connected_clients.drain().collect()); + let clients_to_drain = clients_to_drain + .unwrap_or_else(|| self.connected_clients.borrow_mut().drain().collect()); for client_id in clients_to_drain { client_ids_to_mode_infos.push(self.drain_single_client(client_id)); } @@ -599,63 +543,32 @@ impl Tab { pub fn drain_single_client(&mut self, client_id: ClientId) -> (ClientId, ModeInfo) { let client_mode_info = self .mode_info + .borrow_mut() .remove(&client_id) .unwrap_or_else(|| self.default_mode_info.clone()); - self.connected_clients.remove(&client_id); + self.connected_clients.borrow_mut().remove(&client_id); (client_id, client_mode_info) } pub fn has_no_connected_clients(&self) -> bool { - self.connected_clients.is_empty() + self.connected_clients.borrow().is_empty() } pub fn toggle_pane_embed_or_floating(&mut self, client_id: ClientId) { if self.floating_panes.panes_are_visible() { if let Some(focused_floating_pane_id) = self.floating_panes.active_pane_id(client_id) { - let pane_grid = TiledPaneGrid::new( - &mut self.panes, - *self.display_area.borrow(), - *self.viewport.borrow(), - ); - let terminal_id_and_split_direction = pane_grid.find_room_for_new_pane(); - if let Some((terminal_id_to_split, split_direction)) = - terminal_id_and_split_direction - { + if self.tiled_panes.has_room_for_new_pane() { // this unwrap is safe because floating panes should not be visible if there are no floating panes - let mut floating_pane_to_embed = - self.close_pane(focused_floating_pane_id).unwrap(); - let pane_to_split = self.panes.get_mut(&terminal_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); - floating_pane_to_embed.set_geom(second_geom); - self.panes - .insert(focused_floating_pane_id, floating_pane_to_embed); - // ¯\_(ツ)_/¯ - let relayout_direction = match split_direction { - Direction::Vertical => Direction::Horizontal, - Direction::Horizontal => Direction::Vertical, - }; - self.relayout_tab(relayout_direction); - } - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes - .insert(client_id, focused_floating_pane_id); - } - } else { - self.active_panes - .insert(client_id, focused_floating_pane_id); - } + let floating_pane_to_embed = self.close_pane(focused_floating_pane_id).unwrap(); + self.tiled_panes + .insert_pane(focused_floating_pane_id, floating_pane_to_embed); + self.should_clear_display_before_rendering = true; + self.tiled_panes + .focus_pane(focused_floating_pane_id, client_id); self.floating_panes.toggle_show_panes(false); } } - } else if let Some(focused_pane_id) = self.active_panes.get(&client_id).copied() { + } else if let Some(focused_pane_id) = self.tiled_panes.focused_pane_id(client_id) { if let Some(new_pane_geom) = self.floating_panes.find_room_for_new_pane() { - if self.get_selectable_panes().count() <= 1 { + if self.get_selectable_tiled_panes().count() <= 1 { // don't close the only pane on screen... return; } @@ -665,14 +578,8 @@ impl Tab { embedded_pane_to_float.set_active_at(Instant::now()); self.floating_panes .add_pane(focused_pane_id, embedded_pane_to_float); + self.floating_panes.focus_pane(focused_pane_id, client_id); self.floating_panes.toggle_show_panes(true); - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.floating_panes.focus_pane(focused_pane_id, client_id); - } - self.floating_panes.set_force_render(); } } } @@ -733,165 +640,102 @@ impl Tab { new_pane.set_content_offset(Offset::frame(1)); // floating panes always have a frame resize_pty!(new_pane, self.os_api); self.floating_panes.add_pane(pid, Box::new(new_pane)); - // move all clients to new floating pane - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.floating_panes.focus_pane(pid, client_id); - } + self.floating_panes.focus_pane_for_all_clients(pid); } } } else { - if self.fullscreen_is_active { - self.unset_fullscreen(); + if self.tiled_panes.fullscreen_is_active() { + self.tiled_panes.unset_fullscreen(); } - let pane_grid = TiledPaneGrid::new( - &mut self.panes, - *self.display_area.borrow(), - *self.viewport.borrow(), - ); - let terminal_id_and_split_direction = pane_grid.find_room_for_new_pane(); - if let Some((terminal_id_to_split, split_direction)) = terminal_id_and_split_direction { - let next_terminal_position = self.get_next_terminal_position(); - let terminal_to_split = self.panes.get_mut(&terminal_id_to_split).unwrap(); - let terminal_ws = terminal_to_split.position_and_size(); + if self.tiled_panes.has_room_for_new_pane() { if let PaneId::Terminal(term_pid) = pid { - if let Some((first_winsize, second_winsize)) = - split(split_direction, &terminal_ws) - { - let new_terminal = TerminalPane::new( - term_pid, - second_winsize, - self.colors, - next_terminal_position, - String::new(), - self.link_handler.clone(), - ); - terminal_to_split.set_geom(first_winsize); - self.panes.insert(pid, Box::new(new_terminal)); - // ¯\_(ツ)_/¯ - let relayout_direction = match split_direction { - Direction::Vertical => Direction::Horizontal, - Direction::Horizontal => Direction::Vertical, - }; - self.relayout_tab(relayout_direction); - } - } - if let Some(client_id) = client_id { - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, pid); - } - } else { - self.active_panes.insert(client_id, pid); + let next_terminal_position = self.get_next_terminal_position(); + let new_terminal = TerminalPane::new( + term_pid, + PaneGeom::default(), // the initial size will be set later + self.colors, + next_terminal_position, + String::new(), + self.link_handler.clone(), + ); + self.tiled_panes.insert_pane(pid, Box::new(new_terminal)); + self.should_clear_display_before_rendering = true; + if let Some(client_id) = client_id { + self.tiled_panes.focus_pane(pid, client_id); } } } } } pub fn horizontal_split(&mut self, pid: PaneId, client_id: ClientId) { + if self.floating_panes.panes_are_visible() { + return; + } self.close_down_to_max_terminals(); - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { self.toggle_active_pane_fullscreen(client_id); } - if let PaneId::Terminal(term_pid) = pid { - let next_terminal_position = self.get_next_terminal_position(); - let active_pane_id = &self.get_active_pane_id(client_id).unwrap(); - let active_pane = self.panes.get_mut(active_pane_id).unwrap(); - if active_pane.rows() < MIN_TERMINAL_HEIGHT * 2 { - self.senders - .send_to_pty(PtyInstruction::ClosePane(pid)) // we can't open this pane, close the pty - .unwrap(); - return; - } - let terminal_ws = active_pane.position_and_size(); - if let Some((top_winsize, bottom_winsize)) = split(Direction::Horizontal, &terminal_ws) - { + if self.tiled_panes.can_split_pane_horizontally(client_id) { + if let PaneId::Terminal(term_pid) = pid { + let next_terminal_position = self.get_next_terminal_position(); let new_terminal = TerminalPane::new( term_pid, - bottom_winsize, + PaneGeom::default(), // the initial size will be set later self.colors, next_terminal_position, String::new(), self.link_handler.clone(), ); - active_pane.set_geom(top_winsize); - self.panes.insert(pid, Box::new(new_terminal)); - - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, pid); - } - } else { - self.active_panes.insert(client_id, pid); - } - - self.relayout_tab(Direction::Vertical); + self.tiled_panes + .split_pane_horizontally(pid, Box::new(new_terminal), client_id); + self.should_clear_display_before_rendering = true; + self.tiled_panes.focus_pane(pid, client_id); } } } pub fn vertical_split(&mut self, pid: PaneId, client_id: ClientId) { + if self.floating_panes.panes_are_visible() { + return; + } self.close_down_to_max_terminals(); - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { self.toggle_active_pane_fullscreen(client_id); } - if let PaneId::Terminal(term_pid) = pid { - // TODO: check minimum size of active terminal - let next_terminal_position = self.get_next_terminal_position(); - let active_pane_id = &self.get_active_pane_id(client_id).unwrap(); - let active_pane = self.panes.get_mut(active_pane_id).unwrap(); - if active_pane.cols() < MIN_TERMINAL_WIDTH * 2 { - self.senders - .send_to_pty(PtyInstruction::ClosePane(pid)) // we can't open this pane, close the pty - .unwrap(); - return; - } - let terminal_ws = active_pane.position_and_size(); - if let Some((left_winsize, right_winsize)) = split(Direction::Vertical, &terminal_ws) { + if self.tiled_panes.can_split_pane_vertically(client_id) { + if let PaneId::Terminal(term_pid) = pid { + let next_terminal_position = self.get_next_terminal_position(); let new_terminal = TerminalPane::new( term_pid, - right_winsize, + PaneGeom::default(), // the initial size will be set later self.colors, next_terminal_position, String::new(), self.link_handler.clone(), ); - active_pane.set_geom(left_winsize); - self.panes.insert(pid, Box::new(new_terminal)); + self.tiled_panes + .split_pane_vertically(pid, Box::new(new_terminal), client_id); + self.should_clear_display_before_rendering = true; + self.tiled_panes.focus_pane(pid, client_id); } - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, pid); - } - } else { - self.active_panes.insert(client_id, pid); - } - - self.relayout_tab(Direction::Horizontal); } } - pub fn has_active_panes(&self) -> bool { - // a tab without active panes is a dead tab and should close - // a pane can be active even if there are no connected clients, - // we remember that pane for one the client focuses the tab next - !self.active_panes.is_empty() - } pub fn get_active_pane(&self, client_id: ClientId) -> Option<&dyn Pane> { - self.get_active_pane_id(client_id) - .and_then(|ap| self.panes.get(&ap).map(Box::as_ref)) + self.get_active_pane_id(client_id).and_then(|ap| { + if self.floating_panes.panes_are_visible() { + self.floating_panes.get_pane(ap).map(Box::as_ref) + } else { + self.tiled_panes.get_pane(ap).map(Box::as_ref) + } + }) } pub fn get_active_pane_mut(&mut self, client_id: ClientId) -> Option<&mut Box> { - self.get_active_pane_id(client_id) - .and_then(|ap| self.panes.get_mut(&ap)) + self.get_active_pane_id(client_id).and_then(|ap| { + if self.floating_panes.panes_are_visible() { + self.floating_panes.get_pane_mut(ap) + } else { + self.tiled_panes.get_pane_mut(ap) + } + }) } pub fn get_active_pane_or_floating_pane_mut( &mut self, @@ -903,26 +747,29 @@ impl Tab { self.get_active_pane_mut(client_id) } } - fn get_active_pane_id(&self, client_id: ClientId) -> Option { - // TODO: why do we need this? - self.active_panes.get(&client_id).copied() + pub fn get_active_pane_id(&self, client_id: ClientId) -> Option { + if self.floating_panes.panes_are_visible() { + self.floating_panes.get_active_pane_id(client_id) + } else { + self.tiled_panes.get_active_pane_id(client_id) + } } fn get_active_terminal_id(&self, client_id: ClientId) -> Option { - if let Some(PaneId::Terminal(pid)) = self.active_panes.get(&client_id).copied() { + if let Some(PaneId::Terminal(pid)) = self.get_active_pane_id(client_id) { Some(pid) } else { None } } pub fn has_terminal_pid(&self, pid: RawFd) -> bool { - self.panes.contains_key(&PaneId::Terminal(pid)) + self.tiled_panes.panes_contain(&PaneId::Terminal(pid)) || self.floating_panes.panes_contain(&PaneId::Terminal(pid)) } pub fn handle_pty_bytes(&mut self, pid: RawFd, bytes: VteBytes) { if let Some(terminal_output) = self - .panes - .get_mut(&PaneId::Terminal(pid)) - .or_else(|| self.floating_panes.get_mut(&PaneId::Terminal(pid))) + .tiled_panes + .get_pane_mut(PaneId::Terminal(pid)) + .or_else(|| self.floating_panes.get_pane_mut(PaneId::Terminal(pid))) { // If the pane is scrolled buffer the vte events if terminal_output.is_scrolled() { @@ -949,9 +796,9 @@ impl Tab { } fn process_pty_bytes(&mut self, pid: RawFd, bytes: VteBytes) { if let Some(terminal_output) = self - .panes - .get_mut(&PaneId::Terminal(pid)) - .or_else(|| self.floating_panes.get_mut(&PaneId::Terminal(pid))) + .tiled_panes + .get_pane_mut(PaneId::Terminal(pid)) + .or_else(|| self.floating_panes.get_pane_mut(PaneId::Terminal(pid))) { terminal_output.handle_pty_bytes(bytes); let messages_to_pty = terminal_output.drain_messages_to_pty(); @@ -969,10 +816,10 @@ impl Tab { pub fn write_to_active_terminal(&mut self, input_bytes: Vec, client_id: ClientId) { let pane_id = if self.floating_panes.panes_are_visible() { self.floating_panes - .active_pane_id(client_id) - .unwrap_or_else(|| *self.active_panes.get(&client_id).unwrap()) + .get_active_pane_id(client_id) + .unwrap_or_else(|| self.tiled_panes.get_active_pane_id(client_id).unwrap()) } else { - *self.active_panes.get(&client_id).unwrap() + self.tiled_panes.get_active_pane_id(client_id).unwrap() }; self.write_to_pane_id(input_bytes, pane_id); } @@ -996,7 +843,7 @@ impl Tab { let active_terminal = self .floating_panes .get(&pane_id) - .unwrap_or_else(|| self.panes.get(&pane_id).unwrap()); + .unwrap_or_else(|| self.tiled_panes.get_pane(pane_id).unwrap()); let adjusted_input = active_terminal.adjust_input_to_terminal(input_bytes); self.os_api .write_to_tty_stdin(active_terminal_id, &adjusted_input) @@ -1021,15 +868,15 @@ impl Tab { // (x, y) let active_pane_id = if self.floating_panes.panes_are_visible() { self.floating_panes - .active_pane_id(client_id) - .or_else(|| self.active_panes.get(&client_id).copied())? + .get_active_pane_id(client_id) + .or_else(|| self.tiled_panes.get_active_pane_id(client_id))? } else { - self.active_panes.get(&client_id).copied()? + self.tiled_panes.get_active_pane_id(client_id)? }; let active_terminal = &self .floating_panes .get(&active_pane_id) - .or_else(|| self.panes.get(&active_pane_id))?; + .or_else(|| self.tiled_panes.get_pane(active_pane_id))?; active_terminal .cursor_coordinates() .map(|(x_in_terminal, y_in_terminal)| { @@ -1038,98 +885,20 @@ impl Tab { (x, y) }) } - pub fn unset_fullscreen(&mut self) { - if self.fullscreen_is_active { - let first_client_id = self.connected_clients.iter().next().unwrap(); // this is a temporary hack until we fix the ui for multiple clients - let active_pane_id = self.active_panes.get(first_client_id).unwrap(); - for terminal_id in &self.panes_to_hide { - let pane = self.panes.get_mut(terminal_id).unwrap(); - pane.set_should_render(true); - pane.set_should_render_boundaries(true); - } - let viewport_pane_ids: Vec<_> = self - .get_embedded_pane_ids() - .into_iter() - .filter(|id| !self.is_inside_viewport(id)) - .collect(); - for pid in viewport_pane_ids { - let viewport_pane = self.panes.get_mut(&pid).unwrap(); - viewport_pane.reset_size_and_position_override(); - } - self.panes_to_hide.clear(); - let active_terminal = self.panes.get_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_whole_tab(display_area); - self.toggle_fullscreen_is_active(); - } - } 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 panes = self.get_panes(); - let pane_ids_to_hide = panes.filter_map(|(&id, _pane)| { - if id != active_pane_id && self.is_inside_viewport(&id) { - 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 - .get_embedded_pane_ids() - .into_iter() - .filter(|id| !self.is_inside_viewport(id)) - .collect(); - for pid in viewport_pane_ids { - let viewport_pane = self.panes.get_mut(&pid).unwrap(); - viewport_pane.get_geom_override(viewport_pane.position_and_size()); - } - let active_terminal = self.panes.get_mut(&active_pane_id).unwrap(); - let viewport = { *self.viewport.borrow() }; - let full_screen_geom = PaneGeom { - x: viewport.x, - y: viewport.y, - ..Default::default() - }; - active_terminal.get_geom_override(full_screen_geom); - } - let active_panes: Vec = self.active_panes.keys().copied().collect(); - for client_id in active_panes { - self.active_panes.insert(client_id, active_pane_id); - } - self.set_force_render(); - let display_area = *self.display_area.borrow(); - self.resize_whole_tab(display_area); - self.toggle_fullscreen_is_active(); - } + if self.floating_panes.panes_are_visible() { + return; } + self.tiled_panes.toggle_active_pane_fullscreen(client_id); } pub fn is_fullscreen_active(&self) -> bool { - self.fullscreen_is_active + self.tiled_panes.fullscreen_is_active() } pub fn are_floating_panes_visible(&self) -> bool { self.floating_panes.panes_are_visible() } - pub fn toggle_fullscreen_is_active(&mut self) { - self.fullscreen_is_active = !self.fullscreen_is_active; - } 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(); - } + self.tiled_panes.set_force_render(); self.floating_panes.set_force_render(); } pub fn is_sync_panes_active(&self) -> bool { @@ -1139,187 +908,83 @@ impl Tab { self.synchronize_is_active = !self.synchronize_is_active; } pub fn mark_active_pane_for_rerender(&mut self, client_id: ClientId) { - if let Some(active_pane_id) = self.get_active_pane_id(client_id) { - self.panes - .get_mut(&active_pane_id) - .unwrap() - .set_should_render(true) + if let Some(active_pane) = self.get_active_pane_mut(client_id) { + active_pane.set_should_render(true); } } - pub fn set_pane_frames(&mut self, draw_pane_frames: bool) { - self.draw_pane_frames = draw_pane_frames; - self.should_clear_display_before_rendering = true; - 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, self.os_api); - } - self.floating_panes.set_pane_frames(&mut self.os_api); - } fn update_active_panes_in_pty_thread(&self) { // this is a bit hacky and we should ideally not keep this state in two different places at // some point - for &connected_client in &self.connected_clients { + let connected_clients: Vec = + { self.connected_clients.borrow().iter().copied().collect() }; + for client_id in connected_clients { self.senders .send_to_pty(PtyInstruction::UpdateActivePane( - self.active_panes.get(&connected_client).copied(), - connected_client, + self.get_active_pane_id(client_id), + client_id, )) .unwrap(); } } pub fn render(&mut self, output: &mut Output, overlay: Option) { - if self.connected_clients.is_empty() || self.active_panes.is_empty() { + let connected_clients: HashSet = + { self.connected_clients.borrow().iter().copied().collect() }; + if connected_clients.is_empty() || !self.tiled_panes.has_active_panes() { return; } self.update_active_panes_in_pty_thread(); - let floating_panes_stack = if self.floating_panes.panes_are_visible() { - Some(self.floating_panes.stack()) - } else { - None - }; + + let floating_panes_stack = self.floating_panes.stack(); output.add_clients( - &self.connected_clients, + &connected_clients, self.link_handler.clone(), floating_panes_stack, ); - let mut client_id_to_boundaries: HashMap = HashMap::new(); + self.hide_cursor_and_clear_display_as_needed(output); - let active_non_floating_panes = self.active_non_floating_panes(); - // render panes and their frames - for (kind, pane) in self.panes.iter_mut() { - if !self.panes_to_hide.contains(&pane.pid()) { - let mut active_panes = if self.floating_panes.panes_are_visible() { - active_non_floating_panes.clone() - } else { - self.active_panes.clone() - }; - let multiple_users_exist_in_session = - { self.connected_clients_in_app.borrow().len() > 1 }; - active_panes.retain(|c_id, _| self.connected_clients.contains(c_id)); - let mut pane_contents_and_ui = PaneContentsAndUi::new( - pane, - output, - self.colors, - &active_panes, - multiple_users_exist_in_session, - None, - ); - for &client_id in &self.connected_clients { - let client_mode = self - .mode_info - .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( - self.connected_clients.iter().copied(), - ); - } - } - } + self.tiled_panes.render(output); if self.floating_panes.panes_are_visible() && self.floating_panes.has_active_panes() { - self.floating_panes.render( - &self.connected_clients_in_app, - &self.connected_clients, - &self.mode_info, - &self.default_mode_info, - self.session_is_mirrored, - output, - self.colors, - ); - } - // 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); + self.floating_panes.render(output); } + // FIXME: Once clients can be distinguished if let Some(overlay_vte) = &overlay { output.add_post_vte_instruction_to_multiple_clients( - self.connected_clients.iter().copied(), + connected_clients.iter().copied(), overlay_vte, ); } + self.render_cursor(output); } - fn active_non_floating_panes(&self) -> HashMap { - let mut active_non_floating_panes = self.active_panes.clone(); - active_non_floating_panes.retain(|c_id, _| !self.floating_panes.active_panes_contain(c_id)); - active_non_floating_panes - } fn hide_cursor_and_clear_display_as_needed(&mut self, output: &mut Output) { let hide_cursor = "\u{1b}[?25l"; + let connected_clients: Vec = + { self.connected_clients.borrow().iter().copied().collect() }; output.add_pre_vte_instruction_to_multiple_clients( - self.connected_clients.iter().copied(), + connected_clients.iter().copied(), hide_cursor, ); if self.should_clear_display_before_rendering { let clear_display = "\u{1b}[2J"; output.add_pre_vte_instruction_to_multiple_clients( - self.connected_clients.iter().copied(), + connected_clients.iter().copied(), clear_display, ); self.should_clear_display_before_rendering = false; } } fn render_cursor(&self, output: &mut Output) { - for &client_id in &self.connected_clients { + let connected_clients: Vec = + { self.connected_clients.borrow().iter().copied().collect() }; + for client_id in connected_clients { match self.get_active_terminal_cursor_position(client_id) { Some((cursor_position_x, cursor_position_y)) => { let show_cursor = "\u{1b}[?25h"; - let change_cursor_shape = - self.get_active_pane(client_id).unwrap().cursor_shape_csi(); + let change_cursor_shape = self + .get_active_pane(client_id) + .map(|ap| ap.cursor_shape_csi()) + .unwrap_or_default(); let goto_cursor_position = &format!( "\u{1b}[{};{}H\u{1b}[m{}", cursor_position_y + 1, @@ -1336,83 +1001,43 @@ impl Tab { } } } - fn get_panes(&self) -> impl Iterator)> { - self.panes.iter() + fn get_tiled_panes(&self) -> impl Iterator)> { + self.tiled_panes.get_panes() } - fn get_selectable_panes(&self) -> impl Iterator)> { - self.panes.iter().filter(|(_, p)| p.selectable()) + fn get_selectable_tiled_panes(&self) -> impl Iterator)> { + self.get_tiled_panes().filter(|(_, p)| p.selectable()) } fn get_next_terminal_position(&self) -> usize { - self.panes - .iter() + let tiled_panes_count = self + .tiled_panes + .get_panes() .filter(|(k, _)| match k { PaneId::Plugin(_) => false, PaneId::Terminal(_) => true, }) - .count() - + 1 + .count(); + let floating_panes_count = self + .floating_panes + .get_panes() + .filter(|(k, _)| match k { + PaneId::Plugin(_) => false, + PaneId::Terminal(_) => true, + }) + .count(); + tiled_panes_count + floating_panes_count + 1 } - fn has_selectable_panes(&self) -> bool { - let mut all_terminals = self.get_selectable_panes(); - all_terminals.next().is_some() - } - fn next_active_pane(&self, panes: &[PaneId]) -> Option { - let mut panes: Vec<_> = panes - .iter() - .map(|p_id| self.panes.get(p_id).unwrap()) - .collect(); - panes.sort_by_key(|b| Reverse(b.active_at())); - - panes.iter().find(|pane| pane.selectable()).map(|p| p.pid()) - } - pub fn relayout_tab(&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 has_selectable_panes(&self) -> bool { + let selectable_tiled_panes = self.tiled_panes.get_panes().filter(|(_, p)| p.selectable()); + let selectable_floating_panes = self + .floating_panes + .get_panes() + .filter(|(_, p)| p.selectable()); + selectable_tiled_panes.count() > 0 || selectable_floating_panes.count() > 0 } pub fn resize_whole_tab(&mut self, new_screen_size: Size) { self.floating_panes.resize(new_screen_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.should_clear_display_before_rendering = true; - } - self.set_pane_frames(self.draw_pane_frames); + self.tiled_panes.resize(new_screen_size); + self.should_clear_display_before_rendering = true; } pub fn resize_left(&mut self, client_id: ClientId) { if self.floating_panes.panes_are_visible() { @@ -1423,17 +1048,8 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_left(client_id); } } pub fn resize_right(&mut self, client_id: ClientId) { @@ -1445,17 +1061,8 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_right(client_id); } } pub fn resize_down(&mut self, client_id: ClientId) { @@ -1467,17 +1074,8 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_down(client_id); } } pub fn resize_up(&mut self, client_id: ClientId) { @@ -1489,17 +1087,8 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_up(client_id); } } pub fn resize_increase(&mut self, client_id: ClientId) { @@ -1511,17 +1100,8 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_increase(client_id); } } pub fn resize_decrease(&mut self, client_id: ClientId) { @@ -1533,408 +1113,109 @@ impl Tab { self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease return; } - } - 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, self.os_api); - } + } else { + self.tiled_panes.resize_active_pane_decrease(client_id); } } fn set_pane_active_at(&mut self, pane_id: PaneId) { - if let Some(pane) = self.panes.get_mut(&pane_id) { + if let Some(pane) = self.tiled_panes.get_pane_mut(pane_id) { + pane.set_active_at(Instant::now()); + } else if let Some(pane) = self.floating_panes.get_pane_mut(pane_id) { pane.set_active_at(Instant::now()); } } - - pub fn move_focus(&mut self, client_id: ClientId) { - if !self.has_selectable_panes() { - return; - } - if self.fullscreen_is_active { - return; - } - let current_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(¤t_active_pane_id); - let connected_clients: Vec = self.connected_clients.iter().copied().collect(); - 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_next_pane(&mut self, client_id: ClientId) { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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); - let connected_clients: Vec = self.connected_clients.iter().copied().collect(); - 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); + self.tiled_panes.focus_next_pane(client_id); } pub fn focus_previous_pane(&mut self, client_id: ClientId) { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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); - let connected_clients: Vec = self.connected_clients.iter().copied().collect(); - 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); + self.tiled_panes.focus_previous_pane(client_id); } // returns a boolean that indicates whether the focus moved pub fn move_focus_left(&mut self, client_id: ClientId) -> bool { if self.floating_panes.panes_are_visible() { - self.floating_panes - .move_focus_left(client_id, &self.connected_clients) + self.floating_panes.move_focus_left( + client_id, + &self.connected_clients.borrow().iter().copied().collect(), + ) } else { if !self.has_selectable_panes() { return false; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return false; } - let active_pane_id = self.get_active_pane_id(client_id); - let updated_active_pane = if let Some(active_pane_id) = 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(); - - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, p); - } - } else { - self.active_panes.insert(client_id, p); - } - self.set_pane_active_at(p); - - return true; - } - None => Some(active_pane_id), - } - } else { - active_pane_id - }; - match updated_active_pane { - Some(updated_active_pane) => { - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, updated_active_pane); - } - self.set_pane_active_at(updated_active_pane); - } - None => { - // TODO: can this happen? - self.active_panes.clear(); - } - } - - false + self.tiled_panes.move_focus_left(client_id) } } - pub fn move_focus_down(&mut self, client_id: ClientId) { + pub fn move_focus_down(&mut self, client_id: ClientId) -> bool { if self.floating_panes.panes_are_visible() { - self.floating_panes - .move_focus_down(client_id, &self.connected_clients); + self.floating_panes.move_focus_down( + client_id, + &self.connected_clients.borrow().iter().copied().collect(), + ) } else { if !self.has_selectable_panes() { - return; + return false; } - if self.fullscreen_is_active { - return; - } - let active_pane_id = self.get_active_pane_id(client_id); - let updated_active_pane = if let Some(active_pane_id) = 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(); - - Some(p) - } - None => Some(active_pane_id), - } - } else { - active_pane_id - }; - match updated_active_pane { - Some(updated_active_pane) => { - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, updated_active_pane); - } - self.set_pane_active_at(updated_active_pane); - } else { - self.active_panes.insert(client_id, updated_active_pane); - self.set_pane_active_at(updated_active_pane); - } - } - None => { - // TODO: can this happen? - self.active_panes.clear(); - } + if self.tiled_panes.fullscreen_is_active() { + return false; } + self.tiled_panes.move_focus_down(client_id) } } - pub fn move_focus_up(&mut self, client_id: ClientId) { + pub fn move_focus_up(&mut self, client_id: ClientId) -> bool { if self.floating_panes.panes_are_visible() { - self.floating_panes - .move_focus_up(client_id, &self.connected_clients); + self.floating_panes.move_focus_up( + client_id, + &self.connected_clients.borrow().iter().copied().collect(), + ) } else { if !self.has_selectable_panes() { - return; + return false; } - if self.fullscreen_is_active { - return; - } - let active_pane_id = self.get_active_pane_id(client_id); - let updated_active_pane = if let Some(active_pane_id) = 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(); - - Some(p) - } - None => Some(active_pane_id), - } - } else { - active_pane_id - }; - match updated_active_pane { - Some(updated_active_pane) => { - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, updated_active_pane); - } - self.set_pane_active_at(updated_active_pane); - } else { - self.active_panes.insert(client_id, updated_active_pane); - self.set_pane_active_at(updated_active_pane); - } - } - None => { - // TODO: can this happen? - self.active_panes.clear(); - } + if self.tiled_panes.fullscreen_is_active() { + return false; } + self.tiled_panes.move_focus_up(client_id) } } // returns a boolean that indicates whether the focus moved pub fn move_focus_right(&mut self, client_id: ClientId) -> bool { if self.floating_panes.panes_are_visible() { - self.floating_panes - .move_focus_right(client_id, &self.connected_clients) + self.floating_panes.move_focus_right( + client_id, + &self.connected_clients.borrow().iter().copied().collect(), + ) } else { if !self.has_selectable_panes() { return false; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return false; } - let active_pane_id = self.get_active_pane_id(client_id); - let updated_active_pane = if let Some(active_pane_id) = 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(); - - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, p); - } - } else { - self.active_panes.insert(client_id, p); - } - self.set_pane_active_at(p); - return true; - } - None => Some(active_pane_id), - } - } else { - active_pane_id - }; - match updated_active_pane { - Some(updated_active_pane) => { - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, updated_active_pane); - } - self.set_pane_active_at(updated_active_pane); - } else { - self.active_panes.insert(client_id, updated_active_pane); - self.set_pane_active_at(updated_active_pane); - } - } - None => { - // TODO: can this happen? - self.active_panes.clear(); - } - } - false + self.tiled_panes.move_focus_right(client_id) } } pub fn move_active_pane(&mut self, client_id: ClientId) { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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, 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, self.os_api); - current_position.set_should_render(true); + self.tiled_panes.move_active_pane(client_id); } pub fn move_active_pane_down(&mut self, client_id: ClientId) { if self.floating_panes.panes_are_visible() { @@ -1944,41 +1225,10 @@ impl Tab { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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, 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, self.os_api); - current_position.set_should_render(true); - } - } + self.tiled_panes.move_active_pane_down(client_id); } } pub fn move_active_pane_up(&mut self, client_id: ClientId) { @@ -1989,41 +1239,10 @@ impl Tab { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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, 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, self.os_api); - current_position.set_should_render(true); - } - } + self.tiled_panes.move_active_pane_up(client_id); } } pub fn move_active_pane_right(&mut self, client_id: ClientId) { @@ -2034,41 +1253,10 @@ impl Tab { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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, 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, self.os_api); - current_position.set_should_render(true); - } - } + self.tiled_panes.move_active_pane_right(client_id); } } pub fn move_active_pane_left(&mut self, client_id: ClientId) { @@ -2079,46 +1267,15 @@ impl Tab { if !self.has_selectable_panes() { return; } - if self.fullscreen_is_active { + if self.tiled_panes.fullscreen_is_active() { return; } - 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, 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, self.os_api); - current_position.set_should_render(true); - } - } + self.tiled_panes.move_active_pane_left(client_id); } } fn close_down_to_max_terminals(&mut self) { if let Some(max_panes) = self.max_panes { - let terminals = self.get_embedded_pane_ids(); + let terminals = self.get_tiled_pane_ids(); for &pid in terminals.iter().skip(max_panes - 1) { self.senders .send_to_pty(PtyInstruction::ClosePane(pid)) @@ -2127,22 +1284,22 @@ impl Tab { } } } - pub fn get_embedded_pane_ids(&self) -> Vec { - self.get_panes().map(|(&pid, _)| pid).collect() + pub fn get_tiled_pane_ids(&self) -> Vec { + self.get_tiled_panes().map(|(&pid, _)| pid).collect() } pub fn get_all_pane_ids(&self) -> Vec { // this is here just as a naming thing to make things more explicit self.get_static_and_floating_pane_ids() } pub fn get_static_and_floating_pane_ids(&self) -> Vec { - self.panes - .keys() + self.tiled_panes + .pane_ids() .chain(self.floating_panes.pane_ids()) .copied() .collect() } pub fn set_pane_selectable(&mut self, id: PaneId, selectable: bool) { - if let Some(pane) = self.panes.get_mut(&id) { + if let Some(pane) = self.tiled_panes.get_pane_mut(id) { pane.set_selectable(selectable); if !selectable { // there are some edge cases in which this causes a hard crash when there are no @@ -2156,23 +1313,7 @@ impl Tab { // solve it by adding a "dangling_clients" struct to Tab which we would fill with // the relevant client ids in this case and drain as soon as a new selectable pane // is opened - self.move_clients_out_of_pane(id); - } - } - } - 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(); - for (client_id, active_pane_id) in active_panes { - if active_pane_id == pane_id { - self.active_panes.insert( - client_id, - self.next_active_pane(&self.get_embedded_pane_ids()) - .unwrap(), - ); + self.tiled_panes.move_clients_out_of_pane(id); } } } @@ -2187,29 +1328,13 @@ impl Tab { self.floating_panes.set_force_render(); closed_pane } else { - if self.fullscreen_is_active { - self.unset_fullscreen(); - } - let mut pane_grid = TiledPaneGrid::new( - &mut self.panes, - *self.display_area.borrow(), - *self.viewport.borrow(), - ); - if pane_grid.fill_space_over_pane(id) { - // successfully filled space over pane - let closed_pane = self.panes.remove(&id); - self.move_clients_out_of_pane(id); - for pane in self.panes.values_mut() { - resize_pty!(pane, self.os_api); - } - closed_pane - } else { - self.panes.remove(&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 + if self.tiled_panes.fullscreen_is_active() { + self.tiled_panes.unset_fullscreen(); } + let closed_pane = self.tiled_panes.remove_pane(id); + self.set_force_render(); + self.tiled_panes.set_force_render(); + closed_pane } } pub fn close_focused_pane(&mut self, client_id: ClientId) { @@ -2222,7 +1347,7 @@ impl Tab { return; } } - if let Some(active_pane_id) = self.get_active_pane_id(client_id) { + if let Some(active_pane_id) = self.tiled_panes.get_active_pane_id(client_id) { self.close_pane(active_pane_id); self.senders .send_to_pty(PtyInstruction::ClosePane(active_pane_id)) @@ -2343,27 +1468,34 @@ impl Tab { ) -> Option<&mut Box> { if self.floating_panes.panes_are_visible() { if let Some(pane_id) = self.floating_panes.get_pane_id_at(point, search_selectable) { - return self.floating_panes.get_mut(&pane_id); + return self.floating_panes.get_pane_mut(pane_id); } } if let Some(pane_id) = self.get_pane_id_at(point, search_selectable) { - self.panes.get_mut(&pane_id) + self.tiled_panes.get_pane_mut(pane_id) } else { None } } fn get_pane_id_at(&self, point: &Position, search_selectable: bool) -> Option { - if self.fullscreen_is_active && self.is_position_inside_viewport(point) { - let first_client_id = self.connected_clients.iter().next().unwrap(); // TODO: instead of doing this, record the pane that is in fullscreen - return self.get_active_pane_id(*first_client_id); + if self.tiled_panes.fullscreen_is_active() && self.is_position_inside_viewport(point) { + let first_client_id = { + self.connected_clients + .borrow() + .iter() + .copied() + .next() + .unwrap() + }; // TODO: instead of doing this, record the pane that is in fullscreen + return self.tiled_panes.get_active_pane_id(first_client_id); } if search_selectable { - self.get_selectable_panes() + self.get_selectable_tiled_panes() .find(|(_, p)| p.contains(point)) .map(|(&id, _)| id) } else { - self.get_panes() + self.get_tiled_panes() .find(|(_, p)| p.contains(point)) .map(|(&id, _)| id) } @@ -2417,27 +1549,13 @@ impl Tab { fn focus_pane_at(&mut self, point: &Position, client_id: ClientId) { if self.floating_panes.panes_are_visible() { if let Some(clicked_pane) = self.floating_panes.get_pane_id_at(point, true) { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.floating_panes.focus_pane(clicked_pane, client_id); - } + self.floating_panes.focus_pane(clicked_pane, client_id); self.set_pane_active_at(clicked_pane); return; } } if let Some(clicked_pane) = self.get_pane_id_at(point, true) { - if self.session_is_mirrored { - // move all clients - let connected_clients: Vec = - self.connected_clients.iter().copied().collect(); - for client_id in connected_clients { - self.active_panes.insert(client_id, clicked_pane); - } - } else { - self.active_panes.insert(client_id, clicked_pane); - } + self.tiled_panes.focus_pane(clicked_pane, client_id); self.set_pane_active_at(clicked_pane); if self.floating_panes.panes_are_visible() { self.floating_panes.toggle_show_panes(false); @@ -2534,8 +1652,10 @@ impl Tab { fn write_selection_to_clipboard(&self, selection: &str) { let mut output = Output::default(); - output.add_clients(&self.connected_clients, self.link_handler.clone(), None); - let client_ids = self.connected_clients.iter().copied(); + let connected_clients: HashSet = + { self.connected_clients.borrow().iter().copied().collect() }; + output.add_clients(&connected_clients, self.link_handler.clone(), None); + let client_ids = connected_clients.iter().copied(); let clipboard_event = match self .clipboard_provider @@ -2557,11 +1677,6 @@ impl Tab { .send_to_plugin(PluginInstruction::Update(None, None, clipboard_event)) .unwrap(); } - fn is_inside_viewport(&self, pane_id: &PaneId) -> bool { - // this is mostly separated to an outside function in order to allow us to pass a clone to - // it sometimes when we need to get around the borrow checker - is_inside_viewport(&*self.viewport.borrow(), self.panes.get(pane_id).unwrap()) - } fn offset_viewport(&mut self, position_and_size: &Viewport) { let mut viewport = self.viewport.borrow_mut(); if position_and_size.x == viewport.x @@ -2587,7 +1702,7 @@ impl Tab { } pub fn visible(&self, visible: bool) { - let pids_in_this_tab = self.panes.keys().filter_map(|p| match p { + let pids_in_this_tab = self.tiled_panes.pane_ids().filter_map(|p| match p { PaneId::Plugin(pid) => Some(pid), _ => None, }); @@ -2605,8 +1720,8 @@ impl Tab { pub fn update_active_pane_name(&mut self, buf: Vec, client_id: ClientId) { if let Some(active_terminal_id) = self.get_active_terminal_id(client_id) { let active_terminal = self - .panes - .get_mut(&PaneId::Terminal(active_terminal_id)) + .tiled_panes + .get_pane_mut(PaneId::Terminal(active_terminal_id)) .unwrap(); // It only allows printable unicode, delete and backspace keys. @@ -2631,21 +1746,15 @@ impl Tab { && line <= viewport.y + viewport.rows && column <= viewport.x + viewport.cols } -} -#[allow(clippy::borrowed_box)] -pub fn is_inside_viewport(viewport: &Viewport, pane: &Box) -> 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 + pub fn set_pane_frames(&mut self, should_set_pane_frames: bool) { + self.tiled_panes.set_pane_frames(should_set_pane_frames); + self.should_clear_display_before_rendering = true; + self.set_force_render(); + } + pub fn panes_to_hide_count(&self) -> usize { + self.tiled_panes.panes_to_hide_count() + } } #[cfg(test)] diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap index bab72f60..180b7c50 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ │ │ 10 (C): │ │ │ │ 11 (C): │ │ I am scratch terminal │ │ -12 (C): │ ┌ Pane #2 ─────────────── SCROLL│ │────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SCROLL│ │────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap index 9f4d3777..93fdee06 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #6 ─────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap index 38417876..de6f2ecd 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap index 96faec6e..c86c5998 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ ┌ Pane #6 ─────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└────────────────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap index 38417876..de6f2ecd 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap index 95f61793..17bbcb17 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ───────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap index 38417876..de6f2ecd 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap index 38417876..de6f2ecd 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SC│ │────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap index 223045ff..33d01c0b 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap @@ -5,9 +5,9 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ────────────────────┌ Pane #2 ─────────────────────────────────────────────────┐─────────┐ 01 (C): │ │ │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ -04 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ I am scrat┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ +04 (C): │ ┌ Pane #5 ─────────────── SCROLL: 0/1 ┐ I am scrat┌ Pane #6 ─────────────── SCROLL: 0/1 ┐ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ 06 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ 07 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap index 7e5a2f06..e0292d16 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap @@ -5,9 +5,9 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ────────────────────┌ Pane #2 ─────────┐ 01 (C): │ │ │ -02 (C): │ ┌ Pane #┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ +02 (C): │ ┌ Pane #┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ 03 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ -04 (C): │ ┌ Pane #┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ +04 (C): │ ┌ Pane #┌ Pane #6 ─────────────── SCROLL: 0/1 ┐ 05 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ 06 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ 07 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap index 9f4d3777..93fdee06 100644 --- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap +++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap @@ -5,7 +5,7 @@ expression: snapshot --- 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ 01 (C): │ │ -02 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +02 (C): │ ┌ Pane #3 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #4 ─────────────── SCROLL: 0/1 ┐ │ 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ @@ -15,7 +15,7 @@ expression: snapshot 09 (C): │ │ I am scratch terminal │ │ 10 (C): │ │ │ │ 11 (C): │ │ │ │ -12 (C): │ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #2 ─────────────── SCROLL: 0/1 ┐ │ +12 (C): │ ┌ Pane #5 ─────────────── SCROLL: 0/1 ┐ ┌ Pane #6 ─────────────── SCROLL: 0/1 ┐ │ 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │ diff --git a/zellij-server/src/tab/unit/tab_tests.rs b/zellij-server/src/tab/unit/tab_tests.rs index 527894aa..64fb0c23 100644 --- a/zellij-server/src/tab/unit/tab_tests.rs +++ b/zellij-server/src/tab/unit/tab_tests.rs @@ -134,9 +134,10 @@ fn split_panes_vertically() { let mut tab = create_new_tab(size); let new_pane_id = PaneId::Terminal(2); tab.vertical_split(new_pane_id, 1); - assert_eq!(tab.panes.len(), 2, "The tab has two panes"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "The tab has two panes"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -145,7 +146,8 @@ fn split_panes_vertically() { "first pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -154,7 +156,8 @@ fn split_panes_vertically() { "first pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -164,7 +167,8 @@ fn split_panes_vertically() { "first pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -174,7 +178,8 @@ fn split_panes_vertically() { "first pane row count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -183,7 +188,8 @@ fn split_panes_vertically() { "second pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -192,7 +198,8 @@ fn split_panes_vertically() { "second pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -202,7 +209,8 @@ fn split_panes_vertically() { "second pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -222,10 +230,11 @@ fn split_panes_horizontally() { let mut tab = create_new_tab(size); let new_pane_id = PaneId::Terminal(2); tab.horizontal_split(new_pane_id, 1); - assert_eq!(tab.panes.len(), 2, "The tab has two panes"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "The tab has two panes"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -234,7 +243,8 @@ fn split_panes_horizontally() { "first pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -243,7 +253,8 @@ fn split_panes_horizontally() { "first pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -253,7 +264,8 @@ fn split_panes_horizontally() { "first pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -264,7 +276,8 @@ fn split_panes_horizontally() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -273,7 +286,8 @@ fn split_panes_horizontally() { "second pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -282,7 +296,8 @@ fn split_panes_horizontally() { "second pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -292,7 +307,8 @@ fn split_panes_horizontally() { "second pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -314,10 +330,11 @@ fn split_largest_pane() { let new_pane_id = PaneId::Terminal(i); tab.new_pane(new_pane_id, Some(1)); } - assert_eq!(tab.panes.len(), 4, "The tab has four panes"); + assert_eq!(tab.tiled_panes.panes.len(), 4, "The tab has four panes"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -326,7 +343,8 @@ fn split_largest_pane() { "first pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -335,7 +353,8 @@ fn split_largest_pane() { "first pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -345,7 +364,8 @@ fn split_largest_pane() { "first pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -356,7 +376,8 @@ fn split_largest_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -365,7 +386,8 @@ fn split_largest_pane() { "second pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -374,7 +396,8 @@ fn split_largest_pane() { "second pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -384,7 +407,8 @@ fn split_largest_pane() { "second pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -395,7 +419,8 @@ fn split_largest_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -404,7 +429,8 @@ fn split_largest_pane() { "third pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -413,7 +439,8 @@ fn split_largest_pane() { "third pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -423,7 +450,8 @@ fn split_largest_pane() { "third pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -434,7 +462,8 @@ fn split_largest_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -443,7 +472,8 @@ fn split_largest_pane() { "fourth pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -452,7 +482,8 @@ fn split_largest_pane() { "fourth pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -462,7 +493,8 @@ fn split_largest_pane() { "fourth pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -478,7 +510,11 @@ pub fn cannot_split_panes_vertically_when_active_pane_is_too_small() { let size = Size { cols: 8, rows: 20 }; let mut tab = create_new_tab(size); tab.vertical_split(PaneId::Terminal(2), 1); - assert_eq!(tab.panes.len(), 1, "Tab still has only one pane"); + assert_eq!( + tab.tiled_panes.panes.len(), + 1, + "Tab still has only one pane" + ); } #[test] @@ -486,7 +522,11 @@ pub fn cannot_split_panes_horizontally_when_active_pane_is_too_small() { let size = Size { cols: 121, rows: 4 }; let mut tab = create_new_tab(size); tab.horizontal_split(PaneId::Terminal(2), 1); - assert_eq!(tab.panes.len(), 1, "Tab still has only one pane"); + assert_eq!( + tab.tiled_panes.panes.len(), + 1, + "Tab still has only one pane" + ); } #[test] @@ -494,7 +534,11 @@ pub fn cannot_split_largest_pane_when_there_is_no_room() { let size = Size { cols: 8, rows: 4 }; let mut tab = create_new_tab(size); tab.new_pane(PaneId::Terminal(2), Some(1)); - assert_eq!(tab.panes.len(), 1, "Tab still has only one pane"); + assert_eq!( + tab.tiled_panes.panes.len(), + 1, + "Tab still has only one pane" + ); } #[test] @@ -510,43 +554,59 @@ pub fn toggle_focused_pane_fullscreen() { } tab.toggle_active_pane_fullscreen(1); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().x(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(), 0, "Pane x is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().y(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(), 0, "Pane y is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .cols(), 121, "Pane cols match fullscreen cols" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .rows(), 20, "Pane rows match fullscreen rows" ); tab.toggle_active_pane_fullscreen(1); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().x(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(), 61, "Pane x is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().y(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(), 10, "Pane y is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .cols(), 60, "Pane cols match fullscreen cols" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .rows(), 10, "Pane rows match fullscreen rows" ); @@ -568,22 +628,30 @@ pub fn move_focus_is_disabled_in_fullscreen() { tab.toggle_active_pane_fullscreen(1); tab.move_focus_left(1); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().x(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(), 0, "Pane x is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().y(), + tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(), 0, "Pane y is on screen edge" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .cols(), 121, "Pane cols match fullscreen cols" ); assert_eq!( - tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(), + tab.tiled_panes + .panes + .get(&PaneId::Terminal(4)) + .unwrap() + .rows(), 20, "Pane rows match fullscreen rows" ); @@ -608,10 +676,11 @@ pub fn close_pane_with_another_pane_above_it() { let new_pane_id = PaneId::Terminal(2); tab.horizontal_split(new_pane_id, 1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 1, "One pane left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -620,7 +689,8 @@ pub fn close_pane_with_another_pane_above_it() { "remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -629,7 +699,8 @@ pub fn close_pane_with_another_pane_above_it() { "remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -639,7 +710,8 @@ pub fn close_pane_with_another_pane_above_it() { "remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -670,10 +742,11 @@ pub fn close_pane_with_another_pane_below_it() { tab.horizontal_split(new_pane_id, 1); tab.move_focus_up(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 1, "One pane left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -682,7 +755,8 @@ pub fn close_pane_with_another_pane_below_it() { "remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -691,7 +765,8 @@ pub fn close_pane_with_another_pane_below_it() { "remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -701,7 +776,8 @@ pub fn close_pane_with_another_pane_below_it() { "remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -728,10 +804,11 @@ pub fn close_pane_with_another_pane_to_the_left() { let new_pane_id = PaneId::Terminal(2); tab.vertical_split(new_pane_id, 1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 1, "One pane left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -740,7 +817,8 @@ pub fn close_pane_with_another_pane_to_the_left() { "remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -749,7 +827,8 @@ pub fn close_pane_with_another_pane_to_the_left() { "remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -759,7 +838,8 @@ pub fn close_pane_with_another_pane_to_the_left() { "remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -787,10 +867,11 @@ pub fn close_pane_with_another_pane_to_the_right() { tab.vertical_split(new_pane_id, 1); tab.move_focus_left(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 1, "One pane left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -799,7 +880,8 @@ pub fn close_pane_with_another_pane_to_the_right() { "remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -808,7 +890,8 @@ pub fn close_pane_with_another_pane_to_the_right() { "remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -818,7 +901,8 @@ pub fn close_pane_with_another_pane_to_the_right() { "remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -851,10 +935,11 @@ pub fn close_pane_with_multiple_panes_above_it() { tab.vertical_split(new_pane_id_2, 1); tab.move_focus_down(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 2, "Two panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -863,7 +948,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -872,7 +958,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -882,7 +969,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -893,7 +981,8 @@ pub fn close_pane_with_multiple_panes_above_it() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -902,7 +991,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -911,7 +1001,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -921,7 +1012,8 @@ pub fn close_pane_with_multiple_panes_above_it() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -953,10 +1045,11 @@ pub fn close_pane_with_multiple_panes_below_it() { tab.vertical_split(new_pane_id_2, 1); tab.move_focus_up(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 2, "Two panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -965,7 +1058,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -974,7 +1068,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -984,7 +1079,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -995,7 +1091,8 @@ pub fn close_pane_with_multiple_panes_below_it() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1004,7 +1101,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1013,7 +1111,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1023,7 +1122,8 @@ pub fn close_pane_with_multiple_panes_below_it() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1056,10 +1156,11 @@ pub fn close_pane_with_multiple_panes_to_the_left() { tab.horizontal_split(new_pane_id_2, 1); tab.move_focus_right(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 2, "Two panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1068,7 +1169,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1077,7 +1179,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1087,7 +1190,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1098,7 +1202,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1107,7 +1212,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1116,7 +1222,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1126,7 +1233,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1158,10 +1266,11 @@ pub fn close_pane_with_multiple_panes_to_the_right() { tab.horizontal_split(new_pane_id_2, 1); tab.move_focus_left(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 2, "Two panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1170,7 +1279,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1179,7 +1289,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1189,7 +1300,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1200,7 +1312,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1209,7 +1322,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1218,7 +1332,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1228,7 +1343,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1277,10 +1393,11 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { tab.move_focus_down(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 6, "Six panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1289,7 +1406,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1298,7 +1416,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1308,7 +1427,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1319,7 +1439,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1328,7 +1449,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1337,7 +1459,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1347,7 +1470,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1358,7 +1482,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1367,7 +1492,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "third remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1376,7 +1502,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "third remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1386,7 +1513,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "third remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1397,7 +1525,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1406,7 +1535,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "fourth remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1415,7 +1545,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "fourth remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1425,7 +1556,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "fourth remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1436,7 +1568,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1445,7 +1578,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "sixths remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1454,7 +1588,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "sixths remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1464,7 +1599,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "sixths remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1475,7 +1611,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1484,7 +1621,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "seventh remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1493,7 +1631,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "seventh remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1503,7 +1642,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() { "seventh remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1552,10 +1692,11 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { tab.move_focus_up(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 6, "Six panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1564,7 +1705,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1573,7 +1715,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1583,7 +1726,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1594,7 +1738,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1603,7 +1748,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "third remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1612,7 +1758,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "third remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1622,7 +1769,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "third remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1633,7 +1781,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1642,7 +1791,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "fourth remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1651,7 +1801,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "fourth remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1661,7 +1812,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "fourth remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1672,7 +1824,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -1681,7 +1834,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -1690,7 +1844,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -1700,7 +1855,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -1711,7 +1867,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1720,7 +1877,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "sixths remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1729,7 +1887,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "sixths remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1739,7 +1898,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "sixths remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -1750,7 +1910,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1759,7 +1920,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "seventh remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1768,7 +1930,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "seventh remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1778,7 +1941,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() { "seventh remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -1832,10 +1996,11 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { tab.move_focus_right(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 6, "Six panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1844,7 +2009,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1853,7 +2019,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1863,7 +2030,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -1874,7 +2042,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1883,7 +2052,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "third remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1892,7 +2062,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "third remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1902,7 +2073,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "third remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -1913,7 +2085,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1922,7 +2095,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "fourth remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1931,7 +2105,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "fourth remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1941,7 +2116,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "fourth remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -1952,7 +2128,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1961,7 +2138,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1970,7 +2148,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1980,7 +2159,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -1991,7 +2171,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2000,7 +2181,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "sixths remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2009,7 +2191,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "sixths remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2019,7 +2202,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "sixths remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2030,7 +2214,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2039,7 +2224,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "seventh remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2048,7 +2234,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "seventh remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2058,7 +2245,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() { "seventh remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2111,10 +2299,11 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { tab.move_focus_left(1); tab.close_focused_pane(1); - assert_eq!(tab.panes.len(), 6, "Six panes left in tab"); + assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab"); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2123,7 +2312,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "first remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2132,7 +2322,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "first remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2142,7 +2333,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "first remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2153,7 +2345,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -2162,7 +2355,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "fourth remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -2171,7 +2365,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "fourth remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -2181,7 +2376,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "fourth remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -2192,7 +2388,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -2201,7 +2398,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "second remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -2210,7 +2408,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "second remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -2220,7 +2419,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "second remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -2231,7 +2431,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -2240,7 +2441,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "third remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -2249,7 +2451,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "third remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -2259,7 +2462,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "third remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -2270,7 +2474,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2279,7 +2484,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "sixths remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2288,7 +2494,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "sixths remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2298,7 +2505,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "sixths remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -2309,7 +2517,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2318,7 +2527,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "seventh remaining pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2327,7 +2537,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "seventh remaining pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2337,7 +2548,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() { "seventh remaining pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -2803,17 +3015,28 @@ pub fn resize_down_with_pane_above() { tab.resize_down(1); assert_eq!( - tab.panes.get(&new_pane_id).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id) + .unwrap() + .position_and_size() + .x, 0, "focused pane x position" ); assert_eq!( - tab.panes.get(&new_pane_id).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id) + .unwrap() + .position_and_size() + .y, 11, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id) .unwrap() .position_and_size() @@ -2823,7 +3046,8 @@ pub fn resize_down_with_pane_above() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id) .unwrap() .position_and_size() @@ -2834,7 +3058,8 @@ pub fn resize_down_with_pane_above() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2843,7 +3068,8 @@ pub fn resize_down_with_pane_above() { "pane above x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2852,7 +3078,8 @@ pub fn resize_down_with_pane_above() { "pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2862,7 +3089,8 @@ pub fn resize_down_with_pane_above() { "pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2894,17 +3122,28 @@ pub fn resize_down_with_pane_below() { tab.resize_down(1); assert_eq!( - tab.panes.get(&new_pane_id).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id) + .unwrap() + .position_and_size() + .x, 0, "pane below x position" ); assert_eq!( - tab.panes.get(&new_pane_id).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id) + .unwrap() + .position_and_size() + .y, 11, "pane below y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id) .unwrap() .position_and_size() @@ -2914,7 +3153,8 @@ pub fn resize_down_with_pane_below() { "pane below column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id) .unwrap() .position_and_size() @@ -2925,7 +3165,8 @@ pub fn resize_down_with_pane_below() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2934,7 +3175,8 @@ pub fn resize_down_with_pane_below() { "focused pane x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2943,7 +3185,8 @@ pub fn resize_down_with_pane_below() { "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2953,7 +3196,8 @@ pub fn resize_down_with_pane_below() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -2992,17 +3236,28 @@ pub fn resize_down_with_panes_above_and_below() { tab.resize_down(1); assert_eq!( - tab.panes.get(&new_pane_id_1).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id_1) + .unwrap() + .position_and_size() + .x, 0, "focused pane x position" ); assert_eq!( - tab.panes.get(&new_pane_id_1).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id_1) + .unwrap() + .position_and_size() + .y, 15, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_1) .unwrap() .position_and_size() @@ -3012,7 +3267,8 @@ pub fn resize_down_with_panes_above_and_below() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_1) .unwrap() .position_and_size() @@ -3023,17 +3279,28 @@ pub fn resize_down_with_panes_above_and_below() { ); assert_eq!( - tab.panes.get(&new_pane_id_2).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id_2) + .unwrap() + .position_and_size() + .x, 0, "pane below x position" ); assert_eq!( - tab.panes.get(&new_pane_id_2).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id_2) + .unwrap() + .position_and_size() + .y, 24, "pane below y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_2) .unwrap() .position_and_size() @@ -3043,7 +3310,8 @@ pub fn resize_down_with_panes_above_and_below() { "pane below column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_2) .unwrap() .position_and_size() @@ -3054,17 +3322,28 @@ pub fn resize_down_with_panes_above_and_below() { ); assert_eq!( - tab.panes.get(&first_pane_id).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&first_pane_id) + .unwrap() + .position_and_size() + .x, 0, "pane above x position" ); assert_eq!( - tab.panes.get(&first_pane_id).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&first_pane_id) + .unwrap() + .position_and_size() + .y, 0, "pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&first_pane_id) .unwrap() .position_and_size() @@ -3074,7 +3353,8 @@ pub fn resize_down_with_panes_above_and_below() { "pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&first_pane_id) .unwrap() .position_and_size() @@ -3110,17 +3390,28 @@ pub fn resize_down_with_multiple_panes_above() { tab.resize_down(1); assert_eq!( - tab.panes.get(&new_pane_id_1).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id_1) + .unwrap() + .position_and_size() + .x, 0, "focused pane x position" ); assert_eq!( - tab.panes.get(&new_pane_id_1).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id_1) + .unwrap() + .position_and_size() + .y, 16, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_1) .unwrap() .position_and_size() @@ -3130,7 +3421,8 @@ pub fn resize_down_with_multiple_panes_above() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_1) .unwrap() .position_and_size() @@ -3141,17 +3433,28 @@ pub fn resize_down_with_multiple_panes_above() { ); assert_eq!( - tab.panes.get(&new_pane_id_2).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&new_pane_id_2) + .unwrap() + .position_and_size() + .x, 61, "first pane above x position" ); assert_eq!( - tab.panes.get(&new_pane_id_2).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&new_pane_id_2) + .unwrap() + .position_and_size() + .y, 0, "first pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_2) .unwrap() .position_and_size() @@ -3161,7 +3464,8 @@ pub fn resize_down_with_multiple_panes_above() { "first pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&new_pane_id_2) .unwrap() .position_and_size() @@ -3172,17 +3476,28 @@ pub fn resize_down_with_multiple_panes_above() { ); assert_eq!( - tab.panes.get(&first_pane_id).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&first_pane_id) + .unwrap() + .position_and_size() + .x, 0, "second pane above x position" ); assert_eq!( - tab.panes.get(&first_pane_id).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&first_pane_id) + .unwrap() + .position_and_size() + .y, 0, "second pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&first_pane_id) .unwrap() .position_and_size() @@ -3192,7 +3507,8 @@ pub fn resize_down_with_multiple_panes_above() { "second pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&first_pane_id) .unwrap() .position_and_size() @@ -3230,17 +3546,28 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .x, 61, "focused pane x position" ); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .y, 16, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3250,7 +3577,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3261,7 +3589,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_left) .unwrap() .position_and_size() @@ -3270,7 +3599,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane above and to the left x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_left) .unwrap() .position_and_size() @@ -3279,7 +3609,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane above and to the left y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_left) .unwrap() .position_and_size() @@ -3289,7 +3620,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane above and to the left column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_left) .unwrap() .position_and_size() @@ -3300,17 +3632,28 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes.get(&pane_above).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&pane_above) + .unwrap() + .position_and_size() + .x, 61, "pane above x position" ); assert_eq!( - tab.panes.get(&pane_above).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&pane_above) + .unwrap() + .position_and_size() + .y, 0, "pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above) .unwrap() .position_and_size() @@ -3320,7 +3663,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above) .unwrap() .position_and_size() @@ -3331,7 +3675,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3340,7 +3685,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane to the left x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3349,7 +3695,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane to the left y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3359,7 +3706,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() { "pane to the left column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3397,17 +3745,28 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .x, 61, "focused pane x position" ); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .y, 0, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3417,7 +3776,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3428,7 +3788,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3437,7 +3798,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane above and to the left x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3446,7 +3808,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane above and to the left y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3456,7 +3819,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane above and to the left column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_left) .unwrap() .position_and_size() @@ -3467,17 +3831,28 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes.get(&pane_below).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&pane_below) + .unwrap() + .position_and_size() + .x, 61, "pane above x position" ); assert_eq!( - tab.panes.get(&pane_below).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&pane_below) + .unwrap() + .position_and_size() + .y, 16, "pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below) .unwrap() .position_and_size() @@ -3487,7 +3862,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below) .unwrap() .position_and_size() @@ -3498,7 +3874,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_left) .unwrap() .position_and_size() @@ -3507,7 +3884,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane to the left x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_left) .unwrap() .position_and_size() @@ -3516,7 +3894,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane to the left y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_left) .unwrap() .position_and_size() @@ -3526,7 +3905,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() { "pane to the left column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_left) .unwrap() .position_and_size() @@ -3566,17 +3946,28 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .x, 0, "focused pane x position" ); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .y, 16, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3586,7 +3977,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3597,17 +3989,28 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes.get(&pane_above).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&pane_above) + .unwrap() + .position_and_size() + .x, 0, "pane above x position" ); assert_eq!( - tab.panes.get(&pane_above).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&pane_above) + .unwrap() + .position_and_size() + .y, 0, "pane above y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above) .unwrap() .position_and_size() @@ -3617,7 +4020,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane above column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above) .unwrap() .position_and_size() @@ -3628,7 +4032,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3637,7 +4042,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane to the right x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3646,7 +4052,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane to the right y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3656,7 +4063,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane to the right column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3667,7 +4075,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_right) .unwrap() .position_and_size() @@ -3676,7 +4085,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane above and to the right x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_right) .unwrap() .position_and_size() @@ -3685,7 +4095,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane above and to the right y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_right) .unwrap() .position_and_size() @@ -3695,7 +4106,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() { "pane above and to the right column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_above_and_right) .unwrap() .position_and_size() @@ -3734,17 +4146,28 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .x, 0, "focused pane x position" ); assert_eq!( - tab.panes.get(&focused_pane).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&focused_pane) + .unwrap() + .position_and_size() + .y, 0, "focused pane y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3754,7 +4177,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "focused pane column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&focused_pane) .unwrap() .position_and_size() @@ -3765,17 +4189,28 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes.get(&pane_below).unwrap().position_and_size().x, + tab.tiled_panes + .panes + .get(&pane_below) + .unwrap() + .position_and_size() + .x, 0, "pane below x position" ); assert_eq!( - tab.panes.get(&pane_below).unwrap().position_and_size().y, + tab.tiled_panes + .panes + .get(&pane_below) + .unwrap() + .position_and_size() + .y, 16, "pane below y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below) .unwrap() .position_and_size() @@ -3785,7 +4220,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane below column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below) .unwrap() .position_and_size() @@ -3796,7 +4232,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_right) .unwrap() .position_and_size() @@ -3805,7 +4242,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane below and to the right x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_right) .unwrap() .position_and_size() @@ -3814,7 +4252,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane below and to the right y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_right) .unwrap() .position_and_size() @@ -3824,7 +4263,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane below and to the right column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_below_and_right) .unwrap() .position_and_size() @@ -3835,7 +4275,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3844,7 +4285,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane to the right x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3853,7 +4295,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane to the right y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3863,7 +4306,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() { "pane to the right column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&pane_to_the_right) .unwrap() .position_and_size() @@ -3901,7 +4345,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -3910,7 +4355,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -3919,7 +4365,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -3929,7 +4376,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -3940,7 +4388,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -3949,7 +4398,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -3958,7 +4408,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -3968,7 +4419,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -3979,7 +4431,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -3988,7 +4441,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -3997,7 +4451,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4007,7 +4462,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4018,7 +4474,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4027,7 +4484,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4036,7 +4494,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4046,7 +4505,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4057,7 +4517,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4066,7 +4527,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4075,7 +4537,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4085,7 +4548,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4096,7 +4560,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4105,7 +4570,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4114,7 +4580,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4124,7 +4591,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4161,7 +4629,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4170,7 +4639,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4179,7 +4649,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4189,7 +4660,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4200,7 +4672,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4209,7 +4682,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4218,7 +4692,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4228,7 +4703,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4239,7 +4715,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4248,7 +4725,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4257,7 +4735,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4267,7 +4746,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4278,7 +4758,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4287,7 +4768,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4296,7 +4778,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4306,7 +4789,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4317,7 +4801,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4326,7 +4811,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4335,7 +4821,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4345,7 +4832,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4356,7 +4844,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4365,7 +4854,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4374,7 +4864,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4384,7 +4875,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4425,7 +4917,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4434,7 +4927,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4443,7 +4937,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4453,7 +4948,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4464,7 +4960,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4473,7 +4970,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4482,7 +4980,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4492,7 +4991,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4503,7 +5003,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4512,7 +5013,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4521,7 +5023,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4531,7 +5034,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4542,7 +5046,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4551,7 +5056,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4560,7 +5066,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4570,7 +5077,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4581,7 +5089,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4590,7 +5099,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4599,7 +5109,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4609,7 +5120,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4620,7 +5132,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4629,7 +5142,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4638,7 +5152,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4648,7 +5163,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4659,7 +5175,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -4668,7 +5185,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -4677,7 +5195,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -4687,7 +5206,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -4698,7 +5218,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -4707,7 +5228,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -4716,7 +5238,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -4726,7 +5249,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -4769,7 +5293,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4778,7 +5303,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4787,7 +5313,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4797,7 +5324,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -4808,7 +5336,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4817,7 +5346,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4826,7 +5356,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4836,7 +5367,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -4847,7 +5379,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4856,7 +5389,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4865,7 +5399,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4875,7 +5410,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -4886,7 +5422,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4895,7 +5432,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4904,7 +5442,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4914,7 +5453,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -4925,7 +5465,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4934,7 +5475,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4943,7 +5485,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4953,7 +5496,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -4964,7 +5508,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4973,7 +5518,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4982,7 +5528,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -4992,7 +5539,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -5003,7 +5551,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -5012,7 +5561,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -5021,7 +5571,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -5031,7 +5582,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -5042,7 +5594,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -5051,7 +5604,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -5060,7 +5614,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -5070,7 +5625,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_ "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -5100,7 +5656,8 @@ pub fn cannot_resize_down_when_pane_below_is_at_minimum_height() { tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5110,7 +5667,8 @@ pub fn cannot_resize_down_when_pane_below_is_at_minimum_height() { "pane 1 height stayed the same" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5139,7 +5697,8 @@ pub fn resize_left_with_pane_to_the_left() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5148,7 +5707,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5157,7 +5717,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5167,7 +5728,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5178,7 +5740,8 @@ pub fn resize_left_with_pane_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5187,7 +5750,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5196,7 +5760,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5206,7 +5771,8 @@ pub fn resize_left_with_pane_to_the_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5235,7 +5801,8 @@ pub fn resize_left_with_pane_to_the_right() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5244,7 +5811,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5253,7 +5821,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5263,7 +5832,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5274,7 +5844,8 @@ pub fn resize_left_with_pane_to_the_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5283,7 +5854,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5292,7 +5864,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5302,7 +5875,8 @@ pub fn resize_left_with_pane_to_the_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5333,7 +5907,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5342,7 +5917,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5351,7 +5927,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5361,7 +5938,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5372,7 +5950,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5381,7 +5960,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5390,7 +5970,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5400,7 +5981,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5411,7 +5993,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5420,7 +6003,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5429,7 +6013,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5439,7 +6024,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5470,7 +6056,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5479,7 +6066,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5488,7 +6076,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5498,7 +6087,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5509,7 +6099,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5518,7 +6109,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5527,7 +6119,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5537,7 +6130,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5548,7 +6142,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5557,7 +6152,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5566,7 +6162,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5576,7 +6173,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5609,7 +6207,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5618,7 +6217,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5627,7 +6227,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5637,7 +6238,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5648,7 +6250,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5657,7 +6260,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5666,7 +6270,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5676,7 +6281,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5687,7 +6293,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5696,7 +6303,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5705,7 +6313,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5715,7 +6324,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5726,7 +6336,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5735,7 +6346,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5744,7 +6356,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5754,7 +6367,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5788,7 +6402,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5797,7 +6412,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5806,7 +6422,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5816,7 +6433,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5827,7 +6445,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5836,7 +6455,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5845,7 +6465,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5855,7 +6476,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -5866,7 +6488,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5875,7 +6498,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5884,7 +6508,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5894,7 +6519,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -5905,7 +6531,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5914,7 +6541,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5923,7 +6551,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5933,7 +6562,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -5965,7 +6595,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5974,7 +6605,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5983,7 +6615,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -5993,7 +6626,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6004,7 +6638,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6013,7 +6648,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6022,7 +6658,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6032,7 +6669,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6043,7 +6681,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6052,7 +6691,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6061,7 +6701,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6071,7 +6712,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6082,7 +6724,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6091,7 +6734,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6100,7 +6744,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6110,7 +6755,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6143,7 +6789,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6152,7 +6799,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6161,7 +6809,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6171,7 +6820,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6182,7 +6832,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6191,7 +6842,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6200,7 +6852,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6210,7 +6863,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6221,7 +6875,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6230,7 +6885,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6239,7 +6895,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6249,7 +6906,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6260,7 +6918,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6269,7 +6928,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6278,7 +6938,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6288,7 +6949,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6326,7 +6988,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6335,7 +6998,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6344,7 +7008,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6354,7 +7019,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6365,7 +7031,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6374,7 +7041,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6383,7 +7051,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6393,7 +7062,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6404,7 +7074,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6413,7 +7084,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6422,7 +7094,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6432,7 +7105,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6443,7 +7117,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6452,7 +7127,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6461,7 +7137,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6471,7 +7148,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6482,7 +7160,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6491,7 +7170,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6500,7 +7180,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6510,7 +7191,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6521,7 +7203,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6530,7 +7213,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6539,7 +7223,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6549,7 +7234,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6588,7 +7274,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6597,7 +7284,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6606,7 +7294,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6616,7 +7305,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6627,7 +7317,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6636,7 +7327,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6645,7 +7337,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6655,7 +7348,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6666,7 +7360,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6675,7 +7370,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6684,7 +7380,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6694,7 +7391,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6705,7 +7403,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6714,7 +7413,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6723,7 +7423,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6733,7 +7434,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6744,7 +7446,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6753,7 +7456,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6762,7 +7466,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6772,7 +7477,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -6783,7 +7489,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6792,7 +7499,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6801,7 +7509,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6811,7 +7520,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -6853,7 +7563,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6862,7 +7573,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6871,7 +7583,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6881,7 +7594,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -6892,7 +7606,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6901,7 +7616,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6910,7 +7626,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6920,7 +7637,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -6931,7 +7649,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6940,7 +7659,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6949,7 +7669,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6959,7 +7680,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -6970,7 +7692,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6979,7 +7702,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6988,7 +7712,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -6998,7 +7723,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -7009,7 +7735,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7018,7 +7745,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7027,7 +7755,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7037,7 +7766,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7048,7 +7778,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7057,7 +7788,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7066,7 +7798,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7076,7 +7809,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7087,7 +7821,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7096,7 +7831,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7105,7 +7841,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7115,7 +7852,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7126,7 +7864,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7135,7 +7874,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7144,7 +7884,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7154,7 +7895,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7197,7 +7939,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7206,7 +7949,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7215,7 +7959,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7225,7 +7970,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7236,7 +7982,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7245,7 +7992,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7254,7 +8002,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7264,7 +8013,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7275,7 +8025,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7284,7 +8035,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7293,7 +8045,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7303,7 +8056,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7314,7 +8068,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -7323,7 +8078,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -7332,7 +8088,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -7342,7 +8099,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -7353,7 +8111,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7362,7 +8121,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7371,7 +8131,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7381,7 +8142,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -7392,7 +8154,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7401,7 +8164,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7410,7 +8174,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7420,7 +8185,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -7431,7 +8197,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7440,7 +8207,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7449,7 +8217,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7459,7 +8228,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -7470,7 +8240,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7479,7 +8250,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7488,7 +8260,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7498,7 +8271,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -7524,7 +8298,8 @@ pub fn cannot_resize_left_when_pane_to_the_left_is_at_minimum_width() { tab.resize_left(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7534,7 +8309,8 @@ pub fn cannot_resize_left_when_pane_to_the_left_is_at_minimum_width() { "pane 1 columns stayed the same" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7563,7 +8339,8 @@ pub fn resize_right_with_pane_to_the_left() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7572,7 +8349,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7581,7 +8359,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7591,7 +8370,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7602,7 +8382,8 @@ pub fn resize_right_with_pane_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7611,7 +8392,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7620,7 +8402,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7630,7 +8413,8 @@ pub fn resize_right_with_pane_to_the_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7660,7 +8444,8 @@ pub fn resize_right_with_pane_to_the_right() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7669,7 +8454,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7678,7 +8464,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7688,7 +8475,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7699,7 +8487,8 @@ pub fn resize_right_with_pane_to_the_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7708,7 +8497,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7717,7 +8507,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7727,7 +8518,8 @@ pub fn resize_right_with_pane_to_the_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7758,7 +8550,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7767,7 +8560,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7776,7 +8570,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7786,7 +8581,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7797,7 +8593,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7806,7 +8603,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7815,7 +8613,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7825,7 +8624,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7836,7 +8636,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7845,7 +8646,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7854,7 +8656,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7864,7 +8667,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7896,7 +8700,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7905,7 +8710,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7914,7 +8720,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7924,7 +8731,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -7935,7 +8743,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7944,7 +8753,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7953,7 +8763,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7963,7 +8774,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -7974,7 +8786,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7983,7 +8796,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -7992,7 +8806,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8002,7 +8817,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8035,7 +8851,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8044,7 +8861,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8053,7 +8871,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8063,7 +8882,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8074,7 +8894,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8083,7 +8904,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8092,7 +8914,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8102,7 +8925,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8113,7 +8937,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8122,7 +8947,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8131,7 +8957,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8141,7 +8968,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8152,7 +8980,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8161,7 +8990,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8170,7 +9000,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8180,7 +9011,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8213,7 +9045,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8222,7 +9055,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8231,7 +9065,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8241,7 +9076,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8252,7 +9088,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8261,7 +9098,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8270,7 +9108,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8280,7 +9119,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8291,7 +9131,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8300,7 +9141,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8309,7 +9151,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8319,7 +9162,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8330,7 +9174,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8339,7 +9184,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8348,7 +9194,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8358,7 +9205,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8392,7 +9240,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8401,7 +9250,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8410,7 +9260,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8420,7 +9271,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8431,7 +9283,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8440,7 +9293,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8449,7 +9303,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8459,7 +9314,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8470,7 +9326,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8479,7 +9336,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8488,7 +9346,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8498,7 +9357,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8509,7 +9369,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8518,7 +9379,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8527,7 +9389,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8537,7 +9400,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8572,7 +9436,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8581,7 +9446,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8590,7 +9456,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8600,7 +9467,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8611,7 +9479,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8620,7 +9489,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8629,7 +9499,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8639,7 +9510,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8650,7 +9522,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8659,7 +9532,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8668,7 +9542,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8678,7 +9553,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8689,7 +9565,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8698,7 +9575,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8707,7 +9585,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8717,7 +9596,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8755,7 +9635,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8764,7 +9645,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8773,7 +9655,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8783,7 +9666,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -8794,7 +9678,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8803,7 +9688,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8812,7 +9698,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8822,7 +9709,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -8833,7 +9721,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8842,7 +9731,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8851,7 +9741,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8861,7 +9752,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -8872,7 +9764,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8881,7 +9774,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8890,7 +9784,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8900,7 +9795,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -8911,7 +9807,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -8920,7 +9817,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -8929,7 +9827,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -8939,7 +9838,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -8950,7 +9850,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -8959,7 +9860,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -8968,7 +9870,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -8978,7 +9881,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9016,7 +9920,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9025,7 +9930,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9034,7 +9940,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9044,7 +9951,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9055,7 +9963,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9064,7 +9973,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9073,7 +9983,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9083,7 +9994,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9094,7 +10006,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9103,7 +10016,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9112,7 +10026,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9122,7 +10037,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9133,7 +10049,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9142,7 +10059,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9151,7 +10069,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9161,7 +10080,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9172,7 +10092,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9181,7 +10102,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9190,7 +10112,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9200,7 +10123,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9211,7 +10135,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9220,7 +10145,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9229,7 +10155,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9239,7 +10166,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_ "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9280,7 +10208,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9289,7 +10218,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9298,7 +10228,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9308,7 +10239,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9319,7 +10251,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9328,7 +10261,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9337,7 +10271,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9347,7 +10282,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9358,7 +10294,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9367,7 +10304,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9376,7 +10314,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9386,7 +10325,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9397,7 +10337,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9406,7 +10347,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9415,7 +10357,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9425,7 +10368,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9436,7 +10380,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9445,7 +10390,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9454,7 +10400,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9464,7 +10411,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9475,7 +10423,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9484,7 +10433,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9493,7 +10443,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9503,7 +10454,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9514,7 +10466,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9523,7 +10476,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9532,7 +10486,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9542,7 +10497,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9553,7 +10509,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9562,7 +10519,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9571,7 +10529,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9581,7 +10540,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9623,7 +10583,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9632,7 +10593,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9641,7 +10603,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9651,7 +10614,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9662,7 +10626,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9671,7 +10636,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9680,7 +10646,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9690,7 +10657,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9701,7 +10669,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9710,7 +10679,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9719,7 +10689,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9729,7 +10700,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -9740,7 +10712,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9749,7 +10722,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9758,7 +10732,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9768,7 +10743,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -9779,7 +10755,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9788,7 +10765,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9797,7 +10775,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9807,7 +10786,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -9818,7 +10798,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9827,7 +10808,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9836,7 +10818,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9846,7 +10829,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -9857,7 +10841,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9866,7 +10851,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9875,7 +10861,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9885,7 +10872,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -9896,7 +10884,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9905,7 +10894,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9914,7 +10904,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9924,7 +10915,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -9949,7 +10941,8 @@ pub fn cannot_resize_right_when_pane_to_the_left_is_at_minimum_width() { tab.resize_right(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9959,7 +10952,8 @@ pub fn cannot_resize_right_when_pane_to_the_left_is_at_minimum_width() { "pane 1 columns stayed the same" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -9989,7 +10983,8 @@ pub fn resize_up_with_pane_above() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -9998,7 +10993,8 @@ pub fn resize_up_with_pane_above() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10007,7 +11003,8 @@ pub fn resize_up_with_pane_above() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10017,7 +11014,8 @@ pub fn resize_up_with_pane_above() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10028,7 +11026,8 @@ pub fn resize_up_with_pane_above() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10037,7 +11036,8 @@ pub fn resize_up_with_pane_above() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10046,7 +11046,8 @@ pub fn resize_up_with_pane_above() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10056,7 +11057,8 @@ pub fn resize_up_with_pane_above() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10087,7 +11089,8 @@ pub fn resize_up_with_pane_below() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10096,7 +11099,8 @@ pub fn resize_up_with_pane_below() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10105,7 +11109,8 @@ pub fn resize_up_with_pane_below() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10115,7 +11120,8 @@ pub fn resize_up_with_pane_below() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10126,7 +11132,8 @@ pub fn resize_up_with_pane_below() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10135,7 +11142,8 @@ pub fn resize_up_with_pane_below() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10144,7 +11152,8 @@ pub fn resize_up_with_pane_below() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10154,7 +11163,8 @@ pub fn resize_up_with_pane_below() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10189,7 +11199,8 @@ pub fn resize_up_with_panes_above_and_below() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10198,7 +11209,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10207,7 +11219,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10217,7 +11230,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10228,7 +11242,8 @@ pub fn resize_up_with_panes_above_and_below() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10237,7 +11252,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10246,7 +11262,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10256,7 +11273,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10267,7 +11285,8 @@ pub fn resize_up_with_panes_above_and_below() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10276,7 +11295,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10285,7 +11305,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10295,7 +11316,8 @@ pub fn resize_up_with_panes_above_and_below() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10327,7 +11349,8 @@ pub fn resize_up_with_multiple_panes_above() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10336,7 +11359,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10345,7 +11369,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10355,7 +11380,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10366,7 +11392,8 @@ pub fn resize_up_with_multiple_panes_above() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10375,7 +11402,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10384,7 +11412,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10394,7 +11423,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10405,7 +11435,8 @@ pub fn resize_up_with_multiple_panes_above() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10414,7 +11445,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10423,7 +11455,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10433,7 +11466,8 @@ pub fn resize_up_with_multiple_panes_above() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10465,7 +11499,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10474,7 +11509,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10483,7 +11519,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10493,7 +11530,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10504,7 +11542,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10513,7 +11552,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10522,7 +11562,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10532,7 +11573,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10543,7 +11585,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10552,7 +11595,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10561,7 +11605,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10571,7 +11616,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10582,7 +11628,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10591,7 +11638,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10600,7 +11648,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10610,7 +11659,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10645,7 +11695,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10654,7 +11705,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10663,7 +11715,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10673,7 +11726,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10684,7 +11738,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10693,7 +11748,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10702,7 +11758,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10712,7 +11769,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10723,7 +11781,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10732,7 +11791,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10741,7 +11801,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10751,7 +11812,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10762,7 +11824,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10771,7 +11834,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10780,7 +11844,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10790,7 +11855,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10825,7 +11891,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10834,7 +11901,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10843,7 +11911,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10853,7 +11922,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -10864,7 +11934,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10873,7 +11944,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10882,7 +11954,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10892,7 +11965,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -10903,7 +11977,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10912,7 +11987,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10921,7 +11997,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10931,7 +12008,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -10942,7 +12020,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10951,7 +12030,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10960,7 +12040,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -10970,7 +12051,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11006,7 +12088,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11015,7 +12098,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11024,7 +12108,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11034,7 +12119,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11045,7 +12131,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11054,7 +12141,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11063,7 +12151,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11073,7 +12162,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11084,7 +12174,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11093,7 +12184,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11102,7 +12194,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11112,7 +12205,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11123,7 +12217,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11132,7 +12227,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11141,7 +12237,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11151,7 +12248,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11187,7 +12285,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11196,7 +12295,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11205,7 +12305,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11215,7 +12316,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11226,7 +12328,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11235,7 +12338,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11244,7 +12348,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11254,7 +12359,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11265,7 +12371,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11274,7 +12381,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11283,7 +12391,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11293,7 +12402,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11304,7 +12414,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11313,7 +12424,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11322,7 +12434,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11332,7 +12445,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11343,7 +12457,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11352,7 +12467,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11361,7 +12477,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11371,7 +12488,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11382,7 +12500,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11391,7 +12510,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11400,7 +12520,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11410,7 +12531,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() { "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11447,7 +12569,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11456,7 +12579,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11465,7 +12589,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11475,7 +12600,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11486,7 +12612,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11495,7 +12622,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11504,7 +12632,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11514,7 +12643,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11525,7 +12655,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11534,7 +12665,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11543,7 +12675,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11553,7 +12686,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11564,7 +12698,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11573,7 +12708,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11582,7 +12718,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11592,7 +12729,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11603,7 +12741,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11612,7 +12751,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11621,7 +12761,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11631,7 +12772,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11642,7 +12784,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11651,7 +12794,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11660,7 +12804,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11670,7 +12815,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() { "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11710,7 +12856,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11719,7 +12866,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11728,7 +12876,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11738,7 +12887,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -11749,7 +12899,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11758,7 +12909,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11767,7 +12919,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11777,7 +12930,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -11788,7 +12942,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11797,7 +12952,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11806,7 +12962,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11816,7 +12973,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -11827,7 +12985,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11836,7 +12995,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11845,7 +13005,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11855,7 +13016,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -11866,7 +13028,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11875,7 +13038,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11884,7 +13048,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11894,7 +13059,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -11905,7 +13071,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11914,7 +13081,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11923,7 +13091,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11933,7 +13102,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -11944,7 +13114,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -11953,7 +13124,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -11962,7 +13134,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -11972,7 +13145,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -11983,7 +13157,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -11992,7 +13167,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12001,7 +13177,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12011,7 +13188,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_ "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12052,7 +13230,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri tab.resize_up(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -12061,7 +13240,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 1 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -12070,7 +13250,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 1 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -12080,7 +13261,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 1 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -12091,7 +13273,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12100,7 +13283,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12109,7 +13293,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12119,7 +13304,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12130,7 +13316,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12139,7 +13326,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 3 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12148,7 +13336,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 3 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12158,7 +13347,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 3 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12169,7 +13359,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -12178,7 +13369,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 4 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -12187,7 +13379,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 4 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -12197,7 +13390,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 4 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(4)) .unwrap() .position_and_size() @@ -12208,7 +13402,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -12217,7 +13412,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 5 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -12226,7 +13422,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 5 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -12236,7 +13433,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 5 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(5)) .unwrap() .position_and_size() @@ -12247,7 +13445,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -12256,7 +13455,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 6 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -12265,7 +13465,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 6 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -12275,7 +13476,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 6 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(6)) .unwrap() .position_and_size() @@ -12286,7 +13488,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -12295,7 +13498,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 7 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -12304,7 +13508,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 7 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -12314,7 +13519,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 7 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(7)) .unwrap() .position_and_size() @@ -12325,7 +13531,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12334,7 +13541,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 8 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12343,7 +13551,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 8 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12353,7 +13562,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri "pane 8 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(8)) .unwrap() .position_and_size() @@ -12382,7 +13592,8 @@ pub fn cannot_resize_up_when_pane_above_is_at_minimum_height() { tab.resize_down(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(1)) .unwrap() .position_and_size() @@ -12392,7 +13603,8 @@ pub fn cannot_resize_up_when_pane_above_is_at_minimum_height() { "pane 1 height stayed the same" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12438,7 +13650,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_left() { // should behave like `resize_left_with_pane_to_the_left` assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12447,7 +13660,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12472,7 +13686,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() { // should behave like `resize_left_with_multiple_panes_to_the_left` assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12481,7 +13696,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() { "pane 2 x position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12490,7 +13706,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() { "pane 2 y position" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12500,7 +13717,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() { "pane 2 column count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12524,7 +13742,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() { tab.resize_increase(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12533,7 +13752,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() { "Pane 3 y coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12542,7 +13762,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() { "Pane 3 x coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12552,7 +13773,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() { "Pane 3 row count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(3)) .unwrap() .position_and_size() @@ -12576,7 +13798,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() { tab.resize_increase(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12585,7 +13808,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() { "Pane 3 y coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12594,7 +13818,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() { "Pane 3 x coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12604,7 +13829,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() { "Pane 3 row count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12628,7 +13854,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current tab.resize_increase(1); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12637,7 +13864,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current "Pane 3 y coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12646,7 +13874,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current "Pane 3 x coordinate" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() @@ -12656,7 +13885,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current "Pane 3 row count" ); assert_eq!( - tab.panes + tab.tiled_panes + .panes .get(&PaneId::Terminal(2)) .unwrap() .position_and_size() diff --git a/zellij-server/src/unit/screen_tests.rs b/zellij-server/src/unit/screen_tests.rs index dd88d5eb..cf9b89b5 100644 --- a/zellij-server/src/unit/screen_tests.rs +++ b/zellij-server/src/unit/screen_tests.rs @@ -458,10 +458,9 @@ fn switch_to_tab_with_fullscreen() { screen .get_active_tab(1) .unwrap() - .active_panes - .get(&1) + .get_active_pane_id(1) .unwrap(), - &PaneId::Terminal(2), + PaneId::Terminal(2), "Active pane is still the fullscreen pane" ); }