145 lines
3.9 KiB
Rust
145 lines
3.9 KiB
Rust
//! 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,
|
|
}
|
|
}
|
|
}
|