Merge pull request #945 from derezzedex/menu

feat: add menus

5 files changed, 216 insertions, 27 deletions

diff --git a/core/src/keyboard.rs b/core/src/keyboard.rs
index 61e017ad..cb64701a 100644
--- a/core/src/keyboard.rs
+++ b/core/src/keyboard.rs
@@ -1,8 +1,10 @@
 //! Reuse basic keyboard types.
 mod event;
+mod hotkey;
 mod key_code;
 mod modifiers;
 
 pub use event::Event;
+pub use hotkey::Hotkey;
 pub use key_code::KeyCode;
 pub use modifiers::Modifiers;
diff --git a/core/src/keyboard/hotkey.rs b/core/src/keyboard/hotkey.rs
new file mode 100644
index 00000000..310ef286
--- /dev/null
+++ b/core/src/keyboard/hotkey.rs
@@ -0,0 +1,18 @@
+use crate::keyboard::{KeyCode, Modifiers};
+
+/// Representation of a hotkey, consists on the combination of a [`KeyCode`] and [`Modifiers`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Hotkey {
+    /// The key that represents this hotkey.
+    pub key: KeyCode,
+
+    /// The list of modifiers that represents this hotkey.
+    pub modifiers: Modifiers,
+}
+
+impl Hotkey {
+    /// Creates a new [`Hotkey`] with the given [`Modifiers`] and [`KeyCode`].
+    pub fn new(modifiers: Modifiers, key: KeyCode) -> Self {
+        Self { modifiers, key }
+    }
+}
diff --git a/core/src/keyboard/modifiers.rs b/core/src/keyboard/modifiers.rs
index d2a0500e..383b9370 100644
--- a/core/src/keyboard/modifiers.rs
+++ b/core/src/keyboard/modifiers.rs
@@ -1,20 +1,53 @@
-/// The current state of the keyboard modifiers.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct Modifiers {
-    /// Whether a shift key is pressed
-    pub shift: bool,
+use bitflags::bitflags;
 
-    /// Whether a control key is pressed
-    pub control: bool,
-
-    /// Whether an alt key is pressed
-    pub alt: bool,
-
-    /// Whether a logo key is pressed (e.g. windows key, command key...)
-    pub logo: bool,
+bitflags! {
+    /// The current state of the keyboard modifiers.
+    #[derive(Default)]
+    pub struct Modifiers: u32{
+        /// The "shift" key.
+        const SHIFT = 0b100 << 0;
+        // const LSHIFT = 0b010 << 0;
+        // const RSHIFT = 0b001 << 0;
+        //
+        /// The "control" key.
+        const CTRL = 0b100 << 3;
+        // const LCTRL = 0b010 << 3;
+        // const RCTRL = 0b001 << 3;
+        //
+        /// The "alt" key.
+        const ALT = 0b100 << 6;
+        // const LALT = 0b010 << 6;
+        // const RALT = 0b001 << 6;
+        //
+        /// The "windows" key on Windows, "command" key on Mac, and
+        /// "super" key on Linux.
+        const LOGO = 0b100 << 9;
+        // const LLOGO = 0b010 << 9;
+        // const RLOGO = 0b001 << 9;
+    }
 }
 
 impl Modifiers {
+    /// Returns true if the [`SHIFT`] key is pressed in the [`Modifiers`].
+    pub fn shift(self) -> bool {
+        self.contains(Self::SHIFT)
+    }
+
+    /// Returns true if the [`CTRL`] key is pressed in the [`Modifiers`].
+    pub fn control(self) -> bool {
+        self.contains(Self::CTRL)
+    }
+
+    /// Returns true if the [`ALT`] key is pressed in the [`Modifiers`].
+    pub fn alt(self) -> bool {
+        self.contains(Self::ALT)
+    }
+
+    /// Returns true if the [`LOGO`] key is pressed in the [`Modifiers`].
+    pub fn logo(self) -> bool {
+        self.contains(Self::LOGO)
+    }
+
     /// Returns true if a "command key" is pressed in the [`Modifiers`].
     ///
     /// The "command key" is the main modifier key used to issue commands in the
@@ -22,24 +55,13 @@ impl Modifiers {
     ///
     /// - It is the `logo` or command key (⌘) on macOS
     /// - It is the `control` key on other platforms
-    pub fn is_command_pressed(self) -> bool {
+    pub fn command(self) -> bool {
         #[cfg(target_os = "macos")]
-        let is_pressed = self.logo;
+        let is_pressed = self.logo();
 
         #[cfg(not(target_os = "macos"))]
-        let is_pressed = self.control;
+        let is_pressed = self.control();
 
         is_pressed
     }
-
-    /// Returns true if the current [`Modifiers`] have at least the same
-    /// keys pressed as the provided ones, and false otherwise.
-    pub fn matches(&self, modifiers: Self) -> bool {
-        let shift = !modifiers.shift || self.shift;
-        let control = !modifiers.control || self.control;
-        let alt = !modifiers.alt || self.alt;
-        let logo = !modifiers.logo || self.logo;
-
-        shift && control && alt && logo
-    }
 }
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 6453d599..c4288158 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -15,6 +15,7 @@
 #![forbid(unsafe_code)]
 #![forbid(rust_2018_idioms)]
 pub mod keyboard;
+pub mod menu;
 pub mod mouse;
 
 mod align;
@@ -33,6 +34,7 @@ pub use background::Background;
 pub use color::Color;
 pub use font::Font;
 pub use length::Length;
+pub use menu::Menu;
 pub use padding::Padding;
 pub use point::Point;
 pub use rectangle::Rectangle;
diff --git a/core/src/menu.rs b/core/src/menu.rs
new file mode 100644
index 00000000..8a679085
--- /dev/null
+++ b/core/src/menu.rs
@@ -0,0 +1,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,
+        }
+    }
+}