keyboard: Update to xkbcommon 0.8

Cargo.lock

@@ -474,9 +474,9 @@ dependencies = [
 
 [[package]]
 name = "memmap2"
-version = "0.7.1"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f49388d20533534cd19360ad3d6a7dadc885944aa802ba3995040c5ec11288c6"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
 dependencies = [
  "libc",
 ]
@@ -1307,14 +1307,21 @@ dependencies = [
 
 [[package]]
 name = "xkbcommon"
-version = "0.5.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52db25b599e92bf6e3904134618728eeb7b49a5a4f38f107f92399bb9c496b88"
+checksum = "8d66ca9352cbd4eecbbc40871d8a11b4ac8107cfc528a6e14d7c19c69d0e1ac9"
 dependencies = [
  "libc",
  "memmap2",
+ "xkeysym",
 ]
 
+[[package]]
+name = "xkeysym"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
+
 [[package]]
 name = "yeslogic-fontconfig-sys"
 version = "5.0.0"

Cargo.toml

@@ -26,7 +26,7 @@ unicode-segmentation = "1.10"
 fuzzy-matcher = "0.3"
 shlex = "1.3"
 
-xkbcommon = { version = "0.5", features = ["wayland"] } # update breaks
+xkbcommon = { version = "0.8", features = ["wayland"] }
 
 rcalc_lib = "1.0"
 

src/keyboard/mod.rs

@@ -39,23 +39,40 @@ pub struct KeyEvent {
     pub repeats: bool,
 }
 
+pub struct KeymapDescription {
+    fd: OwnedFd,
+    size: u32,
+}
+
+impl KeymapDescription {
+    fn new(fd: OwnedFd, size: u32) -> KeymapDescription {
+        KeymapDescription { fd: fd, size: size }
+    }
+}
+
+impl Clone for KeymapDescription {
+    fn clone(&self) -> Self {
+        KeymapDescription::new(self.fd.try_clone().expect("unable to clone fd"), self.size)
+    }
+}
+
 pub struct Keyboard {
     state: Option<KbState>,
-    fd: Option<(OwnedFd, u32)>,
+    desc: Option<KeymapDescription>,
 }
 
 impl Keyboard {
     pub fn new() -> Keyboard {
         Keyboard {
             state: None,
-            fd: None,
+            desc: None,
         }
     }
 
     pub fn keymap(&mut self, format: WEnum<wl_keyboard::KeymapFormat>, fd: OwnedFd, size: u32) {
         match format {
             WEnum::Value(wl_keyboard::KeymapFormat::XkbV1) => {
-                self.fd = Some((fd, size));
+                self.desc = Some(KeymapDescription::new(fd, size));
             }
             WEnum::Value(wl_keyboard::KeymapFormat::NoKeymap) => {
                 // TODO: how to handle this (hopefully never occuring) case?
@@ -69,10 +86,9 @@ impl Keyboard {
             return;
         }
 
-        if let Some((fd, size)) = &self.fd {
+        if let Some(desc) = self.desc.take() {
             self.state = Some(
-                KbState::new_from_fd(fd.as_raw_fd(), *size as usize)
+                KbState::new_from_fd(desc.fd, desc.size as usize).expect("unable to load keymap"),
-                    .expect("unable to load keymap"),
             );
         }
     }
@@ -107,7 +123,7 @@ impl Keyboard {
                 } else {
                     None
                 };
-                let repeats = state.key_repeats(key + 8);
+                let repeats = state.key_repeats(xkb::Keycode::new(key + 8));
                 (sym, utf8, repeats)
             };
             KeyEvent {

src/keyboard/state.rs

@@ -1,4 +1,4 @@
-use std::{env, os::unix::io::RawFd};
+use std::{env, os::unix::io::OwnedFd};
 
 use xkbcommon::xkb;
 
@@ -71,16 +71,18 @@ impl KbState {
     }
 
     pub(crate) fn get_one_sym_raw(&mut self, keycode: u32) -> u32 {
-        self.xkb_state.key_get_one_sym(keycode + 8)
+        self.xkb_state
+            .key_get_one_sym(xkb::Keycode::new(keycode + 8))
+            .raw()
     }
 
     pub(crate) fn get_utf8_raw(&mut self, keycode: u32) -> Option<String> {
-        Some(self.xkb_state.key_get_utf8(keycode + 8))
+        Some(self.xkb_state.key_get_utf8(xkb::Keycode::new(keycode + 8)))
     }
 
     pub(crate) fn compose_feed(&mut self, keysym: u32) -> Option<xkb::compose::FeedResult> {
         match &mut self.xkb_compose_state {
-            Some(compose_state) => Some(compose_state.feed(keysym)),
+            Some(compose_state) => Some(compose_state.feed(xkb::Keysym::new(keysym))),
             None => None,
         }
     }
@@ -99,7 +101,7 @@ impl KbState {
         }
     }
 
-    pub(crate) fn new_from_fd(fd: RawFd, size: usize) -> Result<KbState, std::io::Error> {
+    pub(crate) fn new_from_fd(fd: OwnedFd, size: usize) -> Result<KbState, std::io::Error> {
         let xkb_context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
         let xkb_keymap = unsafe {
             xkb::Keymap::new_from_fd(