### Simulate Mouse Button Press and Release in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Provides examples of simulating mouse button actions, such as left clicks, right clicks, and double clicks, using the inputbot library in Rust. It also shows how to check if a mouse button is currently pressed.

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

fn main() {
    // Simulate a left click
    F1Key.bind(|| {
        LeftButton.press();
        sleep(Duration::from_millis(50));
        LeftButton.release();
        println!("Left click simulated");
    });

    // Simulate a right click
    F2Key.bind(|| {
        RightButton.press();
        sleep(Duration::from_millis(50));
        RightButton.release();
        println!("Right click simulated");
    });

    // Simulate a double click
    F3Key.bind(|| {
        for _ in 0..2 {
            LeftButton.press();
            LeftButton.release();
            sleep(Duration::from_millis(50));
        }
        println!("Double click simulated");
    });

    // Check if mouse button is pressed
    F4Key.bind(|| {
        if LeftButton.is_pressed() {
            println!("Left mouse button is currently held");
        }
    });

    inputbot::handle_input_events(false);
}
```

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

### Control Mouse Cursor Position in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Provides examples for retrieving the current mouse coordinates and moving the cursor to absolute or relative screen positions.

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

fn main() {
    Numrow0Key.bind(|| {
        let (x, y) = MouseCursor::pos();
        println!("Current mouse position: ({}, {})", x, y);
    });

    Numrow1Key.bind(|| {
        for x in 0..=600 {
            MouseCursor::move_abs(x, 300);
            sleep(Duration::from_millis(1));
        }
    });

    Numrow2Key.bind(|| {
        MouseCursor::move_rel(100, 100);
    });

    Numrow3Key.bind(|| {
        MouseCursor::move_abs(0, 0);
    });

    inputbot::handle_input_events(false);
}
```

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

### Rust Input Simulation with InputBot

Source: https://github.com/obv-mikhail/inputbot/blob/develop/README.md

This Rust code snippet demonstrates how to use the InputBot library to bind keyboard keys to specific actions. It shows how to simulate typing a string when a key is pressed and how to create an autoclicker that toggles with the Caps Lock key. The `handle_input_events` function is crucial for starting the event listener.

```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(false);
}
```

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

### Simulate Keyboard Key Press and Release in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to programmatically press and release keyboard keys using the inputbot library in Rust. This includes simulating shortcuts like Ctrl+C and Ctrl+V, and checking the pressed state of keys.

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

fn main() {
    // Simulate Ctrl+C keyboard shortcut
    F5Key.bind(|| {
        LControlKey.press();
        CKey.press();
        sleep(Duration::from_millis(50));
        CKey.release();
        LControlKey.release();
        println!("Simulated Ctrl+C");
    });

    // Simulate Ctrl+V keyboard shortcut
    F6Key.bind(|| {
        LControlKey.press();
        VKey.press();
        sleep(Duration::from_millis(50));
        VKey.release();
        LControlKey.release();
        println!("Simulated Ctrl+V");
    });

    // Check if a key is currently pressed
    F7Key.bind(|| {
        if LShiftKey.is_pressed() {
            println!("Shift is being held!");
        }
        if CapsLockKey.is_toggled() {
            println!("Caps Lock is ON");
        }
    });

    inputbot::handle_input_events(false);
}
```

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

### Bind Keyboard Keys in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to bind specific keyboard keys to actions such as typing sequences, printing messages, or executing complex key combinations using the InputBot library.

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

fn main() {
    Numrow1Key.bind(|| {
        KeySequence("Hello, world!").send();
    });

    EscapeKey.bind(|| {
        println!("Escape key was pressed!");
    });

    F1Key.bind(|| {
        println!("F1 pressed - performing sequence");
        AKey.press();
        sleep(Duration::from_millis(50));
        AKey.release();
    });

    inputbot::handle_input_events(false);
}
```

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

### Serde Deserialization for Keybindings in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to use Serde for deserializing keyboard and mouse key configurations from external files (like TOML or JSON) in Rust. This enables flexible and configurable keybindings for applications using the inputbot library.

```rust
use inputbot::{KeySequence, KeybdKey};
use serde::Deserialize;

#[derive(Deserialize)]
struct Config {
    hello_key: KeybdKey,
    world_key: KeybdKey,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse configuration from TOML
    let config: Config = toml::from_str(r#"
        hello_key = "numpad1"
        world_key = "numpad2"
    "#)?;

    // Use deserialized keys for bindings
    config.hello_key.block_bind(|| {
        KeySequence("Hello,").send();
    });

    config.world_key.block_bind(|| {
        KeySequence(" World!").send();
    });

    inputbot::handle_input_events(false);
    Ok(())
}
```

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

### Bind Keyboard Release Events in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Shows how to bind a callback to key release events, which is supported on Windows. This allows for precise detection of when a key is lifted.

```rust
use inputbot::KeybdKey;

fn main() {
    KeybdKey::bind_all_release(|key| {
        match inputbot::from_keybd_key(key) {
            Some(c) => println!("Released key: {}", c),
            None => println!("Released unregistered key: {:?}", key),
        };
    });

    inputbot::handle_input_events(false);
}
```

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

### Serde Deserialization Support API

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Enable Serde deserialization for KeybdKey and MouseButton, allowing configurable keybindings from various file formats.

```APIDOC
## Serde Deserialization Support

With the `serde` feature enabled, `KeybdKey` and `MouseButton` can be deserialized from configuration files. Enables configurable keybindings from TOML, JSON, or other formats.

### Method
Not applicable (this describes functionality, not a specific endpoint).

### Endpoint
Not applicable.

### Parameters
Not applicable.

### Request Example
```rust
use inputbot::{KeySequence, KeybdKey};
use serde::Deserialize;

#[derive(Deserialize)]
struct Config {
    hello_key: KeybdKey,
    world_key: KeybdKey,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse configuration from TOML
    let config: Config = toml::from_str(r#"
        hello_key = "numpad1"
        world_key = "numpad2"
    "#)?;

    // Use deserialized keys for bindings
    config.hello_key.block_bind(|| {
        KeySequence("Hello,").send();
    });

    config.world_key.block_bind(|| {
        KeySequence(" World!").send();
    });

    inputbot::handle_input_events(false);
    Ok(())
}
```

### Response
Not applicable.
```

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

### Bind Mouse Buttons in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Illustrates how to bind specific mouse buttons and scroll wheel events to custom logic, such as creating an autoclicker or retrieving cursor coordinates.

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

fn main() {
    RightButton.bind(|| {
        while RightButton.is_pressed() {
            LeftButton.press();
            LeftButton.release();
            sleep(Duration::from_millis(30));
        }
    });

    MiddleButton.bind(|| {
        let (x, y) = inputbot::MouseCursor::pos();
        println!("Middle click at position: ({}, {})", x, y);
    });

    MousewheelUp.bind(|| {
        println!("Mouse wheel scrolled up");
    });

    MousewheelDown.bind(|| {
        println!("Mouse wheel scrolled down");
    });

    inputbot::handle_input_events(false);
}
```

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

### Automate Mouse Wheel Scrolling in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to programmatically trigger vertical and horizontal mouse wheel events using the MouseWheel utility.

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

fn main() {
    UpKey.bind(|| {
        MouseWheel::scroll_ver(3);
    });

    DownKey.bind(|| {
        MouseWheel::scroll_ver(-3);
    });

    LeftKey.bind(|| {
        MouseWheel::scroll_hor(-3);
    });

    RightKey.bind(|| {
        MouseWheel::scroll_hor(3);
    });

    inputbot::handle_input_events(false);
}
```

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

### Key Press and Release API

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Simulate programmatic pressing and releasing of keyboard keys. Keys remain pressed until explicitly released.

```APIDOC
## Key Press and Release

Directly press and release keyboard keys programmatically. Keys remain in the pressed state until explicitly released.

### Method
Not applicable (this describes functionality, not a specific endpoint).

### Endpoint
Not applicable.

### Parameters
Not applicable.

### Request Example
```rust
use inputbot::KeybdKey::*;
use std::{thread::sleep, time::Duration};

fn main() {
    // Simulate Ctrl+C keyboard shortcut
    F5Key.bind(|| {
        LControlKey.press();
        CKey.press();
        sleep(Duration::from_millis(50));
        CKey.release();
        LControlKey.release();
        println!("Simulated Ctrl+C");
    });

    // Simulate Ctrl+V keyboard shortcut
    F6Key.bind(|| {
        LControlKey.press();
        VKey.press();
        sleep(Duration::from_millis(50));
        VKey.release();
        LControlKey.release();
        println!("Simulated Ctrl+V");
    });

    // Check if a key is currently pressed
    F7Key.bind(|| {
        if LShiftKey.is_pressed() {
            println!("Shift is being held!");
        }
        if CapsLockKey.is_toggled() {
            println!("Caps Lock is ON");
        }
    });

    inputbot::handle_input_events(false);
}
```

### Response
Not applicable.
```

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

### Implement Conditional Input Blocking with Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to use blockable_bind to conditionally suppress system input based on runtime logic. The callback returns Block or DontBlock to determine if the event is consumed.

```rust
use inputbot::{BlockInput::*, KeybdKey::*, MouseButton::*};
use std::thread;

fn main() {
    AKey.blockable_bind(|| {
        if LShiftKey.is_pressed() {
            println!("Blocked A key (Shift was held)");
            Block
        } else {
            DontBlock
        }
    });

    MousewheelDown.blockable_bind(|| {
        if LControlKey.is_pressed() {
            thread::spawn(|| {
                LeftButton.press();
                LeftButton.release();
                println!("Ctrl+Scroll converted to click");
            });
            Block
        } else {
            DontBlock
        }
    });

    inputbot::handle_input_events(false);
}
```

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

### Force Input Blocking with Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Shows how to use block_bind to intercept and suppress specific keys entirely, replacing them with custom logic or sequences.

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

fn main() {
    KKey.block_bind(|| {
        println!("K key blocked and replaced with custom action");
    });

    Numpad1Key.block_bind(|| {
        KeySequence("Hello,").send();
    });

    Numpad2Key.block_bind(|| {
        KeySequence(" World!").send();
    });

    inputbot::handle_input_events(false);
}
```

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

### Bind All Keyboard Keys in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Registers a global callback that triggers for any keyboard key press, useful for logging or centralized input monitoring.

```rust
use inputbot::KeybdKey;

fn main() {
    KeybdKey::bind_all(|key| {
        match inputbot::from_keybd_key(key) {
            Some(c) => println!("Key pressed: {}", c),
            None => println!("Special key pressed: {:?}", key),
        };
    });

    inputbot::handle_input_events(false);
}
```

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

### InputBot Dependency Management

Source: https://github.com/obv-mikhail/inputbot/blob/develop/README.md

This TOML snippet shows how to add the InputBot library as a dependency to your Rust project using Cargo. It includes instructions for both the stable version from crates.io and the development version from a Git repository.

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

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

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

### Bind All Mouse Buttons in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Registers global callbacks for all mouse button press and release events, enabling comprehensive mouse activity monitoring.

```rust
use inputbot::MouseButton;

fn main() {
    MouseButton::bind_all(|button| {
        println!("Mouse button pressed: {:?}", button);
    });

    MouseButton::bind_all_release(|button| {
        println!("Mouse button released: {:?}", button);
    });

    inputbot::handle_input_events(false);
}
```

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

### Mouse Button Press and Release API

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Simulate programmatic pressing and releasing of mouse buttons. Buttons remain pressed until explicitly released.

```APIDOC
## Mouse Button Press and Release

Directly press and release mouse buttons programmatically. Buttons remain in the pressed state until explicitly released.

### Method
Not applicable (this describes functionality, not a specific endpoint).

### Endpoint
Not applicable.

### Parameters
Not applicable.

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

fn main() {
    // Simulate a left click
    F1Key.bind(|| {
        LeftButton.press();
        sleep(Duration::from_millis(50));
        LeftButton.release();
        println!("Left click simulated");
    });

    // Simulate a right click
    F2Key.bind(|| {
        RightButton.press();
        sleep(Duration::from_millis(50));
        RightButton.release();
        println!("Right click simulated");
    });

    // Simulate a double click
    F3Key.bind(|| {
        for _ in 0..2 {
            LeftButton.press();
            LeftButton.release();
            sleep(Duration::from_millis(50));
        }
        println!("Double click simulated");
    });

    // Check if mouse button is pressed
    F4Key.bind(|| {
        if LeftButton.is_pressed() {
            println!("Left mouse button is currently held");
        }
    });

    inputbot::handle_input_events(false);
}
```

### Response
Not applicable.
```

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

### Unbind Keys Dynamically in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Shows how to remove previously registered key bindings at runtime using the inputbot library in Rust. This is useful for managing hotkeys dynamically, allowing for flexible control over application behavior.

```rust
use inputbot::KeybdKey::*;

fn main() {
    // Bind F1 to an action
    F1Key.bind(|| {
        println!("F1 pressed");
    });

    // Bind F2 to unbind F1
    F2Key.bind(|| {
        F1Key.unbind();
        println!("F1 has been unbound");
    });

    // Check if a key is bound
    F3Key.bind(|| {
        if F1Key.is_bound() {
            println!("F1 is currently bound");
        } else {
            println!("F1 is not bound");
        }
    });

    inputbot::handle_input_events(false);
}
```

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

### Detect Toggle Key States (CapsLock, NumLock, ScrollLock) in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Illustrates how to detect the state of toggle keys like CapsLock, NumLock, and ScrollLock using the inputbot library in Rust. This functionality is useful for creating automated tools that react to specific key states.

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

fn main() {
    // Autoclicker that runs while CapsLock is toggled on
    CapsLockKey.bind(move || {
        while CapsLockKey.is_toggled() {
            LeftButton.press();
            LeftButton.release();
            sleep(Duration::from_millis(30));
        }
    });

    // Check scroll lock state
    ScrollLockKey.bind(|| {
        if ScrollLockKey.is_toggled() {
            println!("Scroll Lock is now ON");
        } else {
            println!("Scroll Lock is now OFF");
        }
    });

    // Check num lock state
    NumLockKey.bind(|| {
        if NumLockKey.is_toggled() {
            println!("Num Lock is now ON");
        } else {
            println!("Num Lock is now OFF");
        }
    });

    inputbot::handle_input_events(false);
}
```

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

### Simulate Text Typing with Key Sequences in Rust

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Utilizes the KeySequence struct to simulate complex typing, including automatic handling of shift-key modifiers for uppercase and special characters.

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

fn main() {
    #[cfg(target_os = "linux")]
    inputbot::init_device();

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

    F2Key.bind(|| {
        KeySequence("Dear Customer,\n\nThank you for your inquiry.\n\nBest regards").send();
    });

    let my_sequence = KeySequence("Typed via KeySequence!");
    F3Key.bind(move || {
        my_sequence.send();
    });

    inputbot::handle_input_events(false);
}
```

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

### Stop InputBot Event Loop Programmatically

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Demonstrates how to terminate the input event loop using the stop_handling_input_events function. This can be triggered via a specific key binding or from a separate background thread.

```rust
use inputbot::KeybdKey::*;
use std::thread;

fn main() {
    // Bind Escape to stop the event loop
    EscapeKey.bind(|| {
        println!("Stopping input handler...");
        inputbot::stop_handling_input_events();
    });

    // Alternative: stop from another thread after delay
    thread::spawn(|| {
        std::thread::sleep(std::time::Duration::from_secs(30));
        inputbot::stop_handling_input_events();
        println!("Input handler stopped after 30 seconds");
    });

    // Start with auto_stop=true to stop when all binds are removed
    inputbot::handle_input_events(true);

    println!("Event loop has ended");
}
```

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

### Toggle Key State Detection API

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Detect the state of toggle keys like CapsLock, NumLock, and ScrollLock.

```APIDOC
## Toggle Key State Detection

Check if toggle keys (CapsLock, NumLock, ScrollLock) are currently enabled. Useful for creating autoclickers or mode-based automation.

### Method
Not applicable (this describes functionality, not a specific endpoint).

### Endpoint
Not applicable.

### Parameters
Not applicable.

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

fn main() {
    // Autoclicker that runs while CapsLock is toggled on
    CapsLockKey.bind(move || {
        while CapsLockKey.is_toggled() {
            LeftButton.press();
            LeftButton.release();
            sleep(Duration::from_millis(30));
        }
    });

    // Check scroll lock state
    ScrollLockKey.bind(|| {
        if ScrollLockKey.is_toggled() {
            println!("Scroll Lock is now ON");
        } else {
            println!("Scroll Lock is now OFF");
        }
    });

    // Check num lock state
    NumLockKey.bind(|| {
        if NumLockKey.is_toggled() {
            println!("Num Lock is now ON");
        } else {
            println!("Num Lock is now OFF");
        }
    });

    inputbot::handle_input_events(false);
}
```

### Response
Not applicable.
```

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

### Unbind Keys API

Source: https://context7.com/obv-mikhail/inputbot/llms.txt

Remove previously registered key bindings at runtime for dynamic hotkey management.

```APIDOC
## Unbind Keys

Remove previously registered key bindings at runtime. Useful for dynamic hotkey management.

### Method
Not applicable (this describes functionality, not a specific endpoint).

### Endpoint
Not applicable.

### Parameters
Not applicable.

### Request Example
```rust
use inputbot::KeybdKey::*;

fn main() {
    // Bind F1 to an action
    F1Key.bind(|| {
        println!("F1 pressed");
    });

    // Bind F2 to unbind F1
    F2Key.bind(|| {
        F1Key.unbind();
        println!("F1 has been unbound");
    });

    // Check if a key is bound
    F3Key.bind(|| {
        if F1Key.is_bound() {
            println!("F1 is currently bound");
        } else {
            println!("F1 is not bound");
        }
    });

    inputbot::handle_input_events(false);
}
```

### Response
Not applicable.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.