Struct iced_native::widget::pane_grid::PaneGrid

pub struct PaneGrid<'a, Message, Renderer> { /* fields omitted */ }

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

enum PaneState {
    SomePane,
    AnotherKindOfPane,
}

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

let (mut state, _) = pane_grid::State::new(PaneState::SomePane);

let pane_grid =
    PaneGrid::new(&mut state, |pane, state, focus| {
        match state {
            PaneState::SomePane => Text::new("This is some pane"),
            PaneState::AnotherKindOfPane => Text::new("This is another kind of pane"),
        }.into()
    })
    .on_drag(Message::PaneDragged)
    .on_resize(Message::PaneResized);

Methods

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

pub fn new<T>(
    state: &'a mut State<T>,
    view: impl Fn(Pane, &'a mut T, Option<Focus>) -> Element<'a, Message, Renderer>
) -> Self

Creates a PaneGrid with the given State and view function.

The view function will be called to display each Pane present in the State.

pub fn width(self, width: Length) -> Self

Sets the width of the PaneGrid.

pub fn height(self, height: Length) -> Self

Sets the height of the PaneGrid.

pub fn spacing(self, units: u16) -> Self

Sets the spacing between the panes of the PaneGrid.

pub fn modifier_keys(self, modifier_keys: ModifiersState) -> Self

Sets the modifier keys of the PaneGrid.

The modifier keys will need to be pressed to trigger dragging, resizing, and key events.

The default modifier key is Ctrl.

pub fn on_drag<F>(self, f: F) -> Self where
    F: 'a + Fn(DragEvent) -> Message, 

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

Panes can be dragged using Modifier keys + Left click.

pub fn on_resize<F>(self, f: F) -> Self where
    F: 'a + Fn(ResizeEvent) -> Message, 

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

Panes can be resized using Modifier keys + Right click.

pub fn on_key_press<F>(self, f: F) -> Self where
    F: 'a + Fn(KeyPressEvent) -> Option<Message>, 

Captures hotkey interactions with the PaneGrid, using the provided function to produce messages.

The function will be called when:

• a Pane is focused
• a key is pressed
• all the modifier keys are pressed

If the function returns None, the key press event will be discarded without producing any message.

This method is particularly useful to implement hotkey interactions. For instance, you can use it to enable splitting, swapping, or resizing panes by pressing combinations of keys.

Trait Implementations

impl<'a, Message, Renderer> From<PaneGrid<'a, Message, Renderer>> for Element<'a, Message, Renderer> where
    Renderer: 'static + Renderer,
    Message: 'a, 

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

Performs the conversion.

impl<'a, Message, Renderer> Widget<Message, Renderer> for PaneGrid<'a, Message, Renderer> where
    Renderer: 'static + Renderer, 

fn width(&self) -> Length

Returns the width of the [Widget].

fn height(&self) -> Length

Returns the height of the [Widget].

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

Returns the [Node] of the [Widget].

fn on_event(
    &mut self,
    event: Event,
    layout: Layout,
    cursor_position: Point,
    messages: &mut Vec<Message>,
    renderer: &Renderer,
    clipboard: Option<&dyn Clipboard>
)

Processes a runtime [Event].

fn draw(
    &self,
    renderer: &mut Renderer,
    defaults: &Renderer::Defaults,
    layout: Layout,
    cursor_position: Point
) -> Renderer::Output

Draws the [Widget] using the associated Renderer.

fn hash_layout(&self, state: &mut Hasher)

Computes the layout hash of the [Widget].