Initial menu implementation

Cargo.toml

@@ -85,6 +85,7 @@ members = [
     "examples/tour",
     "examples/tooltip",
     "examples/url_handler",
+    "examples/menu",
 ]
 
 [dependencies]
@@ -92,6 +93,9 @@ iced_core = { version = "0.4", path = "core" }
 iced_futures = { version = "0.3", path = "futures" }
 thiserror = "1.0"
 
+[patch.crates-io]
+winit = { git = "https://github.com/iced-rs/winit", rev = "e351421a32bf01b428325dde44dea39ee2656153"}
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 iced_winit = { version = "0.3", path = "winit" }
 iced_glutin = { version = "0.2", path = "glutin", optional = true }

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;

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 }
+    }
+}

examples/menu/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "menu"
+version = "0.1.0"
+authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+iced = { path = "../.." }
+iced_native = { path = "../../native" }

examples/menu/src/main.rs

@@ -0,0 +1,123 @@
+use iced::{
+    executor, Application, Clipboard, Command, Container, Element, Length,
+    Menu, Settings, Text,
+};
+use iced_native::keyboard::{Hotkey, KeyCode, Modifiers};
+
+pub fn main() -> iced::Result {
+    App::run(Settings::default())
+}
+
+#[derive(Debug, Default)]
+struct App {
+    selected: Option<Entry>,
+}
+
+#[derive(Debug, Clone)]
+enum Entry {
+    One,
+    Two,
+    Three,
+    A,
+    B,
+    C,
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    MenuActivated(Entry),
+}
+
+impl Application for App {
+    type Executor = executor::Default;
+    type Message = Message;
+    type Flags = ();
+
+    fn new(_flags: ()) -> (App, Command<Message>) {
+        (App::default(), Command::none())
+    }
+
+    fn title(&self) -> String {
+        String::from("Menu - Iced")
+    }
+
+    fn menu(&self) -> Menu<Message> {
+        let alt = Modifiers {
+            alt: true,
+            control: false,
+            logo: false,
+            shift: false,
+        };
+        let ctrl_shift = Modifiers {
+            control: true,
+            shift: true,
+            logo: false,
+            alt: false,
+        };
+
+        Menu::new()
+            .dropdown(
+                "First",
+                Menu::new()
+                    .item(
+                        "One",
+                        Hotkey::new(alt, KeyCode::F1),
+                        Message::MenuActivated(Entry::One),
+                    )
+                    .item(
+                        "Two",
+                        Hotkey::new(alt, KeyCode::F2),
+                        Message::MenuActivated(Entry::Two),
+                    )
+                    .separator()
+                    .item(
+                        "Three",
+                        Hotkey::new(alt, KeyCode::F3),
+                        Message::MenuActivated(Entry::Three),
+                    ),
+            )
+            .dropdown(
+                "Second",
+                Menu::new()
+                    .item(
+                        "A",
+                        Hotkey::new(ctrl_shift, KeyCode::A),
+                        Message::MenuActivated(Entry::A),
+                    )
+                    .item(
+                        "B",
+                        Hotkey::new(ctrl_shift, KeyCode::B),
+                        Message::MenuActivated(Entry::B),
+                    )
+                    .separator()
+                    .item(
+                        "C",
+                        Hotkey::new(ctrl_shift, KeyCode::C),
+                        Message::MenuActivated(Entry::C),
+                    ),
+            )
+    }
+
+    fn update(
+        &mut self,
+        message: Message,
+        _clipboard: &mut Clipboard,
+    ) -> Command<Message> {
+        match message {
+            Message::MenuActivated(entry) => self.selected = Some(entry),
+        }
+
+        Command::none()
+    }
+
+    fn view(&mut self) -> Element<Message> {
+        Container::new(
+            Text::new(format!("Selected {:?}", self.selected)).size(48),
+        )
+        .width(Length::Fill)
+        .height(Length::Fill)
+        .center_x()
+        .center_y()
+        .into()
+    }
+}

glutin/Cargo.toml

@@ -15,8 +15,8 @@ debug = ["iced_winit/debug"]
 
 [dependencies.glutin]
 version = "0.27"
-git = "https://github.com/iced-rs/glutin"
-rev = "2564d0ab87cf2ad824a2a58733aebe40dd2f29bb"
+# git = "https://github.com/iced-rs/glutin"
+# rev = "2564d0ab87cf2ad824a2a58733aebe40dd2f29bb"
 
 [dependencies.iced_native]
 version = "0.4"

native/src/lib.rs

@@ -37,6 +37,7 @@ pub mod clipboard;
 pub mod event;
 pub mod keyboard;
 pub mod layout;
+pub mod menu;
 pub mod mouse;
 pub mod overlay;
 pub mod program;
@@ -75,6 +76,7 @@ pub use element::Element;
 pub use event::Event;
 pub use hasher::Hasher;
 pub use layout::Layout;
+pub use menu::{Menu, MenuEntry};
 pub use overlay::Overlay;
 pub use program::Program;
 pub use renderer::Renderer;

native/src/menu.rs

@@ -0,0 +1,81 @@
+//! 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, PartialEq)]
+pub struct Menu<Message> {
+    items: Vec<MenuEntry<Message>>,
+}
+
+impl<Message> Menu<Message> {
+    /// Creates an empty [`Menu`].
+    pub fn new() -> Self {
+        Menu { items: Vec::new() }
+    }
+
+    /// Adds an item to the [`Menu`].
+    pub fn item<S: Into<String>>(
+        mut self,
+        content: S,
+        hotkey: impl Into<Option<Hotkey>>,
+        on_activation: Message,
+    ) -> Self {
+        let content = content.into();
+        let hotkey = hotkey.into();
+
+        self.items.push(MenuEntry::Item {
+            on_activation,
+            content,
+            hotkey,
+        });
+        self
+    }
+
+    /// Adds a separator to the [`Menu`].
+    pub fn separator(mut self) -> Self {
+        self.items.push(MenuEntry::Separator);
+        self
+    }
+
+    /// Adds a dropdown to the [`Menu`].
+    pub fn dropdown<S: Into<String>>(
+        mut self,
+        content: S,
+        submenu: Menu<Message>,
+    ) -> Self {
+        let content = content.into();
+
+        self.items.push(MenuEntry::Dropdown { content, submenu });
+        self
+    }
+
+    /// Returns a [`MenuEntry`] iterator.
+    pub fn iter(self) -> std::vec::IntoIter<MenuEntry<Message>> {
+        self.items.into_iter()
+    }
+}
+
+/// Represents one of the possible entries used to build a [`Menu`].
+#[derive(Debug, Clone, PartialEq)]
+pub enum MenuEntry<Message> {
+    /// Item for a [`Menu`]
+    Item {
+        /// The title of the item
+        content: 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
+        content: String,
+        /// The submenu of the dropdown
+        submenu: Menu<Message>,
+    },
+    /// Separator for a [`Menu`]
+    Separator,
+}

src/application.rs

@@ -1,6 +1,6 @@
 use crate::window;
 use crate::{
-    Clipboard, Color, Command, Element, Executor, Settings, Subscription,
+    Clipboard, Color, Command, Element, Executor, Menu, Settings, Subscription,
 };
 
 /// An interactive cross-platform application.
@@ -191,6 +191,11 @@ pub trait Application: Sized {
         false
     }
 
+    /// TODO
+    fn menu(&self) -> Menu<Self::Message> {
+        Menu::new()
+    }
+
     /// Runs the [`Application`].
     ///
     /// On native platforms, this method will take control of the current thread
@@ -296,6 +301,10 @@ where
     fn should_exit(&self) -> bool {
         self.0.should_exit()
     }
+
+    fn menu(&self) -> Menu<Self::Message> {
+        self.0.menu()
+    }
 }
 
 #[cfg(target_arch = "wasm32")]

src/lib.rs

@@ -246,6 +246,6 @@ pub use settings::Settings;
 
 pub use runtime::{
     futures, Align, Background, Clipboard, Color, Command, Font,
-    HorizontalAlignment, Length, Point, Rectangle, Size, Subscription, Vector,
-    VerticalAlignment,
+    HorizontalAlignment, Length, Menu, Point, Rectangle, Size, Subscription,
+    Vector, VerticalAlignment,
 };

winit/Cargo.toml

@@ -20,8 +20,8 @@ thiserror = "1.0"
 
 [dependencies.winit]
 version = "0.25"
-git = "https://github.com/iced-rs/winit"
-rev = "44a9a6fc442fcfa3fa0dfc2d5a2f86fdf4aba10c"
+# git = "https://github.com/iced-rs/winit"
+# rev = "e351421a32bf01b428325dde44dea39ee2656153"
 
 [dependencies.iced_native]
 version = "0.4"

winit/src/application.rs

@@ -14,6 +14,7 @@ use iced_futures::futures;
 use iced_futures::futures::channel::mpsc;
 use iced_graphics::window;
 use iced_native::program::Program;
+use iced_native::Menu;
 use iced_native::{Cache, UserInterface};
 
 use std::mem::ManuallyDrop;
@@ -98,6 +99,11 @@ pub trait Application: Program<Clipboard = Clipboard> {
     fn should_exit(&self) -> bool {
         false
     }
+
+    /// TODO
+    fn menu(&self) -> Menu<Self::Message> {
+        Menu::new()
+    }
 }
 
 /// Runs an [`Application`] with an executor, compositor, and the provided

winit/src/application/state.rs

@@ -36,6 +36,8 @@ impl<A: Application> State<A> {
             )
         };
 
+        window.set_menu(Some(conversion::menu(application.menu())));
+
         Self {
             title,
             mode,

winit/src/conversion.rs

@@ -6,7 +6,7 @@ use crate::keyboard;
 use crate::mouse;
 use crate::touch;
 use crate::window;
-use crate::{Event, Mode, Point};
+use crate::{Event, Menu, MenuEntry, Mode, Point};
 
 /// Converts a winit window event into an iced event.
 pub fn window_event(
@@ -156,6 +156,51 @@ pub fn visible(mode: Mode) -> bool {
     }
 }
 
+/// Converts a `Hotkey` from [`iced_native`] to a [`winit`] Hotkey.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced_native`]: https://github.com/hecrj/iced/tree/master/native
+fn hotkey(hotkey: keyboard::Hotkey) -> winit::window::Hotkey {
+    use winit::event::ModifiersState;
+
+    let mut modifiers = ModifiersState::empty();
+    modifiers.set(ModifiersState::CTRL, hotkey.modifiers.control);
+    modifiers.set(ModifiersState::SHIFT, hotkey.modifiers.shift);
+    modifiers.set(ModifiersState::ALT, hotkey.modifiers.alt);
+    modifiers.set(ModifiersState::LOGO, hotkey.modifiers.logo);
+
+    winit::window::Hotkey::new(modifiers, to_virtual_keycode(hotkey.key))
+}
+
+/// Converts a `Menu` from [`iced_native`] to a [`winit`] menu.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced_native`]: https://github.com/hecrj/iced/tree/master/native
+pub fn menu<Message>(menu: Menu<Message>) -> winit::window::Menu {
+    let mut converted = winit::window::Menu::new();
+
+    for item in menu.iter() {
+        match item {
+            MenuEntry::Item {
+                content, hotkey, ..
+            } => {
+                let hotkey: Option<&keyboard::Hotkey> = hotkey.as_ref().into();
+                converted.add_item(
+                    0,
+                    content,
+                    hotkey.map(|h| self::hotkey(*h)),
+                );
+            }
+            MenuEntry::Dropdown { content, submenu } => {
+                converted.add_dropdown(content, self::menu(submenu));
+            }
+            MenuEntry::Separator => converted.add_separator(),
+        }
+    }
+
+    converted
+}
+
 /// Converts a `MouseCursor` from [`iced_native`] to a [`winit`] cursor icon.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit
@@ -252,6 +297,183 @@ pub fn touch_event(
     }
 }
 
+/// Converts a `KeyCode` from [`iced_native`] to an [`winit`] key code.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+/// [`iced_native`]: https://github.com/hecrj/iced/tree/master/native
+fn to_virtual_keycode(
+    keycode: keyboard::KeyCode,
+) -> winit::event::VirtualKeyCode {
+    use keyboard::KeyCode;
+    use winit::event::VirtualKeyCode;
+
+    match keycode {
+        KeyCode::Key1 => VirtualKeyCode::Key1,
+        KeyCode::Key2 => VirtualKeyCode::Key2,
+        KeyCode::Key3 => VirtualKeyCode::Key3,
+        KeyCode::Key4 => VirtualKeyCode::Key4,
+        KeyCode::Key5 => VirtualKeyCode::Key5,
+        KeyCode::Key6 => VirtualKeyCode::Key6,
+        KeyCode::Key7 => VirtualKeyCode::Key7,
+        KeyCode::Key8 => VirtualKeyCode::Key8,
+        KeyCode::Key9 => VirtualKeyCode::Key9,
+        KeyCode::Key0 => VirtualKeyCode::Key0,
+        KeyCode::A => VirtualKeyCode::A,
+        KeyCode::B => VirtualKeyCode::B,
+        KeyCode::C => VirtualKeyCode::C,
+        KeyCode::D => VirtualKeyCode::D,
+        KeyCode::E => VirtualKeyCode::E,
+        KeyCode::F => VirtualKeyCode::F,
+        KeyCode::G => VirtualKeyCode::G,
+        KeyCode::H => VirtualKeyCode::H,
+        KeyCode::I => VirtualKeyCode::I,
+        KeyCode::J => VirtualKeyCode::J,
+        KeyCode::K => VirtualKeyCode::K,
+        KeyCode::L => VirtualKeyCode::L,
+        KeyCode::M => VirtualKeyCode::M,
+        KeyCode::N => VirtualKeyCode::N,
+        KeyCode::O => VirtualKeyCode::O,
+        KeyCode::P => VirtualKeyCode::P,
+        KeyCode::Q => VirtualKeyCode::Q,
+        KeyCode::R => VirtualKeyCode::R,
+        KeyCode::S => VirtualKeyCode::S,
+        KeyCode::T => VirtualKeyCode::T,
+        KeyCode::U => VirtualKeyCode::U,
+        KeyCode::V => VirtualKeyCode::V,
+        KeyCode::W => VirtualKeyCode::W,
+        KeyCode::X => VirtualKeyCode::X,
+        KeyCode::Y => VirtualKeyCode::Y,
+        KeyCode::Z => VirtualKeyCode::Z,
+        KeyCode::Escape => VirtualKeyCode::Escape,
+        KeyCode::F1 => VirtualKeyCode::F1,
+        KeyCode::F2 => VirtualKeyCode::F2,
+        KeyCode::F3 => VirtualKeyCode::F3,
+        KeyCode::F4 => VirtualKeyCode::F4,
+        KeyCode::F5 => VirtualKeyCode::F5,
+        KeyCode::F6 => VirtualKeyCode::F6,
+        KeyCode::F7 => VirtualKeyCode::F7,
+        KeyCode::F8 => VirtualKeyCode::F8,
+        KeyCode::F9 => VirtualKeyCode::F9,
+        KeyCode::F10 => VirtualKeyCode::F10,
+        KeyCode::F11 => VirtualKeyCode::F11,
+        KeyCode::F12 => VirtualKeyCode::F12,
+        KeyCode::F13 => VirtualKeyCode::F13,
+        KeyCode::F14 => VirtualKeyCode::F14,
+        KeyCode::F15 => VirtualKeyCode::F15,
+        KeyCode::F16 => VirtualKeyCode::F16,
+        KeyCode::F17 => VirtualKeyCode::F17,
+        KeyCode::F18 => VirtualKeyCode::F18,
+        KeyCode::F19 => VirtualKeyCode::F19,
+        KeyCode::F20 => VirtualKeyCode::F20,
+        KeyCode::F21 => VirtualKeyCode::F21,
+        KeyCode::F22 => VirtualKeyCode::F22,
+        KeyCode::F23 => VirtualKeyCode::F23,
+        KeyCode::F24 => VirtualKeyCode::F24,
+        KeyCode::Snapshot => VirtualKeyCode::Snapshot,
+        KeyCode::Scroll => VirtualKeyCode::Scroll,
+        KeyCode::Pause => VirtualKeyCode::Pause,
+        KeyCode::Insert => VirtualKeyCode::Insert,
+        KeyCode::Home => VirtualKeyCode::Home,
+        KeyCode::Delete => VirtualKeyCode::Delete,
+        KeyCode::End => VirtualKeyCode::End,
+        KeyCode::PageDown => VirtualKeyCode::PageDown,
+        KeyCode::PageUp => VirtualKeyCode::PageUp,
+        KeyCode::Left => VirtualKeyCode::Left,
+        KeyCode::Up => VirtualKeyCode::Up,
+        KeyCode::Right => VirtualKeyCode::Right,
+        KeyCode::Down => VirtualKeyCode::Down,
+        KeyCode::Backspace => VirtualKeyCode::Back,
+        KeyCode::Enter => VirtualKeyCode::Return,
+        KeyCode::Space => VirtualKeyCode::Space,
+        KeyCode::Compose => VirtualKeyCode::Compose,
+        KeyCode::Caret => VirtualKeyCode::Caret,
+        KeyCode::Numlock => VirtualKeyCode::Numlock,
+        KeyCode::Numpad0 => VirtualKeyCode::Numpad0,
+        KeyCode::Numpad1 => VirtualKeyCode::Numpad1,
+        KeyCode::Numpad2 => VirtualKeyCode::Numpad2,
+        KeyCode::Numpad3 => VirtualKeyCode::Numpad3,
+        KeyCode::Numpad4 => VirtualKeyCode::Numpad4,
+        KeyCode::Numpad5 => VirtualKeyCode::Numpad5,
+        KeyCode::Numpad6 => VirtualKeyCode::Numpad6,
+        KeyCode::Numpad7 => VirtualKeyCode::Numpad7,
+        KeyCode::Numpad8 => VirtualKeyCode::Numpad8,
+        KeyCode::Numpad9 => VirtualKeyCode::Numpad9,
+        KeyCode::AbntC1 => VirtualKeyCode::AbntC1,
+        KeyCode::AbntC2 => VirtualKeyCode::AbntC2,
+        KeyCode::NumpadAdd => VirtualKeyCode::NumpadAdd,
+        KeyCode::Plus => VirtualKeyCode::Plus,
+        KeyCode::Apostrophe => VirtualKeyCode::Apostrophe,
+        KeyCode::Apps => VirtualKeyCode::Apps,
+        KeyCode::At => VirtualKeyCode::At,
+        KeyCode::Ax => VirtualKeyCode::Ax,
+        KeyCode::Backslash => VirtualKeyCode::Backslash,
+        KeyCode::Calculator => VirtualKeyCode::Calculator,
+        KeyCode::Capital => VirtualKeyCode::Capital,
+        KeyCode::Colon => VirtualKeyCode::Colon,
+        KeyCode::Comma => VirtualKeyCode::Comma,
+        KeyCode::Convert => VirtualKeyCode::Convert,
+        KeyCode::NumpadDecimal => VirtualKeyCode::NumpadDecimal,
+        KeyCode::NumpadDivide => VirtualKeyCode::NumpadDivide,
+        KeyCode::Equals => VirtualKeyCode::Equals,
+        KeyCode::Grave => VirtualKeyCode::Grave,
+        KeyCode::Kana => VirtualKeyCode::Kana,
+        KeyCode::Kanji => VirtualKeyCode::Kanji,
+        KeyCode::LAlt => VirtualKeyCode::LAlt,
+        KeyCode::LBracket => VirtualKeyCode::LBracket,
+        KeyCode::LControl => VirtualKeyCode::LControl,
+        KeyCode::LShift => VirtualKeyCode::LShift,
+        KeyCode::LWin => VirtualKeyCode::LWin,
+        KeyCode::Mail => VirtualKeyCode::Mail,
+        KeyCode::MediaSelect => VirtualKeyCode::MediaSelect,
+        KeyCode::MediaStop => VirtualKeyCode::MediaStop,
+        KeyCode::Minus => VirtualKeyCode::Minus,
+        KeyCode::NumpadMultiply => VirtualKeyCode::NumpadMultiply,
+        KeyCode::Mute => VirtualKeyCode::Mute,
+        KeyCode::MyComputer => VirtualKeyCode::MyComputer,
+        KeyCode::NavigateForward => VirtualKeyCode::NavigateForward,
+        KeyCode::NavigateBackward => VirtualKeyCode::NavigateBackward,
+        KeyCode::NextTrack => VirtualKeyCode::NextTrack,
+        KeyCode::NoConvert => VirtualKeyCode::NoConvert,
+        KeyCode::NumpadComma => VirtualKeyCode::NumpadComma,
+        KeyCode::NumpadEnter => VirtualKeyCode::NumpadEnter,
+        KeyCode::NumpadEquals => VirtualKeyCode::NumpadEquals,
+        KeyCode::OEM102 => VirtualKeyCode::OEM102,
+        KeyCode::Period => VirtualKeyCode::Period,
+        KeyCode::PlayPause => VirtualKeyCode::PlayPause,
+        KeyCode::Power => VirtualKeyCode::Power,
+        KeyCode::PrevTrack => VirtualKeyCode::PrevTrack,
+        KeyCode::RAlt => VirtualKeyCode::RAlt,
+        KeyCode::RBracket => VirtualKeyCode::RBracket,
+        KeyCode::RControl => VirtualKeyCode::RControl,
+        KeyCode::RShift => VirtualKeyCode::RShift,
+        KeyCode::RWin => VirtualKeyCode::RWin,
+        KeyCode::Semicolon => VirtualKeyCode::Semicolon,
+        KeyCode::Slash => VirtualKeyCode::Slash,
+        KeyCode::Sleep => VirtualKeyCode::Sleep,
+        KeyCode::Stop => VirtualKeyCode::Stop,
+        KeyCode::NumpadSubtract => VirtualKeyCode::NumpadSubtract,
+        KeyCode::Sysrq => VirtualKeyCode::Sysrq,
+        KeyCode::Tab => VirtualKeyCode::Tab,
+        KeyCode::Underline => VirtualKeyCode::Underline,
+        KeyCode::Unlabeled => VirtualKeyCode::Unlabeled,
+        KeyCode::VolumeDown => VirtualKeyCode::VolumeDown,
+        KeyCode::VolumeUp => VirtualKeyCode::VolumeUp,
+        KeyCode::Wake => VirtualKeyCode::Wake,
+        KeyCode::WebBack => VirtualKeyCode::WebBack,
+        KeyCode::WebFavorites => VirtualKeyCode::WebFavorites,
+        KeyCode::WebForward => VirtualKeyCode::WebForward,
+        KeyCode::WebHome => VirtualKeyCode::WebHome,
+        KeyCode::WebRefresh => VirtualKeyCode::WebRefresh,
+        KeyCode::WebSearch => VirtualKeyCode::WebSearch,
+        KeyCode::WebStop => VirtualKeyCode::WebStop,
+        KeyCode::Yen => VirtualKeyCode::Yen,
+        KeyCode::Copy => VirtualKeyCode::Copy,
+        KeyCode::Paste => VirtualKeyCode::Paste,
+        KeyCode::Cut => VirtualKeyCode::Cut,
+        KeyCode::Asterisk => VirtualKeyCode::Asterisk,
+    }
+}
+
 /// Converts a `VirtualKeyCode` from [`winit`] to an [`iced_native`] key code.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit