Struct PaneManager 

pub struct PaneManager { /* private fields */ }

Manages the pane tree within a single tab

Implementations

impl PaneManager

pub fn create_initial_pane( &mut self, config: &Config, runtime: Arc<Runtime>, working_directory: Option<String>, ) -> Result<PaneId>

Create the initial pane (when tab is first created)

If bounds have been set on the PaneManager via set_bounds(), the pane will be created with dimensions calculated from those bounds. Otherwise, the default config dimensions are used.

pub fn create_initial_pane_for_split( &mut self, direction: SplitDirection, config: &Config, runtime: Arc<Runtime>, working_directory: Option<String>, ) -> Result<PaneId>

Create the initial pane sized for an upcoming split

This calculates dimensions based on what the pane size will be AFTER the split, preventing the shell from seeing a resize.

pub fn split( &mut self, direction: SplitDirection, focus_new: bool, config: &Config, runtime: Arc<Runtime>, initial_command: Option<(String, Vec<String>)>, ratio: f32, ) -> Result<Option<PaneId>>

Split the focused pane in the given direction

Returns the ID of the new pane, or None if no pane is focused.

initial_command — when Some((cmd, args)) the new pane launches that process directly instead of the login shell. The pane closes when the process exits.

impl PaneManager

pub fn close_pane(&mut self, id: PaneId) -> bool

Close a pane by ID

Returns true if this was the last pane (tab should close)

pub fn navigate(&mut self, direction: NavigationDirection)

Navigate to a pane in the given direction

pub fn focus_pane(&mut self, id: PaneId)

Focus a specific pane by ID

pub fn focus_pane_at(&mut self, x: f32, y: f32) -> Option<PaneId>

Focus the pane at a given pixel position

pub fn focused_pane(&self) -> Option<&Pane>

Get the currently focused pane

pub fn focused_pane_mut(&mut self) -> Option<&mut Pane>

Get the currently focused pane mutably

pub fn focused_pane_id(&self) -> Option<PaneId>

Get the focused pane ID

impl PaneManager

pub fn set_bounds(&mut self, bounds: PaneBounds)

Set the total bounds available for panes and recalculate layout

pub fn recalculate_bounds(&mut self)

Recalculate bounds for all panes

pub fn resize_all_terminals(&self, cell_width: f32, cell_height: f32)

Resize all pane terminals to match their current bounds

This should be called after bounds are updated (split, resize, window resize) to ensure each PTY is sized correctly for its pane area.

pub fn resize_all_terminals_with_padding( &self, cell_width: f32, cell_height: f32, padding: f32, height_offset: f32, )

Resize all terminal PTYs to match their pane bounds, accounting for padding.

The padding reduces the content area where text is rendered, so terminals should be sized for the padded (smaller) area to avoid content being cut off.

height_offset is an additional height reduction (e.g., pane title bar height) subtracted once from each pane’s content height.

pub fn set_divider_width(&mut self, width: f32)

Set the divider width

pub fn divider_width(&self) -> f32

Get the divider width

pub fn divider_hit_padding(&self) -> f32

Get the hit detection padding (extra area around divider for easier grabbing)

pub fn resize_split(&mut self, pane_id: PaneId, delta: f32)

Resize a split by adjusting its ratio

pane_id: The pane whose adjacent split should be resized delta: Amount to adjust the ratio (-1.0 to 1.0)

pub fn get_dividers(&self) -> Vec<DividerRect>

Get all divider rectangles in the pane tree

pub fn find_divider_at(&self, x: f32, y: f32, padding: f32) -> Option<usize>

Find a divider at the given position

Returns the index of the divider if found, with optional padding for easier grabbing

pub fn is_on_divider(&self, x: f32, y: f32) -> bool

Check if a position is on a divider

pub fn set_divider_hit_width(&mut self, width: f32)

Set the divider hit width

pub fn get_divider(&self, index: usize) -> Option<DividerRect>

Get the divider at an index

pub fn drag_divider(&mut self, divider_index: usize, new_x: f32, new_y: f32)

Resize by dragging a divider to a new position

divider_index: Which divider is being dragged new_position: New mouse position (x for vertical, y for horizontal dividers)

impl PaneManager

pub fn build_from_layout( &mut self, layout: &SessionPaneNode, config: &Config, runtime: Arc<Runtime>, ) -> Result<()>

Build a pane tree from a saved session layout

Recursively constructs live PaneNode tree from a SessionPaneNode, creating new terminal panes for each leaf. If a leaf’s CWD no longer exists, falls back to $HOME.

impl PaneManager

pub fn set_from_tmux_layout( &mut self, layout: &TmuxLayout, config: &Config, runtime: Arc<Runtime>, ) -> Result<HashMap<TmuxPaneId, PaneId>>

Set the pane tree from a tmux layout

This replaces the entire pane tree with one constructed from the tmux layout. Returns a mapping of tmux pane IDs to native pane IDs.

Arguments

• layout - The parsed tmux layout
• config - Configuration for creating panes
• runtime - Async runtime for pane tasks

pub fn rebuild_from_tmux_layout( &mut self, layout: &TmuxLayout, existing_mappings: &HashMap<TmuxPaneId, PaneId>, new_tmux_panes: &[TmuxPaneId], config: &Config, runtime: Arc<Runtime>, ) -> Result<HashMap<TmuxPaneId, PaneId>>

Rebuild the pane tree from a tmux layout, preserving existing pane terminals

This is called when panes are added or the layout structure changes. It rebuilds the entire tree structure to match the tmux layout while reusing existing Pane objects to preserve their terminal state.

Arguments

• layout - The parsed tmux layout
• existing_mappings - Map from tmux pane ID to native pane ID for panes to preserve
• new_tmux_panes - List of new tmux pane IDs that need new Pane objects
• config - Configuration for creating new panes
• runtime - Async runtime for new pane tasks

Returns

Updated mapping of tmux pane IDs to native pane IDs

impl PaneManager

pub fn update_layout_from_tmux( &mut self, layout: &TmuxLayout, pane_mappings: &HashMap<TmuxPaneId, PaneId>, )

Update the layout structure (ratios) from a tmux layout without recreating terminals

This is called when the tmux pane IDs haven’t changed but the layout dimensions have (e.g., due to resize or another client connecting). It updates the split ratios in our pane tree to match the tmux layout.

pub fn update_from_tmux_layout( &mut self, layout: &TmuxLayout, existing_mappings: &HashMap<TmuxPaneId, PaneId>, config: &Config, runtime: Arc<Runtime>, ) -> Result<Option<HashMap<TmuxPaneId, PaneId>>>

Update an existing pane tree to match a new tmux layout

This tries to preserve existing panes where possible and only creates/destroys panes as needed.

Returns updated mappings (Some = new mappings, None = no changes needed)

impl PaneManager

pub fn new() -> Self

Create a new empty pane manager

pub fn new_with_existing_terminal( terminal: Arc<RwLock<TerminalManager>>, working_directory: Option<String>, is_active: Arc<AtomicBool>, ) -> Self

Create a pane manager pre-populated with a single primary pane that wraps an already-running TerminalManager.

This is used by Tab::new_internal so that every tab always starts with a PaneManager (R-32). The primary pane shares the caller’s terminal Arc, so no new shell process is spawned.

Arguments

• terminal — Arc cloned from Tab::terminal
• working_directory — Optional CWD for the primary pane
• is_active — Shared atomic cloned from Tab::is_active

pub fn new_with_pane(pane: Pane) -> Self

Create a pane manager wrapping an existing Pane as the single root node.

Used by Tab::new_from_pane() when promoting a pane to its own tab. The pane’s ID is preserved and next_pane_id is advanced past it.

pub fn with_initial_pane( config: &Config, runtime: Arc<Runtime>, working_directory: Option<String>, ) -> Result<Self>

Create a pane manager with an initial pane

pub fn next_pane_id(&self) -> PaneId

Get the next pane ID that will be assigned

pub fn get_pane(&self, id: PaneId) -> Option<&Pane>

Get a pane by ID

pub fn get_pane_mut(&mut self, id: PaneId) -> Option<&mut Pane>

Get a mutable pane by ID

pub fn all_panes(&self) -> Vec<&Pane>

Get all panes

pub fn all_panes_mut(&mut self) -> Vec<&mut Pane>

Get all panes mutably

pub fn collect_pane_backgrounds(&self) -> Vec<PaneBackgroundConfig>

Collect current per-pane background settings for config persistence

Returns a Vec<PaneBackgroundConfig> containing only panes that have a custom background image set. The index field corresponds to the pane’s position in the tree traversal order.

pub fn pane_count(&self) -> usize

Get the number of panes

pub fn has_multiple_panes(&self) -> bool

Check if there are multiple panes

pub fn root(&self) -> Option<&PaneNode>

Get access to the root node (for rendering)

pub fn root_mut(&mut self) -> Option<&mut PaneNode>

Get mutable access to the root node

pub fn insert_subtree_at( &mut self, target_pane_id: PaneId, subtree: PaneNode, direction: SplitDirection, ratio: f32, ) -> Result<PaneIdRemap, PaneNode>

Insert a PaneNode subtree into the tree by splitting the target pane.

The target leaf is replaced with a Split containing the original pane as one child and the subtree as the other. Bounds are recalculated.

On success, returns the ids the adopted panes hold afterwards, which are not always the ids they arrived with.

On failure — there is no tree here to insert into, or no pane holds target_pane_id — the tree is left untouched and the subtree is handed back, carrying the ids it arrived with. Handing it back is the point of the Err, not a courtesy: a caller gets a subtree to pass here by detaching it from wherever it was living, so this is the only remaining reference to those panes, and dropping it closes them and kills their PTYs. The caller must put it back somewhere.

A subtree arriving from another tab (“Demote Tab to Pane”) brings that tab’s ids with it, and ids are allocated per PaneManager — that is, per tab — so an incoming id can already belong to a pane here: tab A’s panes 1 and 2 landing in a tab that already holds 1 and 2. get_pane is a search over the tree, so a duplicate would make every id-keyed lookup resolve to whichever pane the walk reaches first, and the adopted pane would be unreachable. Colliding panes are therefore renumbered from this manager’s counter.

Advancing the counter past every adopted id closes the other half: this tab must not later hand a new pane an id one of the adopted panes is already using.

A caller holding an id from the subtree across this call must translate it through the returned map; the pre-move id may now name a different pane, or no pane at all.

pub fn extract_pane(&mut self, target_id: PaneId) -> ExtractResult

Extract a pane from the tree by ID, returning ownership of the live Pane.

Unlike remove_pane() which drops the pane, this returns the pane intact so it can be transferred to another tab or pane tree. All processes in the pane’s PTY continue running.

pub fn take_root(&mut self) -> Option<PaneNode>

Take ownership of the root node, leaving None in its place.

Used by demote (tab → pane) to extract the entire pane tree for transplantation into another tab.

pub fn set_root(&mut self, node: PaneNode)

Replace the root node (drops any existing tree).

Used after extract_pane when the remaining tree needs to be restored and the default ExtractResult::Extracted.remaining has already been taken by the caller.

Trait Implementations

impl Default for PaneManager

fn default() -> Self

Returns the “default value” for a type.