Enum ark_api::applet::VirtualKeyCode

pub enum VirtualKeyCode {
    Key1,
    Key2,
    Key3,
    Key4,
    Key5,
    Key6,
    Key7,
    Key8,
    Key9,
    Key0,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z,
    Escape,
    Insert,
    Home,
    Delete,
    End,
    PageDown,
    PageUp,
    Left,
    Up,
    Right,
    Down,
    Back,
    Return,
    Space,
    Add,
    Apostrophe,
    Backslash,
    Colon,
    Comma,
    Divide,
    Equals,
    LAlt,
    LBracket,
    LControl,
    LShift,
    Period,
    RAlt,
    RBracket,
    RControl,
    RShift,
    Semicolon,
    Slash,
    Tab,
    LCommand,
    RCommand,
}

Symbolic name for a keyboard key

Variants

Key1

The ‘1’ key over the letters.

Key2

The ‘2’ key over the letters.

Key3

The ‘3’ key over the letters.

Key4

The ‘4’ key over the letters.

Key5

The ‘5’ key over the letters.

Key6

The ‘6’ key over the letters.

Key7

The ‘7’ key over the letters.

Key8

The ‘8’ key over the letters.

Key9

The ‘9’ key over the letters.

Key0

The ‘0’ key over the ‘O’ and ‘P’ keys.

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

Escape

The Escape key, next to F1.

Insert

Insert, next to Backspace.

Home

Delete

End

PageDown

PageUp

Left

Up

Right

Down

Back

The Backspace key, right over Enter.

Return

The Enter key.

Space

The space bar.

Add

Apostrophe

Backslash

Colon

Comma

Divide

Equals

LAlt

LBracket

LControl

LShift

Period

RAlt

RBracket

RControl

RShift

Semicolon

Slash

Tab

LCommand

On Windows and Linux, LControl/RControl input events will generate an additional LCommand/RCommand input event to avoid platform specifics.

RCommand

Trait Implementations

impl CheckedBitPattern for VirtualKeyCode

type Bits = u32

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern(
    bits: &<VirtualKeyCode as CheckedBitPattern>::Bits
) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for VirtualKeyCode

fn clone(&self) -> VirtualKeyCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VirtualKeyCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for VirtualKeyCode

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

Deserialize this value from the given Serde deserializer.

impl Hash for VirtualKeyCode

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<VirtualKeyCode> for VirtualKeyCode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a_, C_> Readable<'a_, C_> for VirtualKeyCodewhere
    C_: Context,

fn read_from<R_>(
    _reader_: &mut R_
) -> Result<VirtualKeyCode, <C_ as Context>::Error>where
    R_: Reader<'a_, C_>,

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut(
    context: &mut C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error>where
    S: Read,

fn read_from_stream_buffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error>where
    S: Read,

fn read_from_file_with_ctx(
    context: C,
    path: impl AsRef<Path>
) -> Result<Self, <C as Context>::Error>

impl Serialize for VirtualKeyCode

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 TryFrom<u32> for VirtualKeyCode

type Error = TryFromPrimitiveError<VirtualKeyCode>

The type returned in the event of a conversion error.

fn try_from(
    number: u32
) -> Result<VirtualKeyCode, TryFromPrimitiveError<VirtualKeyCode>>

Performs the conversion.

impl TryFromPrimitive for VirtualKeyCode

type Primitive = u32

const NAME: &'static str = "VirtualKeyCode"

fn try_from_primitive(
    number: <VirtualKeyCode as TryFromPrimitive>::Primitive
) -> Result<VirtualKeyCode, TryFromPrimitiveError<VirtualKeyCode>>

impl<C_> Writable<C_> for VirtualKeyCodewhere
    C_: Context,

fn write_to<T_>(&self, _writer_: &mut T_) -> Result<(), <C_ as Context>::Error>where
    T_: Writer<C_> + ?Sized,

fn write_to_buffer_with_ctx(
    &self,
    context: C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut(
    &self,
    context: &mut C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx(
    &self,
    context: C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut(
    &self,
    context: &mut C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>(
    &self,
    context: C,
    stream: S
) -> Result<(), <C as Context>::Error>where
    S: Write,

fn write_to_file_with_ctx(
    &self,
    context: C,
    path: impl AsRef<Path>
) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Copy for VirtualKeyCode

impl Eq for VirtualKeyCode

impl NoUninit for VirtualKeyCode

impl StructuralEq for VirtualKeyCode

impl StructuralPartialEq for VirtualKeyCode