Struct Panel 

pub struct Panel { /* private fields */ }

A panel that covers an entire side (left, right, top or bottom) of a Ui or screen.

The order in which you add panels matter! The first panel you add will always be the outermost, and the last you add will always be the innermost.

⚠ Always add any CentralPanel last.

See the module level docs for more details.

Showing the panel

Pick the variant that matches the behavior you want:

• Panel::show: always show the panel.
• Panel::show_collapsible: show or hide the panel, with a slide animation in between.
• Panel::show_switched: animate between two different panels: a thin/collapsed one and a thick/expanded one.

egui::Panel::left("my_left_panel").show(ui, |ui| {
   ui.label("Hello World!");
});

Implementations

impl Panel

pub fn left(id: impl Into<Id>) -> Self

Create a left panel.

The id should be globally unique, e.g. Id::new("my_left_panel").

pub fn right(id: impl Into<Id>) -> Self

Create a right panel.

The id should be globally unique, e.g. Id::new("my_right_panel").

pub fn top(id: impl Into<Id>) -> Self

Create a top panel.

The id should be globally unique, e.g. Id::new("my_top_panel").

By default this is NOT resizable.

pub fn bottom(id: impl Into<Id>) -> Self

Create a bottom panel.

The id should be globally unique, e.g. Id::new("my_bottom_panel").

By default this is NOT resizable.

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

Can panel be resized by dragging the edge of it?

Default is true.

If you want your panel to be resizable you also need to make the ui use the available space.

This can be done by using Ui::take_available_space, or using a widget in it that takes up more space as you resize it, such as:

• Wrapping text (Ui::horizontal_wrapped).
• A crate::ScrollArea.
• A crate::Separator.
• A crate::TextEdit.
• …

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

Can a fully collapsed panel be dragged back open?

Default: true.

When enabled, a panel that Self::show_collapsible has collapsed all the way still leaves a thin grab handle at its fixed edge. The handle is invisible until hovered, at which point it lights up like a normal resize handle. Dragging it outward past Self::min_size — or double-clicking it — reopens the panel.

This is the counterpart to drag-to-collapse, and like it requires Self::resizable to be true.

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

Show a separator line, even when not interacting with it?

The separator line sits on the panel’s inner edge, i.e. the edge facing the rest of the ui. It is painted outside the Frame’s outline, in room the panel reserves for it in the frame’s Frame::outer_margin, so that going from the panel contents outwards you get:

contents | Frame::inner_margin | Frame::stroke | separator line | Frame::outer_margin

Turning this off removes that reserved room too, so the panel gets no permanent gap along that edge.

A resizable panel still shows a line while hovered or dragged, regardless of this setting. With this setting off there is no room reserved for it, so that transient line is painted just outside the frame’s outline, overlapping the Frame::outer_margin.

Default: true.

pub fn default_size(self, default_size: f32) -> Self

The initial wrapping width of the Panel, including margins.

pub fn min_size(self, min_size: f32) -> Self

Minimum size of the panel, including margins.

pub fn max_size(self, max_size: f32) -> Self

Maximum size of the panel, including margins.

pub fn size_range(self, size_range: impl Into<Rangef>) -> Self

The allowable size range for the panel, including margins.

pub fn exact_size(self, size: f32) -> Self

Enforce this exact size, including margins.

pub fn frame(self, frame: Frame) -> Self

Change the background color, margins, etc.

impl Panel

pub fn show<R>( self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R, ) -> InnerResponse<R>

Show the panel inside a Ui.

pub fn show_inside<R>( self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R, ) -> InnerResponse<R>

👎Deprecated:

Renamed to show

Renamed to Self::show.

pub fn show_collapsible<R>( self, ui: &mut Ui, is_expanded: &mut bool, add_contents: impl FnOnce(&mut Ui) -> R, ) -> Option<InnerResponse<R>>

Show the panel if *is_expanded is true, otherwise hide it, with a slide animation in between.

During the animation add_contents runs against the real panel, and the panel slides off-screen toward its fixed edge (clipped against the parent). The parent only reserves the visible portion, so neighboring widgets follow.

is_expanded is taken by &mut so the panel can flip it to false when the user drags the resize handle past the panel’s minimum size, and back to true if the user drags the handle outward while the panel is closed. When Self::resizable is true, double-clicking the resize edge also flips *is_expanded.

A fully collapsed panel keeps a thin grab handle at its fixed edge, so the user can drag it back open. See Self::drag_to_open to opt out.

pub fn show_animated_inside<R>( self, ui: &mut Ui, is_expanded: bool, add_contents: impl FnOnce(&mut Ui) -> R, ) -> Option<InnerResponse<R>>

👎Deprecated:

Renamed to show_collapsible

Renamed to Self::show_collapsible.

Note: Self::show_collapsible takes is_expanded by &mut so it can flip it to false when the user drags the panel closed. To opt in, migrate to the new name.

pub fn show_switched<R>( ui: &mut Ui, is_expanded: &mut bool, collapsed_panel: Self, expanded_panel: Self, add_contents: impl FnOnce(&mut Ui, bool) -> R, ) -> InnerResponse<R>

Show either a collapsed or expanded panel, with a nice slide animation between.

The collapsed_panel is shown only when fully collapsed; during the animation, the expanded_panel slides in/out toward its fixed edge, interpolating its visible size between the two panels’ sizes. add_contents receives expanded = true whenever the expanded panel is rendered (including mid-animation), and false for the collapsed view.

Give the two panels distinct ids so their persisted sizes don’t overwrite each other.

Drag-to-collapse / drag-to-expand

The user can resize the panel by dragging its edge. Pulling that edge past the size limits flips *is_expanded:

• .resizable(true) on the expanded panel enables drag-to-collapse: shrinking past min_size sets *is_expanded = false.
• .resizable(true) on the collapsed panel enables drag-to-expand: growing past max_size sets *is_expanded = true. (Use Self::exact_size or Self::max_size to set a tight cap so a small outward drag is enough to trigger the swap.)

Both panels share a single resize-handle widget under the hood (keyed to the expanded panel’s id), so a single uninterrupted drag can collapse and re-expand the panel without releasing.

Double-clicking the resize edge also flips *is_expanded (whichever panel is currently shown is the one whose edge you click).

let mut is_expanded = true;
// `.resizable(true)` on both panels enables drag-to-collapse + drag-to-expand:
let collapsed = egui::Panel::top("top_collapsed")
    .resizable(true)
    .default_size(20.0);
let expanded = egui::Panel::top("top_expanded")
    .resizable(true)
    .default_size(120.0);
egui::Panel::show_switched(
    ui,
    &mut is_expanded,
    collapsed,
    expanded,
    |ui, expanded| {
        if expanded {
            ui.heading("Expanded");
            ui.label("More content here…");
        } else {
            ui.label("Collapsed toolbar");
        }
    },
);
ui.toggle_value(&mut is_expanded, "Expand");

pub fn show_animated_between_inside<R>( ui: &mut Ui, is_expanded: bool, collapsed_panel: Self, expanded_panel: Self, add_contents: impl FnOnce(&mut Ui, f32) -> R, ) -> InnerResponse<R>

👎Deprecated:

Renamed to show_switched

Renamed to Self::show_switched.

Note: Self::show_switched takes is_expanded by &mut (to allow drag-to-collapse / drag-to-expand to flip it) and passes a bool to add_contents instead of an f32 animation fraction. To opt in, migrate to the new name.