Struct Layout 

pub struct Layout { /* private fields */ }

A node in a layout tree. Mirrors rich.layout.Layout.

Implementations

impl Layout

pub fn new() -> Self

An empty layout (no renderable, so it shows the placeholder; no children).

pub fn with_renderable(renderable: Box<dyn Renderable>) -> Self

A leaf layout wrapping renderable.

pub fn name(self, name: impl Into<String>) -> Self

Name this layout, for get (upstream name).

pub fn visible(self, visible: bool) -> Self

Show or hide this layout (upstream visible, default on). A hidden child takes no space in its parent’s split.

pub fn size(self, size: usize) -> Self

Pin this region to a fixed size along its parent’s split axis.

pub fn ratio(self, ratio: usize) -> Self

Set the flex weight used when this region is unsized.

pub fn minimum_size(self, minimum_size: usize) -> Self

Set the minimum size this region may shrink to.

pub fn set_name(&mut self, name: Option<String>) -> &mut Self

Set (or clear) the name in place.

pub fn set_visible(&mut self, visible: bool) -> &mut Self

Set the visibility in place.

pub fn set_size(&mut self, size: Option<usize>) -> &mut Self

Set (or clear) the fixed size in place.

pub fn set_ratio(&mut self, ratio: usize) -> &mut Self

Set the ratio in place.

pub fn set_minimum_size(&mut self, minimum_size: usize) -> &mut Self

Set the minimum size in place.

pub fn get_name(&self) -> Option<&str>

The name, if any.

pub fn is_visible(&self) -> bool

Whether this layout is visible.

pub fn get_size(&self) -> Option<usize>

The fixed size, if any.

pub fn get_ratio(&self) -> usize

The ratio.

pub fn get_minimum_size(&self) -> usize

The minimum size.

pub fn splitter(&self) -> Splitter

The splitter dividing this layout among its children.

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

The leaf renderable, if one is set (none shows the placeholder).

pub fn update(&mut self, renderable: Box<dyn Renderable>)

Replace the leaf renderable. Port of Layout.update.

pub fn children(&self) -> Vec<&Layout>

The visible children (upstream’s children property).

pub fn all_children(&self) -> &[Layout]

Every child, hidden ones included (upstream _children).

pub fn all_children_mut(&mut self) -> &mut Vec<Layout>

Every child, mutably.

pub fn split(&mut self, children: Vec<Layout>, splitter: Splitter)

Split into children with splitter. Port of Layout.split.

pub fn split_column(&mut self, children: Vec<Layout>)

Split into children stacked vertically. Port of Layout.split_column.

pub fn split_row(&mut self, children: Vec<Layout>)

Split into children placed side by side. Port of Layout.split_row.

pub fn add_split(&mut self, children: Vec<Layout>)

Add children to the existing split. Port of Layout.add_split.

pub fn unsplit(&mut self)

Remove every child. Port of Layout.unsplit.

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

The first layout named name, depth first from this one. Port of Layout.get.

pub fn get_mut(&mut self, name: &str) -> Option<&mut Layout>

get, mutably.

pub fn at_path(&self, path: &[usize]) -> Option<&Layout>

The layout at path (child indexes, hidden children counted), as LayoutRender::path records it.

pub fn tree(&self) -> Tree

A tree renderable showing the layout’s structure. Port of Layout.tree.

pub fn region_map( &self, width: usize, height: usize, ) -> Vec<(Vec<usize>, Region)>

Every layout’s region for a width by height render, as (path, region) sorted by region. Port of Layout._make_region_map.

pub fn render_regions( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<LayoutRender>

Render every leaf into its region. Port of Layout.render: options give the width and (else the console’s) height.

pub fn refresh_screen( &self, console: &Console, layout_name: &str, ) -> Result<bool>

Render the layout named layout_name again and write it over its region of the alternate screen. Port of Layout.refresh_screen: the layout must be a leaf of the last render (upstream raises KeyError otherwise; here, Ok(false) and nothing is written), and the console must be in the alternate screen (RichError::NoAltScreen otherwise).

pub fn map(&self) -> Vec<LayoutRender>

The leaves of the last render. Port of Layout.map.

Trait Implementations

impl Default for Layout

fn default() -> Self

Returns the “default value” for a type.

impl Index<&str> for Layout

fn index(&self, name: &str) -> &Layout

layout[name]; panics as upstream raises KeyError when there is no such layout.

type Output = Layout

The returned type after indexing.

impl IndexMut<&str> for Layout

fn index_mut(&mut self, name: &str) -> &mut Layout

Performs the mutable indexing (container[index]) operation.

impl Renderable for Layout

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn measure(&self, _console: &Console, options: &ConsoleOptions) -> Measurement

The (minimum, maximum) cell width this renderable wants. The default assumes the renderable fills the available width (e.g. Panel, Table); Text overrides it with its content width so the top-level print path can shrink to fit. Port of __rich_measure__ / Measurement.get.

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.

fn vertical(&self) -> Option<VerticalAlign>

The vertical alignment a Table cell holding this renderable uses in place of its column’s. Upstream reads getattr(renderable, "vertical", None); Align sets it.