path: root/zellij-server/src/panes/tiled_panes/stacked_panes.rs

use crate::{panes::PaneId, tab::Pane};
use zellij_utils::{
    errors::prelude::*,
    pane_size::{Dimension, PaneGeom},
};
use std::cell::RefCell;
use std::rc::Rc;
use std::collections::{HashMap, HashSet};

pub struct StackedPanes <'a>{
    panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>,
}

impl <'a>StackedPanes <'a>{
    pub fn new(panes: Rc<RefCell<HashMap<PaneId, &'a mut Box<dyn Pane>>>>) -> Self {
        StackedPanes {
            panes
        }
    }
    pub fn new_from_btreemap(
        panes: impl IntoIterator<Item = (&'a PaneId, &'a mut Box<dyn Pane>)>,
        panes_to_hide: &HashSet<PaneId>,
    ) -> Self {
        let panes: HashMap<_, _> = panes
            .into_iter()
            .filter(|(p_id, _)| !panes_to_hide.contains(p_id))
            .map(|(p_id, p)| (*p_id, p))
            .collect();
        let panes = Rc::new(RefCell::new(panes));
        StackedPanes {
            panes
        }
    }
    pub fn move_down(&mut self, source_pane_id: &PaneId, destination_pane_id: &PaneId) -> Result<()> {
        let err_context = || format!("Failed to move stacked pane focus down");
        let source_pane_is_stacked = self.panes.borrow().get(source_pane_id).with_context(err_context)?.position_and_size().is_stacked;
        let destination_pane_is_stacked = self.panes.borrow().get(destination_pane_id).with_context(err_context)?.position_and_size().is_stacked;
        if source_pane_is_stacked && destination_pane_is_stacked {
            let mut panes = self.panes.borrow_mut();
            let source_pane = panes.get_mut(source_pane_id).with_context(err_context)?;
            let mut source_pane_geom = source_pane.position_and_size();
            let mut destination_pane_geom = source_pane_geom.clone();
            destination_pane_geom.y = source_pane_geom.y + 1;
            source_pane_geom.rows = Dimension::fixed(1);
            source_pane.set_geom(source_pane_geom);
            let destination_pane = panes.get_mut(&destination_pane_id).with_context(err_context)?;
            destination_pane.set_geom(destination_pane_geom);
        } else if destination_pane_is_stacked {
            // we're moving down to the highest pane in the stack, we need to expand it and shrink the
            // expanded stack pane
            self.make_highest_pane_in_stack_flexible(destination_pane_id)?;
        }
        Ok(())
    }
    pub fn move_up(&mut self, source_pane_id: &PaneId, destination_pane_id: &PaneId) -> Result<()> {
        let err_context = || format!("Failed to move stacked pane focus up");
        let source_pane_is_stacked = self.panes.borrow().get(source_pane_id).with_context(err_context)?.position_and_size().is_stacked;
        let destination_pane_is_stacked = self.panes.borrow().get(destination_pane_id).with_context(err_context)?.position_and_size().is_stacked;
        if source_pane_is_stacked && destination_pane_is_stacked {
            let mut panes = self.panes.borrow_mut();
            let source_pane = panes.get_mut(source_pane_id).with_context(err_context)?;
            let mut source_pane_geom = source_pane.position_and_size();
            let mut destination_pane_geom = source_pane_geom.clone();
            source_pane_geom.y = (source_pane_geom.y + source_pane_geom.rows.as_usize()) - 1; // -1 because we want to be at the last line of the source pane, not the next line over
            source_pane_geom.rows = Dimension::fixed(1);
            source_pane.set_geom(source_pane_geom);
            destination_pane_geom.y -= 1;
            let destination_pane = panes.get_mut(&destination_pane_id).with_context(err_context)?;
            destination_pane.set_geom(destination_pane_geom);
        } else if destination_pane_is_stacked {
            // we're moving up to the lowest pane in the stack, we need to expand it and shrink the
            // expanded stack pane
            self.make_lowest_pane_in_stack_flexible(destination_pane_id)?;
        }
        Ok(())
    }
    pub fn focus_pane(&mut self, pane_id: &PaneId) -> Result<()> {
        // this function doesn't actually change the focus (since it is controlled elsewhere)
        // but rather makes sure pane_id is flexible if it were a one-liner before
        let err_context = || format!("Failed to focus stacked pane");
        let all_stacked_pane_positions = self.positions_in_stack(pane_id).with_context(err_context)?;

        let position_of_flexible_pane = self.position_of_flexible_pane(&all_stacked_pane_positions).with_context(err_context)?;
        let (flexible_pane_id, mut flexible_pane) = *all_stacked_pane_positions.iter().nth(position_of_flexible_pane).with_context(err_context)?;
        if flexible_pane_id != *pane_id {
            let mut panes = self.panes.borrow_mut();
            let height_of_flexible_pane = all_stacked_pane_positions.iter().nth(</