From: Manuel Nickschas Date: Wed, 8 Sep 2010 16:44:07 +0000 (+0200) Subject: Basic event dispatching (with priorities) X-Git-Tag: 0.8-beta1~122 X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=commitdiff_plain;h=03b1230e44adca6b808a6a702aa5173e578a1160 Basic event dispatching (with priorities) I think priorities make more sense than the prepending/appending of handlers we've had before. --- diff --git a/src/common/event.cpp b/src/common/event.cpp index 826af7c6..3803ab96 100644 --- a/src/common/event.cpp +++ b/src/common/event.cpp @@ -19,3 +19,9 @@ ***************************************************************************/ #include "event.h" + +Event::Event(EventManager::EventType type) + : _type(type) +{ + +} diff --git a/src/common/event.h b/src/common/event.h index ed82f7e8..b3fa8f5d 100644 --- a/src/common/event.h +++ b/src/common/event.h @@ -23,14 +23,20 @@ #include +#include "eventmanager.h" + class Event { public: - Event(); - virtual ~Event(); + explicit Event(EventManager::EventType type = EventManager::Invalid); + virtual ~Event() {}; + + inline EventManager::EventType type() const { return _type; } - virtual QStringList params() const; + //virtual QStringList params() const; +private: + EventManager::EventType _type; }; #endif diff --git a/src/common/eventmanager.cpp b/src/common/eventmanager.cpp index a8ddd675..c5f01b63 100644 --- a/src/common/eventmanager.cpp +++ b/src/common/eventmanager.cpp @@ -23,11 +23,13 @@ #include #include +#include "event.h" + EventManager::EventManager(QObject *parent) : QObject(parent) { } -void EventManager::registerObject(QObject *object, RegistrationMode mode, const QString &methodPrefix) { +void EventManager::registerObject(QObject *object, Priority priority, const QString &methodPrefix) { int eventEnumIndex = metaObject()->indexOfEnumerator("EventType"); Q_ASSERT(eventEnumIndex >= 0); QMetaEnum eventEnum = metaObject()->enumerator(eventEnumIndex); @@ -46,29 +48,75 @@ void EventManager::registerObject(QObject *object, RegistrationMode mode, const qWarning() << Q_FUNC_INFO << QString("Could not find EventType %1").arg(methodSignature); continue; } - Handler handler(object, i); - mode == Prepend ? registeredHandlers()[static_cast(eventType)].prepend(handler) - : registeredHandlers()[static_cast(eventType)].append(handler); - + Handler handler(object, i, priority); + registeredHandlers()[static_cast(eventType)].append(handler); qDebug() << "Registered event handler for" << methodSignature << "in" << object; } } -void EventManager::registerEventHandler(EventType event, QObject *object, const char *slot, RegistrationMode mode) { - registerEventHandler(QList() << event, object, slot, mode); +void EventManager::registerEventHandler(EventType event, QObject *object, const char *slot, Priority priority) { + registerEventHandler(QList() << event, object, slot, priority); } -void EventManager::registerEventHandler(QList events, QObject *object, const char *slot, RegistrationMode mode) { +void EventManager::registerEventHandler(QList events, QObject *object, const char *slot, Priority priority) { int methodIndex = object->metaObject()->indexOfMethod(slot); if(methodIndex < 0) { qWarning() << Q_FUNC_INFO << QString("Slot %1 not found in object %2").arg(slot).arg(object->objectName()); return; } - Handler handler(object, methodIndex); + Handler handler(object, methodIndex, priority); foreach(EventType event, events) { - mode == Prepend ? registeredHandlers()[event].prepend(handler) - : registeredHandlers()[event].append(handler); - + registeredHandlers()[event].append(handler); qDebug() << "Registered event handler for" << event << "in" << object; } } + +// not threadsafe! if we should want that, we need to add a mutexed queue somewhere in this general area. +void EventManager::sendEvent(Event *event) { + dispatchEvent(event); +} + +void EventManager::dispatchEvent(Event *event) { + // we try handlers from specialized to generic by masking the enum + + // build a list sorted by priorities that contains all eligible handlers + QList handlers; + EventType type = event->type(); + insertHandlers(registeredHandlers().value(type), handlers); + + // check if we have a generic handler for the event group + if((type & EventGroupMask) != type) + insertHandlers(registeredHandlers().value(type & EventGroupMask), handlers); + + // now dispatch the event + QList::const_iterator it = handlers.begin(); + while(it != handlers.end()) { + + // TODO: check event flags here! + + void *param[] = {0, Q_ARG(Event *, event).data() }; + it->object->qt_metacall(QMetaObject::InvokeMetaMethod, it->methodIndex, param); + + ++it; + } + + // finally, delete it + delete event; +} + +void EventManager::insertHandlers(const QList &newHandlers, QList &existing) { + foreach(Handler handler, newHandlers) { + if(existing.isEmpty()) + existing.append(handler); + else { + // need to insert it at the proper position + QList::iterator it = existing.begin(); + while(it != existing.end()) { + if(handler.priority > it->priority) + break; + ++it; + } + existing.insert(it, handler); + } + } +} diff --git a/src/common/eventmanager.h b/src/common/eventmanager.h index 78a72acc..b19e8eee 100644 --- a/src/common/eventmanager.h +++ b/src/common/eventmanager.h @@ -37,40 +37,55 @@ public: Append }; + enum Priority { + VeryLowPriority, + LowPriority, + NormalPriority, + HighPriority, + HighestPriority + }; + /* */ + /* These values make sense! Don't change without knowing what you do! */ enum EventType { Invalid = 0xffffffff, - GenericEvent = 0x000000, - - IrcServerEvent = 0x010000, - IrcServerLooking = 0x010001, - IrcServerConnecting = 0x010002, - IrcServerConnected = 0x010003, - IrcServerConnectionFailure = 0x010004, - IrcServerDisconnected = 0x010005, - IrcServerQuit = 0x010006, - - IrcServerIncoming = 0x010007, - - IrcEvent = 0x020000, - IrcEventCap = 0x020001, - IrcEventCapAuthenticate = 0x020002, - IrcEventInvite = 0x020003, - IrcEventJoin = 0x020004, - IrcEventKick = 0x020005, - IrcEventMode = 0x020006, - IrcEventNick = 0x020007, - IrcEventNotice = 0x020008, - IrcEventPart = 0x020009, - IrcEventPing = 0x02000a, - IrcEventPong = 0x02000b, - IrcEventPrivmsg = 0x02000c, - IrcEventQuit = 0x02000d, - IrcEventTopic = 0x02000e, - - IrcEventNumeric = 0x021000 /* needs 1000 (0x03e8) consecutive free values! */ + GenericEvent = 0x00000000, + + // for event group handlers (handleIrcEvent() will handle all IrcEvent* enums) + // event groups are specified by bits 20-24 + EventGroupMask = 0x00ff0000, + + NetworkEvent = 0x00010000, + NetworkConnecting, + NetworkInitializing, + NetworkInitialized, + NetworkReconnecting, + NetworkDisconnecting, + NetworkDisconnected, + NetworkIncoming, + + IrcServerEvent = 0x00020000, + IrcServerIncoming, + + IrcEvent = 0x00030000, + IrcEventCap, + IrcEventCapAuthenticate, + IrcEventInvite, + IrcEventJoin, + IrcEventKick, + IrcEventMode, + IrcEventNick, + IrcEventNotice, + IrcEventPart, + IrcEventPing, + IrcEventPong, + IrcEventPrivmsg, + IrcEventQuit, + IrcEventTopic, + + IrcEventNumeric = 0x00031000, /* needs 1000 (0x03e8) consecutive free values! */ }; EventManager(QObject *parent = 0); @@ -79,27 +94,41 @@ public: QStringList providesEnums(); public slots: - void registerObject(QObject *object, RegistrationMode mode = Append, const QString &methodPrefix = "handle"); - void registerEventHandler(EventType event, QObject *object, const char *slot, RegistrationMode mode = Append); - void registerEventHandler(QList events, QObject *object, const char *slot, RegistrationMode mode = Append); - - //void sendEvent(Event *event); + void registerObject(QObject *object, Priority priority = NormalPriority, const QString &methodPrefix = "handle"); + void registerEventHandler(EventType event, QObject *object, const char *slot, Priority priority = NormalPriority); + void registerEventHandler(QList events, QObject *object, const char *slot, Priority priority = NormalPriority); + + //! Send an event to the registered handlers + /** + The EventManager takes ownership of the event and will delete it once it's processed. + NOTE: This method is not threadsafe! + @param event The event to be dispatched + */ + void sendEvent(Event *event); private: struct Handler { QObject *object; int methodIndex; + Priority priority; - explicit Handler(QObject *obj = 0, int method = 0) { + explicit Handler(QObject *obj = 0, int method = 0, Priority prio = NormalPriority) { object = obj; methodIndex = method; + priority = prio; } }; - typedef QHash > HandlerHash; + typedef QHash > HandlerHash; inline const HandlerHash ®isteredHandlers() const { return _registeredHandlers; } inline HandlerHash ®isteredHandlers() { return _registeredHandlers; } + + //! Add handlers to an existing sorted (by priority) handler list + void insertHandlers(const QList &newHandlers, QList &existing); + + void dispatchEvent(Event *event); + HandlerHash _registeredHandlers; };