tui-vision 0.1.1

A turbo vision inspired library for ratatui.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::{
    command::Command,
    menus::{ActionItem, MenuItem, SeparatorItem, SubMenuItem},
};

/// A menu containing a title and a collection of menu items.
///
/// Menus are displayed as dropdowns when opened and support keyboard navigation
/// with hotkeys for quick access.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Menu {
    /// Title text displayed in the menu bar
    pub title: String,

    /// Collection of menu items in this menu
    pub items: Vec<super::MenuItem>,

    /// Whether the menu is enabled
    pub enabled: bool,

    /// Optional hotkey for quick access to this menu
    pub hotkey: Option<char>,

    /// Index of the currently focused item when this menu is open
    pub focused_item: Option<usize>,
}

// Menu builders
impl Menu {
    /// Creates a new menu with the given title.
    pub fn new(title: impl Into<String>) -> Self {
        Self {
            title: title.into(),
            items: Vec::new(),
            enabled: true,
            hotkey: None,
            focused_item: None,
        }
    }

    /// Creates a new menu with a hotkey.
    pub fn with_hotkey(title: impl Into<String>, hotkey: char) -> Self {
        Self {
            title: title.into(),
            items: Vec::new(),
            enabled: true,
            hotkey: Some(hotkey),
            focused_item: None,
        }
    }

    /// Creates a new menu with title, hotkey, and items.
    ///
    /// # Example
    ///
    /// ```rust
    /// use tui_vision::menus::{Menu, MenuItem};
    ///
    /// let menu = Menu::with_items("File", Some('F'), vec![
    ///     MenuItem::new_action("New", "file.new"),
    ///     MenuItem::separator(),
    /// ]);
    /// ```
    pub fn with_items<S: Into<String>>(
        title: S,
        hotkey: Option<char>,
        items: Vec<MenuItem>,
    ) -> Self {
        Self {
            title: title.into(),
            items,
            enabled: true,
            hotkey,
            focused_item: None,
        }
    }

    /// Sets the hotkey for this menu (builder pattern).
    pub fn hotkey(mut self, hotkey: char) -> Self {
        self.hotkey = Some(hotkey);
        self
    }

    /// Adds an item to this menu (builder pattern).
    pub fn item(mut self, item: MenuItem) -> Self {
        self.items.push(item);
        self
    }

    /// Adds multiple items to this menu (builder pattern).
    pub fn items(mut self, items: Vec<MenuItem>) -> Self {
        self.items.extend(items);
        self
    }

    /// Adds an action item as a convenience method.
    pub fn add_action<S: Into<String>, C: Into<Command>>(
        &mut self,
        label: S,
        command: C,
        hotkey: Option<char>,
    ) -> &mut Self {
        let action = ActionItem::new(label, command);
        let action = if let Some(hk) = hotkey {
            action.hotkey(hk)
        } else {
            action
        };
        self.items.push(MenuItem::Action(action));
        self
    }

    /// Adds a separator as a convenience method.
    pub fn add_separator(&mut self) -> &mut Self {
        self.items.push(MenuItem::Separator(SeparatorItem::new()));
        self
    }

    /// Adds a submenu as a convenience method.
    pub fn add_submenu<S: Into<String>>(&mut self, label: S, hotkey: Option<char>) -> &mut Self {
        self.items.push(MenuItem::SubMenu(SubMenuItem::with_items(
            label,
            hotkey,
            vec![],
        )));
        self
    }

    /// Adds a menu item to this menu.
    pub fn add_item(&mut self, item: MenuItem) {
        self.items.push(item);
    }
}