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.

Example

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

let mut state = MenuState::new(vec![MenuItem::new("File")]);
state.set_items(vec![MenuItem::new("A"), MenuItem::new("B"), MenuItem::new("C")]);
assert_eq!(state.items().len(), 3);

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

Adds a menu item.

If this is the first item, it becomes selected.

Example

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

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

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.

Example

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

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

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 selected(&self) -> Option<usize>

Alias for selected_index().

Example

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

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

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

Sets the selected item index.

Pass Some(index) to select an item (clamped to valid range), or None to clear the selection. Has no effect on an empty menu when selecting.

Example

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

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

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 update(&mut self, msg: MenuMessage) -> Option<MenuOutput>

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

Example

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

let mut state = MenuState::new(vec![
    MenuItem::new("File"),
    MenuItem::new("Edit"),
]);
let output = state.update(MenuMessage::Right);
assert_eq!(output, Some(MenuOutput::SelectionChanged(1)));

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