Struct SplitManager 

pub struct SplitManager { /* private fields */ }

Manager for the split view system

Implementations

impl SplitManager

pub fn new(buffer_id: BufferId) -> Self

Create a new split manager with a single buffer

pub fn root(&self) -> &SplitNode

Get the root split node

pub fn allocate_split_id(&mut self) -> SplitId

Allocate a new unique split ID

pub fn replace_root(&mut self, new_root: SplitNode, new_active: LeafId)

Replace the root split tree. The new tree must have unique IDs (allocated via allocate_split_id). The caller must also provide the new active leaf ID.

pub fn active_split(&self) -> LeafId

Get the currently active split ID

pub fn set_active_split(&mut self, split_id: LeafId) -> bool

Set the active split (must be a leaf)

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

Get the buffer ID of the active split (if it’s a leaf)

pub fn get_buffer_id(&self, split_id: SplitId) -> Option<BufferId>

Get the buffer ID for a specific split (if it’s a leaf)

pub fn set_active_buffer_id(&mut self, new_buffer_id: BufferId) -> bool

Update the buffer ID of the active split

pub fn set_split_buffer(&mut self, leaf_id: LeafId, new_buffer_id: BufferId)

Update the buffer ID of a specific leaf split

pub fn split_active( &mut self, direction: SplitDirection, new_buffer_id: BufferId, ratio: f32, ) -> Result<LeafId, String>

Split the currently active pane

pub fn split_active_before( &mut self, direction: SplitDirection, new_buffer_id: BufferId, ratio: f32, ) -> Result<LeafId, String>

Split the active pane, placing the new buffer before (left/top) the existing content. ratio still controls the first child’s proportion of space.

pub fn split_active_positioned( &mut self, direction: SplitDirection, new_buffer_id: BufferId, ratio: f32, before: bool, ) -> Result<LeafId, String>

pub fn split_root_positioned( &mut self, direction: SplitDirection, new_buffer_id: BufferId, ratio: f32, before: bool, ) -> Result<LeafId, String>

Split the root of the tree (rather than the active leaf), so the new leaf becomes a sibling of the entire existing layout. Used by the Utility Dock so the dock spans the full width below any pre-existing horizontal-axis splits, instead of nesting under whichever pane happened to be active.

ratio controls the first child’s proportion. before = false places the new leaf after (right/bottom) the existing root.

pub fn close_split(&mut self, split_id: LeafId) -> Result<(), String>

Close a split pane (if not the last one)

pub fn remove_grouped(&mut self, target: LeafId) -> Result<(), String>

Remove a Grouped node from the tree by its split_id. Unlike close_split which requires a leaf, this removes a whole Grouped subtree (tab) from the split structure. The Grouped node is replaced with… well, nothing — so this can only succeed if the Grouped is inside a Split (so we can replace the Split with its sibling) or if the root itself is the Grouped (which we can’t remove without a replacement).

pub fn adjust_ratio(&mut self, container_id: ContainerId, delta: f32)

Adjust the split ratio of a container

pub fn parent_container_of(&self, leaf_id: LeafId) -> Option<ContainerId>

Find the parent container of a leaf

pub fn get_visible_buffers( &self, viewport_rect: Rect, ) -> Vec<(LeafId, BufferId, Rect)>

Get all visible buffer views with their rectangles

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

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

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

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

pub fn get_ratio(&self, split_id: SplitId) -> Option<f32>

Get the current ratio of a split container

pub fn set_ratio(&mut self, container_id: ContainerId, new_ratio: f32)

Set the exact ratio of a split container

pub fn set_fixed_size( &mut self, container_id: ContainerId, first: Option<u16>, second: Option<u16>, )

Set a fixed size on a split container’s first or second child. When set, the child gets exactly this many rows/cols instead of using the ratio.

pub fn distribute_splits_evenly(&mut self)

Distribute all visible splits evenly This sets the ratios of all container splits so that leaf splits get equal space

pub fn next_split(&mut self)

Navigate to the next split (circular)

pub fn prev_split(&mut self)

Navigate to the previous split (circular)

pub fn splits_for_buffer(&self, target_buffer_id: BufferId) -> Vec<LeafId>

Get all split IDs that display a specific buffer

pub fn buffer_for_split(&self, target_split_id: LeafId) -> Option<BufferId>

Get the buffer ID for a specific leaf split

pub fn maximize_split(&mut self) -> Result<(), String>

Maximize the active split (hide all other splits temporarily) Returns Ok(()) if successful, Err if there’s only one split

pub fn unmaximize_split(&mut self) -> Result<(), String>

Unmaximize the currently maximized split (restore all splits) Returns Ok(()) if successful, Err if no split is maximized

pub fn is_maximized(&self) -> bool

Check if a split is currently maximized

pub fn maximized_split(&self) -> Option<SplitId>

Get the currently maximized split ID (if any)

pub fn toggle_maximize(&mut self) -> Result<bool, String>

Toggle maximize state for the active split If maximized, unmaximize. If not maximized, maximize. Returns true if maximized, false if ununmaximized.

pub fn get_splits_in_group( &self, group_id: u32, view_states: &HashMap<LeafId, SplitViewState>, ) -> Vec<LeafId>

Get all leaf split IDs that belong to a specific sync group

pub fn set_label(&mut self, split_id: LeafId, label: String)

Set a label on a leaf split (e.g., “sidebar”)

pub fn clear_label(&mut self, split_id: SplitId)

Remove a label from a split

pub fn get_label(&self, split_id: SplitId) -> Option<&str>

Get the label for a split (if any)

pub fn labels(&self) -> &HashMap<SplitId, String>

Get all split labels (for workspace serialization)

pub fn set_leaf_role(&mut self, split_id: LeafId, new_role: Option<SplitRole>)

Set the role tag on a leaf. No-op if split_id is not a leaf. Caller is responsible for the “at most one leaf per role” invariant — call clear_role on the previous holder first.

pub fn find_leaf_by_role(&self, target: SplitRole) -> Option<LeafId>

Find the unique leaf carrying the given role, if any.

pub fn clear_role(&mut self, target: SplitRole) -> Option<LeafId>

Clear any leaf currently carrying the given role. Returns the leaf id whose role was cleared, if one was found. Used to enforce the “at most one leaf per role” invariant when transferring a role.

pub fn find_split_by_label(&self, label: &str) -> Option<LeafId>

Find the first leaf split with the given label

pub fn find_unlabeled_leaf(&self) -> Option<LeafId>

Find the first leaf split without a label

Trait Implementations

impl Debug for SplitManager

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

Formats the value using the given formatter.