Struct RectCopy item path

Creates a new Rect, with width and height limited to keep both bounds within u16.

If the width or height would cause the right or bottom coordinate to be larger than the maximum value of u16, the width or height will be clamped to keep the right or bottom coordinate within u16.

§Examples

use ratatui_core::layout::Rect;

let rect = Rect::new(1, 2, 3, 4);

The area of the Rect. If the area is larger than the maximum value of u16, it will be clamped to u16::MAX.

Returns true if the Rect has no area.

Returns the left coordinate of the Rect.

Returns the right coordinate of the Rect. This is the first coordinate outside of the Rect.

If the right coordinate is larger than the maximum value of u16, it will be clamped to u16::MAX.

Returns the top coordinate of the Rect.

Returns the bottom coordinate of the Rect. This is the first coordinate outside of the Rect.

If the bottom coordinate is larger than the maximum value of u16, it will be clamped to u16::MAX.

Returns a new Rect inside the current one, with the given margin on each side.

If the margin is larger than the Rect, the returned Rect will have no area.

Returns a new Rect outside the current one, with the given margin applied on each side.

If the margin causes the Rect’s bounds to outsdie the range of a u16, the Rect will be truncated to keep the bounds within u16. This will cause the size of the Rect to change.

The generated Rect may not fit inside the buffer or containing area, so it consider constraining the resulting Rect with Rect::clamp before using it.

Moves the Rect without modifying its size.

Moves the Rect according to the given offset without modifying its width or height.

• Positive x moves the whole Rect to the right, negative to the left.
• Positive y moves the whole Rect to the bottom, negative to the top.

See Offset for details.

Returns a new Rect that contains both the current one and the given one.

Returns a new Rect that is the intersection of the current one and the given one.

If the two Rects do not intersect, the returned Rect will have no area.

Returns true if the two Rects intersect.

Returns true if the given position is inside the Rect.

The position is considered inside the Rect if it is on the Rect’s border.

§Examples

use ratatui_core::layout::{Position, Rect};

let rect = Rect::new(1, 2, 3, 4);
assert!(rect.contains(Position { x: 1, y: 2 }));

Clamp this Rect to fit inside the other Rect.

If the width or height of this Rect is larger than the other Rect, it will be clamped to the other Rect’s width or height.

If the left or top coordinate of this Rect is smaller than the other Rect, it will be clamped to the other Rect’s left or top coordinate.

If the right or bottom coordinate of this Rect is larger than the other Rect, it will be clamped to the other Rect’s right or bottom coordinate.

This is different from Rect::intersection because it will move this Rect to fit inside the other Rect, while Rect::intersection instead would keep this Rect’s position and truncate its size to only that which is inside the other Rect.

§Examples

use ratatui_core::layout::Rect;

let area = Rect::new(0, 0, 100, 100);
let rect = Rect::new(80, 80, 30, 30).clamp(area);
assert_eq!(rect, Rect::new(70, 70, 30, 30));

An iterator over rows within the Rect.

Each row is a full Rect region with height 1 that can be used for rendering widgets or as input to further layout methods.

§Example

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::{Constraint, Layout, Rect};
use ratatui_core::widgets::Widget;

fn render_list(area: Rect, buf: &mut Buffer) {
    // Renders "Item 0", "Item 1", etc. in each row
    for (i, row) in area.rows().enumerate() {
        format!("Item {i}").render(row, buf);
    }
}

fn render_with_nested_layout(area: Rect, buf: &mut Buffer) {
    // Splits each row into left/right areas and renders labels and content
    for (i, row) in area.rows().take(3).enumerate() {
        let [left, right] =
            Layout::horizontal([Constraint::Percentage(30), Constraint::Fill(1)]).areas(row);

        format!("{i}:").render(left, buf);
        "Content".render(right, buf);
    }
}

An iterator over columns within the Rect.

Each column is a full Rect region with width 1 that can be used for rendering widgets or as input to further layout methods.

§Example

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;
use ratatui_core::widgets::Widget;

fn render_columns(area: Rect, buf: &mut Buffer) {
    // Renders column indices (0-9 repeating) in each column
    for (i, column) in area.columns().enumerate() {
        format!("{}", i % 10).render(column, buf);
    }
}

An iterator over the positions within the Rect.

The positions are returned in a row-major order (left-to-right, top-to-bottom). Each position is a Position that represents a single cell coordinate.

§Example

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::{Position, Rect};
use ratatui_core::widgets::Widget;

fn render_positions(area: Rect, buf: &mut Buffer) {
    // Renders position indices (0-9 repeating) at each cell position
    for (i, position) in area.positions().enumerate() {
        buf[position].set_symbol(&format!("{}", i % 10));
    }
}

Returns a Position with the same coordinates as this Rect.

§Examples

use ratatui_core::layout::Rect;

let rect = Rect::new(1, 2, 3, 4);
let position = rect.as_position();

Converts the Rect into a size struct.

Returns a new Rect, centered horizontally based on the provided constraint.

§Examples

use ratatui_core::layout::Constraint;
use ratatui_core::terminal::Frame;

fn render(frame: &mut Frame) {
    let area = frame.area().centered_horizontally(Constraint::Ratio(1, 2));
}

Returns a new Rect, centered vertically based on the provided constraint.

§Examples

use ratatui_core::layout::Constraint;
use ratatui_core::terminal::Frame;

fn render(frame: &mut Frame) {
    let area = frame.area().centered_vertically(Constraint::Ratio(1, 2));
}

Returns a new Rect, centered horizontally and vertically based on the provided constraints.

§Examples

use ratatui_core::layout::Constraint;
use ratatui_core::terminal::Frame;

fn render(frame: &mut Frame) {
    let area = frame
        .area()
        .centered(Constraint::Ratio(1, 2), Constraint::Ratio(1, 3));
}

Split the rect into a number of sub-rects according to the given Layout.

An ergonomic wrapper around Layout::split that returns an array of Rects instead of Rc<[Rect]>.

This method requires the number of constraints to be known at compile time. If you don’t know the number of constraints at compile time, use Layout::split instead.

§Panics

Panics if the number of constraints is not equal to the length of the returned array.

§Examples

use ratatui_core::layout::{Constraint, Layout, Rect};

let area = Rect::new(0, 0, 10, 10);
let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
let [top, main] = area.layout(&layout);
assert_eq!(top, Rect::new(0, 0, 10, 1));
assert_eq!(main, Rect::new(0, 1, 10, 9));

// or explicitly specify the number of constraints:
let areas = area.layout::<2>(&layout);
assert_eq!(areas, [Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);

Split the rect into a number of sub-rects according to the given Layout.

An ergonomic wrapper around Layout::split that returns a Vec of Rects instead of Rc<[Rect]>.

§Examples

use ratatui_core::layout::{Constraint, Layout, Rect};

let area = Rect::new(0, 0, 10, 10);
let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
let areas = area.layout_vec(&layout);
assert_eq!(areas, vec![Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);

Try to split the rect into a number of sub-rects according to the given Layout.

An ergonomic wrapper around Layout::split that returns an array of Rects instead of Rc<[Rect]>.

§Errors

Returns an error if the number of constraints is not equal to the length of the returned array.

§Examples

use ratatui_core::layout::{Constraint, Layout, Rect};

let area = Rect::new(0, 0, 10, 10);
let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
let [top, main] = area.try_layout(&layout)?;
assert_eq!(top, Rect::new(0, 0, 10, 1));
assert_eq!(main, Rect::new(0, 1, 10, 9));

// or explicitly specify the number of constraints:
let areas = area.try_layout::<2>(&layout)?;
assert_eq!(areas, [Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.