Struct kas::widget::List

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

A generic row/column widget

This type is generic over both directionality and the type of child widgets. Essentially, it is a Vec which also implements the Widget trait.

Row and Column are parameterisations with set directionality.

BoxList (and its derivatives BoxRow, BoxColumn) parameterise W = Box<dyn Widget>, thus supporting individually boxed child widgets. This allows use of multiple types of child widget at the cost of extra allocation, and requires dynamic dispatch of methods.

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

For fixed configurations of child widgets, make_widget can be used instead. make_widget has the advantage that it can support child widgets of multiple types without allocation and via static dispatch, but the disadvantage that drawing and event handling are O(n) in the number of children.

Methods

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

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

Construct a new instance

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

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

pub fn new_with_direction(direction: D, widgets: Vec<W>) -> Self

Construct a new instance with explicit direction

pub fn direction(&self) -> Direction

Get the direction of contents

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

Returns the number of elements the vector can hold without reallocating.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted into the list. See documentation of Vec::reserve.

pub fn clear(&mut self) -> TkAction

Remove all child widgets

Triggers a reconfigure action if any widget is removed.

pub fn push(&mut self, widget: W) -> TkAction

Append a child widget

Triggers a reconfigure action.

pub fn pop(&mut self) -> (Option<W>, TkAction)

Remove the last child widget

Returns None if there are no children. Otherwise, this triggers a reconfigure before the next draw operation.

Triggers a reconfigure action if any widget is removed.

pub fn insert(&mut self, index: usize, widget: W) -> TkAction

Inserts a child widget position index

Panics if index > len.

Triggers a reconfigure action.

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

Removes the child widget at position index

Panics if index is out of bounds.

Triggers a reconfigure action.

pub fn replace(&mut self, index: usize, widget: W) -> (W, TkAction)

Replace the child at index

Panics if index is out of bounds.

Triggers a reconfigure action.

pub fn extend<T: IntoIterator<Item = W>>(&mut self, iter: T) -> TkAction

Append child widgets from an iterator

Triggers a reconfigure action if any widgets are added.

pub fn resize_with<F: Fn(usize) -> W>(&mut self, len: usize, f: F) -> TkAction

Resize, using the given closure to construct new widgets

Triggers a reconfigure action.

pub fn retain<F: FnMut(&W) -> bool>(&mut self, f: F) -> TkAction

Retain only widgets satisfying predicate f

See documentation of Vec::retain.

Triggers a reconfigure action if any widgets are removed.

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

Iterate over childern

Trait Implementations

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

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

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

Formats the value using the given formatter.

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

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

Returns the "default value" for a type.

impl<D: Directional, W: Widget> Handler for List<D, W>

type Msg = <W as Handler>::Msg

Type of message returned by this widget

fn activation_via_press(&self) -> bool

Generic handler: translate presses to activations

fn handle(&mut self, _: &mut Manager, event: Event) -> Response<Self::Msg>

Handle an event and return a user-defined message

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

type Output = W

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

fn size_rules(
    &mut self,
    size_handle: &mut dyn SizeHandle,
    axis: AxisInfo
) -> SizeRules

Get size rules for the given axis

fn set_rect(&mut self, rect: Rect, align: AlignHints)

Apply a given rect to self

fn spatial_range(&self) -> (usize, usize)

Iterate through children in spatial order

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

Find a widget by coordinate

fn draw(
    &self,
    draw_handle: &mut dyn DrawHandle,
    mgr: &ManagerState,
    disabled: bool
)

Draw a widget and its children

fn translation(&self, _child_index: usize) -> Coord

Get translation of a child

impl<D: Directional, W: Widget> SendEvent for List<D, W>

fn send(
    &mut self,
    mgr: &mut Manager,
    id: WidgetId,
    event: Event
) -> Response<Self::Msg>

Send an event

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

impl<D: Directional, W: Widget> WidgetChildren for List<D, W>

fn len(&self) -> usize

Get the number of child widgets

fn get(&self, index: usize) -> Option<&dyn WidgetConfig>

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

fn get_mut(&mut self, index: usize) -> Option<&mut dyn WidgetConfig>

Mutable variant of get

fn is_ancestor_of(&self, id: WidgetId) -> bool

Check whether id is a descendant

fn find(&self, id: WidgetId) -> Option<&dyn WidgetConfig>

Find a child widget by identifier

fn find_mut(&mut self, id: WidgetId) -> Option<&mut dyn WidgetConfig>

Find a child widget by identifier

fn walk(&self, f: &mut dyn FnMut(&dyn WidgetConfig))

Walk through all widgets, calling f once on each.

fn walk_mut(&mut self, f: &mut dyn FnMut(&mut dyn WidgetConfig))

Walk through all widgets, calling f once on each.

impl<D: Directional, W: Widget> WidgetConfig for List<D, W>

fn key_nav(&self) -> bool

Is this widget navigable via Tab key?

fn cursor_icon(&self) -> CursorIcon

Which cursor icon should be used on hover?

fn configure(&mut self, _: &mut Manager)

Configure widget

fn configure_recurse<'a, 'b>(&mut self, cmgr: ConfigureManager<'a, 'b>)

Configure self and children

impl<D: Directional, W: Widget> WidgetCore for List<D, W>

fn as_any(&self) -> &dyn Any

Get self as type Any

fn as_any_mut(&mut self) -> &mut dyn Any

Get self as type Any (mutable)

fn core_data(&self) -> &CoreData

Get direct access to the CoreData providing property storage.

fn core_data_mut(&mut self) -> &mut CoreData

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

Get the name of the widget struct

fn as_widget(&self) -> &dyn WidgetConfig

Erase type

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

Erase type

fn id(&self) -> WidgetId

Get the widget's numeric identifier

fn is_disabled(&self) -> bool

Get whether the widget is disabled

fn set_disabled(&mut self, disabled: bool) -> TkAction

Get the disabled state of a widget

fn rect(&self) -> Rect

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

fn input_state(&self, mgr: &ManagerState, disabled: bool) -> InputState

Construct InputState