Rust终端工具Wezterm输入处理库wezterm-input-types的使用，解析与扩展终端输入事件类型

安装

在项目目录中运行以下Cargo命令：

cargo add wezterm-input-types

或者在Cargo.toml中添加以下行：

wezterm-input-types = "0.1.0"

基本使用

wezterm-input-types库提供了处理终端输入事件的功能。以下是一个基本使用示例：

use wezterm_input_types::{KeyCode, KeyModifiers, MouseEvent};

fn handle_key_event(key: KeyCode, mods: KeyModifiers) {
    match key {
        KeyCode::Char(c) => println!("Pressed character: {} with modifiers {:?}", c, mods),
        KeyCode::Enter => println!("Pressed Enter"),
        _ => println!("Other key: {:?}", key),
    }
}

fn handle_mouse_event(event: MouseEvent) {
    println!("Mouse event: {:?}", event);
}

fn main() {
    // 模拟键盘输入
    handle_key_event(KeyCode::Char('a'), KeyModifiers::NONE);
    handle_key_event(KeyCode::Enter, KeyModifiers::SHIFT);
    
    // 模拟鼠标输入
    handle_mouse_event(MouseEvent {
        x: 100,
        y: 200,
        button: 1,
        modifiers: KeyModifiers::CTRL,
    });
}

完整示例

以下是一个更完整的示例，展示了如何解析和扩展终端输入事件：

use wezterm_input_types::{
    KeyCode, KeyModifiers, MouseButton, MouseEvent, InputEvent, InputParser
};

struct CustomInputHandler;

impl CustomInputHandler {
    fn handle_event(&mut self, event: InputEvent) {
        match event {
            InputEvent::Key(key_event) => {
                println!("Key event: {:?}", key_event);
                self.handle_key(key_event.key, key_event.mods);
            }
            InputEvent::Mouse(mouse_event) => {
                println!("Mouse event: {:?}", mouse_event);
                self.handle_mouse(mouse_event);
            }
            InputEvent::Paste(text) => {
                println!("Pasted text: {}", text);
            }
            _ => println!("Other input event: {:?}", event),
        }
    }

    fn handle_key(&self, key: KeyCode, mods: KeyModifiers) {
        // 自定义键盘处理逻辑
        match (key, mods) {
            (KeyCode::Char('c'), KeyModifiers::CTRL) => {
                println!("Ctrl+C pressed - handling custom behavior");
            }
            (KeyCode::F(n), _) => {
                println!("Function key F{} pressed", n);
            }
            _ => println!("Regular key: {:?} with mods {:?}", key, mods),
        }
    }

    fn handle_mouse(&self, event: MouseEvent) {
        // 自定义鼠标处理逻辑
        let button = match event.button {
            MouseButton::Left => "left",
            MouseButton::Right => "right",
            MouseButton::Middle => "middle",
            MouseButton::None => "none",
            _ => "other",
        };

        println!(
            "Mouse at ({}, {}), button: {}, mods: {:?}",
            event.x, event.y, button, event.modifiers
        );
    }
}

fn main() {
    let mut handler = CustomInputHandler;
    let mut parser = InputParser::new();

    // 模拟输入数据流
    let input_data = b"\x1b[32;100;200M"; // 模拟鼠标点击事件

    for byte in input_data {
        if let Some(event) = parser.advance(&[*byte]) {
            handler.handle_event(event);
        }
    }
}

扩展输入事件类型

您可以通过实现自定义的输入事件类型来扩展功能：

use wezterm_input_types::{InputEvent, KeyCode, KeyModifiers};

#[derive(Debug)]
enum CustomInputEvent {
    Standard(InputEvent),
    CustomGesture(String),
}

struct ExtendedInputHandler;

impl ExtendedInputHandler {
    fn handle_custom_event(&self, event: CustomInputEvent) {
        match event {
            CustomInputEvent::Standard(std_event) => {
                println!("Standard event: {:?}", std_event);
            }
            CustomInputEvent::CustomGesture(gesture) => {
                println!("Custom gesture detected: {}", gesture);
                self.handle_gesture(gesture);
            }
        }
    }

    fn handle_gesture(&self, gesture: String) {
        match gesture.as_str() {
            "swipe-left" => println!("Handling swipe left gesture"),
            "swipe-right" => println!("Handling swipe right gesture"),
            _ => println!("Unknown gesture: {}", gesture),
        }
    }
}

fn create_custom_events() -> Vec<CustomInputEvent> {
    vec![
        CustomInputEvent::Standard(InputEvent::Key(
            KeyCode::Char('a').with_modifiers(KeyModifiers::NONE)
        )),
        CustomInputEvent::CustomGesture("swipe-left".to_string()),
    ]
}

fn main() {
    let handler = ExtendedInputHandler;
    let events = create_custom_events();

    for event in events {
        handler.handle_custom_event(event);
    }
}

这个库是Wezterm终端模拟器的一部分，专门用于处理终端输入事件。它提供了强大的功能来解析和响应各种键盘和鼠标事件，并可以轻松扩展以支持自定义输入类型。