Struct KeyPress 

pub struct KeyPress {
    pub code: KeyCode,
    pub mods: KeyModifiers,
}

Represents a specific key press, combining a KeyCode and KeyModifiers.

This provides a structured, type-safe way to define key combinations that can be used throughout the application for consistent key handling.

Examples

use bubbletea_widgets::key::KeyPress;
use crossterm::event::{KeyCode, KeyModifiers};

// Create a Ctrl+C key press
let ctrl_c = KeyPress {
    code: KeyCode::Char('c'),
    mods: KeyModifiers::CONTROL,
};

// Create from tuple
let alt_f4: KeyPress = (KeyCode::F(4), KeyModifiers::ALT).into();

// Create from string
let escape: KeyPress = "esc".into();

Fields

code: KeyCode

The key code representing the physical key pressed.

mods: KeyModifiers

The modifier keys (Ctrl, Alt, Shift) held during the key press.

Trait Implementations

impl Clone for KeyPress

fn clone(&self) -> KeyPress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyPress

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

Formats the value using the given formatter.

impl From<&str> for KeyPress

Creates a KeyPress from a string representation.

This provides a human-readable way to define key combinations using string names. Supports both simple keys and modifier combinations.

Supported Formats

• Simple keys: “enter”, “tab”, “esc”, “space”, “up”, “down”, etc.
• Function keys: “f1”, “f2”, …, “f12”
• Single characters: “a”, “1”, “?”, “/”
• Modifier combinations: “ctrl+c”, “alt+f4”, “shift+tab”
• Complex combinations: “ctrl+alt+a”

Examples

use bubbletea_widgets::key::KeyPress;

let enter: KeyPress = "enter".into();
let ctrl_c: KeyPress = "ctrl+c".into();
let alt_f4: KeyPress = "alt+f4".into();
let page_up: KeyPress = "pgup".into();

Panics

This function does not panic. Unknown key combinations will result in a KeyPress with KeyCode::Null.

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<(KeyCode, KeyModifiers)> for KeyPress

Creates a KeyPress from a tuple of (KeyCode, KeyModifiers).

This provides a convenient way to create key press instances from tuples, making it easy to define key combinations inline.

Examples

use bubbletea_widgets::key::KeyPress;
use crossterm::event::{KeyCode, KeyModifiers};

let save_key: KeyPress = (KeyCode::Char('s'), KeyModifiers::CONTROL).into();
let quit_key: KeyPress = (KeyCode::Char('q'), KeyModifiers::CONTROL).into();

fn from((code, mods): (KeyCode, KeyModifiers)) -> Self

Converts to this type from the input type.

impl From<KeyCode> for KeyPress

Creates a KeyPress from just a KeyCode with no modifiers.

This is useful for simple keys that don’t require modifier combinations, such as arrow keys, function keys, or single character keys.

Examples

use bubbletea_widgets::key::KeyPress;
use crossterm::event::KeyCode;

let enter_key: KeyPress = KeyCode::Enter.into();
let up_arrow: KeyPress = KeyCode::Up.into();
let letter_a: KeyPress = KeyCode::Char('a').into();

fn from(code: KeyCode) -> Self

Converts to this type from the input type.

impl PartialEq for KeyPress

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for KeyPress

impl StructuralPartialEq for KeyPress