Implement global shortcut on Linux, close #307 (#308)

* Implement wrong global shortcut

This one set accelerator group to each window.
It's not the real global shortcut. If no window is active, all shortcuts
won't work.

* Implement correct global shortcut

* Add change file [skip ci]

* Use GAction for accelerator instead

* Update event name and error message

.changes/linux-shortcuts.md

@@ -0,0 +1,5 @@
+---
+"tao": patch
+---
+
+Fix global shortcut support on Linux (both x11 and wayland).

examples/global_shortcut.rs

@@ -23,7 +23,7 @@ fn main() {
   let shortcut_1 = Accelerator::new(SysMods::Shift, KeyCode::ArrowUp);
   let shortcut_2 = Accelerator::new(RawMods::AltCtrlMeta, KeyCode::KeyB);
   // use string parser to generate accelerator (require `std::str::FromStr`)
-  let shortcut_3 = Accelerator::from_str("COMMANDORCONTROL+SHIFT+3").unwrap();
+  let shortcut_3 = Accelerator::from_str("COMMANDORCONTROL+3").unwrap();
   let shortcut_4 = Accelerator::from_str("COMMANDORCONTROL+shIfT+DOWN").unwrap();
 
   // save a reference to unregister it later
@@ -64,7 +64,7 @@ fn main() {
       // by example `shortcut_1` will NOT match AcceleratorId::new("SHIFT+UP") as it's
       // been created with a struct and the ID is generated automatically
       Event::GlobalShortcutEvent(hotkey_id)
-        if hotkey_id == AcceleratorId::new("COMMANDORCONTROL+SHIFT+3") =>
+        if hotkey_id == AcceleratorId::new("COMMANDORCONTROL+3") =>
       {
         println!("Pressed on `shortcut_3`");
       }

src/platform_impl/linux/event_loop.rs

@@ -17,7 +17,6 @@ use glib::{source::Priority, Continue, MainContext};
 use gtk::{prelude::*, AboutDialog, Inhibit};
 
 use crate::{
-  accelerator::AcceleratorId,
   dpi::{LogicalPosition, LogicalSize},
   event::{ElementState, Event, MouseButton, StartCause, WindowEvent},
   event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW},
@@ -29,6 +28,7 @@ use crate::{
 };
 
 use super::{
+  global_shortcut::GlobalShortcutEvent,
   keyboard,
   monitor::MonitorHandle,
   window::{WindowId, WindowRequest},
@@ -44,6 +44,8 @@ pub struct EventLoopWindowTarget<T> {
   pub(crate) windows: Rc<RefCell<HashSet<WindowId>>>,
   /// Window requests sender
   pub(crate) window_requests_tx: glib::Sender<(WindowId, WindowRequest)>,
+  /// Global shortcut requests sender
+  pub(crate) shortcut_requests_tx: glib::Sender<GlobalShortcutEvent>,
   _marker: std::marker::PhantomData<T>,
 }
 
@@ -116,13 +118,16 @@ impl<T: 'static> EventLoop<T> {
     // Create event loop window target.
     let (window_requests_tx, window_requests_rx) = glib::MainContext::channel(Priority::default());
     let window_requests_tx_ = window_requests_tx.clone();
+    let (shortcut_requests_tx, shortcut_requests_rx) =
+      glib::MainContext::channel(Priority::default());
     let display = gdk::Display::default()
       .expect("GdkDisplay not found. This usually means `gkt_init` hasn't called yet.");
     let window_target = EventLoopWindowTarget {
       display,
       app,
       windows: Rc::new(RefCell::new(HashSet::new())),
       window_requests_tx,
+      shortcut_requests_tx,
       _marker: std::marker::PhantomData,
     };
 
@@ -136,6 +141,39 @@ impl<T: 'static> EventLoop<T> {
       Continue(true)
     });
 
+    // Global Shortcut Event Request
+    let app = app_.clone();
+    let event_tx_ = event_tx.clone();
+    shortcut_requests_rx.attach(Some(&context), move |event| {
+      match event {
+        GlobalShortcutEvent::Register((id, key)) => {
+          let name = format!("{}", id.0);
+          let action = gio::SimpleAction::new(&name, None);
+          let event_tx = event_tx_.clone();
+          action.connect_activate(move |_, _| {
+            if let Err(e) = event_tx.send(Event::GlobalShortcutEvent(id)) {
+              log::warn!(
+                "Failed to send global shortcut event to event channel: {}",
+                e
+              );
+            }
+          });
+          app.add_action(&action);
+          app.set_accels_for_action(&format!("app.{}", name), &[&key]);
+        }
+        GlobalShortcutEvent::UnRegister(id) => {
+          app.remove_action(&format!("{}", id.0));
+        }
+        GlobalShortcutEvent::UnRegisterAll => {
+          for action in app.list_actions() {
+            app.remove_action(&action);
+          }
+        }
+      }
+
+      Continue(true)
+    });
+
     // Window Request
     window_requests_rx.attach(Some(&context), move |(id, request)| {
       if let Some(window) = app_.window_by_id(id.0) {
@@ -563,9 +601,9 @@ impl<T: 'static> EventLoop<T> {
 
             let tx_clone = event_tx.clone();
             let keyboard_handler = Rc::new(move |event_key: EventKey, element_state| {
-              // if we have a modifier lets send it
               let mut mods = keyboard::get_modifiers(event_key.clone());
-              if !mods.is_empty() {
+              // if we have a modifier lets send it
+              if event_key.is_modifier() {
                 // if we release the modifier tell the world
                 if ElementState::Released == element_state {
                   mods = ModifiersState::empty();
@@ -723,25 +761,16 @@ impl<T: 'static> EventLoop<T> {
               menubar.show_all();
             }
           }
-          WindowRequest::GlobalHotKey(_hotkey_id) => {}
         }
       } else if id == WindowId::dummy() {
-        match request {
-          WindowRequest::GlobalHotKey(hotkey_id) => {
-            if let Err(e) = event_tx.send(Event::GlobalShortcutEvent(AcceleratorId(hotkey_id))) {
-              log::warn!("Failed to send global hotkey event to event channel: {}", e);
-            }
-          }
-          WindowRequest::Menu((None, Some(menu_id))) => {
-            if let Err(e) = event_tx.send(Event::MenuEvent {
-              window_id: None,
-              menu_id,
-              origin: MenuType::ContextMenu,
-            }) {
-              log::warn!("Failed to send status bar event to event channel: {}", e);
-            }
+        if let WindowRequest::Menu((None, Some(menu_id))) = request {
+          if let Err(e) = event_tx.send(Event::MenuEvent {
+            window_id: None,
+            menu_id,
+            origin: MenuType::ContextMenu,
+          }) {
+            log::warn!("Failed to send status bar event to event channel: {}", e);
           }
-          _ => {}
         }
       }
       Continue(true)