Struct MenuBar 

pub struct MenuBar {
    pub id: WidgetId,
    pub items: Vec<MenuBarItem>,
    pub open_item: Option<usize>,
    pub focused_item: Option<usize>,
}

Declarative description of a menu bar.

Examples

use quadraui::{MenuBar, MenuBarHit, MenuBarItem, MenuBarItemMeasure, Rect, WidgetId};

let bar = MenuBar {
    id: WidgetId::new("menubar:main"),
    items: vec![MenuBarItem {
        id: WidgetId::new("menu:file"),
        label: "&File".to_string(),
        disabled: false,
        submenu: None,
    }],
    open_item: None,
    focused_item: None,
};

let layout = bar.layout(Rect::new(0.0, 0.0, 80.0, 1.0), |_| MenuBarItemMeasure::new(6.0));
assert_eq!(layout.hit_test(2.0, 0.0), MenuBarHit::Item(0));

Fields

id: WidgetId

items: Vec<MenuBarItem>

open_item: Option<usize>

Index of the currently-open menu (if any). Backends use this to render the “pressed” visual on the active item.

focused_item: Option<usize>

Keyboard-focused item (for Alt+navigation) — may differ from open_item during arrow-key traversal.

Implementations

impl MenuBar

pub fn layout<F>(&self, bounds: Rect, measure_item: F) -> MenuBarLayout

where F: Fn(usize) -> MenuBarItemMeasure,

Compute item positions along the bar.

Arguments

• bounds — menu-bar row.
• measure_item(i) — width of item i.

pub fn layout_with_leading<F>( &self, bounds: Rect, leading_width: f32, measure_item: F, ) -> MenuBarLayout

where F: Fn(usize) -> MenuBarItemMeasure,

Like Self::layout, but reserves leading_width device units at the start of bounds for a fixed-size leading element — an app-logo crate::Image left of the first menu item, VS-Code style — before laying out items.

The offset math is the key concern: a consumer that narrows the rect it hands to a paint call but not the rect it hands to a click-routing call (or vice versa) gets a menu bar whose visible items and clickable items silently disagree. Centralizing the shift here means both call sites can pass the same bounds + leading_width pair instead of each independently computing a narrowed rect.

leading_width <= 0.0 behaves exactly like Self::layout called with bounds unchanged. MenuBarLayout::bounds on the result still covers the full bounds (including the reserved leading region) so MenuBarLayout::hit_test’s “inside the bar” check keeps treating a click over the icon as MenuBarHit::Bar rather than MenuBarHit::Outside — callers that want to special-case a click on the icon itself compare the click x against bounds.x + leading_width themselves, since the icon’s own geometry isn’t a MenuBar concern.

pub fn find_alt_target(&self, ch: char) -> Option<usize>

Find the index of the item whose label contains the Alt-key character ch (case-insensitive). The label’s & prefix marks the activation character; if no &, the first character is used.

Trait Implementations

impl Clone for MenuBar

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MenuBar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MenuBar

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MenuBar

impl PartialEq for MenuBar

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for MenuBar

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MenuBar