Enum PaneNode 

pub enum PaneNode {
    Leaf(Box<Pane>),
    Split {
        direction: SplitDirection,
        ratio: f32,
        first: Box<PaneNode>,
        second: Box<PaneNode>,
    },
}

Tree node for pane layout

The pane tree is a binary tree where:

• Leaf nodes contain actual terminal panes
• Split nodes contain two children with a split direction and ratio

Variants

Leaf(Box<Pane>)

A leaf node containing a terminal pane

Split

A split containing two child nodes

Fields

direction: SplitDirection

Direction of the split

ratio: f32

Split ratio (0.0 to 1.0) - position of divider For horizontal: ratio is height of first child / total height For vertical: ratio is width of first child / total width

first: Box<PaneNode>

First child (top for horizontal, left for vertical)

second: Box<PaneNode>

Second child (bottom for horizontal, right for vertical)

Implementations

impl PaneNode

pub fn leaf(pane: Pane) -> Self

Create a new leaf node with a pane

pub fn split( direction: SplitDirection, ratio: f32, first: PaneNode, second: PaneNode, ) -> Self

Create a new split node

pub fn is_leaf(&self) -> bool

Check if this is a leaf node

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

Get the pane if this is a leaf node

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

Get mutable pane if this is a leaf node

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

Find a pane by ID (recursive)

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

Find a mutable pane by ID (recursive)

pub fn find_pane_at(&self, x: f32, y: f32) -> Option<&Pane>

Find the pane at a given pixel position

pub fn all_pane_ids(&self) -> Vec<PaneId>

Get all pane IDs in this subtree

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

Get all panes in this subtree

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

Get all mutable panes in this subtree

pub fn pane_count(&self) -> usize

Count total number of panes

pub fn calculate_bounds(&mut self, bounds: PaneBounds, divider_width: f32)

Calculate bounds for all panes given the total available area

This recursively distributes space according to split ratios and updates each pane’s bounds field.

pub fn find_pane_in_direction( &self, from_id: PaneId, direction: NavigationDirection, ) -> Option<PaneId>

Find the closest pane in a given direction from the focused pane

Returns the pane ID of the closest pane in the specified direction, or None if there is no pane in that direction.

pub fn collect_dividers( &self, bounds: PaneBounds, divider_width: f32, ) -> Vec<DividerRect>

Collect all divider rectangles in the pane tree

Returns a list of DividerRect structures that can be used for:

• Rendering divider lines between panes
• Hit testing for mouse drag resize