Struct PaneManager 

pub struct PaneManager { /* private fields */ }

Manages the pane tree within a single tab

Implementations

impl PaneManager

pub fn new() -> Self

Create a new empty pane manager

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 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, config: &Config, runtime: Arc<Runtime>, ) -> 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

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

pub fn next_pane_id(&self) -> PaneId

Get the next pane ID that will be assigned

pub fn add_pane_for_tmux(&mut self, pane: Pane)

Add a pane for tmux integration (doesn’t create split, just adds to flat structure)

This is used when tmux splits a pane - we need to add a new native pane without restructuring our tree (tmux layout update will handle that).

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 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 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 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)

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.

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

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)

Trait Implementations

impl Default for PaneManager

fn default() -> Self

Returns the “default value” for a type.