Struct ComponentArea 

pub struct ComponentArea(pub Rect);

Context type for component render area

This is provided by the renderer and consumed by components via use_area().

Implements Deref<Target = Rect> so you can access Rect methods directly:

use reratui::prelude::*;
use ratatui::layout::Margin;

let area = use_area();
let width = area.width;  // Direct access to Rect fields
let height = area.height;
let inner = area.inner(&Margin::new(1, 1));  // Call Rect methods

Tuple Fields

0: Rect

Methods from Deref<Target = Rect>

pub fn area(self) -> u32

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

pub fn is_empty(self) -> bool

Returns true if the Rect has no area.

pub fn left(self) -> u16

Returns the left coordinate of the Rect.

pub fn right(self) -> u16

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.

pub fn top(self) -> u16

Returns the top coordinate of the Rect.

pub fn bottom(self) -> u16

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.

pub fn inner(self, margin: Margin) -> Rect

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.

pub fn offset(self, offset: Offset) -> Rect

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.

pub fn union(self, other: Rect) -> Rect

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

pub fn intersection(self, other: Rect) -> Rect

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.

pub fn intersects(self, other: Rect) -> bool

Returns true if the two Rects intersect.

pub fn contains(self, position: Position) -> bool

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::layout::{Position, Rect};

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

pub fn clamp(self, other: Rect) -> Rect

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::{layout::Rect, Frame};

let area = frame.area();
let rect = Rect::new(0, 0, 100, 100).clamp(area);

pub fn rows(self) -> Rows

An iterator over rows within the Rect.

Example

use ratatui::{buffer::Buffer, layout::Rect, text::Line, widgets::Widget};

fn render(area: Rect, buf: &mut Buffer) {
    for row in area.rows() {
        Line::raw("Hello, world!").render(row, buf);
    }
}

pub fn columns(self) -> Columns

An iterator over columns within the Rect.

Example

use ratatui::{
    buffer::Buffer,
    layout::Rect,
    widgets::{Block, Borders, Widget},
};
fn render(area: Rect, buf: &mut Buffer) {
    if let Some(left) = area.columns().next() {
        Block::new().borders(Borders::LEFT).render(left, buf);
    }
}

pub fn positions(self) -> Positions

An iterator over the positions within the Rect.

The positions are returned in a row-major order (left-to-right, top-to-bottom).

Example

use ratatui::{buffer::Buffer, layout::Rect};

fn render(area: Rect, buf: &mut Buffer) {
    for position in area.positions() {
        buf[(position.x, position.y)].set_symbol("x");
    }
}

pub fn as_position(self) -> Position

Returns a Position with the same coordinates as this Rect.

Examples

use ratatui::layout::Rect;

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

pub fn as_size(self) -> Size

Converts the Rect into a size struct.

Trait Implementations

impl Clone for ComponentArea

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ComponentArea

impl Debug for ComponentArea

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

Formats the value using the given formatter.

impl Deref for ComponentArea

type Target = Rect

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Eq for ComponentArea

impl PartialEq for ComponentArea

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ComponentArea