Struct Key 

pub struct Key {
    pub code: KeyCode,
    pub modifiers: Modifiers,
    /* private fields */
}

A key press.

Two keys are equal when their code and modifiers are. How the terminal reported one changes only which bindings it matches: a terminal without the kitty keyboard protocol (a legacy terminal) sends one byte for Tab and for Ctrl+I, so its Tab could be either key, while a key marked exact is only itself.

Fields

code: KeyCode

modifiers: Modifiers

Implementations

impl Key

pub const fn new(code: KeyCode) -> Key

pub const fn with(code: KeyCode, modifiers: Modifiers) -> Key

A key and the modifiers held with it.

pub const fn ctrl(c: char) -> Key

pub const fn char(c: char) -> Key

pub fn parse(text: &str) -> Option<Key>

Parse a key name such as enter, ctrl+c, shift+tab, pagedown, f5 or a single character. Case does not matter for names. The comma key is , or comma (ctrl+comma), the name a list of key names can hold without quotes; the other punctuation keys have names too, for where the character is awkward (a key list, a TOML string, ctrl+minus): see punctuation. A key named so is the character, and shows as it (equals is =).

A name means the key: ctrl+i is Ctrl+I, not Tab, although a legacy terminal sends the two alike; matches is what lets a Tab from such a terminal fire a ctrl+i binding.

pub const fn exact(self) -> Key

This key as a terminal that tells every key apart reports it (the kitty keyboard protocol): it matches a binding for itself only. A Session with the protocol on reads keys so, and a test marks them to stand for such a terminal.

pub const fn is_exact(&self) -> bool

Whether the key came from a terminal that tells every key apart.

pub fn legacy(self) -> Key

This key as a legacy terminal sends it: Ctrl+I arrives as Tab, Ctrl+M as Enter, Ctrl+[ as Esc, Ctrl+\ ] ^ _ as Ctrl+4 to 7, Ctrl+@ as Ctrl+Space, and Ctrl+Shift with a letter as Ctrl and the letter. Any other key arrives as itself. The result is not exact.

pub fn matches(&self, binding: &Key) -> bool

Whether this key, as read, fires a binding for binding. A key fires a binding for itself. One from a legacy terminal also fires a binding for any key that terminal sends alike (see legacy): its Tab fires tab or ctrl+i; and its Ctrl+H, which some terminals send for Backspace, fires ctrl+h or backspace. An exact key fires only its own.

pub fn matches_any<'a>( &self, bindings: impl IntoIterator<Item = &'a Key>, ) -> bool

Whether this key fires a binding for any of bindings.

pub fn pick<'a>( &self, sets: impl IntoIterator<Item = &'a [Key]>, ) -> Option<usize>

Which of sets (each the keys of one binding) this key fires: the first that has it exactly, else the first it matches. A Tab from a legacy terminal picks a tab binding over an earlier ctrl+i one.

pub fn is_interrupt(&self) -> bool

Ctrl+C: the event loop ends every component with Outcome::Interrupted on it.

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

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

Formats the value using the given formatter.

impl Eq for Key

impl From<Key> for Event

fn from(key: Key) -> Event

Converts to this type from the input type.

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: &Key) -> bool

Equality operator ==.

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

Inequality operator !=.