InputBot

https://docs.rs/inputbot
Admin
InputBot is a cross-platform library for simulating keyboard and mouse input events and registering...
Tokens:36,160
Snippets:189
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Key Sequence Example

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

This example shows how to bind the backquote key to send a predefined string.

```APIDOC
## Key Sequence Example

### Description
This example demonstrates binding the backquote key (`, ~`) to send the string "Hello, world!". It also mentions the optional `inputbot::init_device()` for Linux users to prevent startup delays.

### Method
`bind`, `send`

### Endpoint
N/A (Local Input Binding)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Optional initialization for Linux users
// inputbot::init_device();

BackquoteKey.bind(|| {
    KeySequence("Hello, world!").send();
});
```

### Response
N/A (This is an example of input binding, not an API endpoint with a direct response.)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Mouse Movement Examples

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Examples demonstrating absolute and relative mouse cursor movements.

```APIDOC
## Mouse Movement Examples

### Description
This section provides examples for moving the mouse cursor. One example shows absolute movement across the screen triggered by the '1' key, and another shows relative movement triggered by the '2' key.

### Method
`bind`, `move_abs`, `move_rel`

### Endpoint
N/A (Local Input Binding)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Absolute mouse movement
Numrow1Key.bind(|| {
    for x in 0..=600 {
        MouseCursor::move_abs(x as i32, 300);
        sleep(Duration::from_millis(1));
    }
});

// Relative mouse movement
Numrow2Key.bind(|| {
    MouseCursor::move_rel(100, 100);
    sleep(Duration::from_millis(1));
});
```

### Response
N/A (This is an example of input binding, not an API endpoint with a direct response.)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Creating a Scraped Example in Rust

Source: https://docs.rs/inputbot/latest/scrape-examples-help.html

This example demonstrates how to create a scraped example by calling a documented function from another crate. This code will be included in the documentation for `a_crate::a_func`.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Start Listening for Input Events

Source: https://docs.rs/inputbot/latest/inputbot/fn.handle_input_events.html

This function starts the inputbot listener, which will then process all bound input events. It should typically be called at the end of your input binding setup.

```APIDOC
## handle_input_events

### Description
Starts listening for bound input events.

### Method
This is a function call, not an HTTP method.

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
inputbot::handle_input_events();
```

### Response
This function does not return a value. It starts a background process.

### Error Handling
No explicit error handling is documented for this function.
```

--------------------------------

### Blockable Bind Example

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Demonstrates how to bind keys with conditional blocking behavior.

```APIDOC
## Blockable Bind Example

### Description
This example illustrates the use of `blockable_bind` to conditionally block input events. The 'A' key is blocked when the Left Shift key is held down. The 'K' key is also shown with a simple `block_bind`.

### Method
`blockable_bind`, `block_bind`

### Endpoint
N/A (Local Input Binding)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Conditionally block 'A' key when Left Shift is pressed
AKey.blockable_bind(|| {
    if LShiftKey.is_pressed() {
        Block
    } else {
        DontBlock
    }
});

// Simple block for 'K' key
KKey.block_bind(|| ());
```

### Response
N/A (This is an example of input binding, not an API endpoint with a direct response.)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Basic Input Simulation and Event Handling

Source: https://docs.rs/inputbot

This example demonstrates binding keys to simulate typing and an autoclicker. On Linux, this may require running with sudo.

```rust
use inputbot::{KeySequence, KeybdKey::*, MouseButton::*};
use std::{thread::sleep, time::Duration};

fn main() {
    // Bind the number 1 key your keyboard to a function that types 
    // "Hello, world!" when pressed.
    Numrow1Key.bind(|| KeySequence("Hello, world!").send());

    // Bind your caps lock key to a function that starts an autoclicker.
    CapsLockKey.bind(move || {
        while CapsLockKey.is_toggled() {
            LeftButton.press();
            LeftButton.release();

            sleep(Duration::from_millis(30));
        }
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Send KeySequence Example

Source: https://docs.rs/inputbot/latest/inputbot/struct.KeySequence.html

Demonstrates binding a key to send a sequence of characters. Call inputbot::init_device() on Linux to prevent potential startup delays.

```rust
fn main() {
    // If you are on Linux, you may wish to call this function first to avoid a startup delay when
    // the fake device is created. Otherwise, your first input event - if it is a key sequence - may
    // have missing characters.
    //     inputbot::init_device();

    // Bind our Backquote key (`, ~) to a function that types out the string "Hello, world!".
    // You must remember to call the `.send()` method on the KeySequence after creating it.
    // You could explicitly define the KeySequence ahead of time and send it later like so:
    //      let seq: KeySequence = KeySequence("Hello, world!");
    //      seq.send();
    BackquoteKey.bind(|| {
        KeySequence("Hello, world!").send();
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Start Listening for Input Events

Source: https://docs.rs/inputbot/latest/inputbot/fn.handle_input_events.html

Call this function to begin processing bound input events. Ensure all desired bindings are set up before calling this.

```rust
inputbot::handle_input_events();
```

--------------------------------

### Documenting a Function in Rust

Source: https://docs.rs/inputbot/latest/scrape-examples-help.html

This example shows how to document a public function in Rust. Rustdoc will automatically scrape examples that call this function.

```rust
// src/lib.rs
pub fn a_func() {}
```

--------------------------------

### Autoclicker Example

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

This example demonstrates how to bind the right mouse button to autoclick and the Caps Lock key to toggle autoclicking.

```APIDOC
## Autoclicker Example

### Description
This example shows how to bind the right mouse button to perform rapid clicks when held down, and how to bind the Caps Lock key to toggle an autoclicking behavior.

### Method
`bind`

### Endpoint
N/A (Local Input Binding)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// For RightButton autoclick
RightButton.bind(|| {
    while RightButton.is_pressed() {
        LeftButton.press();
        LeftButton.release();
        sleep(Duration::from_millis(30));
    }
});

// For CapsLockKey toggle autoclick
CapsLockKey.bind(move || {
    while CapsLockKey.is_toggled() {
        LeftButton.press();
        LeftButton.release();
        sleep(Duration::from_millis(30));
    }
});
```

### Response
N/A (This is an example of input binding, not an API endpoint with a direct response.)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Bind Input Events with inputbot

Source: https://docs.rs/inputbot/latest/inputbot/enum.MouseButton.html

Demonstrates how to bind mouse and keyboard events to trigger automated actions. Requires calling inputbot::handle_input_events() to start the event loop.

```rust
7fn main() {
8    // Bind our right mouse button to a function that autoclicks every 30 milliseconds. Hold it down
9    // to bake some cookies really fast!
10    RightButton.bind(|| {
11        while RightButton.is_pressed() {
12            LeftButton.press();
13            LeftButton.release();
14
15            sleep(Duration::from_millis(30));
16        }
17    });
18
19    // Bind our Caps Lock key to a function that toggles autoclicking. Go AFK and bake some
20    // cookies really fast without hurting your hands!
21    CapsLockKey.bind(move || {
22        while CapsLockKey.is_toggled() {
23            LeftButton.press();
24            LeftButton.release();
25
26            sleep(Duration::from_millis(30));
27        }
28    });
29
30    // Call this to start listening for bound inputs.
31    inputbot::handle_input_events();
32}
```

--------------------------------

### Sending Key Sequences with Inputbot

Source: https://docs.rs/inputbot/latest/src/key_sequences/key_sequences.rs.html

Demonstrates binding a key to a KeySequence that types a string. Requires calling handle_input_events to start listening.

```rust
use inputbot::{KeySequence, KeybdKey::*};

/// This example demonstrates sending sequences of key presses / characters via a KeySequence.
/// This can be used, for example, to create a macro which types a specific string.

fn main() {
    // If you are on Linux, you may wish to call this function first to avoid a startup delay when
    // the fake device is created. Otherwise, your first input event - if it is a key sequence - may
    // have missing characters.
    //     inputbot::init_device();

    // Bind our Backquote key (`, ~) to a function that types out the string "Hello, world!".
    // You must remember to call the `.send()` method on the KeySequence after creating it.
    // You could explicitly define the KeySequence ahead of time and send it later like so:
    //      let seq: KeySequence = KeySequence("Hello, world!");
    //      seq.send();
    BackquoteKey.bind(|| {
        KeySequence("Hello, world!").send();
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Bind Key with a Simple Block Action

Source: https://docs.rs/inputbot/latest/inputbot/fn.handle_input_events.html

Binds a key ('K') to a function that performs a blocking action. This example shows a minimal block bind.

```rust
KKey.block_bind(|| ());
```

--------------------------------

### Block Input Conditionally with KeybdKey

Source: https://docs.rs/inputbot/latest/src/blockable_binds/blockable_binds.rs.html

Demonstrates blocking the 'A' key when the left shift key is held. Note that callbacks for blockable binds do not execute in new threads. For long-running processes, create new threads within the callback if necessary. This example is not functional on Linux.

```Rust
use inputbot::{BlockInput::*, KeybdKey::*};

fn main() {
    // Block the A key when left shift is held. Note: callbacks for blockable binds won't be
    // executed in new threads, so for long-running processes create new threads inside the callback
    // if needed.
    AKey.blockable_bind(|| {
        if LShiftKey.is_pressed() {
            Block
        } else {
            DontBlock
        }
    });

    // Block the K key when left shift is held.
    KKey.block_bind(|| ());

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Move Mouse Absolutely

Source: https://docs.rs/inputbot/latest/inputbot/struct.MouseCursor.html

Moves the mouse to a specific position on the screen. The top-left corner is (0,0). This example demonstrates moving the cursor horizontally across the screen.

```rust
9fn main() {
    // Bind our 1 key to a function that moves the mouse absolute to your monitors. Note: if you
    // have multiple monitors, 0, 0 might be not where you're expecting. If we wanted to get the
    // absolute position of your primary (or a specific) monitor, we would need to bring in extra
    // libraries.
    Numrow1Key.bind(|| {
        for x in 0..=600 {
            MouseCursor::move_abs(x as i32, 300);
            sleep(Duration::from_millis(1));
        }
    });

    // Bind our 2 key to a function that moves the mouse relative to its current position.
    // This will be 100 pixels over and 100 pixels down.
    Numrow2Key.bind(|| {
        MouseCursor::move_rel(100, 100);
        sleep(Duration::from_millis(1));
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### init_device

Source: https://docs.rs/inputbot/latest/inputbot/fn.init_device.html

Documentation for the init_device function.

```APIDOC
## init_device

### Description
Requests the fake device to be generated. Can be called before using the fake device to prevent it from building when you first try to use it.

### Method
Function Call

### Endpoint
inputbot::init_device()
```

--------------------------------

### Device Initialization

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Initializes the fake input device. This can be called proactively to ensure the device is ready before its first use.

```APIDOC
## init_device

### Description
Requests the fake device to be generated. Can be called before using the fake device to prevent it from building when you first try to use it.

### Method

```rust
pub fn init_device()
```

### Endpoint

N/A (Function call)

### Parameters

None

### Request Example

```rust
inputbot::init_device();
```

### Response

None
```

--------------------------------

### TypeId Function Implementation

Source: https://docs.rs/inputbot/latest/inputbot/enum.BlockInput.html

Gets the TypeId of the current type. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Keyboard Key

Source: https://docs.rs/inputbot/latest/inputbot/fn.get_keybd_key.html

Converts a character to its corresponding `KeybdKey` enum variant. Returns `None` if the character does not map to a known key.

```APIDOC
## Function get_keybd_key

### Description
Converts a character to its corresponding `KeybdKey` enum variant. Returns `None` if the character does not map to a known key.

### Signature
```rust
pub fn get_keybd_key(c: char) -> Option<KeybdKey>
```

### Parameters
#### Path Parameters
- **c** (char) - Required - The character to convert.

### Returns
- **Option<KeybdKey>** - An `Option` containing the `KeybdKey` variant if the character is recognized, otherwise `None`.
```

--------------------------------

### Get KeybdKey from Character

Source: https://docs.rs/inputbot/latest/inputbot/fn.get_keybd_key.html

Converts a character to its corresponding KeybdKey enum variant. Returns None if the character does not map to a known key.

```rust
pub fn get_keybd_key(c: char) -> Option<KeybdKey>
```

--------------------------------

### Initialize the fake device

Source: https://docs.rs/inputbot/latest/inputbot/fn.init_device.html

Call this function to generate the fake device before use, preventing lazy initialization overhead.

```rust
pub fn init_device()
```

--------------------------------

### Send Keyboard Sequences

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Shows how to bind a key to trigger a string sequence. On Linux, consider calling inputbot::init_device() to prevent startup delays.

```rust
6fn main() {
7    // If you are on Linux, you may wish to call this function first to avoid a startup delay when
8    // the fake device is created. Otherwise, your first input event - if it is a key sequence - may
9    // have missing characters.
10    //     inputbot::init_device();
11
12    // Bind our Backquote key (`, ~) to a function that types out the string "Hello, world!".
13    // You must remember to call the `.send()` method on the KeySequence after creating it.
14    // You could explicitly define the KeySequence ahead of time and send it later like so:
15    //      let seq: KeySequence = KeySequence("Hello, world!");
16    //      seq.send();
17    BackquoteKey.bind(|| {
18        KeySequence("Hello, world!").send();
19    });
20
21    // Call this to start listening for bound inputs.
22    inputbot::handle_input_events();
23}
```

--------------------------------

### Initialize Fake Input Device

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Ensures the fake input device is generated. Call this before using the device to avoid potential delays during the first input simulation.

```rust
pub fn init_device() {
    FAKE_DEVICE.lock().unwrap();
}
```

--------------------------------

### Bind All Input Events

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Shows how to register a global callback for all keyboard keys or mouse buttons.

```rust
6fn main() {
7    // Bind all keys to a common callback event.
8    KeybdKey::bind_all(|event| {
9        match inputbot::from_keybd_key(event) {
10            Some(c) => println!("{c}"),
11            None => println!("Unregistered Key"),
12        };
13    });
14
15    // Bind all mouse buttons to a common callback event.
16    MouseButton::bind_all(|event| {
17        println!("{:?}", event);
18    });
19
20    // Call this to start listening for bound inputs.
21    inputbot::handle_input_events();
22}
```

--------------------------------

### Bind All Keys and Mouse Buttons

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Shows how to bind all keyboard keys and mouse buttons to a single callback function.

```APIDOC
## Bind All Keys and Mouse Buttons

### Description
This example demonstrates how to use `bind_all` to attach a single callback function to all keyboard key events and all mouse button events. The callbacks process and print information about the triggered events.

### Method
`bind_all`

### Endpoint
N/A (Local Input Binding)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Bind all keyboard keys
KeybdKey::bind_all(|event| {
    match inputbot::from_keybd_key(event) {
        Some(c) => println!("{c}"),
        None => println!("Unregistered Key"),
    };
});

// Bind all mouse buttons
MouseButton::bind_all(|event| {
    println!("{:?}", event);
});
```

### Response
N/A (This is an example of input binding, not an API endpoint with a direct response.)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Block Key Press Conditionally

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Use `blockable_bind` to conditionally block a key press based on the state of another key. Call `inputbot::handle_input_events()` to start listening for bound inputs.

```rust
fn main() {
    // Block the A key when left shift is held. Note: callbacks for blockable binds won't be
    // executed in new threads, so for long-running processes create new threads inside the callback
    // if needed.
    AKey.blockable_bind(|| {
        if LShiftKey.is_pressed() {
            Block
        } else {
            DontBlock
        }
    });

    // Block the K key when left shift is held.
    KKey.block_bind(|| ());

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Binding a Key to a Callback

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Demonstrates how to use the `bind` method associated with the `KeybdKey` enum to execute a closure when a specific key is pressed.

```APIDOC
## POST /bind

### Description
Binds a specific keyboard key to execute a provided callback function when pressed.

### Method
`impl KeybdKey`

### Endpoint
N/A (This is a method call on an enum variant)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method Signature
`pub fn bind<F: Fn() + Send + Sync + 'static>(self, callback: F)`

- `self`: The `KeybdKey` variant representing the key to bind.
- `callback`: A closure that takes no arguments and returns nothing. It must be `Send`, `Sync`, and have a `'static` lifetime, suitable for running in a separate thread.

### Request Example
```rust
use inputbot::KeybdKey::{self, AKey, EnterKey};

fn main() {
    // Bind the 'A' key to print a message
    AKey.bind(|| {
        println!("A key pressed!");
    });

    // Bind the 'Enter' key to exit the application
    EnterKey.bind(|| {
        println!("Exiting program.");
        std::process::exit(0);
    });

    // Start listening for key events
    inputbot::handle_input_events();
}
```

### Response
This method does not return a value directly. It registers the callback for the specified key.

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Bind Right Mouse Button for Autoclicking

Source: https://docs.rs/inputbot/latest/inputbot/enum.MouseButton.html

Binds the right mouse button to a function that repeatedly clicks the left button while the right button is held down. Requires `inputbot::handle_input_events()` to be called to start listening.

```rust
7fn main() {
    // Bind our right mouse button to a function that autoclicks every 30 milliseconds. Hold it down
    // to bake some cookies really fast!
    RightButton.bind(|| {
        while RightButton.is_pressed() {
            LeftButton.press();
            LeftButton.release();

            sleep(Duration::from_millis(30));
        }
    });

    // Bind our Caps Lock key to a function that toggles autoclicking. Go AFK and bake some
    // cookies really fast without hurting your hands!
    CapsLockKey.bind(move || {
        while CapsLockKey.is_toggled() {
            LeftButton.press();
            LeftButton.release();

            sleep(Duration::from_millis(30));
        }
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### inputbot Crate Entry Point

Source: https://docs.rs/inputbot/latest/src/inputbot/lib.rs.html

This code defines the main library file for the inputbot crate. It includes the README, imports common and public modules, and conditionally includes platform-specific modules for Windows and Linux, re-exporting their public items.

```Rust
#![doc = include_str!("../README.md")]

mod common;

mod public;
pub use crate::public::*;

#[cfg(target_os = "windows")]
mod windows;
#[cfg(target_os = "windows")]
pub use crate::windows::*;

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
pub use crate::linux::*;
```

--------------------------------

### Convert KeybdKey to char

Source: https://docs.rs/inputbot/latest/inputbot/fn.from_keybd_key.html

Demonstrates using from_keybd_key within a bind_all callback to map keyboard events to characters.

```rust
fn main() {
    // Bind all keys to a common callback event.
    KeybdKey::bind_all(|event| {
        match inputbot::from_keybd_key(event) {
            Some(c) => println!("{c}"),
            None => println!("Unregistered Key"),
        };
    });

    // Bind all mouse buttons to a common callback event.
    MouseButton::bind_all(|event| {
        println!("{:?}", event);
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Simulate Keyboard Key Release

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Simulates releasing a `KeybdKey`, setting it to the up position.

```rust
pub fn release(self) {
    let mut device = FAKE_DEVICE.lock().unwrap();

    device.write(0x01, key_to_scan_code(self), 0).unwrap();
    device.synchronize().unwrap();
}
```

--------------------------------

### Use Latest InputBot from GitHub

Source: https://docs.rs/inputbot

If you need the latest features, use this dependency configuration to pull directly from the develop branch of the GitHub repository.

```toml
[dependencies]
inputbot = { git = "https://github.com/obv-mikhail/InputBot", branch = "develop" }
```

--------------------------------

### Type String with Key Sequence

Source: https://docs.rs/inputbot/latest/inputbot/fn.handle_input_events.html

Binds the backquote key to type the string "Hello, world!". Requires calling `.send()` on the `KeySequence`.

```rust
BackquoteKey.bind(|| {
        KeySequence("Hello, world!").send();
    });
```

--------------------------------

### Keyboard Key Simulation

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Provides methods for checking the state of keyboard keys and simulating key presses and releases.

```APIDOC
## KeybdKey API

### Description
Provides functionality to interact with keyboard keys, including checking their pressed state, simulating presses and releases, and checking toggle states for keys like CapsLock.

### Methods

#### `is_pressed(self) -> bool`

- **Description**: Returns `true` if a given `KeybdKey` is currently pressed.
- **Returns**: `bool` - `true` if the key is pressed, `false` otherwise.

#### `press(self)`

- **Description**: Presses a given `KeybdKey`. The key remains in the down position until `release` is called.

#### `release(self)`

- **Description**: Releases a given `KeybdKey`, setting it to the up position.

#### `is_toggled(self) -> bool`

- **Description**: Returns `true` if a keyboard key that supports toggling (ScrollLock, NumLock, CapsLock) is currently on.
- **Returns**: `bool` - `true` if the toggle key is on, `false` otherwise.

### Example Usage

```rust
use inputbot::KeybdKey;

// Check if the 'A' key is pressed
if KeybdKey::AKey.is_pressed() {
    println!("A key is pressed!");
}

// Press and release the 'Enter' key
KeybdKey::EnterKey.press();
inputbot::sleep(std::time::Duration::from_millis(100)); // Simulate holding the key
KeybdKey::EnterKey.release();

// Check if CapsLock is toggled on
if KeybdKey::CapsLockKey.is_toggled() {
    println!("CapsLock is ON");
}
```
```

--------------------------------

### Handle Input Events

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Main loop for dispatching libinput events and processing keyboard or mouse input.

```rust
pub fn handle_input_events() {
    let mut libinput_context = Libinput::new_with_udev(LibinputInterfaceRaw);
    libinput_context
        .udev_assign_seat(&LibinputInterfaceRaw.seat())
        .unwrap();

    while !MOUSE_BINDS.lock().unwrap().is_empty() || !KEYBD_BINDS.lock().unwrap().is_empty() {
        libinput_context.dispatch().unwrap();

        for event in libinput_context.by_ref() {
            handle_input_event(event);
        }

        sleep(Duration::from_millis(10));
    }
}
```

```rust
fn handle_input_event(event: Event) {
    match event {
        Keyboard(KeyboardEvent::Key(keyboard_key_event)) => {
            let key = keyboard_key_event.key();
            if let Some(keybd_key) = scan_code_to_key(key) {
                if keyboard_key_event.key_state() == KeyState::Pressed {
                    KEY_STATES.lock().unwrap().insert(keybd_key, true);

                    if let Some(Bind::NormalBind(cb)) = KEYBD_BINDS.lock().unwrap().get(&keybd_key)
                    {
                        let cb = Arc::clone(cb);
                        spawn(move || cb());
                    }
                } else {
                    KEY_STATES.lock().unwrap().insert(keybd_key, false);
                }
            }
        }
        Pointer(Button(button_event)) => {
            let button = button_event.button();
            if let Some(mouse_button) = match button {
                272 => Some(MouseButton::LeftButton),
                273 => Some(MouseButton::RightButton),
                274 => Some(MouseButton::MiddleButton),
                275 => Some(MouseButton::X1Button),
                276 => Some(MouseButton::X2Button),
                _ => None,
            } {
                if button_event.button_state() == ButtonState::Pressed {
                    BUTTON_STATES.lock().unwrap().insert(mouse_button, true);
                    if let Some(Bind::NormalBind(cb)) =
```

--------------------------------

### KeybdKey Methods

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Methods available for interacting with keyboard keys.

```APIDOC
## pub fn is_pressed(self) -> bool

### Description
Returns true if a given `KeybdKey` is currently pressed (in the down position).

## pub fn press(self)

### Description
Presses a given `KeybdKey`. Note: this means the key will remain in the down position. You must manually call release to create a full ‘press’.

## pub fn release(self)

### Description
Releases a given `KeybdKey`. This means the key would be in the up position.

## pub fn is_toggled(self) -> bool

### Description
Returns true if a keyboard key which supports toggling (ScrollLock, NumLock, CapsLock) is on.

## pub fn unbind(self)

### Description
Removes the binding associated with the key.
```

--------------------------------

### Bind all keyboard and mouse inputs in Rust

Source: https://docs.rs/inputbot/latest/src/bind_all/bind_all.rs.html

Uses bind_all to register a callback for all keyboard keys and mouse buttons. Requires calling handle_input_events to begin listening.

```rust
use inputbot::{KeybdKey, MouseButton};

/// This example demonstrates binding all of the keyboard keys and mouse buttons to a
/// simple function. The function prints the key or button name that was pressed.

fn main() {
    // Bind all keys to a common callback event.
    KeybdKey::bind_all(|event| {
        match inputbot::from_keybd_key(event) {
            Some(c) => println!("{c}"),
            None => println!("Unregistered Key"),
        };
    });

    // Bind all mouse buttons to a common callback event.
    MouseButton::bind_all(|event| {
        println!("{:?}", event);
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Define Input Structures and Bindings

Source: https://docs.rs/inputbot/latest/src/inputbot/public.rs.html

Defines the core enumerations for keyboard keys and mouse buttons, and provides methods for binding callbacks to these inputs.

```rust
1use crate::common::*; 
2use std::{thread::sleep, time::Duration};
3
4use strum::IntoEnumIterator;
5use strum_macros::EnumIter;
6
7pub enum BlockInput {
8    Block,
9    DontBlock,
10}
11
12#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone, EnumIter)]
13pub enum KeybdKey {
14    BackspaceKey,
15    TabKey,
16    EnterKey,
17    EscapeKey,
18    SpaceKey,
19    PageUpKey,
20    PageDownKey,
21    EndKey,
22    HomeKey,
23    LeftKey,
24    UpKey,
25    RightKey,
26    DownKey,
27    InsertKey,
28    DeleteKey,
29    Numrow0Key,
30    Numrow1Key,
31    Numrow2Key,
32    Numrow3Key,
33    Numrow4Key,
34    Numrow5Key,
35    Numrow6Key,
36    Numrow7Key,
37    Numrow8Key,
38    Numrow9Key,
39    AKey,
40    BKey,
41    CKey,
42    DKey,
43    EKey,
44    FKey,
45    GKey,
46    HKey,
47    IKey,
48    JKey,
49    KKey,
50    LKey,
51    MKey,
52    NKey,
53    OKey,
54    PKey,
55    QKey,
56    RKey,
57    SKey,
58    TKey,
59    UKey,
60    VKey,
61    WKey,
62    XKey,
63    YKey,
64    ZKey,
65    LSuper,
66    RSuper,
67    Numpad0Key,
68    Numpad1Key,
69    Numpad2Key,
70    Numpad3Key,
71    Numpad4Key,
72    Numpad5Key,
73    Numpad6Key,
74    Numpad7Key,
75    Numpad8Key,
76    Numpad9Key,
77    F1Key,
78    F2Key,
79    F3Key,
80    F4Key,
81    F5Key,
82    F6Key,
83    F7Key,
84    F8Key,
85    F9Key,
86    F10Key,
87    F11Key,
88    F12Key,
89    F13Key,
90    F14Key,
91    F15Key,
92    F16Key,
93    F17Key,
94    F18Key,
95    F19Key,
96    F20Key,
97    F21Key,
98    F22Key,
99    F23Key,
100    F24Key,
101    NumLockKey,
102    ScrollLockKey,
103    CapsLockKey,
104    LShiftKey,
105    RShiftKey,
106    LControlKey,
107    RControlKey,
108    LAltKey,
109    RAltKey,
110
111    BrowserBackKey,
112    BrowserForwardKey,
113    BrowserRefreshKey,
114
115    VolumeMuteKey,
116    VolumeDownKey,
117    VolumeUpKey,
118
119    MediaNextTrackKey,
120    MediaPrevTrackKey,
121    MediaStopKey,
122    MediaPlayPauseKey,
123
124    BackquoteKey,
125    SlashKey,
126    BackslashKey,
127    CommaKey,
128    PeriodKey,
129    MinusKey,
130    QuoteKey,
131    SemicolonKey,
132    LBracketKey,
133    RBracketKey,
134    EqualKey,
135
136    #[strum(disabled)]
137    OtherKey(u64),
138}
139
140#[derive(Debug, Eq, PartialEq, Hash, Copy, Clone, EnumIter)]
141pub enum MouseButton {
142    LeftButton,
143    MiddleButton,
144    RightButton,
145    X1Button,
146    X2Button,
147
148    #[strum(disabled)]
149    OtherButton(u32),
150}
151
152pub struct MouseCursor;
153
154pub struct MouseWheel;
155
156impl KeybdKey {
157    pub fn bind<F: Fn() + Send + Sync + 'static>(self, callback: F) {
158        KEYBD_BINDS
159            .lock()
160            .unwrap()
161            .insert(self, Bind::NormalBind(Arc::new(callback)));
162    }
163
164    pub fn block_bind<F: Fn() + Send + Sync + 'static>(self, callback: F) {
165        KEYBD_BINDS
166            .lock()
167            .unwrap()
168            .insert(self, Bind::BlockBind(Arc::new(callback)));
169    }
170
171    pub fn blockable_bind<F: Fn() -> BlockInput + Send + Sync + 'static>(self, callback: F) {
172        KEYBD_BINDS
173            .lock()
174            .unwrap()
175            .insert(self, Bind::BlockableBind(Arc::new(callback)));
176    }
177
178    pub fn bind_all<F: Fn(KeybdKey) + Send + Sync + Clone + 'static>(callback: F) {
179        for key in KeybdKey::iter() {
180            let callback = callback.clone();
181            let fire = move || {
182                callback(key);
183            };
184
185            KEYBD_BINDS
186                .lock()
187                .unwrap()
188                .insert(key, Bind::NormalBind(Arc::new(fire)));
189        }
190    }
191
192    pub fn unbind(self) {
193        KEYBD_BINDS.lock().unwrap().remove(&self);
194    }
195}
196
197impl MouseButton {
198    pub fn bind<F: Fn() + Send + Sync + 'static>(self, callback: F) {
199        MOUSE_BINDS
200            .lock()
201            .unwrap()
202            .insert(self, Bind::NormalBind(Arc::new(callback)));
203    }
204
205    pub fn block_bind<F: Fn() + Send + Sync + 'static>(self, callback: F) {
206        MOUSE_BINDS
207            .lock()
208            .unwrap()
209            .insert(self, Bind::BlockBind(Arc::new(callback)));
210    }
211
212    pub fn blockable_bind<F: Fn() -> BlockInput + Send + Sync + 'static>(self, callback: F) {
213        MOUSE_BINDS
214            .lock()
215            .unwrap()
216            .insert(self, Bind::BlockableBind(Arc::new(callback)));
217    }
218
219    pub fn bind_all<F: Fn(MouseButton) + Send + Sync + Clone + 'static>(callback: F) {
220        for btn in MouseButton::iter() {
221            let callback = callback.clone();
222            let fire = move || {
223                callback(btn);
224            };
225
226            MOUSE_BINDS
227                .lock()
228                .unwrap()
```

--------------------------------

### Implement Input Blocking

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Demonstrates how to conditionally block input events. Note that callbacks for blockable binds run in the main thread, so use separate threads for long-running tasks.

```rust
6fn main() {
7    // Block the A key when left shift is held. Note: callbacks for blockable binds won't be
8    // executed in new threads, so for long-running processes create new threads inside the callback
9    // if needed.
10    AKey.blockable_bind(|| {
11        if LShiftKey.is_pressed() {
12            Block
13        } else {
14            DontBlock
15        }
16    });
17
18    // Block the K key when left shift is held.
19    KKey.block_bind(|| ());
20
21    // Call this to start listening for bound inputs.
22    inputbot::handle_input_events();
23}
```

--------------------------------

### Add inputbot to Cargo.toml

Source: https://docs.rs/inputbot

Add this to your Cargo.toml to include the inputbot crate in your project.

```toml
[dependencies]
inputbot = "0.6"
```

--------------------------------

### KeySequence::send

Source: https://docs.rs/inputbot/latest/inputbot/struct.KeySequence.html

Sends the defined string sequence as keyboard input events.

```APIDOC
## KeySequence::send

### Description
Sends the string sequence contained within the KeySequence struct as keyboard input events.

### Method
Rust Method

### Parameters
- **&self** - The KeySequence instance containing the string to be sent.

### Request Example
```rust
KeySequence("Hello, world!").send();
```
```

--------------------------------

### Mouse Button Simulation

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Enables simulation of mouse button presses and checks their current state.

```APIDOC
## MouseButton API

### Description
Provides functionality to interact with mouse buttons, including checking their pressed state and simulating presses.

### Methods

#### `is_pressed(self) -> bool`

- **Description**: Returns `true` if a given `MouseButton` is currently pressed.
- **Returns**: `bool` - `true` if the button is pressed, `false` otherwise.

#### `press(self)`

- **Description**: Presses a given `MouseButton`. The button remains in the down position until `release` is called (though `release` is not explicitly shown in the provided source for `MouseButton`).

### Example Usage

```rust
use inputbot::MouseButton;

// Check if the left mouse button is pressed
if MouseButton::LeftButton.is_pressed() {
    println!("Left mouse button is pressed!");
}

// Press the right mouse button
MouseButton::RightButton.press();
```
```

--------------------------------

### Control Mouse Movement

Source: https://docs.rs/inputbot/latest/inputbot/enum.KeybdKey.html

Illustrates absolute and relative mouse movement using specific key bindings.

```rust
9fn main() {
10    // Bind our 1 key to a function that moves the mouse absolute to your monitors. Note: if you
11    // have multiple monitors, 0, 0 might be not where you're expecting. If we wanted to get the
12    // absolute position of your primary (or a specific) monitor, we would need to bring in extra
13    // libraries.
14    Numrow1Key.bind(|| {
15        for x in 0..=600 {
16            MouseCursor::move_abs(x as i32, 300);
17            sleep(Duration::from_millis(1));
18        }
19    });
20
21    // Bind our 2 key to a function that moves the mouse relative to its current position.
22    // This will be 100 pixels over and 100 pixels down.
23    Numrow2Key.bind(|| {
24        MouseCursor::move_rel(100, 100);
25        sleep(Duration::from_millis(1));
26    });
27
28    // Call this to start listening for bound inputs.
29    inputbot::handle_input_events();
30}
```

--------------------------------

### Move mouse cursor with inputbot

Source: https://docs.rs/inputbot/latest/src/move_mouse/move_mouse.rs.html

Demonstrates binding keyboard keys to absolute and relative mouse movement functions. Requires calling inputbot::handle_input_events() to begin listening for inputs.

```rust
use std::{thread::sleep, time::Duration};

use inputbot::{KeybdKey::*, MouseCursor};

/// This example demonstrates moving the mouse around on the screen both relative to its position,
/// and absolute. To use these functions effectively, you would ideally combine it with a library
/// which exposes your system display resolution, as well as separates different monitors.

fn main() {
    // Bind our 1 key to a function that moves the mouse absolute to your monitors. Note: if you
    // have multiple monitors, 0, 0 might be not where you're expecting. If we wanted to get the
    // absolute position of your primary (or a specific) monitor, we would need to bring in extra
    // libraries.
    Numrow1Key.bind(|| {
        for x in 0..=600 {
            MouseCursor::move_abs(x as i32, 300);
            sleep(Duration::from_millis(1));
        }
    });

    // Bind our 2 key to a function that moves the mouse relative to its current position.
    // This will be 100 pixels over and 100 pixels down.
    Numrow2Key.bind(|| {
        MouseCursor::move_rel(100, 100);
        sleep(Duration::from_millis(1));
    });

    // Call this to start listening for bound inputs.
    inputbot::handle_input_events();
}
```

--------------------------------

### Inputbot Common Types and Bindings

Source: https://docs.rs/inputbot/latest/src/inputbot/common.rs.html

Defines the various types of bind handlers and the global static maps for keyboard and mouse bindings.

```APIDOC
## Inputbot Common Module

### Description
This module provides common types and global static variables used for managing keyboard and mouse input bindings within the inputbot crate.

### Types

- **Bind**: An enum representing different types of input bindings.
  - **NormalBind(BindHandler)**: A standard bind.
  - **BlockBind(BlockBindHandler)**: A bind that blocks further input processing.
  - **BlockableBind(BlockableBindHandler)**: A bind that can optionally block input.

- **BindHandler**: Type alias for an `Arc<dyn Fn() + Send + Sync + 'static>` representing a function to be called for a bind.
- **BlockBindHandler**: Type alias for an `Arc<dyn Fn() + Send + Sync + 'static>` representing a function for a blocking bind.
- **BlockableBindHandler**: Type alias for an `Arc<dyn Fn() -> BlockInput + Send + Sync + 'static>` representing a function for a blockable bind that returns a `BlockInput`.
- **KeybdBindMap**: Type alias for `HashMap<KeybdKey, Bind>` mapping keyboard keys to bind handlers.
- **MouseBindMap**: Type alias for `HashMap<MouseButton, Bind>` mapping mouse buttons to bind handlers.

### Global Static Variables

- **KEYBD_BINDS**: A `Lazy<Mutex<KeybdBindMap>>` that holds the global map for keyboard bindings. It is initialized as an empty `HashMap`.
- **MOUSE_BINDS**: A `Lazy<Mutex<MouseBindMap>>` that holds the global map for mouse bindings. It is initialized as an empty `HashMap`.

### Usage
These types and static variables are fundamental for setting up and managing input event handlers in the inputbot library.
```

--------------------------------

### Simulate Keyboard Key Press

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

Simulates pressing a `KeybdKey`. This action keeps the key in the down position; a separate `release` call is needed for a full key press.

```rust
pub fn press(self) {
    let mut device = FAKE_DEVICE.lock().unwrap();

    device.write(0x01, key_to_scan_code(self), 1).unwrap();
    device.synchronize().unwrap();
}
```

--------------------------------

### Input Event Handling API

Source: https://docs.rs/inputbot/latest/src/inputbot/linux/mod.rs.html

API for handling raw input events from the system.

```APIDOC
## Input Event Handling API

### Description
This API provides functionality to start listening for and handling raw input events, such as keyboard presses and mouse button clicks.

### Methods

#### `handle_input_events()`

- **Description**: Starts listening for bound input events. This function will block and continuously process input events until no more key or mouse binds are registered.
- **Method**: `handle_input_events`
- **Endpoint**: N/A (Function)

### Request Example
```rust
// Start handling input events
handle_input_events();
```

#### `handle_input_event(event: Event)`

- **Description**: Processes a single input event. This is typically called internally by `handle_input_events`.
- **Method**: `handle_input_event`
- **Endpoint**: N/A (Function)
- **Parameters**:
  - **event** (Event) - Required - The input event to handle. This can be a keyboard or pointer event.

### Event Types Handled:

- **Keyboard Events**: Detects key presses and releases, triggering associated callbacks.
- **Pointer Button Events**: Detects mouse button presses and releases, updating button states and triggering callbacks.

### Response
N/A (These are event processing functions, not query endpoints)
```

--------------------------------

### MouseWheel Blanket Implementations

Source: https://docs.rs/inputbot/latest/inputbot/struct.MouseWheel.html

Blanket implementations for the MouseWheel struct.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T

#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T, U> TryFrom<U> for T

#### type Error = Infallible
The type returned in the event of a conversion error.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T

#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### Map characters to keyboard keys

Source: https://docs.rs/inputbot/latest/src/inputbot/public.rs.html

Matches specific characters to their corresponding keyboard key constants.

```rust
'=' | '+' => Some(KeybdKey::EqualKey),
        '\' | '|' => Some(KeybdKey::BackslashKey),
        '\'' | '"' => Some(KeybdKey::QuoteKey),
        _ => None,
    }
}
```

--------------------------------

### TryFrom Function Implementation

Source: https://docs.rs/inputbot/latest/inputbot/enum.BlockInput.html

Performs the conversion. This is part of the TryFrom trait implementation.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```
Tokens:
Raw