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    ) -> (Option<key::NewPressedKey>, key::KeyEvents<Self::Event>) {
66        match self {
67            LayeredKey::Layered(key) => key.handle_event(pending_state, context, key_path, event),
68            LayeredKey::Pass(key) => key.handle_event(pending_state, context, key_path, event),
69        }
70    }
71
72    fn lookup(
73        &self,
74        path: &[u16],
75    ) -> &dyn key::Key<
76        Context = Self::Context,
77        Event = Self::Event,
78        PendingKeyState = Self::PendingKeyState,
79        KeyState = Self::KeyState,
80    > {
81        match self {
82            LayeredKey::Layered(key) => key.lookup(path),
83            LayeredKey::Pass(key) => key.lookup(path),
84        }
85    }
86}
87
88impl<K: LayeredNestable> key::Key for Layered<K> {
89    type Context = Context;
90    type Event = Event;
91    type PendingKeyState = PendingKeyState;
92    type KeyState = KeyState;
93
94    fn new_pressed_key(
95        &self,
96        context: &Self::Context,
97        key_path: key::KeyPath,
98    ) -> (PressedKeyResult, key::KeyEvents<Self::Event>) {
99        let Layered(key) = self;
100        key.new_pressed_key(context, key_path)
101    }
102
103    fn handle_event(
104        &self,
105        pending_state: &mut Self::PendingKeyState,
106        context: &Self::Context,
107        key_path: key::KeyPath,
108        event: key::Event<Self::Event>,
109    ) -> (Option<key::NewPressedKey>, key::KeyEvents<Self::Event>) {
110        let Layered(key) = self;
111        key.handle_event(pending_state, context, key_path, event)
112    }
113
114    fn lookup(
115        &self,
116        path: &[u16],
117    ) -> &dyn key::Key<
118        Context = Self::Context,
119        Event = Self::Event,
120        PendingKeyState = Self::PendingKeyState,
121        KeyState = Self::KeyState,
122    > {
123        let Layered(key) = self;
124        key.lookup(path)
125    }
126}
127
128impl LayeredKey<TapHoldKey<BaseKey>> {
129    /// Constructs a [LayeredKey] from the given [key::keyboard::Key].
130    pub const fn keyboard(key: key::keyboard::Key) -> Self {
131        Self::Pass(TapHoldKey::keyboard(key))
132    }
133
134    /// Constructs a [LayeredKey] from the given [key::tap_hold::Key].
135    pub const fn tap_hold(key: key::tap_hold::Key<BaseKey>) -> Self {
136        Self::Pass(TapHoldKey::tap_hold(key))
137    }
138
139    /// Constructs a [LayeredKey] from the given [key::layered::ModifierKey].
140    pub const fn layer_modifier(key: key::layered::ModifierKey) -> Self {
141        Self::Pass(TapHoldKey::layer_modifier(key))
142    }
143}
144
145impl<K: LayeredNestable> LayeredKey<K> {
146    /// Constructs a [LayeredKey] from the given [key::layered::LayeredKey].
147    pub const fn layered(key: key::layered::LayeredKey<K>) -> Self {
148        Self::Layered(key)
149    }
150}
151
152impl Layered<TapHold<key::keyboard::Key>> {
153    /// Constructs a [Layered] newtype from the given key.
154    pub const fn keyboard(key: key::keyboard::Key) -> Self {
155        Self(TapHold(key))
156    }
157}
158
159impl Layered<TapHoldKey<key::keyboard::Key>> {
160    /// Constructs a [Layered] newtype from the given [key::tap_hold::Key].
161    pub const fn tap_hold(key: key::tap_hold::Key<key::keyboard::Key>) -> Self {
162        Self(TapHoldKey::TapHold(key))
163    }
164}
smart_keymap/key/composite/layered.rs

smart_keymap/key/composite/
layered.rs
