iced_plus_components 0.1.0

Component library for iced-plus: Button, TextInput, Card, Modal, and 30+ widgets
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Menu and context menu components.

use std::borrow::Cow;

/// A menu item.
#[derive(Clone)]
pub enum MenuItem<'a, Message> {
    /// Regular clickable item.
    Item {
        /// Item label.
        label: Cow<'a, str>,
        /// Optional icon.
        icon: Option<Cow<'a, str>>,
        /// Message to emit on click.
        on_click: Message,
        /// Whether the item is enabled.
        enabled: bool,
        /// Optional keyboard shortcut hint.
        shortcut: Option<Cow<'a, str>>,
    },
    /// Separator line.
    Separator,
    /// Submenu.
    Submenu {
        /// Submenu label.
        label: Cow<'a, str>,
        /// Submenu items.
        items: Vec<MenuItem<'a, Message>>,
    },
}

impl<'a, Message> MenuItem<'a, Message> {
    /// Create a new menu item.
    pub fn new(label: impl Into<Cow<'a, str>>, on_click: Message) -> Self {
        Self::Item {
            label: label.into(),
            icon: None,
            on_click,
            enabled: true,
            shortcut: None,
        }
    }

    /// Create a separator.
    pub fn separator() -> Self {
        Self::Separator
    }

    /// Create a submenu.
    pub fn submenu(label: impl Into<Cow<'a, str>>, items: Vec<MenuItem<'a, Message>>) -> Self {
        Self::Submenu {
            label: label.into(),
            items,
        }
    }

    /// Add an icon to the item.
    #[must_use]
    pub fn icon(mut self, icon: impl Into<Cow<'a, str>>) -> Self {
        if let Self::Item { icon: ref mut i, .. } = self {
            *i = Some(icon.into());
        }
        self
    }

    /// Set enabled state.
    #[must_use]
    pub fn enabled(mut self, enabled: bool) -> Self {
        if let Self::Item { enabled: ref mut e, .. } = self {
            *e = enabled;
        }
        self
    }

    /// Add a shortcut hint.
    #[must_use]
    pub fn shortcut(mut self, shortcut: impl Into<Cow<'a, str>>) -> Self {
        if let Self::Item { shortcut: ref mut s, .. } = self {
            *s = Some(shortcut.into());
        }
        self
    }
}

/// A menu definition.
pub struct Menu<'a, Message> {
    /// Menu items.
    pub items: Vec<MenuItem<'a, Message>>,
}

impl<'a, Message> Menu<'a, Message> {
    /// Create a new empty menu.
    #[must_use]
    pub fn new() -> Self {
        Self { items: Vec::new() }
    }

    /// Add an item to the menu.
    #[must_use]
    pub fn item(mut self, item: MenuItem<'a, Message>) -> Self {
        self.items.push(item);
        self
    }

    /// Add a simple labeled item.
    #[must_use]
    pub fn push(mut self, label: impl Into<Cow<'a, str>>, on_click: Message) -> Self {
        self.items.push(MenuItem::new(label, on_click));
        self
    }

    /// Add a separator.
    #[must_use]
    pub fn separator(mut self) -> Self {
        self.items.push(MenuItem::Separator);
        self
    }

    /// Add a submenu.
    #[must_use]
    pub fn submenu(mut self, label: impl Into<Cow<'a, str>>, items: Vec<MenuItem<'a, Message>>) -> Self {
        self.items.push(MenuItem::submenu(label, items));
        self
    }
}

impl<'a, Message> Default for Menu<'a, Message> {
    fn default() -> Self {
        Self::new()
    }
}

/// Menu bar containing multiple menus.
pub struct MenuBar<'a, Message> {
    /// Named menus in the bar.
    pub menus: Vec<(Cow<'a, str>, Menu<'a, Message>)>,
}

impl<'a, Message> MenuBar<'a, Message> {
    /// Create a new empty menu bar.
    #[must_use]
    pub fn new() -> Self {
        Self { menus: Vec::new() }
    }

    /// Add a menu to the bar.
    #[must_use]
    pub fn menu(mut self, label: impl Into<Cow<'a, str>>, menu: Menu<'a, Message>) -> Self {
        self.menus.push((label.into(), menu));
        self
    }
}

impl<'a, Message> Default for MenuBar<'a, Message> {
    fn default() -> Self {
        Self::new()
    }
}