Enum KeyCode

pub enum KeyCode {
    Escape,
    Back,
    Backtick,
    Key0,
    Key1,
    Key2,
    Key3,
    Key4,
    Key5,
    Key6,
    Key7,
    Key8,
    Key9,
    Minus,
    Equals,
    Backspace,
    Tab,
    KeyQ,
    KeyW,
    KeyE,
    KeyR,
    KeyT,
    KeyY,
    KeyU,
    KeyI,
    KeyO,
    KeyP,
    LBracket,
    RBracket,
    ReturnKey,
    KeyA,
    KeyS,
    KeyD,
    KeyF,
    KeyG,
    KeyH,
    KeyJ,
    KeyK,
    KeyL,
    Semicolon,
    Quote,
    Backslash,
    KeyZ,
    KeyX,
    KeyC,
    KeyV,
    KeyB,
    KeyN,
    KeyM,
    Comma,
    Period,
    Slash,
    Control,
    Alt,
    Shift,
    Logo,
    Space,
    Capslock,
    F1,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    PrintScreen,
    ScrollLock,
    Pause,
    Insert,
    Delete,
    Home,
    End,
    PageUp,
    PageDown,
    Numpad0,
    Numpad1,
    Numpad2,
    Numpad3,
    Numpad4,
    Numpad5,
    Numpad6,
    Numpad7,
    Numpad8,
    Numpad9,
    NumpadEquals,
    NumpadSubtract,
    NumpadAdd,
    NumpadDecimal,
    NumpadMultiply,
    NumpadDivide,
    Numlock,
    NumpadEnter,
    ArrowUp,
    ArrowDown,
    ArrowLeft,
    ArrowRight,
    Unknown,
}

Variants

Escape

Back

Backtick

Key0

Key1

Key2

Key3

Key4

Key5

Key6

Key7

Key8

Key9

Minus

Equals

Backspace

Tab

KeyQ

KeyW

KeyE

KeyR

KeyT

KeyY

KeyU

KeyI

KeyO

KeyP

LBracket

RBracket

ReturnKey

KeyA

KeyS

KeyD

KeyF

KeyG

KeyH

KeyJ

KeyK

KeyL

Semicolon

Quote

Backslash

KeyZ

KeyX

KeyC

KeyV

KeyB

KeyN

KeyM

Comma

Period

Slash

Control

Alt

Shift

Logo

Space

Capslock

F1

F2

F3

F4

F5

F6

F7

F8

F9

F10

F11

F12

PrintScreen

ScrollLock

Pause

Insert

Delete

Home

End

PageUp

PageDown

Numpad0

Numpad1

Numpad2

Numpad3

Numpad4

Numpad5

Numpad6

Numpad7

Numpad8

Numpad9

NumpadEquals

NumpadSubtract

NumpadAdd

NumpadDecimal

NumpadMultiply

NumpadDivide

Numlock

NumpadEnter

ArrowUp

ArrowDown

ArrowLeft

ArrowRight

Unknown

Implementations

impl KeyCode

pub fn is_unknown(&self) -> bool

pub fn to_char(&self, uc: bool) -> Option<char>

Trait Implementations

impl Clone for KeyCode

fn clone(&self) -> KeyCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DeBin for KeyCode

fn de_bin(o: &mut usize, d: &[u8]) -> Result<KeyCode, DeBinErr>

fn deserialize_bin(d: &[u8]) -> Result<Self, DeBinErr>

impl DeJson for KeyCode

fn de_json(s: &mut DeJsonState, i: &mut Chars<'_>) -> Result<KeyCode, DeJsonErr>

fn deserialize_json(input: &str) -> Result<Self, DeJsonErr>

impl Debug for KeyCode

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

Formats the value using the given formatter.

impl Default for KeyCode

fn default() -> KeyCode

Returns the “default value” for a type.

impl LiveApply for KeyCode

fn apply( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, start_index: usize, nodes: &[LiveNode], ) -> usize

fn apply_over(&mut self, cx: &mut Cx, nodes: &[LiveNode])

impl LiveHook for KeyCode

fn apply_value_unknown( &mut self, cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

fn skip_apply_animator( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], ) -> bool

fn apply_value_instance( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

fn skip_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], ) -> Option<usize>

fn before_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], )

fn after_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], )

fn after_apply_from(&mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>)

fn after_new_from_doc(&mut self, _cx: &mut Cx)

fn after_update_from_doc(&mut self, _cx: &mut Cx)

fn after_apply_from_doc(&mut self, _cx: &mut Cx)

fn after_new_before_apply(&mut self, _cx: &mut Cx)

impl LiveNew for KeyCode

fn new(cx: &mut Cx) -> KeyCode

fn live_type_info(cx: &mut Cx) -> LiveTypeInfo

fn live_design_with(cx: &mut Cx)

fn new_apply( cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> Self

where Self: Sized,

fn new_apply_over(cx: &mut Cx, nodes: &[LiveNode]) -> Self

where Self: Sized,

fn new_apply_mut_index( cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: &mut usize, nodes: &[LiveNode], ) -> Self

where Self: Sized,

fn new_from_ptr(cx: &mut Cx, live_ptr: Option<LivePtr>) -> Self

where Self: Sized,

fn update_from_ptr(&mut self, cx: &mut Cx, live_ptr: Option<LivePtr>)

fn update_from_ptr_with_scope( &mut self, cx: &mut Cx, live_ptr: Option<LivePtr>, scope: &mut Scope<'_, '_>, )

fn new_from_ptr_with_scope( cx: &mut Cx, live_ptr: Option<LivePtr>, scope: &mut Scope<'_, '_>, ) -> Self

where Self: Sized,

fn new_main(cx: &mut Cx) -> Option<Self>

where Self: Sized,

fn register_main_module(cx: &mut Cx)

fn update_main(&mut self, cx: &mut Cx)

fn new_local(cx: &mut Cx) -> Self

where Self: Sized,

fn new_from_module( cx: &mut Cx, module_id: LiveModuleId, id: LiveId, ) -> Option<Self>

where Self: Sized,

fn update_from_module( &mut self, cx: &mut Cx, module_id: LiveModuleId, id: LiveId, )

impl PartialEq for KeyCode

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

fn ser_bin(&self, s: &mut Vec<u8>)

fn serialize_bin(&self) -> Vec<u8>

impl SerJson for KeyCode

fn ser_json(&self, d: usize, s: &mut SerJsonState)

fn serialize_json(&self) -> String

impl Copy for KeyCode

impl Eq for KeyCode

impl StructuralPartialEq for KeyCode