Struct kas::widgets::List

pub struct List<D, W>where
    D: Directional,
    W: Widget,{ /* private fields */ }

A generic row/column widget

This type is roughly Vec but for widgets. Generics:

• D: Directional — fixed or run-time direction of layout
• W: Widget — type of widget

Alternatives

Some more specific type-defs are available:

• Row and Column fix the direction D
• BoxList fixes the widget type to Box<dyn Widget>
• BoxRow and BoxColumn fix both type parameters

Performance

Configuring and resizing elements is O(n) in the number of children. Drawing and event handling is O(log n) in the number of children (assuming only a small number are visible at any one time).

Messages

If a handler is specified via Self::on_message then this handler is called when a child pushes a message. This allows associating the child’s index with a message.

Implementations

impl<D, W> List<D, W>where D: Directional + Default, W: Widget,

pub fn new() -> List<D, W>

Construct a new instance

This constructor is available where the direction is determined by the type: for D: Directional + Default. In other cases, use Self::new_dir.

pub fn new_vec(widgets: Vec<W, Global>) -> List<D, W>

Construct a new instance with vec

This constructor is available where the direction is determined by the type: for D: Directional + Default. In other cases, use Self::new_dir_vec.

impl<W> List<Direction, W>where W: Widget,

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

Set the direction of contents

impl<D, W> List<D, W>where D: Directional, W: Widget,

pub fn new_dir(direction: D) -> List<D, W>

Construct a new instance with explicit direction

pub fn new_dir_vec(direction: D, widgets: Vec<W, Global>) -> List<D, W>

Construct a new instance with explicit direction and vec

pub fn set_on_message(&mut self, f: Option<fn(_: &mut EventMgr<'_>, _: usize)>)

Assign a child message handler

This handler (if any) is called when a child pushes a message: f(mgr, index), where index is the child’s index.

pub fn on_message(self, f: fn(_: &mut EventMgr<'_>, _: usize)) -> List<D, W>

Assign a child message handler (inline style)

This handler is called when a child pushes a message: f(mgr, index), where index is the child’s index.

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

Edit the list of children directly

This may be used to edit children 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, Action::RECONFIGURE).

pub fn direction(&self) -> Direction

Get the direction of contents

pub fn layout_storage(&mut self) -> &mut impl RowStorage

Access layout storage

The number of columns/rows is [Self.len].

pub fn is_empty(&self) -> bool

True if there are no child widgets

pub fn len(&self) -> usize

Returns the number of child widgets

pub fn clear(&mut self)

Remove all child widgets

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

Returns a reference to the child, if any

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

Returns a mutable reference to the child, if any

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

Append a child widget

The new child is configured immediately. Action::RESIZE is triggered.

Returns the new element’s index.

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

Remove the last child widget (if any) and return

Triggers Action::RESIZE.

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. Triggers Action::RESIZE.

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.

Triggers Action::RESIZE.

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. Triggers Action::RESIZE.

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

Append child widgets from an iterator

New children are configured immediately. Triggers Action::RESIZE.

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

Resize, using the given closure to construct new widgets

New children are configured immediately. Triggers Action::RESIZE.

pub fn iter(&self) -> impl Iterator<Item = &W>

Iterate over childern

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut W>

Mutably iterate over childern

Trait Implementations

impl<D, W> AutoLayout for List<D, W>where D: Directional, W: Widget,

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<D, W> Clone for List<D, W>where D: Directional, W: Widget + Clone,

fn clone(&self) -> List<D, W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D, W> Debug for List<D, W>where D: Directional, W: Widget,

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

Formats the value using the given formatter.

impl<D, W> Default for List<D, W>where D: Directional + Default, W: Widget,

fn default() -> List<D, W>

Returns the “default value” for a type.

impl<D, W> FromIterator<W> for List<D, W>where D: Directional + Default, W: Widget,

fn from_iter<T>(iter: T) -> List<D, W>where T: IntoIterator<Item = W>,

Creates a value from an iterator.

impl<D, W> Index<usize> for List<D, W>where D: Directional, W: Widget,

type Output = W

The returned type after indexing.

fn index(&self, index: usize) -> &<List<D, W> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<D, W> IndexMut<usize> for List<D, W>where D: Directional, W: Widget,

fn index_mut( &mut self, index: usize ) -> &mut <List<D, W> as Index<usize>>::Output

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

impl<D, W> Layout for List<D, W>where D: Directional, W: Widget,

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<D, W> Widget for List<D, W>where D: Directional, W: Widget,

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

Pre-configuration

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

Handler for messages from children/descendants

fn nav_next( &mut self, _: &mut ConfigMgr<'_>, reverse: 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<'_>, 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<D, W> WidgetChildren for List<D, W>where D: Directional, W: Widget,

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<D, W> WidgetCore for List<D, W>where D: Directional, W: Widget,

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