Struct Tabs

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

A widget that displays a horizontal set of Tabs with a single tab selected.

Each tab title is stored as a Line which can be individually styled. The selected tab is set using Tabs::select and styled using Tabs::highlight_style. The divider can be customized with Tabs::divider. Padding can be set with Tabs::padding or Tabs::padding_left and Tabs::padding_right.

The divider defaults to |, and padding defaults to a singular space on each side.

Example

use ratatui::{
    style::{Style, Stylize},
    symbols,
    widgets::{Block, Tabs},
};

Tabs::new(vec!["Tab1", "Tab2", "Tab3", "Tab4"])
    .block(Block::bordered().title("Tabs"))
    .style(Style::default().white())
    .highlight_style(Style::default().yellow())
    .select(2)
    .divider(symbols::DOT)
    .padding("->", "<-");

In addition to Tabs::new, any iterator whose element is convertible to Line can be collected into Tabs.

use ratatui::widgets::Tabs;

(0..5).map(|i| format!("Tab{i}")).collect::<Tabs>();

Implementations

impl<'a> Tabs<'a>

pub fn new<Iter>(titles: Iter) -> Self

where Iter: IntoIterator, Iter::Item: Into<Line<'a>>,

Creates new Tabs from their titles.

titles can be a Vec of &str, String or anything that can be converted into Line. As such, titles can be styled independently.

The selected tab can be set with Tabs::select. The first tab has index 0 (this is also the default index).

The selected tab can have a different style with Tabs::highlight_style. This defaults to a style with the Modifier::REVERSED modifier added.

The default divider is a pipe (|), but it can be customized with Tabs::divider.

The entire widget can be styled with Tabs::style.

The widget can be wrapped in a Block using Tabs::block.

Examples

Basic titles.

use ratatui::widgets::Tabs;

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

Styled titles

use ratatui::{style::Stylize, widgets::Tabs};

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

pub fn titles<Iter>(self, titles: Iter) -> Self

where Iter: IntoIterator, Iter::Item: Into<Line<'a>>,

Sets the titles of the tabs.

titles is an iterator whose elements can be converted into Line.

The selected tab can be set with Tabs::select. The first tab has index 0 (this is also the default index).

Examples

Basic titles.

use ratatui::widgets::Tabs;

let tabs = Tabs::default().titles(vec!["Tab 1", "Tab 2"]);

Styled titles.

use ratatui::{style::Stylize, widgets::Tabs};

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

pub fn block(self, block: Block<'a>) -> Self

Surrounds the Tabs with a Block.

pub fn select<T: Into<Option<usize>>>(self, selected: T) -> Self

Sets the selected tab.

The first tab has index 0 (this is also the default index). The selected tab can have a different style with Tabs::highlight_style.

Examples

Select the second tab.

use ratatui::widgets::Tabs;

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

Deselect the selected tab.

use ratatui::widgets::Tabs;

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

pub fn style<S: Into<Style>>(self, style: S) -> Self

Sets the style of the tabs.

style accepts any type that is convertible to Style (e.g. Style, Color, or your own type that implements Into<Style>).

This will set the given style on the entire render area. More precise style can be applied to the titles by styling the ones given to Tabs::new. The selected tab can be styled differently using Tabs::highlight_style.

pub fn highlight_style<S: Into<Style>>(self, style: S) -> Self

Sets the style for the highlighted tab.

style accepts any type that is convertible to Style (e.g. Style, Color, or your own type that implements Into<Style>).

Highlighted tab can be selected with Tabs::select.

pub fn divider<T>(self, divider: T) -> Self

where T: Into<Span<'a>>,

Sets the string to use as tab divider.

By default, the divider is a pipe (|).

Examples

Use a dot (•) as separator.

use ratatui::{symbols, widgets::Tabs};

let tabs = Tabs::new(vec!["Tab 1", "Tab 2"]).divider(symbols::DOT);

Use dash (-) as separator.

use ratatui::widgets::Tabs;

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

pub fn padding<T, U>(self, left: T, right: U) -> Self

where T: Into<Line<'a>>, U: Into<Line<'a>>,

Sets the padding between tabs.

Both default to space.

Examples

A space on either side of the tabs.

use ratatui::widgets::Tabs;

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

Nothing on either side of the tabs.

use ratatui::widgets::Tabs;

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

pub fn padding_left<T>(self, padding: T) -> Self

where T: Into<Line<'a>>,

Sets the left side padding between tabs.

Defaults to a space.

Example

An arrow on the left of tabs.

use ratatui::widgets::Tabs;

let tabs = Tabs::new(vec!["Tab 1", "Tab 2"]).padding_left("->");

pub fn padding_right<T>(self, padding: T) -> Self

where T: Into<Line<'a>>,

Sets the right side padding between tabs.

Defaults to a space.

Example

An arrow on the right of tabs.

use ratatui::widgets::Tabs;

let tabs = Tabs::new(vec!["Tab 1", "Tab 2"]).padding_right("<-");

Trait Implementations

impl<'a> Clone for Tabs<'a>

fn clone(&self) -> Tabs<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Tabs<'a>

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

Formats the value using the given formatter.

impl Default for Tabs<'_>

fn default() -> Self

Returns a default Tabs widget.

The default widget has:

• No tabs
• No selected tab
• The highlight style is set to reversed.
• The divider is set to a pipe (|).
• The padding on the left and right is set to a space.

This is rarely useful on its own without calling Tabs::titles.

Examples

use ratatui::widgets::Tabs;

let tabs = Tabs::default().titles(["Tab 1", "Tab 2"]);

impl<'a, Item> FromIterator<Item> for Tabs<'a>

where Item: Into<Line<'a>>,

fn from_iter<Iter: IntoIterator<Item = Item>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<'a> Hash for Tabs<'a>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Tabs<'a>

fn eq(&self, other: &Tabs<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Styled for Tabs<'a>

type Item = Tabs<'a>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S: Into<Style>>(self, style: S) -> Self::Item

Sets the style of the object.

impl Widget for Tabs<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl WidgetRef for Tabs<'_>

fn render_ref(&self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl<'a> Eq for Tabs<'a>

impl<'a> StructuralPartialEq for Tabs<'a>