smart_keymap_core/key/
callback.rs

1use core::fmt::Debug;
2use core::marker::PhantomData;
3use core::ops::Index;
4
5use serde::Deserialize;
6
7use crate::key;
8
9use crate::keymap::KeymapCallback;
10
11/// Reference for a keymap callback key.
12#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
13pub struct Ref(pub u8);
14
15/// A key for keymap callbacks.
16#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
17pub struct Key {
18    /// The keymap callback
19    pub keymap_callback: KeymapCallback,
20}
21
22impl Key {
23    /// Constructs a key with the given key_code.
24    pub const fn new(keymap_callback: KeymapCallback) -> Self {
25        Key { keymap_callback }
26    }
27}
28
29/// The context type for keymap callback keys. (No events).
30#[derive(Debug, Clone, Copy, PartialEq)]
31pub struct Context;
32
33impl Context {
34    /// No runtime state to clear.
35    pub fn reset(&mut self) {}
36}
37
38/// The event type for keymap callback keys. (No events).
39#[derive(Debug, Clone, Copy, PartialEq)]
40pub struct Event;
41
42/// The pending key state type for keymap callback keys. (No pending state).
43#[derive(Debug, Clone, Copy, PartialEq)]
44pub struct PendingKeyState;
45
46/// Key state used by [System]. (No state).
47#[derive(Debug, Clone, Copy, PartialEq)]
48pub struct KeyState;
49
50/// The [key::System] implementation for keymap callback keys.
51#[derive(Debug, Clone, Copy, PartialEq)]
52pub struct System<R, Keys: Index<usize, Output = Key>> {
53    keys: Keys,
54    marker: PhantomData<R>,
55}
56
57impl<R, Keys: Index<usize, Output = Key>> System<R, Keys> {
58    /// Constructs a new [System] with the given key data.
59    ///
60    /// The key data is for keys with both key codes and modifiers.
61    pub const fn new(keys: Keys) -> Self {
62        Self {
63            keys,
64            marker: PhantomData,
65        }
66    }
67}
68
69impl<R: Debug, Keys: Debug + Index<usize, Output = Key>> key::System<R> for System<R, Keys> {
70    type Ref = Ref;
71    type Context = Context;
72    type Event = Event;
73    type PendingKeyState = PendingKeyState;
74    type KeyState = KeyState;
75
76    fn new_pressed_key(
77        &self,
78        _keymap_index: u16,
79        _context: &Self::Context,
80        Ref(key_index): Ref,
81    ) -> (
82        key::PressedKeyResult<R, Self::PendingKeyState, Self::KeyState>,
83        key::KeyEvents<Self::Event>,
84    ) {
85        let &Key { keymap_callback } = &self.keys[key_index as usize];
86        let pkr = key::PressedKeyResult::NewPressedKey(key::NewPressedKey::NoOp);
87        let km_ev = crate::keymap::KeymapEvent::Callback(keymap_callback);
88        let pke = key::KeyEvents::event(key::Event::Keymap(km_ev));
89        (pkr, pke)
90    }
91
92    fn update_pending_state(
93        &self,
94        _pending_state: &mut Self::PendingKeyState,
95        _keymap_index: u16,
96        _context: &Self::Context,
97        _key_ref: Ref,
98        _event: key::Event<Self::Event>,
99    ) -> (Option<key::NewPressedKey<R>>, key::KeyEvents<Self::Event>) {
100        panic!()
101    }
102
103    fn update_state(
104        &self,
105        _key_state: &mut Self::KeyState,
106        _ref: &Self::Ref,
107        _context: &Self::Context,
108        _keymap_index: u16,
109        _event: key::Event<Self::Event>,
110    ) -> key::KeyEvents<Self::Event> {
111        panic!()
112    }
113
114    fn key_output(
115        &self,
116        _key_ref: &Self::Ref,
117        _key_state: &Self::KeyState,
118    ) -> Option<key::KeyOutput> {
119        panic!()
120    }
121}
122
123#[cfg(test)]
124mod tests {
125    use super::*;
126
127    #[test]
128    fn test_sizeof_ref() {
129        assert_eq!(1, core::mem::size_of::<Ref>());
130    }
131
132    #[test]
133    fn test_sizeof_event() {
134        assert_eq!(0, core::mem::size_of::<Event>());
135    }
136}
smart_keymap_core/key/callback.rs

smart_keymap_core/key/
callback.rs
