Enum KeyboardInput 

pub enum KeyboardInput {
    Key(Key),
    Modifier(Modifier),
}

Unified keyboard input type that can represent both keys and modifiers

Variants

Key(Key)

Regular key

Modifier(Modifier)

Modifier key

Implementations

impl KeyboardInput

pub fn as_str(&self) -> &'static str

Get the string representation of the keyboard input

pub fn to_code(&self, platform: Platform) -> usize

Convert to platform-specific code

Examples found in repository

examples/typing_simulation.rs (line 14)

pub fn typing_string(text: &str) -> Result<(), KeyParseError> {
    // 1. 解析输入字符串（支持别名）
    let input = text.parse::<KeyboardInput>()?;

    // 2. 获取当前平台虚拟键码
    let platform = Platform::current();
    let vk_code = input.to_code(platform);

    // 3. 模拟键盘按下和释放
    simulate_key_press(vk_code)?;

    Ok(())
}

examples/validation_tool.rs (line 23)

fn main() {
    println!("=== 验证工具示例 ===\n");

    // 测试往返转换
    let test_inputs = ["a", "ctrl", "esc", "return", "lctrl"];
    let platform = current_platform();
    println!("当前平台: {}", platform);
    println!("往返转换测试:");
    for input in test_inputs {
        println!("\n测试: '{}'", input);

        // 字符串 -> 枚举
        if let Ok(keyboard_input) = parse_keyboard_input(input) {
            println!("  解析: {}", keyboard_input);

            // 枚举 -> 虚拟键码 (使用当前平台)
            let vk_code = keyboard_input.to_code(platform);
            println!("  {} VK: 0x{:02X}", platform, vk_code);

            // 虚拟键码 -> 枚举
            if let Some(round_tripped) = KeyboardInput::from_code(vk_code, platform) {
                println!("  往返: {}", round_tripped);

                if keyboard_input == round_tripped {
                    println!("  ✓ 往返转换成功");
                } else {
                    println!("  ✗ 往返转换失败");
                }
            }
        } else {
            println!("  ✗ 解析失败");
        }
    }

    println!("\n示例完成!");
}

examples/keyboard_input_usage.rs (line 21)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

examples/basic_usage.rs (line 30)

fn main() {
    println!("=== 键盘代码库基础用法示例 ===\n");

    // 1. 基本键解析
    println!("1. 基本键解析:");
    let key: Key = "Enter".parse().unwrap();
    println!(
        "   'Enter' -> {:?} -> Windows VK: {:02X}",
        key,
        key.to_code(Platform::Windows)
    );

    // 2. 别名支持
    println!("\n2. 别名支持:");
    let inputs = ["ctrl", "esc", "return", "del", "cmd"];
    for input in inputs {
        if let Ok(ki) = parse_keyboard_input(input) {
            println!(
                "   '{}' -> {} -> VK: {:02X}",
                input,
                ki,
                ki.to_code(Platform::Windows)
            );
        }
    }

    // 3. 快捷方式解析
    println!("\n3. 快捷方式解析:");
    let shortcuts = ["ctrl+c", "shift+tab", "ctrl+alt+del", "cmd+q"];
    for shortcut in shortcuts {
        if let Ok(parsed) = parse_shortcut_with_aliases(shortcut) {
            println!("   '{}' -> {}", shortcut, parsed);
        }
    }

    // 4. 跨平台代码转换
    println!("\n4. 跨平台代码转换:");
    let key = Key::A;
    println!("   Key::A 代码:");
    println!("   - Windows: {:02X}", key.to_code(Platform::Windows));
    println!("   - Linux: {}", key.to_code(Platform::Linux));
    println!("   - macOS: {}", key.to_code(Platform::MacOS));

    // 5. 当前平台检测
    println!("\n5. 当前平台: {}", current_platform());
}

examples/macro_system.rs (line 38)

fn main() {
    println!("=== 宏系统示例 ===\n");

    let platform = current_platform();
    println!("当前平台: {}\n", platform);

    // 演示宏录制概念
    println!("宏录制概念演示:");

    // 定义一些宏步骤 - 修复解析问题
    let macro_steps = [
        ("输入文本", "Hello", MacroActionType::Text),
        ("快捷键", "ctrl+a", MacroActionType::Shortcut),
        ("快捷键", "ctrl+c", MacroActionType::Shortcut),
        ("导航", "arrowdown", MacroActionType::SingleKey),
        ("快捷键", "ctrl+v", MacroActionType::Shortcut),
        ("功能键", "f5", MacroActionType::SingleKey),
        ("修饰键", "shift", MacroActionType::SingleKey),
    ];

    for (i, (action, input, action_type)) in macro_steps.iter().enumerate() {
        println!("  步骤 {}: {} -> '{}'", i + 1, action, input);

        match action_type {
            MacroActionType::Text => {
                // 文本输入 - 分解为单个字符
                println!("      -> 文本输入: '{}'", input);
                for ch in input.chars() {
                    if let Ok(keyboard_input) = parse_keyboard_input(&ch.to_string()) {
                        let vk_code = keyboard_input.to_code(platform);
                        println!(
                            "        字符 '{}' -> {} (VK: 0x{:02X})",
                            ch, keyboard_input, vk_code
                        );
                    }
                }
            }
            MacroActionType::Shortcut => {
                // 快捷方式解析
                match parse_shortcut_with_aliases(input) {
                    Ok(shortcut) => {
                        let modifier_codes: Vec<String> = shortcut
                            .modifiers
                            .iter()
                            .map(|m| format!("0x{:02X}", m.to_code(platform)))
                            .collect();
                        let key_code = shortcut.key.to_code(platform);
                        println!(
                            "      -> 快捷方式: {} (修饰键: {:?}, 主键: 0x{:02X})",
                            shortcut, modifier_codes, key_code
                        );
                    }
                    Err(e) => {
                        println!("      -> 解析失败: {}", e);
                    }
                }
            }
            MacroActionType::SingleKey => {
                // 单个键解析
                match parse_keyboard_input(input) {
                    Ok(keyboard_input) => {
                        let vk_code = keyboard_input.to_code(platform);
                        println!("      -> {} (VK: 0x{:02X})", keyboard_input, vk_code);
                    }
                    Err(e) => {
                        println!("      -> 解析失败: {}", e);
                    }
                }
            }
        }
    }

    // 演示宏回放概念
    println!("\n宏回放概念演示:");

    let playback_macro = vec![
        MacroStep::Shortcut(parse_shortcut_with_aliases("ctrl+a").unwrap()),
        MacroStep::Shortcut(parse_shortcut_with_aliases("ctrl+c").unwrap()),
        MacroStep::Key(Key::ArrowDown),
        MacroStep::Shortcut(parse_shortcut_with_aliases("ctrl+v").unwrap()),
    ];

    for (i, step) in playback_macro.iter().enumerate() {
        println!("  执行步骤 {}: {}", i + 1, step);
    }

    println!("\n示例完成!");
}

pub fn from_code(code: usize, platform: Platform) -> Option<Self>

Parse from platform-specific code

Examples found in repository

examples/game_input_system.rs (line 105)

    fn handle_key_event(&self, vk_code: usize) -> Option<GameAction> {
        if let Some(keyboard_input) = KeyboardInput::from_code(vk_code, self.platform) {
            match keyboard_input {
                KeyboardInput::Key(key) => {
                    // 查找普通键绑定
                    if let Some(action) = self.key_bindings.get(&key) {
                        return Some(*action);
                    }
                }
                KeyboardInput::Modifier(modifier) => {
                    // 查找修饰键绑定
                    if let Some(action) = self.modifier_bindings.get(&modifier) {
                        return Some(*action);
                    }
                }
            }
        }
        None
    }

    fn list_bindings(&self) {
        println!("\n普通键绑定:");
        let mut keys: Vec<_> = self.key_bindings.iter().collect();
        keys.sort_by_key(|(key, _)| key.as_str());
        for (key, action) in keys {
            println!("  {:15} -> {:?}", key, action);
        }

        println!("\n修饰键绑定:");
        let mut modifiers: Vec<_> = self.modifier_bindings.iter().collect();
        modifiers.sort_by_key(|(modifier, _)| modifier.as_str());
        for (modifier, action) in modifiers {
            println!("  {:15} -> {:?}", modifier, action);
        }
    }

    // 处理组合键（例如：Shift + 某个键）
    fn handle_combo_event(
        &self,
        modifier_vks: &[usize],
        key_vk: usize,
    ) -> Option<(Vec<Modifier>, GameAction)> {
        let modifiers: Vec<Modifier> = modifier_vks
            .iter()
            .filter_map(|&code| {
                if let Some(KeyboardInput::Modifier(modifier)) =
                    KeyboardInput::from_code(code, self.platform)
                {
                    Some(modifier)
                } else {
                    None
                }
            })
            .collect();

        if let Some(KeyboardInput::Key(key)) = KeyboardInput::from_code(key_vk, self.platform) {
            if let Some(action) = self.key_bindings.get(&key) {
                return Some((modifiers, *action));
            }
        }

        None
    }

examples/validation_tool.rs (line 27)

fn main() {
    println!("=== 验证工具示例 ===\n");

    // 测试往返转换
    let test_inputs = ["a", "ctrl", "esc", "return", "lctrl"];
    let platform = current_platform();
    println!("当前平台: {}", platform);
    println!("往返转换测试:");
    for input in test_inputs {
        println!("\n测试: '{}'", input);

        // 字符串 -> 枚举
        if let Ok(keyboard_input) = parse_keyboard_input(input) {
            println!("  解析: {}", keyboard_input);

            // 枚举 -> 虚拟键码 (使用当前平台)
            let vk_code = keyboard_input.to_code(platform);
            println!("  {} VK: 0x{:02X}", platform, vk_code);

            // 虚拟键码 -> 枚举
            if let Some(round_tripped) = KeyboardInput::from_code(vk_code, platform) {
                println!("  往返: {}", round_tripped);

                if keyboard_input == round_tripped {
                    println!("  ✓ 往返转换成功");
                } else {
                    println!("  ✗ 往返转换失败");
                }
            }
        } else {
            println!("  ✗ 解析失败");
        }
    }

    println!("\n示例完成!");
}

examples/keyboard_input_usage.rs (line 25)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

pub fn is_key(&self) -> bool

Check if this is a regular key

Examples found in repository

examples/keyboard_input_usage.rs (line 12)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

pub fn is_modifier(&self) -> bool

Check if this is a modifier key

Examples found in repository

examples/keyboard_input_usage.rs (line 13)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

pub fn as_key(&self) -> Option<Key>

Get the inner key if this is a Key variant

Examples found in repository

examples/keyboard_input_usage.rs (line 15)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

pub fn as_modifier(&self) -> Option<Modifier>

Get the inner modifier if this is a Modifier variant

pub fn parse_with_aliases(input: &str) -> Result<Self, KeyParseError>

Parse with alias and case-insensitive support

Examples found in repository

examples/keyboard_input_usage.rs (line 33)

fn main() -> Result<(), KeyParseError> {
    // 1. 从字符串创建 KeyboardInput
    let key_a = "A".parse::<KeyboardInput>()?;
    let modifier_ctrl = "Control".parse::<KeyboardInput>()?;
    let _alias_esc = "esc".parse::<KeyboardInput>()?; // 使用别名

    // 2. 类型检查与转换
    println!("key_a 是普通键: {}", key_a.is_key()); // true
    println!("modifier_ctrl 是修饰键: {}", modifier_ctrl.is_modifier()); // true

    if let Some(key) = key_a.as_key() {
        println!("获取内部 Key: {}", key);
    }

    // 3. 平台键码转换
    let platform = current_platform();
    let code_a = key_a.to_code(platform);
    println!("A 键在 {} 的键码: 0x{:02X}", platform, code_a);

    // 4. 从键码反解析
    if let Some(parsed) = KeyboardInput::from_code(code_a, platform) {
        println!("从键码反解析: {}", parsed);
    }

    // 5. 高级解析（带别名和大小写不敏感）
    let inputs = ["Ctrl", "SHIFT", "alt", "F1", "space"];
    println!("\n高级解析测试:");
    for input in inputs {
        match KeyboardInput::parse_with_aliases(input) {
            Ok(kb_input) => println!("  '{}' -> {}", input, kb_input),
            Err(e) => println!("  '{}' 解析失败: {}", input, e),
        }
    }

    // 6. 显示实现
    println!("\nDisplay 实现:");
    println!("{} + {} = 组合键", modifier_ctrl, key_a);

    Ok(())
}

Trait Implementations

impl Clone for KeyboardInput

fn clone(&self) -> KeyboardInput

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyboardInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for KeyboardInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for KeyboardInput

type Err = KeyParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for KeyboardInput

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl KeyCodeMapper for KeyboardInput

fn to_code(&self, platform: Platform) -> usize

Convert the key or modifier to a platform-specific code

fn from_code(code: usize, platform: Platform) -> Option<Self>

Parse a key or modifier from a platform-specific code

impl PartialEq for KeyboardInput

fn eq(&self, other: &KeyboardInput) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for KeyboardInput

impl Eq for KeyboardInput

impl StructuralPartialEq for KeyboardInput