Struct kas_widgets::TabStack

pub struct TabStack<W: Widget> { /* private fields */ }

A tabbed stack of widgets

A stack consists a set of child widgets, “pages”, all of equal size. Only a single page is visible at a time. The page is “turned” via tab handles or calling Self::set_active.

Type parameter D controls the position of tabs relative to the stack; default value is Direction::Up: tabs are positioned above the stack. Within the bar, items are always left-to-right (TODO: support for vertical bars).

This may only be parametrised with a single widget type, thus usually it will be necessary to box children (this is what BoxTabStack is).

See also the main implementing widget: Stack.

Implementations

impl<W: Widget> TabStack<W>

pub fn new() -> Self

Construct a new, empty instance

pub fn set_direction(&mut self, direction: Direction) -> TkAction

Set the position of tabs relative to content

Default value: Direction::Up

impl<W: Widget> TabStack<W>

pub fn set_size_limit(&mut self, limit: usize)

Limit the number of pages considered by Layout::size_rules

By default, this is usize::MAX: all pages affect the result. If this is set to 1 then only the active page will affect the result. If this is n > 1, then min(n, num_pages) pages (including active) will be used. (If this is set to 0 it is silently replaced with 1.)

Using a limit lower than the number of pages has two effects: (1) resizing is faster and (2) calling Self::set_active may cause a full-window resize.

pub fn active(&self) -> usize

Get the index of the active page

pub fn with_active(self, active: usize) -> Self

Set the active page (inline)

Unlike Self::set_active, this does not update anything; it is assumed that sizing happens afterwards.

pub fn set_active(&mut self, mgr: &mut ConfigMgr<'_>, index: usize)

Set the active page

Behaviour depends on whether SizeRules were already solved for index (see Self::set_size_limit and note that methods like Self::push do not solve rules for new pages). Case:

• index >= num_pages: no page displayed
• index == active and SizeRules were solved: nothing happens
• SizeRules were solved: set layout (Layout::set_rect) and update mouse-cursor target (TkAction::REGION_MOVED)
• Otherwise: resize the whole window (TkAction::RESIZE)

pub fn get_active(&self) -> Option<&W>

Get a direct reference to the active child widget, if any

pub fn is_empty(&self) -> bool

True if there are no pages

pub fn len(&self) -> usize

Returns the number of pages

pub fn clear(&mut self)

Remove all pages

This does not change the active page index.

pub fn get(&self, index: usize) -> Option<&W>

Get a page

pub fn get_mut(&mut self, index: usize) -> Option<&mut W>

Get a page

pub fn get_tab(&self, index: usize) -> Option<&Tab>

Get a tab

pub fn get_tab_mut(&mut self, index: usize) -> Option<&mut Tab>

Get a tab

pub fn with_tab(self, tab: Tab, widget: W) -> Self

Append a page (inline)

Does not configure or size child.

pub fn with_title(self, title: impl Into<AccelString>, widget: W) -> Self

Append a page (inline)

Does not configure or size child.

pub fn push(&mut self, mgr: &mut ConfigMgr<'_>, tab: Tab, widget: W) -> usize

Append a page

The new page is configured immediately. If it becomes the active page and then TkAction::RESIZE will be triggered.

Returns the new page’s index.

pub fn pop(&mut self, mgr: &mut ConfigMgr<'_>) -> Option<(Tab, W)>

Remove the last child widget (if any) and return

If this page was active then the previous page becomes active.

pub fn insert(&mut self, mgr: &mut ConfigMgr<'_>, index: usize, tab: Tab, widget: W)

Inserts a child widget position index

Panics if index > len.

The new child is configured immediately. The active page does not change.

pub fn remove(&mut self, mgr: &mut ConfigMgr<'_>, index: usize) -> (Tab, W)

Removes the child widget at position index

Panics if index is out of bounds.

If the active page is removed then the previous page (if any) becomes active.

pub fn replace(&mut self, mgr: &mut ConfigMgr<'_>, index: usize, w: W) -> W

Replace the child at index

Panics if index is out of bounds.

The new child is configured immediately. If it replaces the active page, then TkAction::RESIZE is triggered.

pub fn extend<T: IntoIterator<Item = (Tab, W)>>(
    &mut self,
    mgr: &mut ConfigMgr<'_>,
    iter: T
)

Append child widgets from an iterator

New children are configured immediately. If a new page becomes active, then TkAction::RESIZE is triggered.

Trait Implementations

impl<W: Widget> AutoLayout for TabStack<W>

fn size_rules(&mut self, size_mgr: SizeMgr<'_>, axis: AxisInfo) -> SizeRules

Get size rules for the given axis

fn set_rect(&mut self, mgr: &mut ConfigMgr<'_>, rect: Rect)

Set size and position

fn find_id(&mut self, coord: Coord) -> Option<WidgetId>

Translate a coordinate to a WidgetId

fn draw(&mut self, draw: DrawMgr<'_>)

Draw a widget and its children

impl<W: Clone + Widget> Clone for TabStack<W>

fn clone(&self) -> TabStack<W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W: Debug + Widget> Debug for TabStack<W>

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

Formats the value using the given formatter.

impl<W: Widget> Default for TabStack<W>

fn default() -> Self

Returns the “default value” for a type.

impl<W: Widget, T: IntoIterator<Item = (Tab, W)>> From<T> for TabStack<W>

fn from(iter: T) -> Self

Converts to this type from the input type.

impl<W: Widget> Layout for TabStack<W>

fn size_rules(&mut self, size_mgr: SizeMgr<'_>, axis: AxisInfo) -> SizeRules

Get size rules for the given axis

fn set_rect(&mut self, mgr: &mut ConfigMgr<'_>, rect: Rect)

Set size and position

fn find_id(&mut self, coord: Coord) -> Option<WidgetId>

Translate a coordinate to a WidgetId

fn draw(&mut self, draw: DrawMgr<'_>)

Draw a widget and its children

impl<W: Widget> Widget for TabStack<W>

fn nav_next(
    &mut self,
    _: &mut ConfigMgr<'_>,
    reverse: bool,
    from: Option<usize>
) -> Option<usize>

Navigation in spatial order

fn handle_message(&mut self, mgr: &mut EventMgr<'_>, _: usize)

Handler for messages from children/descendants

fn pre_configure(&mut self, _: &mut ConfigMgr<'_>, id: WidgetId)

Pre-configuration

fn configure(&mut self, mgr: &mut ConfigMgr<'_>)

Configure widget

fn navigable(&self) -> bool

Is this widget navigable via Tab key?

fn translation(&self) -> Offset

Get translation of children relative to this widget

fn handle_event(&mut self, mgr: &mut EventMgr<'_>, event: Event) -> Response

Handle an event sent to this widget

fn steal_event(
    &mut self,
    mgr: &mut EventMgr<'_>,
    id: &WidgetId,
    event: &Event
) -> Response

Potentially steal an event before it reaches a child

fn handle_unused(
    &mut self,
    mgr: &mut EventMgr<'_>,
    index: usize,
    event: Event
) -> Response

Handle an event sent to child index but left unhandled

fn handle_scroll(&mut self, mgr: &mut EventMgr<'_>, scroll: Scroll)

Handler for scrolling

impl<W: Widget> WidgetChildren for TabStack<W>

fn num_children(&self) -> usize

Get the number of child widgets

fn get_child(&self, _index: usize) -> Option<&dyn Widget>

Get a reference to a child widget by index, or None if the index is out of bounds.

fn get_child_mut(&mut self, _index: usize) -> Option<&mut dyn Widget>

Mutable variant of get

fn find_child_index(&self, id: &WidgetId) -> Option<usize>

Find the child which is an ancestor of this id, if any

fn make_child_id(&mut self, index: usize) -> WidgetId

Make an identifier for a child

impl<W: Widget> WidgetCore for TabStack<W>

fn id_ref(&self) -> &WidgetId

Get the widget’s identifier

fn rect(&self) -> Rect

Get the widget’s region, relative to its parent.

fn widget_name(&self) -> &'static str

Get the name of the widget struct

fn as_widget(&self) -> &dyn Widget

Erase type

fn as_widget_mut(&mut self) -> &mut dyn Widget

Erase type