Struct KeyBinder 

pub struct KeyBinder<T> { /* private fields */ }

Main Keybinder struct

This struct is a safe wrapper for KeyBinder and contains functions to initialize KeyBinder, bind keys and then unbind keys.

The struct guarantees that keybinder_init is called only once. This means you can use this struct anywhere inside your code. Only the first time you call KeyBinder::new() will call keybinder_init.

Note

Make sure you initialize GTK before initializing KeyBinder

Example:

use keybinder::KeyBinder;

fn main() {
    gtk::init().expect("Failed to init GTK");
    let data = String::from("some data");
    let mut keybinder = KeyBinder::<String>::new(true).expect("Keybinder is not supported");

    assert_eq!(keybinder.bind("<Shift>space", |key, data| {
        println!("key: {} , data: {}", key, data);
        gtk::main_quit();
    }, data), true);
    println!("Successfully bound keystring to handler");
    gtk::main();
}

Implementations

impl<T> KeyBinder<T>

pub fn new(use_cooked: bool) -> Result<Self, ()>

Creates and initializes Keybinder(It it’s not already initialized).

Returns

Ok(Self) if KeyBinder is supported. Otherwise, Err(()).

pub fn bind( &mut self, keystring: &str, user_handler: fn(String, &T), user_data: T, ) -> bool

Binds handler to given keystring and passes the user data to handler when key is pressed.

pub fn unbind(&mut self, keystring: &str)

Unbinds the given keystring. If it’s not bound, it does nothing.

Trait Implementations

impl<T: Debug> Debug for KeyBinder<T>

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

Formats the value using the given formatter.

impl<T> Drop for KeyBinder<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.