### Automatic Terminal Setup

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

Use the run function for the simplest setup, which handles automatic terminal initialization and cleanup.

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

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

### Start Flex Alignment Examples

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

Visual representations of items aligned to the start of the container using the Start variant.

```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)     │
└──────────────────┘
```

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

### Basic Usage

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.try_init.html?search=

Example of initializing the terminal using try_init.

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

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

### Search example for Option mapping

Source: https://docs.rs/ratatui/0.30.0/ratatui/style/palette/tailwind/constant.YELLOW.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example search query demonstrating functional mapping syntax.

```rust
Option<T>, (T -> U) -> Option<U>
```

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

### Initialize Padding Examples

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

Demonstrates various ways to initialize 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);
```

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

### Legacy constraint examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/layout/enum.Flex.html?search=u32+-%3E+bool

Examples showing how constraints interact under the Legacy flex strategy.

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

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

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

### Buffer Diffing Multi-width Character Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/buffer/struct.Buffer.html?search=std%3A%3Avec

Examples illustrating how the diffing algorithm handles multi-width characters during buffer updates.

```text
(Index:) `01`
Prev:    `コ`
Next:    `aa`
Updates: `0: a, 1: a'
```

```text
(Index:) `01`
Prev:    `a `
Next:    `コ`
Updates: `0: コ` (double width symbol at index 0 - skip index 1)
```

```text
(Index:) `012`
Prev:    `aaa`
Next:    `aコ`
Updates: `0: a, 1: コ` (double width symbol at index 1 - skip index 2)
```

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

### List Widget Usage

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.List.html?search=u32+-%3E+bool

Example demonstrating how to instantiate and configure a List widget with various fluent setters.

```APIDOC
## List Widget

### Description
A widget to display several items among which one can be selected. It supports automatic height determination and can be rendered in reverse order.

### Fluent Setters
- **highlight_style**: Sets the style of the selected item.
- **highlight_symbol**: Sets the symbol to be displayed in front of the selected item.
- **repeat_highlight_symbol**: Sets whether to repeat the symbol and style over selected multi-line items.
- **direction**: Sets the list direction (e.g., TopToBottom, BottomToTop).

### Example
```rust
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"))
    .highlight_style(Style::new().italic())
    .highlight_symbol(">>")
    .repeat_highlight_symbol(true)
    .direction(ListDirection::BottomToTop);
```
```

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

### Initialize terminal with convenience functions

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

Use the recommended high-level API to handle setup and teardown automatically.

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

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

### Create a simple BarChart

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

Shows the minimal setup required to initialize a BarChart with a collection of Bar instances.

```rust
use ratatui::widgets::{Bar, BarChart};

BarChart::new([Bar::with_label("A", 10), Bar::with_label("B", 20)]);
```

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

### Initialize a Terminal with CrosstermBackend

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/backend/index.html

Demonstrates the standard setup for a terminal using the Crossterm backend.

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

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

let backend = CrosstermBackend::new(stdout());
let mut terminal = Terminal::new(backend)?;
terminal.clear()?;
terminal.draw(|frame| {
    // -- snip --
})?;
```

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

### Implement and use a stateful List widget

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/trait.StatefulWidget.html?search=std%3A%3Avec

Example demonstrating how to manage application state with ListState and render it using render_stateful_widget.

```rust
use std::io;

use ratatui::{
    backend::TestBackend,
    widgets::{List, ListItem, ListState, StatefulWidget, Widget},
    Terminal,
};

// Let's say we have some events to display.
struct Events {
    // `items` is the state managed by your application.
    items: Vec<String>,
    // `state` is the state that can be modified by the UI. It stores the index of the selected
    // item as well as the offset computed during the previous draw call (used to implement
    // natural scrolling).
    state: ListState,
}

impl Events {
    fn new(items: Vec<String>) -> Events {
        Events {
            items,
            state: ListState::default(),
        }
    }

    pub fn set_items(&mut self, items: Vec<String>) {
        self.items = items;
        // We reset the state as the associated items have changed. This effectively reset
        // the selection as well as the stored offset.
        self.state = ListState::default();
    }

    // Select the next item. This will not be reflected until the widget is drawn in the
    // `Terminal::draw` callback using `Frame::render_stateful_widget`.
    pub fn next(&mut self) {
        let i = match self.state.selected() {
            Some(i) => {
                if i >= self.items.len() - 1 {
                    0
                } else {
                    i + 1
                }
            }
            None => 0,
        };
        self.state.select(Some(i));
    }

    // Select the previous item. This will not be reflected until the widget is drawn in the
    // `Terminal::draw` callback using `Frame::render_stateful_widget`.
    pub fn previous(&mut self) {
        let i = match self.state.selected() {
            Some(i) => {
                if i == 0 {
                    self.items.len() - 1
                } else {
                    i - 1
                }
            }
            None => 0,
        };
        self.state.select(Some(i));
    }

    // Unselect the currently selected item if any. The implementation of `ListState` makes
    // sure that the stored offset is also reset.
    pub fn unselect(&mut self) {
        self.state.select(None);
    }
}


let mut events = Events::new(vec![String::from("Item 1"), String::from("Item 2")]);

loop {
    terminal.draw(|f| {
        // The items managed by the application are transformed to something
        // that is understood by ratatui.
        let items: Vec<ListItem> = events
            .items
            .iter()
            .map(|i| ListItem::new(i.as_str()))
            .collect();
        // The `List` widget is then built with those items.
        let list = List::new(items);
        // Finally the widget is rendered using the associated state. `events.state` is
        // effectively the only thing that we will "remember" from this draw call.
        f.render_stateful_widget(list, f.size(), &mut events.state);
    });
}
```

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

### Define and implement StatefulWidgetRef

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

Example showing the definition of a custom widget implementing StatefulWidgetRef and the corresponding StatefulWidget implementation.

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

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

### MergeStrategy Usage Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/symbols/merge/enum.MergeStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates basic usage of different merge strategies to combine symbols.

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

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

### Construct and use Size

Source: https://docs.rs/ratatui/0.30.0/ratatui/layout/struct.Size.html?search=

Examples of creating Size instances from various sources and calculating the total 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);
```

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

### Run Ratatui logo example

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

Command to run the Ratatui logo example from the repository.

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

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

### Initialize a Terminal with TermionBackend

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

Demonstrates setting up a terminal using stdout or stderr 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 Hello World TUI application

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

A minimal example demonstrating how to initialize a terminal and render a widget using the Ratatui run loop.

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

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

### Buffer Usage Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/buffer/struct.Buffer.html?search=std%3A%3Avec

Demonstrates how to initialize a buffer, index cells using positions or tuples, and set string content 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(), "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);
```

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

### Create and Configure a Table

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

Demonstrates initializing a Table with rows and column constraints, including styling, headers, footers, and selection highlights.

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

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

### Exact Strategy Example

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/symbols/merge/enum.MergeStrategy.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows the Exact strategy, which attempts to find a composite unicode character or falls back to replacement.

```rust
let strategy = MergeStrategy::Exact;
assert_eq!(strategy.merge("│", "━"), "┿"); // exact match exists
assert_eq!(strategy.merge("┘", "╔"), "╔"); // no exact match, falls back to Replace
```

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

### size

Source: https://docs.rs/ratatui/0.30.0/ratatui/backend/struct.TermionBackend.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the terminal size.

```APIDOC
## fn size(&self) -> Result<Size, Error>

### Description
Get the size of the terminal screen in columns/rows as a `Size`.
```

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

### init / try_init

Source: https://docs.rs/ratatui/0.30.0/ratatui/init/index.html?search=u32+-%3E+bool

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

```APIDOC
## fn init() -> DefaultTerminal
## fn try_init() -> Result<DefaultTerminal, Error>

### Description
Initializes the terminal with default configurations. `init` will panic on failure, while `try_init` returns a Result.
```

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

### window_size

Source: https://docs.rs/ratatui/0.30.0/ratatui/backend/struct.CrosstermBackend.html?search=u32+-%3E+bool

Gets the terminal window size.

```APIDOC
## fn window_size(&mut self) -> Result<WindowSize, Error>

### Description
Get the size of the terminal screen in columns/rows and pixels as a `WindowSize`.
```

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

### set_span

Source: https://docs.rs/ratatui/0.30.0/ratatui/buffer/struct.Buffer.html?search=std%3A%3Avec

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

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

### set_line

Source: https://docs.rs/ratatui/0.30.0/ratatui/buffer/struct.Buffer.html?search=std%3A%3Avec

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

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

### init / try_init

Source: https://docs.rs/ratatui/0.30.0/ratatui/init/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

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

```APIDOC
## fn init() -> DefaultTerminal
## fn try_init() -> Result<DefaultTerminal, Box<dyn Error>>

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

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

### set_string

Source: https://docs.rs/ratatui/0.30.0/ratatui/buffer/struct.Buffer.html?search=std%3A%3Avec

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). `T` must implement `AsRef<str>` and `S` must implement `Into<Style>`.
```

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

### init_with_options

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

Initialize a terminal with the given options and reasonable defaults.

```APIDOC
## init_with_options

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

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

### get_cursor()

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/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.
```

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

### Retrieve TypeId

Source: https://docs.rs/ratatui/0.30.0/ratatui/enum.Viewport.html?search=

Gets the TypeId of the current instance.

```rust
fn type_id(&self) -> TypeId
```

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

### init

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

Initialize a terminal with reasonable defaults for most applications.

```APIDOC
## init

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

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

### TermionBackend::writer_mut

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

Gets the writer as a mutable reference.

```APIDOC
## pub const fn writer_mut(&mut self) -> &mut W

### Description
Gets the writer as a mutable reference. Note that writing to the writer directly may cause incorrect output due to the way the Terminal implements diffing. This method is marked as unstable and requires the `unstable-backend-writer` crate feature.
```

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

### Create Layouts with New

Source: https://docs.rs/ratatui/0.30.0/ratatui/layout/struct.Layout.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows various ways to initialize a Layout using different 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]);
```

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

### TermionBackend::writer

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

Gets the writer associated with the backend.

```APIDOC
## pub const fn writer(&self) -> &W

### Description
Gets the writer. This method is marked as unstable and requires the `unstable-backend-writer` crate feature.
```

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

### Render WidgetRef

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/trait.FrameExt.html?search=

Example of rendering a widget using render_widget_ref.

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

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

### Initialize and Verify TestBackend

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

Demonstrates creating a new TestBackend instance and asserting the state of the buffer.

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

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

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

### BarChart Example Output

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.BarChart.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Visual representation of a rendered BarChart.

```text
┌─────────────────────────────────┐
│                             ████│
│                        ▅▅▅▅ ████│
│            ▇▇▇▇        ████ ████│
│     ▄▄▄▄   ████ ████   ████ ████│
│▆10▆ █20█   █50█ █40█   █60█ █90█│
│ B1   B2     B1   B2     B1   B2 │
│ Group1      Group2      Group3  │
└─────────────────────────────────┘
```

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

### Create and render a List widget

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

Demonstrates initializing a List with items, applying styling, setting a highlight symbol, and rendering it within a frame.

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

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

### try_init_with_options

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

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

```APIDOC
## try_init_with_options

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

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

### Ratio Constraint Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/layout/enum.Constraint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Visual representation of Ratio constraints.

```text
[Ratio(1, 2) ; 2]
┌───────────────────────┐┌───────────────────────┐
│         25 px         ││         25 px         │
└───────────────────────┘└───────────────────────┘
```

```text
[Ratio(1, 4) ; 4]
┌───────────┐┌──────────┐┌───────────┐┌──────────┐
│   13 px   ││   12 px  ││   13 px   ││   12 px  │
└───────────┘└──────────┘└───────────┘└──────────┘
```

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

### Create a new TermionBackend instance

Source: https://docs.rs/ratatui/0.30.0/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());
```

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

### Percentage Constraint Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/layout/enum.Constraint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Visual representation of Percentage constraints.

```text
[Percentage(75), Fill(1)]
┌────────────────────────────────────┐┌──────────┐
│                38 px               ││   12 px  │
└────────────────────────────────────┘└──────────┘
```

```text
[Percentage(50), Fill(1)]
┌───────────────────────┐┌───────────────────────┐
│         25 px         ││         25 px         │
└───────────────────────┘└───────────────────────┘
```

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

### Create a new TermwizBackend instance

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

Creates a new backend instance, which automatically enables raw mode and enters the alternate screen.

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

let backend = TermwizBackend::new()?;
```

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

### Get TableState offset

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.TableState.html?search=std%3A%3Avec

Retrieves the current row offset.

```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/init/index.html

Try to initialize a terminal with the given options.

```APIDOC
## try_init_with_options

### Description
Try to initialize a terminal with the given options and reasonable defaults, returning a Result.
```

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

### init_with_options / try_init_with_options

Source: https://docs.rs/ratatui/0.30.0/ratatui/init/index.html?search=u32+-%3E+bool

Creates a terminal instance with custom TerminalOptions.

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

### Description
Initializes the terminal using custom options. Enables raw mode but does not enable alternate screen by default.
```

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

### Render StatefulWidgetRef

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/trait.FrameExt.html?search=

Example of rendering a stateful widget using render_stateful_widget_ref.

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

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

### init_with_options / try_init_with_options

Source: https://docs.rs/ratatui/0.30.0/ratatui/init/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a terminal instance with custom TerminalOptions.

```APIDOC
## fn init_with_options(options: TerminalOptions) -> DefaultTerminal
## fn try_init_with_options(options: TerminalOptions) -> Result<DefaultTerminal, Box<dyn Error>>

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

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

### Length Constraint Examples

Source: https://docs.rs/ratatui/0.30.0/ratatui/layout/enum.Constraint.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Visual representation of fixed Length constraints.

```text
[Length(20), Length(20)]
┌──────────────────┐┌──────────────────┐
│       20 px      ││       20 px      │
└──────────────────┘└──────────────────┘
```

```text
[Length(20), Length(30)]
┌──────────────────┐┌────────────────────────────┐
│       20 px      ││            30 px           │
└──────────────────┘└────────────────────────────┘
```

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

### Get Selected Item

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

Retrieve the index of the currently selected item.

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

let state = ListState::default();
assert_eq!(state.selected(), None);
```

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

### Get Terminal Size

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

Retrieves the current dimensions of the terminal screen.

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

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

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

### init_with_options

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html?search=u32+-%3E+bool

Initializes a terminal with the provided options and panics if initialization fails.

```APIDOC
## fn init_with_options(options: TerminalOptions) -> DefaultTerminal

### Description
Initializes a terminal with the given options and reasonable defaults. This function will panic if enabling raw mode or creating the terminal fails.

### Parameters
- **options** (TerminalOptions) - Required - The configuration options for the terminal, including viewport settings.

### Returns
- **DefaultTerminal** - The initialized terminal instance.
```

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

### init_with_options

Source: https://docs.rs/ratatui/0.30.0/src/ratatui/init.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a terminal with the provided options and panics if initialization fails.

```APIDOC
## fn init_with_options(options: TerminalOptions) -> DefaultTerminal

### Description
Initializes a terminal with the given options and reasonable defaults. This function will panic if enabling raw mode or creating the terminal fails.

### Parameters
- **options** (TerminalOptions) - Required - The configuration options for the terminal, including the viewport.
```

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

### get_cursor_position / set_cursor_position

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

Methods to get or set the current cursor position.

```APIDOC
## fn get_cursor_position(&mut self) -> Result<Position, Infallible>
## fn set_cursor_position<P>(&mut self, position: P) -> Result<(), Infallible>

### Description
Retrieves or updates the cursor position on the terminal screen. set_cursor_position accepts any type that implements Into<Position>.
```

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

### Creating and Configuring a Chart

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

Demonstrates how to define datasets, configure X and Y 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);
```

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

### Rendering Text

Source: https://docs.rs/ratatui/0.30.0/ratatui/text/struct.Text.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of rendering Text directly or via the Paragraph widget.

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

// within another widget's `render` method:
let text = Text::from("The first line\nThe second line");
text.render(area, buf);
```

```rust
let text = Text::from("The first line\nThe second line");
frame.render_widget(text, area);
```

```rust
use ratatui::{
    buffer::Buffer,
    layout::Rect,
    text::Text,
    widgets::{Paragraph, Widget, Wrap},
};

let text = Text::from("The first line\nThe second line");
let paragraph = Paragraph::new(text)
    .wrap(Wrap { trim: true })
    .scroll((1, 1))
    .render(area, buf);
```

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

### LIGHT_QUADRUPLE_DASHED visual representation

Source: https://docs.rs/ratatui/0.30.0/ratatui/prelude/symbols/border/constant.LIGHT_QUADRUPLE_DASHED.html

Visual example of how the light quadruple-dashed border appears.

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

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

### Rendering Lines

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

Examples of rendering a Line directly to a buffer or via a frame.

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

// in another widget's render method
let line = Line::from("Hello world!").style(Style::new().yellow().italic());
line.render(area, buf);
```

```rust
let line = Line::from("Hello world!");
frame.render_widget(line, area);
```

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

### Initialize and restore terminal

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

Demonstrates the convenience run() function versus manual init() and restore() methods for terminal lifecycle management.

```rust
fn main() -> std::io::Result<()> {
    ratatui::run(|mut terminal| {
        loop {
            terminal.draw(render)?;
            if should_quit()? {
                break Ok(());
            }
        }
    })
}

fn render(frame: &mut ratatui::Frame) {
    // ...
}

fn should_quit() -> std::io::Result<bool> {
    // ...
}
```

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

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

### ratatui::try_init()

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.try_init.html?search=std%3A%3Avec

Initializes the terminal with default settings. Requires the 'crossterm' feature.

```APIDOC
## Function: ratatui::try_init()

### Description
Attempts to initialize a terminal using reasonable defaults for most applications. This includes enabling raw mode, the alternate screen buffer, installing a panic hook, and creating a Terminal using CrosstermBackend.

### Signature
`pub fn try_init() -> Result<DefaultTerminal>`

### Requirements
- **Feature Flag**: `crossterm`

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

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

### Get selected cell indexes

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.TableState.html?search=std%3A%3Avec

Retrieves the indexes of the currently selected cell.

```rust
let state = TableState::new();
assert_eq!(state.selected_cell(), None);
```

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

### Get selected column index

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.TableState.html?search=std%3A%3Avec

Retrieves the index of the currently selected column.

```rust
let state = TableState::new();
assert_eq!(state.selected_column(), None);
```

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

### try_init

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

Try to initialize a terminal using reasonable defaults for most applications.

```APIDOC
## try_init

### Description
Try to initialize a terminal using reasonable defaults for most applications.
```

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

### TermwizBackend::new

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

Creates a new Termwiz backend instance, automatically enabling raw mode and entering the alternate screen.

```APIDOC
## pub fn new() -> Result<TermwizBackend, Box<dyn Error>>

### Description
Creates a new Termwiz backend instance. The backend will automatically enable raw mode and enter the alternate screen.

### Errors
Returns an error if unable to query terminal capabilities, enter raw mode, enter the alternate screen, or create the system/buffered terminal.
```

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

### Get selected row index

Source: https://docs.rs/ratatui/0.30.0/ratatui/widgets/struct.TableState.html?search=std%3A%3Avec

Retrieves the index of the currently selected row.

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

let state = TableState::new();
assert_eq!(state.selected(), None);
```

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

### Get ListItem width

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

Retrieves the maximum width among all lines in the ListItem.

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

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

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

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

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

### TermwizBackend::new

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

Creates a new Termwiz backend instance, automatically enabling raw mode and entering the alternate screen.

```APIDOC
## pub fn new() -> Result<TermwizBackend, Box<dyn Error>>

### Description
Creates a new Termwiz backend instance. The backend will automatically enable raw mode and enter the alternate screen.

### Errors
Returns an error if unable to query terminal capabilities, enter raw mode, enter the alternate screen, or create the terminal.
```

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

### Get ListItem height

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

Retrieves the height of a ListItem based on its content lines.

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

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

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

let item = ListItem::new("Multi-line\nitem");
assert_eq!(item.height(), 2);
```

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

### Get List Offset

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

Retrieve the current index of the first item displayed.

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

let state = ListState::default();
assert_eq!(state.offset(), 0);
```

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

### ratatui::init

Source: https://docs.rs/ratatui/0.30.0/ratatui/fn.init.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a terminal with reasonable defaults, including Crossterm backend, raw mode, alternate screen, and a panic hook.

```APIDOC
## fn init()

### Description
Initialize a terminal with reasonable defaults for most applications. This function enables raw mode, enters the alternate screen buffer, and installs a panic hook to restore the terminal state upon failure.

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

### Requirements
- Crate feature: `crossterm`

### Panics
This function will panic if enabling raw mode, entering the alternate screen buffer, or calculating the terminal size fails.

### Example
```rust
let terminal = ratatui::init();
```
```

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

### Get line width

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

Calculates the total width of the line based on its content.

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

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

### TestBackend::new

Source: https://docs.rs/ratatui/0.30.0/ratatui/backend/struct.TestBackend.html?search=std%3A%3Avec

Creates a new TestBackend with the specified width and height.

```APIDOC
## pub fn new(width: u16, height: u16) -> TestBackend

### Description
Creates a new `TestBackend` with the specified width and height.

### Parameters
- **width** (u16) - Required - The width of the backend.
- **height** (u16) - Required - The height of the backend.
```

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

### Scrollbar Widget Usage

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

Example of how to initialize and render a Scrollbar widget using ScrollbarState.

```APIDOC
## Scrollbar Widget

### Description
The `Scrollbar` widget is used to display a scrollbar in a terminal UI. It requires a `ScrollbarState` to track the content length and current position.

### Usage
```rust
let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight)
    .begin_symbol(Some("↑"))
    .end_symbol(Some("↓"));

let mut scrollbar_state = ScrollbarState::new(content_length).position(current_position);

frame.render_stateful_widget(scrollbar, area, &mut scrollbar_state);
```

### Important
You must specify the `ScrollbarState::content_length` before rendering the `Scrollbar`, or the widget will render blank.
```