Enum KeyAction

pub enum KeyAction {
    Inherit,
    Normal(KeyCode),
    Normal2(KeyCode, KeyCode),
    TapHold(KeyCode, KeyCode),
    OneShot(KeyCode),
    TapDance(u8),
}

Represents key action.

Variants

Inherit

Inherit key definition from parent layer.

Normal(KeyCode)

Normal key

Normal2(KeyCode, KeyCode)

Normal key with secondary key. These keys are sent together.

TapHold(KeyCode, KeyCode)

Tap-Hold key (tap, hold)

If key is pressed and released in KeyResolverConfig::tap_hold, tap key is sent. If key is pressed and held longer, hold key is sent. Also, rktk-keymanager emulates qmk’s HOLD_ON_OTHER_KEY_PRESS feature. If another key is pressed while holding this key, even before tap_threshold, hold key is sent.

OneShot(KeyCode)

One-shot key

After pressing this key, the key will be sent together with the next key press.

TapDance(u8)

Tap-dance (id)

Execute tap-dance with specified id. TapDance can be configured in KeyResolverConfig.

Implementations

impl KeyAction

pub const fn const_default() -> KeyAction

Trait Implementations

impl Clone for KeyAction

fn clone(&self) -> KeyAction

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for KeyAction

fn default() -> KeyAction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KeyAction

fn deserialize<__D>( __deserializer: __D, ) -> Result<KeyAction, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Format for KeyAction

where KeyCode: Format,

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl MaxSize for KeyAction

const POSTCARD_MAX_SIZE: usize = 7usize

The maximum possible size that the serialization of this type can have, in bytes.

impl PartialEq for KeyAction

fn eq(&self, other: &KeyAction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for KeyAction

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for KeyAction

impl Eq for KeyAction

impl StructuralPartialEq for KeyAction