Great question—managing shortcuts centrally is a total game-changer for large Qt applications, especially when you want to avoid digging through scattered UI code to track or modify keybindings. Let’s break down two solid approaches to solve this, including the config-file-based solution you’re asking about:

方法1：用QAction统一集中管理（代码内维护） #

Qt’s QAction is the native, best-practice way to handle shortcuts, and you can wrap all your shortcut logic into a dedicated class (like a ShortcutManager) instead of scattering it across UI components.

核心思路： #

• Create a singleton ShortcutManager class (or attach it as a member of your main window) to register all shortcuts and their linked actions in one place.
• Each shortcut maps to a QAction, where you set the key binding and connect it to the target slot (either a UI component’s existing logic or custom code).
• This keeps all shortcut definitions visible in a single file, making modifications, en/disabling, and debugging way easier.

代码示例： #

First, the header for your manager:

// ShortcutManager.h
#include <QObject>
#include <QAction>
#include <QPointer>

class TextFinder; // Forward declare your main widget class

class ShortcutManager : public QObject
{
    Q_OBJECT
public:
    static ShortcutManager* instance();
    void init(TextFinder* mainWidget); // Pass in your main widget to link actions

private slots:
    void onFindTriggered(); // Slot for your search action

private:
    explicit ShortcutManager(QObject *parent = nullptr);
    QPointer<TextFinder> m_mainWidget;
    QAction* m_findAction;
};

Then the implementation:

// ShortcutManager.cpp
#include "ShortcutManager.h"
#include "TextFinder.h"

ShortcutManager* ShortcutManager::instance()
{
    static ShortcutManager instance;
    return &instance;
}

ShortcutManager::ShortcutManager(QObject *parent) : QObject(parent)
{
    // Initialize the search action with its shortcut
    m_findAction = new QAction(this);
    m_findAction->setShortcut(tr("Return"));
    connect(m_findAction, &QAction::triggered, this, &ShortcutManager::onFindTriggered);
}

void ShortcutManager::init(TextFinder* mainWidget)
{
    m_mainWidget = mainWidget;
    // Add the action to the main widget so the shortcut works globally (or target a specific component)
    mainWidget->addAction(m_findAction);
}

void ShortcutManager::onFindTriggered()
{
    // Trigger the existing search button logic, or run custom search code directly
    if (m_mainWidget) {
        m_mainWidget->ui->findButton->click();
        // Alternatively, skip the UI button and call your search logic directly for tighter coupling
    }
}

Finally, initialize the manager in your TextFinder constructor:

TextFinder::TextFinder(QWidget *parent) : QWidget(parent), ui(new Ui::TextFinder)
{
    ui->setupUi(this);
    ShortcutManager::instance()->init(this);
}

方法2：用配置文件实现可自定义的快捷键 #

If you want shortcuts to be editable (either by you or end-users) without touching code, you can load keybindings from a config file (like INI or JSON) and bind them dynamically via QAction.

核心思路： #

• Define a simple config format to store shortcut-key pairs (e.g., Find=Return).
• Have your ShortcutManager read the config on startup, create QActions dynamically, and link them to the correct logic.
• Optionally, add a settings UI to let users modify shortcuts and save changes back to the config file.

代码示例（INI格式 with QSettings） #

First, create a shortcuts.ini file:

[Shortcuts]
Find=Return
Quit=Ctrl+Q
OpenFile=Ctrl+O

Modify the ShortcutManager to load this config:

// ShortcutManager.cpp
#include <QSettings>

ShortcutManager::ShortcutManager(QObject *parent) : QObject(parent)
{
    QSettings settings("shortcuts.ini", QSettings::IniFormat);
    settings.beginGroup("Shortcuts");

    // Load search shortcut (fallback to "Return" if config is missing)
    m_findAction = new QAction(this);
    QString findKey = settings.value("Find", "Return").toString();
    m_findAction->setShortcut(QKeySequence(findKey));
    connect(m_findAction, &QAction::triggered, this, &ShortcutManager::onFindTriggered);

    // Load quit shortcut
    QAction* quitAction = new QAction(this);
    QString quitKey = settings.value("Quit", "Ctrl+Q").toString();
    quitAction->setShortcut(QKeySequence(quitKey));
    connect(quitAction, &QAction::triggered, qApp, &QApplication::quit);

    settings.endGroup();
}

For JSON (using QJsonDocument), the config file would look like this:

{
  "shortcuts": {
    "Find": "Return",
    "Quit": "Ctrl+Q"
  }
}

And the loading code:

// ShortcutManager.cpp
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>

ShortcutManager::ShortcutManager(QObject *parent) : QObject(parent)
{
    QFile configFile("shortcuts.json");
    if (configFile.open(QIODevice::ReadOnly)) {
        QJsonDocument doc = QJsonDocument::fromJson(configFile.readAll());
        QJsonObject shortcuts = doc.object()["shortcuts"].toObject();

        QString findKey = shortcuts["Find"].toString("Return");
        m_findAction = new QAction(this);
        m_findAction->setShortcut(QKeySequence(findKey));
        connect(m_findAction, &QAction::triggered, this, &ShortcutManager::onFindTriggered);
    }
}

Extra Optimizations: #

• Add shortcut conflict detection to ensure no two actions share the same keybinding.
• Build a settings UI where users can modify shortcuts, then save the updated values back to the config file.
• Use a QMap<QString, std::function<void()>> to map action IDs to their logic, so adding new shortcuts only requires updating the config and map (no repeated connect code).

Why This Beats Scattered UI Code #

As you noted, Qt Designer-generated shortcut code gets spread across multiple UI headers, making it impossible to get a full overview of your app’s keybindings at a glance. Centralized management keeps your code clean, maintainable, and flexible—whether you’re tweaking shortcuts yourself or letting users customize them.

内容的提问来源于stack exchange，提问作者websealevel