Ratatui

https://docs.rs/ratatui/latest/ratatui/
Admin
Ratatui is a Rust library for building rich terminal user interfaces with widgets, layouts, styling,...
Tokens:271,706
Snippets:4,184
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start Flex Examples

Source: https://docs.rs/ratatui/latest/ratatui/layout/enum.Flex.html

Visual examples of items aligned to the start of the container.

```text
<------------------------------------80 px------------------------------------->
┌────16 px─────┐┌──────20 px───────┐┌──────20 px───────┐
│Percentage(20)││    Length(20)    ││     Fixed(20)    │
└──────────────┘└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌──────20 px───────┐┌──────20 px───────┐
│      Max(20)     ││      Max(20)     │
└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌──────20 px───────┐
│      Max(20)     │
└──────────────────┘
```

--------------------------------

### Initialize Terminal with TermwizBackend

Source: https://docs.rs/ratatui/latest/ratatui/backend/struct.TermwizBackend.html

Example showing how to initialize a Terminal using the TermwizBackend. This setup automatically enables raw mode and switches to the alternate screen.

```rust
use ratatui::Terminal;
use ratatui::backend::TermwizBackend;

let backend = TermwizBackend::new()?;
let mut terminal = Terminal::new(backend)?;

terminal.clear()?;
terminal.draw(|frame| {
    // -- snip --
})?;
```

--------------------------------

### Legacy Flex Examples

Source: https://docs.rs/ratatui/latest/ratatui/layout/enum.Flex.html

Visual examples of layout allocation under Legacy mode.

```text
<------------------------------------80 px------------------------------------->
┌──────────────────────────60 px───────────────────────────┐┌──────20 px───────┐
│                          Min(20)                         ││      Max(20)     │
└──────────────────────────────────────────────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌────────────────────────────────────80 px─────────────────────────────────────┐
│                                    Max(20)                                   │
└──────────────────────────────────────────────────────────────────────────────┘
```

--------------------------------

### Run Ratatui-logo example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.RatatuiLogo.html

Command to run the Ratatui-logo example from the repository with an optional size argument.

```bash
cargo run --example logo [size]
```

--------------------------------

### Size construction and usage examples

Source: https://docs.rs/ratatui/latest/ratatui/layout/struct.Size.html

Examples demonstrating how to create a Size instance using new and from, and how to calculate its area.

```rust
use ratatui_core::layout::{Rect, Size};

let size = Size::new(80, 24);
assert_eq!(size.area(), 1920);
let size = Size::from((80, 24));
let size = Size::from(Rect::new(0, 0, 80, 24));
assert_eq!(size.area(), 1920);
```

--------------------------------

### Render WidgetRef Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/trait.FrameExt.html

Example showing how to render a widget using the render_widget_ref method.

```rust
use ratatui::layout::Rect;
use ratatui::widgets::{Block, FrameExt};

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

--------------------------------

### Render StatefulWidgetRef Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/trait.FrameExt.html

Example showing how to render a stateful widget using the render_stateful_widget_ref method.

```rust
use ratatui::layout::Rect;
use ratatui::widgets::{FrameExt, 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_ref(&list, area, &mut state);
```

--------------------------------

### MergeStrategy usage examples

Source: https://docs.rs/ratatui/latest/ratatui/prelude/symbols/merge/enum.MergeStrategy.html

Basic usage examples demonstrating the behavior of different MergeStrategy variants.

```rust
assert_eq!(MergeStrategy::Replace.merge("│", "━"), "━");
assert_eq!(MergeStrategy::Exact.merge("│", "─"), "┼");
assert_eq!(MergeStrategy::Fuzzy.merge("┘", "╔"), "╬");
```

--------------------------------

### Padding configuration examples

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Padding.html

Common ways to instantiate Padding using its static methods.

```rust
use ratatui::widgets::Padding;

Padding::uniform(1);
Padding::horizontal(2);
Padding::left(3);
Padding::proportional(4);
Padding::symmetric(5, 6);
```

--------------------------------

### Assert Backend Size

Source: https://docs.rs/ratatui/latest/ratatui/backend/trait.Backend.html

Example demonstrating how to assert the size of a backend.

```rust
assert_eq!(backend.size()?, Size::new(80, 25));
```

--------------------------------

### Create and configure a Chart

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html

Example showing how to define datasets, configure axes, and assemble them into a Chart widget.

```rust
use ratatui::style::{Style, Stylize};
use ratatui::symbols;
use ratatui::widgets::{Axis, Block, Chart, Dataset, GraphType};

// Create the datasets to fill the chart with
let datasets = vec![
    // Scatter chart
    Dataset::default()
        .name("data1")
        .marker(symbols::Marker::Dot)
        .graph_type(GraphType::Scatter)
        .style(Style::default().cyan())
        .data(&[(0.0, 5.0), (1.0, 6.0), (1.5, 6.434)]),
    // Line chart
    Dataset::default()
        .name("data2")
        .marker(symbols::Marker::Braille)
        .graph_type(GraphType::Line)
        .style(Style::default().magenta())
        .data(&[(4.0, 5.0), (5.0, 8.0), (7.66, 13.5)]),
];

// Create the X axis and define its properties
let x_axis = Axis::default()
    .title("X Axis".red())
    .style(Style::default().white())
    .bounds([0.0, 10.0])
    .labels(["0.0", "5.0", "10.0"]);

// Create the Y axis and define its properties
let y_axis = Axis::default()
    .title("Y Axis".red())
    .style(Style::default().white())
    .bounds([0.0, 10.0])
    .labels(["0.0", "5.0", "10.0"]);

// Create the chart and link all the parts together
let chart = Chart::new(datasets)
    .block(Block::new().title("Chart"))
    .x_axis(x_axis)
    .y_axis(y_axis);
```

--------------------------------

### Execute Command Example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.TerminaBackend.html

Demonstrates executing a command directly using the execute method.

```rust
fn main() -> io::Result<()> {
     // will be executed directly
      io::stdout()
        .execute(Print("sum:\n".to_string()))?
        .execute(Print(format!("1 + 1= {} ", 1 + 1)))?;

      Ok(())

     // ==== Output ====
     // sum:
     // 1 + 1 = 2
}
```

--------------------------------

### Gauge example usage

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html

A basic example showing how to create a Gauge with a bordered block and custom styling.

```rust
use ratatui::style::{Style, Stylize};
use ratatui::widgets::{Block, Gauge};

Gauge::default()
    .block(Block::bordered().title("Progress"))
    .gauge_style(Style::new().white().on_black().italic())
    .percent(20);
```

--------------------------------

### Create a Style

Source: https://docs.rs/ratatui/latest/ratatui/prelude/style/struct.Style.html

Example of creating a Style using the default constructor and builder methods.

```rust
use ratatui_core::style::{Color, Modifier, Style};

Style::default()
    .fg(Color::Black)
    .bg(Color::Green)
    .add_modifier(Modifier::ITALIC | Modifier::BOLD);
```

--------------------------------

### Margin usage examples

Source: https://docs.rs/ratatui/latest/ratatui/layout/struct.Margin.html

Demonstrates creating a Margin instance and applying it to a Rect or a Layout.

```rust
use ratatui_core::layout::{Constraint, Layout, Margin, Rect};

// Create a margin of 2 cells horizontally and 1 cell vertically
let margin = Margin::new(2, 1);

// Apply directly to a rectangle
let area = Rect::new(0, 0, 80, 24);
let inner_area = area.inner(margin);

// Or use with a layout (which only accepts uniform margins)
let layout = Layout::vertical([Constraint::Fill(1)]).margin(2);
```

--------------------------------

### Style::bg method example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Style.html

Demonstrates how to set the background color of a Style and how patching affects it.

```rust
use ratatui_core::style::{Color, Style};

let style = Style::default().bg(Color::Blue);
let diff = Style::default().bg(Color::Red);
assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
```

--------------------------------

### Implementing StatefulWidgetRef

Source: https://docs.rs/ratatui/latest/ratatui/widgets/trait.StatefulWidgetRef.html

An example showing how to implement StatefulWidgetRef for a custom widget and how it relates to StatefulWidget.

```rust
use ratatui::widgets::StatefulWidgetRef;
use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;
use ratatui_core::style::Stylize;
use ratatui_core::text::Line;
use ratatui_core::widgets::{StatefulWidget, Widget};

struct PersonalGreeting;

impl StatefulWidgetRef for PersonalGreeting {
    type State = String;
    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        Line::raw(format!("Hello {}", state)).render(area, buf);
    }
}

impl StatefulWidget for PersonalGreeting {
    type State = String;
    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        (&self).render_ref(area, buf, state);
    }
}

fn render(area: Rect, buf: &mut Buffer) {
    let widget = PersonalGreeting;
    let mut state = "world".to_string();
    widget.render(area, buf, &mut state);
}
```

--------------------------------

### Style::fg method example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Style.html

Demonstrates how to set the foreground color of a Style and how patching affects it.

```rust
use ratatui_core::style::{Color, Style};

let style = Style::default().fg(Color::Blue);
let diff = Style::default().fg(Color::Red);
assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
```

--------------------------------

### Render a masked string

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Masked.html

Example showing how to create a Masked instance and render it to a buffer.

```rust
use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;
use ratatui_core::text::{Masked, Text};
use ratatui_core::widgets::Widget;

let mut buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
let password = Masked::new("12345", 'x');

Text::from(password).render(buffer.area, &mut buffer);
assert_eq!(buffer, Buffer::with_lines(["xxxxx"]));
```

--------------------------------

### Usage of restore

Source: https://docs.rs/ratatui/latest/ratatui/fn.restore.html

Example showing how to call the restore function to clean up the terminal state.

```rust
ratatui::restore();
```

--------------------------------

### ExecutableCommand Example

Source: https://docs.rs/ratatui/latest/ratatui/backend/struct.TerminaBackend.html

Demonstrates how to use the ExecutableCommand trait to execute a command directly on a writer.

```rust
use std::io;
use crossterm::{ExecutableCommand, style::Print};
```

--------------------------------

### Style::patch method example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Style.html

Demonstrates combining two styles using the patch method.

```rust
use ratatui_core::style::{Color, Modifier, Style};

let style_1 = Style::default().fg(Color::Yellow);
let style_2 = Style::default().bg(Color::Red);
let combined = style_1.patch(style_2);
assert_eq!(
    Style::default().patch(style_1).patch(style_2),
    Style::default().patch(combined)
);
```

--------------------------------

### Create a Hello World application

Source: https://docs.rs/ratatui/latest/ratatui/index.html

A basic example demonstrating how to run a terminal application that renders 'Hello World!' and exits on a key press.

```rust
use crossterm::event;

fn main() -> std::io::Result<()> {
    ratatui::run(|mut terminal| {
        loop {
            terminal.draw(|frame| frame.render_widget("Hello World!", frame.area()))?;
            if event::read()?.is_key_press() {
                break Ok(());
            }
        }
    })
}
```

--------------------------------

### Initialize TermionBackend with Terminal

Source: https://docs.rs/ratatui/latest/ratatui/backend/struct.TermionBackend.html

Demonstrates how to set up a terminal using TermionBackend with raw mode and alternate screen enabled.

```rust
use std::io::{stderr, stdout};

use ratatui::Terminal;
use ratatui::backend::TermionBackend;
use ratatui::termion::raw::IntoRawMode;
use ratatui::termion::screen::IntoAlternateScreen;

let writer = stdout().into_raw_mode()?.into_alternate_screen()?;
let mut backend = TermionBackend::new(writer);
// or
let writer = stderr().into_raw_mode()?.into_alternate_screen()?;
let backend = TermionBackend::new(stderr());
let mut terminal = Terminal::new(backend)?;

terminal.clear()?;
terminal.draw(|frame| {
    // -- snip --
})?;
```

--------------------------------

### Create a Dataset with custom configuration

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Dataset.html

This example demonstrates how to initialize a Dataset, set its name, provide data points, choose a marker type, set the graph type, and apply a red style.

```rust
use ratatui::style::Stylize;
use ratatui::symbols::Marker;
use ratatui::widgets::{Dataset, GraphType};

let dataset = Dataset::default()
    .name("dataset 1")
    .data(&[(1., 1.), (5., 5.)])
    .marker(Marker::Braille)
    .graph_type(GraphType::Line)
    .red();
```

--------------------------------

### Set Flex Alignment to Start

Source: https://docs.rs/ratatui/latest/ratatui/prelude/layout/struct.Layout.html

Aligns layout items to the start of the layout using Flex::Start.

```rust
use ratatui_core::layout::Constraint::*;
use ratatui_core::layout::{Flex, Layout};

let layout = Layout::horizontal([Length(20), Length(20), Length(20)]).flex(Flex::Start);
```

--------------------------------

### Create and configure a Table

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html

Demonstrates how to initialize a Table with rows and column constraints, and apply various styling and layout configurations.

```rust
use ratatui::layout::Constraint;
use ratatui::style::{Style, Stylize};
use ratatui::widgets::{Block, Row, Table};

let rows = [Row::new(vec!["Cell1", "Cell2", "Cell3"])];
// Columns widths are constrained in the same way as Layout...
let widths = [
    Constraint::Length(5),
    Constraint::Length(5),
    Constraint::Length(10),
];
let table = Table::new(rows, widths)
    // ...and they can be separated by a fixed spacing.
    .column_spacing(1)
    // You can set the style of the entire Table.
    .style(Style::new().blue())
    // It has an optional header, which is simply a Row always visible at the top.
    .header(
        Row::new(vec!["Col1", "Col2", "Col3"])
            .style(Style::new().bold())
            // To add space between the header and the rest of the rows, specify the margin
            .bottom_margin(1),
    )
    // It has an optional footer, which is simply a Row always visible at the bottom.
    .footer(Row::new(vec!["Updated on Dec 28"]))
    // As any other widget, a Table can be wrapped in a Block.
    .block(Block::new().title("Table"))
    // The selected row, column, cell and its content can also be styled.
    .row_highlight_style(Style::new().reversed())
    .column_highlight_style(Style::new().red())
    .cell_highlight_style(Style::new().blue())
    // ...and potentially show a symbol in front of the selection.
    .highlight_symbol(">>");
```

--------------------------------

### ratatui::init / ratatui::try_init

Source: https://docs.rs/ratatui/latest/ratatui/init/index.html

Creates a terminal with default settings, including alternate screen and raw mode.

```APIDOC
## fn init() -> DefaultTerminal
## fn try_init() -> std::io::Result<DefaultTerminal>

### Description
Initializes a terminal with reasonable defaults. `init` panics on failure, while `try_init` returns a `Result`.
```

--------------------------------

### Buffer usage examples

Source: https://docs.rs/ratatui/latest/ratatui/buffer/struct.Buffer.html

Demonstrates initializing a buffer, indexing with Position or tuples, safely accessing cells, and setting strings with styles.

```rust
use ratatui_core::buffer::{Buffer, Cell};
use ratatui_core::layout::{Position, Rect};
use ratatui_core::style::{Color, Style};

let mut buf = Buffer::empty(Rect {
    x: 0,
    y: 0,
    width: 10,
    height: 5,
});

// indexing using Position
buf[Position { x: 0, y: 0 }].set_symbol("A");
assert_eq!(buf[Position { x: 0, y: 0 }].symbol(), "A");

// indexing using (x, y) tuple (which is converted to Position)
buf[(0, 1)].set_symbol("B");
assert_eq!(buf[(0, 1)].symbol(), "B");

// getting an Option instead of panicking if the position is outside the buffer
let cell = buf
    .cell_mut(Position { x: 0, y: 2 })
    .ok_or("cell not found")?;
cell.set_symbol("C");

let cell = buf.cell(Position { x: 0, y: 2 }).ok_or("cell not found")?;
assert_eq!(cell.symbol(), "C");

buf.set_string(
    3,
    0,
    "string",
    Style::default().fg(Color::Red).bg(Color::White),
);
let cell = &buf[(5, 0)]; // cannot move out of buf, so we borrow it
assert_eq!(cell.symbol(), "r");
assert_eq!(cell.fg, Color::Red);
assert_eq!(cell.bg, Color::White);
```

--------------------------------

### set_span

Source: https://docs.rs/ratatui/latest/ratatui/buffer/struct.Buffer.html

Print a span, starting at the position (x, y).

```APIDOC
## pub fn set_span(&mut self, x: u16, y: u16, span: &Span<'_>, max_width: u16) -> (u16, u16)

### Description
Print a span, starting at the position (x, y).
```

--------------------------------

### List widget usage example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html

Demonstrates creating a List with items, a border, custom styles, a highlight symbol, and bottom-to-top direction.

```rust
use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::style::{Style, Stylize};
use ratatui::widgets::{Block, List, ListDirection, ListItem};

let items = ["Item 1", "Item 2", "Item 3"];
let list = List::new(items)
    .block(Block::bordered().title("List"))
    .style(Style::new().white())
    .highlight_style(Style::new().italic())
    .highlight_symbol(">>")
    .repeat_highlight_symbol(true)
    .direction(ListDirection::BottomToTop);

frame.render_widget(list, area);
```

--------------------------------

### set_line

Source: https://docs.rs/ratatui/latest/ratatui/buffer/struct.Buffer.html

Print a line, starting at the position (x, y).

```APIDOC
## pub fn set_line(&mut self, x: u16, y: u16, line: &Line<'_>, max_width: u16) -> (u16, u16)

### Description
Print a line, starting at the position (x, y).
```

--------------------------------

### set_string

Source: https://docs.rs/ratatui/latest/ratatui/buffer/struct.Buffer.html

Print a string, starting at the position (x, y).

```APIDOC
## pub fn set_string<T, S>(&mut self, x: u16, y: u16, string: T, style: S)

### Description
Print a string, starting at the position (x, y).
```

--------------------------------

### get_cursor

Source: https://docs.rs/ratatui/latest/ratatui/backend/trait.Backend.html

Gets the current cursor position (Deprecated).

```APIDOC
## fn get_cursor(&mut self) -> Result<(u16, u16), Self::Error>

### Description
Get the current cursor position on the terminal screen. Deprecated: use `get_cursor_position()` instead.
```

--------------------------------

### QuadrantInside Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the QuadrantInside border type.

```text
▗▄▄▄▄▄▄▄▖
▐       ▌
▐       ▌
▝▀▀▀▀▀▀▀▘
```

--------------------------------

### HeavyQuadrupleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the HeavyQuadrupleDashed border type.

```text
┏┉┉┉┉┉┉┉┓
┋       ┋
┗┉┉┉┉┉┉┉┛
```

--------------------------------

### Manual terminal setup and teardown

Source: https://docs.rs/ratatui/latest/ratatui/init/index.html

Use init/restore for manual control over terminal state. init panics on failure, while try_init returns a Result.

```rust
// Using init() - panics on failure
let mut terminal = ratatui::init();
// ... app logic ...
ratatui::restore();

// Using try_init() - returns Result for custom error handling
let mut terminal = ratatui::try_init()?;
// ... app logic ...
ratatui::try_restore()?;
```

--------------------------------

### LightQuadrupleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the LightQuadrupleDashed border type.

```text
┌┈┈┈┈┈┈┈┐
┊       ┊
└┈┈┈┈┈┈┈┘
```

--------------------------------

### init

Source: https://docs.rs/ratatui/latest/ratatui/index.html

Initializes a terminal with reasonable defaults for most applications.

```APIDOC
### init

Initialize a terminal with reasonable defaults for most applications.
```

--------------------------------

### HeavyTripleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the HeavyTripleDashed border type.

```text
┏┅┅┅┅┅┅┅┓
┇       ┇
┗┅┅┅┅┅┅┅┛
```

--------------------------------

### LightTripleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the LightTripleDashed border type.

```text
┌┄┄┄┄┄┄┄┐
┆       ┆
└┄┄┄┄┄┄┄┘
```

--------------------------------

### Initialize and verify TestBackend

Source: https://docs.rs/ratatui/latest/ratatui/backend/struct.TestBackend.html

Demonstrates creating a new TestBackend instance and using assertion methods to verify the buffer content.

```rust
use ratatui::backend::{Backend, TestBackend};

let mut backend = TestBackend::new(10, 2);
backend.clear()?;
backend.assert_buffer_lines(["          "; 2]);
```

--------------------------------

### HeavyDoubleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the HeavyDoubleDashed border type.

```text
┏╍╍╍╍╍╍╍┓
╏       ╏
┗╍╍╍╍╍╍╍┛
```

--------------------------------

### LightDoubleDashed Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the LightDoubleDashed border type.

```text
┌╌╌╌╌╌╌╌┐
╎       ╎
└╌╌╌╌╌╌╌┘
```

--------------------------------

### init_with_options

Source: https://docs.rs/ratatui/latest/ratatui/init/index.html

Initializes a terminal with specific options and reasonable defaults.

```APIDOC
## init_with_options

### Description
Initialize a terminal with the given options and reasonable defaults.
```

--------------------------------

### Span::style setter

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Span.html

Example of using the fluent style setter.

```rust
use ratatui_core::style::{Style, Stylize};
use ratatui_core::text::Span;
```

--------------------------------

### Span::content setter

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Span.html

Example of using the fluent content setter.

```rust
use ratatui_core::text::Span;

let mut span = Span::default().content("content");
```

--------------------------------

### QueueableCommand Example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.TerminaBackend.html

Demonstrates queuing commands for later execution using the queue method and flushing the buffer.

```rust
use std::io::{self, Write};
use crossterm::{QueueableCommand, style::Print};

 fn main() -> io::Result<()> {
    let mut stdout = io::stdout();

    // `Print` will executed executed when `flush` is called.
    stdout
        .queue(Print("foo 1\n".to_string()))?
        .queue(Print("foo 2".to_string()))?;

    // some other code (no execution happening here) ...

    // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed.
    stdout.flush()?;

    Ok(())
```

--------------------------------

### Create Layout with Layout::new

Source: https://docs.rs/ratatui/latest/ratatui/layout/struct.Layout.html

Shows various ways to initialize a layout using different directions and constraint inputs.

```rust
use ratatui_core::layout::{Constraint, Direction, Layout};

Layout::new(
    Direction::Horizontal,
    [Constraint::Length(5), Constraint::Fill(1)],
);

Layout::new(
    Direction::Vertical,
    [1, 2, 3].iter().map(|&c| Constraint::Length(c)),
);

Layout::new(Direction::Horizontal, vec![1, 2]);
```

--------------------------------

### Span::styled usage

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Span.html

Example of creating a Span with a specific style.

```rust
use ratatui_core::style::{Style, Stylize};
use ratatui_core::text::Span;

let style = Style::new().yellow().on_green().italic();
Span::styled("test content", style);
Span::styled(String::from("test content"), style);
```

--------------------------------

### Initialize Terminal with Viewports

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Terminal.html

Demonstrates how to initialize a terminal in fullscreen mode and a fixed region mode using TerminalOptions.

```rust
use ratatui::backend::CrosstermBackend;
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::{Terminal, TerminalOptions, Viewport};

// Fullscreen (most common):
let fullscreen = Terminal::new(CrosstermBackend::new(std::io::stdout()))?;

// Fixed region (your app manages the coordinates):
let viewport = Viewport::Fixed(Rect::new(0, 0, 30, 10));
let fixed = Terminal::with_options(
    CrosstermBackend::new(std::io::stdout()),
    TerminalOptions { viewport },
)?;

fixed.draw(|frame| {
    // Split the fixed viewport itself instead of assuming the viewport starts at `(0, 0)`.
    let [header, body] =
        Layout::vertical([Constraint::Length(1), Constraint::Min(0)]).areas(frame.area());

    frame.render_widget("Fixed panel header", header);
    frame.render_widget("Render the panel body relative to frame.area()", body);
})?;
```

--------------------------------

### Get TableState offset

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.TableState.html

Retrieves the index of the first row to be displayed.

```rust
use ratatui::widgets::TableState;

let state = TableState::new();
assert_eq!(state.offset(), 0);
```

--------------------------------

### Plain Border Example

Source: https://docs.rs/ratatui/latest/ratatui/widgets/enum.BorderType.html

Visual representation of the Plain border type, which is the default.

```text
┌───────┐
│       │
└───────┘
```

--------------------------------

### PROPORTIONAL_TALL visual representation

Source: https://docs.rs/ratatui/latest/ratatui/prelude/symbols/border/constant.PROPORTIONAL_TALL.html

A visual example of how the PROPORTIONAL_TALL border appears when rendered.

```text
▕█▀▀█
▕█xx█
▕█xx█
▕█▄▄█
```

--------------------------------

### Style::remove_modifier method example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Style.html

Demonstrates removing text modifiers from a Style.

```rust
use ratatui_core::style::{Modifier, Style};

let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
let diff = Style::default().remove_modifier(Modifier::ITALIC);
let patched = style.patch(diff);
assert_eq!(patched.add_modifier, Modifier::BOLD);
assert_eq!(patched.sub_modifier, Modifier::ITALIC);
```

--------------------------------

### ratatui::init_with_options / ratatui::try_init_with_options

Source: https://docs.rs/ratatui/latest/ratatui/init/index.html

Creates a terminal with custom options, such as inline viewports.

```APIDOC
## fn init_with_options(options: TerminalOptions) -> DefaultTerminal
## fn try_init_with_options(options: TerminalOptions) -> std::io::Result<DefaultTerminal>

### Description
Initializes a terminal using the provided `TerminalOptions`. `init_with_options` panics on failure, while `try_init_with_options` returns a `Result`.
```

--------------------------------

### Style::add_modifier method example

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Style.html

Demonstrates adding text modifiers to a Style.

```rust
use ratatui_core::style::{Modifier, Style};

let style = Style::default().add_modifier(Modifier::BOLD);
let diff = Style::default().add_modifier(Modifier::ITALIC);
let patched = style.patch(diff);
assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
assert_eq!(patched.sub_modifier, Modifier::empty());
```

--------------------------------

### Create a new TermionBackend

Source: https://docs.rs/ratatui/latest/ratatui/backend/struct.TermionBackend.html

Shows the basic instantiation of a TermionBackend using standard output.

```rust
use std::io::stdout;

use ratatui::backend::TermionBackend;

let backend = TermionBackend::new(stdout());
```

--------------------------------

### Get width of ListItem

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.ListItem.html

Calculates the width of a ListItem based on its content length.

```rust
use ratatui::widgets::ListItem;

let item = ListItem::new("12345");
assert_eq!(item.width(), 5);
```

--------------------------------

### Get height of single-line ListItem

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.ListItem.html

Verifies the height of a single-line ListItem is 1.

```rust
use ratatui::widgets::ListItem;

let item = ListItem::new("Item 1");
assert_eq!(item.height(), 1);
```

--------------------------------

### Initialize and use an Inline Viewport

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Terminal.html

Demonstrates initializing a terminal with an inline viewport of 10 lines and using insert_before to render content above the UI.

```rust
use ratatui::{TerminalOptions, Viewport};

println!("Some output above the UI");

let options = TerminalOptions {
    viewport: Viewport::Inline(10),
};
let mut terminal = ratatui::try_init_with_options(options)?;

terminal.insert_before(1, |buf| {
    // Render a single line of output into `buf` before the UI.
    // (For example: logs, status updates, or command output.)
})?;

terminal.draw(|frame| {
    // Continue rendering the inline UI relative to the inline viewport.
    frame.render_widget("inline ui", frame.area());
})?;
```

--------------------------------

### Initialize terminal with try_init

Source: https://docs.rs/ratatui/latest/ratatui/fn.try_init.html

A basic example showing how to call try_init and handle potential errors using the question mark operator.

```rust
let terminal = ratatui::try_init()?;
```

--------------------------------

### Get Styled Graphemes

Source: https://docs.rs/ratatui/latest/ratatui/prelude/struct.Span.html

Iterates over the graphemes of a Span, applying a base style to each.

```rust
use std::iter::Iterator;

use ratatui_core::style::{Style, Stylize};
use ratatui_core::text::{Span, StyledGrapheme};

let span = Span::styled("Test", Style::new().green().italic());
let style = Style::new().red().on_yellow();
assert_eq!(
    span.styled_graphemes(style)
        .collect::<Vec<StyledGrapheme>>(),
    vec![
        StyledGrapheme::new("T", Style::new().green().on_yellow().italic()),
        StyledGrapheme::new("e", Style::new().green().on_yellow().italic()),
        StyledGrapheme::new("s", Style::new().green().on_yellow().italic()),
        StyledGrapheme::new("t", Style::new().green().on_yellow().italic()),
    ],
);
```

--------------------------------

### current_buffer_mut

Source: https://docs.rs/ratatui/latest/ratatui/init/type.DefaultTerminal.html

Gets the current buffer as a mutable reference for direct cell access.

```APIDOC
## pub const fn current_buffer_mut(&mut self) -> &mut Buffer

### Description
Gets the current buffer as a mutable reference. This is a low-level escape hatch; normal applications should render inside `Terminal::draw`.
```

--------------------------------

### Initialize terminal with custom viewport options

Source: https://docs.rs/ratatui/latest/ratatui/fn.init_with_options.html

Demonstrates how to initialize a terminal using TerminalOptions with a specific Viewport configuration.

```rust
use ratatui::{TerminalOptions, Viewport};

let options = TerminalOptions {
    viewport: Viewport::Inline(5),
};
let terminal = ratatui::init_with_options(options);
```

--------------------------------

### Initialize and restore with init and restore

Source: https://docs.rs/ratatui/latest/ratatui/index.html

Provides manual control over terminal setup and teardown, useful when logic must surround the application closure.

```rust
fn main() -> std::io::Result<()> {
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal);
    ratatui::restore();
    result
}

fn run_app(terminal: &mut ratatui::DefaultTerminal) -> std::io::Result<()> {
    loop {
        terminal.draw(render)?;
        if should_quit()? {
            break Ok(());
        }
    }
}
```

--------------------------------

### BarChart Direction Examples

Source: https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html

Visual representation of vertical and horizontal bar chart directions.

```text
  █
█ █
f b
```

```text
█foo██

█bar██
```
Tokens:
Raw