Struct Grid 

pub struct Grid<C: CellCollection> { /* private fields */ }

A generic grid widget

Child widgets are displayed in a grid, according to each child’s GridCellInfo. This allows spans and overlapping widgets. The numbers of rows and columns is determined automatically while the sizes of rows and columns are determined based on their contents (including special handling for spans, mostly with good results).

Note that all child widgets are stored in a list internally. The order of widgets in that list does not affect display position, but does have a few effects: (a) widgets may be accessed in this order via indexing, (b) widgets are configured and drawn in this order, (c) navigating through widgets with the Tab key currently uses the list order (though it may be changed in the future to use display order).

There is no protection against multiple widgets occupying the same cell. If this does happen, the last widget in that cell will appear on top, but overlapping widget drawing may not be pretty.

Alternatives

Where the entries are fixed, also consider custom Widget implementations.

Performance

Most operations are O(n) in the number of children.

Example

use kas::cell_collection;
let _grid = Grid::new(cell_collection! {
    (0, 0) => "one",
    (1, 0) => "two",
    (0..2, 1) => "three",
});

Implementations

impl<C: CellCollection> Grid<C>

pub fn new(widgets: C) -> Self

Construct a new instance

pub fn dimensions(&self) -> GridDimensions

Get grid dimensions

The numbers of rows, columns and spans is determined automatically.

pub fn layout_storage(&mut self) -> &mut (impl GridStorage + use<C>)

Access layout storage

Use Self::dimensions to get expected dimensions.

impl<W: Widget> Grid<Vec<(GridCellInfo, W)>>

pub fn build<F: FnOnce(GridBuilder<'_, W>)>(f: F) -> Self

Construct via a builder

pub fn edit<F: FnOnce(GridBuilder<'_, W>)>( &mut self, cx: &mut ConfigCx<'_>, data: &W::Data, f: F, )

Edit an existing grid via a builder

This method will reconfigure self and all children.

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 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 iter(&self) -> impl Iterator<Item = &(GridCellInfo, W)>

Iterate over childern

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

Mutably iterate over childern

Trait Implementations

impl<C: CellCollection> Events for Grid<C>

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 make_child_id(&mut self, index: usize) -> Id

Make an identifier for a child

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

Configure self

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

Configure children

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_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> FromIterator<(GridCellInfo, W)> for Grid<Vec<(GridCellInfo, W)>>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = (GridCellInfo, W)>,

Creates a value from an iterator.

impl<W: Widget> Index<usize> for Grid<Vec<(GridCellInfo, W)>>

type Output = (GridCellInfo, 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 Grid<Vec<(GridCellInfo, W)>>

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

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

impl<C: CellCollection> Layout for Grid<C>

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<C: CellCollection> Tile for Grid<C>

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

Describe the widget’s role

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 get_child(&self, index: usize) -> Option<&dyn Tile>

Access a child as a dyn Tile, if available

fn child_indices(&self) -> ChildIndices

Get child indices available to recursion

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

Navigation in spatial order

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

impl<C: CellCollection> Widget for Grid<C>

type Data = <C as Collection>::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