me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Revert system menus support

Browse source 
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`.
This commit is contained in:
Héctor Ramón Jiménez 2021-09-15 15:31:40 +07:00
parent 93fec8d273
commit c0ab988842
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
21 changed files with 19 additions and 673 deletions
Download patch file Download diff file Expand all files Collapse all files

19
winit/src/application.rs
View file

@ -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)?;
@ -419,16 +410,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,
..

19
winit/src/application/state.rs
View file

@ -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;
}
}
}

282
winit/src/conversion.rs
View file

@ -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