Struct MenuSystem 

pub struct MenuSystem<'prov, M: MenuProvider> {
    pub current_menu: M::MenuId,
    pub cursor: u8,
    pub scroll_offset: u8,
    /* private fields */
}

Stateful menu controller that owns cursor position, scroll offset, and open/closed state.

MenuSystem is parameterised over the MenuProvider implementation, so it can call into the provider for data without any downcasting or dynamic dispatch overhead.

Fields

current_menu: M::MenuId

Which menu is currently active.

cursor: u8

0-based index of the currently-highlighted option.

scroll_offset: u8

Scroll offset (for scrollable menus). 0 = first visible option is at index 0 in the full option list.

Implementations

impl<'prov, M: MenuProvider> MenuSystem<'prov, M>

pub fn new(provider: &'prov M) -> Self

Create a new MenuSystem backed by provider. The menu starts closed; call open to activate it.

Examples found in repository

examples/hello_dotzuki.rs (line 769)

fn demo_menu() {
    println!("\n╔══ MENU NAVIGATION ═════════════════════╗");
    let provider = HelloConfig::new();
    let mut menu = MenuSystem::new(&provider);
    menu.open(MenuScreen::Main);

    println!("║ Menu '{}' — 3 options", provider.title(MenuScreen::Main));
    for (i, opt) in provider.main_menu_options.iter().enumerate() {
        let marker = if i == menu.cursor as usize { ">" } else { " " };
        println!(
            "║  {} {}{}",
            marker,
            opt.label,
            if opt.enabled { "" } else { " (disabled)" }
        );
    }

    // Navigate down × 2
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    println!("║ Cursor after 2× Down: {}", menu.cursor);

    // Select
    let action = menu.handle_input(&MenuInput {
        confirm: true,
        ..Default::default()
    });
    println!(
        "║ Confirm → {:?} ('{}')",
        action,
        menu.selected_option()
            .map(|o| o.label.as_str())
            .unwrap_or("?")
    );
    println!("╚══════════════════════════════════════════╝");
}

pub fn open(&mut self, menu: M::MenuId)

Open a specific menu, resetting cursor and scroll to their defaults.

Examples found in repository

examples/hello_dotzuki.rs (line 770)

fn demo_menu() {
    println!("\n╔══ MENU NAVIGATION ═════════════════════╗");
    let provider = HelloConfig::new();
    let mut menu = MenuSystem::new(&provider);
    menu.open(MenuScreen::Main);

    println!("║ Menu '{}' — 3 options", provider.title(MenuScreen::Main));
    for (i, opt) in provider.main_menu_options.iter().enumerate() {
        let marker = if i == menu.cursor as usize { ">" } else { " " };
        println!(
            "║  {} {}{}",
            marker,
            opt.label,
            if opt.enabled { "" } else { " (disabled)" }
        );
    }

    // Navigate down × 2
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    println!("║ Cursor after 2× Down: {}", menu.cursor);

    // Select
    let action = menu.handle_input(&MenuInput {
        confirm: true,
        ..Default::default()
    });
    println!(
        "║ Confirm → {:?} ('{}')",
        action,
        menu.selected_option()
            .map(|o| o.label.as_str())
            .unwrap_or("?")
    );
    println!("╚══════════════════════════════════════════╝");
}

pub fn close(&mut self)

Close the menu.

pub fn is_open(&self) -> bool

Returns true if the menu is currently open.

pub fn handle_input(&mut self, input: &MenuInput) -> MenuAction

Process one frame of abstract input and return a MenuAction.

The caller should call this once per frame with the aggregated directional / confirm / cancel state.

Examples found in repository

examples/hello_dotzuki.rs (lines 784-787)

fn demo_menu() {
    println!("\n╔══ MENU NAVIGATION ═════════════════════╗");
    let provider = HelloConfig::new();
    let mut menu = MenuSystem::new(&provider);
    menu.open(MenuScreen::Main);

    println!("║ Menu '{}' — 3 options", provider.title(MenuScreen::Main));
    for (i, opt) in provider.main_menu_options.iter().enumerate() {
        let marker = if i == menu.cursor as usize { ">" } else { " " };
        println!(
            "║  {} {}{}",
            marker,
            opt.label,
            if opt.enabled { "" } else { " (disabled)" }
        );
    }

    // Navigate down × 2
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    println!("║ Cursor after 2× Down: {}", menu.cursor);

    // Select
    let action = menu.handle_input(&MenuInput {
        confirm: true,
        ..Default::default()
    });
    println!(
        "║ Confirm → {:?} ('{}')",
        action,
        menu.selected_option()
            .map(|o| o.label.as_str())
            .unwrap_or("?")
    );
    println!("╚══════════════════════════════════════════╝");
}

pub fn selected_option(&self) -> Option<&MenuOption>

Return the currently-selected option, or None if the cursor is out of range or the menu is closed.

Examples found in repository

examples/hello_dotzuki.rs (line 802)

fn demo_menu() {
    println!("\n╔══ MENU NAVIGATION ═════════════════════╗");
    let provider = HelloConfig::new();
    let mut menu = MenuSystem::new(&provider);
    menu.open(MenuScreen::Main);

    println!("║ Menu '{}' — 3 options", provider.title(MenuScreen::Main));
    for (i, opt) in provider.main_menu_options.iter().enumerate() {
        let marker = if i == menu.cursor as usize { ">" } else { " " };
        println!(
            "║  {} {}{}",
            marker,
            opt.label,
            if opt.enabled { "" } else { " (disabled)" }
        );
    }

    // Navigate down × 2
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    menu.handle_input(&MenuInput {
        down: true,
        ..Default::default()
    });
    println!("║ Cursor after 2× Down: {}", menu.cursor);

    // Select
    let action = menu.handle_input(&MenuInput {
        confirm: true,
        ..Default::default()
    });
    println!(
        "║ Confirm → {:?} ('{}')",
        action,
        menu.selected_option()
            .map(|o| o.label.as_str())
            .unwrap_or("?")
    );
    println!("╚══════════════════════════════════════════╝");
}

pub fn render<P: Painter>(&self, painter: &mut P)

Render the menu onto painter using the Painter trait.

This draws the text box, title, options, and cursor indicator through the backend-agnostic Painter interface. TUI and pixel backends produce identical visual output (modulo resolution).