Struct Keybinds

pub struct Keybinds<A> { /* private fields */ }

A dispatcher that takes key inputs and dispatches the corresponding key bindings’ actions.

The Keybinds::dispatch method dispatches an action for the given key input. The dispatcher receives key inputs as a key sequence. When the sequence matches to one of the defined key bindings, it returns the corresponding action.

When some key binding matches to a key sequence, the dispatcher dispatches the corresponding action even if some other key bindings are ongoing. For example, if “a b” and “a b c” are defined, the sequence “a” → “b” matches to the binding “a b” ignoring matching to “a b c” is ongoing hence “a b c” will never be triggered.

If the interval of key inputs exceeds the timeout (default to 1 second), the key sequence breaks there. For example, when “b” input follows “a” input after 2 seconds, each inputs “a” and “b” are treated as single key inputs, not a key sequence “a b”. Please see Keybinds::set_timeout for the code example.

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

#[derive(PartialEq, Eq, Debug)]
enum Action {
    Foo,
    Bar,
}

let mut keybinds = Keybinds::default();

// Key sequence "f" → "o" → "o"
keybinds.bind("f o o", Action::Foo).unwrap();
// Sequence of key combinations
keybinds.bind("Ctrl+b Ctrl+a", Action::Bar).unwrap();

assert_eq!(keybinds.dispatch('f'), None);
assert_eq!(keybinds.dispatch('o'), None);
assert_eq!(keybinds.dispatch('o'), Some(&Action::Foo));

assert_eq!(keybinds.dispatch(KeyInput::new('b', Mods::CTRL)), None);
assert_eq!(keybinds.dispatch(KeyInput::new('a', Mods::CTRL)), Some(&Action::Bar));

Implementations

impl<A> Keybinds<A>

pub fn new(binds: Vec<Keybind<A>>) -> Self

Create a Keybinds instance from the array of key bindings.

If you want to collect a Keybinds instance from an iterator, Keybinds::from_iter is also useful.

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

enum Action {
    Foo,
    Bar,
    Piyo,
}

let binds = vec![
    Keybind::new('a', Action::Foo),
    Keybind::new(Key::Enter, Action::Bar),
    Keybind::new(KeyInput::new(Key::Up, Mods::CTRL), Action::Piyo),
];

let keybinds = Keybinds::new(binds);
assert_eq!(keybinds.as_slice().len(), 3);

pub fn push(&mut self, bind: Keybind<A>)

Push a new Keybind instance. If this method is called while some key binding matching is ongoing, the matching is reset.

use keybinds::{Keybinds, Keybind};

struct Action;

let mut keybinds = Keybinds::default();

keybinds.push(Keybind::new('x', Action));
assert_eq!(keybinds.as_slice().len(), 1);

pub fn bind(&mut self, key_sequence: &str, action: A) -> Result<()>

Define a new key binding. If the key sequence does not follow the syntax, this method returns an error.

use keybinds::{Keybinds, Keybind, KeyInput, Mods};

#[derive(PartialEq, Eq, Debug)]
struct Action;

let mut keybinds = Keybinds::default();

keybinds.bind("Ctrl+x Ctrl+y", Action).unwrap();
keybinds.bind("Foo+x", Action).unwrap_err(); // Unknown modifier "Foo"

assert_eq!(keybinds.as_slice().len(), 1);

// Dispatch the action
assert_eq!(keybinds.dispatch(KeyInput::new('x', Mods::CTRL)), None);          // Matching is ongoing
assert_eq!(keybinds.dispatch(KeyInput::new('y', Mods::CTRL)), Some(&Action)); // Dispatched

Examples found in repository

examples/winit.rs (line 29)

    fn default() -> Self {
        // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
        let mut keybinds = Keybinds::default();

        // Key bindings to dispatch the actions
        keybinds.bind("h i", Action::SayHi).unwrap();
        keybinds.bind("Mod+m", Action::ToggleMaximized).unwrap();
        keybinds.bind("Mod+Alt+t", Action::ToggleTheme).unwrap();
        keybinds.bind("Mod+x Mod+c", Action::Exit).unwrap();

        Self {
            window: None,
            keybinds,
            converter: WinitEventConverter::default(),
        }
    }

examples/iced.rs (line 40)

    fn default() -> Self {
        // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
        let mut keybinds = Keybinds::default();

        // Define the key bindings
        keybinds.bind("Mod+m", Action::ToggleMaximize).unwrap();
        keybinds.bind("H e l l o", Action::SayHello).unwrap();
        keybinds.bind("Mod+T", Action::ToggleTheme).unwrap();
        keybinds.bind("Mod+x Mod+c", Action::Exit).unwrap();

        Self {
            window_id: window::Id::unique(),
            ongoing_input: "".to_string(),
            last_action: "".to_string(),
            maximized: false,
            theme: Theme::Dark,
            help: keybinds
                .as_slice()
                .iter()
                .map(|b| (format!("{}", b.seq), b.action))
                .collect(),
            keybinds,
        }
    }

examples/minimal.rs (line 16)

fn main() -> io::Result<()> {
    // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
    let mut keybinds = Keybinds::default();

    // Register key bindings to dispatch the actions
    keybinds.bind("h e l l o", Action::SayHello).unwrap();
    keybinds.bind("Esc", Action::ExitApp).unwrap();

    println!("Type inputs and send it by hitting Enter key. Send Esc to exit");
    for b in io::stdin().lock().bytes() {
        // Convert your key input into `KeyInput` struct
        let input = match b? {
            b'\x1b' => KeyInput::from(Key::Esc),
            b => KeyInput::from(b as char),
        };
        println!("Key input: {input:?}");

        // Try to dispatch action by `dispatch` method
        if let Some(action) = keybinds.dispatch(input) {
            println!("Dispatched action: {action:?}");
            match action {
                Action::SayHello => println!("Hello!"),
                Action::ExitApp => break,
            }
        }
    }

    Ok(())
}

examples/termwiz.rs (line 24)

fn main() -> Result<(), Error> {
    // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
    let mut keybinds = Keybinds::default();

    // Key bindings to dispatch the actions
    keybinds.bind("h i", Action::SayHi).unwrap();
    keybinds.bind("Left", Action::MoveLeft).unwrap();
    keybinds.bind("Ctrl+p", Action::Paste).unwrap();
    keybinds.bind("Ctrl+x Ctrl+c", Action::ExitApp).unwrap();

    let caps = Capabilities::new_from_env()?;
    let terminal = new_terminal(caps)?;

    let mut buf = BufferedTerminal::new(terminal)?;
    buf.add_change("Type Ctrl+x Ctrl+c to exit");
    buf.add_change(Change::CursorPosition {
        x: Position::Absolute(0),
        y: Position::Absolute(2),
    });
    buf.flush()?;
    buf.terminal().set_raw_mode()?;

    loop {
        let Some(input) = buf.terminal().poll_input(None)? else {
            continue;
        };

        // Dispatch action by directly passing `InputEvent` to `dispatch` method.
        let action = keybinds.dispatch(&input);

        buf.add_change(Change::CursorPosition {
            x: Position::Absolute(0),
            y: Position::Absolute(0),
        });
        buf.add_change(Change::ClearToEndOfLine(ColorAttribute::Default));
        if let Some(action) = action {
            buf.add_change(Change::Attribute(AttributeChange::Foreground(
                AnsiColor::Red.into(),
            )));
            buf.add_change(format!("Action: {action:?}"));
        }

        buf.add_change(Change::CursorPosition {
            x: Position::Absolute(0),
            y: Position::Absolute(2),
        });
        buf.add_change(Change::ClearToEndOfLine(ColorAttribute::Default));
        buf.add_change(format!("KeyInput: {:?}", KeyInput::from(input)));

        buf.flush()?;

        if action == Some(&Action::ExitApp) {
            return Ok(());
        }
    }
}

pub fn dispatch<I: Into<KeyInput>>(&mut self, input: I) -> Option<&A>

Dispatch an action for the given key input.

This method accepts various values which implement Into<KeyInput>. For example, char value is converted into a single-character key input with no modifiers. Conversions from key event types in several frameworks are supported by enabling the optional features.

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

#[derive(PartialEq, Eq, Debug)]
enum Action {
    Foo,
}

let mut keybinds = Keybinds::default();

keybinds.bind("f Ctrl+o Enter", Action::Foo).unwrap();

// Input "f" key with no modifiers
assert_eq!(keybinds.dispatch('f'), None);
// Input "o" key with Ctrl modifier
assert_eq!(keybinds.dispatch(KeyInput::new('o', Mods::CTRL)), None);
// Input "Enter" key with no modifiers
assert_eq!(keybinds.dispatch(Key::Enter), Some(&Action::Foo));

Examples found in repository

examples/vim.rs (line 393)

    fn dispatch(&mut self, input: KeyInput) -> Option<Action> {
        let keybinds = match self.mode {
            Mode::Normal => &mut self.normal,
            Mode::Visual => &mut self.visual,
            Mode::Insert => &mut self.insert,
        };
        keybinds.dispatch(input).copied()
    }

examples/minimal.rs (line 29)

fn main() -> io::Result<()> {
    // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
    let mut keybinds = Keybinds::default();

    // Register key bindings to dispatch the actions
    keybinds.bind("h e l l o", Action::SayHello).unwrap();
    keybinds.bind("Esc", Action::ExitApp).unwrap();

    println!("Type inputs and send it by hitting Enter key. Send Esc to exit");
    for b in io::stdin().lock().bytes() {
        // Convert your key input into `KeyInput` struct
        let input = match b? {
            b'\x1b' => KeyInput::from(Key::Esc),
            b => KeyInput::from(b as char),
        };
        println!("Key input: {input:?}");

        // Try to dispatch action by `dispatch` method
        if let Some(action) = keybinds.dispatch(input) {
            println!("Dispatched action: {action:?}");
            match action {
                Action::SayHello => println!("Hello!"),
                Action::ExitApp => break,
            }
        }
    }

    Ok(())
}

examples/winit.rs (line 57)

    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/crossterm.rs (line 78)

fn main() -> io::Result<()> {
    // Parse the configuration from the file content
    let config: Config = toml::from_str(CONFIG_FILE_CONTENT).unwrap();

    // `Keybinds` instance is a key bindings dispatcher that receives key inputs and
    // dispatches the corresponding actions.
    let mut keybinds = config.keyboard;

    enable_raw_mode()?;
    let mut stdout = io::stdout();

    // Read the crossterm's key events and pass it to `Keybinds::dispatch` directly.
    while let Ok(event) = event::read() {
        // If the event triggered some action, handle it using `match`
        if let Some(action) = keybinds.dispatch(&event) {
            match action {
                Action::Exit => break,
                Action::Up => execute!(stdout, cursor::MoveUp(1))?,
                Action::Down => execute!(stdout, cursor::MoveDown(1))?,
                Action::Left => execute!(stdout, cursor::MoveLeft(1))?,
                Action::Right => execute!(stdout, cursor::MoveRight(1))?,
                Action::Top => execute!(stdout, cursor::MoveUp(9999))?,
                Action::Bottom => execute!(stdout, cursor::MoveDown(9999))?,
                Action::Home => execute!(stdout, cursor::MoveLeft(9999))?,
                Action::End => execute!(stdout, cursor::MoveRight(9999))?,
            }
        }
    }

    disable_raw_mode()
}

examples/iced.rs (line 79)

    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()
    }

examples/termwiz.rs (line 47)

fn main() -> Result<(), Error> {
    // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
    let mut keybinds = Keybinds::default();

    // Key bindings to dispatch the actions
    keybinds.bind("h i", Action::SayHi).unwrap();
    keybinds.bind("Left", Action::MoveLeft).unwrap();
    keybinds.bind("Ctrl+p", Action::Paste).unwrap();
    keybinds.bind("Ctrl+x Ctrl+c", Action::ExitApp).unwrap();

    let caps = Capabilities::new_from_env()?;
    let terminal = new_terminal(caps)?;

    let mut buf = BufferedTerminal::new(terminal)?;
    buf.add_change("Type Ctrl+x Ctrl+c to exit");
    buf.add_change(Change::CursorPosition {
        x: Position::Absolute(0),
        y: Position::Absolute(2),
    });
    buf.flush()?;
    buf.terminal().set_raw_mode()?;

    loop {
        let Some(input) = buf.terminal().poll_input(None)? else {
            continue;
        };

        // Dispatch action by directly passing `InputEvent` to `dispatch` method.
        let action = keybinds.dispatch(&input);

        buf.add_change(Change::CursorPosition {
            x: Position::Absolute(0),
            y: Position::Absolute(0),
        });
        buf.add_change(Change::ClearToEndOfLine(ColorAttribute::Default));
        if let Some(action) = action {
            buf.add_change(Change::Attribute(AttributeChange::Foreground(
                AnsiColor::Red.into(),
            )));
            buf.add_change(format!("Action: {action:?}"));
        }

        buf.add_change(Change::CursorPosition {
            x: Position::Absolute(0),
            y: Position::Absolute(2),
        });
        buf.add_change(Change::ClearToEndOfLine(ColorAttribute::Default));
        buf.add_change(format!("KeyInput: {:?}", KeyInput::from(input)));

        buf.flush()?;

        if action == Some(&Action::ExitApp) {
            return Ok(());
        }
    }
}

pub fn set_timeout(&mut self, timeout: Duration)

Set the timeout to wait for the next key input while matching to key bindings is ongoing. For the default timeout value, see DEFAULT_TIMEOUT.

use std::time::Duration;
use std::thread::sleep;
use keybinds::Keybinds;

struct Action;

let mut keybinds = Keybinds::default();
keybinds.bind("a b", Action).unwrap();

// Set the timeout to very small value to demonstrate the usage.
keybinds.set_timeout(Duration::from_millis(10));

// Input the first key input of key sequence "a b"
assert!(keybinds.dispatch('a').is_none());

// Make the ongoing match expire (50ms > 10ms)
sleep(Duration::from_millis(50));

// Input the second key input of key sequence "a b". However it does not dispatch the action
// because the matching expired.
assert!(keybinds.dispatch('b').is_none());

Examples found in repository

examples/deserialize.rs (line 43)

fn main() {
    let configuration = r#"
[keyboard]
timeout = 500

[keyboard.bindings]
"Ctrl+Alt+Enter" = "OpenFile"
"Ctrl+x Ctrl+c" = "ExitApp"
"#;

    // Parse the TOML input into the `Config` instance
    let config: Config = toml::from_str(configuration).unwrap();
    let mut keybinds = config.keyboard.bindings;

    // Set the key sequence matching timeout if needed
    if let Some(ms) = config.keyboard.timeout {
        keybinds.set_timeout(Duration::from_millis(ms));
    }

    dbg!(keybinds.as_slice());
    dbg!(keybinds.timeout());
}

pub fn reset(&mut self)

Reset the state of the dispatcher. This resets the ongoing matching state of key binding.

use keybinds::Keybinds;

struct Action;

let mut keybinds = Keybinds::default();
keybinds.bind("a b", Action).unwrap();

assert!(keybinds.dispatch('a').is_none());

// Abandon the ongoing matching for "a b"
keybinds.reset();

assert!(keybinds.dispatch('b').is_none());

Examples found in repository

examples/iced.rs (line 100)

    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 timeout(&self) -> Duration

Get the timeout of key binding matching. See Keybinds::set_timeout to know the details of the timeout.

use std::time::Duration;
use keybinds::{Keybinds, DEFAULT_TIMEOUT};

struct Action;

let mut keybinds = Keybinds::<Action>::default();
assert_eq!(keybinds.timeout(), DEFAULT_TIMEOUT);

let duration = Duration::from_millis(500);
keybinds.set_timeout(duration);
assert_eq!(keybinds.timeout(), duration);

Examples found in repository

examples/deserialize.rs (line 47)

fn main() {
    let configuration = r#"
[keyboard]
timeout = 500

[keyboard.bindings]
"Ctrl+Alt+Enter" = "OpenFile"
"Ctrl+x Ctrl+c" = "ExitApp"
"#;

    // Parse the TOML input into the `Config` instance
    let config: Config = toml::from_str(configuration).unwrap();
    let mut keybinds = config.keyboard.bindings;

    // Set the key sequence matching timeout if needed
    if let Some(ms) = config.keyboard.timeout {
        keybinds.set_timeout(Duration::from_millis(ms));
    }

    dbg!(keybinds.as_slice());
    dbg!(keybinds.timeout());
}

pub fn as_slice(&self) -> &[Keybind<A>]

Get the reference to the inner slice of Keybind instances.

use keybinds::{Keybinds, Keybind};

#[derive(Clone, PartialEq, Eq, Debug)]
struct Action;

let mut keybinds = Keybinds::default();

keybinds.bind("a", Action).unwrap();

assert_eq!(keybinds.as_slice(), &[Keybind::new('a', Action)]);

Examples found in repository

examples/deserialize.rs (line 46)

fn main() {
    let configuration = r#"
[keyboard]
timeout = 500

[keyboard.bindings]
"Ctrl+Alt+Enter" = "OpenFile"
"Ctrl+x Ctrl+c" = "ExitApp"
"#;

    // Parse the TOML input into the `Config` instance
    let config: Config = toml::from_str(configuration).unwrap();
    let mut keybinds = config.keyboard.bindings;

    // Set the key sequence matching timeout if needed
    if let Some(ms) = config.keyboard.timeout {
        keybinds.set_timeout(Duration::from_millis(ms));
    }

    dbg!(keybinds.as_slice());
    dbg!(keybinds.timeout());
}

examples/iced.rs (line 52)

    fn default() -> Self {
        // Create a key bindings dispatcher to dispatch actions for upcoming key inputs
        let mut keybinds = Keybinds::default();

        // Define the key bindings
        keybinds.bind("Mod+m", Action::ToggleMaximize).unwrap();
        keybinds.bind("H e l l o", Action::SayHello).unwrap();
        keybinds.bind("Mod+T", Action::ToggleTheme).unwrap();
        keybinds.bind("Mod+x Mod+c", Action::Exit).unwrap();

        Self {
            window_id: window::Id::unique(),
            ongoing_input: "".to_string(),
            last_action: "".to_string(),
            maximized: false,
            theme: Theme::Dark,
            help: keybinds
                .as_slice()
                .iter()
                .map(|b| (format!("{}", b.seq), b.action))
                .collect(),
            keybinds,
        }
    }

pub fn is_ongoing(&self) -> bool

Return whether the matching for key bindings is ongoing.

use keybinds::Keybinds;

struct Action;

let mut keybinds = Keybinds::default();
keybinds.bind("a b", Action).unwrap();

assert!(!keybinds.is_ongoing());
keybinds.dispatch('a');
assert!(keybinds.is_ongoing());
keybinds.dispatch('b');
assert!(!keybinds.is_ongoing());

Examples found in repository

examples/iced.rs (line 69)

    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 ongoing_inputs(&self) -> &[KeyInput]

Get the ongoing key inputs being matched to some key sequence in the key bindings.

use keybinds::{Keybinds, KeyInput};

struct Action;

let mut keybinds = Keybinds::default();
keybinds.bind("a b c", Action).unwrap();

// Initially there is no ongoing sequence.
assert_eq!(keybinds.ongoing_inputs(), &[]);

// Matching to the key sequence "a b c" is ongoing.
keybinds.dispatch('a');
keybinds.dispatch('b');
assert_eq!(keybinds.ongoing_inputs(), &['a'.into(), 'b'.into()]);

// The inputs matches to "a b c" and dispatches the action.
keybinds.dispatch('c');
assert_eq!(keybinds.ongoing_inputs(), &[]);

// This input matches nothing so there is no ongoing match.
keybinds.dispatch('d');
assert_eq!(keybinds.ongoing_inputs(), &[]);

pub fn into_vec(self) -> Vec<Keybind<A>>

Convert to the inner Vec of Keybind instances. This method is useful when you need to modify the key bindings.

use keybinds::{Keybinds, Keybind};

#[derive(Clone, PartialEq, Eq, Debug)]
struct Action;

let mut keybinds = Keybinds::new(vec![Keybind::new('a', Action)]);

let mut config = keybinds.into_vec();
config[0] = Keybind::new('b', Action);

// Recreate the `Keybinds` instance
let mut keybinds = Keybinds::new(config);

assert_eq!(keybinds.dispatch('a'), None);
assert_eq!(keybinds.dispatch('b'), Some(&Action));

Trait Implementations

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Keybinds<A>

Available on crate feature arbitrary only.

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

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

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

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<A: Clone> Clone for Keybinds<A>

fn clone(&self) -> Keybinds<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Keybinds<A>

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

Formats the value using the given formatter.

impl<A> Default for Keybinds<A>

fn default() -> Self

Create an empty Keybinds instance.

use keybinds::Keybinds;

struct Action;

let mut keybinds = Keybinds::default();
assert!(keybinds.as_slice().is_empty());

keybinds.bind("Ctrl+X", Action).unwrap();
assert!(!keybinds.as_slice().is_empty());

impl<'de, A: Deserialize<'de>> Deserialize<'de> for Keybinds<A>

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<A> Extend<Keybind<A>> for Keybinds<A>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Keybind<A>>,

Extend the key bindings with the iterator of Keybind instances. When some key binding matching is ongoing, it will be reset.

use keybinds::{Keybinds, Keybind};

struct Action;

let mut keybinds = Keybinds::new(vec![Keybind::new(['a', 'b'], Action)]);

keybinds.dispatch('a');
assert!(keybinds.is_ongoing());

keybinds.extend([Keybind::new('c', Action), Keybind::new('d', Action)]);
assert_eq!(keybinds.as_slice().len(), 3);

// The matching state was reset
assert!(!keybinds.is_ongoing());

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A> FromIterator<Keybind<A>> for Keybinds<A>

fn from_iter<T: IntoIterator<Item = Keybind<A>>>(iter: T) -> Self

Collect Keybinds instance from an iterator of Keybind.

use keybinds::{Keybinds, Keybind, KeySeq};

enum Action {
    Foo,
    Bar,
    Piyo,
}

let config = [
    ("f o o",         Action::Foo),
    ("Ctrl+b Ctrl+a", Action::Bar),
    ("Enter",         Action::Piyo),
];

let binds: Keybinds<_> = config
        .into_iter()
        .map(|(k, a)| k.parse().map(|k: KeySeq| Keybind::new(k, a)))
        .collect::<Result<_, _>>()
        .unwrap();

assert_eq!(binds.as_slice().len(), 3);

impl<A: PartialEq> PartialEq for Keybinds<A>

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

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<A: Eq> Eq for Keybinds<A>

impl<A> StructuralPartialEq for Keybinds<A>