Struct Block 

pub struct Block<W = Element> { /* private fields */ }

A widget that wrap another widget and adds border and title. A widget that wraps another widget and adds border and title.

Block is typically used to visualize separation and organize sections. You can customize the border style, type of the border and so on.

Example

let mut main = Block::horizontal()
    .title("Termint".fg(Color::Red))
    .border_type(BorderType::Double)
    .border_color(Color::LightGray);

let block1 = Block::vertical().title("Sub block");
main.add_child(block1, Constraint::Percent(50));
let block2 = Block::vertical().title("Another");
main.add_child(block2, Constraint::Percent(50));

let mut term = Term::new();
term.render(main)?;

Implementations

impl<W> Block<W>

where W: Widget,

pub fn new<T>(child: T) -> Self

where T: Into<Element>,

Returns a new Block wrapping the given widget, with all borders enabled and no title.

You can provide any type implementing the Widget trait.

pub fn title<T>(self, title: T) -> Self

where T: Into<Box<dyn Text>>,

Sets the Text title displayed at the top of the Block.

This is typically used for section labels in your TUI.

pub fn borders(self, borders: Border) -> Self

Sets the visible borders of the Block using the given Border flags.

Example

let block1 = Block::horizontal().borders(Border::TOP | Border::BOTTOM);
let block2 = Block::horizontal().borders(borders!(TOP, BOTTOM));

pub fn border_type(self, border_type: BorderType) -> Self

Sets the BorderType used to render the Block border.

pub fn border_style<T>(self, style: T) -> Self

where T: Into<Style>,

Sets the style applied to Block borders.

pub fn border_color(self, color: Color) -> Self

Sets the foreground color of the Block borders.

impl Block<Spacer>

pub fn empty() -> Self

Returns an empty Block with no title and all borders

impl Block<Layout>

pub fn vertical() -> Self

Returns a Block containing a vertical Layout as its child.

Very often you want to have a layout inside of a Block widget. This constructor makes it easier.

Example

// Creates block with vertical layout as its child
let block1: Block<Layout> = Block::new(Layout::vertical());
// Does the same, but shorter
let block2: Block<Layout> = Block::vertical();

pub fn horizontal() -> Self

Returns a Block containing a horizontal Layout as its child.

Very often you want to have a layout inside of a Block widget. This constructor makes it easier.

Example

// Creates block with horizontal layout as its child
let block1: Block<Layout> = Block::new(Layout::horizontal());
// Does the same, but shorter
let block2: Block<Layout> = Block::horizontal();

pub fn direction(self, direction: Direction) -> Self

Sets flexing Direction of the Layout.

pub fn style<T>(self, style: T) -> Self

where T: Into<Style>,

Sets the base style of the Layout.

pub fn bg<T>(self, bg: T) -> Self

where T: Into<Option<Color>>,

Sets base background color of the Layout.

pub fn fg<T>(self, fg: T) -> Self

where T: Into<Option<Color>>,

Sets base foreground color of the Layout.

pub fn padding<T>(self, padding: T) -> Self

where T: Into<Padding>,

Sets the Padding of the Layout.

pub fn center(self) -> Self

Makes Layout center its content in the direction it flexes.

If the layout is flexing its children horizontally, the content will be centered horizontally. Otherwise it will be centered vertically.

pub fn add_child<T, C>(&mut self, child: T, constraint: C)

where T: Into<Element>, C: Into<Constraint>,

👎Deprecated since 0.6.0: Kept for compatibility purposes; use push function instead

Adds child with its Constraint to Layout

pub fn push<T, C>(&mut self, child: T, constraint: C)

where T: Into<Element>, C: Into<Constraint>,

Adds a child widget with its contraint

Parameters

• child: The widget to add (any type convertible to Element)
• contraint: Widget’s contraint (any type convertible to Constraint)

Trait Implementations

impl<W: Debug> Debug for Block<W>

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

Formats the value using the given formatter.

impl<W> From<Block<W>> for Box<dyn Widget>

where W: Widget + 'static,

fn from(value: Block<W>) -> Self

Converts to this type from the input type.

impl<W> From<Block<W>> for Element

where W: Widget + 'static,

fn from(value: Block<W>) -> Self

Converts to this type from the input type.

impl<W> Widget for Block<W>

where W: Widget,

fn render(&self, buffer: &mut Buffer, rect: Rect, cache: &mut Cache)

Renders the widget into the given Buffer within the provided Rect bounds.

fn height(&self, size: &Vec2) -> usize

Returns the height of the Widget based on the width of the given size.

fn width(&self, size: &Vec2) -> usize

Returns the width of the Widget based on the height of the given size.

fn children(&self) -> Vec<&Element>

Gets widget’s children