Revert system menus support

The current implementation has some important issues on Windows. We will reintroduce the feature once we figure them out!

I have kept some of the changes in #945, like the new `keyboard::Modifiers` powered by `bitflags`.

4 files changed, 2 insertions, 320 deletions

diff --git a/winit/Cargo.toml b/winit/Cargo.toml
index 6eca624d..c5c6ef70 100644
--- a/winit/Cargo.toml
+++ b/winit/Cargo.toml
@@ -21,7 +21,7 @@ thiserror = "1.0"
 [dependencies.winit]
 version = "0.25"
 git = "https://github.com/iced-rs/winit"
-rev = "24a75a7bdc10d2dc2f520c36284618e9ae6c2568"
+rev = "44a9a6fc442fcfa3fa0dfc2d5a2f86fdf4aba10c"
 
 [dependencies.iced_native]
 version = "0.4"
diff --git a/winit/src/application.rs b/winit/src/application.rs
index 722b4757..ab9a70a0 100644
--- a/winit/src/application.rs
+++ b/winit/src/application.rs
@@ -15,7 +15,6 @@ 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;
@@ -100,13 +99,6 @@ pub trait Application: Program {
     fn should_exit(&self) -> bool {
         false
     }
-
-    /// Returns the current system [`Menu`] of the [`Application`].
-    ///
-    /// By default, it returns an empty [`Menu`].
-    fn menu(&self) -> Menu<Self::Message> {
-        Menu::new()
-    }
 }
 
 /// Runs an [`Application`] with an executor, compositor, and the provided
@@ -153,7 +145,6 @@ where
             event_loop.primary_monitor(),
             settings.id,
         )
-        .with_menu(Some(conversion::menu(&application.menu())))
         .build(&event_loop)
         .map_err(Error::WindowCreationFailed)?;
 
@@ -420,16 +411,6 @@ async fn run_instance<A, E, C>(
                 }
             }
             event::Event::WindowEvent {
-                event: event::WindowEvent::MenuEntryActivated(entry_id),
-                ..
-            } => {
-                if let Some(message) =
-                    conversion::menu_message(state.menu(), entry_id)
-                {
-                    messages.push(message);
-                }
-            }
-            event::Event::WindowEvent {
                 event: window_event,
                 ..
             } => {
diff --git a/winit/src/application/state.rs b/winit/src/application/state.rs
index f60f09be..b54d3aed 100644
--- a/winit/src/application/state.rs
+++ b/winit/src/application/state.rs
@@ -1,5 +1,5 @@
 use crate::conversion;
-use crate::{Application, Color, Debug, Menu, Mode, Point, Size, Viewport};
+use crate::{Application, Color, Debug, Mode, Point, Size, Viewport};
 
 use std::marker::PhantomData;
 use winit::event::{Touch, WindowEvent};
@@ -9,7 +9,6 @@ use winit::window::Window;
 #[derive(Debug, Clone)]
 pub struct State<A: Application> {
     title: String,
-    menu: Menu<A::Message>,
     mode: Mode,
     background_color: Color,
     scale_factor: f64,
@@ -24,7 +23,6 @@ impl<A: Application> State<A> {
     /// Creates a new [`State`] for the provided [`Application`] and window.
     pub fn new(application: &A, window: &Window) -> Self {
         let title = application.title();
-        let menu = application.menu();
         let mode = application.mode();
         let background_color = application.background_color();
         let scale_factor = application.scale_factor();
@@ -40,7 +38,6 @@ impl<A: Application> State<A> {
 
         Self {
             title,
-            menu,
             mode,
             background_color,
             scale_factor,
@@ -53,11 +50,6 @@ impl<A: Application> State<A> {
         }
     }
 
-    /// Returns the current [`Menu`] of the [`State`].
-    pub fn menu(&self) -> &Menu<A::Message> {
-        &self.menu
-    }
-
     /// Returns the current background [`Color`] of the [`State`].
     pub fn background_color(&self) -> Color {
         self.background_color
@@ -211,14 +203,5 @@ impl<A: Application> State<A> {
 
             self.scale_factor = new_scale_factor;
         }
-
-        // Update menu
-        let new_menu = application.menu();
-
-        if self.menu != new_menu {
-            window.set_menu(Some(conversion::menu(&new_menu)));
-
-            self.menu = new_menu;
-        }
     }
 }
diff --git a/winit/src/conversion.rs b/winit/src/conversion.rs
index 8e2dd02d..b00a095d 100644
--- a/winit/src/conversion.rs
+++ b/winit/src/conversion.rs
@@ -3,7 +3,6 @@
 //! [`winit`]: https://github.com/rust-windowing/winit
 //! [`iced_native`]: https://github.com/hecrj/iced/tree/master/native
 use crate::keyboard;
-use crate::menu::{self, Menu};
 use crate::mouse;
 use crate::touch;
 use crate::window;
@@ -206,110 +205,6 @@ 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 {
-    fn menu_i<Message>(
-        converted: &mut winit::window::Menu,
-        starting_id: u16,
-        menu: &Menu<Message>,
-    ) -> u16 {
-        let mut id = starting_id;
-
-        for item in menu.iter() {
-            match item {
-                menu::Entry::Item { title, hotkey, .. } => {
-                    converted.add_item(id, title, hotkey.map(self::hotkey));
-
-                    id += 1;
-                }
-                menu::Entry::Dropdown { title, submenu } => {
-                    let mut converted_submenu = winit::window::Menu::new();
-                    let n_children =
-                        menu_i(&mut converted_submenu, id, submenu);
-
-                    converted.add_dropdown(title, converted_submenu);
-
-                    id += n_children;
-                }
-                menu::Entry::Separator => {
-                    converted.add_separator();
-                }
-            }
-        }
-
-        id - starting_id
-    }
-
-    let mut converted = winit::window::Menu::default();
-    let _ = menu_i(&mut converted, 0, menu);
-
-    converted
-}
-
-/// Given a [`Menu`] and an identifier of a [`menu::Entry`], it returns the
-/// `Message` that should be produced when that entry is activated.
-pub fn menu_message<Message>(menu: &Menu<Message>, id: u16) -> Option<Message>
-where
-    Message: Clone,
-{
-    fn find_message<Message>(
-        target: u16,
-        starting_id: u16,
-        menu: &Menu<Message>,
-    ) -> Result<Message, u16>
-    where
-        Message: Clone,
-    {
-        let mut id = starting_id;
-
-        for entry in menu.iter() {
-            match entry {
-                menu::Entry::Item { on_activation, .. } => {
-                    if id == target {
-                        return Ok(on_activation.clone());
-                    }
-
-                    id += 1;
-                }
-                menu::Entry::Dropdown { submenu, .. } => {
-                    match find_message(target, id, submenu) {
-                        Ok(message) => {
-                            return Ok(message);
-                        }
-                        Err(n_children) => {
-                            id += n_children;
-                        }
-                    }
-                }
-                menu::Entry::Separator => {}
-            }
-        }
-
-        Err(id - starting_id)
-    }
-
-    find_message(id, 0, menu).ok()
-}
-
 /// Converts a `MouseCursor` from [`iced_native`] to a [`winit`] cursor icon.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit
@@ -408,183 +303,6 @@ 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