# **9\. Qt消息机制和事件**

## **9.1 事件**

事件（event）是由系统或者 Qt 本身在不同的时刻发出的。当用户按下鼠标、敲下键盘，或者是窗口需要重新绘制的时候，都会发出一个相应的事件。一些事件在对用户操作做出响应时发出，如键盘事件等；另一些事件则是由系统自动发出，如计时器事件。

在前面我们也曾经简单提到，**Qt 程序**需要在main()函数创建一个QApplication对象，然后调用它的exec()函数。这个函数就是开始 Qt 的事件循环。在执行exec()函数之后，程序将进入事件循环来监听应用程序的事件。当事件发生时，Qt 将创建一个事件对象。**Qt 中所有事件类都继承于QEvent**。在事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。**event()函数并不直接处理事件，而是按照事件对象的类型分派给特定的事件处理函数**（event handler），关于这一点，会在后边详细说明。

在所有组件的父类QWidget中，定义了很多事件处理的回调函数，如

```c++
- keyPressEvent()
- keyReleaseEvent()
- mouseDoubleClickEvent()
- mouseMoveEvent()
- mousePressEvent()
- mouseReleaseEvent() 等。
```

这些函数都是 protected virtual 的，也就是说，我们可以在子类中重新实现这些函数。下面来看一个例子：

```c++
class EventLabel : public QLabel

{

protected:

void mouseMoveEvent(QMouseEvent *event);

void mousePressEvent(QMouseEvent *event);

void mouseReleaseEvent(QMouseEvent *event);

};

void EventLabel::mouseMoveEvent(QMouseEvent *event)

{

this->setText(QString("Move: (%1, %2)").arg(QString::number(event->x()),QString::number(event->y())));

}

void EventLabel::mousePressEvent(QMouseEvent *event)

{this->setText(QString("Press:(%1, %2)").arg(QString::number(event->x()),QString::number(event->y())));}

void EventLabel::mouseReleaseEvent(QMouseEvent *event)

{

QString msg;

msg.sprintf("Release: (%d, %d)",

event->x(), event->y());

this->setText(msg);

}

int main(int argc, char *argv[])

{

QApplication a(argc, argv);

EventLabel *label = new EventLabel;

label->setWindowTitle("MouseEvent Demo");

label->resize(300, 200);

label->show();

return a.exec();

}
```

- EventLabel继承了QLabel，覆盖了mousePressEvent()、mouseMoveEvent()和MouseReleaseEvent()三个函数。我们并没有添加什么功能，只是在鼠标按下（press）、鼠标移动（move）和鼠标释放（release）的时候，把当前鼠标的坐标值显示在这个Label上面。由于QLabel是支持 HTML 代码的，因此我们直接使用了 HTML 代码来格式化文字。

- QString的arg()函数可以自动替换掉QString中出现的占位符。其占位符以 % 开始，后面是占位符的位置，例如 %1，%2 这种。

  QString("\[%1, %2\]").arg(x).arg(y);

语句将会使用x替换 %1，y替换 %2，因此，生成的QString为\[x, y\]。

- 在mouseReleaseEvent()函数中，我们使用了另外一种QString的构造方法。我们使用类似 C 风格的格式化函数sprintf()来构造QString。

运行上面的代码，当我们点击了一下鼠标之后，label 上将显示鼠标当前坐标值。

![](data:image/png;base64,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)

为什么要点击鼠标之后才能在`mouseMoveEvent()`函数中显示鼠标坐标值？

**这是因为QWidget中有一个mouseTracking属性，该属性用于设置是否追踪鼠标。只有鼠标被追踪时，mouseMoveEvent()才会发出。如果mouseTracking是 false（默认即是），组件在至少一次鼠标点击之后，才能够被追踪，也就是能够发出mouseMoveEvent()事件。如果mouseTracking为 true，则mouseMoveEvent()直接可以被发出。**

知道了这一点，我们就可以在main()函数中添加如下代码：

`label->setMouseTracking(true);`

在运行程序就没有这个问题了。

## **9.2 event（）**

事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是将这些事件对象按照它们不同的类型，分发给不同的事件处理器（event handler）。

如上所述，**event()函数主要用于事件的分发**。所以，如果你希望在事件分发之前做一些操作，就可以重写这个event()函数了。例如，我们希望在一个QWidget组件中监听 tab 键的按下，那么就可以继承QWidget，并重写它的event()函数，来达到这个目的：

```c++
bool CustomWidget::event(QEvent *e){

if (e->type() == QEvent::KeyPress) {

QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);

if (keyEvent->key() == Qt::Key_Tab) {

qDebug() << "You press tab.";

return true;

}

}

return QWidget::event(e);

}
```

CustomWidget是一个普通的QWidget子类。我们重写了它的event()函数，这个函数有一个QEvent对象作为参数，也就是需要转发的事件对象。函数返回值是 bool 类型。

- **如果传入的事件已被识别并且处理，则需要返回 true，否则返回 false。如果返回值是 true，那么 Qt 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。**
- **在event()函数中，调用事件对象的accept()和ignore()函数是没有作用的，不会影响到事件的传播**。

我们可以通过使用QEvent::type()函数可以检查事件的实际类型，其返回值是QEvent::Type类型的枚举。我们处理过自己感兴趣的事件之后，可以直接返回 true，表示我们已经对此事件进行了处理；对于其它我们不关心的事件，则需要调用父类的event()函数继续转发，否则这个组件就只能处理我们定义的事件了。为了测试这一种情况，我们可以尝试下面的代码：

bool CustomTextEdit::event(QEvent \*e)

{

if (e->type() == QEvent::KeyPress)

{

QKeyEvent \*keyEvent = static_cast&lt;QKeyEvent \*&gt;(e);

if (keyEvent->key() == Qt::Key_Tab)

{

qDebug() << "You press tab.";

return true;

}

}

return false;

}

CustomTextEdit是QTextEdit的一个子类。我们重写了其event()函数，却没有调用父类的同名函数。这样，我们的组件就只能处理 Tab 键，再也无法输入任何文本，也不能响应其它事件，比如鼠标点击之后也不会有光标出现。这是因为我们只处理的KeyPress类型的事件，并且如果不是KeyPress事件，则直接返回 false，鼠标事件根本不会被转发，也就没有了鼠标事件。

通过查看QObject::event()的实现，我们可以理解，event()函数同前面的章节中我们所说的事件处理器有什么联系：

//!!! Qt5

bool QObject::event(QEvent \*e)

{

switch (e->type()) {

case QEvent::Timer:

timerEvent((QTimerEvent\*)e);

break;

case QEvent::ChildAdded:

case QEvent::ChildPolished:

case QEvent::ChildRemoved:

childEvent((QChildEvent\*)e);

break;

// ...

default:

if (e->type() >= QEvent::User) {

customEvent(e);

break;

}

return false;

}

return true;

}

这是 Qt 5 中QObject::event()函数的源代码（Qt 4 的版本也是类似的）。我们可以看到，同前面我们所说的一样，Qt 也是使用QEvent::type()判断事件类型，然后调用了特定的事件处理器。比如，如果event->type()返回值是QEvent::Timer，则调用timerEvent()函数。可以想象，QWidget::event()中一定会有如下的代码：

switch (event->type()) {

case QEvent::MouseMove:

mouseMoveEvent((QMouseEvent\*)event);

break;

// ...

}

事实也的确如此。timerEvent()和mouseMoveEvent()这样的函数，就是我们前面章节所说的事件处理器 event handler。也就是说，**event()函数中实际是通过事件处理器来响应一个具体的事件。这相当于event()函数将具体事件的处理“委托”给具体的事件处理器。而这些事件处理器是 protected virtual 的，因此，我们重写了某一个事件处理器，即可让 Qt 调用我们自己实现的版本。**

由此可以见，event()是一个集中处理不同类型的事件的地方。如果你不想重写一大堆事件处理器，就可以重写这个event()函数，通过QEvent::type()判断不同的事件。鉴于重写event()函数需要十分小心注意父类的同名函数的调用，一不留神就可能出现问题，所以一般还是建议只重写事件处理器（当然，也必须记得是不是应该调用父类的同名处理器）。这其实暗示了event()函数的另外一个作用：屏蔽掉某些不需要的事件处理器。正如我们前面的CustomTextEdit例子看到的那样，我们创建了一个只能响应 tab 键的组件。这种作用是重写事件处理器所不能实现的。

## **9.3 事件过滤器**

有时候，对象需要查看、甚至要拦截发送到另外对象的事件。例如，对话框可能想要拦截按键事件，不让别的组件接收到；或者要修改回车键的默认处理。

通过前面的章节，我们已经知道，Qt 创建了QEvent事件对象之后，会调用QObject的event()函数处理事件的分发。显然，我们可以在event()函数中实现拦截的操作。由于event()函数是 protected 的，因此，需要继承已有类。如果组件很多，就需要重写很多个event()函数。这当然相当麻烦，更不用说重写event()函数还得小心一堆问题。好在 Qt 提供了另外一种机制来达到这一目的：事件过滤器。

QObject有一个eventFilter()函数，用于建立事件过滤器。函数原型如下：

virtual bool QObject::eventFilter ( QObject \* watched, QEvent \* event );

这个函数正如其名字显示的那样，是一个“事件过滤器”。所谓事件过滤器，可以理解成一种过滤代码。事件过滤器会检查接收到的事件。如果这个事件是我们感兴趣的类型，就进行我们自己的处理；如果不是，就继续转发。这个函数返回一个 bool 类型，如果你想将参数 event 过滤出来，比如，\*\*不想让它继续转发，就返回 true，否则返回 false。\*\*事件过滤器的调用时间是目标对象（也就是参数里面的watched对象）接收到事件对象之前。也就是说，如果你在事件过滤器中停止了某个事件，那么，watched对象以及以后所有的事件过滤器根本不会知道这么一个事件。

我们来看一段简单的代码：

class MainWindow : public QMainWindow

{

public:

MainWindow();

protected:

bool eventFilter(QObject \*obj, QEvent \*event);

private:

QTextEdit \*textEdit;

};

MainWindow::MainWindow()

{

textEdit = new QTextEdit;

setCentralWidget(textEdit);

textEdit->installEventFilter(this);

}

bool MainWindow::eventFilter(QObject \*obj, QEvent \*event)

{

if (obj == textEdit) {

if (event->type() == QEvent::KeyPress) {

QKeyEvent \*keyEvent = static_cast&lt;QKeyEvent \*&gt;(event);

qDebug() &lt;< "Ate key press" << keyEvent-&gt;key();

return true;

} else {

return false;

}

} else {

// pass the event on to the parent class

return QMainWindow::eventFilter(obj, event);

}

}

- MainWindow是我们定义的一个类。我们重写了它的eventFilter()函数。为了过滤特定组件上的事件，首先需要判断这个对象是不是我们感兴趣的组件，然后判断这个事件的类型。在上面的代码中，我们不想让textEdit组件处理键盘按下的事件。所以，首先我们找到这个组件，如果这个事件是键盘事件，则直接返回 true，也就是过滤掉了这个事件，其他事件还是要继续处理，所以返回 false。对于其它的组件，我们并不保证是不是还有过滤器，于是最保险的办法是调用父类的函数。

- eventFilter()函数相当于创建了过滤器，然后我们需要安装这个过滤器。安装过滤器需要调用QObject::installEventFilter()函数。函数的原型如下：

  void QObject::installEventFilter ( QObject \* filterObj )

  这个函数接受一个QObject \*类型的参数。记得刚刚我们说的，eventFilter()函数是QObject的一个成员函数，因此，任意QObject都可以作为事件过滤器（问题在于，如果你没有重写eventFilter()函数，这个事件过滤器是没有任何作用的，因为默认什么都不会过滤）。已经存在的过滤器则可以通过QObject::removeEventFilter()函数移除。

- 我们可以向一个对象上面安装多个事件处理器，只要调用多次installEventFilter()函数。如果一个对象存在多个事件过滤器，那么，最后一个安装的会第一个执行，也就是后进先执行的顺序。

还记得我们前面的那个例子吗？我们使用event()函数处理了 Tab 键：

bool CustomWidget::event(QEvent \*e)

{

if (e->type() == QEvent::KeyPress) {

QKeyEvent \*keyEvent = static_cast&lt;QKeyEvent \*&gt;(e);

if (keyEvent->key() == Qt::Key_Tab) {

qDebug() << "You press tab.";

return true;

}

}

return QWidget::event(e);

}

现在，我们可以给出一个使用事件过滤器的版本：

bool FilterObject::eventFilter(QObject \*object, QEvent \*event)

{

if (object == target && event->type() == QEvent::KeyPress)

{

QKeyEvent \*keyEvent = static_cast&lt;QKeyEvent \*&gt;(event);

if (keyEvent->key() == Qt::Key_Tab) {

qDebug() << "You press tab.";

return true;

} else {

return false;

}

}

return false;

}

事件过滤器的强大之处在于，我们可以为整个应用程序添加一个事件过滤器。记得，installEventFilter()函数是QObject的函数，QApplication或者QCoreApplication对象都是QObject的子类，因此，我们可以向QApplication或者QCoreApplication添加事件过滤器。\*\*这种全局的事件过滤器将会在所有其它特性对象的事件过滤器之前调用。尽管很强大，但这种行为会严重降低整个应用程序的事件分发效率。\*\*因此，除非是不得不使用的情况，否则的话我们不应该这么做。

**注意，**

**事件过滤器和被安装过滤器的组件必须在同一线程，否则，过滤器将不起作用。另外，如果在安装过滤器之后，这两个组件到了不同的线程，那么，只有等到二者重新回到同一线程的时候过滤器才会有效。**

## **9.4 总结**

Qt 的事件是整个 Qt 框架的核心机制之一，也比较复杂。说它复杂，更多是因为它涉及到的函数众多，而处理方法也很多，有时候让人难以选择。现在我们简单总结一下 Qt 中的事件机制。

Qt 中有很多种事件：鼠标事件、键盘事件、大小改变的事件、位置移动的事件等等。如何处理这些事件，实际有两种选择：

- 所有事件对应一个事件处理函数，在这个事件处理函数中用一个很大的分支语句进行选择，其代表作就是 win32 API 的WndProc()函数：

  LRESULT CALLBACK WndProc(HWND hWnd,

  UINT message,

  WPARAM wParam,

  LPARAM lParam)

  在这个函数中，我们需要使用switch语句，选择message参数的类型进行处理，典型代码是：

  switch(message)

  {

  case WM_PAINT:

  break;

  case WM_DESTROY:

  break;

  }

- 每一种事件对应一个事件处理函数。Qt 就是使用的这么一种机制：

  - mouseEvent()
  - keyPressEvent()
  - …

Qt 具有这么多种事件处理函数，肯定有一个地方对其进行分发，否则，Qt 怎么知道哪一种事件调用哪一个事件处理函数呢？这个分发的函数，就是event()。显然，当QMouseEvent产生之后，event()函数将其分发给mouseEvent()事件处理器进行处理。

event()函数会有两个问题：

- event()函数是一个 protected 的函数，这意味着我们要想重写event()，必须继承一个已有的类。试想，我的程序根本不想要鼠标事件，程序中所有组件都不允许处理鼠标事件，是不是我得继承所有组件，一一重写其event()函数？protected 函数带来的另外一个问题是，如果我基于第三方库进行开发，而对方没有提供源代码，只有一个链接库，其它都是封装好的。我怎么去继承这种库中的组件呢？
- event()函数的确有一定的控制，不过有时候我的需求更严格一些：我希望那些组件根本看不到这种事件。event()函数虽然可以拦截，但其实也是接收到了QMouseEvent对象。我连让它收都收不到。这样做的好处是，模拟一种系统根本没有那个事件的效果，所以其它组件根本不会收到这个事件，也就无需修改自己的事件处理函数。这种需求怎么办呢？

这两个问题是event()函数无法处理的。于是，Qt 提供了另外一种解决方案：事件过滤器。事件过滤器给我们一种能力，让我们能够完全移除某种事件。事件过滤器可以安装到任意QObject类型上面，并且可以安装多个。如果要实现全局的事件过滤器，则可以安装到QApplication或者QCoreApplication上面。这里需要注意的是，如果使用installEventFilter()函数给一个对象安装事件过滤器，那么该事件过滤器只对该对象有效，只有这个对象的事件需要先传递给事件过滤器的eventFilter()函数进行过滤，其它对象不受影响。如果给QApplication对象安装事件过滤器，那么该过滤器对程序中的每一个对象都有效，任何对象的事件都是先传给eventFilter()函数。

**事件过滤器可以解决刚刚我们提出的event()函数的两点不足：**

- **首先，事件过滤器不是 protected 的，因此我们可以向任何QObject子类安装事件过滤器；**
- **其次，事件过滤器在目标对象接收到事件之前进行处理，如果我们将事件过滤掉，目标对象根本不会见到这个事件。**

事实上，还有一种方法，我们没有介绍。Qt 事件的调用最终都会追溯到QCoreApplication::notify()函数，因此，最大的控制权实际上是重写QCoreApplication::notify()。这个函数的声明是：

virtual bool QCoreApplication::notify ( QObject \* receiver,

QEvent \* event );

该函数会将event发送给receiver，也就是调用receiver->event(event)，其返回值就是来自receiver的事件处理器。注意，这个函数为任意线程的任意对象的任意事件调用，因此，它不存在事件过滤器的线程的问题。不过我们并不推荐这么做，因为notify()函数只有一个，而事件过滤器要灵活得多。

**现在我们可以总结一下 Qt 的事件处理，实际上是有五个层次：**

- 重写paintEvent()、mousePressEvent()等事件处理函数。这是最普通、最简单的形式，同时功能也最简单。
- 重写event()函数。event()函数是所有对象的事件入口，QObject和QWidget中的实现，默认是把事件传递给特定的事件处理函数。
- 在特定对象上面安装事件过滤器。该过滤器仅过滤该对象接收到的事件。
- 在QCoreApplication::instance()上面安装事件过滤器。该过滤器将过滤所有对象的所有事件，因此和notify()函数一样强大，但是它更灵活，因为可以安装多个过滤器。全局的事件过滤器可以看到 disabled 组件上面发出的鼠标事件。全局过滤器有一个问题：只能用在主线程。
- 重写QCoreApplication::notify()函数。这是最强大的，和全局事件过滤器一样提供完全控制，并且不受线程的限制。但是全局范围内只能有一个被使用（因为QCoreApplication是单例的）。