Struct PaneGrid 

pub struct PaneGrid<'a, Message, Theme = Theme, Renderer = Renderer<Renderer, Renderer>>
where
    Theme: Catalog,
    Renderer: Renderer,
{ /* private fields */ }

A collection of panes distributed using either vertical or horizontal splits to completely fill the space available.

This distribution of space is common in tiling window managers (like awesome, i3, or even tmux).

A PaneGrid supports:

• Vertical and horizontal splits
• Tracking of the last active pane
• Mouse-based resizing
• Drag and drop to reorganize panes
• Hotkey support
• Configurable modifier keys
• State API to perform actions programmatically (split, swap, resize, etc.)

Example

use iced::widget::{pane_grid, text};

struct State {
    panes: pane_grid::State<Pane>,
}

enum Pane {
    SomePane,
    AnotherKindOfPane,
}

enum Message {
    PaneDragged(pane_grid::DragEvent),
    PaneResized(pane_grid::ResizeEvent),
}

fn view(state: &State) -> Element<'_, Message> {
    pane_grid(&state.panes, |pane, state, is_maximized| {
        pane_grid::Content::new(match state {
            Pane::SomePane => text("This is some pane"),
            Pane::AnotherKindOfPane => text("This is another kind of pane"),
        })
    })
    .on_drag(Message::PaneDragged)
    .on_resize(10, Message::PaneResized)
    .into()
}

Implementations

impl<'a, Message, Theme, Renderer> PaneGrid<'a, Message, Theme, Renderer>

where Theme: Catalog, Renderer: Renderer,

pub fn new<T>( state: &'a State<T>, view: impl Fn(Pane, &'a T, bool) -> Content<'a, Message, Theme, Renderer>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Creates a PaneGrid with the given State and view function.

The view function will be called to display each Pane present in the State. bool is set if the pane is maximized.

pub fn width( self, width: impl Into<Length>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Sets the width of the PaneGrid.

pub fn height( self, height: impl Into<Length>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Sets the height of the PaneGrid.

pub fn spacing( self, amount: impl Into<Pixels>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Sets the spacing between the panes of the PaneGrid.

pub fn min_size( self, min_size: impl Into<Pixels>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Sets the minimum size of a Pane in the PaneGrid on both axes.

pub fn on_click<F>(self, f: F) -> PaneGrid<'a, Message, Theme, Renderer>

where F: 'a + Fn(Pane) -> Message,

Sets the message that will be produced when a Pane of the PaneGrid is clicked.

pub fn on_drag<F>(self, f: F) -> PaneGrid<'a, Message, Theme, Renderer>

where F: 'a + Fn(DragEvent) -> Message,

Enables the drag and drop interactions of the PaneGrid, which will use the provided function to produce messages.

pub fn on_resize<F>( self, leeway: impl Into<Pixels>, f: F, ) -> PaneGrid<'a, Message, Theme, Renderer>

where F: 'a + Fn(ResizeEvent) -> Message,

Enables the resize interactions of the PaneGrid, which will use the provided function to produce messages.

The leeway describes the amount of space around a split that can be used to grab it.

The grabbable area of a split will have a length of spacing + leeway, properly centered. In other words, a length of (spacing + leeway) / 2.0 on either side of the split line.

pub fn on_focus_cycle<F>(self, f: F) -> PaneGrid<'a, Message, Theme, Renderer>

where F: 'a + Fn(Pane) -> Message,

Sets the callback for focus cycling via F6 / Shift+F6.

When the user presses F6, the next Pane in order is published. Shift+F6 cycles in reverse. The application is responsible for tracking which pane is focused and passing it via Self::focused_pane.

pub fn focused_pane(self, pane: Pane) -> PaneGrid<'a, Message, Theme, Renderer>

Sets the currently focused Pane.

This is used by Self::on_focus_cycle to determine the starting point when cycling panes with F6 / Shift+F6. If no pane is focused, cycling starts from the first pane.

pub fn style( self, style: impl Fn(&Theme) -> Style + 'a, ) -> PaneGrid<'a, Message, Theme, Renderer>

where <Theme as Catalog>::Class<'a>: From<Box<dyn Fn(&Theme) -> Style + 'a>>,

Sets the style of the PaneGrid.

pub fn class( self, class: impl Into<<Theme as Catalog>::Class<'a>>, ) -> PaneGrid<'a, Message, Theme, Renderer>

Available on crate feature advanced only.

Sets the style class of the PaneGrid.

Trait Implementations

impl<'a, Message, Theme, Renderer> From<PaneGrid<'a, Message, Theme, Renderer>> for Element<'a, Message, Theme, Renderer>

where Message: 'a, Theme: Catalog + 'a, Renderer: Renderer + 'a,

fn from( pane_grid: PaneGrid<'a, Message, Theme, Renderer>, ) -> Element<'a, Message, Theme, Renderer>

Converts to this type from the input type.

impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer> for PaneGrid<'_, Message, Theme, Renderer>

where Theme: Catalog, Renderer: Renderer,

fn tag(&self) -> Tag

Returns the Tag of the Widget.

fn state(&self) -> State

Returns the State of the Widget.

fn children(&self) -> Vec<Tree>

Returns the state Tree of the children of the Widget.

fn diff(&self, tree: &mut Tree)

Reconciles the Widget with the provided Tree.

fn size(&self) -> Size<Length>

Returns the Size of the Widget in lengths.

fn layout( &mut self, tree: &mut Tree, renderer: &Renderer, limits: &Limits, ) -> Node

Returns the layout::Node of the Widget.

fn operate( &mut self, tree: &mut Tree, layout: Layout<'_>, renderer: &Renderer, operation: &mut dyn Operation, )

Applies an Operation to the Widget.

fn update( &mut self, tree: &mut Tree, event: &Event, layout: Layout<'_>, cursor: Cursor, renderer: &Renderer, shell: &mut Shell<'_, Message>, viewport: &Rectangle, )

Processes a runtime Event.

fn mouse_interaction( &self, tree: &Tree, layout: Layout<'_>, cursor: Cursor, viewport: &Rectangle, renderer: &Renderer, ) -> Interaction

Returns the current mouse::Interaction of the Widget.

fn draw( &self, tree: &Tree, renderer: &mut Renderer, theme: &Theme, defaults: &Style, layout: Layout<'_>, cursor: Cursor, viewport: &Rectangle, )

Draws the Widget using the associated Renderer.

fn overlay<'b>( &'b mut self, tree: &'b mut Tree, layout: Layout<'b>, renderer: &Renderer, viewport: &Rectangle, translation: Vector, ) -> Option<Element<'b, Message, Theme, Renderer>>

Returns the overlay of the Widget, if there is any.

fn size_hint(&self) -> Size<Length>

Returns a Size hint for laying out the Widget.