Struct Shell 

pub struct Shell<D> { /* private fields */ }

The window frame. Hold one as the app’s root; call ui every frame.

Labels are message ids: each frame the hover text is looked up in the language installed (see i18n), so a language switch shows on the next frame.

The shell keeps clear of the system’s bars and notches (egui’s safe area, which iOS fills): the rail, the bar’s buttons and the screens stay inside it, and the bottom bar’s fill runs on under the home indicator, as a phone’s tab bar does. Give it the window’s whole root ui; the app adds no margin of its own. If the app does keep ui clear of them itself, the shell sees that and adds nothing, so the margin is never doubled. On Android, window::run_android keeps the app’s ui clear of the bars and the keyboard already.

#[derive(Clone, Copy, PartialEq)]
enum Screen { Gallery, Albums, Settings }

let mut shell = Shell::new(vec![
    // The app's own Lucide SVGs: `egui::include_image!("../assets/icons/images.svg")`.
    Destination::new(Screen::Gallery, icons::folder(), "gallery"),
    Destination::new(Screen::Albums, icons::folder(), "albums"),
])
.with_footer(vec![Destination::new(Screen::Settings, icons::settings(), "settings")]);
shell.ui(ui, |ui, screen| match screen {
    Screen::Gallery => { egui::CentralPanel::default().show(ui, |ui| ui.label("…")); }
    Screen::Albums => { egui::CentralPanel::default().show(ui, |ui| ui.label("…")); }
    Screen::Settings => { egui::CentralPanel::default().show(ui, |ui| ui.label("…")); }
});

Implementations

impl<D: Copy + PartialEq> Shell<D>

pub fn new(destinations: Vec<Destination<D>>) -> Shell<D>

A frame with destinations on the rail, the first one open.

pub fn with_actions(self, actions: Vec<Action>) -> Shell<D>

Put actions on the rail, under the screens (on the bottom bar, after them).

pub fn with_footer(self, footer: Vec<Destination<D>>) -> Shell<D>

Put footer at the rail’s foot (at the bottom bar’s end): where an app puts Settings. With no other destinations, the first of these is open.

pub fn take_action(&mut self) -> Option<&'static str>

The Action clicked in the last ui, once: call it after ui every frame and do what it names.

pub fn current(&self) -> Option<D>

The destination that is open; None only when there are none.

pub fn open(&mut self, id: D)

Open the destination id.

pub fn ui(&mut self, ui: &mut Ui, content: impl FnOnce(&mut Ui, D))

Render into the window’s root ui. content draws the open destination into what the frame leaves of ui, as it would at the root: its own panels, then a CentralPanel. The first frame installs the default theme and language if the app has not installed them.

pub fn ui_with_foot( &mut self, ui: &mut Ui, foot: impl FnOnce(&mut Ui) -> Option<D>, content: impl FnOnce(&mut Ui, D), )

As ui, with foot drawn beside the footer — a status dot, say. A destination foot returns is opened, and drawn this frame.

pub fn ui_with_status( &mut self, ui: &mut Ui, foot: impl FnOnce(&mut Ui) -> Option<D>, status: impl FnOnce(&mut Ui), content: impl FnOnce(&mut Ui, D), )

As ui_with_foot, with a status bar along the window’s bottom when wide. status fills it from the left — a log’s last line, the services’ state, the track playing; the bar’s right end holds foot (there rather than at the rail’s foot), then the detail pane’s toggle when the open screen has one. Narrow, as on a phone, there is no status bar: foot stays on the bottom bar, and status is not called.