1. 首页
  2. 文章中心
  3. QT

详解 Qt (事件过滤器、事件总结、自定义事件)

54 阅读 0 评论
我是靠谱客的博主 紧张战斗机，最近开发中收集的这篇文章主要介绍详解 Qt (事件过滤器、事件总结、自定义事件)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Qt中的事件过滤器
问题：有时候我们在自定义事件时，并不是需要所有的事件类型都可以触发的，例如在数字键盘中，我们就不希望按下字母可以触发事件并输入到编辑框中。那么Qt有什么机制可以过滤掉一部分事件呢？

事件过滤器对象需要重写eventFilter() 函数
组件通过installEventFilter() 函数安装事件过滤器
事件过滤器在组件之前接收到事件
事件过滤器能够决定是否将事件转发到组件对象

å¨è¿éæå¥å¾çæè¿°

å¨è¿éæå¥å¾çæè¿°

示例代码：事件过滤器的使用

//MyLineEdit.h
class MyLineEdit : public QLineEdit
{
    Q_OBJECT
public:
    explicit MyLineEdit(QWidget *parent = 0);
    bool event(QEvent* e);
    void keyPressEvent(QKeyEvent* e);
signals:
    
public slots:    
};

//MyLineEdit.cpp
MyLineEdit::MyLineEdit(QWidget *parent) :
    QLineEdit(parent)
{
}

bool MyLineEdit::event(QEvent* e)
{
    if( e->type() == QEvent::KeyPress )
    {
        qDebug() << "MyLineEdit::event";  //22222222222222
    }

    return QLineEdit::event(e);
}

void MyLineEdit::keyPressEvent(QKeyEvent* e)
{
    qDebug() << "MyLineEdit::keyPressEvent"; //3333333333333

    QLineEdit::keyPressEvent(e);

     //e->ignore();     //当注释以后，事件不会继续传给父组件了
}

//Widget.h
class Widget : public QWidget
{
    Q_OBJECT
    
    MyLineEdit myLineEdit;
public:
    Widget(QWidget* parent = 0);
    bool event(QEvent* e);
    void keyPressEvent(QKeyEvent* e);
    bool eventFilter(QObject* obj, QEvent* e);
    ~Widget();
};

//Widget.cpp
Widget::Widget(QWidget *parent)
    : QWidget(parent), myLineEdit(this)
{
    myLineEdit.installEventFilter(this);        //使用事件过滤器前必须先安装
}

bool Widget::event(QEvent* e)
{
    if( e->type() == QEvent::KeyPress )
    {
        qDebug() << "Widget::event";
    }

    return QWidget::event(e);
}

void Widget::keyPressEvent(QKeyEvent* e)
{
    qDebug() << "Widget::keyPressEvent";

    QWidget::keyPressEvent(e);
}

bool Widget::eventFilter(QObject* obj, QEvent* e)
{
    bool ret = true;

    if( (obj == &myLineEdit) && (e->type() == QEvent::KeyPress) )
    {
        qDebug() << "Widget::eventFilter";    //111111111111

        QKeyEvent* evt = dynamic_cast<QKeyEvent*>(e);

        switch(evt->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:
                ret = false;    //返回false表明以上事件过滤失败
                break;
            default:
                break;
        }
    }
    else
    {
        ret = QWidget::eventFilter(obj, e);     //调用父类事件过滤器
    }

    return ret;
}

现象：

当键盘输入字母时，文本框无显示，命令行仅打印出：
Widget::eventFilter
当键盘输入数字时，文本框显示对应数字，命令行打印出：
Widget::eventFilter
MyLineEdit::event
MyLineEdit::keyPressEvent
————————————————

事件过滤器

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

QObject有一个eventFilter()函数，用于建立事件过滤器。这个函数的签名如下：

virtual bool QObject::eventFilter ( QObject * watched, QEvent * event );
  • 这个函数返回一个 bool 类型，不想让它继续转发，就返回 true，否则返回 false。事件过滤器的调用时间是目标对象接收到事件对象之前。
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() << "Ate key press" << keyEvent->key();
             return true;
         } else {
             return false;
         }
     } else {
         // pass the event on to the parent class
         return QMainWindow::eventFilter(obj, event);
     }
 }

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

void QObject::installEventFilter ( QObject * filterObj )
  • 已经存在的过滤器则可以通过QObject::removeEventFilter()函数移除。

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

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

注意，如果你在事件过滤器中 delete 了某个接收组件，务必将函数返回值设为 true。否则，Qt 还是会将事件分发给这个接收组件，从而导致程序崩溃。

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

事件总结

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

  1. 所有事件对应一个事件处理函数，在这个事件处理函数中用一个很大的分支语句进行选择，其代表作就是 win32 API 的WndProc()函数：
switch(message)
{
    case WM_PAINT:
        // ...
        break;
    case WM_DESTROY:
        // ...
        break;
    ...
}

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

    mouseEvent()
    keyPressEvent()
    …
    Qt 具有这么多种事件处理函数，肯定有一个地方对其进行分发，这个分发的函数，就是event()。显然，当QMouseEvent产生之后，event()函数将其分发给mouseEvent()事件处理器进行处理。

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

  1. QWidget::event()函数是一个 protected 的函数，这意味着我们要想重写event()，必须继承一个已有的类。
  2. event()函数的确有一定的控制，不过有时候我的需求更严格一些：我希望那些组件根本看不到这种事件。event()函数虽然可以拦截，但其实也是接收到了QMouseEvent对象。我连让它收都收不到。

这两个问题是event()函数无法处理的。如果给QApplication对象安装事件过滤器，那么该过滤器对程序中的每一个对象都有效，任何对象的事件都是先传给eventFilter()函数。

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

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

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

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

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

    bool eventFilter(QObject *watched, QEvent *event)
    {
        if (watched == this) {
            if (event->type() == QEvent::MouseButtonPress) {
                qDebug() << "eventFilter";
            }
        }
        return false;
    }

protected:
    void mousePressEvent(QMouseEvent *)
    {
        qDebug() << "mousePressEvent";
    }

    bool event(QEvent *e)
    {
        if (e->type() == QEvent::MouseButtonPress) {
            qDebug() << "event";
        }
        return QWidget::event(e);
    }
};

class EventFilter : public QObject
{
public:
    EventFilter(QObject *watched, QObject *parent = 0) :
        QObject(parent),
        m_watched(watched)
    {
    }

    bool eventFilter(QObject *watched, QEvent *event)
    {
        if (watched == m_watched) {
            if (event->type() == QEvent::MouseButtonPress) {
                qDebug() << "QApplication::eventFilter";
            }
        }
        return false;
    }

private:
    QObject *m_watched;
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    Label label;
    app.installEventFilter(new EventFilter(&label, &label));
    label.show();
    return app.exec();
}

QApplication::eventFilter 
eventFilter 
event 
mousePressEvent

因此可以知道，全局事件过滤器被第一个调用，之后是该对象上面的事件过滤器，其次是event()函数，最后是特定的事件处理函数。

自定义事件

Qt 自定义事件很简单，同其它类库的使用很相似，都是要继承一个类进行扩展。在 Qt 中，你需要继承的类是QEvent。

继承QEvent类，最重要的是提供一个QEvent::Type类型的参数，作为自定义事件的类型值。比如在event()函数中，我们使用QEvent::type()获得这个事件类型，然后与我们定义的实际类型对比。

QEvent::Type是QEvent定义的一个枚举。因此，我们可以传递一个 int 值。在 Qt 中，系统保留 0 – 999 的值，也就是说，你的事件 type 要大于 999。这种数值当然非常难记，所以 Qt 定义了两个边界值：QEvent::User和QEvent::MaxUser。我们的自定义事件的 type 应该在这两个值的范围之间。其中，QEvent::User的值是 1000，QEvent::MaxUser的值是 65535。

但是，这样并不能保证自定义事件相互之间不会被覆盖。为了解决这个问题，Qt 提供了一个函数：registerEventType()，用于自定义事件的注册。

static int QEvent::registerEventType ( int hint = -1 );

函数返回值是向系统注册的新的 Type 类型的值。如果 hint 是合法的，也就是说这个 hint 不会发生任何覆盖（系统的以及其它自定义事件的），则会直接返回这个值；否则，系统会自动分配一个合法值并返回。这个函数是线程安全的，不必另外添加同步。

Qt 中提供了两种事件发送方式：
1.

static bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event);

接将event事件发送给receiver接受者，使用的是QCoreApplication::notify()函数。函数返回值就是事件处理函数的返回值。在事件被发送的时候，event对象并不会被销毁。通常我们会在栈上创建event对象，例如：

QMouseEvent event(QEvent::MouseButtonPress, pos, 0, 0, 0);
QApplication::sendEvent(mainWindow, &event);

2.

static void QCoreApplication::postEvent(QObject *receiver, QEvent *event);

将event事件及其接受者receiver一同追加到事件队列中，函数立即返回。

因为 post 事件队列会持有事件对象，并且在其 post 的时候将其 delete 掉，因此，我们必须在堆上创建event对象。当对象被发送之后，再试图访问event对象就会出现问题（因为 post 之后，event对象就会被 delete）。

当控制权返回到主线程循环时，保存在事件队列中的所有事件都通过notify()函数发送出去。

事件会根据 post 的顺序进行处理。如果你想要改变事件的处理顺序，可以考虑为其指定一个优先级。默认的优先级是Qt::NormalEventPriority。

这个函数是线程安全的

Qt 还提供了一个函数：

static void QCoreApplication::sendPostedEvents(QObject *receiver, int event_type);

这个函数的作用是，将事件队列中的接受者为receiver，事件类为 event_type 的所有事件立即发送给 receiver 进行处理。需要注意的是，来自窗口系统的事件并不由这个函数进行处理，而是processEvent()。详细信息请参考 Qt API 手册。

最后一步：处理自定义事件。处理自定义事件，同前面我们讲解的那些处理方法没有什么区别。我们可以重写QObject::customEvent()函数，该函数接收一个QEvent对象作为参数：

void QObject::customEvent(QEvent *event);

我们可以通过转换 event 对象类型来判断不同的事件：

void CustomWidget::customEvent(QEvent *event) {
    CustomEvent *customEvent = static_cast<CustomEvent *>(event);
    // ...
}
  • 当然，我们也可以在event()函数中直接处理：
bool CustomWidget::event(QEvent *event) {
    if (event->type() == MyCustomEventType) {
        CustomEvent *myEvent = static_cast<CustomEvent *>(event);
        // processing...
        return true;
    }
    return QWidget::event(event);
}


参考：

https://blog.csdn.net/qq_40729688/article/details/89500394

https://blog.csdn.net/small_prince_/article/details/96107813

https://mobile.51cto.com/symbian-272256.htm

最后

以上就是紧张战斗机为你收集整理的详解 Qt (事件过滤器、事件总结、自定义事件)的全部内容，希望文章能够帮你解决详解 Qt (事件过滤器、事件总结、自定义事件)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(36)

相关文章

Qt使用notify函数响应事件
Qt使用notify函数响应事件
Qt4.8与Qt5.12keyPressEvent函数差异现象分析解决方案引用
Qt4.8与Qt5.12keyPressEvent函数差异现象分析解决方案引用
Qt / Qt5 事件（event）机制详解
Qt / Qt5 事件（event）机制详解
自定义事件之C#设计笔记(十)
自定义事件之C#设计笔记(十)
详解 Qt (事件过滤器、事件总结、自定义事件)
详解 Qt (事件过滤器、事件总结、自定义事件)
12-事件
12-事件
qt发送event_详解关于Qt中Event事件处理流程
qt发送event_详解关于Qt中Event事件处理流程
Qt学习之路(19): 事件(event)
Qt学习之路(19): 事件(event)

评论列表共有 0 条评论

立即
投稿
返回
顶部