Enum SplitNode 

pub enum SplitNode {
    Leaf {
        buffer_id: BufferId,
        split_id: LeafId,
    },
    Split {
        direction: SplitDirection,
        first: Box<Self>,
        second: Box<Self>,
        ratio: f32,
        split_id: ContainerId,
        fixed_first: Option<u16>,
        fixed_second: Option<u16>,
    },
    Grouped {
        split_id: LeafId,
        name: String,
        layout: Box<Self>,
        active_inner_leaf: LeafId,
    },
}

A node in the split tree

Variants

Leaf

Leaf node: displays a single buffer

Fields

buffer_id: BufferId

Which buffer to display

split_id: LeafId

Unique ID for this split pane

Split

Internal node: contains two child splits

Fields

direction: SplitDirection

Direction of the split

first: Box<Self>

First child (top or left)

second: Box<Self>

Second child (bottom or right)

ratio: f32

Size ratio (0.0 to 1.0) - how much space the first child gets 0.5 = equal split, 0.3 = first gets 30%, etc.

split_id: ContainerId

Unique ID for this split container

fixed_first: Option<u16>

If set, first child gets exactly this many rows/cols instead of using ratio

fixed_second: Option<u16>

If set, second child gets exactly this many rows/cols instead of using ratio

Grouped

A grouped subtree that appears as a single tab entry in its parent split’s tab bar. When that tab is active, the subtree is expanded and rendered inside the parent split’s content area. When inactive, the node is skipped during rect computation.

Fields

split_id: LeafId

Unique ID used as a tab target (see TabTarget::Group). Behaves like a LeafId — identifies this node uniquely.

name: String

Display name shown in the tab bar

layout: Box<Self>

The nested layout to render when this tab is active

active_inner_leaf: LeafId

The preferred active leaf within the layout (for focus when activating)

Implementations

impl SplitNode

pub fn leaf(buffer_id: BufferId, split_id: SplitId) -> Self

Create a new leaf node

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

Create a new split node with two children

pub fn id(&self) -> SplitId

Get the split ID for this node

pub fn buffer_id(&self) -> Option<BufferId>

Get the buffer ID if this is a leaf node

pub fn find_mut(&mut self, target_id: SplitId) -> Option<&mut Self>

Find a split by ID (returns mutable reference). Grouped nodes are found by their split_id, and their inner layout is searched as well.

pub fn find(&self, target_id: SplitId) -> Option<&Self>

Find a split by ID (returns immutable reference). Grouped nodes are found by their split_id, and their inner layout is searched as well.

pub fn parent_container_of(&self, target_id: SplitId) -> Option<ContainerId>

Find the parent container of a given split node. For a node inside a Grouped subtree, returns the container within the subtree (not the Grouped node itself).

pub fn grouped_ancestor_of(&self, target_id: SplitId) -> Option<LeafId>

Find the Grouped ancestor node that contains a given target id (by walking into Grouped subtrees). Returns the Grouped node’s own split_id if found.

pub fn find_grouped(&self, target: LeafId) -> Option<&Self>

Find the Grouped node whose split_id matches target. Returns a reference to the Grouped node (or None).

pub fn get_leaves_with_rects(&self, rect: Rect) -> Vec<(LeafId, BufferId, Rect)>

Get all leaf nodes (buffer views) with their rectangles.

Grouped nodes always recurse into their inner layout — the layout’s leaves get the full rect that would have been given to the Grouped node. Visibility (which group is “active”) is applied elsewhere.

pub fn get_visible_leaves_with_rects<F>( &self, rect: Rect, is_group_active: &F, ) -> Vec<(LeafId, BufferId, Rect)>

where F: Fn(LeafId) -> bool,

Walk the tree using an “active group” predicate. For each Grouped node encountered, the predicate is called with the Grouped node’s split_id; if it returns true, the node’s layout is recursed into (with the Grouped node’s rect). If false, the Grouped node and its subtree are skipped entirely (not rendered).

pub fn get_separators(&self, rect: Rect) -> Vec<(SplitDirection, u16, u16, u16)>

Get all split separator lines (for rendering borders) Returns (direction, x, y, length) tuples

pub fn get_separators_with_ids( &self, rect: Rect, ) -> Vec<(ContainerId, SplitDirection, u16, u16, u16)>

Get all split separator lines with their split IDs (for mouse hit testing) Returns (split_id, direction, x, y, length) tuples

pub fn all_split_ids(&self) -> Vec<SplitId>

Collect all split IDs in the tree

pub fn leaf_split_ids(&self) -> Vec<LeafId>

Collect only leaf split IDs (visible buffer splits, not container nodes). For Grouped nodes, returns the inner layout’s leaves.

pub fn count_leaves(&self) -> usize

Count the number of leaf nodes (visible buffers). Grouped subtrees count their inner leaves.

pub fn collect_group_names(&self) -> HashMap<LeafId, String>

Collect display names for all Grouped nodes in the tree, keyed by their LeafId (which is what TabTarget::Group points to).

Trait Implementations

impl Clone for SplitNode

fn clone(&self) -> SplitNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SplitNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SplitNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SplitNode

fn eq(&self, other: &SplitNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SplitNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SplitNode