Struct KeyInput

pub struct KeyInput { /* private fields */ }

Single key input by pressing a key and modifiers.

This struct is equivalent to a key combination in the syntax document such as “Ctrl+x”.

Implementations

impl KeyInput

pub fn new<K, M>(key: K, mods: M) -> Self

where K: Into<Key>, M: Into<Mods>,

Create a new KeyInput instance with checking the Shift modifier restriction described in the syntax document.

use keybinds::{KeyInput, Key, Mods};

let k = KeyInput::new('x', Mods::CTRL);
assert_eq!(k.key(), Key::Char('x'));
assert_eq!(k.mods(), Mods::CTRL);

let k = KeyInput::new(Key::Enter, Mods::MOD);
assert_eq!(k.key(), Key::Enter);
assert_eq!(k.mods(), Mods::MOD);

// Shift modifier is removed when it is not used with named keys following the restriction.
let k = KeyInput::new('x', Mods::SHIFT | Mods::CTRL);
assert_eq!(k.key(), Key::Char('x'));
assert_eq!(k.mods(), Mods::CTRL);

// You need to use the following instead.
let k = KeyInput::new('X', Mods::CTRL);
assert_eq!(k.key(), Key::Char('X'));
assert_eq!(k.mods(), Mods::CTRL);

pub fn key(&self) -> Key

Return the Key of the input.

Examples found in repository

examples/vim.rs (line 401)

    fn convert_key_input(&self, input: KeyInput) -> Option<Input> {
        if self.mode != Mode::Insert {
            return None;
        }

        let key = match input.key() {
            keybinds::Key::Char(c) => Key::Char(c),
            keybinds::Key::Copy => Key::Copy,
            keybinds::Key::Cut => Key::Cut,
            keybinds::Key::Paste => Key::Paste,
            keybinds::Key::Backspace => Key::Backspace,
            keybinds::Key::Delete => Key::Delete,
            keybinds::Key::Enter => Key::Enter,
            keybinds::Key::Up => Key::Up,
            keybinds::Key::Right => Key::Right,
            keybinds::Key::Down => Key::Down,
            keybinds::Key::Left => Key::Left,
            keybinds::Key::Home => Key::Home,
            keybinds::Key::End => Key::End,
            keybinds::Key::PageUp => Key::PageUp,
            keybinds::Key::PageDown => Key::PageDown,
            keybinds::Key::Tab => Key::Tab,
            _ => return None,
        };

        let mods = input.mods();
        Some(Input {
            key,
            ctrl: mods.contains(Mods::CTRL),
            alt: mods.contains(Mods::ALT),
            shift: mods.contains(Mods::SHIFT),
        })
    }

examples/winit.rs (line 52)

    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
        // Convert the window event into key input
        let input = self.converter.convert(&event);
        if input.key() != Key::Ignored {
            println!("Key input: {input:?}");
        }

        // Check if the converted key input dispatches some action
        if let Some(action) = self.keybinds.dispatch(input) {
            println!("Action: {action:?}");

            match action {
                Action::SayHi => println!("Hi!"),
                Action::ToggleMaximized => {
                    let window = self.window.as_ref().unwrap();
                    window.set_maximized(!window.is_maximized());
                }
                Action::ToggleTheme => {
                    let window = self.window.as_ref().unwrap();
                    let theme = match window.theme() {
                        Some(Theme::Dark) => Theme::Light,
                        _ => Theme::Dark,
                    };
                    window.set_theme(Some(theme));
                }
                Action::Exit => event_loop.exit(),
            }
        }

        if let WindowEvent::CloseRequested = event {
            event_loop.exit();
        }
    }

examples/iced.rs (line 67)

    fn update(&mut self, message: Message) -> Task<Message> {
        match message {
            Message::WindowOpen(id) => self.window_id = id,
            Message::KeyEvent(event) => {
                let input = KeyInput::from(&event);
                if input.key() != Key::Ignored {
                    println!("Key input: {input:?}");
                    if !self.keybinds.is_ongoing() {
                        self.last_action.clear();
                        self.ongoing_input.clear();
                    }
                    if !self.ongoing_input.is_empty() {
                        self.ongoing_input.push_str(" → ");
                    }
                    write!(self.ongoing_input, "{input:}").unwrap();
                }

                if let Some(action) = self.keybinds.dispatch(event) {
                    self.last_action = format!("{action:?}");

                    // Handle the dispatched action
                    match action {
                        Action::SayHello => println!("Hello!"),
                        Action::ToggleMaximize => {
                            self.maximized = !self.maximized;
                            return window::maximize(self.window_id, self.maximized);
                        }
                        Action::ToggleTheme => {
                            self.theme = match self.theme {
                                Theme::Dark => Theme::Light,
                                _ => Theme::Dark,
                            };
                        }
                        Action::Exit => return iced::exit(),
                    }
                }
            }
            Message::Reset => {
                self.keybinds.reset();
                self.ongoing_input.clear();
                self.last_action.clear();
            }
        }
        Task::none()
    }

pub fn mods(&self) -> Mods

Return the Mods of the input.

Examples found in repository

examples/vim.rs (line 421)

    fn convert_key_input(&self, input: KeyInput) -> Option<Input> {
        if self.mode != Mode::Insert {
            return None;
        }

        let key = match input.key() {
            keybinds::Key::Char(c) => Key::Char(c),
            keybinds::Key::Copy => Key::Copy,
            keybinds::Key::Cut => Key::Cut,
            keybinds::Key::Paste => Key::Paste,
            keybinds::Key::Backspace => Key::Backspace,
            keybinds::Key::Delete => Key::Delete,
            keybinds::Key::Enter => Key::Enter,
            keybinds::Key::Up => Key::Up,
            keybinds::Key::Right => Key::Right,
            keybinds::Key::Down => Key::Down,
            keybinds::Key::Left => Key::Left,
            keybinds::Key::Home => Key::Home,
            keybinds::Key::End => Key::End,
            keybinds::Key::PageUp => Key::PageUp,
            keybinds::Key::PageDown => Key::PageDown,
            keybinds::Key::Tab => Key::Tab,
            _ => return None,
        };

        let mods = input.mods();
        Some(Input {
            key,
            ctrl: mods.contains(Mods::CTRL),
            alt: mods.contains(Mods::ALT),
            shift: mods.contains(Mods::SHIFT),
        })
    }

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for KeyInput

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for KeyInput

fn clone(&self) -> KeyInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyInput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyInput

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for KeyInput

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

Generate a string representation of the key input following the syntax.

use keybinds::{Key, Mods, KeyInput};

assert_eq!(format!("{}", KeyInput::new('x', Mods::CTRL)), "Ctrl+x");
assert_eq!(
    format!("{}", KeyInput::new(Key::Enter, Mods::SHIFT | Mods::ALT)),
    "Alt+Shift+Enter",
);

impl From<&Event> for KeyInput

Available on crate feature crossterm only.

fn from(event: &Event) -> Self

Convert crossterm’s events to KeyInput. Events unrelated to key presses are converted into Key::Ignored with no modifiers.

impl From<&Event> for KeyInput

Available on crate feature iced only.

fn from(event: &KeyEvent) -> Self

Convert iced’s key events to KeyInput. Events except for key presses are converted into Key::Ignored with no modifiers. Note that Shift modifier is removed when the pressed key is unnamed following the syntax.

use keybinds::{KeyInput, Mods};
use iced::keyboard::{Event, Modifiers, Key};

// Key event for Ctrl+Shift+X
let event = Event::KeyPressed {
    key: Key::Character("x".into()),
    modified_key: Key::Character("X".into()),
    modifiers: Modifiers::CTRL | Modifiers::SHIFT,
    // ...
};
// `Mods::SHIFT` is removed because 'X' is already modified by Shift key
assert_eq!(KeyInput::from(event), KeyInput::new('X', Mods::CTRL));

// Events other than key presses are ignored
let event = Event::KeyReleased {
    // ...
};
assert_eq!(KeyInput::from(event), KeyInput::from(keybinds::Key::Ignored));

impl From<&Event> for KeyInput

Available on crate feature iced only.

fn from(event: &Event) -> Self

Convert iced’s events to KeyInput. Events unrelated to key presses are converted into Key::Ignored with no modifiers.

impl From<&InputEvent> for KeyInput

Available on crate feature termwiz only.

fn from(event: &InputEvent) -> Self

Converts to this type from the input type.

impl From<&KeyEvent> for KeyInput

Available on crate feature crossterm only.

fn from(event: &KeyEvent) -> Self

Convert crossterm’s key events to KeyInput. The key release events are converted into Key::Ignored with no modifiers.

impl From<&KeyEvent> for KeyInput

Available on crate feature termwiz only.

fn from(event: &KeyEvent) -> Self

Converts to this type from the input type.

impl From<Event> for KeyInput

Available on crate feature crossterm only.

fn from(event: Event) -> Self

Converts to this type from the input type.

impl From<Event> for KeyInput

Available on crate feature iced only.

fn from(event: KeyEvent) -> Self

Converts to this type from the input type.

impl From<Event> for KeyInput

Available on crate feature iced only.

fn from(event: Event) -> Self

Converts to this type from the input type.

impl From<InputEvent> for KeyInput

Available on crate feature termwiz only.

fn from(event: InputEvent) -> Self

Converts to this type from the input type.

impl<K: Into<Key>> From<K> for KeyInput

fn from(k: K) -> Self

Convert a single key with no modifiers into KeyInput.

use keybinds::{KeyInput, Mods};

assert_eq!(KeyInput::from('x'), KeyInput::new('x', Mods::NONE));

impl From<KeyEvent> for KeyInput

Available on crate feature crossterm only.

fn from(event: KeyEvent) -> Self

Converts to this type from the input type.

impl From<KeyEvent> for KeyInput

Available on crate feature termwiz only.

fn from(event: KeyEvent) -> Self

Converts to this type from the input type.

impl FromStr for KeyInput

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse the key input from str following the syntax.

use keybinds::{Key, Mods, KeyInput};

assert_eq!("a".parse(), Ok(KeyInput::new('a', Mods::NONE)));
assert_eq!("Ctrl+x".parse(), Ok(KeyInput::new('x', Mods::CTRL)));
assert_eq!("Alt+Shift+Enter".parse(), Ok(KeyInput::new(Key::Enter, Mods::ALT | Mods::SHIFT)));

assert!("".parse::<KeyInput>().is_err());
assert!("Foooo".parse::<KeyInput>().is_err());
assert!("Shift+x".parse::<KeyInput>().is_err()); // Violates Shift modifier invariant

type Err = Error

The associated error which can be returned from parsing.

impl Hash for KeyInput

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 KeyInput

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

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Copy for KeyInput

impl Eq for KeyInput

impl StructuralPartialEq for KeyInput