smart_keymap/key/composite/
layered.rsuse core::fmt::Debug;
#[cfg(feature = "std")]
use serde::Deserialize;
use crate::{input, key};
use super::BaseKey;
use super::{Context, Event};
use super::{TapHold, TapHoldKey, TapHoldNestable, TapHoldPressedKey};
use key::PressedKey as _;
pub trait LayeredNestable:
key::Key<Context = Context, Event = Event, PressedKey = TapHoldPressedKey<BaseKey>>
+ Copy
+ PartialEq
{
fn as_fat_key(self) -> TapHoldKey<BaseKey>;
}
impl<K: TapHoldNestable> LayeredNestable for TapHold<K> {
fn as_fat_key(self) -> TapHoldKey<BaseKey> {
TapHold::as_fat_key(self)
}
}
impl<K: TapHoldNestable> LayeredNestable for TapHoldKey<K> {
fn as_fat_key(self) -> TapHoldKey<BaseKey> {
TapHoldKey::as_fat_key(self)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "std", derive(Deserialize))]
#[cfg_attr(feature = "std", serde(untagged))]
pub enum LayeredKey<K: LayeredNestable> {
Layered(key::layered::LayeredKey<K>),
Pass(K),
}
impl<K: LayeredNestable> LayeredKey<K> {
pub fn as_fat_key(self) -> LayeredKey<TapHoldKey<BaseKey>> {
match self {
LayeredKey::Layered(key) => LayeredKey::Layered(key.map_key(|k| k.as_fat_key())),
LayeredKey::Pass(key) => LayeredKey::Pass(key.as_fat_key()),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Layered<K: LayeredNestable>(pub K);
impl<K: LayeredNestable> Layered<K> {
pub fn as_fat_key(self) -> LayeredKey<TapHoldKey<BaseKey>> {
let Layered(key) = self;
LayeredKey::Pass(key.as_fat_key())
}
}
impl<K: LayeredNestable> key::Key for LayeredKey<K> {
type Context = Context;
type Event = Event;
type PressedKey = LayeredPressedKey<TapHoldKey<BaseKey>>;
fn new_pressed_key(
&self,
context: Self::Context,
keymap_index: u16,
) -> (Self::PressedKey, key::PressedKeyEvents<Self::Event>) {
match self {
LayeredKey::Layered(key) => {
let (layered_pk, pke) = key.new_pressed_key(context.into(), keymap_index);
let pk = input::PressedKey {
key: LayeredKey::Pass(layered_pk.key),
keymap_index,
pressed_key_state: LayeredPressedKeyState::<TapHoldKey<BaseKey>>(layered_pk),
};
(pk, pke)
}
LayeredKey::Pass(key) => {
let (passthrough_pk, pke) = key.new_pressed_key(context.into(), keymap_index);
let pk = input::PressedKey {
key: LayeredKey::Pass(passthrough_pk.key),
keymap_index,
pressed_key_state: LayeredPressedKeyState::<TapHoldKey<BaseKey>>(
passthrough_pk,
),
};
(pk, pke)
}
}
}
}
impl<K: LayeredNestable> key::Key for Layered<K> {
type Context = Context;
type Event = Event;
type PressedKey = LayeredPressedKey<TapHoldKey<BaseKey>>;
fn new_pressed_key(
&self,
context: Self::Context,
keymap_index: u16,
) -> (Self::PressedKey, key::PressedKeyEvents<Self::Event>) {
let Layered(key) = self;
let (passthrough_pk, pke) = <K as key::Key>::new_pressed_key(key, context, keymap_index);
let pk = input::PressedKey {
key: LayeredKey::Pass(passthrough_pk.key),
keymap_index,
pressed_key_state: LayeredPressedKeyState::<TapHoldKey<BaseKey>>(passthrough_pk),
};
(pk, pke)
}
}
impl LayeredKey<TapHoldKey<BaseKey>> {
pub const fn keyboard(key: key::keyboard::Key) -> Self {
Self::Pass(TapHoldKey::keyboard(key))
}
pub const fn tap_hold(key: key::tap_hold::Key<BaseKey>) -> Self {
Self::Pass(TapHoldKey::tap_hold(key))
}
pub const fn layer_modifier(key: key::layered::ModifierKey) -> Self {
Self::Pass(TapHoldKey::layer_modifier(key))
}
}
impl<K: LayeredNestable> LayeredKey<K> {
pub const fn layered(key: key::layered::LayeredKey<K>) -> Self {
Self::Layered(key)
}
}
impl Layered<TapHold<key::keyboard::Key>> {
pub const fn keyboard(key: key::keyboard::Key) -> Self {
Self(TapHold(key))
}
}
impl Layered<TapHoldKey<key::keyboard::Key>> {
pub const fn tap_hold(key: key::tap_hold::Key<key::keyboard::Key>) -> Self {
Self(TapHoldKey::TapHold(key))
}
}
#[derive(Debug, PartialEq)]
pub struct LayeredPressedKeyState<K: LayeredNestable>(K::PressedKey);
pub type LayeredPressedKey<K> = input::PressedKey<LayeredKey<K>, LayeredPressedKeyState<K>>;
impl<K: Copy + Into<LayeredKey<NK>>, NK: LayeredNestable> key::PressedKeyState<K>
for LayeredPressedKeyState<NK>
{
type Context = Context;
type Event = Event;
fn handle_event_for(
&mut self,
context: Context,
_keymap_index: u16,
_key: &K,
event: key::Event<Event>,
) -> key::PressedKeyEvents<Event> {
let LayeredPressedKeyState(pk) = self;
pk.handle_event(context, event)
}
fn key_output(&self, _key: &K) -> key::KeyOutputState {
let LayeredPressedKeyState(pk) = self;
pk.key_output()
}
}