feat(combo): add option to enable a combo only for a specific layer

rmk-macro/src/behavior.rs

@@ -47,7 +47,11 @@ fn expand_combos(combos: &Option<CombosConfig>) -> proc_macro2::TokenStream {
             let combos = combos.combos.iter().map(|combo| {
                 let actions = combo.actions.iter().map(|a| parse_key(a.to_owned()));
                 let output = parse_key(combo.output.to_owned());
-                quote! { ::rmk::combo::Combo::new([#(#actions),*], #output) }
+                let layer = match combo.layer {
+                    Some(layer) => quote! { ::core::option::Option::Some(#layer) },
+                    None => quote! { ::core::option::Option::None },
+                };
+                quote! { ::rmk::combo::Combo::new([#(#actions),*], #output, #layer) }
             });
 
             quote! { ::heapless::Vec::from_iter([#(#combos),*]) }

rmk-macro/src/config/mod.rs

@@ -162,6 +162,7 @@ pub struct CombosConfig {
 pub struct ComboConfig {
     pub actions: Vec<String>,
     pub output: String,
+    pub layer: Option<u8>,
 }
 
 /// Configurations for split keyboards

rmk-macro/src/keyboard_config.rs

@@ -455,6 +455,12 @@ impl KeyboardConfig {
                         if c.actions.len() > COMBO_MAX_LENGTH {
                             return rmk_compile_error!(format!("keyboard.toml: number of keys in combo #{i} is greater than [behavior.combo.max_length]"));
                         }
+
+                        if let Some(layer) = c.layer {
+                            if layer >= layout.layers {
+                                return rmk_compile_error!(format!("keyboard.toml: layer in combo #{i} is greater than [layout.layers]"));
+                            }
+                        }
                     }
                 }
 

rmk/src/combo.rs

@@ -11,6 +11,7 @@ pub(crate) const COMBO_MAX_LENGTH: usize = 4;
 pub struct Combo {
     pub(crate) actions: Vec<KeyAction, COMBO_MAX_LENGTH>,
     pub(crate) output: KeyAction,
+    pub(crate) layer: Option<u8>,
     state: u8,
 }
 
@@ -21,23 +22,43 @@ impl Default for Combo {
 }
 
 impl Combo {
-    pub fn new<I: IntoIterator<Item = KeyAction>>(actions: I, output: KeyAction) -> Self {
+    pub fn new<I: IntoIterator<Item = KeyAction>>(
+        actions: I,
+        output: KeyAction,
+        layer: Option<u8>,
+    ) -> Self {
         Self {
             actions: Vec::from_iter(actions),
             output,
+            layer,
             state: 0,
         }
     }
 
     pub fn empty() -> Self {
-        Self::new(Vec::<KeyAction, COMBO_MAX_LENGTH>::new(), KeyAction::No)
+        Self::new(
+            Vec::<KeyAction, COMBO_MAX_LENGTH>::new(),
+            KeyAction::No,
+            None,
+        )
     }
 
-    pub(crate) fn update(&mut self, key_action: KeyAction, key_event: KeyEvent) -> bool {
+    pub(crate) fn update(
+        &mut self,
+        key_action: KeyAction,
+        key_event: KeyEvent,
+        active_layer: u8,
+    ) -> bool {
         if !key_event.pressed || key_action == KeyAction::No {
             return false;
         }
 
+        if let Some(layer) = self.layer {
+            if layer != active_layer {
+                return false;
+            }
+        }
+
         let action_idx = self.actions.iter().position(|&a| a == key_action);
         if let Some(i) = action_idx {
             self.state |= 1 << i;

rmk/src/keyboard.rs

@@ -322,8 +322,9 @@ impl<'a, const ROW: usize, const COL: usize, const NUM_LAYER: usize>
         key_event: KeyEvent,
     ) -> Option<KeyAction> {
         let mut is_combo_action = false;
+        let current_layer = self.keymap.borrow().get_activated_layer();
         for combo in self.keymap.borrow_mut().combos.iter_mut() {
-            is_combo_action |= combo.update(key_action, key_event);
+            is_combo_action |= combo.update(key_action, key_event, current_layer);
         }
 
         if key_event.pressed && is_combo_action {

rmk/src/keymap.rs

@@ -245,7 +245,7 @@ impl<'a, const ROW: usize, const COL: usize, const NUM_LAYER: usize>
         KeyAction::No
     }
 
-    fn get_activated_layer(&self) -> u8 {
+    pub(crate) fn get_activated_layer(&self) -> u8 {
         for (layer_idx, _) in self.layers.iter().enumerate().rev() {
             if self.layer_state[layer_idx] || layer_idx as u8 == self.default_layer {
                 return layer_idx as u8;

rmk/src/storage/mod.rs

@@ -187,7 +187,11 @@ impl Value<'_> for StorageData {
                     );
                 }
                 BigEndian::write_u16(&mut buffer[9..11], to_via_keycode(combo.output));
-                Ok(11)
+                buffer[11] = match combo.layer {
+                    Some(layer) => layer.to_be(),
+                    None => u8::MAX,
+                };
+                Ok(12)
             }
             StorageData::ConnectionType(ty) => {
                 buffer[0] = StorageKeys::ConnectionType as u8;
@@ -273,7 +277,7 @@ impl Value<'_> for StorageData {
                     Ok(StorageData::MacroData(buf))
                 }
                 StorageKeys::ComboData => {
-                    if buffer.len() < 11 {
+                    if buffer.len() < 12 {
                         return Err(SerializationError::InvalidData);
                     }
                     let mut actions = [KeyAction::No; 4];
@@ -282,10 +286,12 @@ impl Value<'_> for StorageData {
                             from_via_keycode(BigEndian::read_u16(&buffer[1 + i * 2..3 + i * 2]));
                     }
                     let output = from_via_keycode(BigEndian::read_u16(&buffer[9..11]));
+                    let layer = u8::from_be(buffer[11]);
                     Ok(StorageData::ComboData(ComboData {
                         idx: 0,
                         actions,
                         output,
+                        layer: (layer != u8::MAX).then_some(layer),
                     }))
                 }
                 StorageKeys::ConnectionType => Ok(StorageData::ConnectionType(buffer[1])),
@@ -353,6 +359,7 @@ pub(crate) struct ComboData {
     pub(crate) idx: usize,
     pub(crate) actions: [KeyAction; COMBO_MAX_LENGTH],
     pub(crate) output: KeyAction,
+    pub(crate) layer: Option<u8>,
 }
 
 pub(crate) struct Storage<
@@ -707,7 +714,7 @@ impl<F: AsyncNorFlash, const ROW: usize, const COL: usize, const NUM_LAYER: usiz
                 for &action in combo.actions.iter().filter(|&&a| a != KeyAction::No) {
                     let _ = actions.push(action);
                 }
-                combos[i] = Combo::new(actions, combo.output);
+                combos[i] = Combo::new(actions, combo.output, combo.layer);
             }
         }
 

rmk/src/via/process.rs

@@ -453,6 +453,7 @@ impl<'a, const ROW: usize, const COL: usize, const NUM_LAYER: usize>
                                 idx: real_idx,
                                 actions,
                                 output,
+                                layer: combos[real_idx].layer,
                             }))
                             .await;
                     }