Function parse_keyboard_input 

pub fn parse_keyboard_input(input: &str) -> Result<KeyboardInput, KeyParseError>

Parse any keyboard input (key or modifier) with alias support

Examples found in repository

examples/game_input_system.rs (line 70)

    fn add_key_binding(bindings: &mut HashMap<Key, GameAction>, input: &str, action: GameAction) {
        match parse_keyboard_input(input) {
            Ok(KeyboardInput::Key(key)) => {
                bindings.insert(key, action);
                println!("  绑定: '{}' -> {:?}", input, action);
            }
            Ok(KeyboardInput::Modifier(_)) => {
                eprintln!("警告: '{}' 是修饰键，请使用 add_modifier_binding", input);
            }
            Err(e) => {
                eprintln!("警告: 无法解析键绑定 '{}': {}", input, e);
            }
        }
    }

    // 添加修饰键绑定
    fn add_modifier_binding(
        bindings: &mut HashMap<Modifier, GameAction>,
        input: &str,
        action: GameAction,
    ) {
        match parse_keyboard_input(input) {
            Ok(KeyboardInput::Modifier(modifier)) => {
                bindings.insert(modifier, action);
                println!("  绑定: '{}' -> {:?}", input, action);
            }
            Ok(KeyboardInput::Key(_)) => {
                eprintln!("警告: '{}' 是普通键，请使用 add_key_binding", input);
            }
            Err(e) => {
                eprintln!("警告: 无法解析修饰键绑定 '{}': {}", input, e);
            }
        }
    }

examples/validation_tool.rs (line 19)

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/basic_usage.rs (line 25)

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 37)

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示例完成!");
}