feat: allow handle virtual keyboard input by WM

Author: Bot-wxt1221

Cargo.toml

@@ -110,6 +110,7 @@ wayland_frontend = ["wayland-server", "wayland-protocols", "wayland-protocols-wl
 x11rb_event_source = ["x11rb"]
 xwayland = ["encoding_rs", "wayland_frontend", "x11rb/composite", "x11rb/xfixes", "x11rb/randr", "x11rb_event_source", "scopeguard"]
 test_all_features = ["default", "use_system_lib", "renderer_glow", "renderer_test"]
+virtual_keyboard_not_use_default_handler = [ ]
 
 [[example]]
 name = "minimal"

src/wayland/virtual_keyboard/mod.rs

@@ -57,9 +57,9 @@ use wayland_protocols_misc::zwp_virtual_keyboard_v1::server::{
 };
 use wayland_server::{backend::GlobalId, Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New};
 
-use crate::input::{Seat, SeatHandler};
-
 use self::virtual_keyboard_handle::VirtualKeyboardHandle;
+use crate::backend::input::{KeyState, Keycode};
+use crate::input::{Seat, SeatHandler};
 
 const MANAGER_VERSION: u32 = 1;
 
@@ -91,6 +91,10 @@ where
     display.create_global::<D, ZwpVirtualKeyboardManagerV1, _>(MANAGER_VERSION, data)
 }
 
+pub trait VirtualKeyboardHandler {
+    fn process_wm(&mut self, keycode: Keycode, state: KeyState, time: u32) -> bool;
+}
+
 impl VirtualKeyboardManagerState {
     /// Initialize a virtual keyboard manager global.
     pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self

src/wayland/virtual_keyboard/virtual_keyboard_handle.rs

@@ -10,9 +10,8 @@ use wayland_protocols_misc::zwp_virtual_keyboard_v1::server::zwp_virtual_keyboar
     self, ZwpVirtualKeyboardV1,
 };
 use wayland_server::{
-    backend::ClientId,
-    protocol::wl_keyboard::{KeyState, KeymapFormat},
-    Client, DataInit, Dispatch, DisplayHandle, Resource,
+    backend::ClientId, protocol::wl_keyboard::KeymapFormat, Client, DataInit, Dispatch, DisplayHandle,
+    Resource,
 };
 use xkbcommon::xkb;
 
@@ -23,7 +22,9 @@ use crate::{
     wayland::seat::{keyboard::for_each_focused_kbds, WaylandFocus},
 };
 
-use super::VirtualKeyboardManagerState;
+use crate::backend::input::{KeyState, Keycode};
+
+use super::{VirtualKeyboardHandler, VirtualKeyboardManagerState};
 
 #[derive(Debug, Default)]
 pub(crate) struct VirtualKeyboard {
@@ -71,10 +72,18 @@ impl<D: SeatHandler> fmt::Debug for VirtualKeyboardUserData<D> {
     }
 }
 
+#[cfg(not(feature = "virtual_keyboard_not_use_default_handler"))]
+impl<T: SeatHandler + 'static> VirtualKeyboardHandler for T {
+    fn process_wm(&mut self, keycode: Keycode, state: KeyState, time: u32) -> bool {
+        true
+    }
+}
+
 impl<D> Dispatch<ZwpVirtualKeyboardV1, VirtualKeyboardUserData<D>, D> for VirtualKeyboardManagerState
 where
     D: Dispatch<ZwpVirtualKeyboardV1, VirtualKeyboardUserData<D>>,
     D: SeatHandler + 'static,
+    D: VirtualKeyboardHandler,
     <D as SeatHandler>::KeyboardFocus: WaylandFocus,
 {
     fn request(
@@ -100,25 +109,30 @@ where
                         return;
                     }
                 };
-
                 // Ensure virtual keyboard's keymap is active.
                 let keyboard_handle = data.seat.get_keyboard().unwrap();
                 let mut internal = keyboard_handle.arc.internal.lock().unwrap();
                 let focus = internal.focus.as_mut().map(|(focus, _)| focus);
                 keyboard_handle.send_keymap(user_data, &focus, &vk_state.keymap, vk_state.mods);
-
-                if let Some(wl_surface) = focus.and_then(|f| f.wl_surface()) {
-                    for_each_focused_kbds(&data.seat, &wl_surface, |kbd| {
-                        // This should be wl_keyboard::KeyState, but the protocol does not state
-                        // the parameter is an enum.
-                        let key_state = if state == 1 {
-                            KeyState::Pressed
-                        } else {
-                            KeyState::Released
-                        };
-
-                        kbd.key(SERIAL_COUNTER.next_serial().0, time, key, key_state);
-                    });
+                let keystate = if state == 1 {
+                    KeyState::Pressed
+                } else {
+                    KeyState::Released
+                };
+                if user_data.process_wm((key + 8).into(), keystate, time) {
+                    if let Some(wl_surface) = focus.and_then(|f| f.wl_surface()) {
+                        for_each_focused_kbds(&data.seat, &wl_surface, |kbd| {
+                            // This should be wl_keyboard::KeyState, but the protocol does not state
+                            // the parameter is an enum.
+                            use wayland_server::protocol::wl_keyboard::KeyState;
+                            let key_state = if state == 1 {
+                                KeyState::Pressed
+                            } else {
+                                KeyState::Released
+                            };
+                            kbd.key(SERIAL_COUNTER.next_serial().0, time, key, key_state);
+                        });
+                    }
                 }
             }
             zwp_virtual_keyboard_v1::Request::Modifiers {