Struct Frame 

pub struct Frame<'a> { /* private fields */ }

A consistent view into the terminal state for rendering a single frame.

This is obtained via the closure argument of Terminal::draw. It is used to render widgets to the terminal and control the cursor position.

The changes drawn to the frame are applied only to the current Buffer. After the closure returns, the current buffer is compared to the previous buffer and only the changes are applied to the terminal. This avoids drawing redundant cells.

Implementations

impl Frame<'_>

pub const fn area(&self) -> Rect

The area of the current frame

This is guaranteed not to change during rendering, so may be called multiple times.

If your app listens for a resize event from the backend, it should ignore the values from the event for any calculations that are used to render the current frame and use this value instead as this is the area of the buffer that is used to render the current frame.

pub const fn size(&self) -> Rect

👎Deprecated: use area() instead

The area of the current frame

This is guaranteed not to change during rendering, so may be called multiple times.

If your app listens for a resize event from the backend, it should ignore the values from the event for any calculations that are used to render the current frame and use this value instead as this is the area of the buffer that is used to render the current frame.

pub fn render_widget<W: Widget>(&mut self, widget: W, area: Rect)

Render a Widget to the current buffer using Widget::render.

Usually the area argument is the size of the current frame or a sub-area of the current frame (which can be obtained using Layout to split the total area).

Example

use ratatui::{layout::Rect, widgets::Block};

let block = Block::new();
let area = Rect::new(0, 0, 5, 5);
frame.render_widget(block, area);

pub fn render_stateful_widget<W>( &mut self, widget: W, area: Rect, state: &mut W::State, )

where W: StatefulWidget,

Render a StatefulWidget to the current buffer using StatefulWidget::render.

Usually the area argument is the size of the current frame or a sub-area of the current frame (which can be obtained using Layout to split the total area).

The last argument should be an instance of the StatefulWidget::State associated to the given StatefulWidget.

Example

use ratatui::{
    layout::Rect,
    widgets::{List, ListItem, ListState},
};

let mut state = ListState::default().with_selected(Some(1));
let list = List::new(vec![ListItem::new("Item 1"), ListItem::new("Item 2")]);
let area = Rect::new(0, 0, 5, 5);
frame.render_stateful_widget(list, area, &mut state);

pub fn set_cursor_position<P: Into<Position>>(&mut self, position: P)

After drawing this frame, make the cursor visible and put it at the specified (x, y) coordinates. If this method is not called, the cursor will be hidden.

Note that this will interfere with calls to Terminal::hide_cursor, Terminal::show_cursor, and Terminal::set_cursor_position. Pick one of the APIs and stick with it.

pub fn set_cursor(&mut self, x: u16, y: u16)

👎Deprecated: use set_cursor_position((x, y)) instead which takes impl Into<Position>

After drawing this frame, make the cursor visible and put it at the specified (x, y) coordinates. If this method is not called, the cursor will be hidden.

Note that this will interfere with calls to Terminal::hide_cursor, Terminal::show_cursor, and Terminal::set_cursor_position. Pick one of the APIs and stick with it.

pub const fn buffer_mut(&mut self) -> &mut Buffer

Gets the buffer that this Frame draws into as a mutable reference.

pub const fn count(&self) -> usize

Returns the current frame count.

This method provides access to the frame count, which is a sequence number indicating how many frames have been rendered up to (but not including) this one. It can be used for purposes such as animation, performance tracking, or debugging.

Each time a frame has been rendered, this count is incremented, providing a consistent way to reference the order and number of frames processed by the terminal. When count reaches its maximum value (usize::MAX), it wraps around to zero.

This count is particularly useful when dealing with dynamic content or animations where the state of the display changes over time. By tracking the frame count, developers can synchronize updates or changes to the content with the rendering process.

Examples

let current_count = frame.count();
println!("Current frame count: {}", current_count);

Trait Implementations

impl<'a> Debug for Frame<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Frame<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.