C++Qt开发——事件处理函数_qt notify

事件(event)是由系统或者Qt本身在不同时刻发出的。当用户按下鼠标、敲下键盘，或者其它情况时候都会发出一个相应的事件。一些事件在对用户操作做出相应时发出，如键盘事件等；另外一些则是由系统自动发出，如计时事件等。

Qt程序需要在main()函数创建一个QApplication对象，然后调用它的exec()函数。这个函数就是开始Qt的事件循环。在执行exec()函数之后，程序将进入事件循环来监听应用程序的事件，当事件发生时，Qt将创建一个事件对象。Qt中所有事件类都继承自QEvent。在事件对象创建完毕之后，Qt将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是按照事件对象的类型分派给指定的事件处理函数(event handler)进行处理。

事件处理函数一般都是虚函数，都可以在子类中重写

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT图像绘制，QT网络，QT数据库编程，QT项目实战，QT嵌入式开发，Quick模块等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓

QWidget事件

1. 鼠标事件

首先请注意，Qt中的QMouseEvent一般只涉及鼠标左键或右键的单击、释放等操作，而对鼠标滚轮的响应则通过QWheelEvent来处理。

QMouseEvent类包含了用于描述鼠标事件的参数。

当在一个窗口里按住鼠标按键、或移动、或释放就会产生鼠标事件QMouseEvent。

鼠标移动事件只会在按下鼠标按键的情况下才会发生，除非通过显式调用QWidget::setMouseTracking()函数来开启鼠标轨迹，这种情况下只要鼠标指针在移动，就会产生一系列的Qt鼠标事件；

在一个窗口中，当鼠标按键被按下时，Qt会自动捕捉鼠标轨迹，鼠标所在的窗口会继续接受鼠标事件，直到最后一个鼠标按键被释放。

需要对鼠标事件进行处理时，通常要重新实现以下几个鼠标事件处理函数

事件处理

鼠标事件使用的时候，加头文件

#include <QMouseEvent>

(1)鼠标按下事件

void Widget::mousePressEvent(QMouseEvent *event)
{
　　// 如果是鼠标左键按下
　　if(event->button() == Qt::LeftButton)
　　{
       ···
   }
   // 如果是鼠标右键按下
   else if(event->button() == Qt::RightButton)
   {
       ···
   }
}

(2)鼠标移动事件

默认情况下，触发事件需要点击一下，才能触发。可设置为自动触发:setMouseTracking(true);

this->setMouseTracking(true);
void Widget::mouseMoveEvent(QMouseEvent *event)
{
    //必须使用buttons()判断，鼠标当前所有状态都通过这个函数返回
    if(ev->buttons() & Qt::MouseButton::LeftButton)
    {
        qDebug()<<"左键按下并移动";
    }
}

(3)鼠标释放事件

void Widget::mouseReleaseEvent(QMouseEvent *event)
{
   ···
}

(4)鼠标双击事件

void Widget::mouseDoubleClickEvent(QMouseEvent *event)
{
    if(ev->button() == Qt::MouseButton::LeftButton)
    {
        qDebug()<<"左键双击";
    }
}

(5)鼠标滚轮事件

void Widget::wheelEvent(QWheelEvent *event)
{
    if(ev->angleDelta().y()>0)
    {
        qDebug()<<"向远离用户的方向";
    }
    else
   {
        qDebug()<<"向靠近用户的方向";
    }
}

(6)鼠标移入事件

当鼠标进入小部件时产生

void Widget::enterEvent(QEvent *ev)
{
   ...
}

(7)鼠标移出事件

当鼠标移出小部件时产生

void Widget::leaveEvent(QEvent *ev)
{
    ...
}

Example：无边框窗口拖动

• framelessWindow.h

#include <QWidget>
#include<QPoint>
class framelessWindow : public QWidget
{
    Q_OBJECT
​
public:
    framelessWindow(QWidget *parent = Q_NULLPTR);
    void mousePressEvent(QMouseEvent* ev)override;
    void mouseMoveEvent(QMouseEvent* ev)override;
​
private:
    QPoint disPos;          //鼠标距离窗口左上角的距离(x y方向一起存储)
};

• framelessWindow.cpp

#include "framelessWindow.h"
#include<QEvent>
#include<QMouseEvent>
framelessWindow::framelessWindow(QWidget *parent)
    : QWidget(parent)
{
    setWindowFlags(Qt::WindowType::FramelessWindowHint);
    this->setMouseTracking(true);
    resize(430, 330);
}
​
void framelessWindow::mousePressEvent(QMouseEvent* ev)
{
    disPos = ev->pos();
}
​
void framelessWindow::mouseMoveEvent(QMouseEvent* ev)
{
    if(ev->buttons() & Qt::MouseButton::LeftButton == Qt::MouseButton::LeftButton)
        this->move(ev->globalPos() - disPos);
}

2. 键盘事件

键盘按键事件通过QKeyEvent处理，包含了用于描述键盘事件的参数。

当在一个窗口里按住鼠标按键、或移动、或释放就会产生鼠标事件QMouseEvent。

• int key() 返回按下或释放的键的代码
• Qt::KeyboardModifiers modifiers() 返回事件发生后立即存在的键盘修饰符标志

需要对键盘事件进行处理时，通常要重新实现以下两个事件处理函数

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT图像绘制，QT网络，QT数据库编程，QT项目实战，QT嵌入式开发，Quick模块等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓

(1)按键按下事件

void Widget::keyPressEvent(QKeyEvent *event)
{
    //单个键
    if(event->key() == Qt::Key::Key_Up)
    {
        qDebug()<<"上键按下";
    }
    else if(event->key() == Qt::Key::Key_Down)
    {
        qDebug()<<"下键按下";
    }
    else if(event->key() == Qt::Key::Key_Left)
    {
        qDebug()<<"左键按下";
    }
    else if(event->key() == Qt::Key::Key_Right)
    {
        qDebug()<<"右键按下";
    }
    //组合键 Ctrl + A
    if(event->modifiers() == Qt::KeyboardModifier::ControlModifier &&
            event->key() == Qt::Key::Key_A)
    {
        qDebug()<<"Ctrl + A";
    }
}

(2)按键弹起事件

void Widget::keyReleaseEvent(QKeyEvent *event)
{
    //单个键
    if(event->key() == Qt::Key::Key_Up)
    {
        qDebug()<<"上键释放";
    }
    else if(event->key() == Qt::Key::Key_Down)
    {
        qDebug()<<"下键释放";
    }
    else if(event->key() == Qt::Key::Key_Left)
    {
        qDebug()<<"左键释放";
    }
    else if(event->key() == Qt::Key::Key_Right)
    {
        qDebug()<<"右键释放";
    }
​
    if(event->modifiers() == Qt::KeyboardModifier::ControlModifier &&
            event->key() == Qt::Key::Key_A)
    {
        qDebug()<<"Ctrl + A 释放";
    }
}

3. 窗口关闭事件

当Qt从窗口系统接收到一个顶级小部件的窗口关闭请求时，该事件处理程序将与给定的事件一起调用。

默认情况下，接受事件并关闭小部件。 您可以重新实现这个函数，以更改小部件响应窗口关闭请求的方式。 例如，您可以通过对所有事件调用ignore()来防止窗口关闭。

主窗口应用程序通常使用此函数的重新实现来检查用户的工作是否已被保存，并在关闭前请求许可。

void Widget::closeEvent(QCloseEvent *ev)
{
    this->hide();   //隐藏窗口
    ev->ignore();   //忽略关闭事件，窗口不会被关闭
    //ev->accept(); //接受关闭事件，窗口会被关闭或者隐藏(是不是最后一个窗口，或者有没有设置Qt::WA_DeleteOnClose属性)
}

4. 程序状态改变事件

可以通过提供的事件检索该事件中正在更改的状态。

void Widget::changeEvent(QEvent *ev)
{
    if(ev->type() == QEvent::WindowStateChange)
    {
        if(this->windowState() == Qt::WindowState::WindowMinimized)
        {
            qDebug()<<"窗口最小化啦";
        }
        if(this->windowState() == Qt::WindowState::WindowNoState)
        {
            qDebug()<<"窗口正常显示啦";
        }
        if(this->windowState() == Qt::WindowState::WindowMaximized)
        {
            qDebug()<<"窗口最大化啦";
        }
    }
}

5. 右键菜单事件

当小部件的contextMenuPolicy为Qt::DefaultContextMenu时，该处理程序被调用。

void Widget::contextMenuEvent(QContextMenuEvent *event)
{
    menu->popup(event->globalPos());
}

6. 拖拽事件

当正在进行拖动并鼠标进入此小部件时，将调用此事件处理程序。

• 要想处理拖拽事件，必须调用函数this->setAcceptDrops(true); 接受拖拽
• 在dragEnterEvent中接受事件：event->accept();

(1)拖拽进入

void DragArea::dragEnterEvent(QDragEnterEvent *event)
{
    auto *mdata = event->mimeData();
    if(mdata->hasUrls())
    {
        QString str;
       foreach(auto &url, mdata->urls())
       {
           str.append(url.path());
           qDebug()<<url.path();
       }
       this->setText(str);
    }
​
    event->accept();
}

(2)拖拽移动

void DragArea::dragMoveEvent(QDragMoveEvent *event)
{
    qDebug()<<"dragMove"<<event->mimeData()->text();
}

(3)拖拽离开

void DragArea::dragLeaveEvent(QDragLeaveEvent *event)
{
    qDebug()<<"dragLeave";
}

(4)拖拽放开

void DragArea::dropEvent(QDropEvent *event)
{
    qDebug()<<"drop"<<event->mimeData()->text();
}

7. 焦点事件

小部件获得和失去键盘焦点事件。 将调用此事件处理程序。

virtual void focusInEvent(QFocusEvent *event)
virtual void focusOutEvent(QFocusEvent *event)

8. 窗口隐藏、显示事件

注意:当窗口系统改变窗口的映射状态时，窗口小部件会收到自发的显示和隐藏事件，例如，当用户最小化窗口时，会收到自发的隐藏事件，当窗口再次恢复时，会收到自发的显示事件。

void Widget::hideEvent(QHideEvent *event)
{
    qDebug()<<"窗口隐藏啦~";
}
​
void Widget::showEvent(QShowEvent *event)
{
    qDebug()<<"窗口显示啦~";
}

9. 窗口移动事件

void Widget::moveEvent(QMoveEvent *event)
{
     qDebug()<<"原来的pos"<<event->oldPos()<<"现在的pos"<<event->pos();
}

10. 窗口大小改变事件

void Widget::resizeEvent(QResizeEvent *event)
{
    qDebug()<<"原来的大小"<<event->oldSize()<<"现在大小"<<event->size();
}

QObject事件

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 事件。

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

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. 事件分发机制

事件传递顺序以及监听特定控件是否接收某个事件

1.事件首先由Qt的ServerApplication去接收来自于外部或内部的一些行为，鼠标点击，键盘输入，时钟事件等，分析并决定送往对应 的对象去处理(内部管理机制，如有机会另文分析)，最后会调用[virtual] bool QCoreApplication::notify ( QObject * receiver, QEvent * event ) 去处理，当然这个是虚函数，你可以在子类去重新实现它 。

2.在notify(…)中，在发给对应的接收者前，会先把消息送给QApplication。所以如果想在你界面的Widget前先处理那些事 件，那么你可以给QApplication对象installEventFilter,然后在对应的eventFilter()里先把这些事件都给过一 遍，然后你可以过滤一些不必要事件·。

3.如果QApplication没有处理那些事件，然后就是交给事件接收对象了。在这个对象接收前，也可以为这对象加一个事件过滤器，同样是 installEventFilter，不过它的调用者是事件接收者(也就是前面那个reveiver参数)，而不是 QApplication/QCoreApplication.

4.如果你写了具体的mouseEvent()，或者keyEvent()等具体实现句柄实现后，接收处理该事件，那么该事件不会再传递了，然后就会进入接收者的event()函数（你可以里面根据事件的不同类型尽情处理），如果event事件在接受者处理后，也不会上传给父类的event，否则会上传进入父类的event。

5.默认event()函数根据事件类型会调用不同的事件处理函数,类似mouseEvent(),keyEvent()去分别处理他们。

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT图像绘制，QT网络，QT数据库编程，QT项目实战，QT嵌入式开发，Quick模块等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓

2. 事件传递

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

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

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

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

• 如果想要调用父类的处理函数，直接调用即可

class Button : public QPushButton
{
    Q_OBJECT
public:
    Button(QWidget*parent=nullptr);
    void mousePressEvent(QMouseEvent*ev)override;
};
Button::Button(QWidget*parent):QPushButton(parent)
{
​
}
​
void Button::mousePressEvent(QMouseEvent *ev)
{
    QPushButton::mousePressEvent(ev);   //交给父类处理
}

如果重写了mousePressEvent但是不调用父类的mousePressEvent，鼠标点击按钮时，将不会触发任何信号。

• 组件传播

#include"button.h"
class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
    void mousePressEvent(QMouseEvent *event) override;
};
​
Widget::Widget(QWidget *parent): QWidget(parent)
{
    resize(640,480);
​
    Button *btn= new Button(this);
    btn->setText("hello");
    connect(btn,&Button::clicked,this,[](){qDebug()<<"clicked";});
}
​
Widget::~Widget()
{
}
​
void Widget::mousePressEvent(QMouseEvent *event)
{
    qDebug()<<"Widget~";
}

由于事件处理函数都是默认接受的，所以先把Button中的QPushButton::mousePressEvent(ev)去掉，代码如下

void Button::mousePressEvent(QMouseEvent *ev)
{
    ev->ignore();       //Widget::mousePressEvent会被调用
   //ev->accept();    //Widget::mousePressEvent不会被调用 (如果都不写，默认就是这个)
   //QPushButton::mousePressEvent(ev);
}

3. 事件过滤

看完了事件的传播流程，如果说我们想屏蔽某些事件，或者对某些事件进行特殊的处理，就需要用到事件过滤了

• 任意的QObject对象都可以作为事件过滤器使用
• 事件过滤器的实现,需要重写eventFilter()函数
• 组件要想被监控,则需要通过installEventFilter()安装事件过滤器
• 事件过滤器能够决定是否将事件转发给组件对象

//如果已经安装此对象，则此对象作为被监视对象的事件过滤器。
[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)
//在此对象上安装事件筛选器filterObj
void QObject::installEventFilter(QObject *filterObj)
//从该对象中移除事件筛选器对象obj。    
void QObject::removeEventFilter(QObject *obj)

• 下面案例演示了如何过滤按键按下事件

bool Widget::eventFilter(QObject *watched, QEvent *ev)
{
    if(ev->type()==QEvent::KeyPress)
    {
        return true;    //返回true表示事件已处理，不会继续传递了
    }
    return false;
}
installEventFilter(this);   //必须安装过滤器

事件类型

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

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

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

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

QEvent::Type

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

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

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

属性文档

• accepted : bool

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

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

访问函数：

bool isAccepted() const
void setAccepted(bool accepted)

成员函数文档

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

返回事件的类型

事件处理5种级别

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

1. 重写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);	//其他事件交给父类处理
}

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

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

1. 继承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);
    }
};

许多事件类型，包括鼠标，键盘事件，是能够传播的。如果事件在到达目标对象的途中或者由目标对象处理掉，事件处理的过程会重新开始，不同的是这时的目标对象是原目标对象的父控件。这样从父控件再到父控件，知道有控件处理这个事件或者到达了最顶级的那个控件。

事件和信号的区别

信号和事件是两个不同层面的东西，发出者不同，作用不同。Qt中，所有的QObject的子类实例均可对事件接收和处理！

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT图像绘制，QT网络，QT数据库编程，QT项目实战，QT嵌入式开发，Quick模块等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓