Enum ModifierKey

pub enum ModifierKey {
    Hold(LayerIndex),
    SetActiveLayers(LayerBitset),
    Default(LayerIndex),
}

Modifier layer key affects what layers are active.

Variants

Hold(LayerIndex)

Activates the given layer when the held.

SetActiveLayers(LayerBitset)

Sets the set of active layers to the given layers when the key is pressed.

Default(LayerIndex)

Sets the default layer.

Implementations

impl ModifierKey

pub const fn hold(layer: LayerIndex) -> Self

Create a new ModifierKey that activates the given layer when held.

pub const fn set_active_layers(layers: &[LayerIndex]) -> Self

Create a new ModifierKey that sets the active layers to the given slice of layers when pressed.

Each LayerIndex in the slice must be less than MAX_BITSET_LAYER.

pub const fn set_active_layers_from_bitset(bitset: LayerBitset) -> Self

Create a new ModifierKey that sets the active layers bitset.

pub const fn default(layer: LayerIndex) -> Self

Create a new ModifierKey that sets the default layer.

pub fn new_pressed_key(&self) -> (ModifierKeyState, LayerEvent)

Create a new input::PressedKey and key::ScheduledEvent for the given keymap index.

Pressing a ModifierKey::Hold emits a LayerEvent::LayerActivated event.

Trait Implementations

impl Clone for ModifierKey

fn clone(&self) -> ModifierKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModifierKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModifierKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ModifierKey> for BaseKey

fn from(key: ModifierKey) -> Self

Converts to this type from the input type.

impl Key for ModifierKey

type Context = Context

The associated Context is used to provide state that may affect behaviour when pressing the key. (e.g. the behaviour of layered::LayeredKey depends on which layers are active in layered::Context).

type Event = Event

The associated Event is to be handled by the associated Context, pending key states, and key states.

type PendingKeyState = PendingKeyState

Associated pending key state.

type KeyState = KeyState

Associated key state type.

fn new_pressed_key( &self, _context: &Self::Context, key_path: KeyPath, ) -> (PressedKeyResult<Self::PendingKeyState, Self::KeyState>, KeyEvents<Self::Event>)

Key::new_pressed_key produces a pressed key value, and may yield some ScheduledEvents. (e.g. tap_hold::Key schedules a tap_hold::Event::TapHoldTimeout so that holding the key resolves as a hold).

fn handle_event( &self, _pending_state: &mut Self::PendingKeyState, _context: &Self::Context, _key_path: KeyPath, _event: Event<Self::Event>, ) -> (Option<NewPressedKey>, KeyEvents<Self::Event>)

Update the given pending key state with the given impl.

fn lookup( &self, _path: &[u16], ) -> &dyn Key<Context = Self::Context, Event = Self::Event, PendingKeyState = Self::PendingKeyState, KeyState = Self::KeyState>

Return a reference to the key for the given path.

impl PartialEq for ModifierKey

fn eq(&self, other: &ModifierKey) -> 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 Copy for ModifierKey

impl StructuralPartialEq for ModifierKey

impl TapHoldNestable for ModifierKey