Added support for Sequences (aka macros)

src/action.rs

@@ -1,7 +1,35 @@
-//! 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] // Definitely NOT exhaustive!  Let's add more! Mouse events maybe? :)
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum SequenceEvent {
+    /// A keypress/keydown
+    Press(KeyCode),
+    /// Key release/keyup
+    Release(KeyCode),
+    /// For sequences that need to wait a bit before continuing
+    Delay {
+        /// A delay (in ticks) to wait before executing the next SequenceEvent
+        since: u32,
+        /// Number of ticks to wait before removing the Delay
+        ticks: u32,
+    },
+}
+
+impl SequenceEvent {
+    /// Returns the keycode associated with the given Press/Release event
+    pub fn keycode(&self) -> Option<KeyCode> {
+        match *self {
+            SequenceEvent::Press(keycode) => Some(keycode),
+            SequenceEvent::Release(keycode) => Some(keycode),
+            _ => None,
+        }
+    }
+}
+
 /// The different actions that can be done.
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -41,6 +69,11 @@ pub enum Action {
         /// The tap action.
         tap: &'static Action,
     },
+    /// A sequence of SequenceEvents
+    Sequence {
+        /// An array of SequenceEvents that will be triggered (in order)
+        events: &'static [SequenceEvent],
+    },
 }
 impl Action {
     /// Gets the layer number if the action is the `Layer` action.
@@ -78,8 +111,9 @@ 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)
 }
+

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;
@@ -23,6 +23,9 @@ pub struct Layout {
     states: Vec<State, U64>,
     waiting: Option<WaitingState>,
     stacked: ArrayDeque<[Stacked; 16], arraydeque::behavior::Wrapping>,
+    sequenced: ArrayDeque<[SequenceEvent; 32], arraydeque::behavior::Wrapping>,
+    // Riskable NOTE: Wish we didn't have to preallocate sequenced like this.
+    //       I want to be able to have my keyboard type long sentences/quotes!
 }
 
 /// An event on the key matrix.
@@ -67,15 +70,34 @@ impl Event {
     }
 }
 
+/// The various states used internally by Keyberon
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 enum State {
-    NormalKey { keycode: KeyCode, coord: (u8, u8) },
-    LayerModifier { value: usize, coord: (u8, u8) },
+    /// Normal keys
+    NormalKey {
+        /// Keycode
+        keycode: KeyCode,
+        /// Coordinates in the matrix
+        coord: (u8, u8),
+    },
+    /// Layer modifier keys
+    LayerModifier {
+        /// Value
+        value: usize,
+        /// Coordinates of this layer modifier key in the matrix
+        coord: (u8, u8),
+    },
+    /// Fake key event for sequences
+    FakeKey {
+        /// The key to everything!
+        keycode: KeyCode,
+    },
 }
 impl State {
     fn keycode(&self) -> Option<KeyCode> {
         match self {
             NormalKey { keycode, .. } => Some(*keycode),
+            FakeKey { keycode } => Some(*keycode),
             _ => None,
         }
     }
@@ -90,6 +112,12 @@ impl State {
             _ => Some(*self),
         }
     }
+    fn seq_release(&self, kc: KeyCode) -> Option<Self> {
+        match *self {
+            FakeKey { keycode, .. } if keycode == kc => None,
+            _ => Some(*self),
+        }
+    }
     fn get_layer(&self) -> Option<usize> {
         match self {
             LayerModifier { value, .. } => Some(*value),
@@ -143,6 +171,7 @@ impl Layout {
             states: Vec::new(),
             waiting: None,
             stacked: ArrayDeque::new(),
+            sequenced: ArrayDeque::new(),
         }
     }
     /// Iterates on the key codes of the current state.
@@ -185,6 +214,32 @@ impl Layout {
                 }
             }
         }
+        // Process sequences
+        if let Some(event) = self.sequenced.pop_front() {
+            match event {
+                SequenceEvent::Press(keycode) => {
+                    // Start tracking this fake key Press() event
+                    let _ = self.states.push(FakeKey { keycode });
+                }
+                SequenceEvent::Release(keycode) => {
+                    // Clear out the Press() matching this Release's keycode
+                    self.states = self
+                        .states
+                        .iter()
+                        .filter_map(|s| s.seq_release(keycode))
+                        .collect()
+                }
+                SequenceEvent::Delay { since, ticks } => {
+                    if since < ticks {
+                        // Increment and put it back
+                        self.sequenced.push_front(SequenceEvent::Delay {
+                            since: since.saturating_add(1),
+                            ticks: 1, // Count this tick as the first
+                        });
+                    }
+                }
+            }
+        }
         self.keycodes()
     }
     fn unstack(&mut self, stacked: Stacked) {
@@ -278,6 +333,23 @@ impl Layout {
                     self.do_action(action, coord, delay);
                 }
             }
+            Sequence { events } => {
+                // Copy the contents of the sequence events into the sequenced ArrayDeque
+                for key_event in events {
+                    match *key_event {
+                        SequenceEvent::Press(keycode) => {
+                            self.sequenced.push_back(SequenceEvent::Press(keycode));
+                        }
+                        SequenceEvent::Release(keycode) => {
+                            self.sequenced.push_back(SequenceEvent::Release(keycode));
+                        }
+                        SequenceEvent::Delay { since, ticks } => {
+                            self.sequenced
+                                .push_back(SequenceEvent::Delay { since, ticks });
+                        }
+                    }
+                }
+            }
             Layer(value) => {
                 let _ = self.states.push(LayerModifier { value, coord });
             }
@@ -306,6 +378,7 @@ mod test {
     extern crate std;
     use super::{Event::*, Layers, Layout};
     use crate::action::Action::*;
+    use crate::action::SequenceEvent;
     use crate::action::{k, l, m};
     use crate::key_code::KeyCode;
     use crate::key_code::KeyCode::*;
@@ -369,4 +442,43 @@ mod test {
         assert_keys(&[LShift], layout.tick());
         assert_keys(&[], layout.tick());
     }
+
+    #[test]
+    fn sequences() {
+        static LAYERS: Layers = &[&[&[
+            Sequence {
+                // Simple Ctrl-C sequence/macro
+                events: &[
+                    SequenceEvent::Press(LCtrl),
+                    SequenceEvent::Press(C),
+                    SequenceEvent::Release(C),
+                    SequenceEvent::Release(LCtrl),
+                ],
+            },
+            Sequence {
+                // YO with a delay in the middle
+                events: &[
+                    SequenceEvent::Press(Y),
+                    SequenceEvent::Release(Y),
+                    // How many licks does it take to get to the center?
+                    SequenceEvent::Delay { since: 0, ticks: 3 }, // This many!
+                    SequenceEvent::Press(O),
+                    SequenceEvent::Release(O),
+                ],
+            },
+        ]]];
+        let mut layout = Layout::new(LAYERS);
+        assert_keys(&[], layout.tick());
+        assert_keys(&[], layout.event(Press(0, 0)));
+        assert_keys(&[LCtrl], layout.tick());
+        assert_keys(&[LCtrl, C], layout.tick());
+        assert_keys(&[LCtrl], layout.tick());
+        assert_keys(&[], layout.tick());
+        assert_keys(&[], layout.event(Press(0, 1)));
+        assert_keys(&[Y], layout.tick());
+        assert_keys(&[], layout.tick()); // 1
+        assert_keys(&[], layout.tick()); // 2
+        assert_keys(&[], layout.tick()); // 3
+        assert_keys(&[O], layout.tick()); // CHOMP!
+    }
 }