smart_keymap/key/
layered.rs

1use core::fmt::Debug;
2use core::marker::Copy;
3use core::ops::Index;
4
5use serde::Deserialize;
6
7use crate::input;
8use crate::key;
9
10/// The type used for layer index.
11pub type LayerIndex = u32;
12
13/// The type used for set of active layers in ModifierKey.
14/// (Limited to [MAX_BITSET_LAYER] layers.)
15pub type LayerBitset = u32;
16
17/// The maximum number of layers that can be represented in a [LayerBitset].
18pub const MAX_BITSET_LAYER: usize = 8 * core::mem::size_of::<LayerBitset>() - 1;
19
20/// Reference for a keyboard key.
21#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
22pub enum Ref {
23    /// Ref to a layer modifier key.
24    Modifier(u8),
25    /// Ref to a layered key.
26    Layered(u8),
27}
28
29/// Modifier layer key affects what layers are active.
30#[derive(Debug, Deserialize, Clone, Copy, PartialEq)]
31pub enum ModifierKey {
32    /// Activates the given layer when the held.
33    Hold(LayerIndex),
34    /// Toggles whether the given layer is active when pressed.
35    Toggle(LayerIndex),
36    /// Sticky layer modifier, similar to sticky modifier key.
37    ///
38    /// Acts the same as `Hold` variant if interrupted.
39    /// If tapped, then the layer is activated for the next key tap.
40    Sticky(LayerIndex),
41    /// Sets the set of active layers to the given layers when the key is pressed.
42    SetActiveLayers(LayerBitset),
43    /// Sets the default layer.
44    Default(LayerIndex),
45}
46
47impl ModifierKey {
48    /// Create a new [ModifierKey] that activates the given layer when held.
49    pub const fn hold(layer: LayerIndex) -> Self {
50        ModifierKey::Hold(layer)
51    }
52
53    /// Create a new [ModifierKey] that activates the layer when held, or makes it sticky when tapped.
54    pub const fn sticky(layer: LayerIndex) -> Self {
55        ModifierKey::Sticky(layer)
56    }
57
58    /// Create a new [ModifierKey] that toggles the given layer.
59    pub const fn toggle(layer: LayerIndex) -> Self {
60        ModifierKey::Toggle(layer)
61    }
62
63    /// Create a new [ModifierKey] that sets the active layers to the given slice of layers when pressed.
64    ///
65    /// Each LayerIndex in the slice must be less than [MAX_BITSET_LAYER].
66    pub const fn set_active_layers(layers: &[LayerIndex]) -> Self {
67        let mut bitset = 0;
68
69        let mut idx = 0;
70        while idx < layers.len() {
71            let layer = layers[idx] as usize;
72            if layer < MAX_BITSET_LAYER {
73                bitset |= 1 << layer;
74            } else {
75                panic!("LayerIndex must be less than MAX_BITSET_LAYER");
76            }
77            idx += 1;
78        }
79
80        ModifierKey::SetActiveLayers(bitset)
81    }
82
83    /// Create a new [ModifierKey] that sets the active layers bitset.
84    pub const fn set_active_layers_from_bitset(bitset: LayerBitset) -> Self {
85        ModifierKey::SetActiveLayers(bitset)
86    }
87
88    /// Create a new [ModifierKey] that sets the default layer.
89    pub const fn default(layer: LayerIndex) -> Self {
90        ModifierKey::Default(layer)
91    }
92
93    /// Create a new [input::PressedKey] and [key::ScheduledEvent] for the given keymap index.
94    ///
95    /// Pressing a [ModifierKey::Hold] emits a [LayerEvent::Activated] event.
96    pub fn new_pressed_key(&self) -> (ModifierKeyState, Option<LayerEvent>) {
97        match self {
98            ModifierKey::Hold(layer) => {
99                (ModifierKeyState::new(), Some(LayerEvent::Activated(*layer)))
100            }
101            ModifierKey::Toggle(layer) => {
102                (ModifierKeyState::new(), Some(LayerEvent::Toggled(*layer)))
103            }
104            ModifierKey::Sticky(layer) => (
105                ModifierKeyState::sticky(),
106                Some(LayerEvent::StickyActivated(*layer)),
107            ),
108            ModifierKey::SetActiveLayers(layer_set) => {
109                (ModifierKeyState::new(), Some(LayerEvent::Set(*layer_set)))
110            }
111            ModifierKey::Default(layer) => (
112                ModifierKeyState::new(),
113                Some(LayerEvent::SetDefault(*layer)),
114            ),
115        }
116    }
117}
118
119impl From<LayerEvent> for () {
120    fn from(_: LayerEvent) -> Self {}
121}
122
123/// Style of activating a layer.
124#[derive(Debug, Clone, Copy, PartialEq)]
125pub enum ActivationStyle {
126    /// Regular layer activation.
127    Regular,
128    /// Sticky layer activation.
129    ///
130    /// Sticky layer activation is similar to sticky key modifiers.
131    /// The sticky layer activation is implemented using the sticky layer modifier key.
132    Sticky,
133}
134
135/// State of an individual layer: active or inactive.
136#[derive(Debug, Clone, Copy, PartialEq)]
137pub enum Activity {
138    /// The layer is active.
139    Active(ActivationStyle),
140    /// The layer is inactive.
141    Inactive,
142}
143
144impl Activity {
145    /// Returns true if the layer is active.
146    pub fn is_active(&self) -> bool {
147        matches!(self, Activity::Active(_))
148    }
149}
150
151/// Tracks state of active layers.
152pub trait LayerState: Copy + Debug {
153    /// Activate the given layer.
154    fn activate(&mut self, layer: LayerIndex, style: ActivationStyle);
155    /// Deactivate the given layer.
156    fn deactivate(&mut self, layer: LayerIndex);
157    /// Get the active layers, from highest active layer to lowest.
158    fn active_layers(&self) -> impl Iterator<Item = LayerIndex>;
159}
160
161impl<const L: usize> LayerState for [Activity; L] {
162    fn activate(&mut self, layer_index: LayerIndex, style: ActivationStyle) {
163        let layer_index: usize = layer_index as usize;
164        debug_assert!(
165            layer_index <= L,
166            "layer must be less than array length of {}",
167            L
168        );
169        self[layer_index - 1] = Activity::Active(style);
170    }
171
172    fn deactivate(&mut self, layer_index: LayerIndex) {
173        let layer_index: usize = layer_index as usize;
174        debug_assert!(
175            layer_index <= L,
176            "layer must be less than array length of {}",
177            L
178        );
179        self[layer_index - 1] = Activity::Inactive;
180    }
181
182    fn active_layers(&self) -> impl Iterator<Item = LayerIndex> {
183        self.iter().enumerate().rev().filter_map(|(i, activity)| {
184            if activity.is_active() {
185                Some(i as LayerIndex + 1)
186            } else {
187                None
188            }
189        })
190    }
191}
192
193/// [crate::key::Context] for [LayeredKey] that tracks active layers.
194#[derive(Debug, Clone, Copy)]
195pub struct Context<const LAYER_COUNT: usize> {
196    default_layer: Option<LayerIndex>,
197    active_layers: [Activity; LAYER_COUNT],
198    // Keymap index which was pressed while a layer was sticky.
199    pressed_keymap_index: Option<u16>,
200}
201
202impl<const LAYER_COUNT: usize> Context<LAYER_COUNT> {
203    /// Create a new [Context].
204    pub const fn new() -> Self {
205        Context {
206            default_layer: None,
207            active_layers: [Activity::Inactive; LAYER_COUNT],
208            pressed_keymap_index: None,
209        }
210    }
211}
212
213impl<const LAYER_COUNT: usize> Default for Context<LAYER_COUNT> {
214    fn default() -> Self {
215        Self::new()
216    }
217}
218
219impl<const LAYER_COUNT: usize> Context<LAYER_COUNT> {
220    /// Get the active layers.
221    pub fn layer_state(&self) -> &[Activity; LAYER_COUNT] {
222        &self.active_layers
223    }
224
225    fn sticky_layer(&self) -> Option<LayerIndex> {
226        self.active_layers
227            .iter()
228            .position(|&a| a == Activity::Active(ActivationStyle::Sticky))
229            .map(|i| i as LayerIndex + 1)
230    }
231
232    /// Updates the context with the [LayerEvent].
233    fn handle_layer_event(&mut self, event: LayerEvent) {
234        match event {
235            LayerEvent::Activated(layer) => {
236                self.active_layers.activate(layer, ActivationStyle::Regular);
237            }
238            LayerEvent::Deactivated(layer) => {
239                self.active_layers.deactivate(layer);
240            }
241            LayerEvent::StickyActivated(layer) => {
242                self.active_layers.activate(layer, ActivationStyle::Sticky);
243                self.pressed_keymap_index = None;
244            }
245            LayerEvent::Toggled(layer) => {
246                if self.active_layers[layer as usize - 1].is_active() {
247                    self.active_layers.deactivate(layer);
248                } else {
249                    self.active_layers.activate(layer, ActivationStyle::Regular);
250                }
251            }
252            LayerEvent::Set(layer_set) => {
253                let max_layer = 1 + LAYER_COUNT.min(MAX_BITSET_LAYER);
254
255                // layer 0 is always active.
256                for li in 1..max_layer {
257                    if (layer_set & (1 << li)) != 0 {
258                        self.active_layers
259                            .activate(li as LayerIndex, ActivationStyle::Regular);
260                    } else {
261                        self.active_layers.deactivate(li as LayerIndex);
262                    }
263                }
264            }
265            LayerEvent::SetDefault(0) => self.default_layer = None,
266            LayerEvent::SetDefault(layer) => self.default_layer = Some(layer),
267        }
268    }
269
270    /// Updates the context with the [key::Event].
271    fn handle_event(&mut self, event: key::Event<LayerEvent>) {
272        match event {
273            key::Event::Input(input::Event::Press { keymap_index, .. }) => {
274                if let Some(sticky_layer_index) = self.sticky_layer() {
275                    if self.pressed_keymap_index.is_some() {
276                        // The sticky layer modifier has already been used;
277                        // the sticky layer should be deactivated for subsequent presses.
278                        self.active_layers.deactivate(sticky_layer_index);
279                        self.pressed_keymap_index = None;
280                    } else {
281                        self.pressed_keymap_index = Some(keymap_index);
282                    }
283                }
284            }
285            key::Event::Input(input::Event::Release { keymap_index, .. }) => {
286                if let Some(sticky_layer_index) = self.sticky_layer() {
287                    if self.pressed_keymap_index == Some(keymap_index) {
288                        self.active_layers.deactivate(sticky_layer_index);
289                        self.pressed_keymap_index = None;
290                    }
291                }
292            }
293            key::Event::Key { key_event, .. } => {
294                self.handle_layer_event(key_event);
295            }
296            _ => {}
297        }
298    }
299}
300
301impl<const LAYER_COUNT: usize> key::Context for Context<LAYER_COUNT> {
302    type Event = LayerEvent;
303
304    fn handle_event(&mut self, event: key::Event<Self::Event>) -> key::KeyEvents<Self::Event> {
305        self.handle_event(event);
306        key::KeyEvents::no_events()
307    }
308}
309
310/// Errors when constructing Layers.
311#[derive(Debug, Clone, Copy, PartialEq)]
312pub enum LayersError {
313    /// Trying to construct more layers than the Layers can store.
314    Overflow,
315}
316
317impl core::fmt::Display for LayersError {
318    // This trait requires `fmt` with this exact signature.
319    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
320        write!(f, "LayersError::Overflow")
321    }
322}
323
324/// Trait for layers of [LayeredKey].
325pub trait Layers<R>: Copy + Debug {
326    /// Get the highest active key, if any, for the given [LayerState].
327    fn highest_active_key<LS: LayerState>(
328        &self,
329        layer_state: &LS,
330        default_layer: Option<LayerIndex>,
331    ) -> Option<(LayerIndex, R)>;
332    /// Constructs layers; return Err if the iterable has more keys than Layers can store.
333    fn from_iterable<I: IntoIterator<Item = Option<R>>>(keys: I) -> Result<Self, LayersError>;
334}
335
336impl<R: Copy + Debug, const L: usize> Layers<R> for [Option<R>; L] {
337    fn highest_active_key<LS: LayerState>(
338        &self,
339        layer_state: &LS,
340        default_layer: Option<LayerIndex>,
341    ) -> Option<(LayerIndex, R)> {
342        for layer_index in layer_state.active_layers() {
343            if self[layer_index as usize - 1].is_some() {
344                return self[layer_index as usize - 1].map(|k| (layer_index, k));
345            }
346        }
347
348        match default_layer {
349            Some(layer_index) if self[layer_index as usize - 1].is_some() => {
350                self[layer_index as usize - 1].map(|k| (layer_index, k))
351            }
352            _ => None,
353        }
354    }
355
356    fn from_iterable<I: IntoIterator<Item = Option<R>>>(keys: I) -> Result<Self, LayersError> {
357        let mut layered: [Option<R>; L] = [None; L];
358        for (i, maybe_key) in keys.into_iter().enumerate() {
359            if i < L {
360                layered[i] = maybe_key;
361            } else {
362                return Err(LayersError::Overflow);
363            }
364        }
365        Ok(layered)
366    }
367}
368
369/// Constructs an array of keys for the given array.
370pub const fn layered_keys<K: Copy, const L: usize, const LAYER_COUNT: usize>(
371    keys: [Option<K>; L],
372) -> [Option<K>; LAYER_COUNT] {
373    let mut layered: [Option<K>; LAYER_COUNT] = [None; LAYER_COUNT];
374
375    if L > LAYER_COUNT {
376        panic!("Too many layers for layered_keys");
377    }
378
379    let mut i = 0;
380
381    while i < L {
382        layered[i] = keys[i];
383        i += 1;
384    }
385
386    layered
387}
388
389/// A key whose behavior depends on which layer is active.
390#[derive(Debug, Deserialize, Clone, Copy, PartialEq)]
391pub struct LayeredKey<R: Copy + Debug + PartialEq, const LAYER_COUNT: usize> {
392    /// The base key, used when no layers are active.
393    pub base: R,
394    /// The layered keys, used when the corresponding layer is active.
395    #[serde(deserialize_with = "deserialize_layered")]
396    #[serde(bound(deserialize = "R: Deserialize<'de>"))]
397    pub layered: [Option<R>; LAYER_COUNT],
398}
399
400/// Deserialize a [Layers].
401fn deserialize_layered<'de, R, L: Layers<R>, D>(deserializer: D) -> Result<L, D::Error>
402where
403    R: Deserialize<'de>,
404    D: serde::Deserializer<'de>,
405{
406    let keys_vec: heapless::Vec<Option<R>, 64> = Deserialize::deserialize(deserializer)?;
407
408    L::from_iterable(keys_vec).map_err(serde::de::Error::custom)
409}
410
411impl<R: Copy + Debug + PartialEq, const LAYER_COUNT: usize> LayeredKey<R, LAYER_COUNT> {
412    /// Constructs a new [LayeredKey].
413    pub const fn new<const L: usize>(base: R, layered: [Option<R>; L]) -> Self {
414        let layered = layered_keys(layered);
415        Self { base, layered }
416    }
417}
418
419impl<R: Copy + Debug + PartialEq, const LAYER_COUNT: usize> LayeredKey<R, LAYER_COUNT> {
420    /// Presses the key, using the highest active key, if any.
421    fn new_pressed_key(&self, context: &Context<LAYER_COUNT>) -> key::NewPressedKey<R> {
422        let (_layer, passthrough_ref) = self
423            .layered
424            .highest_active_key(context.layer_state(), context.default_layer)
425            .unwrap_or((0, self.base));
426
427        key::NewPressedKey::key(passthrough_ref)
428    }
429}
430
431/// Events from [ModifierKey] which affect [Context].
432#[derive(Debug, Clone, Copy, Eq, PartialEq)]
433pub enum LayerEvent {
434    /// Activates the given layer.
435    Activated(LayerIndex),
436    /// Deactivates the given layer.
437    Deactivated(LayerIndex),
438    /// Toggles the given layer.
439    Toggled(LayerIndex),
440    /// Activates the given layer.
441    StickyActivated(LayerIndex),
442    /// Sets the active layers to the given set of layers.
443    Set(LayerBitset),
444    /// Changes the default layer.
445    SetDefault(LayerIndex),
446}
447
448/// Struct for layer system pending key state. (No pending state).
449#[derive(Debug, Clone, Copy, PartialEq)]
450pub struct PendingKeyState;
451
452/// Whether the pressed Sticky modifier key is "sticky" or "regular".
453#[derive(Debug, Clone, Copy, Eq, PartialEq)]
454pub enum Behavior {
455    /// Key state is "sticky". (Will activate sticky modifier when released).
456    Sticky,
457    /// Key state is "regular". (No sticky modifiers activated when released).
458    Regular,
459}
460
461/// [crate::key::KeyState] of [ModifierKey].
462#[derive(Debug, Clone, Copy, PartialEq)]
463pub struct ModifierKeyState {
464    behavior: Behavior,
465}
466
467impl ModifierKeyState {
468    /// Constructs a regular ModifierKeyState
469    pub fn new() -> Self {
470        Self {
471            behavior: Behavior::Regular,
472        }
473    }
474
475    /// Constructs a sticky ModifierKeyState
476    pub fn sticky() -> Self {
477        Self {
478            behavior: Behavior::Sticky,
479        }
480    }
481
482    /// Handle the given event for the given key.
483    pub fn handle_event(
484        &mut self,
485        keymap_index: u16,
486        event: key::Event<LayerEvent>,
487        key: &ModifierKey,
488    ) -> Option<LayerEvent> {
489        match key {
490            ModifierKey::Hold(layer) => match event {
491                key::Event::Input(input::Event::Release { keymap_index: ki }) => {
492                    if keymap_index == ki {
493                        Some(LayerEvent::Deactivated(*layer))
494                    } else {
495                        None
496                    }
497                }
498                _ => None,
499            },
500            ModifierKey::Toggle(_) => None,
501            ModifierKey::Sticky(layer) => match event {
502                key::Event::Input(input::Event::Press { keymap_index: _ }) => {
503                    if self.behavior == Behavior::Sticky {
504                        // Another key pressed while sticky modifier is held; make self regular
505                        self.behavior = Behavior::Regular;
506                        // Change the layer state to *regular*
507                        Some(LayerEvent::Activated(*layer))
508                    } else {
509                        None
510                    }
511                }
512                key::Event::Input(input::Event::Release { keymap_index: ki })
513                    if keymap_index == ki && self.behavior == Behavior::Regular =>
514                {
515                    Some(LayerEvent::Deactivated(*layer))
516                }
517                _ => None,
518            },
519            ModifierKey::SetActiveLayers(_layer_set) => None,
520            ModifierKey::Default(layer) => match event {
521                key::Event::Input(input::Event::Release { keymap_index: ki }) => {
522                    if keymap_index == ki {
523                        Some(LayerEvent::SetDefault(*layer))
524                    } else {
525                        None
526                    }
527                }
528                _ => None,
529            },
530        }
531    }
532}
533
534/// The [key::System] implementation for layer system keys.
535#[derive(Debug, Clone, Copy, PartialEq)]
536pub struct System<
537    R: Copy + Debug + PartialEq,
538    ModifierKeys: Index<usize, Output = ModifierKey>,
539    LayeredKeys: Index<usize, Output = LayeredKey<R, LAYER_COUNT>>,
540    const LAYER_COUNT: usize,
541> {
542    modifier_keys: ModifierKeys,
543    layered_keys: LayeredKeys,
544}
545
546impl<
547        R: Copy + Debug + PartialEq,
548        ModifierKeys: Index<usize, Output = ModifierKey>,
549        LayeredKeys: Index<usize, Output = LayeredKey<R, LAYER_COUNT>>,
550        const LAYER_COUNT: usize,
551    > System<R, ModifierKeys, LayeredKeys, LAYER_COUNT>
552{
553    /// Constructs a new [System] with the given key data.
554    pub const fn new(modifier_keys: ModifierKeys, layered_keys: LayeredKeys) -> Self {
555        Self {
556            modifier_keys,
557            layered_keys,
558        }
559    }
560}
561
562impl<
563        R: Copy + Debug + PartialEq,
564        ModifierKeys: Debug + Index<usize, Output = ModifierKey>,
565        LayeredKeys: Debug + Index<usize, Output = LayeredKey<R, LAYER_COUNT>>,
566        const LAYER_COUNT: usize,
567    > key::System<R> for System<R, ModifierKeys, LayeredKeys, LAYER_COUNT>
568{
569    type Ref = Ref;
570    type Context = Context<LAYER_COUNT>;
571    type Event = LayerEvent;
572    type PendingKeyState = PendingKeyState;
573    type KeyState = ModifierKeyState;
574
575    fn new_pressed_key(
576        &self,
577        keymap_index: u16,
578        context: &Self::Context,
579        key_ref: Ref,
580    ) -> (
581        key::PressedKeyResult<R, Self::PendingKeyState, Self::KeyState>,
582        key::KeyEvents<Self::Event>,
583    ) {
584        match key_ref {
585            Ref::Modifier(i) => {
586                let key = self.modifier_keys[i as usize];
587                let (m_ks, maybe_lmod_ev) = key.new_pressed_key();
588                let pks = key::PressedKeyResult::Resolved(m_ks);
589                let pke = match maybe_lmod_ev {
590                    Some(lmod_ev) => {
591                        key::KeyEvents::event(key::Event::key_event(keymap_index, lmod_ev))
592                    }
593                    None => key::KeyEvents::no_events(),
594                };
595                (pks, pke)
596            }
597            Ref::Layered(i) => {
598                let key = &self.layered_keys[i as usize];
599                let npk = key.new_pressed_key(context);
600                (
601                    key::PressedKeyResult::NewPressedKey(npk),
602                    key::KeyEvents::no_events(),
603                )
604            }
605        }
606    }
607
608    fn update_pending_state(
609        &self,
610        _pending_state: &mut Self::PendingKeyState,
611        _keymap_index: u16,
612        _context: &Self::Context,
613        _key_ref: Ref,
614        _event: key::Event<Self::Event>,
615    ) -> (Option<key::NewPressedKey<R>>, key::KeyEvents<Self::Event>) {
616        panic!()
617    }
618
619    fn update_state(
620        &self,
621        key_state: &mut Self::KeyState,
622        key_ref: &Self::Ref,
623        _context: &Self::Context,
624        keymap_index: u16,
625        event: key::Event<Self::Event>,
626    ) -> key::KeyEvents<Self::Event> {
627        match key_ref {
628            Ref::Modifier(mod_key_index) => {
629                let mod_key = &self.modifier_keys[*mod_key_index as usize];
630                let maybe_ev = key_state.handle_event(keymap_index, event, mod_key);
631                maybe_ev.map_or(key::KeyEvents::no_events(), |ev| {
632                    key::KeyEvents::event(key::Event::key_event(keymap_index, ev))
633                })
634            }
635            _ => key::KeyEvents::no_events(),
636        }
637    }
638
639    fn key_output(
640        &self,
641        _key_ref: &Self::Ref,
642        _key_state: &Self::KeyState,
643    ) -> Option<key::KeyOutput> {
644        None
645    }
646}
647
648#[cfg(test)]
649mod tests {
650    use super::*;
651
652    use crate::key::keyboard;
653
654    use crate::key::System as _;
655
656    const LAYER_COUNT: usize = 8;
657
658    type Context = super::Context<LAYER_COUNT>;
659
660    #[test]
661    fn test_sizeof_ref() {
662        assert_eq!(2, core::mem::size_of::<Ref>());
663    }
664
665    #[test]
666    fn test_sizeof_event() {
667        assert_eq!(8, core::mem::size_of::<LayerEvent>());
668    }
669
670    #[test]
671    fn test_pressing_hold_modifier_key_emits_event_activate_layer() {
672        let layer = 1;
673        let key = ModifierKey::Hold(layer);
674
675        let (_pressed_key, layer_event) = key.new_pressed_key();
676
677        assert_eq!(Some(LayerEvent::Activated(layer)), layer_event);
678    }
679
680    #[test]
681    fn test_releasing_hold_modifier_key_emits_event_deactivate_layer() {
682        // Assemble: press a Hold layer modifier key
683        let layer = 1;
684        let key = ModifierKey::Hold(layer);
685        let keymap_index = 9; // arbitrary
686        let (mut pressed_key_state, _) = key.new_pressed_key();
687
688        // Act: the modifier key handles "release key" input event
689        let actual_events = pressed_key_state
690            .handle_event(
691                keymap_index,
692                key::Event::Input(input::Event::Release { keymap_index }),
693                &key,
694            )
695            .into_iter()
696            .next();
697
698        // Assert: the pressed key should have emitted a layer deactivation event
699        let first_ev = actual_events.into_iter().next();
700        if let Some(actual_layer_event) = first_ev {
701            let expected_layer_event = LayerEvent::Deactivated(layer);
702            assert_eq!(expected_layer_event, actual_layer_event);
703        } else {
704            panic!("Expected Some LayerDeactivated event");
705        }
706    }
707
708    #[test]
709    fn test_releasing_different_hold_modifier_key_does_not_emit_event() {
710        // Assemble: press a Hold layer modifier key
711        let layer = 1;
712        let key = ModifierKey::Hold(layer);
713        let keymap_index = 9; // arbitrary
714        let (mut pressed_key_state, _) = key.new_pressed_key();
715
716        // Act: the modifier key handles "release key" input event for a different key
717        let different_keymap_index = keymap_index + 1;
718        let different_key_released_ev = key::Event::Input(input::Event::Release {
719            keymap_index: different_keymap_index,
720        });
721        let actual_events = pressed_key_state
722            .handle_event(keymap_index, different_key_released_ev, &key)
723            .into_iter()
724            .next();
725
726        // Assert: the pressed key should not emit an event
727        if actual_events.is_some() {
728            panic!("Expected no event emitted");
729        }
730    }
731
732    #[test]
733    fn test_context_handling_event_adjusts_active_layers() {
734        let mut context = Context::default();
735
736        context.handle_layer_event(LayerEvent::Activated(2));
737
738        let actual_active_layers = &context.active_layers[0..3];
739        assert_eq!(
740            &[
741                Activity::Inactive,
742                Activity::Active(ActivationStyle::Regular),
743                Activity::Inactive
744            ],
745            actual_active_layers
746        );
747    }
748
749    #[test]
750    fn test_pressing_layered_key_acts_as_base_key_when_no_layers_active() {
751        // Assemble
752        let context = Context::default();
753        let expected_ref = keyboard::Ref::KeyCode(0x04);
754        let layered_key = LayeredKey::new(
755            expected_ref,
756            [
757                Some(keyboard::Ref::KeyCode(0x05)),
758                Some(keyboard::Ref::KeyCode(0x06)),
759                Some(keyboard::Ref::KeyCode(0x07)),
760            ],
761        );
762        let system = System::new([], [layered_key]);
763
764        // Act: without activating a layer, press the layered key
765        let keymap_index = 9; // arbitrary
766        let key_ref = Ref::Layered(0);
767        let (pkr, _pke) = system.new_pressed_key(keymap_index, &context, key_ref);
768
769        // Assert
770        let expected_pkr =
771            key::PressedKeyResult::NewPressedKey(key::NewPressedKey::Key(expected_ref));
772        assert_eq!(expected_pkr, pkr,);
773    }
774
775    // Terminology:
776    //   "defined layer" = LayeredKey.layered[] is Some for that layer;
777    //   "active layer" = Context.active_layers[] = true for that layer.
778
779    #[test]
780    fn test_pressing_layered_key_falls_through_undefined_active_layers() {
781        // Assemble: layered key (with no layered definitions)
782        let mut context = Context::default();
783        let expected_ref = keyboard::Ref::KeyCode(0x04);
784        let layered_key = LayeredKey::new(expected_ref, [None, None, None]);
785        let system = System::new([], [layered_key]);
786
787        // Act: activate all layers, press layered key
788        context.handle_layer_event(LayerEvent::Activated(1));
789        context.handle_layer_event(LayerEvent::Activated(2));
790        context.handle_layer_event(LayerEvent::Activated(3));
791        let keymap_index = 9; // arbitrary
792        let key_ref = Ref::Layered(0);
793        let (pkr, _pke) = system.new_pressed_key(keymap_index, &context, key_ref);
794
795        // Assert
796        let expected_pkr =
797            key::PressedKeyResult::NewPressedKey(key::NewPressedKey::Key(expected_ref));
798        assert_eq!(expected_pkr, pkr,);
799    }
800
801    #[test]
802    fn test_pressing_layered_key_acts_as_highest_defined_active_layer() {
803        // Assemble: layered key (with no layered definitions)
804        let mut context = Context::default();
805        let expected_ref = keyboard::Ref::KeyCode(0x09);
806        let layered_key = LayeredKey::new(
807            keyboard::Ref::KeyCode(0x04),
808            [
809                Some(keyboard::Ref::KeyCode(0x05)),
810                Some(keyboard::Ref::KeyCode(0x06)),
811                Some(expected_ref),
812            ],
813        );
814        let system = System::new([], [layered_key]);
815
816        // Act: activate all layers, press layered key
817        context.handle_layer_event(LayerEvent::Activated(1));
818        context.handle_layer_event(LayerEvent::Activated(2));
819        context.handle_layer_event(LayerEvent::Activated(3));
820        let keymap_index = 9; // arbitrary
821        let key_ref = Ref::Layered(0);
822        let (pkr, _pke) = system.new_pressed_key(keymap_index, &context, key_ref);
823
824        // Assert
825        let expected_pkr =
826            key::PressedKeyResult::NewPressedKey(key::NewPressedKey::Key(expected_ref));
827        assert_eq!(expected_pkr, pkr,);
828    }
829
830    #[test]
831    fn test_pressing_layered_key_with_some_transparency_acts_as_highest_defined_active_layer() {
832        // Assemble: layered key (with no layered definitions)
833        let mut context = Context::default();
834        let expected_ref = keyboard::Ref::KeyCode(0x09);
835        let layered_key = LayeredKey::new(
836            keyboard::Ref::KeyCode(0x04),
837            [Some(expected_ref), Some(keyboard::Ref::KeyCode(0x06)), None],
838        );
839        let system = System::new([], [layered_key]);
840
841        // Act: activate all layers, press layered key
842        context.handle_layer_event(LayerEvent::Activated(1));
843        context.handle_layer_event(LayerEvent::Activated(3));
844        let keymap_index = 9; // arbitrary
845        let key_ref = Ref::Layered(0);
846        let (pkr, _pke) = system.new_pressed_key(keymap_index, &context, key_ref);
847
848        // Assert
849        let expected_pkr =
850            key::PressedKeyResult::NewPressedKey(key::NewPressedKey::Key(expected_ref));
851        assert_eq!(expected_pkr, pkr,);
852    }
853
854    #[test]
855    fn test_layer_state_array_active_layers() {
856        let mut layer_state: [Activity; 5] = [Activity::Inactive; 5];
857        layer_state.activate(1, ActivationStyle::Regular);
858        layer_state.activate(2, ActivationStyle::Regular);
859        layer_state.activate(4, ActivationStyle::Regular);
860        let actual_active_layers: Vec<LayerIndex> = layer_state.active_layers().collect();
861        let expected_active_layers: Vec<LayerIndex> = vec![4, 2, 1];
862
863        assert_eq!(expected_active_layers, actual_active_layers);
864    }
865
866    #[test]
867    fn test_pressing_toggle_modifier_key_emits_event_layer_toggled() {
868        // Assemble
869        let layer = 1;
870        let key = ModifierKey::Toggle(layer);
871
872        // Act
873        let (_pressed_key, layer_event) = key.new_pressed_key();
874
875        // Assert
876        assert_eq!(Some(LayerEvent::Toggled(layer)), layer_event);
877    }
878}
smart_keymap/key/layered.rs

smart_keymap/key/
layered.rs
