Struct Flow 

pub struct Flow<C: Collection, D: Directional> { /* private fields */ }

Rows or columns of content with line-splitting

This widget is a variant of List, arranging a linear Collection of children into multiple rows or columns with automatic splitting. Unlike Grid, items are not aligned across lines.

When the collection uses Vec, various methods to insert/remove elements are available.

Layout details

Currently only horizontal lines (rows) which wrap down to the next line are supported.

Width requirements depend on the desired numbers of columns; see Self::set_num_columns.

Items within each line are stretched (if any has non-zero Stretch priority) in accordance with SizeRules::solve_widths. It is not currently possible to adjust this (except by tweaking the stretchiness of items).

Performance

Sizing, drawing and event handling are all O(n) where n is the number of children.

Example

use kas::collection;

let list = Flow::right(collection![
    "A checkbox",
    CheckBox::new(|_, state: &bool| *state),
]);

Implementations

impl<C: Collection, D> Flow<C, D>

where D: Default + Directional,

pub fn new(widgets: C) -> Self

Construct a new instance with default-constructed direction

This constructor is available where the direction is determined by the type: for D: Directional + Default. The wrap direction is down or right.

Examples

Where widgets have the same type and the length is fixed, an array may be used:

use kas_widgets::{Label, Row};
let _ = Row::new([Label::new("left"), Label::new("right")]);

To support run-time insertion/deletion, use Vec:

use kas_widgets::{AdaptWidget, Button, Row};

#[derive(Clone, Debug)]
enum Msg {
    Add,
    Remove,
}

let _ = Row::new(vec![Button::label_msg("Add", Msg::Add)])
    .on_messages(|cx, row, data| {
        if let Some(msg) = cx.try_pop() {
            match msg {
                Msg::Add => {
                    let button = if row.len() % 2 == 0 {
                        Button::label_msg("Add", Msg::Add)
                    } else {
                        Button::label_msg("Remove", Msg::Remove)
                    };
                    row.push(cx, data, button);
                }
                Msg::Remove => {
                    let _ = row.pop(cx);
                }
            }
        }
    });

impl<C: Collection> Flow<C, Left>

pub fn left(widgets: C) -> Self

Construct a new instance with fixed direction

Lines flow from right-to-left, wrapping down.

impl<C: Collection> Flow<C, Right>

pub fn right(widgets: C) -> Self

Construct a new instance with fixed direction

Lines flow from left-to-right, wrapping down.

impl<C: Collection, D: Directional> Flow<C, D>

pub fn new_dir(widgets: C, direction: D) -> Self

Construct a new instance with explicit direction

pub fn set_num_columns(&mut self, min: i32, ideal: i32)

Set the (minimum, ideal) numbers of columns

This affects the final SizeRules for the horizontal axis.

By default, the values 1, 3 are used.

pub fn with_num_columns(self, min: i32, ideal: i32) -> Self

Set the (minimum, ideal) numbers of columns (inline)

This affects the final SizeRules for the horizontal axis.

By default, the values 1, 3 are used.

pub fn is_empty(&self) -> bool

True if there are no child widgets

pub fn len(&self) -> usize

Returns the number of child widgets

impl<W: Widget, D: Directional> Flow<Vec<W>, D>

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 clear(&mut self)

Remove all child widgets

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

Append a child widget

The new child is configured immediately. Triggers a resize.

Returns the new element’s index.

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

Remove the last child widget (if any) and return

Triggers a resize.

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 new child is configured immediately. Triggers a resize.

pub fn remove(&mut self, cx: &mut ConfigCx<'_>, index: usize) -> W

Removes the child widget at position index

Panics if index is out of bounds.

Triggers a resize.

pub fn truncate(&mut self, cx: &mut ConfigCx<'_>, len: usize)

Removes all children at positions ≥ len

Does nothing if self.len() < len.

Triggers a resize.

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.

The new child is configured immediately. Triggers a resize.

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

where T: IntoIterator<Item = W>,

Append child widgets from an iterator

New children are configured immediately. Triggers a resize.

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

where F: Fn(usize) -> W,

Resize, using the given closure to construct new widgets

New children are configured immediately. Triggers a 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<C, D> Default for Flow<C, D>

where C: Default + Collection, D: Default + Directional,

fn default() -> Self

Returns the “default value” for a type.

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

type Output = W

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<C: Collection, D: Directional> Layout for Flow<C, D>

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

Calculate size requirements for an axis

fn set_rect(&mut self, cx: &mut SizeCx<'_>, 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

impl<C: Collection, D: Directional> Tile for Flow<C, D>

fn try_probe(&self, coord: Coord) -> Option<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 id(&self) -> Id

Get the widget’s identifier

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

Return a Display-able widget identifier

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 translation(&self, index: usize) -> Offset

Get translation of child index relative to this widget

fn navigable(&self) -> bool

Whether this widget supports navigation focus

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

Tooltip

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

Describe the widget’s role

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

Specify additional role properties for child index

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

Navigation in spatial order

impl<C: Collection, D: Directional> Widget for Flow<C, D>

type Data = <List<C, D> as Widget>::Data

Input data type

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

Erase type

fn child_node<'__n>( &'__n mut self, data: &'__n Self::Data, index: usize, ) -> Option<Node<'__n>>

Access a child as a Node, if available