smart_keymap/key/composite/
layered.rs

1use core::fmt::Debug;
2
3#[cfg(feature = "std")]
4use serde::Deserialize;
5
6use crate::key;
7
8use super::BaseKey;
9use super::{Context, Event, KeyState, PendingKeyState, PressedKeyResult};
10use super::{TapHold, TapHoldKey, TapHoldNestable};
11
12/// Trait for types which can be nested in [LayeredKey] variants.
13pub trait LayeredNestable:
14    key::Key<
15        Context = Context,
16        Event = Event,
17        KeyState = KeyState,
18        PendingKeyState = PendingKeyState,
19    > + Copy
20    + PartialEq
21{
22}
23
24impl<K: TapHoldNestable> LayeredNestable for TapHold<K> {}
25impl<K: TapHoldNestable> LayeredNestable for TapHoldKey<K> {}
26
27/// An aggregate of [key::Key] types.
28#[derive(Debug, Clone, Copy, PartialEq)]
29#[cfg_attr(feature = "std", derive(Deserialize))]
30#[cfg_attr(feature = "std", serde(untagged))]
31pub enum LayeredKey<K: LayeredNestable> {
32    /// A layered key.
33    Layered(key::layered::LayeredKey<K>),
34    /// Non-layered,
35    Pass(K),
36}
37
38/// Newtype for [LayeredNestable] keys so they can implement [key::Key].
39#[derive(Debug, Clone, Copy, PartialEq)]
40pub struct Layered<K: LayeredNestable>(pub K);
41
42impl<K: LayeredNestable> key::Key for LayeredKey<K> {
43    type Context = Context;
44    type Event = Event;
45    type PendingKeyState = PendingKeyState;
46    type KeyState = KeyState;
47
48    fn new_pressed_key(
49        &self,
50        context: &Self::Context,
51        key_path: key::KeyPath,
52    ) -> (PressedKeyResult, key::KeyEvents<Self::Event>) {
53        match self {
54            LayeredKey::Layered(key) => key.new_pressed_key(context, key_path),
55            LayeredKey::Pass(key) => key.new_pressed_key(context, key_path),
56        }
57    }
58
59    fn handle_event(
60        &self,
61        pending_state: &mut Self::PendingKeyState,
62        context: &Self::Context,
63        key_path: key::KeyPath,
64        event: key::Event<Self::Event>,
65    ) -> (
66        Option<key::PressedKeyResult<Self::PendingKeyState, Self::KeyState>>,
67        key::KeyEvents<Self::Event>,
68    ) {
69        match self {
70            LayeredKey::Layered(key) => key.handle_event(pending_state, context, key_path, event),
71            LayeredKey::Pass(key) => key.handle_event(pending_state, context, key_path, event),
72        }
73    }
74
75    fn lookup(
76        &self,
77        path: &[u16],
78    ) -> &dyn key::Key<
79        Context = Self::Context,
80        Event = Self::Event,
81        PendingKeyState = Self::PendingKeyState,
82        KeyState = Self::KeyState,
83    > {
84        match self {
85            LayeredKey::Layered(key) => key.lookup(path),
86            LayeredKey::Pass(key) => key.lookup(path),
87        }
88    }
89}
90
91impl<K: LayeredNestable> key::Key for Layered<K> {
92    type Context = Context;
93    type Event = Event;
94    type PendingKeyState = PendingKeyState;
95    type KeyState = KeyState;
96
97    fn new_pressed_key(
98        &self,
99        context: &Self::Context,
100        key_path: key::KeyPath,
101    ) -> (PressedKeyResult, key::KeyEvents<Self::Event>) {
102        let Layered(key) = self;
103        key.new_pressed_key(context, key_path)
104    }
105
106    fn handle_event(
107        &self,
108        pending_state: &mut Self::PendingKeyState,
109        context: &Self::Context,
110        key_path: key::KeyPath,
111        event: key::Event<Self::Event>,
112    ) -> (
113        Option<key::PressedKeyResult<Self::PendingKeyState, Self::KeyState>>,
114        key::KeyEvents<Self::Event>,
115    ) {
116        let Layered(key) = self;
117        key.handle_event(pending_state, context, key_path, event)
118    }
119
120    fn lookup(
121        &self,
122        path: &[u16],
123    ) -> &dyn key::Key<
124        Context = Self::Context,
125        Event = Self::Event,
126        PendingKeyState = Self::PendingKeyState,
127        KeyState = Self::KeyState,
128    > {
129        let Layered(key) = self;
130        key.lookup(path)
131    }
132}
133
134impl LayeredKey<TapHoldKey<BaseKey>> {
135    /// Constructs a [LayeredKey] from the given [key::keyboard::Key].
136    pub const fn keyboard(key: key::keyboard::Key) -> Self {
137        Self::Pass(TapHoldKey::keyboard(key))
138    }
139
140    /// Constructs a [LayeredKey] from the given [key::tap_hold::Key].
141    pub const fn tap_hold(key: key::tap_hold::Key<BaseKey>) -> Self {
142        Self::Pass(TapHoldKey::tap_hold(key))
143    }
144
145    /// Constructs a [LayeredKey] from the given [key::layered::ModifierKey].
146    pub const fn layer_modifier(key: key::layered::ModifierKey) -> Self {
147        Self::Pass(TapHoldKey::layer_modifier(key))
148    }
149}
150
151impl<K: LayeredNestable> LayeredKey<K> {
152    /// Constructs a [LayeredKey] from the given [key::layered::LayeredKey].
153    pub const fn layered(key: key::layered::LayeredKey<K>) -> Self {
154        Self::Layered(key)
155    }
156}
157
158impl Layered<TapHold<key::keyboard::Key>> {
159    /// Constructs a [Layered] newtype from the given key.
160    pub const fn keyboard(key: key::keyboard::Key) -> Self {
161        Self(TapHold(key))
162    }
163}
164
165impl Layered<TapHoldKey<key::keyboard::Key>> {
166    /// Constructs a [Layered] newtype from the given [key::tap_hold::Key].
167    pub const fn tap_hold(key: key::tap_hold::Key<key::keyboard::Key>) -> Self {
168        Self(TapHoldKey::TapHold(key))
169    }
170}
smart_keymap/key/composite/layered.rs

smart_keymap/key/composite/
layered.rs
