Struct State

pub struct State<T> {
    pub panes: BTreeMap<Pane, T>,
    pub internal: Internal,
}

The state of a PaneGrid.

It keeps track of the state of each Pane and the position of each Split.

The State needs to own any mutable contents a Pane may need. This is why this struct is generic over the type T. Values of this type are provided to the view function of PaneGrid::new for displaying each Pane.

Fields

panes: BTreeMap<Pane, T>

The panes of the PaneGrid.

internal: Internal

The internal state of the PaneGrid.

Implementations

impl<T> State<T>

pub fn new(first_pane_state: T) -> (State<T>, Pane)

Creates a new State, initializing the first pane with the provided state.

Alongside the State, it returns the first Pane identifier.

pub fn with_configuration(config: impl Into<Configuration<T>>) -> State<T>

Creates a new State with the given Configuration.

pub fn len(&self) -> usize

Returns the total amount of panes in the State.

pub fn is_empty(&self) -> bool

Returns true if the amount of panes in the State is 0.

pub fn get(&self, pane: Pane) -> Option<&T>

Returns the internal state of the given Pane, if it exists.

pub fn get_mut(&mut self, pane: Pane) -> Option<&mut T>

Returns the internal state of the given Pane with mutability, if it exists.

pub fn iter(&self) -> impl Iterator<Item = (&Pane, &T)>

Returns an iterator over all the panes of the State, alongside its internal state.

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

Returns a mutable iterator over all the panes of the State, alongside its internal state.

pub fn layout(&self) -> &Node

Returns the layout of the State.

pub fn adjacent(&self, pane: Pane, direction: Direction) -> Option<Pane>

Returns the adjacent Pane of another Pane in the given direction, if there is one.

pub fn split( &mut self, axis: Axis, pane: Pane, state: T, ) -> Option<(Pane, Split)>

Splits the given Pane into two in the given Axis and initializing the new Pane with the provided internal state.

pub fn split_with(&mut self, target: Pane, pane: Pane, region: Region)

Split a target Pane with a given Pane on a given Region.

Panes will be swapped by default for Region::Center.

pub fn drop(&mut self, pane: Pane, target: Target)

Drops the given Pane into the provided Target.

pub fn move_to_edge(&mut self, pane: Pane, edge: Edge)

Move Pane to an Edge of the PaneGrid.

pub fn swap(&mut self, a: Pane, b: Pane)

Swaps the position of the provided panes in the State.

If you want to swap panes on drag and drop in your PaneGrid, you will need to call this method when handling a DragEvent.

pub fn resize(&mut self, split: Split, ratio: f32)

Resizes two panes by setting the position of the provided Split.

The ratio is a value in [0, 1], representing the exact position of a Split between two panes.

If you want to enable resize interactions in your PaneGrid, you will need to call this method when handling a ResizeEvent.

pub fn close(&mut self, pane: Pane) -> Option<(T, Pane)>

Closes the given Pane and returns its internal state and its closest sibling, if it exists.

pub fn maximize(&mut self, pane: Pane)

Maximize the given Pane. Only this pane will be rendered by the PaneGrid until Self::restore() is called.

pub fn restore(&mut self)

Restore the currently maximized Pane to it’s normal size. All panes will be rendered by the PaneGrid.

pub fn maximized(&self) -> Option<Pane>

Returns the maximized Pane of the PaneGrid.

Trait Implementations

impl<T> Clone for State<T>

where T: Clone,

fn clone(&self) -> State<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for State<T>

where T: Debug,

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

Formats the value using the given formatter.