Struct Keybind

pub struct Keybind<A> {
    pub seq: KeySeq,
    pub action: A,
}

Single key binding. A pair of a key sequence and its action.

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

struct Action;

let mut keybinds = Keybinds::default();
keybinds.push(Keybind::new('x', Action));
keybinds.push(Keybind::new(['x', 'y'], Action));
keybinds.push(Keybind::new(KeyInput::new(Key::Left, Mods::CTRL), Action));
keybinds.push(Keybind::new(KeySeq::from([KeyInput::new('x', Mods::ALT), KeyInput::new('y', Mods::ALT)]), Action));

Fields

seq: KeySeq

The key sequence that triggers the action.

action: A

The action triggered by the key sequence.

Implementations

impl<A> Keybind<A>

pub fn new<S: Into<KeySeq>>(seq: S, action: A) -> Self

Create a new key binding.

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

struct Action;

// Single-key key bindings
let _ = Keybind::new('x', Action);
let _ = Keybind::new(Key::Enter, Action);
let _ = Keybind::new(KeyInput::new('x', Mods::CTRL), Action);

// Complex key binding ("Ctrl+Up Alt+Down")
let _ = Keybind::new(
    KeySeq::from([
        KeyInput::new(Key::Up, Mods::CTRL),
        KeyInput::new(Key::Down, Mods::ALT),
    ]),
    Action,
);

Examples found in repository

examples/vim.rs (line 149)

        fn keybinds(map: &[(&str, Action)]) -> keybinds::Result<Keybinds<Action>> {
            map.iter()
                .copied()
                .map(|(k, a)| k.parse().map(|s: KeySeq| Keybind::new(s, a)))
                .collect()
        }

examples/serialize.rs (line 27)

fn main() -> keybinds::Result<()> {
    println!("Input your favorite key bindings like Ctrl+a per line.");
    println!("Input an empty line to finish.");

    let bindings: Keybinds<_> = stdin()
        .lines()
        .map(Result::unwrap)
        .take_while(|l| !l.is_empty())
        .map(|l| {
            let seq: KeySeq = l.parse()?;
            Ok(Keybind::new(seq, Action::DoSomething))
        })
        .collect::<Result<_, _>>()?;
    let config = Config { bindings };

    // Generate configuration file content using serde
    let generated = toml::to_string_pretty(&config).unwrap();
    println!("{generated}");

    Ok(())
}

Trait Implementations

impl<'arbitrary, A: Arbitrary<'arbitrary>> Arbitrary<'arbitrary> for Keybind<A>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Keybind<A>

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

Formats the value using the given formatter.

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 Keybind<A>

fn eq(&self, other: &Keybind<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: Eq> Eq for Keybind<A>

impl<A> StructuralPartialEq for Keybind<A>