Use the user's keyboard layout from the x11 system

This change uses xkbcommon to decode the key utf8 value based
on the user's current layout. The implementation is adapted from
the x11rb's xkbcommon-example.

Author: TristanCacqueray

Cargo.toml

@@ -24,6 +24,7 @@ raw-window-handle = "0.5"
 
 [target.'cfg(target_os="linux")'.dependencies]
 x11rb = { version = "0.13.0", features = ["cursor", "resource_manager", "allow-unsafe-code"] }
+xkbcommon = { version = "0.7", features = ["x11"]}
 x11 = { version = "2.21", features = ["xlib", "xlib_xcb"] }
 nix = "0.22.0"
 

src/x11/event_loop.rs

@@ -9,6 +9,7 @@ use std::os::fd::AsRawFd;
 use std::time::{Duration, Instant};
 use x11rb::connection::Connection;
 use x11rb::protocol::Event as XEvent;
+use xkbcommon::xkb as xkbc;
 
 pub(super) struct EventLoop {
     handler: Box<dyn WindowHandler>,
@@ -18,20 +19,36 @@ pub(super) struct EventLoop {
     new_physical_size: Option<PhySize>,
     frame_interval: Duration,
     event_loop_running: bool,
+    xkb_state: xkbc::State,
 }
 
 impl EventLoop {
     pub fn new(
         window: WindowInner, handler: impl WindowHandler + 'static,
         parent_handle: Option<ParentHandle>,
     ) -> Self {
+        // Setup the xkb state
+        let xkb_state = {
+            let context = xkbc::Context::new(xkbc::CONTEXT_NO_FLAGS);
+            let conn = &window.xcb_connection.conn;
+            let device_id = xkbc::x11::get_core_keyboard_device_id(conn);
+            assert!(device_id >= 0);
+            let keymap = xkbc::x11::keymap_new_from_device(
+                &context,
+                conn,
+                device_id,
+                xkbc::KEYMAP_COMPILE_NO_FLAGS,
+            );
+            xkbc::x11::state_new_from_device(&keymap, &conn, device_id)
+        };
         Self {
             window,
             handler: Box::new(handler),
             parent_handle,
             frame_interval: Duration::from_millis(15),
             event_loop_running: false,
             new_physical_size: None,
+            xkb_state,
         }
     }
 
@@ -261,14 +278,14 @@ impl EventLoop {
             XEvent::KeyPress(event) => {
                 self.handler.on_event(
                     &mut crate::Window::new(Window { inner: &self.window }),
-                    Event::Keyboard(convert_key_press_event(&event)),
+                    Event::Keyboard(convert_key_press_event(&event, &mut self.xkb_state)),
                 );
             }
 
             XEvent::KeyRelease(event) => {
                 self.handler.on_event(
                     &mut crate::Window::new(Window { inner: &self.window }),
-                    Event::Keyboard(convert_key_release_event(&event)),
+                    Event::Keyboard(convert_key_release_event(&event, &mut self.xkb_state)),
                 );
             }
 

src/x11/keyboard.rs

@@ -19,16 +19,14 @@
 //! X11 keyboard handling
 
 use x11rb::protocol::xproto::{KeyButMask, KeyPressEvent, KeyReleaseEvent};
+use xkbcommon::xkb as xkbc;
 
 use keyboard_types::*;
 
 use crate::keyboard::code_to_location;
 
 /// Convert a hardware scan code to a key.
-///
-/// Note: this is a hardcoded layout. We need to detect the user's
-/// layout from the system and apply it.
-fn code_to_key(code: Code, m: Modifiers) -> Key {
+fn code_to_key(code: Code, m: Modifiers, hw_code: xkbc::Keycode, xkb_state: &xkbc::State) -> Key {
     fn a(s: &str) -> Key {
         Key::Character(s.into())
     }
@@ -39,6 +37,7 @@ fn code_to_key(code: Code, m: Modifiers) -> Key {
             Key::Character(base.into())
         }
     }
+    let k = || Key::Character(xkb_state.key_get_utf8(hw_code));
     fn n(mods: Modifiers, base: Key, num: &str) -> Key {
         if mods.contains(Modifiers::NUM_LOCK) != mods.contains(Modifiers::SHIFT) {
             Key::Character(num.into())
@@ -47,55 +46,55 @@ fn code_to_key(code: Code, m: Modifiers) -> Key {
         }
     }
     match code {
-        Code::KeyA => s(m, "a", "A"),
-        Code::KeyB => s(m, "b", "B"),
-        Code::KeyC => s(m, "c", "C"),
-        Code::KeyD => s(m, "d", "D"),
-        Code::KeyE => s(m, "e", "E"),
-        Code::KeyF => s(m, "f", "F"),
-        Code::KeyG => s(m, "g", "G"),
-        Code::KeyH => s(m, "h", "H"),
-        Code::KeyI => s(m, "i", "I"),
-        Code::KeyJ => s(m, "j", "J"),
-        Code::KeyK => s(m, "k", "K"),
-        Code::KeyL => s(m, "l", "L"),
-        Code::KeyM => s(m, "m", "M"),
-        Code::KeyN => s(m, "n", "N"),
-        Code::KeyO => s(m, "o", "O"),
-        Code::KeyP => s(m, "p", "P"),
-        Code::KeyQ => s(m, "q", "Q"),
-        Code::KeyR => s(m, "r", "R"),
-        Code::KeyS => s(m, "s", "S"),
-        Code::KeyT => s(m, "t", "T"),
-        Code::KeyU => s(m, "u", "U"),
-        Code::KeyV => s(m, "v", "V"),
-        Code::KeyW => s(m, "w", "W"),
-        Code::KeyX => s(m, "x", "X"),
-        Code::KeyY => s(m, "y", "Y"),
-        Code::KeyZ => s(m, "z", "Z"),
+        Code::KeyA => k(),
+        Code::KeyB => k(),
+        Code::KeyC => k(),
+        Code::KeyD => k(),
+        Code::KeyE => k(),
+        Code::KeyF => k(),
+        Code::KeyG => k(),
+        Code::KeyH => k(),
+        Code::KeyI => k(),
+        Code::KeyJ => k(),
+        Code::KeyK => k(),
+        Code::KeyL => k(),
+        Code::KeyM => k(),
+        Code::KeyN => k(),
+        Code::KeyO => k(),
+        Code::KeyP => k(),
+        Code::KeyQ => k(),
+        Code::KeyR => k(),
+        Code::KeyS => k(),
+        Code::KeyT => k(),
+        Code::KeyU => k(),
+        Code::KeyV => k(),
+        Code::KeyW => k(),
+        Code::KeyX => k(),
+        Code::KeyY => k(),
+        Code::KeyZ => k(),
 
-        Code::Digit0 => s(m, "0", ")"),
-        Code::Digit1 => s(m, "1", "!"),
-        Code::Digit2 => s(m, "2", "@"),
-        Code::Digit3 => s(m, "3", "#"),
-        Code::Digit4 => s(m, "4", "$"),
-        Code::Digit5 => s(m, "5", "%"),
-        Code::Digit6 => s(m, "6", "^"),
-        Code::Digit7 => s(m, "7", "&"),
-        Code::Digit8 => s(m, "8", "*"),
-        Code::Digit9 => s(m, "9", "("),
+        Code::Digit0 => k(),
+        Code::Digit1 => k(),
+        Code::Digit2 => k(),
+        Code::Digit3 => k(),
+        Code::Digit4 => k(),
+        Code::Digit5 => k(),
+        Code::Digit6 => k(),
+        Code::Digit7 => k(),
+        Code::Digit8 => k(),
+        Code::Digit9 => k(),
 
-        Code::Backquote => s(m, "`", "~"),
-        Code::Minus => s(m, "-", "_"),
-        Code::Equal => s(m, "=", "+"),
-        Code::BracketLeft => s(m, "[", "{"),
-        Code::BracketRight => s(m, "]", "}"),
-        Code::Backslash => s(m, "\\", "|"),
-        Code::Semicolon => s(m, ";", ":"),
-        Code::Quote => s(m, "'", "\""),
-        Code::Comma => s(m, ",", "<"),
-        Code::Period => s(m, ".", ">"),
-        Code::Slash => s(m, "/", "?"),
+        Code::Backquote => k(),
+        Code::Minus => k(),
+        Code::Equal => k(),
+        Code::BracketLeft => k(),
+        Code::BracketRight => k(),
+        Code::Backslash => k(),
+        Code::Semicolon => k(),
+        Code::Quote => k(),
+        Code::Comma => k(),
+        Code::Period => k(),
+        Code::Slash => k(),
 
         Code::Space => a(" "),
 
@@ -383,22 +382,36 @@ pub(super) fn key_mods(mods: KeyButMask) -> Modifiers {
     ret
 }
 
-pub(super) fn convert_key_press_event(key_press: &KeyPressEvent) -> KeyboardEvent {
+pub(super) fn convert_key_press_event(
+    key_press: &KeyPressEvent, state: &mut xkbc::State,
+) -> KeyboardEvent {
     let hw_keycode = key_press.detail;
+
+    // Update the xkbc state
+    let hw_code = hw_keycode.into();
+    state.update_key(hw_code, xkbc::KeyDirection::Down);
+
     let code = hardware_keycode_to_code(hw_keycode.into());
     let modifiers = key_mods(key_press.state);
-    let key = code_to_key(code, modifiers);
+    let key = code_to_key(code, modifiers, hw_code, state);
     let location = code_to_location(code);
     let state = KeyState::Down;
 
     KeyboardEvent { code, key, modifiers, location, state, repeat: false, is_composing: false }
 }
 
-pub(super) fn convert_key_release_event(key_release: &KeyReleaseEvent) -> KeyboardEvent {
+pub(super) fn convert_key_release_event(
+    key_release: &KeyReleaseEvent, state: &mut xkbc::State,
+) -> KeyboardEvent {
     let hw_keycode = key_release.detail;
+
+    // Update the xkbc state
+    let hw_code = hw_keycode.into();
+    state.update_key(hw_code, xkbc::KeyDirection::Up);
+
     let code = hardware_keycode_to_code(hw_keycode.into());
     let modifiers = key_mods(key_release.state);
-    let key = code_to_key(code, modifiers);
+    let key = code_to_key(code, modifiers, hw_code, state);
     let location = code_to_location(code);
     let state = KeyState::Up;