fix: adapt to newer virtual_keyboard

Author: Bot-wxt1221

src/input/mod.rs

@@ -7,14 +7,14 @@ use std::time::Duration;
 use calloop::timer::{TimeoutAction, Timer};
 use input::event::gesture::GestureEventCoordinates as _;
 use niri_config::{
-    Action, Bind, Binds, Config, Key, ModKey, Modifiers, MruDirection, SwitchBinds, Trigger, Xkb,
+    Action, Bind, Binds, Config, Key, ModKey, Modifiers, MruDirection, SwitchBinds, Trigger,
 };
 use niri_ipc::LayoutSwitchTarget;
 use smithay::backend::input::{
     AbsolutePositionEvent, Axis, AxisSource, ButtonState, Device, DeviceCapability, Event,
     GestureBeginEvent, GestureEndEvent, GesturePinchUpdateEvent as _, GestureSwipeUpdateEvent as _,
-    InputEvent, KeyState, KeyboardKeyEvent, Keycode, MouseButton, PointerAxisEvent,
-    PointerButtonEvent, PointerMotionEvent, ProximityState, Switch, SwitchState, SwitchToggleEvent,
+    InputEvent, KeyState, KeyboardKeyEvent, MouseButton, PointerAxisEvent, PointerButtonEvent,
+    PointerMotionEvent, ProximityState, Switch, SwitchState, SwitchToggleEvent,
     TabletToolButtonEvent, TabletToolEvent, TabletToolProximityEvent, TabletToolTipEvent,
     TabletToolTipState, TouchEvent,
 };
@@ -48,7 +48,6 @@ use crate::dbus::freedesktop_a11y::KbMonBlock;
 use crate::layout::scrolling::ScrollDirection;
 use crate::layout::{ActivateWindow, LayoutElement as _};
 use crate::niri::{CastTarget, PointerVisibility, State};
-use crate::protocols::virtual_keyboard::VirtualKeyboard;
 use crate::ui::mru::{WindowMru, WindowMruUi};
 use crate::ui::screenshot_ui::ScreenshotUi;
 use crate::utils::spawning::{spawn, spawn_sh};
@@ -368,29 +367,6 @@ impl State {
     ) where
         I::Device: 'static,
     {
-        // Reset the keymap when handling a physical keyboard after a virtual one.
-        if self.niri.reset_keymap {
-            let device = event.device();
-            let is_virtual_keyboard = (&device as &dyn Any)
-                .downcast_ref::<VirtualKeyboard>()
-                .is_some();
-            if !is_virtual_keyboard {
-                self.niri.reset_keymap = false;
-
-                let config = self.niri.config.borrow();
-                let xkb_config = config.input.keyboard.xkb.clone();
-                std::mem::drop(config);
-
-                if xkb_config != Xkb::default() {
-                    self.set_xkb_config(xkb_config.to_xkb_config());
-                } else {
-                    // Use locale1 settings if xkb config is unset.
-                    let xkb = self.niri.xkb_from_locale1.clone().unwrap_or_default();
-                    self.set_xkb_config(xkb.to_xkb_config());
-                }
-            }
-        }
-
         let mod_key = self.backend.mod_key(&self.niri.config.borrow());
 
         let serial = SERIAL_COUNTER.next_serial();
@@ -448,7 +424,6 @@ impl State {
             serial,
             time,
             |this, mods, keysym| {
-                let key_code = event.key_code();
                 let modified = keysym.modified_sym();
                 let raw = keysym.raw_latin_sym_or_raw_current_sym();
                 let modifiers = modifiers_from_state(*mods);
@@ -498,7 +473,7 @@ impl State {
                     }
 
                     // Don't send this press to any clients.
-                    this.niri.suppressed_keys.insert(key_code);
+                    this.niri.suppressed_keys.insert(modified);
                     return FilterResult::Intercept(None);
                 }
 
@@ -507,7 +482,7 @@ impl State {
                 if this.niri.window_mru_ui.is_open() && !pressed && modifiers.is_empty() {
                     this.do_action(Action::MruConfirm, false);
 
-                    if this.niri.suppressed_keys.remove(&key_code) {
+                    if this.niri.suppressed_keys.remove(&modified) {
                         return FilterResult::Intercept(None);
                     } else {
                         return FilterResult::Forward;
@@ -525,7 +500,7 @@ impl State {
                         .get_pointer()
                         .unwrap()
                         .unset_grab(this, serial, time);
-                    this.niri.suppressed_keys.insert(key_code);
+                    this.niri.suppressed_keys.insert(modified);
                     return FilterResult::Intercept(None);
                 }
 
@@ -542,7 +517,6 @@ impl State {
                         &mut this.niri.suppressed_keys,
                         bindings,
                         mod_key,
-                        key_code,
                         modified,
                         raw,
                         pressed,
@@ -558,7 +532,7 @@ impl State {
                     if this.niri.keyboard_focus.is_overview() && pressed {
                         if let Some(bind) = raw.and_then(|raw| hardcoded_overview_bind(raw, *mods))
                         {
-                            this.niri.suppressed_keys.insert(key_code);
+                            this.niri.suppressed_keys.insert(modified);
                             return FilterResult::Intercept(Some(bind));
                         }
                     }
@@ -4329,10 +4303,9 @@ impl State {
 /// to them from being delivered.
 #[allow(clippy::too_many_arguments)]
 fn should_intercept_key<'a>(
-    suppressed_keys: &mut HashSet<Keycode>,
+    suppressed_keys: &mut HashSet<Keysym>,
     bindings: impl IntoIterator<Item = &'a Bind>,
     mod_key: ModKey,
-    key_code: Keycode,
     modified: Keysym,
     raw: Option<Keysym>,
     pressed: bool,
@@ -4344,7 +4317,7 @@ fn should_intercept_key<'a>(
     // Actions are only triggered on presses, release of the key
     // shouldn't try to intercept anything unless we have marked
     // the key to suppress.
-    if !pressed && !suppressed_keys.contains(&key_code) {
+    if !pressed && !suppressed_keys.contains(&modified) {
         return FilterResult::Forward;
     }
 
@@ -4395,7 +4368,7 @@ fn should_intercept_key<'a>(
             if is_inhibiting_shortcuts && bind.allow_inhibiting {
                 FilterResult::Forward
             } else {
-                suppressed_keys.insert(key_code);
+                suppressed_keys.insert(modified);
                 FilterResult::Intercept(Some(bind))
             }
         }
@@ -4405,7 +4378,7 @@ fn should_intercept_key<'a>(
             // But we don't need to check for shortcuts inhibition here, because
             // if it was inhibited on press (forwarded to the client), it wouldn't be suppressed,
             // so the release would already have been forwarded at the start of this function.
-            suppressed_keys.remove(&key_code);
+            suppressed_keys.remove(&modified);
             FilterResult::Intercept(None)
         }
         (None, true) => FilterResult::Forward,
@@ -4466,7 +4439,6 @@ fn find_configured_bind<'a>(
 ) -> Option<Bind> {
     // Handle configured binds.
     let mut modifiers = modifiers_from_state(mods);
-
     let mod_down = modifiers_from_state(mods).contains(mod_key.to_modifiers());
     if mod_down {
         modifiers |= Modifiers::COMPOSITOR;
@@ -5115,13 +5087,11 @@ mod tests {
         // The key_code we pick is arbitrary, the only thing
         // that matters is that they are different between cases.
 
-        let close_key_code = Keycode::from(close_keysym.raw() + 8u32);
-        let close_key_event = |suppr: &mut HashSet<Keycode>, mods: ModifiersState, pressed| {
+        let close_key_event = |suppr: &mut HashSet<Keysym>, mods: ModifiersState, pressed| {
             should_intercept_key(
                 suppr,
                 &bindings.0,
                 comp_mod,
-                close_key_code,
                 close_keysym,
                 Some(close_keysym),
                 pressed,
@@ -5133,12 +5103,11 @@ mod tests {
         };
 
         // Key event with the code which can't trigger any action.
-        let none_key_event = |suppr: &mut HashSet<Keycode>, mods: ModifiersState, pressed| {
+        let none_key_event = |suppr: &mut HashSet<Keysym>, mods: ModifiersState, pressed| {
             should_intercept_key(
                 suppr,
                 &bindings.0,
                 comp_mod,
-                Keycode::from(Keysym::l.raw() + 8),
                 Keysym::l,
                 Some(Keysym::l),
                 pressed,
@@ -5165,7 +5134,7 @@ mod tests {
                 ..
             }))
         ));
-        assert!(suppressed_keys.contains(&close_key_code));
+        assert!(suppressed_keys.contains(&close_keysym));
 
         let filter = close_key_event(&mut suppressed_keys, mods, false);
         assert!(matches!(filter, FilterResult::Intercept(None)));
@@ -5266,7 +5235,7 @@ mod tests {
                 ..
             }))
         ));
-        assert!(suppressed_keys.contains(&close_key_code));
+        assert!(suppressed_keys.contains(&close_keysym));
 
         is_inhibiting_shortcuts.set(true);
 

src/niri.rs

@@ -19,7 +19,6 @@ use niri_config::{
     WorkspaceReference, Xkb,
 };
 use smithay::backend::allocator::Fourcc;
-use smithay::backend::input::Keycode;
 use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
@@ -44,7 +43,7 @@ use smithay::desktop::{
     find_popup_root_surface, layer_map_for_output, LayerMap, LayerSurface, PopupGrab, PopupManager,
     PopupUngrabStrategy, Space, Window, WindowSurfaceType,
 };
-use smithay::input::keyboard::{Layout as KeyboardLayout, XkbConfig};
+use smithay::input::keyboard::{Keysym, Layout as KeyboardLayout, XkbConfig};
 use smithay::input::pointer::{
     CursorIcon, CursorImageStatus, CursorImageSurfaceData, Focus,
     GrabStartData as PointerGrabStartData, MotionEvent,
@@ -317,7 +316,7 @@ pub struct Niri {
 
     pub seat: Seat<State>,
     /// Scancodes of the keys to suppress.
-    pub suppressed_keys: HashSet<Keycode>,
+    pub suppressed_keys: HashSet<Keysym>,
     /// Button codes of the mouse buttons to suppress.
     pub suppressed_buttons: HashSet<u32>,
     pub bind_cooldown_timers: HashMap<Key, RegistrationToken>,
@@ -331,11 +330,6 @@ pub struct Niri {
     /// Most recent XKB settings from org.freedesktop.locale1.
     pub xkb_from_locale1: Option<Xkb>,
 
-    /// Whether to reset the keymap on the next physical keyboard event.
-    ///
-    /// Set to true when handling virtual keyboard events which override the keymap.
-    pub reset_keymap: bool,
-
     pub cursor_manager: CursorManager,
     pub cursor_texture_cache: CursorTextureCache,
     pub cursor_shape_manager_state: CursorShapeManagerState,
@@ -2510,7 +2504,6 @@ impl Niri {
             is_fdo_idle_inhibited: Arc::new(AtomicBool::new(false)),
             keyboard_shortcuts_inhibiting_surfaces: HashMap::new(),
             xkb_from_locale1: None,
-            reset_keymap: false,
             cursor_manager,
             cursor_texture_cache: Default::default(),
             cursor_shape_manager_state,

src/protocols/virtual_keyboard.rs

@@ -107,10 +107,6 @@ impl VirtualKeyboardHandler for State {
         time: u32,
         _keyboard: KeyboardHandle<Self>,
     ) {
-        // The virtual keyboard impl in Smithay changes the keymap, so we'll need to reset it on
-        // the next real keyboard event.
-        self.niri.reset_keymap = true;
-
         let event = VirtualKeyboardKeyEvent {
             keycode,
             state,