Struct kas_widgets::Stack

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

A 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” by calling Self::set_active.

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

Configuring is O(n) in the number of pages n. Resizing may be O(n) or may be limited: see Self::set_size_limit. Drawing is O(1), and so is event handling in the expected case.

Implementations

impl<W: Widget> Stack<W>

pub fn new() -> Self

Construct a new, empty instance

pub fn new_vec(widgets: Vec<W>) -> Self

Construct a new instance

Initially, the first page (if any) will be shown. Use Self::with_active to change this.

pub fn edit<F: FnOnce(&mut Vec<W>)>(&mut self, f: F) -> TkAction

Edit the list of children directly

This may be used to edit pages before window construction. It may also be used from a running UI, but in this case a full reconfigure of the window’s widgets is required (triggered by the the return value, TkAction::RECONFIGURE).

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 widget

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

Set the active widget (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>

Returns a reference to the page, if any

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

Returns a mutable reference to the page, if any

pub fn push(&mut self, mgr: &mut ConfigMgr<'_>, 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<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, 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) -> 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 = 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.

pub fn resize_with<F: Fn(usize) -> W>(
    &mut self,
    mgr: &mut ConfigMgr<'_>,
    len: usize,
    f: F
)

Resize, using the given closure to construct new widgets

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

Trait Implementations

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

fn clone(&self) -> Stack<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 Stack<W>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<W: Widget> FromIterator<W> for Stack<W>

fn from_iter<T>(iter: T) -> Selfwhere
    T: IntoIterator<Item = W>,

Creates a value from an iterator.

impl<W: Widget> Index<usize> for Stack<W>

type Output = W

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<W: Widget> IndexMut<usize> for Stack<W>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<W: Widget> Layout for Stack<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 Stack<W>

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

Pre-configuration

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

Navigation in spatial order

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_message(&mut self, mgr: &mut EventMgr<'_>, index: usize)

Handler for messages from children/descendants

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

Handler for scrolling

impl<W: Widget> WidgetChildren for Stack<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 Stack<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