Enum rust_raylib::ffi::KeyboardKey

#[repr(C)]
pub enum KeyboardKey {
    Null,
    Apostrophe,
    Comma,
    Minus,
    Period,
    Slash,
    Zero,
    One,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Semicolon,
    Equal,
    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,
    LeftBracket,
    Backslash,
    RightBracket,
    Grave,
    Space,
    Escape,
    Enter,
    Tab,
    Backspace,
    Insert,
    Delete,
    Right,
    Left,
    Down,
    Up,
    PageUp,
    PageDown,
    Home,
    End,
    CapsLock,
    ScrollLock,
    NumLock,
    PrintScreen,
    Pause,
    F1,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    LeftShift,
    LeftControl,
    LeftAlt,
    LeftSuper,
    RightShift,
    RightControl,
    RightAlt,
    RightSuper,
    KbMenu,
    Kp0,
    Kp1,
    Kp2,
    Kp3,
    Kp4,
    Kp5,
    Kp6,
    Kp7,
    Kp8,
    Kp9,
    KpDecimal,
    KpDivide,
    KpMultiply,
    KpSubtract,
    KpAdd,
    KpEnter,
    KpEqual,
    Back,
    VolumeUp,
    VolumeDown,
}

Keyboard keys (US keyboard layout)

Variants

Null

Key: NULL, used for no key pressed

Apostrophe

Key: ’

Comma

Key: ,

Minus

Key: -

Period

Key: .

Slash

Key: /

Zero

Key: 0

One

Key: 1

Two

Key: 2

Three

Key: 3

Four

Key: 4

Five

Key: 5

Six

Key: 6

Seven

Key: 7

Eight

Key: 8

Nine

Key: 9

Semicolon

Key: ;

Equal

Key: =

A

Key: A | a

B

Key: B | b

C

Key: C | c

D

Key: D | d

E

Key: E | e

F

Key: F | f

G

Key: G | g

H

Key: H | h

I

Key: I | i

J

Key: J | j

K

Key: K | k

L

Key: L | l

M

Key: M | m

N

Key: N | n

O

Key: O | o

P

Key: P | p

Q

Key: Q | q

R

Key: R | r

S

Key: S | s

T

Key: T | t

U

Key: U | u

V

Key: V | v

W

Key: W | w

X

Key: X | x

Y

Key: Y | y

Z

Key: Z | z

LeftBracket

Key: [

Backslash

Key: ’'

RightBracket

Key: ]

Grave

Key: `

Space

Key: Space

Escape

Key: Esc

Enter

Key: Enter

Tab

Key: Tab

Backspace

Key: Backspace

Insert

Key: Ins

Delete

Key: Del

Right

Key: Cursor right

Left

Key: Cursor left

Down

Key: Cursor down

Up

Key: Cursor up

PageUp

Key: Page up

PageDown

Key: Page down

Home

Key: Home

End

Key: End

CapsLock

Key: Caps lock

ScrollLock

Key: Scroll down

NumLock

Key: Num lock

PrintScreen

Key: Print screen

Pause

Key: Pause

F1

Key: F1

F2

Key: F2

F3

Key: F3

F4

Key: F4

F5

Key: F5

F6

Key: F6

F7

Key: F7

F8

Key: F8

F9

Key: F9

F10

Key: F10

F11

Key: F11

F12

Key: F12

LeftShift

Key: Shift left

LeftControl

Key: Control left

LeftAlt

Key: Alt left

LeftSuper

Key: Super left

RightShift

Key: Shift right

RightControl

Key: Control right

RightAlt

Key: Alt right

RightSuper

Key: Super right

KbMenu

Key: KB menu

Kp0

Key: Keypad 0

Kp1

Key: Keypad 1

Kp2

Key: Keypad 2

Kp3

Key: Keypad 3

Kp4

Key: Keypad 4

Kp5

Key: Keypad 5

Kp6

Key: Keypad 6

Kp7

Key: Keypad 7

Kp8

Key: Keypad 8

Kp9

Key: Keypad 9

KpDecimal

Key: Keypad .

KpDivide

Key: Keypad /

KpMultiply

Key: Keypad *

KpSubtract

Key: Keypad -

KpAdd

Key: Keypad +

KpEnter

Key: Keypad Enter

KpEqual

Key: Keypad =

Back

Key: Android back button

VolumeUp

Key: Android volume up button

VolumeDown

Key: Android volume down button

Trait Implementations

impl Clone for KeyboardKey

fn clone(&self) -> KeyboardKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyboardKey

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

Formats the value using the given formatter.

impl Hash for KeyboardKey

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

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<KeyboardKey> for KeyboardKey

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

impl Eq for KeyboardKey

impl StructuralEq for KeyboardKey

impl StructuralPartialEq for KeyboardKey