Struct Tabs 

pub struct Tabs { /* private fields */ }

A row of tabs. The strip publishes one Role::Tab node per tab.

Implementations

impl Tabs

pub fn new(ident: impl Into<Ident>) -> Self

pub fn tab(self, tab: TabItem) -> Self

pub fn tabs(self, tabs: impl IntoIterator<Item = TabItem>) -> Self

pub fn selected(self, id: impl Into<SharedString>) -> Self

pub fn on_select( self, handler: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> Self

pub fn on_close( self, handler: impl Fn(SharedString, &mut Window, &mut App) + 'static, ) -> Self

Reports the tab that should be put away. The strip closes nothing.

Only a tab marked TabItem::closable gets a control, and the control is a target of its own: it swallows the click that reaches it, so the gesture that means “switch to this tab” cannot land on it by accident. A middle click anywhere on a closable tab reports the same thing, which is the platform convention wherever a pointer has three buttons.

pub fn overflow_after(self, count: usize) -> Self

Keeps the first count tabs in the strip and moves the rest into the overflow menu.

The cut is declared rather than measured, for the reason Toolbar::overflow_after states: GPUI measures after the element tree exists, so a strip cannot find out what fits and then still move a tab somewhere else.

A menu rather than a scrolling strip, because a scroll offset is not something a reader can address: a tab scrolled out of view is at a position nobody can name, has no bounds, publishes nothing, and a horizontal scroll region would also eat the left and right arrows the strip uses to step between tabs. A menu keeps every hidden tab named, listed, and carrying its own save state. Either way the keyboard reaches a hidden tab directly: arrow, home and end step over every tab the caller declared, hidden or not, and report the one they land on.

pub fn overflow_menu(self, menu: Entity<Menu>) -> Self

The menu the overflowed tabs are moved into.

Caller-owned, because whether it is open outlives a frame. The menu reports the tab that was taken as MenuEvent::Invoked, carrying the same id the strip would have reported.

pub fn reorderable(self, reorderable: bool) -> Self

Lets a tab be dragged to another place in the strip.

pub fn accepts( self, predicate: impl Fn(&DragItem, &DropPosition) -> bool + 'static, ) -> Self

Whether this strip takes a payload, and where. Without one, it takes its own tabs and nothing else.

pub fn on_reorder( self, handler: impl Fn(&DropIntent, &mut Window, &mut App) + 'static, ) -> Self

Reports where a dropped tab should go. The strip does not move it.

Trait Implementations

impl Debug for Tabs

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

Formats the value using the given formatter.

impl Disableable for Tabs

fn disabled(self, disabled: bool) -> Self

Refuses the whole strip. A disabled strip installs no handler at all, including the keyboard one.

impl IntoElement for Tabs

type Element = ViewElement<Tabs>

The specific type of element into which the implementing type is converted. Useful for converting other types into elements automatically, like Strings

fn into_element(self) -> Self::Element

Convert self into a type that implements Element.

fn into_any_element(self) -> AnyElement

Convert self into a dynamically-typed AnyElement.

impl RenderOnce for Tabs

fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement

Render this component into an element tree. Note that this method takes ownership of self, as compared to Render::render() method which takes a mutable reference.

impl Sizable for Tabs

fn control_size(self, size: ControlSize) -> Self

fn xs(self) -> Self

fn small(self) -> Self

fn medium(self) -> Self

fn large(self) -> Self