Struct Stack 

pub struct Stack<A> { /* 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.

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.

Messages

kas::messages::SetIndex may be used to change the page.

Implementations

impl<A> Stack<A>

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 this method is only used before the UI is run.

pub fn set_active(&mut self, cx: &mut ConfigCx<'_>, data: &A, index: usize)

Set the active page

pub fn get_active(&self) -> Option<&Page<A>>

Get a direct reference to the active child page, 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<&Page<A>>

Returns a reference to the page, if any

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

Returns a mutable reference to the page, if any

pub fn push(&mut self, cx: &mut ConfigCx<'_>, data: &A, page: Page<A>) -> 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<Page<A>>

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: &A, index: usize, page: Page<A>, )

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) -> Page<A>

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: &A, index: usize, page: Page<A>, ) -> Page<A>

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 = Page<A>>>( &mut self, cx: &mut ConfigCx<'_>, data: &A, 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) -> Page<A>>( &mut self, cx: &mut ConfigCx<'_>, data: &A, 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<A> Default for Stack<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A> Events for Stack<A>

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 handle_messages(&mut self, cx: &mut EventCx<'_>, data: &A)

Handler for messages from children/descendants

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

Handle an Event

const REDRAW_ON_MOUSE_OVER: bool = false

Does this widget have a different appearance on mouse over?

fn mouse_over_icon(&self) -> Option<CursorIcon>

The mouse cursor icon to use on mouse over

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

Update self using input data

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

Update children

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

Mouse focus handler

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

Handler for scrolling

impl<A, I> From<I> for Stack<A>

where I: IntoIterator<Item = Page<A>>,

fn from(iter: I) -> Self

Converts to this type from the input type.

impl<A> Index<usize> for Stack<A>

type Output = Page<A>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<A> IndexMut<usize> for Stack<A>

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

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

impl<A> Layout for Stack<A>

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, hints: AlignHints)

Set size and position

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

Draw a widget and its children

fn rect(&self) -> Rect

Get the widget’s region

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

Probe a coordinate for a widget’s Id

impl<A> Tile for Stack<A>

fn role(&self, _: &mut dyn RoleCx) -> Role<'_>

Describe the widget’s role

fn child_indices(&self) -> ChildIndices

Get child indices available to recursion

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

Access a child as a dyn Tile, if available

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

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

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

Navigation in spatial order

fn probe(&self, coord: Coord) -> Id

Probe a coordinate for a widget’s Id

fn as_tile(&self) -> &dyn Tile

Get as a dyn Tile

fn id_ref(&self) -> &Id

Get a reference to the widget’s identifier

fn identify(&self) -> IdentifyWidget<'_>

Return a Display-able widget identifier

fn id(&self) -> Id

Get the widget’s identifier

fn navigable(&self) -> bool

Whether this widget supports navigation focus

fn tooltip(&self) -> Option<&str>

Tooltip

fn role_child_properties(&self, cx: &mut dyn RoleCx, index: usize)

Specify additional role properties for child index

fn translation(&self, index: usize) -> Offset

Get translation of child index relative to this widget

impl<A> Widget for Stack<A>

type Data = A

Input data type

fn child_node<'n>(&'n mut self, data: &'n A, index: usize) -> Option<Node<'n>>

Access a child as a Node, if available

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

Erase type