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
|
//! Build menus for your application.
use crate::keyboard::Hotkey;
/// Menu representation.
///
/// This can be used by `shell` implementations to create a menu.
#[derive(Debug, Clone)]
pub struct Menu<Message> {
entries: Vec<Entry<Message>>,
}
impl<Message> PartialEq for Menu<Message> {
fn eq(&self, other: &Self) -> bool {
self.entries == other.entries
}
}
impl<Message> Menu<Message> {
/// Creates an empty [`Menu`].
pub fn new() -> Self {
Self::with_entries(Vec::new())
}
/// Creates a new [`Menu`] with the given entries.
pub fn with_entries(entries: Vec<Entry<Message>>) -> Self {
Self { entries }
}
/// Returns a [`MenuEntry`] iterator.
pub fn iter(&self) -> impl Iterator<Item = &Entry<Message>> {
self.entries.iter()
}
/// Adds an [`Entry`] to the [`Menu`].
pub fn push(mut self, entry: Entry<Message>) -> Self {
self.entries.push(entry);
self
}
/// Maps the `Message` of the [`Menu`] using the provided function.
///
/// This is useful to compose menus and split them into different
/// abstraction levels.
pub fn map<B>(self, f: impl Fn(Message) -> B + Copy) -> Menu<B> {
// TODO: Use a boxed trait to avoid reallocation of entries
Menu {
entries: self
.entries
.into_iter()
.map(|entry| entry.map(f))
.collect(),
}
}
}
/// Represents one of the possible entries used to build a [`Menu`].
#[derive(Debug, Clone)]
pub enum Entry<Message> {
/// Item for a [`Menu`]
Item {
/// The title of the item
title: String,
/// The [`Hotkey`] to activate the item, if any
hotkey: Option<Hotkey>,
/// The message generated when the item is activated
on_activation: Message,
},
/// Dropdown for a [`Menu`]
Dropdown {
/// Title of the dropdown
title: String,
/// The submenu of the dropdown
submenu: Menu<Message>,
},
/// Separator for a [`Menu`]
Separator,
}
impl<Message> Entry<Message> {
/// Creates an [`Entry::Item`].
pub fn item<S: Into<String>>(
title: S,
hotkey: impl Into<Option<Hotkey>>,
on_activation: Message,
) -> Self {
let title = title.into();
let hotkey = hotkey.into();
Self::Item {
title,
hotkey,
on_activation,
}
}
/// Creates an [`Entry::Dropdown`].
pub fn dropdown<S: Into<String>>(title: S, submenu: Menu<Message>) -> Self {
let title = title.into();
Self::Dropdown { title, submenu }
}
fn map<B>(self, f: impl Fn(Message) -> B + Copy) -> Entry<B> {
match self {
Self::Item {
title,
hotkey,
on_activation,
} => Entry::Item {
title,
hotkey,
on_activation: f(on_activation),
},
Self::Dropdown { title, submenu } => Entry::Dropdown {
title,
submenu: submenu.map(f),
},
Self::Separator => Entry::Separator,
}
}
}
impl<Message> PartialEq for Entry<Message> {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(
Entry::Item { title, hotkey, .. },
Entry::Item {
title: other_title,
hotkey: other_hotkey,
..
},
) => title == other_title && hotkey == other_hotkey,
(
Entry::Dropdown { title, submenu },
Entry::Dropdown {
title: other_title,
submenu: other_submenu,
},
) => title == other_title && submenu == other_submenu,
(Entry::Separator, Entry::Separator) => true,
_ => false,
}
}
}
|
