Qt键盘组合

1. 键盘事件处理基础

在Qt中，键盘事件主要通过QKeyEvent类来处理。要捕获键盘组合键，我们需要重写相应的事件处理函数。

1.1 主要的事件处理函数

// 键盘按下事件
void keyPressEvent(QKeyEvent *event);

// 键盘释放事件  
void keyReleaseEvent(QKeyEvent *event);

2. 基本组合键捕获实现

2.1 在QWidget中捕获组合键

// KeyCaptureWidget.h
#ifndef KEYCAPTUREWIDGET_H
#define KEYCAPTUREWIDGET_H

#include <QWidget>
#include <QKeyEvent>
#include <QLabel>
#include <QVBoxLayout>

class KeyCaptureWidget : public QWidget
{
    Q_OBJECT

public:
    explicit KeyCaptureWidget(QWidget *parent = nullptr);

protected:
    void keyPressEvent(QKeyEvent *event) override;
    void keyReleaseEvent(QKeyEvent *event) override;

private:
    void setupUI();
    void handleKeyCombination(int key, Qt::KeyboardModifiers modifiers);
    
private:
    QLabel *m_statusLabel;
    QLabel *m_infoLabel;
    QSet<int> m_pressedKeys;  // 记录当前按下的键
};

#endif // KEYCAPTUREWIDGET_H

// KeyCaptureWidget.cpp
#include "KeyCaptureWidget.h"
#include <QApplication>
#include <QDebug>

KeyCaptureWidget::KeyCaptureWidget(QWidget *parent)
    : QWidget(parent)
    , m_statusLabel(new QLabel(this))
    , m_infoLabel(new QLabel(this))
{
    setupUI();
    setFocusPolicy(Qt::StrongFocus);  // 确保widget可以接收键盘事件
}

void KeyCaptureWidget::setupUI()
{
    auto *layout = new QVBoxLayout(this);
    
    m_statusLabel->setText("按下键盘组合键...");
    m_statusLabel->setAlignment(Qt::AlignCenter);
    m_statusLabel->setStyleSheet("font-size: 16px; color: blue;");
    
    m_infoLabel->setText("支持的组合键: Ctrl+C, Ctrl+V, Ctrl+S, Alt+F4, Shift+方向键");
    m_infoLabel->setAlignment(Qt::AlignCenter);
    
    layout->addWidget(m_statusLabel);
    layout->addWidget(m_infoLabel);
    
    setWindowTitle("键盘组合键捕获示例");
    resize(400, 200);
}

void KeyCaptureWidget::keyPressEvent(QKeyEvent *event)
{
    int key = event->key();
    Qt::KeyboardModifiers modifiers = event->modifiers();
    
    m_pressedKeys.insert(key);
    
    // 处理组合键
    handleKeyCombination(key, modifiers);
    
    event->accept();  // 标记事件已处理
}

void KeyCaptureWidget::keyReleaseEvent(QKeyEvent *event)
{
    int key = event->key();
    m_pressedKeys.remove(key);
    event->accept();
}

void KeyCaptureWidget::handleKeyCombination(int key, Qt::KeyboardModifiers modifiers)
{
    QString combination;
    
    // 检查修饰键
    if (modifiers & Qt::ControlModifier) combination += "Ctrl+";
    if (modifiers & Qt::ShiftModifier) combination += "Shift+";
    if (modifiers & Qt::AltModifier) combination += "Alt+";
    if (modifiers & Qt::MetaModifier) combination += "Meta+";
    
    // 添加主要按键
    combination += QKeySequence(key).toString();
    
    QString message = QString("检测到组合键: %1").arg(combination);
    m_statusLabel->setText(message);
    
    qDebug() << "按键组合:" << combination;
    
    // 处理特定组合键
    if (modifiers & Qt::ControlModifier) {
        switch (key) {
        case Qt::Key_C:
            m_statusLabel->setText("Ctrl+C: 复制操作");
            break;
        case Qt::Key_V:
            m_statusLabel->setText("Ctrl+V: 粘贴操作");  
            break;
        case Qt::Key_S:
            m_statusLabel->setText("Ctrl+S: 保存操作");
            break;
        case Qt::Key_A:
            m_statusLabel->setText("Ctrl+A: 全选操作");
            break;
        case Qt::Key_Z:
            m_statusLabel->setText("Ctrl+Z: 撤销操作");
            break;
        case Qt::Key_Q:
            m_statusLabel->setText("Ctrl+Q: 退出应用");
            QApplication::quit();
            break;
        }
    }
    
    // Alt组合键
    if (modifiers & Qt::AltModifier) {
        switch (key) {
        case Qt::Key_F4:
            m_statusLabel->setText("Alt+F4: 关闭窗口");
            close();
            break;
        case Qt::Key_Enter:
        case Qt::Key_Return:
            m_statusLabel->setText("Alt+Enter: 全屏切换");
            break;
        }
    }
    
    // Shift组合键
    if (modifiers & Qt::ShiftModifier) {
        switch (key) {
        case Qt::Key_Left:
            m_statusLabel->setText("Shift+Left: 向左选择");
            break;
        case Qt::Key_Right:
            m_statusLabel->setText("Shift+Right: 向右选择");
            break;
        case Qt::Key_Up:
            m_statusLabel->setText("Shift+Up: 向上选择");
            break;
        case Qt::Key_Down:
            m_statusLabel->setText("Shift+Down: 向下选择");
            break;
        }
    }
    
    // 多键组合
    if ((modifiers & Qt::ControlModifier) && (modifiers & Qt::ShiftModifier)) {
        switch (key) {
        case Qt::Key_R:
            m_statusLabel->setText("Ctrl+Shift+R: 强制刷新");
            break;
        case Qt::Key_T:
            m_statusLabel->setText("Ctrl+Shift+T: 恢复关闭的标签页");
            break;
        }
    }
}

3. 高级组合键处理

3.1 使用QShortcut类（推荐）

// ShortcutManager.h
#ifndef SHORTCUTMANAGER_H
#define SHORTCUTMANAGER_H

#include <QWidget>
#include <QShortcut>
#include <QMap>

class ShortcutManager : public QWidget
{
    Q_OBJECT

public:
    explicit ShortcutManager(QWidget *parent = nullptr);

private slots:
    void onSaveShortcut();
    void onOpenShortcut();
    void onCustomShortcut();
    void onQuitShortcut();

private:
    void setupShortcuts();
    void setupUI();
    
private:
    QMap<QString, QShortcut*> m_shortcuts;
};

#endif // SHORTCUTMANAGER_H

// ShortcutManager.cpp
#include "ShortcutManager.h"
#include <QVBoxLayout>
#include <QLabel>
#include <QMessageBox>

ShortcutManager::ShortcutManager(QWidget *parent)
    : QWidget(parent)
{
    setupUI();
    setupShortcuts();
}

void ShortcutManager::setupUI()
{
    auto *layout = new QVBoxLayout(this);
    auto *label = new QLabel("尝试以下快捷键:\n"
                            "Ctrl+S - 保存\n"
                            "Ctrl+O - 打开\n" 
                            "Ctrl+Shift+P - 自定义操作\n"
                            "Ctrl+Q - 退出", this);
    label->setAlignment(Qt::AlignCenter);
    layout->addWidget(label);
    
    setWindowTitle("QShortcut示例");
    resize(300, 200);
}

void ShortcutManager::setupShortcuts()
{
    // Ctrl+S - 保存
    auto *saveShortcut = new QShortcut(QKeySequence("Ctrl+S"), this);
    connect(saveShortcut, &QShortcut::activated, this, &ShortcutManager::onSaveShortcut);
    m_shortcuts["Save"] = saveShortcut;
    
    // Ctrl+O - 打开
    auto *openShortcut = new QShortcut(QKeySequence("Ctrl+O"), this);
    connect(openShortcut, &QShortcut::activated, this, &ShortcutManager::onOpenShortcut);
    m_shortcuts["Open"] = openShortcut;
    
    // Ctrl+Shift+P - 自定义操作
    auto *customShortcut = new QShortcut(QKeySequence("Ctrl+Shift+P"), this);
    connect(customShortcut, &QShortcut::activated, this, &ShortcutManager::onCustomShortcut);
    m_shortcuts["Custom"] = customShortcut;
    
    // Ctrl+Q - 退出
    auto *quitShortcut = new QShortcut(QKeySequence("Ctrl+Q"), this);
    connect(quitShortcut, &QShortcut::activated, this, &ShortcutManager::onQuitShortcut);
    m_shortcuts["Quit"] = quitShortcut;
}

void ShortcutManager::onSaveShortcut()
{
    QMessageBox::information(this, "快捷键", "保存操作被触发 (Ctrl+S)");
}

void ShortcutManager::onOpenShortcut()
{
    QMessageBox::information(this, "快捷键", "打开操作被触发 (Ctrl+O)");
}

void ShortcutManager::onCustomShortcut()
{
    QMessageBox::information(this, "快捷键", "自定义操作被触发 (Ctrl+Shift+P)");
}

void ShortcutManager::onQuitShortcut()
{
    QMessageBox::information(this, "退出", "应用程序将退出");
    QApplication::quit();
}

3.2 全局快捷键实现

// GlobalShortcut.h
#ifndef GLOBALSHORTCUT_H
#define GLOBALSHORTCUT_H

#include <QObject>
#include <QKeySequence>
#include <QHash>

#ifdef Q_OS_WIN
    #include <windows.h>
#endif

class GlobalShortcut : public QObject
{
    Q_OBJECT

public:
    explicit GlobalShortcut(QObject *parent = nullptr);
    ~GlobalShortcut();

    bool registerShortcut(const QKeySequence &keySequence);
    bool unregisterShortcut(const QKeySequence &keySequence);

signals:
    void activated();

protected:
    bool nativeEventFilter(const QByteArray &eventType, void *message, long *result) override;

private:
#ifdef Q_OS_WIN
    QHash<int, QKeySequence> m_registeredKeys;
#endif
};

#endif // GLOBALSHORTCUT_H

4. 游戏开发中的组合键处理

4.1 游戏控制类示例

// GameController.h
#ifndef GAMECONTROLLER_H
#define GAMECONTROLLER_H

#include <QObject>
#include <QSet>
#include <QTimer>

class GameController : public QObject
{
    Q_OBJECT

public:
    explicit GameController(QObject *parent = nullptr);
    ~GameController();

    void keyPressed(int key);
    void keyReleased(int key);
    
    void startListening();
    void stopListening();

signals:
    void moveLeft();
    void moveRight();
    void moveUp();
    void moveDown();
    void attack();
    void specialAttack();
    void pauseGame();

private slots:
    void processInput();

private:
    QSet<int> m_pressedKeys;
    QTimer *m_inputTimer;
    
    void handleMovement();
    void handleActions();
};

#endif // GAMECONTROLLER_H

// GameController.cpp
#include "GameController.h"
#include <QDebug>

GameController::GameController(QObject *parent)
    : QObject(parent)
    , m_inputTimer(new QTimer(this))
{
    m_inputTimer->setInterval(16);  // ~60 FPS
    connect(m_inputTimer, &QTimer::timeout, this, &GameController::processInput);
}

GameController::~GameController()
{
    stopListening();
}

void GameController::keyPressed(int key)
{
    m_pressedKeys.insert(key);
}

void GameController::keyReleased(int key)
{
    m_pressedKeys.remove(key);
}

void GameController::startListening()
{
    m_inputTimer->start();
}

void GameController::stopListening()
{
    m_inputTimer->stop();
    m_pressedKeys.clear();
}

void GameController::processInput()
{
    handleMovement();
    handleActions();
}

void GameController::handleMovement()
{
    // WASD移动
    bool w = m_pressedKeys.contains(Qt::Key_W);
    bool a = m_pressedKeys.contains(Qt::Key_A);
    bool s = m_pressedKeys.contains(Qt::Key_S);
    bool d = m_pressedKeys.contains(Qt::Key_D);
    
    // 方向键移动
    bool up = m_pressedKeys.contains(Qt::Key_Up);
    bool left = m_pressedKeys.contains(Qt::Key_Left);
    bool down = m_pressedKeys.contains(Qt::Key_Down);
    bool right = m_pressedKeys.contains(Qt::Key_Right);
    
    if ((a || left) && !(d || right)) {
        emit moveLeft();
    } else if ((d || right) && !(a || left)) {
        emit moveRight();
    }
    
    if ((w || up) && !(s || down)) {
        emit moveUp();
    } else if ((s || down) && !(w || up)) {
        emit moveDown();
    }
}

void GameController::handleActions()
{
    // 空格键攻击
    if (m_pressedKeys.contains(Qt::Key_Space)) {
        emit attack();
    }
    
    // Shift + 空格特殊攻击
    if (m_pressedKeys.contains(Qt::Key_Space) && 
        (m_pressedKeys.contains(Qt::Key_Shift) || m_pressedKeys.contains(Qt::Key_Control))) {
        emit specialAttack();
    }
    
    // ESC暂停
    if (m_pressedKeys.contains(Qt::Key_Escape)) {
        emit pauseGame();
    }
    
    // Ctrl + S 快速保存（游戏中）
    if (m_pressedKeys.contains(Qt::Key_S) && m_pressedKeys.contains(Qt::Key_Control)) {
        qDebug() << "快速保存游戏";
    }
}

5. 主程序入口

// main.cpp
#include <QApplication>
#include "KeyCaptureWidget.h"
#include "ShortcutManager.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    
    // 示例1: 基本组合键捕获
    KeyCaptureWidget keyWidget;
    keyWidget.show();
    
    // 示例2: QShortcut使用
    ShortcutManager shortcutManager;
    shortcutManager.show();
    
    return app.exec();
}

6. 总结

6.1 捕获键盘组合键的几种方式：

1. 重写keyPressEvent/keyReleaseEvent - 最基础的方式，适合需要精细控制的情况

2. 使用QShortcut类 - 推荐方式，简单易用，支持复杂组合键

3. 全局快捷键 - 需要平台特定代码，实现较复杂

6.2 最佳实践：

• 对于简单的快捷键，优先使用QShortcut

• 对于游戏等需要实时输入处理的情况，使用keyPressEvent配合状态跟踪

• 注意事件传播机制，避免意外的事件处理

• 考虑跨平台兼容性，不同系统可能有不同的快捷键约定

通过合理使用这些技术，可以创建出响应灵敏、用户体验良好的Qt应用程序。