Ratatui

https://docs.rs/ratatui/0.30.0/
Admin
Ratatui is a lightweight Rust crate for building terminal user interfaces with widgets, layouts,...
Tokens:1,394,170
Snippets:8,685
Trust Score:9.1
Update:1 day ago
Show doc for...
Tokens:
Raw
### flex with Flex::Start example

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

Creates a horizontal layout with three Length(20) constraints and sets flex behavior to Flex::Start, aligning items to the 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);
```

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

### List usage example

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

Example demonstrating how to create and configure a List widget.

```APIDOC
## List Usage Example

### Description
Example showing how to create a List widget with various fluent setters and render it.

### Code
```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);
```
```

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

### Run the RatatuiLogo example with optional size

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

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

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

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

### Material Palette Usage Example

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/style/palette/material/index.html

Example demonstrating how to use Material palette constants to access specific color shades.

```APIDOC
## Material Palette Usage Example

### Description
Demonstrates accessing Material palette color constants and their shade fields.

### Code Example
```rust
use ratatui_core::style::Color;
use ratatui_core::style::palette::material::{BLUE, RED};

assert_eq!(RED.c500, Color::Rgb(244, 67, 54));
assert_eq!(BLUE.c500, Color::Rgb(33, 150, 243));
```
```

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

### TestBackend usage example

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

Example of creating a TestBackend, clearing it, and asserting buffer lines. Uses the ? operator, so it must be used in a function that returns a Result.

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

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

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

### Simple closure example using ratatui::run

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.run.html

A minimal example where the app logic is contained in the closure passed to ratatui::run. It draws a widget and breaks on key press.

```rust
use crossterm::event;

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

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

### bg method example

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

Shows how to set the background color using Style::bg and patch. The example asserts that patching a style with a diff changes the background color to the diff's color.

```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));
```

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

### fg method example

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

Shows how to set the foreground color using Style::fg and patch. The example asserts that patching a style with a diff changes the foreground color to the diff's color.

```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));
```

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

### selected_mut example

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.ListState.html

Shows how to use the selected_mut method to get a mutable reference to the selected index and set it to Some(1).

```rust
use ratatui::widgets::ListState;

let mut state = ListState::default();
*state.selected_mut() = Some(1);
```

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

### Using convenience functions (recommended)

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

Modern approach using ratatui::run() to handle setup and teardown automatically. The closure receives a terminal and draws a Paragraph widget with 'Hello World!'.

```rust
// Modern approach using convenience functions
ratatui::run(|terminal| {
    terminal.draw(|frame| {
        let area = frame.area();
        frame.render_widget(Paragraph::new("Hello World!"), area);
    })?;
    Ok(())
})?;
```

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

### Get line width with width

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/struct.Line.html

Returns the width of the underlying string. The example creates a line from styled spans and asserts the width is 12.

```rust
use ratatui_core::style::Stylize;
use ratatui_core::text::Line;

let line = Line::from(vec!["Hello".blue(), " world!".green()]);
assert_eq!(12, line.width());
```

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

### try_init_with_options

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

Same as init_with_options but returns a Result instead of panicking.

```APIDOC
## try_init_with_options

### Description
Same as init_with_options but returns a Result instead of panicking.

### Function
`try_init_with_options`

### Parameters
- **options** (TerminalOptions) - Required - Custom terminal options.

### Returns
- `Result<DefaultTerminal, Error>` - A Result containing the terminal or an error.
```

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

### Getting a frame and rendering a widget with Terminal::get_frame

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

Use this example to access the frame buffer directly for unit testing widgets or buffer inspection. It creates a TestBackend, gets a frame, renders a Paragraph, and manually flushes and swaps buffers because draw is not used.

```rust
use ratatui::{backend::TestBackend, Terminal};
use ratatui::widgets::Paragraph;
let backend = TestBackend::new(30, 5);
let mut terminal = Terminal::new(backend).unwrap();
{
    let mut frame = terminal.get_frame();
    frame.render_widget(Paragraph::new("Hello"), frame.area());
}
// When not using `draw`, present the buffer manually:
terminal.flush().unwrap();
terminal.swap_buffers();
terminal.backend_mut().flush().unwrap();
```

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

### spacers example

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

Shows how to use `Layout::spacers` to get the spacers between areas. The number of constraints plus one must equal the returned array length, otherwise it panics. The example also shows explicitly specifying the number of spacers with `spacers::<3>`.

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

let area = Rect::new(0, 0, 10, 10);
let layout = Layout::vertical([Constraint::Length(1), Constraint::Fill(1)]);
let [top, main] = layout.areas(area);
let [before, inbetween, after] = layout.spacers(area);

// or explicitly specify the number of constraints:
let spacers = layout.spacers::<3>(area);
```

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

### Hello World example using ratatui::run

Source: https://docs.rs/ratatui/0.30.0/ratatui/

A minimal Ratatui application that renders the text "Hello World!" and exits when a key is pressed. Uses the ratatui::run helper and crossterm's event module.

```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(());
            }
        }
    })
}
```

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

### Standard full-screen initialization with init and try_init

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

Shows manual initialization and cleanup for full-screen apps. init panics on failure, while try_init returns a Result for custom error handling.

```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()?;
```

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

### Get max width of text lines with Text::width

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/struct.Text.html

Returns the maximum width of all lines in the Text. The example asserts that the width of a two-line text is 15.

```rust
use ratatui_core::text::Text;

let text = Text::from("The first line\nThe second line");
assert_eq!(15, text.width());
```

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

### Initialize and restore terminal with init() and try_init()

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html

Shows standard full-screen application setup: ratatui::init() panics on failure, while ratatui::try_init() returns a Result for custom error handling. Both are paired with their corresponding restore functions.

```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()?;
# Ok::<(), std::io::Error>(())
```

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

### select_first example

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.ListState.html

Shows how to use the select_first method to select the first item.

```rust
use ratatui::widgets::ListState;

let mut state = ListState::default();
state.select_first();
```

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

### Horizontal split_with_spacers with spacing example

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

Shows a horizontal layout with spacing(1) and ratio constraints. The resulting areas and spacers are asserted, demonstrating how the spacer between areas gets the configured width.

```rust
let (areas, spacers) = Layout::default()
    .direction(Direction::Horizontal)
    .spacing(1)
    .constraints([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)])
    .split_with_spacers(Rect::new(0, 0, 10, 2));
assert_eq!(areas[..], [Rect::new(0, 0, 3, 2), Rect::new(4, 0, 6, 2)]);
assert_eq!(
    spacers[..],
    [
        Rect::new(0, 0, 0, 2),
        Rect::new(3, 0, 1, 2),
        Rect::new(10, 0, 0, 2)
    ]
);
```

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

### index_of: Panic on out-of-bounds coordinates

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

This example panics because the top coordinate (0,0) is outside the buffer's area in global coordinate space, as the buffer's area starts at (200,100).

```rust
use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;

let buffer = Buffer::empty(Rect::new(200, 100, 10, 10));
// Top coordinate is outside of the buffer in global coordinate space, as the Buffer's area
// starts at (200, 100).
buffer.index_of(0, 0); // Panics
```

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

### init

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html

Initializes a terminal with reasonable defaults for standard full-screen applications. Installs a panic hook and enables alternate screen and raw mode.

```APIDOC
## init

### Description
Initializes a terminal with reasonable defaults for standard full-screen applications. This function enables alternate screen and raw mode, and installs a panic hook that restores the terminal state before panicking.

### Signature
```rust
pub fn init() -> DefaultTerminal
```

### Return Value
- `DefaultTerminal` - A terminal using the `CrosstermBackend` writing to `Stdout`.

### Panics
Panics if initialization fails.

### Notes
- Installs a panic hook that automatically restores the terminal state before panicking.
- Call this function *after* installing any other panic hooks to ensure the terminal is restored before other hooks run.
```

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

### Create Terminal with new and set panic hook

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

Creates a Terminal with a CrosstermBackend using Terminal::new. Unlike ratatui::init, this does not install a panic hook, so the example manually sets one to restore the terminal on panic.

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

use ratatui::{backend::CrosstermBackend, Terminal};

let backend = CrosstermBackend::new(stdout());
let terminal = Terminal::new(backend)?;

// Optionally set up a panic hook to restore the terminal on panic.
let old_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
    ratatui::restore();
    old_hook(info);
}));
```

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

### Using frame.count() to get current frame count

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/struct.Frame.html

Example from the documentation of Frame::count. It retrieves the current frame count and prints it. The count is a sequence number indicating how many frames have been rendered up to (but not including) this one, and wraps around at usize::MAX.

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

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

### try_init

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

Same as init but returns a Result instead of panicking.

```APIDOC
## try_init

### Description
Same as init but returns a Result instead of panicking.

### Function
`try_init`

### Parameters
None

### Returns
- `Result<DefaultTerminal, Error>` - A Result containing the terminal or an error.
```

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

### Indexing Buffer with tuple and Position

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

Shows how to use the Index implementation to get a Cell reference from a Buffer using a tuple (x, y) or a Position. Requires importing Buffer, Cell, Position, and Rect. The example creates a 10x10 empty buffer and indexes it.

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

let buf = Buffer::empty(Rect::new(0, 0, 10, 10));
let cell = &buf[(0, 0)];
let cell = &buf[Position::new(0, 0)];
```

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

### inner method: draw a block nested within another block

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.Block.html

Computes the inner area of a block after subtracting borders, titles, and padding. The example creates an outer and inner block, uses outer_block.inner(outer_area) to get the inner area, and renders both blocks.

```rust
use ratatui::Frame;
use ratatui::widgets::Block;

let outer_block = Block::bordered().title("Outer");
let inner_block = Block::bordered().title("Inner");

let outer_area = frame.area();
let inner_area = outer_block.inner(outer_area);

frame.render_widget(outer_block, outer_area);
frame.render_widget(inner_block, inner_area);
// Renders
// ┌Outer────────┐
// │┌Inner──────┐│
// ││           ││
// │└───────────┘│
// └─────────────┘
```

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

### Create a Table with rows, widths, and styling

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

Shows how to create a Table with rows and column widths, set column spacing, style the entire table, add a header and footer, wrap in a Block, and apply highlight styles and a selection symbol.

```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(">>");
```

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

### init_with_options

Source: https://docs.rs/ratatui/0.30.0/ratatui/

Initializes a terminal with the given options and reasonable defaults.

```APIDOC
## init_with_options

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

### Function
`init_with_options(options)`

### Parameters
- **options** (InitOptions) - Required - The options to use for initialization.

### Returns
- **Terminal** - The initialized terminal.

### Notes
- Requires the `crossterm` feature.
```

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

### Margin Usage Examples

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

Examples of using Margin with rectangles and layouts.

```APIDOC
## Margin Usage Examples

### Description
Demonstrates how to create and apply a Margin to a rectangle and use it with a layout.

### Example
```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);
```
```

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

### size() example: assert terminal size

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

Example for the size() method of the Backend trait. It asserts that the backend size equals Size::new(80, 25). The example is not tested.

```rust
use ratatui::{backend::Backend, layout::Size};

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

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

### ratatui::init

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html

Creates a terminal with reasonable defaults including alternate screen and raw mode. Panics on failure.

```APIDOC
## ratatui::init

### Description
Creates a terminal with reasonable defaults including alternate screen and raw mode. Panics on failure.

### Function Signature
`pub fn init() -> DefaultTerminal`

### Parameters
None.

### Return Value
- `DefaultTerminal` - A terminal instance with alternate screen and raw mode enabled.

### Example
```rust,no_run
let mut terminal = ratatui::init();
// ... app logic ...
ratatui::restore();
```
```

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

### init

Source: https://docs.rs/ratatui/0.30.0/ratatui/

Initializes a terminal with reasonable defaults for most applications.

```APIDOC
## init

### Description
Initializes a terminal with reasonable defaults for most applications.

### Function
`init()`

### Returns
- **Terminal** - The initialized terminal.

### Notes
- Requires the `crossterm` feature.
```

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

### Padding usage example

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

Example of using Padding constructors: uniform, horizontal, left, proportional, and symmetric.

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

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

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

### Create a Terminal with TermwizBackend

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

Shows how to create a TermwizBackend and a Terminal, then clear and draw on it. The backend automatically enables raw mode and enters 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 --
})?;
```

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

### Create a chart with multiple datasets

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

Example for Chart::new showing how to create a chart with two datasets.

```rust
use ratatui::widgets::{Chart, Dataset};

let data_points = vec![];
let data_points2 = vec![];
let chart = Chart::new(vec![
    Dataset::default().data(&data_points),
    Dataset::default().data(&data_points2),
]);
```

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

### Replace variant example

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

Example of using MergeStrategy::Replace, which replaces the previous symbol with the next one.

```rust
let strategy = MergeStrategy::Replace;
assert_eq!(strategy.merge("│", "━"), "━");
```

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

### Create TermionBackend with stdout

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

Shows the simplest way to create a TermionBackend using stdout as the writer. This example is not tested.

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

use ratatui::backend::TermionBackend;

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

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

### Position Construction and Conversion Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/struct.Position.html

Examples of constructing Position from various sources and converting it back to components.

```APIDOC
## Position Construction and Conversion Examples

### Description
Demonstrates the various ways to create a Position and convert it back to its components.

### Constructors
- `Position { x: i32, y: i32 }` - Direct struct initialization.
- `Position::new(x: i32, y: i32)` - Constructor method.
- `From<(i32, i32)>` - Conversion from a tuple.
- `From<Rect>` - Conversion from a Rect (uses its x and y coordinates).

### Conversions
- `Into<(i32, i32)>` - Converts the Position into a tuple of (x, y).

### Example
```rust
use ratatui_core::layout::{Position, Rect};

// the following are all equivalent
let position = Position { x: 1, y: 2 };
let position = Position::new(1, 2);
let position = Position::from((1, 2));
let position = Position::from(Rect::new(1, 2, 3, 4));

// position can be converted back into the components when needed
let (x, y) = position.into();
```
```

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

### try_init_with_options

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.try_init_with_options.html

Initializes a terminal with custom options, enabling raw mode and installing a panic hook. Returns a Result containing the DefaultTerminal or an error.

```APIDOC
## Function try_init_with_options

### Description
Try to initialize a terminal with the given options and reasonable defaults. This function allows the caller to specify a custom Viewport via the TerminalOptions. It will attempt to create a DefaultTerminal and initialize it with the given options and the following defaults: raw mode is enabled, and a panic hook is installed that restores the terminal before panicking. Unlike try_init, this function does not enter the alternate screen buffer. If any of these steps fail, the error is returned.

### Signature
```rust
pub fn try_init_with_options(
    options: TerminalOptions,
) -> Result<DefaultTerminal>
```

### Parameters
- **options** (TerminalOptions) - Required - The terminal options, including a custom Viewport.

### Returns
- **Result<DefaultTerminal>** - The initialized terminal or an error.

### Availability
Available on **crate feature `crossterm`** only.

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

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

### Notes
- Ensure that this method is called _after_ your app installs any other panic hooks to ensure the terminal is restored before the other hooks are called.
- Generally, you should use `init_with_options` instead of this function, as the panic hook installed by this function will ensure that any failures during initialization will restore the terminal before panicking. This function is provided for cases where you need to handle the error yourself.
- See the module-level documentation for a comparison of all initialization functions and guidance on when to use each one.
```

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

### render_widget example

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/struct.Frame.html

Example usage of Frame::render_widget to render a Block widget to a specified Rect area.

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

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

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

### Initializing terminal with ratatui::try_init

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html

Example from the try_init function documentation showing how to initialize a terminal with error handling using ratatui::try_init.

```rust
let terminal = ratatui::try_init()?;
# Ok::<(), std::io::Error>(())
```

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

### Example: ratatui::restore()

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

Example usage of the restore function. Call this before program exit to restore the terminal.

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

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

### TermwizBackend::new

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

Creates a new TermwizBackend instance. This method automatically enables raw mode and switches to the alternate screen.

```APIDOC
## TermwizBackend::new

### Description
Creates a new TermwizBackend instance. This method automatically enables raw mode and switches to the alternate screen.

### Method
Associated function

### Signature
`pub fn new() -> Result<TermwizBackend>`

### Parameters
None

### Returns
- `Result<TermwizBackend>` - A new TermwizBackend instance, or an error if initialization fails.

### Notes
- Automatically enables raw mode and switches to the alternate screen.
- When dropped, disables raw mode and returns to the main screen.
```

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

### has_modifier example

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

Checks if a style has a given modifier set. The example verifies BOLD and ITALIC are set, and UNDERLINED is not.

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

let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
assert!(style.has_modifier(Modifier::BOLD));
assert!(style.has_modifier(Modifier::ITALIC));
assert!(!style.has_modifier(Modifier::UNDERLINED));
```

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

### Buffer usage example

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

Example showing how to create an empty Buffer, index it with Position and tuple, use cell_mut and cell methods, and set a string with styling. Note the assertion for tuple indexing expects "x" but the symbol set is "B", which may be a typo in the source.

```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(), "x");

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

let cell = buf.cell(Position { x: 0, y: 2 })?;
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);
```

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

### offset example

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

Returns the index of the first row to be displayed. The example creates a new TableState and asserts that the offset is 0.

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

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

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

### try_init_with_options

Source: https://docs.rs/ratatui/0.30.0/ratatui/

Tries to initialize a terminal with the given options and reasonable defaults.

```APIDOC
## try_init_with_options

### Description
Tries to initialize a terminal with the given options and reasonable defaults.

### Function
`try_init_with_options(options)`

### Parameters
- **options** (InitOptions) - Required - The options to use for initialization.

### Returns
- **Result** - The result of the initialization.

### Notes
- Requires the `crossterm` feature.
```

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

### Sparkline Usage Example

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.Sparkline.html

Example demonstrating how to create and configure a Sparkline widget with block, data, max, direction, and styling.

```APIDOC
## Sparkline Usage Example

### Description
Example showing how to use the Sparkline widget with various setter methods.

### Code
```rust
use ratatui::style::{Color, Style, Stylize};
use ratatui::symbols;
use ratatui::widgets::{Block, RenderDirection, Sparkline};

Sparkline::default()
    .block(Block::bordered().title("Sparkline"))
    .data(&[0, 2, 3, 4, 1, 4, 10])
    .max(5)
    .direction(RenderDirection::RightToLeft)
    .style(Style::default().red().on_white())
    .absent_value_style(Style::default().fg(Color::Red))
    .absent_value_symbol(symbols::shade::FULL);
```

```

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

### Create a simple chart with one dataset

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

Example for Chart::new showing how to create a chart with a single empty dataset.

```rust
use ratatui::widgets::{Chart, Dataset};

let data_points = vec![];
let chart = Chart::new(vec![Dataset::default().data(&data_points)]);
```

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

### flex with Flex::Legacy example

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

Creates a horizontal layout with three Length(20) constraints and sets flex behavior to Flex::Legacy, stretching items equally to fill available space.

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

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

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

### Example usage: ratatui::try_restore()?;

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.try_restore.html

Example of calling try_restore with the '?' operator to propagate any error. This is used when you need to handle the error yourself.

```rust
ratatui::try_restore()?;
```
Tokens:
Raw