refactor

Sine Striker

2023-12-11 c3c6647e7888b7dbe9d9d22fb77bf08104a3653c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include "sharedeventfilter.h"
 
namespace QWK {
 
    class EventFilterForwarder : public QObject {
    public:
        explicit EventFilterForwarder(SharedEventDispatcherPrivate *master,
                                      QObject *parent = nullptr)
            : QObject(parent), master(master) {
        }
 
        bool eventFilter(QObject *obj, QEvent *event) override;
 
    protected:
        SharedEventDispatcherPrivate *master;
    };
 
    class SharedEventDispatcherPrivate {
    public:
        explicit SharedEventDispatcherPrivate(SharedEventDispatcher *q)
            : q(q), forwarder(new EventFilterForwarder(this)) {
        }
        ~SharedEventDispatcherPrivate() = default;
 
        bool dispatch(QObject *obj, QEvent *event) {
            for (const auto &ef : qAsConst(eventFilters)) {
                if (ef->eventFilter(obj, event)) {
                    return true;
                }
            }
            return false;
        }
 
        inline void install(SharedEventFilter *eventFilter) {
            bool empty = eventFilters.isEmpty();
 
            eventFilters.append(eventFilter);
            eventFilter->m_dispatcher = q;
 
            if (empty) {
                q->target()->installEventFilter(forwarder.get());
            }
        }
 
        inline void uninstall(SharedEventFilter *eventFilter) {
            if (!eventFilters.removeOne(eventFilter)) {
                return;
            }
            eventFilter->m_dispatcher = nullptr;
 
            if (eventFilters.isEmpty()) {
                q->target()->removeEventFilter(forwarder.get());
            }
        }
 
        SharedEventDispatcher *q;
 
        std::unique_ptr<EventFilterForwarder> forwarder;
        QVector<SharedEventFilter *> eventFilters;
    };
 
    bool EventFilterForwarder::eventFilter(QObject *obj, QEvent *event) {
        return master->dispatch(obj, event);
    }
 
    SharedEventFilter::SharedEventFilter() : m_dispatcher(nullptr) {
    }
 
    SharedEventFilter::~SharedEventFilter() {
        if (m_dispatcher)
            m_dispatcher->removeSharedEventFilter(this);
    }
 
    SharedEventDispatcher::SharedEventDispatcher() : d(new SharedEventDispatcherPrivate(this)) {
    }
 
    SharedEventDispatcher::~SharedEventDispatcher() {
        delete d;
    }
 
    void SharedEventDispatcher::installSharedEventFilter(SharedEventFilter *eventFilter) {
        d->install(eventFilter);
    }
 
    void SharedEventDispatcher::removeSharedEventFilter(SharedEventFilter *eventFilter) {
        d->uninstall(eventFilter);
    }
 
 
}