Struct GridLayoutState 

pub struct GridLayoutState { /* private fields */ }

The state of a GridLayout: the items’ areas, the rules the layout settles under, and any gesture in progress.

The application owns the layout. Create the state with the grid’s rules, then its areas, and subscribe to GridLayoutEvent::Change to persist what the user arranges.

let state = cx.new(|cx| {
    GridLayoutState::new(cx).cols(12).default_areas([
        GridArea::new("revenue").col_span(8).row_span(4),
        GridArea::new("orders").col(8).col_span(4).row_span(4),
    ])
});

Implementations

impl GridLayoutState

pub fn new(cx: &mut App) -> Self

An empty, 12-column grid that compacts vertically.

pub fn cols(self, cols: usize) -> Self

The number of equal columns the width is divided into. Defaults to 12.

pub fn compaction(self, compaction: Option<Axis>) -> Self

The direction items float toward when space opens up, or None to leave them wherever they are put. Defaults to Some(Axis::Vertical).

pub fn prevent_collision(self, prevent_collision: bool) -> Self

Refuse a move or resize that would overlap another item, instead of pushing that item out of the way. Defaults to false.

pub fn draggable(self, draggable: bool) -> Self

Whether items can be moved. Defaults to true.

pub fn resizable(self, resizable: bool) -> Self

Whether items can be resized. Defaults to true.

pub fn default_areas(self, areas: impl IntoIterator<Item = GridArea>) -> Self

The areas the grid starts with, settled under the rules set so far: overlaps are pushed apart and, with compaction on, gaps close. Set the rules first.

pub fn areas(&self) -> &[GridArea]

The committed layout, in the order the areas were given.

pub fn area(&self, id: &str) -> Option<&GridArea>

The area of the item id.

pub fn column_count(&self) -> usize

pub fn compaction_axis(&self) -> Option<Axis>

pub fn is_collision_prevented(&self) -> bool

pub fn is_draggable(&self) -> bool

pub fn is_resizable(&self) -> bool

pub fn selected_item(&self) -> Option<&SharedString>

The item keyboard commands act on.

pub fn active_item(&self) -> Option<&SharedString>

The item being dragged or resized, if a gesture is in progress.

pub fn set_areas( &mut self, areas: impl IntoIterator<Item = GridArea>, cx: &mut Context<'_, Self>, )

Replace the layout, settling it under the grid’s rules. Cancels any gesture in progress, and does not emit GridLayoutEvent::Change.

pub fn set_cols(&mut self, cols: usize, cx: &mut Context<'_, Self>)

pub fn set_compaction( &mut self, compaction: Option<Axis>, cx: &mut Context<'_, Self>, )

pub fn set_prevent_collision( &mut self, prevent_collision: bool, cx: &mut Context<'_, Self>, )

pub fn set_draggable(&mut self, draggable: bool, cx: &mut Context<'_, Self>)

pub fn set_resizable(&mut self, resizable: bool, cx: &mut Context<'_, Self>)

pub fn set_selected_item( &mut self, id: Option<SharedString>, cx: &mut Context<'_, Self>, )

Select the item keyboard commands act on.

pub fn move_item( &mut self, id: &str, col: usize, row: usize, cx: &mut Context<'_, Self>, ) -> bool

Move the item id so its leading column is col and its top row row, pushing whatever it lands on out of the way. Returns whether the layout changed; a refused or no-op move returns false.

pub fn resize_item( &mut self, id: &str, col_span: usize, row_span: usize, cx: &mut Context<'_, Self>, ) -> bool

Resize the item id to cover col_span columns and row_span rows, clamped to its limits. Returns whether the layout changed.

Trait Implementations

impl EventEmitter<GridLayoutEvent> for GridLayoutState