1. 定时器事件

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    oneTimer = startTimer(1000);    //开启定时器，并保存定时器Id
}
void Widget::timerEvent(QTimerEvent *event)
{

    if(event->timerId() == oneTimer)
    {
        static int i = 0;
        qDebug()<<"定时器 oneTimer"<<i++;
        if(i == 10)
        {
            killTimer(oneTimer);    //杀死定时器
        }
    }
}

自定义事件

首先要明白的是：“在 Qt 里，一个事件就是一个对象，所有事件的祖先都来自于 QEvent”。意思就是说，只要有一个事件发生（如鼠标单击事件），此时就会有一个 QEvent 对象被创建出来，然后开始各种传送。由于 Qt 事件系统是依托于元对象系统的，所以所有的 QObject 类都可以接收/处理 QEvent 事件。

说起事件，其实无非就是围绕着“产生-发送-处理”这个基本流程来说的。

Qt资料领取（视频教程+文档+代码+项目实战）

1. 如何产生一个事件？

我们从QEvent派生一个子类，取名为MyEvent~

注意的是，每个事件类都有一个唯一的类型标识：type值

class MyEvent : public QEvent
{
public:
    MyEvent(const QString&name,int age);
    ~MyEvent();

    friend QDebug operator<<(QDebug&debug,const MyEvent& myEvent);
    friend QDebug operator<<(QDebug&debug,const MyEvent* myEvent);

    QString name;
    int age;
    //保存自定义事件的类型，所有自定义MyEvent事件对象共享
    inline static QEvent::Type myType = (QEvent::Type)QEvent::registerEventType();
};

MyEvent::MyEvent(const QString&name,int age)
    :QEvent(myType)
    ,name(name)
    ,age(age)
{}

MyEvent::~MyEvent()
{
    qDebug()<<"~MyEvent";
}

QDebug operator<<(QDebug &debug, const MyEvent *myEvent)
{
    debug<<*myEvent;
}

QDebug operator<<(QDebug &debug, const MyEvent &myEvent)
{
    debug<<"("<<myEvent.name<<myEvent.age<<")";
    return debug;
}

好了，现在我们已经认识了 Qt 事件类长什么样了。接下来就是怎么把它发送出去了。

2. 如何发送一个事件？

Qt 提供了三个 static 事件发送函数：sendEvent、postEvent、sendPostEvents。函数原型如下：

void postEvent(QObject *receiver, QEvent *event, int priority = Qt::NormalEventPriority)
bool sendEvent(QObject *receiver, QEvent *event)

直接发送：sendEvent

这是最好理解的，两个参数中一个是要发给谁，另一个是发送什么事件。使用notify()函数将事件直接发送给接收方，返回从事件处理程序返回的值(阻塞式)，因此事件被发送的时候，event 对象并不会被销毁，因此我们要在栈上创建 event 对象。

MyEvent ev("张三",18);
QApplication::sendEvent(this,&ev);

发到队列：postEvent

我们创建一个 Qt 程序的时候，一般在 main 下面会看到 QCoreApplication a(argc, argv) 以及 return a.exec() 的字样。这其实就是开启了 Qt 事件循环来维护一个事件队列，exec 的本质就是不停的调用 processEvent() 函数从队列中获取事件来处理。而 postEvent() 的作用就是把事件发送到这个队列中去。

这种方式不需要等待处理结果，只要把事件发到队列中就可以了，所以返回值是 void。由于事件队列会持有发送的事件对象，在事件被处理后会自动 delete 掉，所以我们必须在堆上创建 event 对象。

MyEvent *pev = new MyEvent("maye",20);
QApplication::postEvent(this,pev);

3. 如何处理一个事件？

创建了事件，发送了事件，接下来就是怎么接收处理事件了。

• 系统事件通过virtual void event(QEvent *event)处理
• 自定义事件通过virtual void customEvent(QEvent *event)处理，当然也可以通过event来处理

void Widget::customEvent(QEvent *ev)
{
    if(ev->type() == MyEvent::myType)
    {
        MyEvent *myEvent = static_cast<MyEvent*>(ev);
        qDebug()<<"customEvent"<<myEvent;
    }
}

bool Widget::event(QEvent *ev)
{
    if(ev->type() == MyEvent::myType)
    {
        MyEvent *myEvent = static_cast<MyEvent*>(ev);
        qDebug()<<"event"<<myEvent;
        return true;
    }
    return QWidget::event(ev);
}

需要注意的是，重写事件处理器函数时，如果不实现任何功能，最好调用基类的实现。就像上面的那段代码，Qt 本身就已经写了一大堆的实现了，你要是不写上 QWidget::event(ev)这个代码，那你写的这个继承于 QWidget类的 Widget就不会对鼠标点击产生任何反应。正所谓“你要不会干这事，叫你爸爸来做吧”。

至此，一个完整的事件处理过程已经说完了。此时的你应该不仅了解了 Qt 自带的类是如何处理事件的，而且写个自定义事件也是应该是能下手了。接下来我们对事件处理再说说其他方便的功能：过滤、接收/忽略。

事件传播机制

1. 事件分发器

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

如果你希望在事件分发之前做一些操作，就可以重写这个event()函数了。
1、如果传入的事件已被识别并且处理，则需要返回 true，否则返回 false。如果返回值是 true，那么 Qt 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。
2、在event()函数中，调用事件对象的accept()和ignore()函数是没有作用的，不会影响到事件的传播。
3、记得不关心的事件 记得用父类的事件分发器处理。

声明分发器事件:

virtual bool event(QEvent *event);

重写分发器事件:

bool Widget::event(QEvent *event)
{
    if(event->type() == QEvent::KeyPress)  //键盘按下处理,其他事件让事件处理器自己处理,不能返回false
    {
        QKeyEvent *e = static_cast<QKeyEvent *>(event);//把QEvent类型转为QKeyEvent
 
        if(e->key() == Qt::Key_B) //如果是 键盘上的B键 将不会打印键值
        {
            return QWidget::event(event);
        }
 
        qDebug()<<(char)(e->key());
        return true;
    }
    else if(event->type() == QEvent::Timer)//计数器事件
    {
        //此处添加处理定时器事件的内容,如果想干掉定时器就直接返回true 定时器事件就不会处理
        QTimerEvent *ev = static_cast<QTimerEvent *>(event);//把QEvent类型转换为QTimerEvent
        timerEvent(ev);
        return true; //如果返回true,事件停止传播
    }
    else if(event->type() == QEvent::MouseMove)//鼠标移动事件  ,需要在构造函数中设置追踪鼠标
    {
        //鼠标移动处理事件,当返回true时就停止事件处理,所以在返回true前处理事件,打印坐标
        QMouseEvent *ev = static_cast<QMouseEvent *>(event);//把QEvent类型转换为QMouseEvent
        qDebug()<<QString("Mouse Move:(%1, %2)").arg(ev->x()).arg(ev->y());
        return true; //如果返回true,事件停止传播
    }
    else
    {
        return QWidget::event(event);
    }
}

2. 事件过滤器

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

1.在mylabel.cpp的构造函数中加载 事件过滤器

#include "mylabel.h"
#include <QEvent>
#include <QMouseEvent>
#include <QDebug>

MyLabel::MyLabel(QWidget *parent,QString text):QLabel(parent)
{
    this->setFixedSize(100,80);
    this->setText(text);

    //设置鼠标跟踪功能(用户不需要按下鼠标)
    this->setMouseTracking(true);
    //1.加载事件过滤器
    this->installEventFilter(this);
}

2.在mylabel.h中声明 事件过滤器函数

#ifndef MYLABEL_H
#define MYLABEL_H

#include <QLabel>

class MyLabel : public QLabel
{
public:
    MyLabel(QWidget *parent,QString text);

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

};

#endif // MYLABEL_H

3.在mylabel.cpp中实现 事件过滤器函数

bool MyLabel::eventFilter(QObject *watched, QEvent *event)
{
    //watched:触发的控件     event:具体的事件
    if (watched == this)
    {
        if (event->type() == QEvent::MouseButtonPress)
        {
            qDebug()<<"事件过滤器过滤中,鼠标被点击了"<<endl;
            QMouseEvent *ev = static_cast<QMouseEvent *>(event);
            qDebug()<<"x = "<<ev->x()<<"y = "<<ev->y()<<endl;
            return true;//自己处理
        }
    }

    //对于其他控件以及事件,统统交给父类处理
    return QLabel::eventFilter(watched, event);
}

注意：
1、这种全局的事件过滤器将会在所有其它特性对象的事件过滤器之前调用。尽管很强大，但这种行为会严重降低整个应用程序的事件分发效率。
2、事件过滤器和被安装过滤器的组件必须在同一线程，否则，过滤器将不起作用。另外，如果在安装过滤器之后，这两个组件到了不同的线程，那么，只有等到二者重新回到同一线程的时候过滤器才会有效。

3. 事件传递

QEvent有 accept()函数 和 ignore()函数

accept():本组件处理该事件，这个事件就不会被继续传播给其父组件；

ignore():本组件不想要处理这个事件。这个事件会被继续传播给其父组件；

注意：这里事件的传播是在组件层次上面的，而不是依靠类继承机制(父对象而不是父类)。

示例:

头文件widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void mousePressEvent(QMouseEvent *event);

private:
    Ui::Widget *ui;
};
#endif // WIDGET_H

源文件widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include "mybutton.h"
#include <QDebug>

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

    MyButton *btn= new MyButton("MyButton",this);

}

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

void Widget::mousePressEvent(QMouseEvent *event)
{
    qDebug() << "this:" << this << ", Widget::mousePressEvent";
}

头文件mybutton.h

#ifndef MYBUTTON_H
#define MYBUTTON_H
#include <QPushButton>

class MyButton : public QPushButton
{
public:

    MyButton(QString text,QWidget* parent=nullptr);

    void mousePressEvent(QMouseEvent* event);
};

#endif // MYBUTTON_H

源文件mybutton.cpp

#include "mybutton.h"
#include <QDebug>
#include <QMouseEvent>

MyButton::MyButton(QString text, QWidget* parent):QPushButton(parent)
{
    this->setText(text);
}

void MyButton::mousePressEvent(QMouseEvent *event)
{
    event->ignore();    //accept()和ignore() 表示是否将事件传递出去，是传递给父组件，而不是父对象

    qDebug() << "this:" << this << ", MyButton::mousePressEvent";

    //QPushButton::mousePressEvent(event);  // 调用父类QPushButton的mousePressEvent处理其他事件
}

点击MyButton按钮之后事件会被传递到父组件Widget上

运行效果:

事件的类型

QEvent 类是所有事件类的基类，事件对象包含事件参数。

Qt 的主事件循环（QCoreApplication::exec()）从事件队列中获取本地窗口系统事件，将它们转化为 QEvents，然后将转换后的事件发送给 QObjects。

一般来说，事件来自底层窗口系统（spontaneous() 返回 true），但也可以使用 QCoreApplication::sendEvent() 和 QCoreApplication::postEvent()（spontaneous() 返回 false）来手动发送事件。

基本的 QEvent 只包含了一个事件类型参数。QEvent 的子类包含了额外的描述特定事件的参数。

1.QEvent::Type

这个枚举类型定义了Qt中有效的事件类型。事件类型和每个类型的专门类如下：

用户事件的值应该介于 QEvent::User 和 QEvent::MaxUser之间。

为方便起见，可以使用 [static] int QEvent::registerEventType(int *hint* = -1) 函数来注册和存储一个自定义事件类型，这样做会避免意外地重用一个自定义事件类型。

2.属性文档

• accepted : bool

设置 accept 标志意味着接收器需要该事件，不需要的事件可能会被传递给它的父窗口。默认情况下，isAccepted() 设置为 true。不能依赖于此，因为子类可能会在子类构造器中清除该标志。

出于简便考虑，accept 标志可以通过 accept() 设置，ignore() 清除。

访问函数：

bool isAccepted() const
void setAccepted(bool accepted)

3.成员函数文档

void QEvent::accept()

设置事件对象的 accept 标志，等价于 setAccepted(true)。

设置 accept 标志意味着接收器需要该事件，不需要的事件可能会被传递给它的父窗口。

void QEvent::ignore()

清除事件对象的 accept 标志，等价于 setAccepted(false)。

清除 accept 标志意味着事件接收器不需要该事件，不需要的事件可能会被传递给它的父窗口。

[static] int QEvent::registerEventType(int hint = -1)

注册并返回一个自定义事件类型。如果 hint 是合法的，则会返回这个值；否则，会返回介于 QEvent::User 和 QEvent::MaxUser 之间的一个尚未被注册的值。如果其值不在 QEvent::User 和 QEvent::MaxUser 之间，hint 值将被忽略。

如果可用的值被使用或程序关闭，将返回 -1

bool QEvent::spontaneous() const

如果事件由应用程序之外产生的，比如一个系统事件，返回 true，否则返回 false。

Type QEvent::type() const

返回事件的类型

事件的处理

方法一：重写控件的事件处理函数：如重写keyPressEvent()，mousePressEvent()和paintEvent()，这是最常用的事件处理方法，我们已经看到过很多这样的例子了。

方法二：重写QObject::event()，在事件到达事件处理函数时处理它。在需要改变Tab键的惯用法时这样做。也可以处理那些没有特定事件处理函数的比较少见的事件类型（例如，QEvent::HoverEnter）。我们重写event()时，必须要调用基类的event()，由基类处理我们不需要处理的那些情况。

bool Button::event(QEvent *ev)
{
    //对鼠标点击和双击进行处理，返回true表示已处理，事件不会往下分发
    if(ev->type() == QEvent::Type::MouseButtonPress ||
            ev->type() == QEvent::Type::MouseButtonDblClick)
    {
        QMouseEvent* mouseEv = static_cast<QMouseEvent*>(ev);
        qDebug()<<mouseEv->pos()<<mouseEv->globalPos();
        return true;
    }
    return QPushButton::event(ev);	//其他事件交给父类处理
}

方法三：给QObject对象安装事件过滤器：对象用installEventFilter()后，所有达到目标控件的事件都首先到达监视对象的eventFilter()函数。如果一个对象有多个事件过滤器，过滤器按顺序激活，先到达最近安装的监视对象，最后到达最先安装的监视对象。

方法四：给QApplication安装事件过滤器，如果qApp（唯一的QApplication对象）安装了事件过滤器，程序中所有对象的事件都要送到eventFilter()函数中。这个方法在调试的时候非常有用，在处理非活动状态控件的鼠标事件时这个方法也很常用。

方法五：继承QApplication，重写notify()。Qt调用QApplication::nofity()来发送事件。重写这个函数是在其他事件过滤器处理事件前得到所有事件的唯一方法。通常事件过滤器是最有用的，因为在同一时间，可以有任意数量的事件过滤器，但是notify()函数只有一个。

例如点击按钮时，你想滴滴滴的一声，你不可能每一个按钮对应槽函数设置，重写QCoreApplication::notify即可

class IApplication:public QApplication
{
public:
    using QApplication::QApplication;
    bool notify(QObject *obj, QEvent *ev) override
    {
        if(ev->type() == QEvent::Type::MouseButtonPress)
        {
            if(obj->inherits("QAbstractButton"))
            {
                qDebug()<<"IApplication";
                QApplication::beep();	//响铃
                return true;			//返回true 所有继承自QAbstractButton的类都接收不到鼠标按下事件了
            }
        }
        return QApplication::notify(obj,ev);
    }
};

在实际编程中，最常用的是方法一，其次是方法三。因为方法五需要继承自 QApplication 类；而方法四要使用一个全局的事件过滤器，这将减缓事件的传递，所以，虽然这两种方法功能很强大，但是却很少被用到。

文章转自博客园（BORUTO）：https://www.cnblogs.com/zhuchunlin/p/16485891.html

Qt资料领取→「链接」