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,
    },
}

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

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)

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

Find a split by ID (returns immutable reference)

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

Find the parent container of a given split node

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

Get all leaf nodes (buffer views) with their rectangles

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)

pub fn count_leaves(&self) -> usize

Count the number of leaf nodes (visible buffers)

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