Struct StandardMenu 

pub struct StandardMenu { /* private fields */ }

A platform-standard menu (macOS App / Window / Help) with localized labels. The framework wires the system selectors (About / Hide / Quit, Minimize / Zoom); you supply the strings — defaults are English lit!s, so pass tr!-resolved [LocalizedString]s for a localized app menu. This keeps the OS menu bar inside the i18n net like every other widget.

Implementations

impl StandardMenu

pub fn app() -> Self

The application menu (About / Hide / Quit). title is the bold app-name submenu label — set it to your localized app name.

pub fn window() -> Self

The Window menu (Minimize / Zoom + the live window list).

pub fn help() -> Self

The Help menu.

pub fn for_role(role: StandardMenuRole) -> Self

Default standard menu for a role.

pub fn role(&self) -> StandardMenuRole

This menu’s role.

pub fn title(self, title: impl Into<LocalizedString>) -> Self

Submenu title (the app name for App; the menu label for Window / Help).

pub fn about(self, label: impl Into<LocalizedString>) -> Self

“About …” label (App).

pub fn settings(self, label: impl Into<LocalizedString>) -> Self

“Settings…” label (App). macOS 13+ says “Settings…”; older releases said “Preferences…” — pass whichever your app targets, localized.

The label alone does not create the item: pair it with settings_intent.

pub fn hide(self, label: impl Into<LocalizedString>) -> Self

“Hide …” label (App).

pub fn quit(self, label: impl Into<LocalizedString>) -> Self

“Quit …” label (App).

pub fn minimize(self, label: impl Into<LocalizedString>) -> Self

“Minimize” label (Window).

pub fn zoom(self, label: impl Into<LocalizedString>) -> Self

“Zoom” label (Window).

pub fn quit_intent(self, intent: &'static str) -> Self

Route the App menu’s Quit through intent instead of the platform’s terminate selector, keeping its ⌘Q key equivalent.

Set this whenever quitting has to pass through the app first — unsaved work to confirm, a session to write out, a background job to stop. By default the item is the platform’s own (terminate: on macOS), which exits immediately: it never reaches winit’s exit path, so no LoopExiting hook and nothing the app registered runs.

An in-app ⌘Q shortcut is not a substitute. AppKit dispatches main-menu key equivalents before the responder chain, so the App menu’s item wins and the app’s own shortcut never sees the keystroke — the app looks wired up and is not. Routing the item is the only place that decision can be taken.

Whatever intent resolves to now owns the exit — nothing terminates on the app’s behalf once this is set.

StandardMenu::app()
    .title(tr!(app_name()))
    .quit(tr!(quit()))
    .quit_intent("app.quit")   // the guarded action, same as File ▸ Quit

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

The intent quit_intent installed, or None if Quit is still the platform’s own terminate selector.

Public so an app can test that its Quit is guarded. Everything the routing does happens on macOS, where a downstream test suite generally does not run, so without a getter the difference between a guarded ⌘Q and an unguarded one is invisible from the app’s side — which is the same blind spot that let the unrouted default ship in the first place.

pub fn settings_intent(self, intent: &'static str) -> Self

Put Settings… in the App menu, routed through intent, with the platform’s own placement and key equivalent (⌘, on macOS).

macOS keeps app settings in the application menu, not in File or Edit, and ⌘, is the only chord users try. Neither is reachable from a plain MenuEntry: the App menu is filled in by the platform, so an entry the model declares lands in some other menu instead.

Unlike quit_intent this is the only way to get the item at all — no platform opens an app’s settings on its own, so leaving it unset omits the row rather than falling back to a system behaviour. Route it to the same intent your in-window “Settings” command fires, and the two stay one command.

StandardMenu::app()
    .title(tr!(app_name()))
    .settings(tr!(settings()))
    .settings_intent("app.settings")

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

The intent settings_intent installed, or None if the App menu carries no Settings item.

Public for the same reason as quit_intent_name: the wiring only takes effect on macOS, where an app’s test suite generally does not run, so without a getter a missing route is invisible from the app’s side.

pub fn quit_shortcut(self, id: &'static str) -> Self

The intent + item id settings_intent installed, if any. Advertise the registered shortcut id on the routed Quit row, instead of the platform’s conventional chord (⌘Q on macOS).

Worth naming whenever the app registers a quit shortcut of its own — which is to say whenever quit_intent is set, since the intent has to be reachable somehow. The chord then comes from the ShortcutRegistry like every other menu row’s: it follows the primary-accelerator convention, and it follows a user’s rebind. Left unset, this row is the one place in the app advertising a chord nothing registered — still live after the user moved the command elsewhere, and shadowing the chord they moved it to, because the platform dispatches a main-menu key equivalent before the responder chain.

pub fn settings_shortcut(self, id: &'static str) -> Self

Advertise the registered shortcut id on the routed Settings… row, instead of the platform’s conventional chord (⌘, on macOS). Same reasoning as quit_shortcut.

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

The shortcut id named for the Quit row, if any.

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

The shortcut id named for the Settings row, if any.

Trait Implementations

impl Clone for StandardMenu

fn clone(&self) -> StandardMenu

Returns a duplicate of the value.

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

Performs copy-assignment from source.