Struct KeyChord 

pub struct KeyChord {
    pub key: KeyKind,
    pub mods: KeyMods,
}

Canonical, stack-allocated representation of one chord.

Copy so call sites can pass it freely without lifetime gymnastics; Hash + Eq so it works as a HashMap key in the keymap trie. Memory: 8 bytes (1-byte mod bitfield + 1-byte discriminant + a 4-byte char or 1-byte SpecialKey, padded).

Parse one chord with str::parse (FromStr), a sequence with parse_chord_sequence; Display writes the canonical notation.

Examples

use lattice_protocol::{ChordParseError, KeyChord, KeyKind, KeyMods, SpecialKey};

let chord: KeyChord = "<C-S-Tab>".parse().unwrap();
assert_eq!(chord.key, KeyKind::Special(SpecialKey::Tab));
assert_eq!(chord.mods, KeyMods::CTRL | KeyMods::SHIFT);
assert_eq!(chord.to_string(), "<C-S-Tab>");

// `<` and a bare space are escaped when printed.
assert_eq!(KeyChord::char('<').to_string(), "<lt>");
assert_eq!(KeyChord::char(' ').to_string(), "<Space>");

// `FromStr` wants exactly one chord.
assert!(matches!("ab".parse::<KeyChord>(), Err(ChordParseError::BodyTooLong { .. })));

Fields

key: KeyKind

Which key was pressed.

mods: KeyMods

Modifiers held with it. For a letter, Shift is encoded in the case of KeyKind::Char instead, so this carries no SHIFT bit.

Implementations

impl KeyChord

pub const fn new(key: KeyKind, mods: KeyMods) -> KeyChord

Build directly from kind + mods. Useful for tests + internal callers; production callers go through the renderer-specific adapter (lattice_ui_tui::chord::from_event for the TUI, the analogous function in the future GPUI adapter).

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

Plain printable character with no modifiers.

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

Ctrl-modified character. Letter case is normalised by the caller; convention is lowercase (<C-c>, not <C-C>).

pub const fn special(k: SpecialKey) -> KeyChord

Special key with no modifiers.

Trait Implementations

impl Clone for KeyChord

fn clone(&self) -> KeyChord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for KeyChord

impl Debug for KeyChord

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

Formats the value using the given formatter.

impl Display for KeyChord

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

Formats the value using the given formatter.

impl Eq for KeyChord

impl FromStr for KeyChord

type Err = ChordParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<KeyChord, <KeyChord as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for KeyChord

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

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for KeyChord

impl WitBoundary for KeyChord

type Wit = KeyChord

The generated WIT mirror type.

fn to_wit(&self) -> Result<KeyChord, String>

Project the native value into its owned WIT mirror.

fn from_wit(wit: KeyChord) -> Result<KeyChord, String>

Reconstruct the native value from its WIT mirror.