Struct HotkeyManager 

pub struct HotkeyManager<T: 'static> { /* private fields */ }

Implementations

impl<T: 'static> HotkeyManager<T>

pub fn set_no_repeat(&mut self, no_repeat: bool)

Enable or disable the automatically applied ModKey::NoRepeat modifier. By default, this option is set to true which causes all hotkey registration calls to add the NoRepeat modifier, thereby disabling automatic retriggers of hotkeys when holding down the keys.

When this option is disabled, the ModKey::NoRepeat can still be manually added while registering hotkeys.

Note: Setting this flag doesn’t change previously registered hotkeys. It only applies to registrations performed after calling this function.

Examples found in repository

examples/no_repeat.rs (line 15)

fn main() {
    // Create a HotkeyManager.
    // By default, the hotkey registration will add the NoRepeat modifier. This causes the callback
    // to only be triggered once, when the combination is held down.
    let mut hkm = windows_hotkeys::threadsafe::HotkeyManager::new();

    // Disable automatically applying the NoRepeat modifier. After this call, all registrations
    // will trigger repeatedly when the hotkey is held down. This behavior can be manually changed
    // for each registration by adding the `ModKey::NoRepeat` modifier.
    hkm.set_no_repeat(false);

    // Register a system-wide hotkey with the main key `A` and the modifier key `ALT`
    //
    // NOTE: This will trigger multiple times when the combination is held down
    hkm.register(VKey::A, &[ModKey::Alt], || {
        println!("Hotkey ALT + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the main key `B` and multiple modifier keys
    // (`CTRL` + `ALT`)
    //
    // NOTE: This will only be triggered once and not repeatedly when being held down, since the
    //       NoRepeat modifier is added manually.
    hkm.register(
        VKey::B,
        &[ModKey::Ctrl, ModKey::Alt, ModKey::NoRepeat],
        || {
            println!("Hotkey CTRL + ALT + B was pressed");
        },
    )
    .unwrap();

    // Register a system-wide hotkey for `ALT` + `B` with extra keys `Left` + `Right`. This will
    // trigger only if the `Left` + `Right` keys are also pressed during `ALT` + `B`. So just
    // pressing `ALT` + `B` alone won't execute the closure
    //
    // NOTE: This will trigger multiple times when the combination is held down
    hkm.register_extrakeys(VKey::B, &[ModKey::Alt], &[VKey::Left, VKey::Right], || {
        println!("Hotkey ALT + B + Left + Right was pressed");
    })
    .unwrap();

    // Run the event handler in a blocking loop. This will block forever and execute the set
    // callbacks when registered hotkeys are detected
    hkm.event_loop();
}

Trait Implementations

impl<T> Drop for HotkeyManager<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: 'static + Send> HotkeyManagerImpl<T> for HotkeyManager<T>

fn new() -> Self

fn register( &mut self, key: VKey, key_modifiers: &[ModKey], callback: impl Fn() -> T + Send + 'static, ) -> Result<HotkeyId, HkError>

Same as register_extrakeys but without extra keys.

fn register_extrakeys( &mut self, key: VKey, key_modifiers: &[ModKey], extra_keys: &[VKey], callback: impl Fn() -> T + Send + 'static, ) -> Result<HotkeyId, HkError>

Register a new hotkey with additional required extra keys.

fn unregister(&mut self, id: HotkeyId) -> Result<(), HkError>

Unregister a hotkey. This will prevent the hotkey from being triggered in the future.

fn unregister_all(&mut self) -> Result<(), HkError>

Unregister all registered hotkeys. This will be called automatically when dropping the HotkeyManager instance.

fn handle_hotkey(&self) -> Option<T>

Wait for a single a hotkey event and execute the callback if all keys match. This returns the callback result if it was not interrupted. The function call will block until a hotkey is triggered or it is interrupted.

fn event_loop(&self)

Run the event loop, listening for hotkeys. This will run indefinitely until interrupted and execute any hotkeys registered before.

fn interrupt_handle(&self) -> InterruptHandle

Get an InterruptHandle for this HotkeyManager that can be used to interrupt the event loop.