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).

By default, all pages are configured and sized. To avoid configuring hidden pages (thus preventing these pages from affecting size) call Self::set_size_limit or Self::with_size_limit.

Implementations

impl<W: Widget> Stack<W>

pub fn new() -> Self

Construct a new, empty instance

See also Stack::from.

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

Limit the number of pages considered and sized

By default, this is usize::MAX: all pages are configured and affect the stack’s size requirements.

Set this to 0 to avoid configuring all hidden pages. Set this to n to configure the active page and the first n pages.

pub fn with_size_limit(self, limit: usize) -> Self

Limit the number of pages configured and sized (inline)

By default, this is usize::MAX: all pages are configured and affect the stack’s size requirements.

Set this to 0 to avoid configuring all hidden pages. Set this to n to configure the active page and the first n pages.

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, cx: &mut ConfigCx<'_>, data: &W::Data, index: usize )

Set the active page

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 activen 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, cx: &mut ConfigCx<'_>, data: &W::Data, widget: W ) -> usize

Append a page

The new page is not made active (the active index may be changed to avoid this). Consider calling Self::set_active.

Returns the new page’s index.

pub fn pop(&mut self, cx: &mut EventState) -> Option<W>

Remove the last child widget (if any) and return

If this page was active then no page will be left active. Consider also calling Self::set_active.

pub fn insert( &mut self, cx: &mut ConfigCx<'_>, data: &W::Data, index: usize, widget: W )

Inserts a child widget position index

Panics if index > len.

The active page does not change (the index of the active page may change instead).

pub fn remove(&mut self, cx: &mut EventState, index: usize) -> W

Removes the child widget at position index

Panics if index is out of bounds.

If this page was active then no page will be left active. Consider also calling Self::set_active.

pub fn replace( &mut self, cx: &mut ConfigCx<'_>, data: &W::Data, index: usize, widget: W ) -> W

Replace the child at index

Panics if index is out of bounds.

If the new child replaces the active page then Action::RESIZE is triggered.

pub fn extend<T: IntoIterator<Item = W>>( &mut self, cx: &mut ConfigCx<'_>, data: &W::Data, iter: T )

Append child widgets from an iterator

The new pages are not made active (the active index may be changed to avoid this). Consider calling Self::set_active.

pub fn resize_with<F: Fn(usize) -> W>( &mut self, cx: &mut ConfigCx<'_>, data: &W::Data, len: usize, f: F )

Resize, using the given closure to construct new widgets

The new pages are not made active (the active index may be changed to avoid this). Consider calling Self::set_active.

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> Events for Stack<W>

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

Make an identifier for a child

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

Configure self

fn configure_recurse(&mut self, cx: &mut ConfigCx<'_>, data: &Self::Data)

Configure children

fn update_recurse(&mut self, cx: &mut ConfigCx<'_>, data: &Self::Data)

Update children

fn steal_event( &mut self, _: &mut EventCx<'_>, _: &Self::Data, _: &Id, _: &Event ) -> IsUsed

Potentially steal an event before it reaches a child

fn handle_event( &mut self, _: &mut EventCx<'_>, _: &Self::Data, _: Event ) -> IsUsed

Handle an Event

fn update(&mut self, cx: &mut ConfigCx<'_>, data: &Self::Data)

Update self using input data

fn navigable(&self) -> bool

Is this widget navigable via Tab key?

fn handle_hover(&mut self, cx: &mut EventCx<'_>, state: bool) -> IsUsed

Mouse focus handler

fn handle_messages(&mut self, cx: &mut EventCx<'_>, data: &Self::Data)

Handler for messages from children/descendants

fn handle_scroll( &mut self, cx: &mut EventCx<'_>, data: &Self::Data, scroll: Scroll )

Handler for scrolling

impl<W: Widget, I> From<I> for Stack<W>

where I: IntoIterator<Item = W>,

fn from(iter: I) -> Self

Converts to this type from the input type.

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 num_children(&self) -> usize

Get the number of child widgets

fn get_child(&self, index: usize) -> Option<&dyn Layout>

Access a child as a dyn Layout

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

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

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

Get size rules for the given axis

fn set_rect(&mut self, cx: &mut ConfigCx<'_>, rect: Rect)

Set size and position

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

Navigation in spatial order

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

Translate a coordinate to an Id

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

Draw a widget and its children

fn as_layout(&self) -> &dyn Layout

Get as a dyn Layout

fn id_ref(&self) -> &Id

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 translation(&self) -> Offset

Get translation of children relative to this widget

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

type Data = <W as Widget>::Data

Input data type

fn for_child_node( &mut self, data: &W::Data, index: usize, closure: Box<dyn FnOnce(Node<'_>) + '_> )

Call closure on child with given index, if index < self.num_children().

fn as_node<'a>(&'a mut self, data: &'a Self::Data) -> Node<'a>

Erase type