Event filter

occasionally , Objects need to be viewed 、 Even to intercept events sent to another object . for example , The dialog may want to block key events , Don't let other components receive ; Or to change the default handling of the Enter key .

Through the previous chapters , We already know ,Qt Created QEvent After the event object , Would call QObject Of event() Function to handle the distribution of events . obviously , We can do it in event() Function to achieve the operation of interception . because event() The function is protected Of , therefore , You need to inherit an existing class . If there are many components , You need to rewrite a lot of them event() function . It's quite troublesome, of course , Not to mention rewriting event() Functions have to be careful with a lot of problems . Fortunately Qt Provides another mechanism to achieve this ： Event filter .

QObject There is one eventFilter() function , Used to build event filters . The signature of this function is as follows ：

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

This function, as its name suggests , It's a “ Event filter ”. So called event filters , It can be understood as a kind of filtering code . Think about the filters used in chemical experiments , Impurities can be left on the filter paper , Let the filtered liquid slip away . The same is true of event filters ： It will check the received events . If this is the type of event we're interested in , Just do our own thing ; If not , Just keep forwarding . This function returns one bool type , If you want to put the parameter event To filter out , such as , Don't want it to continue forwarding , Just go back to true, Otherwise return to false. The call time of the event filter is the target object （ That's what's in the parameter watched object ） Before receiving the event object . in other words , If you stop an event in the event filter , that ,watched Object and all subsequent event filters will not know such an event at all .

Let's look at a simple piece of code ：

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

MainWindow It's a class that we define . We rewrote it eventFilter() function . To filter events on specific components , First of all, we need to determine whether the object is a component that we are interested in , And then determine the type of event . In the code above , We don't want textEdit Component handles keyboard pressed Events . therefore , First we find this component , If this event is a keyboard event , Then return directly true, Which is to filter out this event , Other events still need to be dealt with , So back false. For other components , We don't guarantee that there's a filter , So the safest way is to call the function of the parent class .

eventFilter() Function is equivalent to creating a filter , Then we need to install this filter . To install the filter, you need to call QObject::installEventFilter() function . The signature of this function is as follows ：

void QObject::installEventFilter ( QObject * filterObj )

This function accepts a QObject * Parameters of type . Remember what we just said ,eventFilter() The function is QObject A member function of , therefore , arbitrarily QObject Can be used as event filters （ The problem lies in , If you don't rewrite eventFilter() function , This event filter has no effect , Because by default nothing will be filtered ）. The existing filter can pass through QObject::removeEventFilter() Function removal .

We can install multiple event handlers on one object , Just call it many times installEventFilter() function . If an object has multiple event filters , that , The last one to install will be the first to execute , That is, the sequence of last in first execution .

Remember our previous example ？ We use event() Function handles Tab key ：

bool CustomWidget::event(QEvent *e)
{
    if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return QWidget::event(e);
}

Now? , We can give you a version that uses event filters ：

bool FilterObject::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;
}

The power of event filters is , We can add an event filter for the entire application . Remember ,installEventFilter() The function is QObject Function of ,QApplication perhaps QCoreApplication Objects are QObject Subclasses of , therefore , We can approach QApplication perhaps QCoreApplication Add event filters . This global event filter will be called before any event filter of all other feature objects . Powerful as it is , But this behavior will seriously reduce the efficiency of event distribution of the whole application . therefore , Unless it has to be used , Otherwise, we shouldn't do it .

Be careful , If you are in the event filter delete A receiving component , Be sure to set the return value of the function to true. otherwise ,Qt The event will still be distributed to the receiving component , This causes the program to crash .

The event filter and the component on which the filter is installed must be on the same thread , otherwise , The filter will not work . in addition , If after installing the filter , These two components go to different threads , that , The filter will only work when they return to the same thread .