Struct HotkeyManager 

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

Manages the lifecycle of hotkeys, including their registration, unregistration, and execution.

The HotkeyManager listens for keyboard events and triggers the corresponding hotkey callbacks when events match registered hotkeys.

Type Parameters

• T: The return type of the hotkey callbacks.

Implementations

impl<T> HotkeyManager<T>

pub fn new() -> HotkeyManager<T>

Examples found in repository

examples/pomodoro_timer.rs (line 9)

fn main() {
    let mut hkm = HotkeyManager::new();

    hkm.register_hotkey(VKey::P, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro started! Focus for 25 minutes.");
        thread::spawn(|| {
            thread::sleep(time::Duration::from_secs(25 * 60));
            show_popup("Pomodoro Timer", "Time's up! Take a break.");
        });
    })
    .unwrap();

    hkm.register_hotkey(VKey::S, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro stopped!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/pause.rs (line 5)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'CTRL'
    let trigger_key = VKey::A;
    let mod_key = VKey::Control;
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'V' and the modifier key 'CTRL'
    hkm.register_hotkey(VKey::V, &[VKey::Control], || {
        println!("Hotkey CTRL + V was pressed");
    })
    .unwrap();

    // Register pause hotkey. This hotkey will toggle the pause state of win-hotkeys,
    // allowing only registered pause hotkeys to be processed.
    let trigger_key = VKey::P;
    let modifiers = &[VKey::Control, VKey::Shift];
    hkm.register_pause_hotkey(trigger_key, modifiers, || {
        println!("Hotkey CTRL + Shift + P toggles pause state for win-hotkeys!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/vkeys.rs (line 7)

fn main() {
    // Create HotkeyManager
    let mut hkm = HotkeyManager::<()>::new();

    let vk_a1 = VKey::A;
    let vk_a2 = VKey::from_keyname("a").unwrap();
    let vk_a3 = VKey::from_vk_code(0x41);
    let vk_a4 = VKey::from_vk_code(VK_A.0);

    // Create custom keycode equivalent to A
    let vk_a5 = VKey::CustomKeyCode(0x41);

    assert_eq!(vk_a1, vk_a2);
    assert_eq!(vk_a1, vk_a3);
    assert_eq!(vk_a1, vk_a4);
    assert_eq!(vk_a1, vk_a5);

    // NOTE
    // When matching `CustomKeyCodes` you must include a guard if statement
    match vk_a5 {
        VKey::A => {
            // This will never show up
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {
            println!("You didn't use the match statement correctly!");
        }
    }

    // Instead match like this
    match vk_a5 {
        _ if VKey::A == vk_a5 => {
            // This will match
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {}
    }

    hkm.register_hotkey(vk_a5, &[], || {
        println!("You pressed A");
    })
    .unwrap();

    hkm.event_loop();
}

examples/handles.rs (line 8)

fn main() {
    // Create the manager
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with trigger key 'A' and modifier key 'CTRL'
    hkm.register_hotkey(VKey::A, &[VKey::Control], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Get an interrupt handle that can be used to interrupt / stop the event loop from any thread
    let interrupt_handle = hkm.interrupt_handle();

    // Get a pause handle that can be used to programmatically pause the processing of hotkeys from
    // any thread. Note: registered pause hotkeys will still be processed.
    let pause_handle = hkm.pause_handle();

    // Create a second thread that will pause/interrupt hkm
    spawn(move || {
        sleep(Duration::from_secs(3));

        println!("Pausing hotkeys for 3 seconds");
        pause_handle.toggle();
        sleep(Duration::from_secs(3));

        println!("Unpausing hotkeys");
        pause_handle.toggle();

        sleep(Duration::from_secs(3));
        interrupt_handle.interrupt();
    });

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

    println!("Event Loop interrupted");
}

examples/app_command.rs (line 14)

fn main() {
    // The HotkeyManager is generic over the return type of the callback functions.
    let mut hkm = HotkeyManager::new();
    let modifiers = &[VKey::LWin, VKey::Shift];

    // Register WIN + SHIFT + 1 for app command 1
    hkm.register_hotkey(VKey::Vk1, modifiers, || {
        println!("Pressed WIN + SHIFT + 1");
        AppCommand::AppCommand1
    })
    .unwrap();

    // Register WIN + SHIFT + 2 for app command 2
    hkm.register_hotkey(VKey::Vk2, modifiers, || {
        println!("Pressed WIN + SHIFT + 2");
        AppCommand::AppCommand2
    })
    .unwrap();

    // Register WIN + 3 for app command EXIT
    hkm.register_hotkey(VKey::Vk3, modifiers, || {
        println!("Pressed WIN + SHIFT + 3");
        AppCommand::Exit
    })
    .unwrap();

    // Register channel to receive events from the hkm event loop
    let (tx, rx) = unbounded();
    hkm.register_channel(tx);

    // Run HotkeyManager in background thread
    let handle = hkm.interrupt_handle();
    thread::spawn(move || {
        hkm.event_loop();
    });

    // App Logic
    loop {
        let command = rx.recv().unwrap();

        match command {
            AppCommand::AppCommand1 => {
                println!("Do thing 1");
            }
            AppCommand::AppCommand2 => {
                println!("Do thing 2");
            }
            AppCommand::Exit => {
                println!("Exiting...");
                handle.interrupt();
                break;
            }
        }
    }
}

examples/simple.rs (line 5)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'ALT'
    let trigger_key = VKey::from_keyname("a").unwrap();
    let mod_key = VKey::from_keyname("alt").unwrap();
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey ALT + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'B' and the modifier key 'f24'
    let trigger_key = VKey::from_keyname("b").unwrap();
    let modifiers = &[VKey::from_vk_code(0x87)];
    hkm.register_hotkey(trigger_key, modifiers, || {
        println!("Hotkey F24 + B was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'C' and multiple modifier key
    hkm.register_hotkey(VKey::C, &[VKey::LWin, VKey::Menu], || {
        println!("Hotkey WIN + ALT + C was pressed");
    })
    .unwrap();

    // Register and store id for system-wide hotkey with trigger key 'D' and modifier key 'ALT'
    let hotkey_id = hkm
        .register_hotkey(
            VKey::from_vk_code(0x44),
            &[VKey::from_vk_code(0xA4)],
            || {
                println!("Hotkey ALT + D was pressed");
            },
        )
        .unwrap();

    // Unregister hotkey with ID
    hkm.unregister_hotkey(hotkey_id);

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

pub fn register_hotkey( &mut self, trigger_key: VKey, mod_keys: &[VKey], callback: impl Fn() -> T + Send + 'static, ) -> Result<i32, WHKError>

Registers a new hotkey.

Examples found in repository

examples/pomodoro_timer.rs (lines 11-17)

fn main() {
    let mut hkm = HotkeyManager::new();

    hkm.register_hotkey(VKey::P, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro started! Focus for 25 minutes.");
        thread::spawn(|| {
            thread::sleep(time::Duration::from_secs(25 * 60));
            show_popup("Pomodoro Timer", "Time's up! Take a break.");
        });
    })
    .unwrap();

    hkm.register_hotkey(VKey::S, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro stopped!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/pause.rs (lines 10-12)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'CTRL'
    let trigger_key = VKey::A;
    let mod_key = VKey::Control;
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'V' and the modifier key 'CTRL'
    hkm.register_hotkey(VKey::V, &[VKey::Control], || {
        println!("Hotkey CTRL + V was pressed");
    })
    .unwrap();

    // Register pause hotkey. This hotkey will toggle the pause state of win-hotkeys,
    // allowing only registered pause hotkeys to be processed.
    let trigger_key = VKey::P;
    let modifiers = &[VKey::Control, VKey::Shift];
    hkm.register_pause_hotkey(trigger_key, modifiers, || {
        println!("Hotkey CTRL + Shift + P toggles pause state for win-hotkeys!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/vkeys.rs (lines 43-45)

fn main() {
    // Create HotkeyManager
    let mut hkm = HotkeyManager::<()>::new();

    let vk_a1 = VKey::A;
    let vk_a2 = VKey::from_keyname("a").unwrap();
    let vk_a3 = VKey::from_vk_code(0x41);
    let vk_a4 = VKey::from_vk_code(VK_A.0);

    // Create custom keycode equivalent to A
    let vk_a5 = VKey::CustomKeyCode(0x41);

    assert_eq!(vk_a1, vk_a2);
    assert_eq!(vk_a1, vk_a3);
    assert_eq!(vk_a1, vk_a4);
    assert_eq!(vk_a1, vk_a5);

    // NOTE
    // When matching `CustomKeyCodes` you must include a guard if statement
    match vk_a5 {
        VKey::A => {
            // This will never show up
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {
            println!("You didn't use the match statement correctly!");
        }
    }

    // Instead match like this
    match vk_a5 {
        _ if VKey::A == vk_a5 => {
            // This will match
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {}
    }

    hkm.register_hotkey(vk_a5, &[], || {
        println!("You pressed A");
    })
    .unwrap();

    hkm.event_loop();
}

examples/handles.rs (lines 11-13)

fn main() {
    // Create the manager
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with trigger key 'A' and modifier key 'CTRL'
    hkm.register_hotkey(VKey::A, &[VKey::Control], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Get an interrupt handle that can be used to interrupt / stop the event loop from any thread
    let interrupt_handle = hkm.interrupt_handle();

    // Get a pause handle that can be used to programmatically pause the processing of hotkeys from
    // any thread. Note: registered pause hotkeys will still be processed.
    let pause_handle = hkm.pause_handle();

    // Create a second thread that will pause/interrupt hkm
    spawn(move || {
        sleep(Duration::from_secs(3));

        println!("Pausing hotkeys for 3 seconds");
        pause_handle.toggle();
        sleep(Duration::from_secs(3));

        println!("Unpausing hotkeys");
        pause_handle.toggle();

        sleep(Duration::from_secs(3));
        interrupt_handle.interrupt();
    });

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

    println!("Event Loop interrupted");
}

examples/app_command.rs (lines 18-21)

fn main() {
    // The HotkeyManager is generic over the return type of the callback functions.
    let mut hkm = HotkeyManager::new();
    let modifiers = &[VKey::LWin, VKey::Shift];

    // Register WIN + SHIFT + 1 for app command 1
    hkm.register_hotkey(VKey::Vk1, modifiers, || {
        println!("Pressed WIN + SHIFT + 1");
        AppCommand::AppCommand1
    })
    .unwrap();

    // Register WIN + SHIFT + 2 for app command 2
    hkm.register_hotkey(VKey::Vk2, modifiers, || {
        println!("Pressed WIN + SHIFT + 2");
        AppCommand::AppCommand2
    })
    .unwrap();

    // Register WIN + 3 for app command EXIT
    hkm.register_hotkey(VKey::Vk3, modifiers, || {
        println!("Pressed WIN + SHIFT + 3");
        AppCommand::Exit
    })
    .unwrap();

    // Register channel to receive events from the hkm event loop
    let (tx, rx) = unbounded();
    hkm.register_channel(tx);

    // Run HotkeyManager in background thread
    let handle = hkm.interrupt_handle();
    thread::spawn(move || {
        hkm.event_loop();
    });

    // App Logic
    loop {
        let command = rx.recv().unwrap();

        match command {
            AppCommand::AppCommand1 => {
                println!("Do thing 1");
            }
            AppCommand::AppCommand2 => {
                println!("Do thing 2");
            }
            AppCommand::Exit => {
                println!("Exiting...");
                handle.interrupt();
                break;
            }
        }
    }
}

examples/simple.rs (lines 10-12)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'ALT'
    let trigger_key = VKey::from_keyname("a").unwrap();
    let mod_key = VKey::from_keyname("alt").unwrap();
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey ALT + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'B' and the modifier key 'f24'
    let trigger_key = VKey::from_keyname("b").unwrap();
    let modifiers = &[VKey::from_vk_code(0x87)];
    hkm.register_hotkey(trigger_key, modifiers, || {
        println!("Hotkey F24 + B was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'C' and multiple modifier key
    hkm.register_hotkey(VKey::C, &[VKey::LWin, VKey::Menu], || {
        println!("Hotkey WIN + ALT + C was pressed");
    })
    .unwrap();

    // Register and store id for system-wide hotkey with trigger key 'D' and modifier key 'ALT'
    let hotkey_id = hkm
        .register_hotkey(
            VKey::from_vk_code(0x44),
            &[VKey::from_vk_code(0xA4)],
            || {
                println!("Hotkey ALT + D was pressed");
            },
        )
        .unwrap();

    // Unregister hotkey with ID
    hkm.unregister_hotkey(hotkey_id);

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

pub fn unregister_hotkey(&mut self, hotkey_id: i32)

Unregisters a hotkey by its unique id.

Examples found in repository

examples/simple.rs (line 41)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'ALT'
    let trigger_key = VKey::from_keyname("a").unwrap();
    let mod_key = VKey::from_keyname("alt").unwrap();
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey ALT + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'B' and the modifier key 'f24'
    let trigger_key = VKey::from_keyname("b").unwrap();
    let modifiers = &[VKey::from_vk_code(0x87)];
    hkm.register_hotkey(trigger_key, modifiers, || {
        println!("Hotkey F24 + B was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'C' and multiple modifier key
    hkm.register_hotkey(VKey::C, &[VKey::LWin, VKey::Menu], || {
        println!("Hotkey WIN + ALT + C was pressed");
    })
    .unwrap();

    // Register and store id for system-wide hotkey with trigger key 'D' and modifier key 'ALT'
    let hotkey_id = hkm
        .register_hotkey(
            VKey::from_vk_code(0x44),
            &[VKey::from_vk_code(0xA4)],
            || {
                println!("Hotkey ALT + D was pressed");
            },
        )
        .unwrap();

    // Unregister hotkey with ID
    hkm.unregister_hotkey(hotkey_id);

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

pub fn unregister_all(&mut self)

Unregisters all hotkeys.

pub fn register_pause_hotkey( &mut self, trigger_key: VKey, mod_keys: &[VKey], callback: impl Fn() -> T + Send + 'static, ) -> Result<i32, WHKError>

Registers a hotkey that will toggle the paused state of the HotkeyManager. When paused, only registered pause hotkeys will be allowed to trigger.

Examples found in repository

examples/pause.rs (lines 25-27)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'CTRL'
    let trigger_key = VKey::A;
    let mod_key = VKey::Control;
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'V' and the modifier key 'CTRL'
    hkm.register_hotkey(VKey::V, &[VKey::Control], || {
        println!("Hotkey CTRL + V was pressed");
    })
    .unwrap();

    // Register pause hotkey. This hotkey will toggle the pause state of win-hotkeys,
    // allowing only registered pause hotkeys to be processed.
    let trigger_key = VKey::P;
    let modifiers = &[VKey::Control, VKey::Shift];
    hkm.register_pause_hotkey(trigger_key, modifiers, || {
        println!("Hotkey CTRL + Shift + P toggles pause state for win-hotkeys!");
    })
    .unwrap();

    hkm.event_loop();
}

pub fn register_channel(&mut self, channel: Sender<T>)

Registers a channel for callback results to be sent into.

Examples found in repository

examples/app_command.rs (line 40)

fn main() {
    // The HotkeyManager is generic over the return type of the callback functions.
    let mut hkm = HotkeyManager::new();
    let modifiers = &[VKey::LWin, VKey::Shift];

    // Register WIN + SHIFT + 1 for app command 1
    hkm.register_hotkey(VKey::Vk1, modifiers, || {
        println!("Pressed WIN + SHIFT + 1");
        AppCommand::AppCommand1
    })
    .unwrap();

    // Register WIN + SHIFT + 2 for app command 2
    hkm.register_hotkey(VKey::Vk2, modifiers, || {
        println!("Pressed WIN + SHIFT + 2");
        AppCommand::AppCommand2
    })
    .unwrap();

    // Register WIN + 3 for app command EXIT
    hkm.register_hotkey(VKey::Vk3, modifiers, || {
        println!("Pressed WIN + SHIFT + 3");
        AppCommand::Exit
    })
    .unwrap();

    // Register channel to receive events from the hkm event loop
    let (tx, rx) = unbounded();
    hkm.register_channel(tx);

    // Run HotkeyManager in background thread
    let handle = hkm.interrupt_handle();
    thread::spawn(move || {
        hkm.event_loop();
    });

    // App Logic
    loop {
        let command = rx.recv().unwrap();

        match command {
            AppCommand::AppCommand1 => {
                println!("Do thing 1");
            }
            AppCommand::AppCommand2 => {
                println!("Do thing 2");
            }
            AppCommand::Exit => {
                println!("Exiting...");
                handle.interrupt();
                break;
            }
        }
    }
}

pub fn event_loop(&mut self)

Runs the main event loop to listen for keyboard events.

This method blocks and processes keyboard events until interrupted. It matches events against registered hotkeys and executes the corresponding callbacks.

Examples found in repository

examples/pomodoro_timer.rs (line 25)

fn main() {
    let mut hkm = HotkeyManager::new();

    hkm.register_hotkey(VKey::P, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro started! Focus for 25 minutes.");
        thread::spawn(|| {
            thread::sleep(time::Duration::from_secs(25 * 60));
            show_popup("Pomodoro Timer", "Time's up! Take a break.");
        });
    })
    .unwrap();

    hkm.register_hotkey(VKey::S, &[VKey::Control], || {
        show_popup("Pomodoro Timer", "Pomodoro stopped!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/pause.rs (line 30)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'CTRL'
    let trigger_key = VKey::A;
    let mod_key = VKey::Control;
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'V' and the modifier key 'CTRL'
    hkm.register_hotkey(VKey::V, &[VKey::Control], || {
        println!("Hotkey CTRL + V was pressed");
    })
    .unwrap();

    // Register pause hotkey. This hotkey will toggle the pause state of win-hotkeys,
    // allowing only registered pause hotkeys to be processed.
    let trigger_key = VKey::P;
    let modifiers = &[VKey::Control, VKey::Shift];
    hkm.register_pause_hotkey(trigger_key, modifiers, || {
        println!("Hotkey CTRL + Shift + P toggles pause state for win-hotkeys!");
    })
    .unwrap();

    hkm.event_loop();
}

examples/vkeys.rs (line 48)

fn main() {
    // Create HotkeyManager
    let mut hkm = HotkeyManager::<()>::new();

    let vk_a1 = VKey::A;
    let vk_a2 = VKey::from_keyname("a").unwrap();
    let vk_a3 = VKey::from_vk_code(0x41);
    let vk_a4 = VKey::from_vk_code(VK_A.0);

    // Create custom keycode equivalent to A
    let vk_a5 = VKey::CustomKeyCode(0x41);

    assert_eq!(vk_a1, vk_a2);
    assert_eq!(vk_a1, vk_a3);
    assert_eq!(vk_a1, vk_a4);
    assert_eq!(vk_a1, vk_a5);

    // NOTE
    // When matching `CustomKeyCodes` you must include a guard if statement
    match vk_a5 {
        VKey::A => {
            // This will never show up
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {
            println!("You didn't use the match statement correctly!");
        }
    }

    // Instead match like this
    match vk_a5 {
        _ if VKey::A == vk_a5 => {
            // This will match
            println!("CustomKeyCode(0x41) matches against VKey::A");
        }
        _ => {}
    }

    hkm.register_hotkey(vk_a5, &[], || {
        println!("You pressed A");
    })
    .unwrap();

    hkm.event_loop();
}

examples/handles.rs (line 40)

fn main() {
    // Create the manager
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with trigger key 'A' and modifier key 'CTRL'
    hkm.register_hotkey(VKey::A, &[VKey::Control], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Get an interrupt handle that can be used to interrupt / stop the event loop from any thread
    let interrupt_handle = hkm.interrupt_handle();

    // Get a pause handle that can be used to programmatically pause the processing of hotkeys from
    // any thread. Note: registered pause hotkeys will still be processed.
    let pause_handle = hkm.pause_handle();

    // Create a second thread that will pause/interrupt hkm
    spawn(move || {
        sleep(Duration::from_secs(3));

        println!("Pausing hotkeys for 3 seconds");
        pause_handle.toggle();
        sleep(Duration::from_secs(3));

        println!("Unpausing hotkeys");
        pause_handle.toggle();

        sleep(Duration::from_secs(3));
        interrupt_handle.interrupt();
    });

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

    println!("Event Loop interrupted");
}

examples/app_command.rs (line 45)

fn main() {
    // The HotkeyManager is generic over the return type of the callback functions.
    let mut hkm = HotkeyManager::new();
    let modifiers = &[VKey::LWin, VKey::Shift];

    // Register WIN + SHIFT + 1 for app command 1
    hkm.register_hotkey(VKey::Vk1, modifiers, || {
        println!("Pressed WIN + SHIFT + 1");
        AppCommand::AppCommand1
    })
    .unwrap();

    // Register WIN + SHIFT + 2 for app command 2
    hkm.register_hotkey(VKey::Vk2, modifiers, || {
        println!("Pressed WIN + SHIFT + 2");
        AppCommand::AppCommand2
    })
    .unwrap();

    // Register WIN + 3 for app command EXIT
    hkm.register_hotkey(VKey::Vk3, modifiers, || {
        println!("Pressed WIN + SHIFT + 3");
        AppCommand::Exit
    })
    .unwrap();

    // Register channel to receive events from the hkm event loop
    let (tx, rx) = unbounded();
    hkm.register_channel(tx);

    // Run HotkeyManager in background thread
    let handle = hkm.interrupt_handle();
    thread::spawn(move || {
        hkm.event_loop();
    });

    // App Logic
    loop {
        let command = rx.recv().unwrap();

        match command {
            AppCommand::AppCommand1 => {
                println!("Do thing 1");
            }
            AppCommand::AppCommand2 => {
                println!("Do thing 2");
            }
            AppCommand::Exit => {
                println!("Exiting...");
                handle.interrupt();
                break;
            }
        }
    }
}

examples/simple.rs (line 45)

fn main() {
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with the trigger key 'A' and the modifier key 'ALT'
    let trigger_key = VKey::from_keyname("a").unwrap();
    let mod_key = VKey::from_keyname("alt").unwrap();
    hkm.register_hotkey(trigger_key, &[mod_key], || {
        println!("Hotkey ALT + A was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'B' and the modifier key 'f24'
    let trigger_key = VKey::from_keyname("b").unwrap();
    let modifiers = &[VKey::from_vk_code(0x87)];
    hkm.register_hotkey(trigger_key, modifiers, || {
        println!("Hotkey F24 + B was pressed");
    })
    .unwrap();

    // Register a system-wide hotkey with the trigger key 'C' and multiple modifier key
    hkm.register_hotkey(VKey::C, &[VKey::LWin, VKey::Menu], || {
        println!("Hotkey WIN + ALT + C was pressed");
    })
    .unwrap();

    // Register and store id for system-wide hotkey with trigger key 'D' and modifier key 'ALT'
    let hotkey_id = hkm
        .register_hotkey(
            VKey::from_vk_code(0x44),
            &[VKey::from_vk_code(0xA4)],
            || {
                println!("Hotkey ALT + D was pressed");
            },
        )
        .unwrap();

    // Unregister hotkey with ID
    hkm.unregister_hotkey(hotkey_id);

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

pub fn interrupt_handle(&self) -> InterruptHandle

Signals the HotkeyManager to interrupt its event loop.

Examples found in repository

examples/handles.rs (line 17)

fn main() {
    // Create the manager
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with trigger key 'A' and modifier key 'CTRL'
    hkm.register_hotkey(VKey::A, &[VKey::Control], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Get an interrupt handle that can be used to interrupt / stop the event loop from any thread
    let interrupt_handle = hkm.interrupt_handle();

    // Get a pause handle that can be used to programmatically pause the processing of hotkeys from
    // any thread. Note: registered pause hotkeys will still be processed.
    let pause_handle = hkm.pause_handle();

    // Create a second thread that will pause/interrupt hkm
    spawn(move || {
        sleep(Duration::from_secs(3));

        println!("Pausing hotkeys for 3 seconds");
        pause_handle.toggle();
        sleep(Duration::from_secs(3));

        println!("Unpausing hotkeys");
        pause_handle.toggle();

        sleep(Duration::from_secs(3));
        interrupt_handle.interrupt();
    });

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

    println!("Event Loop interrupted");
}

examples/app_command.rs (line 43)

fn main() {
    // The HotkeyManager is generic over the return type of the callback functions.
    let mut hkm = HotkeyManager::new();
    let modifiers = &[VKey::LWin, VKey::Shift];

    // Register WIN + SHIFT + 1 for app command 1
    hkm.register_hotkey(VKey::Vk1, modifiers, || {
        println!("Pressed WIN + SHIFT + 1");
        AppCommand::AppCommand1
    })
    .unwrap();

    // Register WIN + SHIFT + 2 for app command 2
    hkm.register_hotkey(VKey::Vk2, modifiers, || {
        println!("Pressed WIN + SHIFT + 2");
        AppCommand::AppCommand2
    })
    .unwrap();

    // Register WIN + 3 for app command EXIT
    hkm.register_hotkey(VKey::Vk3, modifiers, || {
        println!("Pressed WIN + SHIFT + 3");
        AppCommand::Exit
    })
    .unwrap();

    // Register channel to receive events from the hkm event loop
    let (tx, rx) = unbounded();
    hkm.register_channel(tx);

    // Run HotkeyManager in background thread
    let handle = hkm.interrupt_handle();
    thread::spawn(move || {
        hkm.event_loop();
    });

    // App Logic
    loop {
        let command = rx.recv().unwrap();

        match command {
            AppCommand::AppCommand1 => {
                println!("Do thing 1");
            }
            AppCommand::AppCommand2 => {
                println!("Do thing 2");
            }
            AppCommand::Exit => {
                println!("Exiting...");
                handle.interrupt();
                break;
            }
        }
    }
}

pub fn pause_handle(&self) -> PauseHandle

Signals the HotkeyManager to pause processing of hotkeys.

Examples found in repository

examples/handles.rs (line 21)

fn main() {
    // Create the manager
    let mut hkm = HotkeyManager::new();

    // Register a system-wide hotkey with trigger key 'A' and modifier key 'CTRL'
    hkm.register_hotkey(VKey::A, &[VKey::Control], || {
        println!("Hotkey CTRL + A was pressed");
    })
    .unwrap();

    // Get an interrupt handle that can be used to interrupt / stop the event loop from any thread
    let interrupt_handle = hkm.interrupt_handle();

    // Get a pause handle that can be used to programmatically pause the processing of hotkeys from
    // any thread. Note: registered pause hotkeys will still be processed.
    let pause_handle = hkm.pause_handle();

    // Create a second thread that will pause/interrupt hkm
    spawn(move || {
        sleep(Duration::from_secs(3));

        println!("Pausing hotkeys for 3 seconds");
        pause_handle.toggle();
        sleep(Duration::from_secs(3));

        println!("Unpausing hotkeys");
        pause_handle.toggle();

        sleep(Duration::from_secs(3));
        interrupt_handle.interrupt();
    });

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

    println!("Event Loop interrupted");
}

Trait Implementations

impl<T> Default for HotkeyManager<T>

fn default() -> Self

Returns the “default value” for a type.