Added support for Sequence Actions (aka macros) whereby multiple key events are executed in succession.

Author: riskable

src/action.rs

@@ -1,7 +1,21 @@
-//! The different actions that can be done.
+//! The different actions that can be executed via any given key.
 
 use crate::key_code::KeyCode;
 
+/// The different types of actions we support for key macros
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum SequenceEvent {
+    /// A keypress/keydown
+    Press(KeyCode),
+    /// Key release/keyup
+    Release(KeyCode),
+    /// Combination quick keydown followed by keyrelease
+    Tap(KeyCode),
+    /// Release all (currently) pressed keys
+    ReleaseAll(),
+}
+
 /// The different actions that can be done.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -41,6 +55,13 @@ pub enum Action {
         /// The tap action.
         tap: &'static Action,
     },
+    /// A sequence of KeyEvents
+    Sequence {
+        /// How long to delay between events
+        delay: u16, // NOTE: Currently unused
+        /// The sequence of KeyEvents that will be triggered
+        actions: &'static [SequenceEvent],
+    },
 }
 impl Action {
     /// Gets the layer number if the action is the `Layer` action.
@@ -55,6 +76,7 @@ impl Action {
         match self {
             Action::KeyCode(kc) => core::slice::from_ref(kc).iter().cloned(),
             Action::MultipleKeyCodes(kcs) => kcs.iter().cloned(),
+            // Action::Sequence { delay, actions } => actions.iter().cloned(), // TODO (maybe unnecessary)
             _ => [].iter().cloned(),
         }
     }
@@ -78,8 +100,33 @@ pub const fn d(layer: usize) -> Action {
     Action::DefaultLayer(layer)
 }
 
-/// A shortcut to create a `Action::KeyCode`, useful to create compact
+/// A shortcut to create `Action::MultipleKeyCodes`, useful to create compact
 /// layout.
 pub const fn m(kcs: &'static [KeyCode]) -> Action {
     Action::MultipleKeyCodes(kcs)
 }
+
+/// A shortcut to create `KeyEvent::Tap`, useful to create compact
+/// layout.
+pub const fn tap(kc: KeyCode) -> SequenceEvent {
+    SequenceEvent::Tap(kc)
+}
+
+/// A shortcut to create `KeyEvent::Press`, useful to create compact
+/// layout.
+pub const fn kp(kc: KeyCode) -> SequenceEvent {
+    SequenceEvent::Press(kc)
+}
+
+/// A shortcut to create `KeyEvent::Release`, useful to create compact
+/// layout.
+pub const fn kr(kc: KeyCode) -> SequenceEvent {
+    SequenceEvent::Release(kc)
+}
+
+// NOTE: This doesn't work yet:
+/// A shortcut to create `KeyEvent::Release`, useful to create compact
+/// layout.
+pub const fn ra() -> SequenceEvent {
+    SequenceEvent::ReleaseAll()
+}

src/layout.rs

@@ -1,6 +1,6 @@
 //! Layout management.
 
-use crate::action::Action;
+use crate::action::{Action, SequenceEvent};
 use crate::key_code::KeyCode;
 use arraydeque::ArrayDeque;
 use heapless::consts::U64;
@@ -32,13 +32,18 @@ pub enum Event {
     Press(u8, u8),
     /// Release event with coordinates (i, j).
     Release(u8, u8),
+    /// Press event with just a keycode (for sequences)
+    SequencePress(KeyCode),
+    /// Release event with just a keycode (for sequences)
+    SequenceRelease(KeyCode),
 }
 impl Event {
     /// Returns the coordinates (i, j) of the event.
     pub fn coord(self) -> (u8, u8) {
         match self {
             Event::Press(i, j) => (i, j),
             Event::Release(i, j) => (i, j),
+            _ => (0, 0), // Need a NaN version of this or something
         }
     }
 
@@ -63,6 +68,13 @@ impl Event {
                 let (i, j) = f(i, j);
                 Event::Release(i, j)
             }
+            // Not really sure what (if anything) this needs to be.  Just returning as-is
+            Event::SequencePress(k) => {
+                Event::SequencePress(k)
+            }
+            Event::SequenceRelease(k) => {
+                Event::SequenceRelease(k)
+            }
         }
     }
 }
@@ -71,11 +83,13 @@ impl Event {
 enum State {
     NormalKey { keycode: KeyCode, coord: (u8, u8) },
     LayerModifier { value: usize, coord: (u8, u8) },
+    SequenceKey { keycode: KeyCode },
 }
 impl State {
     fn keycode(&self) -> Option<KeyCode> {
         match self {
             NormalKey { keycode, .. } => Some(*keycode),
+            SequenceKey { keycode } => Some(*keycode),
             _ => None,
         }
     }
@@ -90,6 +104,12 @@ impl State {
             _ => Some(*self),
         }
     }
+    fn seq_release(&self, k: KeyCode) -> Option<Self> {
+        match *self {
+            SequenceKey { keycode, .. } if keycode == k => None,
+            _ => Some(*self),
+        }
+    }
     fn get_layer(&self) -> Option<usize> {
         match self {
             LayerModifier { value, .. } => Some(*value),
@@ -201,6 +221,16 @@ impl Layout {
                 let action = self.press_as_action((i, j), self.current_layer());
                 self.do_action(action, (i, j), stacked.since);
             }
+            SequenceRelease(k) => {
+                self.states = self
+                    .states
+                    .iter()
+                    .filter_map(|s| s.seq_release(k))
+                    .collect()
+            }
+            SequencePress(k) => {
+                let _ = self.states.push(SequenceKey { keycode: k });
+            }
         }
     }
     /// A key event.
@@ -278,6 +308,36 @@ impl Layout {
                     self.do_action(action, coord, delay);
                 }
             }
+            Sequence { delay, actions } => {
+                for key_event in actions {
+                    match *key_event {
+                        SequenceEvent::Press(keycode) => {
+                            self.stacked.push_back(Event::SequencePress(keycode).into());
+                        }
+                        SequenceEvent::Release(keycode) => {
+                            self.stacked.push_back(Event::SequenceRelease(keycode).into());
+                        }
+                        SequenceEvent::Tap(keycode) => {
+                            self.stacked.push_back(Event::SequencePress(keycode).into());
+                            self.stacked.push_back(Event::SequenceRelease(keycode).into());
+                        }
+                        SequenceEvent::ReleaseAll() => {
+                            // Can't figure out a good way to handle iterating over self.stacked
+                            // ...without running into borrow checker problems.
+                            // I basically don't know what I'm doing (yet) hehe
+                            // TODO:
+                            // for s in self.stacked.into_iter().collect() {
+                            //     match s.event {
+                            //         Event::SequencePress(keycode) => {
+                            //             self.stacked.push_back(Event::SequenceRelease(keycode.clone()).into());
+                            //         }
+                            //         _ => { () }
+                            //     }
+                            // }
+                        }
+                    }
+                }
+            }
             Layer(value) => {
                 let _ = self.states.push(LayerModifier { value, coord });
             }