Qt 按钮点击事件全链路解析：从系统驱动到槽函数

[0. 准备：一个最小的窗口程序](#0. 准备：一个最小的窗口程序)

[1. 操作系统层（以 Windows 为例）](#1. 操作系统层（以 Windows 为例）)

[2. Qt 平台插件抓取原生消息](#2. Qt 平台插件抓取原生消息)

[3. 平台插件 → Qt 内核：包装成 QEvent](#3. 平台插件 → Qt 内核：包装成 QEvent)

[4. notify() → 目标控件的 event()](#4. notify() → 目标控件的 event())

[5. QWidget::event() 分拣事件](#5. QWidget::event() 分拣事件)

[6. QPushButton::mousePressEvent()](#6. QPushButton::mousePressEvent())

[7. 用户松开 → 系统再发 WM_LBUTTONUP](#7. 用户松开 → 系统再发 WM_LBUTTONUP)

[8. 信号-槽：直接连接 → 立即执行槽函数](#8. 信号-槽：直接连接 → 立即执行槽函数)

下面我们将用"点一下按钮 "这个最简单的场景，把从 操作系统鼠标驱动 → Qt 事件队列 → 最后执行你的槽函数 的整条链路，通过可运行的伪代码/真实代码，一行行地完整地走一遍。

0. 准备：一个最小的窗口程序

首先，我们创建一个最基础的 Qt 窗口，包含一个按钮，并连接其 clicked 信号到一个 Lambda 槽函数。

复制代码

// main.cpp
#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QDebug>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QWidget      w;
    QPushButton *btn = new QPushButton("点我", &w);

    // 连接信号与槽
    QObject::connect(btn, &QPushButton::clicked,
                     []{ qDebug() << "按钮槽函数被执行"; });

    w.resize(200, 100);
    w.show();

    // <-- 事件循环从这里开始
    return app.exec();
}

1. 操作系统层（以 Windows 为例）

当用户在物理上点击鼠标左键时，鼠标硬件驱动会捕捉到这个动作，并通知操作系统。操作系统随后会在其系统消息队列中放入一条新的消息。

这条消息大致如下：

复制代码

MSG: hwnd=0x1234, message=WM_LBUTTONDOWN, x=50, y=30

hwnd: 目标窗口的句柄。
message: 消息类型，这里是 WM_LBUTTONDOWN（左键按下）。
x, y: 鼠标点击的坐标。

2. Qt 平台插件抓取原生消息

app.exec() 启动了 Qt 的主事件循环。在这个循环内部，Qt 会不断地向操作系统查询是否有新的消息。

QApplication::exec() 的简化版伪代码如下：

复制代码

// 简化后的 QApplication::exec() 伪代码
int QApplication::exec()
{
    while (!quit_was_sent) {
        MSG msg;
        // ① GetMessage 会阻塞，直到从当前线程的消息队列中取到一条消息
        if (::GetMessage(&msg, nullptr, 0, 0)) {
            bool processed = false;
            // 获取特定于平台的上下文（如 Windows 插件）
            if (QAbstractEventDispatcher *dispatcher = ...) {
                 // ② 将原生系统消息交给 Qt 平台相关的部分进行处理
                processed = dispatcher->processEvents(QEventLoop::AllEvents);
            }
            // 如果 Qt 插件没有处理，则交由系统默认处理
            if (!processed) {
                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
        } else {
            // GetMessage 返回 0，意味着收到 WM_QUIT 消息，循环结束
            break;
        }
    }
    return 0;
}

在 Windows 平台上，Qt 的平台插件（QPA）会通过 GetMessage 等 WinAPI 函数从系统消息队列中取出 WM_LBUTTONDOWN 消息，并开始将其转换为 Qt 内部可以理解的格式。

3. 平台插件 → Qt 内核：包装成 QEvent

当 Qt 的 Windows 平台插件接收到 WM_LBUTTONDOWN 消息后，它会将其翻译并包装成一个 QMouseEvent 对象。

windowsProc 内部处理逻辑的简化伪代码：

复制代码

// 简化后的 QWindowsContext::windowsProc 伪代码
bool QWindowsContext::windowsProc(const MSG &msg)
{
    // 根据窗口句柄找到对应的 QWindow 或 QWidget
    QWidget *widget = findWidgetForHwnd(msg.hwnd);

    switch (msg.message) {
    case WM_LBUTTONDOWN: {
        QPoint globalPos(GET_X_LPARAM(msg.lParam), GET_Y_LPARAM(msg.lParam));
        QPoint localPos  = widget->mapFromGlobal(globalPos);

        // 创建一个 Qt 鼠标事件对象
        QMouseEvent ev(QEvent::MouseButtonPress, localPos, globalPos,
                       Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

        // ③ 将事件直接发送给对应的 widget，这是一个同步调用，不进入事件队列
        QCoreApplication::sendSpontaneousEvent(widget, &ev);
        return true; // 告诉系统，这个消息我们已经处理了
    }
    // ... 其他消息如 WM_LBUTTONUP, WM_MOUSEMOVE 等
    }
    return false;
}

关键在于 QCoreApplication::sendSpontaneousEvent，它最终会直接调用 QCoreApplication::notify，将事件立即派发出去，而不是将其 post 到 Qt 的事件队列中等待处理。

4. `notify()` → 目标控件的 `event()`

notify() 是 Qt 事件分发的总入口，所有事件都必须经过它。

复制代码

// QCoreApplication::notify() 的真实实现
bool QCoreApplication::notify(QObject *receiver, QEvent *event)
{
    // ④ notify 直接调用接收者（即我们的按钮）的 event() 方法
    return receiver->event(event);
}

5. `QWidget::event()` 分拣事件

event() 方法像一个分拣中心，它根据事件的类型（ev->type()）来调用相应的、更具体的事件处理函数。

复制代码

// QWidget::event() 的简化实现
bool QWidget::event(QEvent *ev)
{
    switch (ev->type()) {
    case QEvent::MouseButtonPress:
        // ⑤ 识别出是鼠标按下事件，调用 mousePressEvent()
        mousePressEvent(static_cast<QMouseEvent*>(ev));
        return true; // 事件已处理
    case QEvent::MouseButtonRelease:
        mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
        return true;
    // ... 其他事件类型，如 QEvent::KeyPress, QEvent::Paint
    default:
        // 如果是未知的事件类型，则调用基类的 event() 方法
        return QObject::event(ev);
    }
}

6. `QPushButton::mousePressEvent()`

现在事件到达了 QPushButton 自身重写的 mousePressEvent。

复制代码

// QPushButton::mousePressEvent() 的简化逻辑
void QPushButton::mousePressEvent(QMouseEvent *e)
{
    if (e->button() == Qt::LeftButton) {
        // 将按钮状态设置为"按下"，触发重绘，让按钮看起来被按下去了
        setDown(true);
        // 注意：此时并不会发射 clicked() 信号！它需要等待鼠标释放。
    }
    // 调用基类实现以处理其他逻辑
    QAbstractButton::mousePressEvent(e);
}

7. 用户松开 → 系统再发 `WM_LBUTTONUP`

用户松开鼠标左键，这个过程会重复步骤 1 到 5，但这次系统发送的是 WM_LBUTTONUP 消息，Qt 将其转换为 QEvent::MouseButtonRelease，最终调用到 QPushButton::mouseReleaseEvent。

复制代码

// QPushButton::mouseReleaseEvent() 的简化逻辑
void QPushButton::mouseReleaseEvent(QMouseEvent *e)
{
    // 检查是否是左键释放，并且释放时鼠标指针仍在按钮区域内
    if (e->button() == Qt::LeftButton && hitButton(e->pos())) {
        setDown(false); // 恢复按钮外观
        // ⑥ 在这里，关键的 clicked() 信号被发射出去！
        emit clicked();
    } else {
        setDown(false);
    }
    QAbstractButton::mouseReleaseEvent(e);
}

8. 信号-槽：直接连接 → 立即执行槽函数

由于我们的 connect 是在同一个线程中，并且使用默认的 Qt::AutoConnection，它会退化为 Qt::DirectConnection。这意味着信号一旦 emit，槽函数就会被立即、直接地调用，就像一个普通的函数调用。

Qt 元对象系统内部的激活逻辑（伪代码）：

复制代码

// QMetaObject::activate() 简化伪代码
void QMetaObject::activate(QObject *sender, int signalIndex, void **argv)
{
    // 根据发送者和信号索引，查找内部的连接列表
    for (const auto &connection : connections) {
        if (connection.connectionType == Qt::DirectConnection) {
            // ⑦ 如果是直接连接，直接调用槽函数（这里是我们的 lambda）
            connection.slotObject->call(argv);
        } else {
            // 其他连接类型，如 QueuedConnection，则会将调用包装成事件 post 到接收者线程的事件队列
        }
    }
}

此时，我们的 Lambda 函数被执行，终端立刻打印出：

复制代码

按钮槽函数被执行

总结

一张图总结（时间线）

复制代码

[用户操作] 鼠标左键按下
      ↓
[操作系统] 生成 WM_LBUTTONDOWN 消息
      ↓
[Qt 平台插件] 获取消息 → 包装成 QMouseEvent(MouseButtonPress)
      ↓
[Qt 内核] QCoreApplication::notify() → btn->event() → btn->mousePressEvent()
      ↓
[用户操作] 鼠标左键松开
      ↓
[操作系统] 生成 WM_LBUTTONUP 消息
      ↓
[Qt 平台插件] 获取消息 → 包装成 QMouseEvent(MouseButtonRelease)
      ↓
[Qt 内核] QCoreApplication::notify() → btn->event() → btn->mouseReleaseEvent()
      ↓
[Qt 信号槽] emit clicked() → (DirectConnection) → 你的 Lambda 被立即执行

关键要点

可以这么粗略地记，但 Qt 里多了两步关键中转：

操作系统只给 Qt 一个原生鼠标消息；
Qt 先把它包成 QEvent 并派发到对应控件 的 event() -> mousePressEvent() / mouseReleaseEvent()；
控件在 mouseReleaseEvent() 里** emit clicked()**；
最后才触发你的槽函数。

所以完整的一句话是： "点击鼠标 → 系统给 Qt → Qt 转成 QEvent 并分发 → 按钮 emit clicked() → 槽函数被执行。"

少了"事件分发"和"信号 emit"这两环，就和 Qt 的实际路线对不上号。

你可以亲手"打断点"验证

在 bool QWidget::event(QEvent *e) 里打印 e->type()；
在 QCoreApplication::notify 里打印 receiver->objectName() 和事件类型；
在按钮的 mousePressEvent/mouseReleaseEvent 里打印日志；
在 lambda 槽函数里再打印一次。

运行后你会看到输出严格按照上面 8 步顺序，整条链路将一目了然。