Event Summary - common summary

Qt This is the whole Qt One of the core mechanisms of the framework , It's a little bit more complicated . Say it's complicated , More because it involves many functions , And there are many ways to deal with it , Sometimes it's hard to choose . Now let's summarize briefly Qt Event mechanism in .

Qt There are many kinds of events in the world ： Mouse events 、 Keyboard events 、 Events of size change 、 Location movement events and so on . How to deal with these events , There are actually two options ：

1. All events correspond to one event handler , In this event handler, a large branch statement is used to select , His representative work is win32 API Of WndProc() function ：

LRESULT CALLBACK WndProc(HWND hWnd,
                         UINT message,
                         WPARAM wParam,
                         LPARAM lParam)

In this function , We need to use switch sentence , choice message The type of the parameter , The typical code is ：

switch(message)
{
    case WM_PAINT:
        // ...
        break;
    case WM_DESTROY:
        // ...
        break;
    ...
}

1. Each event corresponds to an event handler .Qt That's the mechanism used ：
   • mouseEvent()
   • keyPressEvent()
   • …

Qt There are so many event handling functions , There must be a place to distribute it , otherwise ,Qt How do you know which event handler is called by which event ？ This distributed function , Namely event(). obviously , When QMouseEvent After that ,event() Function to distribute it to mouseEvent() Event handler .

event() Functions have two problems ：

1. event() Function is a protected Function of , It means that we want to rewrite event(), Must inherit an existing class . Just imagine , My program doesn't want mouse events at all , All components in the program are not allowed to handle mouse events , Do I have to inherit all the components , Rewrite them one by one event() function ？protected Another problem with functions is , If I develop based on third-party libraries , The other side did not provide the source code , There's only one link library , Everything else is packaged . How can I inherit the components in this library ？
2. event() Functions do have some control , But sometimes my needs are more stringent ： I hope those components don't see this kind of event at all .event() Function can intercept , But it's actually received QMouseEvent object . I can't even get it . The advantage of this is , Simulating a system has no effect at all on that event , So other components don't receive this event at all , You don't have to modify your own event handling functions . What about this demand ？

These two questions are event() Functions can't handle . therefore ,Qt Provides another solution ： Event filter . Event filters give us the ability to , Let's remove something completely . Event filters can be installed to any QObject Type above , And you can install more than one . If you want to implement a global event filter , Can be installed to QApplication perhaps QCoreApplication above . What needs to be noted here is , If you use installEventFilter() Function to install an event filter for an object , Then the event filter is only valid for that object , Only the events of this object need to be passed to the event filter first eventFilter() Function to filter , Other objects are not affected . If QApplication Object to install the event filter , So the filter works for every object in the program , The event of any object is first passed to eventFilter() function .

Event filter can solve the problem we just proposed event() Two shortcomings of the function ： First , Event filters are not protected Of , So we can offer any QObject Subclasses install event filters ; secondly , The event filter processes the event before it is received by the target object , If we filter out events , The target will not see this event at all .

in fact , There's another way , We didn't introduce .Qt The invocation of events will eventually go back to QCoreApplication::notify() function , therefore , The biggest control is actually rewriting QCoreApplication::notify(). The declaration of this function is ：

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

This function will event Send to receiver, That is to call receiver->event(event), The return value is from receiver Event handler for . Be careful , This function is called for any event of any object in any thread , therefore , It doesn't have a thread problem with event filters . But we don't recommend that , because notify() There is only one function , And event filters are much more flexible .

Now we can summarize Qt Event handling , There are actually five levels ：

1. rewrite paintEvent()、mousePressEvent() And so on . This is the most common 、 The simplest form , At the same time, the function is the simplest .
2. rewrite event() function .event() Function is the event entry for all objects ,QObject and QWidget In the implementation of , The default is to pass events to a specific event handler .
3. Install event filters on specific objects . The filter filters only the events received by the object .
4. stay QCoreApplication::instance() Event filters are installed on it . This filter will filter all events for all objects , So with notify() Functions are just as powerful , But it's more flexible , Because you can install multiple filters . The global event filter can see disabled Mouse events emitted from components . There's a problem with global filters ： Can only be used on the main thread .
5. rewrite QCoreApplication::notify() function . This is the most powerful , Like the global event filter, it provides full control , And it's not limited by threads . But only one can be used globally （ because QCoreApplication Is a singleton ）.

In order to further understand the calling sequence of these levels of event processing , We can write a test code ：

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

We can see , The output result after mouse click is ：

QApplication::eventFilter 
eventFilter 
event 
mousePressEvent

So you know , The global event filter is called first , Then there is the event filter on the object , The second is event() function , Finally, there are specific event handlers .