Ratatui Widgets

https://docs.rs/ratatui-widgets/0.3.0
Admin
Ratatui Widgets is a collection of built-in terminal UI widgets including charts, tables, lists,...
Tokens:1,248,633
Snippets:7,122
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### List Widget Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=std%3A%3Avec

Examples demonstrating how to use the List widget with different configurations, including stateful usage and collection from iterators.

```APIDOC
## §Examples
```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);

// Assuming `frame` and `area` are available
// frame.render_widget(list, area);
```

## §Stateful example
```rust
use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::style::{Style, Stylize};
use ratatui::widgets::{Block, List, ListState};

// This should be stored outside of the function in your application state.
let mut state = ListState::default();
let items = ["Item 1", "Item 2", "Item 3"];
let list = List::new(items)
    .block(Block::bordered().title("List"))
    .highlight_style(Style::new().reversed())
    .highlight_symbol(">>")
    .repeat_highlight_symbol(true);

// Assuming `frame` and `area` are available
// frame.render_stateful_widget(list, area, &mut state);
```

In addition to `List::new`, any iterator whose element is convertible to `ListItem` can be collected into `List`.
```rust
use ratatui::widgets::List;

(0..5).map(|i| format!("Item{{i}}")).collect::<List>();
```
```

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

### Table Widget State Management Example

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/table.rs_search=std%3A%3Avec

Provides an example of how to use the `StatefulWidget` trait with the `Table` widget, including setting up a `Buffer` and `TableState`. This is a basic setup for testing stateful behavior.

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

// Assuming `Table` and `TableState` are imported correctly
// use crate::table::{Row, Table, TableState};

// fn table_buf() -> Buffer {
//     Buffer::empty(Rect::new(0, 0, 10, 10))
// }

// #[rstest]
// fn test_list_state_empty_list(mut table_buf: Buffer) {
//     // Test logic for empty list state would go here
// }
```

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

### Tabs Widget Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/tabs/struct.Tabs_search=

Provides examples of how to create and customize the Tabs widget in Ratatui.

```APIDOC
## Tabs Widget Examples

### Description
Examples demonstrating the usage of the `Tabs` widget, including setting padding.

### Method
N/A (Illustrative Examples)

### Endpoint
N/A (Widget Usage)

### Parameters
N/A

### Request Example
```rust
use ratatui::widgets::Tabs;

// Example with space padding
let tabs_with_space_padding = Tabs::new(vec!["Tab 1", "Tab 2"]).padding(" ", " ");

// Example with no padding
let tabs_without_padding = Tabs::new(vec!["Tab 1", "Tab 2"]).padding("", "");
```

### Response
N/A (Widget Configuration)
```

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

### Example: Creating and Assembling a Chart Widget

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/chart.rs_search=

Shows how to instantiate the `Chart` widget by providing datasets, configuring its X and Y axes, and optionally adding a surrounding `Block` with a title. This example brings together datasets, axes, and block configurations into a complete `Chart` widget.

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

// Assuming datasets, x_axis, and y_axis are already defined as in previous examples

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

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

### Block Widget Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/block/struct.Block_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the Block widget for creating nested UI elements.

```APIDOC
## Block Widget Examples

### Description

This example shows how to draw a block nested within another block using the `ratatui::widgets::Block`.

### Usage

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

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

### Gauge Widget Example

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/gauge/struct.Gauge_search=

Demonstrates how to create and configure a `Gauge` widget in Rust. This example shows setting a block with a title, applying a specific style to the gauge, and setting its percentage.

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

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

### Table Styling Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/table.rs

Demonstrates how to apply various styles to a `Table` widget using method chaining. This includes setting foreground and background colors, bold modifiers, and removing the crossed-out modifier. The example asserts the resulting `Style` object.

```rust
        assert_eq!(
            Table::new(vec![Row::new(vec![Cell::from("")])], [Percentage(100)])
                .black()
                .on_white()
                .bold()
                .not_crossed_out()
                .style,
            Style::default()
                .fg(Color::Black)
                .bg(Color::White)
                .add_modifier(Modifier::BOLD)
                .remove_modifier(Modifier::CROSSED_OUT)
        );
```

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

### Example Usage of BarChart Configuration (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/barchart.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to configure a BarChart with a custom bar gap. The example shows setting the data and then applying a `bar_gap` of 3, illustrating the visual spacing between bars.

```rust
use ratatui::widgets::BarChart;

BarChart::default()
    .data(&[("foo", 1), ("bar", 2)])
    .bar_gap(3);
```

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

### BarChart Example Usage (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/barchart.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create and configure a `BarChart` widget with styled bars, labels, and groups. This example showcases setting various properties like `block`, `bar_width`, `bar_gap`, `group_gap`, and styles for bars, values, and labels.

```rust
BarChart::default()
    .block(Block::bordered().title("BarChart"))
    .bar_width(3)
    .bar_gap(1)
    .group_gap(3)
    .bar_style(Style::new().yellow().on_red())
    .value_style(Style::new().red().bold())
    .label_style(Style::new().white())
    .data(&[("A0", 0), ("A1", 2), ("A2", 4), ("A3", 3)])
    .data(BarGroup::new([
        Bar::with_label("B0", 10),
        Bar::with_label("B2", 20),
    ]))
    .max(4);
```

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

### Tabs Widget Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/tabs/struct.Tabs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create and configure the Tabs widget with different padding options.

```APIDOC
## Tabs Widget Configuration Examples

### Description
Examples showing how to set padding for the Tabs widget.

### Method
N/A (Code examples for widget configuration)

### Endpoint
N/A (Widget configuration)

### Parameters
N/A

### Request Example
```rust
use ratatui::widgets::Tabs;

// Tabs with space padding on both sides
let tabs_with_space_padding = Tabs::new(vec!["Tab 1", "Tab 2"]).padding(" ", " ");

// Tabs with no padding on either side
let tabs_without_padding = Tabs::new(vec!["Tab 1", "Tab 2"]).padding("", "");
```

### Response
N/A (Code examples for widget configuration)
```

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

### LineGauge Usage Example

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/gauge/struct.LineGauge_search=std%3A%3Avec

An example demonstrating how to create and configure a LineGauge widget in Rust. It shows setting a block, style, filled symbol, and ratio.

```rust
use ratatui::style::{Style, Stylize};
use ratatui::symbols;
use ratatui::widgets::{Block, LineGauge);

LineGauge::default()
    .block(Block::bordered().title("Progress"))
    .filled_style(Style::new().white().on_black().bold())
    .filled_symbol(symbols::line::THICK_HORIZONTAL)
    .ratio(0.4);
```

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

### List Widget State Management Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.ListState_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the ListState struct to manage the state of a ratatui List widget. This example shows initializing ListState, modifying its offset and selected item, and rendering the list widget with its state.

```rust
use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::widgets::{List, ListState};

let items = ["Item 1"];
let list = List::new(items);

// This should be stored outside of the function in your application state.
let mut state = ListState::default();

*state.offset_mut() = 1; // display the second item and onwards
state.select(Some(3)); // select the forth item (0-indexed)

// Assuming 'frame' and 'area' are defined elsewhere
// frame.render_stateful_widget(list, area, &mut state);
```

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

### List Widget Rendering Examples (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/list/rendering.rs_search=u32+-%3E+bool

Provides example test cases for the List widget, demonstrating rendering for empty, single, multiple, and multi-line items. It utilizes helper functions `test_case_render` and `test_case_render_stateful` to verify the widget's output against predefined expected buffers for various scenarios, including different selection states in the stateful version.

```rust
let empty_items = Vec::new();
let single_item = vec!["Item 0".into()];
let multiple_items = vec!["Item 0".into(), "Item 1".into(), "Item 2".into()];
let multi_line_items = vec!["Item 0\nLine 2".into(), "Item 1".into(), "Item 2".into()];

// empty list
test_case_render(
    &empty_items,
    [
        "          ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &empty_items,
    None,
    [
        "          ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &empty_items,
    Some(0),
    [
        "          ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);

// single item
test_case_render(
    &single_item,
    [
        "Item 0    ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &single_item,
    None,
    [
        "Item 0    ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &single_item,
    Some(0),
    [
        ">>Item 0  ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &single_item,
    Some(1),
    [
        ">>Item 0  ",
        "          ",
        "          ",
        "          ",
        "          ",
    ],
);

// multiple items
test_case_render(
    &multiple_items,
    [
        "Item 0    ",
        "Item 1    ",
        "Item 2    ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &multiple_items,
    None,
    [
        "Item 0    ",
        "Item 1    ",
        "Item 2    ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &multiple_items,
    Some(0),
    [
        ">>Item 0  ",
        "  Item 1  ",
        "  Item 2  ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &multiple_items,
    Some(1),
    [
        "  Item 0  ",
        ">>Item 1  ",
        "  Item 2  ",
        "          ",
        "          ",
    ],
);
test_case_render_stateful(
    &multiple_items,
    Some(3),
    [
        "  Item 0  ",
        "  Item 1  ",
        ">>Item 2  ",
        "          ",
        "          ",
    ],
);

// multi line items
test_case_render(
    &multi_line_items,
    [
        "Item 0    ",

```

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

### Create and Render a Basic List Widget

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=

Demonstrates how to create a List widget with basic configuration including borders, title, general style, highlight style, and a highlight symbol. It then shows how to render this widget within a frame. This example assumes the existence of `Frame`, `Rect`, `Block`, `List`, `ListItem`, and `Style` from the ratatui library.

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

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

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

### Get ListItem height in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.ListItem_search=

Illustrates how to obtain the height of a `ListItem` in lines using the `height()` method. It shows examples for single-line and multi-line items.

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

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

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

### Checking List Properties

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides examples of how to get the number of items in a Ratatui List using `len()` and check if the list is empty using `is_empty()`.

```rust
use ratatui::widgets::List;

let items = ["Item 1"];
let list = List::new(items);

let len = list.len(); // Gets the number of items
let is_empty = list.is_empty(); // Checks if the list is empty
```

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

### Get ListItem width in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.ListItem_search=

Demonstrates retrieving the maximum width of a `ListItem` across all its lines using the `width()` method. Examples cover single-line and multi-line scenarios.

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

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

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

### ListState selected_mut() Method Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/list/state.rs

Shows how to get a mutable reference to the selected item's index in ListState using `selected_mut()`. This enables direct modification of the selection.

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

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

```

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

### General Implementations and Traits

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/tabs/struct.Tabs

Documentation for blanket implementations like Any, Borrow, BorrowMut, CloneToUninit, Equivalent, From, and Into.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### Description
Provides the `type_id` method to get the `TypeId` of an object.

#### Method
`type_id(&self) -> TypeId`

#### Endpoint
N/A

### impl<T> Borrow<T> for T

#### Description
Provides the `borrow` method for immutable borrowing.

#### Method
`borrow(&self) -> &T`

#### Endpoint
N/A

### impl<T> BorrowMut<T> for T

#### Description
Provides the `borrow_mut` method for mutable borrowing.

#### Method
`borrow_mut(&mut self) -> &mut T`

#### Endpoint
N/A

### impl<T> CloneToUninit for T

#### Description
Provides the experimental `clone_to_uninit` method for copying data to uninitialized memory. This is a nightly-only feature.

#### Method
`unsafe fn clone_to_uninit(&self, dest: *mut u8)

#### Endpoint
N/A

### impl<Q, K> Equivalent<K> for Q

#### Description
Provides the `equivalent` method to compare equality between types.

#### Method
`fn equivalent(&self, key: &K) -> bool`

#### Endpoint
N/A

### impl<T> From<T> for T

#### Description
Provides the `from` method to create a value from another value of the same type (identity conversion).

#### Method
`fn from(t: T) -> T`

#### Endpoint
N/A

### impl<T, U> Into<U> for T

#### Description
Provides the `into` method for converting a type `T` into a type `U` if `U` implements `From<T>`.

#### Method
`fn into(self) -> U`

#### Endpoint
N/A
```

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

### Create a Chart with a Single Dataset in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/chart/struct.Chart_search=

This example shows the basic usage of the `Chart::new` function to create a chart with a single dataset. It initializes an empty vector for data points and then creates a default Dataset which is passed to the Chart constructor. This is a minimal setup for a chart.

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

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

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

### Example: Creating and Styling Datasets for Chart

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/chart.rs_search=

Demonstrates the creation of multiple datasets with different graph types (Scatter and Line), markers, styles, and data points. It also shows how to apply styling using the `.red()` and `.cyan()` methods, which are part of the `Stylize` trait.

```rust
use ratatui::style::Stylize;
use ratatui::widgets::Dataset;

let dataset = Dataset::default().red();

// 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)]),
];
```

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

### Row::new Function Example

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/table/struct.Row_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides examples of using the `Row::new` constructor, accepting either string slices or explicit `Cell` objects.

```rust
use ratatui::widgets::{Cell, Row};

let row = Row::new(vec!["Cell 1", "Cell 2", "Cell 3"]);
let row = Row::new(vec![
    Cell::new("Cell 1"),
    Cell::new("Cell 2"),
    Cell::new("Cell 3"),
]);
```

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

### Table Widget Initialization and Configuration in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/table.rs_search=

Demonstrates how to create and configure a Ratatui Table widget in Rust. It covers setting up rows, column widths, spacing, headers, footers, and applying styles. The `Table::new` constructor is used with `Constraint` for widths, and fluent setters like `column_spacing`, `style`, `header`, `footer`, `block`, and highlight styles are shown.

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

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

### Create and Configure a Basic List Widget

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create a List widget with custom styling, highlight symbols, and direction. It takes an array of string slices as items and renders them within a bordered block. This example highlights the use of fluent setters for customization.

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

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

### Create and Style a Ratatui Table with Header, Footer, and Spacing

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/table/struct.Table

Demonstrates how to create a `Table` widget with specified row data, column widths, spacing, and header/footer rows. It also shows how to apply styles to the entire table, header, and highlight specific rows, columns, or cells.

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

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

### Tabs Widget Padding Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/tabs/struct.Tabs

Demonstrates how to set padding around tabs in the Ratatui Tabs widget. It shows examples with space padding and no padding.

```rust
use ratatui::widgets::Tabs;

let tabs = Tabs::new(vec!["Tab 1", "Tab 2"]).padding(" ", " ");
```

```rust
use ratatui::widgets::Tabs;

let tabs = Tabs::new(vec!["Tab 1", "Tab 2"]).padding("", "");
```

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

### Get the selected item index from ListState

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.ListState

Shows how to get the currently selected item's index from a ListState. It returns an `Option<usize>`, which is `None` if no item is selected.

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

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

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

### Create and Configure a Chart Dataset in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/chart/struct.Dataset

Demonstrates how to initialize a `Dataset` with default settings and then chain methods to set its name, data points, marker style, graph type, and color. This is useful for defining the visual representation of a data series in a chart.

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

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

### Rust Documentation Search Examples

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/canvas.rs_search=std%3A%3Avec

Examples of search queries for Rust documentation, illustrating how to find information on standard library types, type conversions, and generic function signatures.

```text
std::vec
u32 -> bool
Option<T>, (T -> U) -> Option<U>
```

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

### Bar Widget Example

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/barchart/bar.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the creation and basic styling of a Bar widget. This example shows how to set a label, value, and apply distinct styles to the bar and its value.

```rust
use ratatui::style::Stylize;
use ratatui::widgets::Bar;

Bar::with_label("Bar 1", 10)
    .red()
    .value_style(Style::new().red().on_white())
    .text_value("10°C");
```

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

### List Creation and Item Configuration

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/list.rs

This section details how to create a new List widget and populate it with items. It covers initialization with various iterables and the use of fluent setters for configuration.

```APIDOC
## List::new and List::items

### Description
Creates a new List widget or sets its items. The `items` parameter accepts any value that can be converted into an iterator of `Into<ListItem>`. This includes arrays of `&str` or `Vec`s of `Text`.

### Method
`List::new<T>(items: T)` for creation, `List::items<T>(self, items: T)` for setting items fluently.

### Endpoint
N/A (This is a library function, not a web endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use ratatui::widgets::List;

// Create a list from a slice of &str
let list_from_str = List::new(["Item 1", "Item 2"]);

// Create an empty list and set items using the fluent setter
let empty_list = List::default();
let filled_list = empty_list.items(["Item A", "Item B"]);

// Create a list from Text objects
use ratatui::style::{Style, Stylize};
use ratatui::text::Text;
let list_from_text = List::new([
    Text::styled("Item 1", Style::new().red()),
    Text::styled("Item 2", Style::new().blue()),
]);
```

### Response
#### Success Response (200)
N/A (This is a library function)

#### Response Example
N/A
```

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

### List Widget Basics

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=u32+-%3E+bool

Demonstrates how to create and configure a basic List widget with styling, a highlight symbol, and direction.

```APIDOC
## POST /widgets/list

### Description
Creates and renders a basic `List` widget.

### Method
POST

### Endpoint
/widgets/list

### Request Body
- **items** (array[string] | array[Text]) - Required - The items to display in the list. Can be strings or `Text` objects.
- **block_title** (string) - Optional - The title for the bordered block surrounding the list.
- **base_style** (Style) - Optional - The base style for the list items.
- **highlight_style** (Style) - Optional - The style for the selected list item.
- **highlight_symbol** (string) - Optional - The symbol to display before the selected item.
- **repeat_highlight_symbol** (boolean) - Optional - Whether to repeat the highlight symbol for multi-line items.
- **direction** (ListDirection) - Optional - The direction of the list (e.g., `TopToBottom`, `BottomToTop`). Defaults to `TopToBottom`.

### Request Example
```json
{
  "items": ["Item 1", "Item 2", "Item 3"],
  "block_title": "My List",
  "highlight_symbol": ">>",
  "direction": "BottomToTop"
}
```

### Response
#### Success Response (200)
- **rendered_widget** (string) - A representation of the rendered widget.

#### Response Example
```json
{
  "rendered_widget": "..."
}
```
```

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

### General Implementations

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/tabs/struct.Tabs_search=std%3A%3Avec

General blanket implementations for common traits like Any, Borrow, CloneToUninit, etc.

```APIDOC
## General Implementations

### Description
This section covers blanket implementations of standard Rust traits for generic types, including `UnwindSafe`, `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `Equivalent`, `From`, and `Into`.

### Method
Standard trait methods (e.g., `type_id`, `borrow`, `borrow_mut`, `clone_to_uninit`, `equivalent`, `from`, `into`).

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example for Borrow trait
let value = String::from("hello");
let borrowed_value: &String = (&value as &dyn Borrow<String>).borrow();

// Example for Into trait
let number = 5;
let converted: String = number.into(); // Requires String to implement From<i32>
```

### Response
#### Success Response (200)
Depends on the specific trait method being called.

#### Response Example
N/A

## Implemented Traits:
- `UnwindSafe` for `Tabs`
- `Any` for generic `T`
- `Borrow<T>` for generic `T`
- `BorrowMut<T>` for generic `T`
- `CloneToUninit` for generic `T` (Nightly-only experimental)
- `Equivalent<K>` for generic `Q` and `K`
- `From<T>` for generic `T`
- `Into<U>` for generic `T` and `U`
- `IntoEither` for generic `T`

```

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

### Bar Widget Structure and Example in Rust

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/barchart/struct.Bar_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines the structure of a Bar widget and provides an example of its creation with a label, value, and custom styling. It illustrates how to set individual styles for the bar and its value.

```Rust
pub struct Bar<'a> { /* private fields */ }

use ratatui::style::{Style, Stylize};
use ratatui::widgets::Bar;

Bar::with_label("Bar 1", 10)
    .red()
    .value_style(Style::new().red().on_white())
    .text_value("10°C");
```

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

### Get a mutable reference to the selected item index in ListState

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.ListState

Illustrates how to get a mutable reference to the selected item's index within a ListState, allowing direct modification or setting it to `None`.

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

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

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

### Gauge Styling Example

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/gauge.rs_search=u32+-%3E+bool

Demonstrates how to apply various styles (foreground color, background color, modifiers) to a `Gauge` widget. The example shows chaining style methods like `black()`, `on_white()`, `bold()`, and `not_dim()`.

```rust
assert_eq!(
    Gauge::default().black().on_white().bold().not_dim().style,
    Style::default()
        .fg(Color::Black)
        .bg(Color::White)
        .add_modifier(Modifier::BOLD)
        .remove_modifier(Modifier::DIM)
);
```

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

### Example: Sparkline from u64 data (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/sparkline.rs

Demonstrates creating a Sparkline widget from a slice of `u64` values. The widget is then rendered within a `Frame`.

```rust
use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::widgets::Sparkline;

# fn ui(frame: &mut Frame) {
# let area = Rect::default();
let sparkline = Sparkline::default().data(&[1, 2, 3]);
frame.render_widget(sparkline, area);
# }
```

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

### Ratatui BarChart: Direction Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/barchart/struct.BarChart_search=std%3A%3Avec

Demonstrates setting the display direction for bars in the BarChart widget. By default, bars are rendered vertically. This example shows the output for both vertical (default) and horizontal bar orientations.

```rust
// Vertical bars
//   █
// █ █
// f b

// Horizontal bars
// █foo██
// 
// █bar██
```

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

### Chart Widget Initialization

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/chart/struct.Chart

Demonstrates how to create a Chart widget with datasets, x-axis, and y-axis.

```APIDOC
## POST /chart

### Description
Initializes a new Chart widget with the specified datasets and axes.

### Method
POST

### Endpoint
/chart

### Parameters
#### Request Body
- **datasets** (array[Dataset]) - Required - The datasets to be plotted on the chart.
- **x_axis** (Axis) - Optional - The configuration for the X-axis.
- **y_axis** (Axis) - Optional - The configuration for the Y-axis.

### Request Example
```json
{
  "datasets": [
    {
      "name": "data1",
      "marker": "Dot",
      "graph_type": "Scatter",
      "style": {"fg": "cyan"},
      "data": [[0.0, 5.0], [1.0, 6.0], [1.5, 6.434]]
    },
    {
      "name": "data2",
      "marker": "Braille",
      "graph_type": "Line",
      "style": {"fg": "magenta"},
      "data": [[4.0, 5.0], [5.0, 8.0], [7.66, 13.5]]
    }
  ],
  "x_axis": {
    "title": "X Axis",
    "style": {"fg": "white"},
    "bounds": [0.0, 10.0],
    "labels": ["0.0", "5.0", "10.0"]
  },
  "y_axis": {
    "title": "Y Axis",
    "style": {"fg": "white"},
    "bounds": [0.0, 10.0],
    "labels": ["0.0", "5.0", "10.0"]
  }
}
```

### Response
#### Success Response (200)
- **chart_id** (string) - A unique identifier for the created chart.

#### Response Example
```json
{
  "chart_id": "chart-12345"
}
```
```

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

### Instantiate and Initialize Ratatui Tabs Widget

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/tabs.rs_search=std%3A%3Avec

Demonstrates the creation of a `Tabs` widget with a vector of string slices representing the tab titles. It also shows how the `selected` tab index is initialized and how the widget's structure is represented.

```rust
use ratatui::widgets::Tabs;
use ratatui::widgets::Line;
use ratatui::style::{Style, Stylize};
use ratatui_core::symbols;

// ... inside a test function ...
let titles = vec!["Tab1", "Tab2", "Tab3", "Tab4"];
let tabs = Tabs::new(titles.clone());
// Assertion to check the initialized Tabs struct...
```

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

### List Widget Creation and Styling

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List

Demonstrates how to create a List widget and apply basic styling using the Stylize trait.

```APIDOC
## POST /widgets/list

### Description
Creates a new List widget with provided items and applies styling.

### Method
POST

### Endpoint
/widgets/list

### Parameters
#### Request Body
- **items** (array) - Required - An array of strings representing the list items.
- **style** (object) - Optional - A style object to apply to the entire list.
  - **fg** (string) - Optional - Foreground color.
  - **bg** (string) - Optional - Background color.
  - **modifier** (string) - Optional - Style modifier (e.g., 'bold', 'italic').

### Request Example
```json
{
  "items": ["Item 1", "Item 2"],
  "style": {
    "fg": "red",
    "modifier": "italic"
  }
}
```

### Response
#### Success Response (200)
- **widget_id** (string) - A unique identifier for the created widget.

#### Response Example
```json
{
  "widget_id": "list-12345"
}
```
```

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

### BarChart Direction Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/barchart/struct.BarChart_search=u32+-%3E+bool

Demonstrates setting the display direction for BarChart bars using the `direction()` method. By default, bars are rendered vertically. This example shows how to switch to horizontal rendering, which changes the orientation and visual presentation of the bars.

```Rust
// Vertical bars example (default)
// Renders:
//   █
// █ █
// f b

// Horizontal bars example
// Renders:
// █foo██
// 
// █bar██
```

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

### Draw Shapes on Canvas Widget Example

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/canvas/struct.Canvas_search=

An example demonstrating how to use the Canvas widget to draw various shapes. It includes setting the canvas block, defining bounds, and using the paint method with a closure to draw a map, a line, and a rectangle with different colors.

```rust
use ratatui::style::Color;
use ratatui::widgets::Block;
use ratatui::widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle};

Canvas::default()
    .block(Block::bordered().title("Canvas"))
    .x_bounds([-180.0, 180.0])
    .y_bounds([-90.0, 90.0])
    .paint(|ctx| {
        ctx.draw(&Map {
            resolution: MapResolution::High,
            color: Color::White,
        });
        ctx.layer();
        ctx.draw(&Line {
            x1: 0.0,
            y1: 10.0,
            x2: 10.0,
            y2: 10.0,
            color: Color::White,
        });
        ctx.draw(&Rectangle {
            x: 10.0,
            y: 20.0,
            width: 10.0,
            height: 10.0,
            color: Color::Red,
        });
    });

```

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

### CloneToUninit for T

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/gauge/struct.Gauge_search=std%3A%3Avec

Nightly-only experimental API for cloning to uninitialized memory.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Nightly-only experimental API (`clone_to_uninit`) that performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit(dest: *mut u8)`

### Endpoint
N/A

### Parameters
- **dest** (*mut u8) - Required - A mutable pointer to the destination memory.

### Request Example
N/A

### Response
N/A

### Response Example
N/A
```

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

### List Widget - Basic Usage and Styling

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/list/struct.List_search=u32+-%3E+bool

Demonstrates how to create a List widget and apply basic styling using the `Stylize` trait.

```APIDOC
## POST /widgets/list

### Description
Creates a new List widget with specified items and applies styling.

### Method
POST

### Endpoint
/widgets/list

### Parameters
#### Query Parameters
- **items** (array of strings) - Required - The items to display in the list.
- **style** (string) - Optional - A shorthand string for styling the list (e.g., "red.italic").

### Request Body
```json
{
  "items": ["Item 1"],
  "style": "red.italic"
}
```

### Response
#### Success Response (200)
- **widget_data** (object) - Contains data representing the configured List widget.

#### Response Example
```json
{
  "widget_data": {
    "type": "List",
    "items": ["Item 1"],
    "style": {
      "fg": "red",
      "modifier": "italic"
    }
  }
}
```
```

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

### Tabs Widget with Styled Titles Example (Rust)

Source: https://docs.rs/ratatui-widgets/0.3.0/src/ratatui_widgets/tabs.rs_search=std%3A%3Avec

Demonstrates creating a Tabs widget where individual titles are styled. This example uses color modifiers (`.red()`, `.blue()`) to style the tab titles, showing how to apply specific styles to each `Line` object within the Tabs widget.

```Rust
let tabs = Tabs::new(vec!["Tab 1".red(), "Tab 2".blue()]);
```

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

### Standard Library Implementations

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/barchart/struct.Bar_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for blanket implementations provided for generic types, including `Any`, `Borrow`, `CloneToUninit`, `Equivalent`, `From`, `Into`, and `IntoEither`.

```APIDOC
## Standard Library Implementations

### Description
This section details the blanket implementations available for generic types, mirroring standard Rust library functionalities.

### Method
These are standard Rust trait implementations.

### Endpoint
N/A (In-code API)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use std::any::Any;
use std::borrow::{Borrow, BorrowMut};

// Example for Any trait
fn needs_any<T: Any>(value: &T) {
    println!("{:?}", value.type_id());
}

// Example for Borrow trait
let s = String::from("hello");
let borrowed_str: &str = s.borrow();

// Example for BorrowMut trait
let mut s = String::from("hello");
let borrowed_mut_str: &mut str = s.borrow_mut();

// Example for From and Into traits
let number = 5;
let string_number: String = String::from(number);
let string_number_into: String = number.into();

// Example for IntoEither trait
use ratatui::util::IntoEither;
let value = 10;
let either_val: ratatui::util::Either<i32, i32> = value.into_either(true);
```

### Response
#### Success Response (200)
N/A (In-code API)

#### Response Example
N/A (In-code API)
```

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

### Cloning and Initialization API

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/chart/struct.Axis_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Offers functionality for cloning data into uninitialized memory, a nightly-only experimental feature.

```APIDOC
## Cloning and Initialization API

### Clone to Uninitialized

- **Method**: `clone_to_uninit()`
- **Description**: Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.
- **Safety**: `unsafe` function, requires `dest` to be a valid pointer to uninitialized memory of the same size as `self`.
- **Requirements**: The type `T` must implement the `Clone` trait.
```

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

### TableState::selected_cell

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/table/struct.TableState_search=

Gets the indexes of the selected cell.

```APIDOC
## pub const fn selected_cell(&self) -> Option<(usize, usize)>

### Description
Indexes of the selected cell. Returns `None` if no cell is selected.

### Method
`selected_cell`

### Returns
An `Option<(usize, usize)>` containing the row and column index of the selected cell, or `None`.

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

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

### TableState::selected_column

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/table/struct.TableState_search=

Gets the index of the selected column.

```APIDOC
## pub const fn selected_column(&self) -> Option<usize>

### Description
Index of the selected column. Returns `None` if no column is selected.

### Method
`selected_column`

### Returns
An `Option<usize>` containing the index of the selected column, or `None`.

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

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

### TableState::selected

Source: https://docs.rs/ratatui-widgets/0.3.0/ratatui_widgets/table/struct.TableState_search=

Gets the index of the selected row.

```APIDOC
## pub const fn selected(&self) -> Option<usize>

### Description
Index of the selected row. Returns `None` if no row is selected.

### Method
`selected`

### Returns
An `Option<usize>` containing the index of the selected row, or `None`.

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

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