Enum Key 

#[non_exhaustive]
pub enum Key {
    Unknown,
    Backspace,
    Tab,
    Newline,
    Return,
    Escape,
    Space,
    PageUp,
    PageDown,
    End,
    Home,
    Left,
    Up,
    Right,
    Down,
    Insert,
    Delete,
    A,
    Y,
    Z,
    Shift,
    Control,
    Other(u16),
}

A key on a keyboard, as an event reports it.

The named variants are the keys the form layer decides on — navigation, editing, and the three accelerator letters — plus the two modifier keys a host reports as keys in their own right. Everything else is Key::Other, the arm that says “the form layer does not decide on this”.

Key::from_virtual and Key::virtual_code are the boundary with a host’s own event queue, which speaks in bare integers.

use pdfrum_form::Key;

assert_eq!(Key::from_virtual(0x09), Key::Tab);
assert_eq!(Key::Tab.virtual_code(), 0x09);
// A code the form layer does not branch on round-trips too.
assert_eq!(Key::from_virtual(0x70), Key::Other(0x70));
assert_eq!(Key::Other(0x70).virtual_code(), 0x70);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unknown

No key. Also what a selection-clearing delete is rewritten to, which is why the text field branches on it rather than ignoring it.

Backspace

Backspace.

Tab

Tab — focus traversal.

Newline

Line feed. Distinct from Key::Return, which is the carriage return a host sends for the Enter key.

Return

Carriage return — activates a widget, or commits a single-line field.

Escape

Escape — discards an in-progress edit.

Space

Space — activates a widget.

PageUp

Page up. Not handled by the edit control.

PageDown

Page down. Not handled by the edit control.

End

End of line, or of the document with the accelerator held.

Home

Start of line, or of the document with the accelerator held.

Left

Caret left.

Up

Caret up.

Right

Caret right.

Down

Caret down.

Insert

Insert. Not handled.

Delete

Forward delete.

A

The letter A — select-all with the accelerator.

Y

The letter Y — redo with the accelerator, off Apple.

Z

The letter Z — undo, or redo with shift.

Shift

The shift key reported as a key in its own right. Never consumed.

Control

The control key reported as a key in its own right. Never consumed.

Other(u16)

Any other key, by the code a host reported it under.

Never carries a code a named variant already names: Key::from_virtual is the only way one is built from an integer, and it maps the named codes first.

Implementations

impl Key

pub const fn from_virtual(code: u16) -> Key

The key a host’s virtual-key code names.

Total, and the inverse of Key::virtual_code: a code no variant names becomes Key::Other carrying it unchanged.

pub const fn virtual_code(self) -> u16

The virtual-key code this key is reported under.

The inverse of Key::from_virtual over every value that function can produce.

Trait Implementations

impl Clone for Key

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Key

impl Debug for Key

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

Formats the value using the given formatter.

impl Eq for Key

impl Hash for Key

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

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Key