Struct KeyboardState 

#[repr(C)]
pub struct KeyboardState {
    pub current_virtual_keycode: OptionVirtualKeyCode,
    pub pressed_virtual_keycodes: VirtualKeyCodeVec,
    pub pressed_scancodes: ScanCodeVec,
    pub modifiers: KeyModifiers,
    pub locks: KeyLocks,
    pub is_repeat: bool,
    pub current_physical_key: OptionPhysicalKey,
}

Determines which keys are pressed currently (modifiers, etc.)

Fields

current_virtual_keycode: OptionVirtualKeyCode

Currently pressed virtual keycode - DO NOT USE THIS FOR TEXT INPUT.

For text input, use the text_input parameter in callbacks. For example entering à will fire a VirtualKeyCode::Grave, then VirtualKeyCode::A, so to correctly combine characters, the framework handles text composition internally.

pressed_virtual_keycodes: VirtualKeyCodeVec

Currently pressed virtual keycodes (READONLY) - it can happen that more than one key is pressed

This is essentially an “extension” of current_scancodes - current_keys stores the characters, but what if the pressed key is not a character (such as ArrowRight or PgUp)?

Note that this can have an overlap, so pressing “a” on the keyboard will insert both a VirtualKeyCode::A into current_virtual_keycodes and text input will be handled by the framework automatically for contenteditable nodes.

pressed_scancodes: ScanCodeVec

Same as current_virtual_keycodes, but the scancode identifies the physical key pressed, independent of the keyboard layout. The scancode does not change if the user adjusts the host’s keyboard map. Use when the physical location of the key is more important than the key’s host GUI semantics, such as for movement controls in a first-person game (German keyboard: Z key, UK keyboard: Y key, etc.)

modifiers: KeyModifiers

Which modifiers are held right now. (READONLY)

Derivable from pressed_virtual_keycodes by scanning for the six modifier keycodes, which is what every caller was doing. Carrying it directly makes the common check cheap and makes ModifiersChanged possible to emit at all.

locks: KeyLocks

Which lock keys are engaged. (READONLY)

NOT derivable from the pressed set: a lock is a toggle, so it stays on after the key is released and no key event describes it. It has to be read from the OS.

is_repeat: bool

Whether the current key event is an auto-repeat rather than a fresh press. (READONLY)

A text field wants repeats; a jump button does not, and without this the two are indistinguishable.

current_physical_key: OptionPhysicalKey

Physical position of the currently pressed key. (READONLY)

Implementations

impl KeyboardState

pub fn shift_down(&self) -> bool

pub fn ctrl_down(&self) -> bool

pub fn alt_down(&self) -> bool

pub fn super_down(&self) -> bool

pub fn primary_down(&self) -> bool

The platform’s PRIMARY shortcut modifier: Cmd (super) on macOS, Ctrl everywhere else (MWA-A2). Every standard editing shortcut (copy / cut / paste / select-all / undo / redo) keys off this — hardcoding ctrl_down() made Cmd+C/X/V/A/Z dead on macOS, where Cmd arrives as LWin/super.

pub fn is_key_down(&self, key: VirtualKeyCode) -> bool

pub fn derived_modifiers(&self) -> KeyModifiers

The modifier set implied by the keys currently held.

modifiers is a stored field because callbacks read it directly and ModifiersChanged diffs against it, but its VALUE is a pure function of the pressed set — so it must never be assigned independently, only recomputed from here.

pub fn sync_modifiers(&mut self)

Bring modifiers back in step with the pressed set.

Call this after ANY change to pressed_virtual_keycodes. Nothing did, on any backend, so modifiers sat at its default: every callback that read it saw “no modifiers held” no matter what was down, and ModifiersChanged could never fire because the diff compared two identical defaults. The derived accessors (shift_down() and friends) were right the whole time, which is why shortcuts still worked and the gap stayed invisible.

pub fn matches_accelerator(&self, chord: &[AcceleratorKey]) -> bool

Returns true iff every entry of chord is currently active in this keyboard state. Used by accelerator/keymap registrations to evaluate shortcuts like [Ctrl, Shift, Key(VirtualKeyCode::S)].

An empty chord matches trivially.

Trait Implementations

impl Clone for KeyboardState

fn clone(&self) -> KeyboardState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyboardState

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

Formats the value using the given formatter.

impl Default for KeyboardState

fn default() -> KeyboardState

Returns the “default value” for a type.

impl Eq for KeyboardState

impl PartialEq for KeyboardState

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for KeyboardState