device_query

Instead of polling state, you can use DeviceEventsHandler to register callbacks that trigger on specific device events.

• Initialize the handler using DeviceEventsHandler::new(Duration) specifying the polling interval.
• Use methods like on_mouse_move to register listeners.
• The callbacks are managed via a 'guard' pattern: the callbacks are automatically deregistered when the returned guard object goes out of scope.

extern crate device_query;
use device_query::{DeviceEvents, DeviceEventsHandler, Keycode, MouseButton, MousePosition};
use std::thread;
use std::time::Duration;

fn main() {
    // Initialize the event handler with a sleep duration of 10 milliseconds
    let event_handler = DeviceEventsHandler::new(Duration::from_millis(10))
        .expect("Could not initialize event loop");

    // Register callbacks for various events
    // The callbacks will be automatically deregistered when they go out of scope
    let _mouse_move_guard = event_handler.on_mouse_move(|position: &MousePosition| {
        println!("Mouse moved to position: {:?}", position);
    });

    // Keep the main thread alive to continue receiving events
    loop {
        thread::sleep(Duration::from_secs(1000));
    }
}

To react to input changes as they happen rather than polling, use DeviceEventsHandler. Initialize it with DeviceEventsHandler::new(duration), where duration is the polling interval (e.g., Duration::from_millis(10)).

To register callbacks, use methods like .on_mouse_move(|position| { ... }).

Important: The callback registration methods return a guard object. You must keep this guard in scope (e.g., by assigning it to a variable like _guard) to ensure the callback remains active. If the guard is dropped, the event listener for that specific event type will be unregistered.

use device_query::{DeviceEvents, DeviceEventsHandler};
use std::time::Duration;

let device_state = DeviceEventsHandler::new(Duration::from_millis(10))
    .expect("Failed to start event loop");

// Register a mouse move event callback.
// The returned guard must be kept alive to keep the callback active.
let _guard = device_state.on_mouse_move(|position| {
    println!("Mouse position: {:#?}", position);
});

// Keep the main thread alive to continue receiving events
loop {}

The MouseCallbacks struct allows you to register asynchronous, thread-safe callbacks for mouse movements and button actions (down and up).

To register a callback, wrap your closure in an Arc and use the corresponding push_* method. The system uses Weak references internally, meaning callbacks will automatically be cleaned up when the original Arc is dropped, preventing memory leaks.

Available registration methods:

• push_mouse_move(callback: Arc<MouseMoveCallback>): Registers a handler for mouse position changes. The callback receives a reference to &MousePosition.
• push_mouse_down(callback: Arc<MouseButtonCallback>): Registers a handler for mouse button presses. The callback receives a reference to &MouseButton.
• push_mouse_up(callback: Arc<MouseButtonCallback>): Registers a handler for mouse button releases. The callback receives a reference to &MouseButton.

use std::sync::Arc;
use device_query::device_events::callback::mouse_callback::{MouseCallbacks, MouseMoveCallback};

let callbacks = MouseCallbacks::default();

// Create a move callback
let move_handler: Arc<MouseMoveCallback> = Arc::new(|pos| {
    println!("Mouse moved to: {:?}", pos);
});

// Register it
callbacks.push_mouse_move(move_handler);

Use DeviceEventsHandler to register asynchronous callbacks for keyboard and mouse events.

To use this feature:

1. Initialize the handler using DeviceEventsHandler::new(Duration).
2. Call the specific event registration method (e.g., on_key_down, on_mouse_move).
3. Crucial: Store the returned CallbackGuard in a variable. The callback remains active only as long as the guard exists. If the guard is dropped, the callback is unregistered.

Supported events:

• on_key_down: Triggered when a key is pressed. Receives &Keycode.
• on_key_up: Triggered when a key is released. Receives &Keycode.
• on_mouse_move: Triggered on mouse movement. Receives &MousePosition.
• on_mouse_down: Triggered when a mouse button is pressed. Receives &MouseButton.
• on_mouse_up: Triggered when a mouse button is released. Receives &MouseButton.

use device_query::{DeviceEvents, DeviceEventsHandler, Keycode, MouseButton};
use std::time::Duration;

fn main() {
  // Initialize the handler with a sleep duration for the event loop
  let device_events = DeviceEventsHandler::new(Duration::from_millis(10)).unwrap();

  // Register a key down event callback.
  // The returned _guard must be kept in scope to keep the callback alive.
  let _guard = device_events.on_key_down(|key| {
    println!("Key down: {:?}", key);
  });

  // Keep the main thread alive to continue receiving events
  loop {}
}