Struct HashedEventRegister 

pub struct HashedEventRegister<S>(/* private fields */);

A hash store for events and it’s related callback

Each item is a key value pair, where the key is a event and it’s value is a callback. When a event occurs, it is matched inside and when the related match is found, it’s related callback is called.

Implementations

impl HashedEventRegister<RandomState>

pub fn with_default_hasher() -> Self

Create a new HashedEventRegister with the default hasher

impl<S> HashedEventRegister<S>

where S: BuildHasher,

pub const fn new(s: S) -> Self

Create a new HashedEventRegister with the Hasher s

pub fn format_help(&self) -> String

Format dynamic help table from all registered key bindings that have non-empty descriptions.

pub fn insert_wild_event_matcher( &mut self, cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, )

Adds a callback to handle all events that failed to match

Sometimes there are bunch of keys having equal importance that should have the same callback, for instance all the numbers on the keyboard. To handle these types of scenerios this is extremely useful. This callback is called when no event matches the incoming event, then we just match whether the event is a keyboard number and perform the required action.

This is also helpful when you need to do some action, like sending a message when the user presses wrong keyboard/mouse buttons.

pub fn add_resize_event( &mut self, cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, )

Adds a callback for handling resize events

Example

These are from the original sources

use minus::input::{InputEvent, HashedEventRegister, crossterm_event::Event};

let mut input_register = HashedEventRegister::default();

input_register.add_resize_event(|ev, _| {
    let (cols, rows) = if let Event::Resize(cols, rows) = ev {
        (cols, rows)
    } else {
        unreachable!();
    };
    InputEvent::UpdateTermArea(cols as usize, rows as usize)
});

pub fn remove_resize_event(&mut self)

Removes the currently active resize event callback

impl<S> HashedEventRegister<S>

where S: BuildHasher,

pub fn add_key_events( &mut self, desc: &[&str], cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, )

Add all elements of desc as key bindings that minus should respond to with the callback cb

You should prefer using the add_key_events_checked over this one.

Example

use minus::input::{InputEvent, HashedEventRegister, crossterm_event};

let mut input_register = HashedEventRegister::default();

input_register.add_key_events(&["down"], |_, ps| {
    InputEvent::UpdateUpperMark(ps.upper_mark.saturating_sub(1))
});

pub fn add_described_key_events( &mut self, keys: &[&str], desc: impl Into<Cow<'static, str>>, cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, )

Add all elements of keys as key bindings with a description that minus should respond to with the callback cb.

pub fn add_key_events_checked( &mut self, desc: &[&str], cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, remap: bool, )

Add all elements of desc as key bindings that minus should respond to with the callback cb.

Prefer using this over add_key_events.

Panics

This will panic if you the keybinding has been previously defined, unless the remap is set to true. This helps preventing accidental overrides of your keybindings.

Example

use minus::input::{InputEvent, HashedEventRegister, crossterm_event};

let mut input_register = HashedEventRegister::default();

input_register.add_key_events_checked(&["down"], |_, ps| {
    InputEvent::UpdateUpperMark(ps.upper_mark.saturating_sub(1))
}, false);

pub fn add_described_key_events_checked( &mut self, keys: &[&str], desc: impl Into<Cow<'static, str>>, cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, remap: bool, )

Add all elements of keys as key bindings with a description that minus should respond to with the callback cb, with conflict checking.

Panics

Panics if a key already exists and remap is false.

pub fn remove_key_events(&mut self, desc: &[&str])

Removes the callback associated with the all the elements of desc.

use minus::input::{InputEvent, HashedEventRegister, crossterm_event};

let mut input_register = HashedEventRegister::default();

input_register.remove_key_events(&["down"])

pub fn add_help_key(&mut self, desc: &[&str])

Add key binding(s) to show help in the pager prompt.

If desc is empty, defaults to &["m-h"].

Example

use minus::input::HashedEventRegister;

let mut input_register = HashedEventRegister::default();
// Bind default Meta/Alt-h key to show help
input_register.add_help_key(&[]);
// Or specify custom keys
input_register.add_help_key(&["f1"]);

pub fn add_help_key_checked(&mut self, desc: &[&str], remap: bool)

Add key binding(s) to show help in the pager prompt with conflict checking.

If desc is empty, defaults to &["m-h"].

Panics

This will panic if any of the keybindings has been previously defined, unless remap is set to true.

impl<S> HashedEventRegister<S>

where S: BuildHasher,

pub fn add_mouse_events( &mut self, desc: &[&str], cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, )

Add all elemnts of desc as mouse bindings that minus should respond to with the callback cb

You should prefer using the add_mouse_events_checked over this one.

Example

use minus::input::{InputEvent, HashedEventRegister};

let mut input_register = HashedEventRegister::default();

input_register.add_mouse_events(&["scroll:down"], |_, ps| {
    InputEvent::UpdateUpperMark(ps.upper_mark.saturating_sub(5))
});

pub fn add_mouse_events_checked( &mut self, desc: &[&str], cb: impl Fn(Event, &PagerState) -> InputEvent + Send + Sync + 'static, remap: bool, )

Add all elemnts of desc as mouse bindings that minus should respond to with the callback cb.

Prefer using this over add_mouse_events.

Panics

This will panic if you the keybinding has been previously defined, unless the remap is set to true. This helps preventing accidental overrides of your keybindings.

Example

use minus::input::{InputEvent, HashedEventRegister};

let mut input_register = HashedEventRegister::default();

input_register.add_mouse_events_checked(&["scroll:down"], |_, ps| {
    InputEvent::UpdateUpperMark(ps.upper_mark.saturating_sub(5))
}, false);

pub fn remove_mouse_events(&mut self, mouse: &[&str])

Removes the callback associated with the all the elements of desc.

use minus::input::{InputEvent, HashedEventRegister, crossterm_event};

let mut input_register = HashedEventRegister::default();

input_register.remove_mouse_events(&["scroll:down"])

Trait Implementations

impl Default for HashedEventRegister<RandomState>

fn default() -> Self

Create a new HashedEventRegister with the default hasher and insert the default bindings

impl<S> InputClassifier for HashedEventRegister<S>

where S: BuildHasher,

fn classify_input(&self, ev: Event, ps: &PagerState) -> Option<InputEvent>

👎Deprecated:

See #163.

fn format_help(&self) -> Option<String>

👎Deprecated:

See #163.

Format dynamic help text from registered bindings, if supported.