Struct kas_widgets::Grid

pub struct Grid<W: Widget> { /* fields omitted */ }

A generic grid widget

Child widgets are displayed in a grid, according to each child’s GridChildInfo. 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).

Most operations (configuring, resizing and drawing) are O(n) in the number of children. This type is generic over the type of child widgets.

For fixed layouts, an alternative is to construct a custom widget with kas::macros::make_widget which can also perform event handling.

Implementations

impl<W: Widget> Grid<W>

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

Construct a new instance

pub fn dimensions(&self) -> (usize, usize)

Calculate the numbers of columns and rows

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 add_cell(&mut self, widget: W, col: u32, row: u32) -> TkAction

Add a widget to a particular cell

This is just a convenient way to construct a GridChildInfo.

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

Append a child widget

Triggers a reconfigure action.

pub fn pop(&mut self) -> (Option<(W, GridChildInfo)>, 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, GridChildInfo)) -> TkAction

Inserts a child widget position index

Panics if index > len.

Triggers a reconfigure action.

pub fn remove(&mut self, index: usize) -> ((W, GridChildInfo), 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, GridChildInfo)
) -> ((W, GridChildInfo), TkAction)

Replace the child at index

Panics if index is out of bounds.

Triggers a reconfigure action.

pub fn extend<T: IntoIterator<Item = (W, GridChildInfo)>>(
    &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, GridChildInfo)>(
    &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, GridChildInfo)) -> 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(&self) -> impl Iterator<Item = &W>

Iterate over childern

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

Get the index of the child which is an ancestor of id, if any

Trait Implementations

impl<W: Clone + Widget> Clone for Grid<W>

fn clone(&self) -> Grid<W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W: Debug + Widget> Debug for Grid<W>

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

Formats the value using the given formatter.

impl<W: Default + Widget> Default for Grid<W>

fn default() -> Grid<W>

Returns the “default value” for a type.

impl<W: Widget> Handler for Grid<W>

type Msg = (usize, <W as Handler>::Msg)

Type of message returned by this widget

fn activation_via_press(&self) -> bool

Generic handler: translate presses to activations

fn focus_on_key_nav(&self) -> bool

Generic handler: focus rect on key navigation

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

Handle an event and return a user-defined message

impl<W: Widget> Index<usize> for Grid<W>

type Output = (W, GridChildInfo)

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

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

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

impl<W: Widget> Layout for Grid<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, mgr: &mut Manager<'_>, rect: Rect, align: AlignHints)

Apply a given rect to self

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

Get translation of a child

fn spatial_nav(
    &mut self,
    mgr: &mut Manager<'_>,
    reverse: bool,
    from: Option<usize>
) -> Option<usize>

Navigation in spatial order

impl<W: Widget> SendEvent for Grid<W>

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

Send an event

impl<W: Widget> WidgetChildren for Grid<W>

fn first_id(&self) -> WidgetId

Get the first identifier of self or any children

fn record_first_id(&mut self, id: WidgetId)

Record first identifier

fn num_children(&self) -> usize

Get the number of child widgets

fn get_child(&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_child_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_child(&self, id: WidgetId) -> Option<usize>

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

fn find_leaf(&self, id: WidgetId) -> Option<&(dyn WidgetConfig + 'static)>

Find the leaf (lowest descendant) with this id, if any

fn find_leaf_mut(
    &mut self,
    id: WidgetId
) -> Option<&mut (dyn WidgetConfig + 'static)>

Find the leaf (lowest descendant) with this id, if any

fn walk_children<F>(&self, f: F) where
    F: FnMut(&(dyn WidgetConfig + 'static)), 

Walk through all widgets, calling f once on each.

fn walk_children_mut<F>(&mut self, f: F) where
    F: FnMut(&mut (dyn WidgetConfig + 'static)), 

Walk through all widgets, calling f once on each.

impl<W: Widget> WidgetConfig for Grid<W>

fn key_nav(&self) -> bool

Is this widget navigable via Tab key?

fn hover_highlight(&self) -> bool

Does this widget have hover-state highlighting?

fn cursor_icon(&self) -> CursorIcon

Which cursor icon should be used on hover?

fn configure(&mut self, &mut Manager<'_>)

Configure widget

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

Configure self and children

impl<W: Widget> WidgetCore for Grid<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

Set the disabled state of a widget

fn with_disabled(self, disabled: bool) -> Self

Set disabled state (chaining)

fn rect(&self) -> Rect

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

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

Construct InputState

impl<W: Widget> Widget for Grid<W>