1 files changed, 142 insertions, 65 deletions

diff --git a/src/keys.rs b/src/keys.rs
index 08dd056..7e3296f 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -1,66 +1,65 @@
 use crate::{error::*, WM};
-use xcb::x::{
-    GetKeyboardMapping, GetModifierMapping, GrabKey, GrabMode, KeyPressEvent, Keycode, Keysym,
-    Mapping, MappingNotifyEvent, ModMask, UngrabKey, GRAB_ANY,
+use xcb::{
+    x::{
+        GetKeyboardMapping, GetKeyboardMappingReply, GetModifierMapping, GrabKey, GrabMode,
+        KeyPressEvent, Mapping, MappingNotifyEvent, ModMask, UngrabKey, GRAB_ANY,
+    },
+    Connection,
 };
-
-// https://github.com/D-Programming-Deimos/libX11/blob/master/c/X11/keysymdef.h
-const KEYSYM_NUMLOCK: Keysym = 0xff7f;
+use xkeysym::{KeyCode, Keysym, RawKeyCode};
 
 impl WM<'_> {
+    /// Handles a key press event by dispatching according to [`self::KEYBINDS`]
     pub(crate) fn handle_key_press(&mut self, e: KeyPressEvent) -> Result<()> {
-        dbg!(e);
+        let Some(sym) = self.keyboard_state.keycode_to_keysym(e.detail().into(), 0) else {
+            return Ok(()); // probably not bound
+        };
+
+        KEYBINDS.dispatch(
+            sym,
+            ModMask::from_bits_truncate(e.state().bits())
+                .difference(self.keyboard_state.numlock_mask() | ModMask::LOCK),
+        );
 
         Ok(())
     }
 
+    /// Handles a mapping notify event by updating our keyboard setup if needed.
     pub(crate) fn handle_mapping_notify(&mut self, e: MappingNotifyEvent) -> Result<()> {
         if e.request() == Mapping::Keyboard {
-            self.grabkeys()?;
+            self.grab_keys()?;
         }
 
         Ok(())
     }
 
-    pub(crate) fn grabkeys(&self) -> Result<()> {
-        let numlock_mask = self.get_numlock_mask()?;
+    /// Grab all keys specified by [`self::KEYBINDS`], ensuring we get events for them.
+    pub(crate) fn grab_keys(&mut self) -> Result<()> {
+        // Refresh keyboard state
+        self.keyboard_state = KeyboardState::new_with(&self.conn)?;
 
-        // ungrab all keys
+        // Ungrab all keys
         self.conn.send_request(&UngrabKey {
             key: GRAB_ANY,
             grab_window: self.root,
             modifiers: ModMask::ANY,
         });
 
-        // go through keymap and grab what we need
-        let (min_keycode, max_keycode) = (
-            self.conn.get_setup().min_keycode(),
-            self.conn.get_setup().max_keycode(),
-        );
-        let mapping = self
-            .conn
-            .wait_for_reply(self.conn.send_request(&GetKeyboardMapping {
-                first_keycode: min_keycode,
-                count: max_keycode - min_keycode + 1,
-            }))?;
-
-        for shift in 0..mapping.keysyms_per_keycode() {
-            for keycode in min_keycode..max_keycode {
-                let keysym = mapping.keysyms()
-                    [(shift as usize * mapping.keysyms_per_keycode() as usize + keycode as usize)];
-                if true {
-                    // todo: is bound
+        // Bind all of the keycodes which have keysyms we see in our binds.
+        for (keycode, keysym) in self.keyboard_state.iter_keycodes_keysyms() {
+            for bind in KEYBINDS.binds() {
+                if bind.key == keysym {
                     // grab key with any combination of modifiers
                     for modmask in [
                         ModMask::empty(),
                         ModMask::LOCK,
-                        numlock_mask,
-                        numlock_mask | ModMask::LOCK,
+                        self.keyboard_state.numlock_mask(),
+                        self.keyboard_state.numlock_mask() | ModMask::LOCK,
                     ] {
                         self.conn.send_request(&GrabKey {
                             grab_window: self.root,
-                            key: keycode,
-                            modifiers: modmask,
+                            key: keycode.raw() as u8,
+                            modifiers: bind.modifiers | modmask,
                             owner_events: true,
                             pointer_mode: GrabMode::Async,
                             keyboard_mode: GrabMode::Async,
@@ -70,56 +69,134 @@ impl WM<'_> {
             }
         }
 
-        // ensure all requests succeeded
+        // Ensure all requests succeeded
         self.conn.flush()?;
 
         Ok(())
     }
+}
 
-    pub(crate) fn get_numlock_mask(&self) -> Result<ModMask> {
-        let map = self
-            .conn
-            .wait_for_reply(self.conn.send_request(&GetModifierMapping {}))?;
-        let numlock_keycode = self.keysym_to_keycode(KEYSYM_NUMLOCK)?;
+/// Cached information about our keyboard layout.
+pub struct KeyboardState {
+    min_keycode: RawKeyCode,
+    max_keycode: RawKeyCode,
+    numlock_mask: ModMask,
+    mapping: GetKeyboardMappingReply,
+}
 
-        let keypermod = map.keycodes().len() / 8;
+impl KeyboardState {
+    /// Query information about the keyboard layout from the given connection.
+    pub fn new_with(conn: &Connection) -> Result<Self> {
+        let min_keycode = conn.get_setup().min_keycode();
+        let max_keycode = conn.get_setup().max_keycode();
+
+        let mapping = conn.wait_for_reply(conn.send_request(&GetKeyboardMapping {
+            first_keycode: min_keycode,
+            count: max_keycode - min_keycode + 1,
+        }))?;
+
+        let mut this = Self {
+            min_keycode: min_keycode as u32,
+            max_keycode: max_keycode as u32,
+            numlock_mask: ModMask::empty(),
+            mapping,
+        };
+
+        let numlock_keycode = this.keysym_to_keycode(Keysym::Num_Lock)?;
+        let mod_map = conn.wait_for_reply(conn.send_request(&GetModifierMapping {}))?;
+        let keypermod = mod_map.keycodes().len() / 8;
         for i in 0..8 {
             for j in 0..keypermod {
-                if map.keycodes()[(i * keypermod + j) as usize] == numlock_keycode {
-                    return Ok(ModMask::from_bits(1 << i).expect("x11 has unrecognised modifier"));
+                if mod_map.keycodes()[(i * keypermod + j) as usize] as u32 == numlock_keycode.raw()
+                {
+                    this.numlock_mask =
+                        ModMask::from_bits(1 << i).expect("x11 has unrecognised modifier");
                 }
             }
         }
 
-        // todo: is this ok?
-        return Ok(ModMask::empty());
+        Ok(this)
     }
 
-    pub(crate) fn keysym_to_keycode(&self, keysym: Keysym) -> Result<Keycode> {
-        let (min_keycode, max_keycode) = (
-            self.conn.get_setup().min_keycode(),
-            self.conn.get_setup().max_keycode(),
-        );
-        let mapping = self
-            .conn
-            .wait_for_reply(self.conn.send_request(&GetKeyboardMapping {
-                first_keycode: min_keycode,
-                count: max_keycode - min_keycode + 1,
-            }))?;
-
-        // todo: apparently there's an optimisation here https://github.com/ArcherPergande/xcbkeys/blob/main/xcbkeys.h
-        for shift in 0..mapping.keysyms_per_keycode() {
-            for keycode in min_keycode..max_keycode {
-                if mapping.keysyms()
-                    [keycode as usize * mapping.keysyms_per_keycode() as usize + shift as usize]
-                    == keysym
+    /// Get the modifier mask being used for numlock, which varies.
+    pub fn numlock_mask(&self) -> ModMask {
+        self.numlock_mask
+    }
+
+    /// Iterate over all keycodes and their bound keysyms.
+    /// This is likely to contain duplicate pairs.
+    pub(crate) fn iter_keycodes_keysyms(&self) -> impl Iterator<Item = (KeyCode, Keysym)> + '_ {
+        (0..self.mapping.keysyms_per_keycode())
+            .flat_map(|shift| {
+                (self.min_keycode..self.max_keycode).map(move |keycode| (shift, keycode))
+            })
+            .flat_map(|(shift, keycode)| -> Option<_> {
+                Some((
+                    keycode.into(),
+                    self.keycode_to_keysym(keycode.into(), shift)?,
+                ))
+            })
+    }
+
+    /// Lookup the first keycode which has the given keysym
+    pub(crate) fn keysym_to_keycode(&self, keysym: Keysym) -> Result<KeyCode> {
+        for shift in 0..self.mapping.keysyms_per_keycode() {
+            for keycode in self.min_keycode..self.max_keycode {
+                if self.mapping.keysyms()[(keycode as usize - self.min_keycode as usize)
+                    * self.mapping.keysyms_per_keycode() as usize
+                    + shift as usize]
+                    == keysym.raw()
                 {
-                    return Ok(keycode);
+                    return Ok(keycode.into());
                 }
             }
         }
 
-        // todo: is this right?
-        return Ok(0);
+        return Ok(KeyCode::new(0));
+    }
+
+    /// Lookup the keysym in the given column for the given keycode
+    pub fn keycode_to_keysym(&self, keycode: KeyCode, col: u8) -> Option<Keysym> {
+        xkeysym::keysym(
+            keycode,
+            col,
+            self.min_keycode.into(),
+            self.mapping.keysyms_per_keycode(),
+            self.mapping.keysyms(),
+        )
+    }
+}
+
+/// A bound key
+#[derive(Debug)]
+pub struct Keybind {
+    modifiers: ModMask,
+    key: Keysym,
+    // TODO: add action
+}
+
+/// A set of keybinds. Currently, there is only one instance of this defined statically: [`self::KEYBINDS`].
+pub struct Keybinds(&'static [Keybind]);
+
+/// The keybinds to use.
+const KEYBINDS: Keybinds = Keybinds(&[Keybind {
+    modifiers: ModMask::CONTROL,
+    key: Keysym::a,
+}]);
+
+impl Keybinds {
+    /// Get an iterator over all bound keys
+    pub fn binds(&self) -> impl Iterator<Item = &Keybind> {
+        self.0.iter()
+    }
+
+    /// Attempt to run the action for the matching keybind, if it exists.
+    pub fn dispatch(&self, key: Keysym, modifiers: ModMask) {
+        if let Some(bind) = self
+            .binds()
+            .find(|b| b.key == key && modifiers.contains(b.modifiers))
+        {
+            dbg!(bind); // TODO: run the bind
+        }
     }
 }