Struct Tabs 

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

A horizontal strip of titles with the tab at selected highlighted.

Unlike Table/List, Tabs is a plain Widget, not a StatefulWidget: there is no scroll offset for a tab strip, only a selected index, so it takes selected: Option<usize> directly (set via Tabs::select) rather than a ListState: the app is free to drive that index however it likes (a plain usize it owns, a FocusRing, whatever fits), the same “app- or interaction-machinery-driven, widget just reads it” division of labor as every other widget here.

Titles render left to right, column_spacing blank columns apart (default 1, matching Table::column_spacing), with an optional single-character divider (default None, i.e. no divider) centered in that spacing: set with Tabs::divider. Drawing stops once a title would start past the area’s right edge; there is no horizontal scrolling.

style and selected_style default to Theme::DARK (as if Tabs::theme had been called); set them with Tabs::style/Tabs::selected_style.

As an InteractiveWidget, type State = usize (the same index a caller already threads into Tabs::select for the plain Widget path): a single id covers the whole strip, and a click selects the tab whose column range contains Response::pointer_pos, resolved against the very same per-tab column layout the drawing routine uses, so the two can’t diverge.

Examples

use retroglyph_core::grid::{Grid, Rect};
use retroglyph_ui::{Surface, Tabs, Widget};

let titles = ["Overview", "Details", "Settings"];
let area = Rect::new(0, 0, 30, 1);
let mut grid = Grid::new(30, 1);
Tabs::new(&titles)
    .select(Some(0))
    .render(&mut Surface::new(&mut grid, area, 0));

Implementations

impl<'a> Tabs<'a>

pub fn new(titles: &'a [&'a str]) -> Self

A tab strip over titles, with nothing selected, styled from Theme::DARK (as if Tabs::theme had been called).

pub const fn select(self, index: Option<usize>) -> Self

Select tab index (or clear the selection with None).

pub const fn style(self, style: Style) -> Self

Set the style of unselected tabs.

pub const fn selected_style(self, style: Style) -> Self

Set the style of the selected tab, including its background fill.

pub const fn column_spacing(self, spacing: u16) -> Self

Set the number of blank columns between tabs.

pub const fn divider(self, divider: Option<char>) -> Self

Set a divider character drawn within the spacing between tabs. None (the default) draws no divider: just column_spacing blank columns.

pub fn theme(self, theme: Theme) -> Self

Applies theme’s named roles to this tab strip: style becomes theme.dim (unselected tabs read as de-emphasized) on theme.panel_bg, and selected_style becomes theme.bg on theme.accent: the same bright-on-accent highlight super::List::theme and super::Table::theme give their own selected state.

style sets an explicit background rather than leaving it at Style::new()’s default: an unset background isn’t “transparent” once a real backend draws it (a bare Color::Default cell paints as solid black behind the glyph; see retroglyph-software’s DEFAULT_BG), so this widget assumes it’s drawn on theme.panel_bg, true when composed with a themed super::Panel/super::Modal. Drawing this tab strip directly on the raw screen background instead needs a manual .style(...) override afterwards.

Call before any manual Tabs::style/Tabs::selected_style override you want to keep.

pub fn theme_on(self, theme: Theme, bg: Color) -> Self

Same as Tabs::theme, but style is drawn on bg instead of theme.panel_bg: for a tab strip drawn directly on a backdrop other than a themed super::Panel/ super::Modal’s fill. selected_style still uses theme.accent as its background, unaffected by bg. Tabs::theme is exactly theme_on(theme, theme.panel_bg).

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

Formats the value using the given formatter.

impl<Id> InteractiveWidget<Id> for Tabs<'_>

fn sense(&self) -> Sense

A single id covers the whole strip: clicking resolves which tab via Response::pointer_pos and this strip’s own column layout, rather than each tab registering its own id.

type State = usize

State that outlives one render call, e.g. a selection index or scroll offset. () for widgets that have none.

fn render( &self, surface: &mut Surface<'_>, state: &mut Self::State, response: Response<Id>, )

Draw into surface, styled by response, which the caller already resolved (via Interaction::interact) for surface.area() and sense.

impl Widget for Tabs<'_>

fn render(&self, surface: &mut Surface<'_>)

Draw this widget into surface, filling surface.area().

impl<'a> Copy for Tabs<'a>