Qt5 事件（event）机制详解

朱雀 2022-12-08 01:56 386阅读 0赞

#  #

### 1.简述 ###

个人认为，事件机制是Qt最难以理解且最为精妙的一部分。事件主要分为两种：

1.  **在与用户交互时发生**。比如按下鼠标（*mousePressEvent*），敲击键盘（*keyPressEvent*）等。
2.  **系统自动发生**，比如计时器事件（*timerEvent*）等。

在发生事件时（比如说上面说的按下鼠标），就会产生一个*QEvent*对象（这里是*QMouseEvent*，为*QEvent*的子类），这个*QEvent*对象会传给当前组件的*event*函数。如果当前组件没有安装**事件过滤器**（这个下文会提到），则会被*event*函数发放到相应的*xxxEvent*函数中（这里是*mousePressEvent*函数）。

> Qt中所有的事件类都继承于QEvent类
> 
> ![format_png][]

这个*QEvent*对象会有各种各样的属性，这是由用户与界面交互时产生的。*xxxEvent*函数可以对其进行不同的处理（比如说是鼠标左键按下还是右键？）。查看帮助文档，可以看到*QMouseEvent*类有以下枚举。

![format_png 1][]

在QtCreator中查看帮助文档

那么就可以在*mousePressEvent*中根据这个*QEvent*对象的这些枚举值来进行不同的处理，比如

class myLabel : public QLabel
    {
    protected:
        void mousePressEvent(QMouseEvent *event);
    };
    
    void myLabel::mousePressEvent(QMouseEvent *event)
    {
        if(event->Buttons == LeftButton)
        {
            //do sth
        }
        else if(event->Buttons == RightButton)
        {
            //do sth
        }
    }

可以看到，我们首先需要先创建一个自己的QLabel类，并继承于Qt的*QLabel*类，然后并重写相应的*xxxEvent*函数（这些事件处理函数都是虚函数）。

Qt程序的main函数中需要创建一个*QApplication*对象，然后调用exec函数。这将令程序进入一个死循环，并不断监听应用程序的事件，发生事件时就生成一个*QEvent*对象。这又称为事件循环。

#include <QApplication>
    #include "mainwindow.h"
    
    int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
        MainWindow window;
        window.show();
    
        return app.exec();
    }

### 2.事件的分发：event函数 ###

上面提到的*xxxEvent*函数，称为**事件处理器（event handler）**。而*event*函数的作用就在于**事件的分发**。如果想在事件的分发之前就进行一些操作，比如监听某个按键的按下。

bool myWidget::event(QEvent *e)
    {
        if (e->type() == QEvent::KeyPress) 
        {
            //将QEvent对象转换为真正的QKeyEvent对象
            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
            if (keyEvent->key() == Qt::Key_Tab) 
            {
                qDebug() << "You press tab.";
                return true;
            }
        }
        //按照原来的流程来进行事件的分发
        return QWidget::event(e);
    }

在上面的程序中，myWidget是*QWidget*的子类。同样的，它的*event*函数是一个虚函数，带有一个QEvent类型的参数。当系统产生QEvent对象时，就会传入这个函数并调用。函数的返回值是bool类型，返回值不同有不同的意义。

如果传入的事件已被识别并且处理，则需要返回 true，否则返回 false。如果返回值是 true，那么 Qt 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。

> Qt系统在处理事件时，有一种机制叫**事件传播机制**。也就是说，在子组件（比如说一个*QButton*）中发生的事件，调用了子组件的*event*函数之后，还会调用父组件（比如说*QWidget*）的*event*函数。*event*函数的返回值就用于控制这样的一个过程。
> 
> ![format_png 2][]
> 
> https://blog.csdn.net/tqs\_1220/article/details/82563070

需要注意的是，重写*event*函数之后最好返回父类的*event*函数来处理其他的事件分发，不然就只能处理自己定义的事件。

bool myTextEdit::event(QEvent *e)
    {
        if (e->type() == QEvent::KeyPress) 
        {
            //将QEvent对象转换为真正的QKeyEvent对象
            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
            if (keyEvent->key() == Qt::Key_Tab) 
            {
                qDebug() << "You press tab.";
                return true;
            }
        }
        //直接返回false
        return false;
    }

在这个例子中，因为没有调用父类*QTextEdit*的*event*函数，所以只能处理Tab的情况，你再按其他按键就啥反应都没有了。同样，事件也不能进行传播。

### 事件过滤器（Even Filter） ###

某些应用场景下，需要拦截某个组件发生的事件，让这个事件不再向其他组件进行传播，这时候可以为这个组件或其父组件安装一个事件过滤器（*evenFilter*）。

*QObject*有一个虚函数，原型如下

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

可以看到，函数有两个参数，一个为具体发生事件的组件，一个为发生的事件（产生的*QEvent*对象）。当事件是我们感兴趣的类型，可以就地进行处理，并令其不再转发给其他组件。函数的返回值也是bool类型，作用跟*even*函数类似，返回true为不再转发，false则让其继续被处理。

实际使用中，我们需要对QObject组件调用*installEvenFilter*函数，即为组件安装过滤器，才能使用事件过滤器这个机制。这样，该组件及其子组件的事件就会被监听。这个机制的好处在于不用像重写QEvent和xxxEvent函数一样需要继承Qt的内置类。

void QObject::installEventFilter ( QObject * filterObj );

下面举一个例子。*MainWindow*中有一个*QTextEdit*控件，我们拦截它的键盘按下的事件。这样处理之后，会在输出窗口打印出按下的键位，但不会在控件上显示。这表明事件已被拦截，不会去调用*even*函数。

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<QKeyEvent *>(event);
                qDebug() << "you press" << keyEvent->key();
                //事件不再进行传播，拦截
                return true;
            } 
            else
            {
                return false;//继续传播
            }
        } 
        else 
        {
            //当不确定是否继续传播时，按照父类的方法来处理
            //即调用父类的evenFilter函数
            return QMainWindow::eventFilter(obj, event);
        }
    }

同样的，*even*函数能干的事情，*evenFilter*也能干。比如说上面的处理键盘按下Tab键。

bool myObject::eventFilter(QObject *object, QEvent *event)
    {
        if (object == target && event->type() == QEvent::KeyPress) 
        {
            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
            if (keyEvent->key() == Qt::Key_Tab) 
            {
                qDebug() << "You press tab.";
                //拦截
                return true;
            } 
            else 
            {
                //不进行拦截
                return false;
            }
        }
        //不进行拦截
        return false;
    }

我们可以对*QApplication*或者*QCoreApplication*对象添加事件过滤器。这种全局的事件过滤器将会在所有其它特性对象的事件过滤器之前调用。这种行为会严重降低整个应用程序的事件分发效率，要看具体情况使用。

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

### 总结 ###

Qt中使用事件机制，每一种事件对应一个事件处理器，比如：

*  mouseEvent()
 *  keyPressEvent()
 *  etc....

发生事件时会生成一个*QEvent*对象，则需要*even*函数进行分发，来调用相应的事件处理器

switch (event->type()) 
    {
        case QEvent::MouseMove:
            mouseMoveEvent((QMouseEvent*)event);
            break;
        // ...
    }

事件过滤器（*evenFilter*）可以令事件进行拦截，阻止其传播，从而实现某些功能。

另外，有一种一般很少使用的方法，即去重写这么一个函数

virtual bool QCoreApplication::notify ( QObject * receiver, QEvent * event );

该函数原实现相当于让组件调用*even*函数，即*receiver->event(event)*。这相当于全局的事件过滤器，且不会受到多线程的限制。

那么，在使用Qt的事件机制时，应该按照以下思路进行

*  重写*paintEvent*、*mousePressEvent*等事件处理函数。这是最普通、最简单的形式，同时功能也最简单。
 *  重写*event*函数。*event*函数是所有对象的事件入口，*QObjec*t和*QWidget*中的实现，默认是把事件传递给特定的事件处理函数。
 *  在特定对象上面安装事件过滤器。该过滤器仅过滤该对象接收到的事件。
 *  在*QCoreApplication::instance()*上面安装事件过滤器。该过滤器将过滤所有对象的所有事件，但会有多线程问题。
 *  重写*QCoreApplication::notify()*函数。这是最强大的，和全局事件过滤器一样提供完全控制，并且不受线程的限制。

[format_png]: /images/20221123/88ef45d5f5104f62a49888c9d4eb83d2.png
[format_png 1]: /images/20221123/b10255d25ad04f7bb43cb05939876a6b.png
[format_png 2]: /images/20221123/bb54b29574c34fb896407ffbe577305c.png