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};
use ratatui::symbols;
use ratatui::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) -> Tabs<'a>

where Iter: IntoIterator, <Iter as IntoIterator>::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;
use ratatui::widgets::Tabs;

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

pub fn titles<Iter>(self, titles: Iter) -> Tabs<'a>

where Iter: IntoIterator, <Iter as IntoIterator>::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;
use ratatui::widgets::Tabs;

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

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

Surrounds the Tabs with a Block.

pub fn select<T>(self, selected: T) -> Tabs<'a>

where T: Into<Option<usize>>,

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>(self, style: S) -> Tabs<'a>

where S: Into<Style>,

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>(self, style: S) -> Tabs<'a>

where S: Into<Style>,

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) -> Tabs<'a>

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;
use ratatui::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) -> Tabs<'a>

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) -> Tabs<'a>

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) -> Tabs<'a>

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 duplicate 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<(), Error>

Formats the value using the given formatter.

impl Default for Tabs<'_>

fn default() -> Tabs<'_>

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>(iter: Iter) -> Tabs<'a>

where Iter: IntoIterator<Item = Item>,

Creates a value from an iterator.

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

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

where __H: Hasher,

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 Styled for Tabs<'_>

type Item = Tabs<'_>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S>(self, style: S) -> <Tabs<'_> as Styled>::Item

where S: Into<Style>,

Sets the style of the object.

impl UnicodeWidthStr for Tabs<'_>

fn width(&self) -> usize

Returns the width of the rendered tabs.

The width includes the titles, dividers, and padding. It does not include any borders added by the optional block.

Characters in the Ambiguous category are considered single-width.

use ratatui::widgets::Tabs;
use unicode_width::UnicodeWidthStr;

let tabs = Tabs::new(vec!["Tab1", "Tab2", "Tab3"]);
assert_eq!(tabs.width(), 20); // " Tab1 │ Tab2 │ Tab3 "

fn width_cjk(&self) -> usize

Available on crate feature cjk only.

Returns the width of the rendered tabs, accounting for CJK characters.

This is probably the wrong method to use in most contexts that Ratatui applications care about as it doesn’t correlate with the visual representation of most terminals. Consider using Tabs::width instead.

The width includes the titles, dividers, and padding. It does not include any borders added by the optional block.

Characters in the Ambiguous category are considered double-width.

use ratatui::widgets::Tabs;
use unicode_width::UnicodeWidthStr;

let tabs = Tabs::new(vec!["你", "好", "世界"]);
assert_eq!("你".width_cjk(), 2);
assert_eq!("好".width_cjk(), 2);
assert_eq!("世界".width_cjk(), 4);
assert_eq!("│".width_cjk(), 2); // this is correct for cjk
assert_eq!(tabs.width_cjk(), 18); // " 你 │ 好 │ 世界 "

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 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<'a> Eq for Tabs<'a>

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