Struct Layout 

pub struct Layout {
    pub root: LayoutNode,
    pub visible: bool,
    pub minimum_size: usize,
    pub renderables: HashMap<String, DynRenderable>,
    pub splitters: Vec<Box<dyn Splitter>>,
    /* private fields */
}

The Layout compute engine. Assigns screen regions to a tree of layout nodes by recursively splitting available space.

Fields

root: LayoutNode

The root LayoutNode defining the split hierarchy.

visible: bool

Whether the layout is visible.

minimum_size: usize

Minimum size for any region.

renderables: HashMap<String, DynRenderable>

Named renderables for leaf nodes.

splitters: Vec<Box<dyn Splitter>>

Active splitters for dividing regions among children.

Implementations

impl Layout

pub fn new(root: LayoutNode) -> Self

Create a new layout with the given root node.

pub fn from_renderable( name: impl Into<String>, renderable: impl Renderable + Send + Sync + 'static, ) -> Self

Create a new layout from a named renderable (single-pane leaf).

This is a convenience constructor that wraps the renderable in a leaf node with the given name.

pub fn split(&mut self, direction: Direction) -> &mut LayoutNode

Split the current root node into the given direction.

The existing root becomes the first child of the new split, and a new empty leaf is added as the second child. Returns a mutable reference to the root node.

pub fn unsplit(&mut self)

Remove the split at the root. If the root is a split, it is replaced with its first child. If the root is already a leaf, this is a no-op.

pub fn split_column(&mut self) -> &mut Self

Convenience: split the root into a column layout (horizontal split).

pub fn split_row(&mut self) -> &mut Self

Convenience: split the root into a row layout (vertical split).

pub fn add_split( &mut self, renderable: impl Renderable + Send + Sync + 'static, ratio: usize, ) -> usize

Add a child pane with a renderable and a ratio weight.

If the root is already a Split node, the new child is appended. If the root is a Leaf, it is first converted to a Split containing the old leaf and the new child.

Returns the pane ID (index of the new child in the children list).

pub fn renderable(&self) -> Option<&dyn Renderable>

Get the root renderable (if the root is a leaf and has a renderable).

pub fn children(&self) -> &[LayoutNode]

Get child layout nodes (if the root is a split).

pub fn splitters(&self) -> Vec<&dyn Splitter>

Get the active splitters.

pub fn tree(&self) -> &LayoutNode

Get the layout tree root.

pub fn map(&mut self, f: impl Fn(&dyn Renderable) -> DynRenderable)

Apply a function to all leaf renderables, replacing each with the result.

pub fn get(&self, name: &str) -> Option<&dyn Renderable>

Get a named renderable from the tree.

pub fn update( &mut self, name: &str, renderable: impl Renderable + Send + Sync + 'static, ) -> bool

Update a named renderable, returning true if it existed.

pub fn refresh_screen(&mut self, console: &mut Console)

Refresh the layout on screen by re-rendering all visible regions.

Computes the layout for the current terminal size and renders each leaf’s renderable into the console.

pub fn compute( &self, total_width: usize, total_height: usize, ) -> Vec<(String, Region)>

Compute region assignments by recursively splitting the given area.

Returns a list of (name, region) pairs for each leaf node in the layout tree.

Trait Implementations

impl Debug for Layout

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

Formats the value using the given formatter.