Struct MenuState 

pub struct MenuState { /* private fields */ }

State for a Menu component.

Implementations

impl MenuState

pub fn new(items: Vec<MenuItem>) -> Self

Creates a new menu with the given items.

Example

use envision::component::{MenuState, MenuItem};

let state = MenuState::new(vec![
    MenuItem::new("File"),
    MenuItem::new("Edit"),
]);
assert_eq!(state.items().len(), 2);

pub fn items(&self) -> &[MenuItem]

Returns the menu items.

Examples

use envision::prelude::*;

let state = MenuState::new(vec![
    MenuItem::new("File"),
    MenuItem::new("Edit"),
]);
assert_eq!(state.items().len(), 2);
assert_eq!(state.items()[0].label(), "File");

pub fn set_items(&mut self, items: Vec<MenuItem>)

Sets the menu items.

Resets selection to the first item if the current selection is out of bounds. Sets selection to None if the new items list is empty.

pub fn add_item(&mut self, item: MenuItem)

Adds a menu item.

If this is the first item, it becomes selected.

pub fn remove_item(&mut self, index: usize)

Removes a menu item by index.

If the index is out of bounds, this is a no-op. Adjusts the selection after removal:

• If the removed item was the selected item, selects the previous item (or the first if at the beginning).
• If the menu becomes empty, selection becomes None.

pub fn selected_index(&self) -> Option<usize>

Returns the currently selected item index.

Returns None if the menu is empty.

Examples

use envision::prelude::*;

let state = MenuState::new(vec![MenuItem::new("File"), MenuItem::new("Edit")]);
assert_eq!(state.selected_index(), Some(0));

let empty = MenuState::new(vec![]);
assert_eq!(empty.selected_index(), None);

pub fn set_selected(&mut self, index: usize)

Sets the selected item index.

If the index is out of bounds, it will be clamped to the valid range. Has no effect on an empty menu.

pub fn with_selected(self, index: usize) -> Self

Sets the selected item index (builder method).

If the index is out of bounds, it will be clamped to the valid range. Has no effect on an empty menu.

Example

use envision::component::{MenuState, MenuItem};

let state = MenuState::new(vec![
    MenuItem::new("File"),
    MenuItem::new("Edit"),
    MenuItem::new("View"),
]).with_selected(1);
assert_eq!(state.selected_index(), Some(1));

pub fn selected_item(&self) -> Option<&MenuItem>

Returns the currently selected item.

Examples

use envision::prelude::*;

let state = MenuState::new(vec![MenuItem::new("File"), MenuItem::new("Edit")]);
assert_eq!(state.selected_item().unwrap().label(), "File");

pub fn is_focused(&self) -> bool

Returns true if the menu is focused.

Examples

use envision::prelude::*;

let state = MenuState::new(vec![MenuItem::new("File")]);
assert!(!state.is_focused());

pub fn set_focused(&mut self, focused: bool)

Sets the focus state.

Examples

use envision::prelude::*;

let mut state = MenuState::new(vec![MenuItem::new("File")]);
state.set_focused(true);
assert!(state.is_focused());

pub fn is_disabled(&self) -> bool

Returns true if the menu is disabled.

Examples

use envision::prelude::*;

let state = MenuState::new(vec![MenuItem::new("File")]);
assert!(!state.is_disabled());

pub fn set_disabled(&mut self, disabled: bool)

Sets the disabled state.

Examples

use envision::prelude::*;

let mut state = MenuState::new(vec![MenuItem::new("File")]);
state.set_disabled(true);
assert!(state.is_disabled());

pub fn with_disabled(self, disabled: bool) -> Self

Sets the disabled state using builder pattern.

pub fn handle_event(&self, event: &Event) -> Option<MenuMessage>

Maps an input event to a menu message.

pub fn dispatch_event(&mut self, event: &Event) -> Option<MenuOutput>

Dispatches an event, updating state and returning any output.

pub fn update(&mut self, msg: MenuMessage) -> Option<MenuOutput>

Updates the menu state with a message, returning any output.

Trait Implementations

impl Clone for MenuState

fn clone(&self) -> MenuState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MenuState

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

Formats the value using the given formatter.

impl Default for MenuState

fn default() -> MenuState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MenuState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MenuState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MenuState

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 MenuState