Qt 信号槽、事件及事件过滤器

信号与槽（Signal、Slot）

信号

信号就是在特定情况下被发射的事件，例如PushButton 最常见的信号就是鼠标单击时发射的 clicked() 信号，一个 ComboBox 最常见的信号是选择的列表项变化时发射的 CurrentIndexChanged() 信号。

槽

槽就是对信号响应的函数。槽就是一个函数，与一般的C++函数是一样的，可以定义在类的任何部分（public、private 或 protected），可以具有任何参数，也可以被直接调用。槽函数与一般的函数不同的是：槽函数可以与一个信号关联，当信号被发射时，关联的槽函数被自动执行。

关联

关联是用 QObject::connect() 函数实现的，connect() 是 QObject 类的一个静态函数，而 QObject 是所有 Qt 类的基类，在实际调用时可以忽略前面的限定符，所以可以直接写为：

connect(sender, SIGNAL(signal()), receiver, SLOT(slot()));

信号与槽的使用规则：

1.一个信号可以连接多个槽

connect(spinNum, SIGNAL(valueChanged(int)), this, SLOT(addFun(int));
connect(spinNum, SIGNAL(valueChanged(int)), this, SLOT(updateStatus(int));

这是当一个对象 spinNum 的数值发生变化时，所在窗体有两个槽进行响应，一个 addFun()用于计算，一个 updateStatus() 用于更新状态。

当一个信号与多个槽函数关联时，槽函数按照建立连接时的顺序依次执行。

当信号和槽函数带有参数时，在 connect()函数里，要写明参数的类型，但可以不写参数名称。

2.多个信号可以连接同一个槽

在 samp2_2（前面章节中的项目）中，让三个选择颜色的 RadioButton的clicked() 信号关联到相同的一个自定义槽函数 setTextFontColor()。

connect(ui->rBtnBlue,SIGNAL(clicked()),this,SLOT(setTextFontColor()));
connect(ui->rBtnRed,SIGNAL(clicked()),this,SLOT(setTextFontColor()));
connect(ui->rBtnBlack,SIGNAL(clicked()),this,SLOT(setTextFontColor()));

这样，当任何一个 RadioButton 被单击时，都会执行 setTextFontColor() 函数。

3.一个信号可以连接另外一个信号

connect(spinNum, SIGNAL(valueChanged(int)), this, SIGNAL (refreshInfo(int));

这样，当一个信号发射时，也会发射另外一个信号，实现某些特殊的功能。

4.信号与槽的参数个数和类型需要一致

严格的情况下，信号与槽的参数个数和类型需要一致，至少信号的参数不能少于槽的参数。如果不匹配，会出现编译错误或运行错误。

5.使用时必须加入宏Q_OBJECT

在使用信号与槽的类中，必须在类的定义中加入宏 Q_OBJECT。

6.槽函数在信号发射时被立即执行

当一个信号被发射时，与其关联的槽函数通常被立即执行，就像正常调用一个函数一样。只有当信号关联的所有槽函数执行完毕后，才会执行发射信号处后面的代码。

参考：Qt信号与槽机制详解

事件（Event）

事件定义

事件是可以被控件识别的操作，如按下确定按钮、选择某个单选按钮或复选框。每种控件有自己可识别的事件，如窗体的加载、单击、双击等事件，编辑框（文本框）的文本改变事件等等。

事件就是用户对窗口上各种组件的操作。

基于产生的事件类型

1、键盘或鼠标事件：用户按下或松开键盘或鼠标上的按键时，就可以产生一个键盘或者鼠标事件。

2、绘制事件：某个窗口第一次显示的时候，就会产生一个绘制事件，用来告诉窗口需要重新绘制它本身，从而使得该窗口可见。

3、QT事件：Qt自己也会产生很多事件，比如QObject::startTimer()会触发QTimerEvent。

基于分发的事件类型

基于事件如何被产生与分发，可以把事件分为三类：

1、Spontaneous 事件

由窗口系统产生，它们被放到系统队列中，通过事件循环逐个处理。

本类事件通常是Windows System把从系统得到的消息，比如鼠标按键、键盘按键等, 放入系统的消息队列中。 Qt事件循环的时候读取这些事件，转化为QEvent，再依次逐个处理。

2、Posted 事件

由Qt或应用程序产生，它们被Qt组成队列，再通过事件循环处理。

调用QApplication::postEvent()来产生一个posted类型事件。例如：QWidget::update()函数，当需要重新绘制屏幕时，程序调用update()函数。

其实现的原理是new出一个paintEvent，调用 QApplication::postEvent()，将其放入Qt的消息队列中，等待依次被处理。

3、Send事件

由Qt或应用程序产生，但它们被直接发送到目标对象。

调用QApplication::sendEvent()函数来产生一个send类型事件。

send 类型事件不会放入队列, 而是直接被派发和处理, QWidget::repaint()函数用的就是这种方式。

xxxEvent事件重写（事件分发后）

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

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();
}

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 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。

需要注意的是，重写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;
        }
    }
    return false;
}

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

事件传播机制

Qt系统在处理事件时，有一种机制叫事件传播机制。也就是说，在子组件（比如说一个QButton）中发生的事件，调用了子组件的event函数之后，还会调用父组件（比如说QWidget）的event函数。event函数的返回值就用于控制这样的一个过程。

事件过滤器（Event Filter）

事件过滤器定义

使用场景

Qt创建QEvent事件对象后，会调用QObject的event()函数来分发事件。

但有时，你可能需要在调用event()函数之前做一些自己的操作，比如，对话框上某些组件可能并不需要响应回车键按下的事件，此时，你就需要重新定义组件的event()函数。

如果组件很多，就需要重写很多次event()函数，这显然没有效率。为此，你可以使用一个事件过滤器，来判断是否需要调用组件的event()函数。

参考：Qt 事件机制、Qt 事件机制

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

事件过滤器安装

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

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

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

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

void QObject::installEventFilter ( QObject * filterObj );

事件过滤器拦截

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

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提供了5个级别来处理和过滤事件。

1、重新实现特定的event handler

重新实现像mousePressEvent(), keyPressEvent()和paintEvent()这样的event Handler是目前处理event最普通的方式。

2、重新实现QObject::event()

通过重新实现event()，我们可以在事件到达特定的event handler之前对它们作出处理。这个方法主要是用来覆写Tab键的缺省实现，也可以用来处理不同发生的事件类型，对它们，就没有特定的event handler。当重新实现event()的时候，我们必须调用基类的event()来处理我们不显式处理的情况。

3、安装一个event filter到一个单独的QObject

一旦一个对象用installEventFilter注册了, 发到目标对象的所有事件都会先发到监测对象的eventFilter()。如果同一个object安装了多个event filter, filter会依次被激活, 从最近安装的回到第一个。

4、在QApplication对象上安装event filter

一旦一个event filter被注册到qApp(唯一的QApplication对象), 程序里发到每个对象的每个事件在发到其他event filter之前，都要首先发到eventFilter()。这个方法对debugging非常有用，也可以用来处理发到disable的widget上的事件, QApplication通常会丢弃它们。

5、我们可以子类化QApplication并重新实现notify()

Qt调用QApplication::notify()来发出事件，在任何event filter得到之前, 重新实现这个函数是得到所有事件的唯一方法。event filter通常更有用, 因为可以有任意数目且同时存在的event filter, 但是只有一个notify()函数。

参考：Qt5 事件（event）机制详解

事件和信号的区别

1. 事件和信号处理过程不同。在QT中，事件使用了一个事件队列来维护，如果事件的处理中又产生了新的事件，那么新的事件会加入到队列尾，直到当前事件处理完毕后， QApplication再去队列头取下一个事件来处理。而信号的处理方式有些不同，信号处理是立即回调的，也就是一个信号产生后，他上面所注册的所有槽都会立即被回调。这样就会产生一个递归调用的问题，比如某个信号处理器中又产生了一个信号，会使得信号的处理像一棵树一样的展开。
2. 事件和信号处理时的优先级不同。在QT中，事件因为都是与窗口相关的，所以事件回调时都是从当前窗口开始，一级一级向上派发，直到有一个窗口返回true，截断了事件的处理为止。对于信号的处理则比较简单，默认是没有顺序的，如果需要明确的顺序，可以在信号注册时显示地指明槽的位置。
3. 事件和信号返回值的意义不同。事件处理函数的返回值是有意义的，我们要根据这个返回值来确定是否还要继续事件的处理，比如在QT中，事件处理函数如果返回true，则这个事件处理已完成，QApplication会接着处理下一个事件，而如果返回false，那么事件分派函数会继续向上寻找下一个可以处理该事件的注册方法。信号处理函数的返回值对信号分派器来说是无意义的。

参考：Qt事件机制和信号槽机制的区别？

事件过滤器示例

只能输入数字，按下其他键都会唤起弹窗。

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QKeyEvent>
#include <QMessageBox>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    ui->lineEdit->setAttribute(Qt::WA_InputMethodEnabled, false);  //禁用输入法
    ui->lineEdit->installEventFilter(this);  //必须要写这一句
}

MainWindow::~MainWindow()
{
    delete ui;
}

bool MainWindow::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->lineEdit)
    {
        if(event->type() == QEvent::KeyPress)
        {
            QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);

            switch (keyEvent->key()) {
            case Qt::Key_0:
            case Qt::Key_1:
            case Qt::Key_2:
            case Qt::Key_3:
            case Qt::Key_4:
            case Qt::Key_5:
            case Qt::Key_6:
            case Qt::Key_7:
            case Qt::Key_8:
            case Qt::Key_9:
            case Qt::Key_Backspace:
                return false;
            default:
                QMessageBox::information(this, "title", "please input number");
                return true;
            }
        }
    }

    return false;
}