refactor: rewrite

Cargo.toml

@@ -12,18 +12,18 @@ categories = ["gui"]
 
 [dependencies]
 crossbeam-channel = "0.5"
-once_cell = "1.10"
 keyboard-types = "0.6"
+once_cell = "1"
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.34"
+version = "0.42"
 features = [
     "Win32_UI_WindowsAndMessaging",
     "Win32_Foundation",
     "Win32_Graphics_Gdi",
     "Win32_UI_Shell",
     "Win32_Globalization",
-    "Win32_UI_Input_KeyboardAndMouse"
+    "Win32_UI_Input_KeyboardAndMouse",
 ]
 
 [target.'cfg(target_os = "linux")'.dependencies]
@@ -36,5 +36,5 @@ cocoa = "0.24"
 objc = "0.2"
 
 [dev-dependencies]
-winit = { git = "https://github.com/rust-windowing/winit" }
+winit = "0.27"
 tao = { git = "https://github.com/tauri-apps/tao", branch = "muda" }

README.md

@@ -1,29 +1,59 @@
-# muda
-
-Menu Utilities for Desktop Applications.
+muda is a Menu Utilities library for Desktop Applications.
 
 ## Example
 
-Create the root menu and add submenus and men items.
+Create the menu and add your items
+
 ```rs
-let mut menu = Menu::new();
+let menu = Menu::new();
+let menu_item2 = MenuItem::new("Menu item #2", false, None);
+let submenu = Submenu::with_items("Submenu Outer", true,&[
+  &MenuItem::new("Menu item #1", true, Some(Accelerator::new(Some(Modifiers::ALT), Code::KeyD))),
+  &PredefinedMenuItem::separator(),
+  &menu_item2,
+  &MenuItem::new("Menu item #3", true, None),
+  &PredefinedMenuItem::separator(),
+  &Submenu::with_items("Submenu Inner", true,&[
+    &MenuItem::new("Submenu item #1", true, None),
+    &PredefinedMenuItem::separator(),
+    &menu_item2,
+  ])
+]);
 
-let file_menu = menu.add_submenu("File", true);
-let open_item = file_menu.add_text_item("Open", true);
-let save_item = file_menu.add_text_item("Save", true);
+```
 
-let edit_menu = menu.add_submenu("Edit", true);
-let copy_item = file_menu.add_text_item("Copy", true);
-let cut_item = file_menu.add_text_item("Cut", true);
+Then Add your root menu to a Window on Windows and Linux Only or use it
+as your global app menu on macOS
 
+```rs
+// --snip--
 #[cfg(target_os = "windows")]
 menu.init_for_hwnd(window.hwnd() as isize);
 #[cfg(target_os = "linux")]
 menu.init_for_gtk_window(&gtk_window);
 #[cfg(target_os = "macos")]
 menu.init_for_nsapp();
 ```
-Then listen for the events
+
+## Context menus (Popup menus)
+
+You can also use a [`Menu`] or a [`Submenu`] show a context menu.
+
+```rs
+// --snip--
+let x = 100;
+let y = 120;
+#[cfg(target_os = "windows")]
+menu.show_context_menu_for_hwnd(window.hwnd() as isize, x, y);
+#[cfg(target_os = "linux")]
+menu.show_context_menu_for_gtk_window(&gtk_window, x, y);
+#[cfg(target_os = "macos")]
+menu.show_context_menu_for_nsview(nsview, x, y);
+```
+## Processing menu events
+
+You can use [`menu_event_receiver`](https://docs.rs/muda/latest/muda/fn.menu_event_receiver.html) to get a reference to the [`MenuEventReceiver`](https://docs.rs/muda/latest/muda/type.MenuEventReceiver.html)
+which you can use to listen to events when a menu item is activated
 ```rs
 if let Ok(event) = menu_event_receiver().try_recv() {
     match event.id {
@@ -34,3 +64,10 @@ if let Ok(event) = menu_event_receiver().try_recv() {
     }
 }
 ```
+
+## Accelerators on Windows
+
+Accelerators don't work unless the win32 message loop calls
+[`TranslateAcceleratorW`](https://docs.rs/windows-sys/latest/windows_sys/Win32/UI/WindowsAndMessaging/fn.TranslateAcceleratorW.html)
+
+See [`Menu::init_for_hwnd`](https://docs.rs/muda/latest/muda/struct.Menu.html#method.init_for_hwnd) for more details

examples/tao.rs

@@ -1,42 +1,98 @@
-use keyboard_types::Code;
+#![allow(unused)]
 use muda::{
-    accelerator::{Accelerator, Mods},
-    menu_event_receiver, Menu, NativeMenuItem,
+    accelerator::{Accelerator, Code, Modifiers},
+    menu_event_receiver, AboutMetadata, CheckMenuItem, Menu, MenuItem, PredefinedMenuItem, Submenu,
 };
 #[cfg(target_os = "linux")]
 use tao::platform::unix::WindowExtUnix;
 #[cfg(target_os = "windows")]
-use tao::platform::windows::WindowExtWindows;
+use tao::platform::windows::{EventLoopBuilderExtWindows, WindowExtWindows};
 use tao::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event::{ElementState, Event, MouseButton, WindowEvent},
+    event_loop::{ControlFlow, EventLoopBuilder},
     window::WindowBuilder,
 };
 
 fn main() {
-    let event_loop = EventLoop::new();
+    let mut event_loop_builder = EventLoopBuilder::new();
+
+    let menu_bar = Menu::new();
+
+    #[cfg(target_os = "windows")]
+    {
+        let menu_bar_c = menu_bar.clone();
+        event_loop_builder.with_msg_hook(move |msg| {
+            use windows_sys::Win32::UI::WindowsAndMessaging::{TranslateAcceleratorW, MSG};
+            unsafe {
+                let msg = msg as *const MSG;
+                let translated = TranslateAcceleratorW((*msg).hwnd, menu_bar_c.haccel(), msg);
+                translated == 1
+            }
+        });
+    }
+
+    #[allow(unused_mut)]
+    let mut event_loop = event_loop_builder.build();
 
     let window = WindowBuilder::new().build(&event_loop).unwrap();
     let window2 = WindowBuilder::new().build(&event_loop).unwrap();
 
-    let mut menu_bar = Menu::new();
+    let file_m = Submenu::new("File", true);
+    let edit_m = Submenu::new("Edit", true);
+    let window_m = Submenu::new("Window", true);
+
+    menu_bar.append_items(&[&file_m, &edit_m, &window_m]);
 
-    let mut file_menu = menu_bar.add_submenu("&File", true);
-    let mut open_item = file_menu.add_item("&Open", true, None);
-    let mut save_item = file_menu.add_item(
-        "&Save",
+    let custom_i_1 = MenuItem::new(
+        "C&ustom 1",
+        true,
+        Some(Accelerator::new(Some(Modifiers::ALT), Code::KeyC)),
+    );
+    let custom_i_2 = MenuItem::new("Custom 2", false, None);
+    let check_custom_i_1 = CheckMenuItem::new("Check Custom 1", true, true, None);
+    let check_custom_i_2 = CheckMenuItem::new("Check Custom 2", false, true, None);
+    let check_custom_i_3 = CheckMenuItem::new(
+        "Check Custom 3",
+        true,
         true,
-        Some(Accelerator::new(Mods::Ctrl, Code::KeyS)),
+        Some(Accelerator::new(Some(Modifiers::SHIFT), Code::KeyD)),
     );
-    file_menu.add_native_item(NativeMenuItem::Minimize);
-    file_menu.add_native_item(NativeMenuItem::CloseWindow);
-    file_menu.add_native_item(NativeMenuItem::Quit);
 
-    let mut edit_menu = menu_bar.add_submenu("&Edit", true);
-    edit_menu.add_native_item(NativeMenuItem::Cut);
-    edit_menu.add_native_item(NativeMenuItem::Copy);
-    edit_menu.add_native_item(NativeMenuItem::Paste);
-    edit_menu.add_native_item(NativeMenuItem::SelectAll);
+    let copy_i = PredefinedMenuItem::copy(None);
+    let cut_i = PredefinedMenuItem::cut(None);
+    let paste_i = PredefinedMenuItem::paste(None);
+
+    file_m.append_items(&[
+        &custom_i_1,
+        &custom_i_2,
+        &window_m,
+        &PredefinedMenuItem::separator(),
+        &check_custom_i_1,
+    ]);
+
+    window_m.append_items(&[
+        &check_custom_i_2,
+        &PredefinedMenuItem::close_window(None),
+        &PredefinedMenuItem::separator(),
+        &PredefinedMenuItem::quit(None),
+        &PredefinedMenuItem::select_all(None),
+        &PredefinedMenuItem::about(
+            None,
+            Some(AboutMetadata {
+                name: Some("tao".to_string()),
+                copyright: Some("Copyright TAO".to_string()),
+                ..Default::default()
+            }),
+        ),
+        &PredefinedMenuItem::minimize(None),
+        &check_custom_i_3,
+        &custom_i_1,
+    ]);
+
+    edit_m.append_items(&[&copy_i, &PredefinedMenuItem::separator(), &cut_i]);
+
+    edit_m.prepend(&paste_i);
+    window_m.insert(&cut_i, 2);
 
     #[cfg(target_os = "windows")]
     {
@@ -50,9 +106,9 @@ fn main() {
     }
 
     let menu_channel = menu_event_receiver();
-    let mut open_item_disabled = false;
-    let mut counter = 0;
 
+    let mut x = 0_f64;
+    let mut y = 0_f64;
     event_loop.run(move |event, _, control_flow| {
         *control_flow = ControlFlow::Wait;
 
@@ -65,27 +121,42 @@ fn main() {
                 event: WindowEvent::CloseRequested,
                 ..
             } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent {
+                event: WindowEvent::CursorMoved { position, .. },
+                window_id,
+                ..
+            } => {
+                if window_id == window.id() {
+                    x = position.x;
+                    y = position.y;
+                }
+            }
+            Event::WindowEvent {
+                event:
+                    WindowEvent::MouseInput {
+                        state: ElementState::Pressed,
+                        button: MouseButton::Right,
+                        ..
+                    },
+                window_id,
+                ..
+            } => {
+                if window_id == window.id() {
+                    #[cfg(target_os = "windows")]
+                    window_m.show_context_menu_for_hwnd(window2.hwnd() as _, x, y);
+                }
+            }
             Event::MainEventsCleared => {
-                // window.request_redraw();
+                window.request_redraw();
             }
             _ => (),
         }
 
         if let Ok(event) = menu_channel.try_recv() {
-            match event.id {
-                _ if event.id == save_item.id() => {
-                    println!("Save menu item activated!");
-                    counter += 1;
-                    save_item.set_label(format!("&Save activated {counter} times"));
-
-                    if !open_item_disabled {
-                        println!("Open item disabled!");
-                        open_item.set_enabled(false);
-                        open_item_disabled = true;
-                    }
-                }
-                _ => {}
+            if event.id == custom_i_1.id() {
+                file_m.insert(&MenuItem::new("asdasd", false, None), 2);
             }
+            println!("{:?}", event);
         }
     })
 }