src/common/eventmanager.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2010 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "eventmanager.h"
  22
  23 #include <QDebug>
  24 #include <QMetaEnum>
  25
  26 #include "event.h"
  27
  28 EventManager::EventManager(QObject *parent) : QObject(parent) {
  29
  30 }
  31
  32 void EventManager::registerObject(QObject *object, Priority priority, const QString &methodPrefix) {
  33   int eventEnumIndex = metaObject()->indexOfEnumerator("EventType");
  34   Q_ASSERT(eventEnumIndex >= 0);
  35   QMetaEnum eventEnum = metaObject()->enumerator(eventEnumIndex);
  36
  37   for(int i = object->metaObject()->methodOffset(); i < object->metaObject()->methodCount(); i++) {
  38     QString methodSignature(object->metaObject()->method(i).signature());
  39
  40     if(!methodSignature.startsWith(methodPrefix))
  41       continue;
  42
  43     methodSignature = methodSignature.section('(',0,0);  // chop the attribute list
  44     methodSignature = methodSignature.mid(methodPrefix.length()); // strip prefix
  45
  46     int eventType = eventEnum.keyToValue(methodSignature.toAscii());
  47     if(eventType < 0) {
  48       qWarning() << Q_FUNC_INFO << QString("Could not find EventType %1").arg(methodSignature);
  49       continue;
  50     }
  51     Handler handler(object, i, priority);
  52     registeredHandlers()[static_cast<EventType>(eventType)].append(handler);
  53     qDebug() << "Registered event handler for" << methodSignature << "in" << object;
  54   }
  55 }
  56
  57 void EventManager::registerEventHandler(EventType event, QObject *object, const char *slot, Priority priority) {
  58   registerEventHandler(QList<EventType>() << event, object, slot, priority);
  59 }
  60
  61 void EventManager::registerEventHandler(QList<EventType> events, QObject *object, const char *slot, Priority priority) {
  62   int methodIndex = object->metaObject()->indexOfMethod(slot);
  63   if(methodIndex < 0) {
  64     qWarning() << Q_FUNC_INFO << QString("Slot %1 not found in object %2").arg(slot).arg(object->objectName());
  65     return;
  66   }
  67   Handler handler(object, methodIndex, priority);
  68   foreach(EventType event, events) {
  69     registeredHandlers()[event].append(handler);
  70     qDebug() << "Registered event handler for" << event << "in" << object;
  71   }
  72 }
  73
  74 // not threadsafe! if we should want that, we need to add a mutexed queue somewhere in this general area.
  75 void EventManager::sendEvent(Event *event) {
  76   dispatchEvent(event);
  77 }
  78
  79 void EventManager::dispatchEvent(Event *event) {
  80   // we try handlers from specialized to generic by masking the enum
  81
  82   // build a list sorted by priorities that contains all eligible handlers
  83   QList<Handler> handlers;
  84   EventType type = event->type();
  85   insertHandlers(registeredHandlers().value(type), handlers);
  86
  87   // check if we have a generic handler for the event group
  88   if((type & EventGroupMask) != type)
  89     insertHandlers(registeredHandlers().value(type & EventGroupMask), handlers);
  90
  91   // now dispatch the event
  92   QList<Handler>::const_iterator it = handlers.begin();
  93   while(it != handlers.end()) {
  94
  95     // TODO: check event flags here!
  96
  97     void *param[] = {0, Q_ARG(Event *, event).data() };
  98     it->object->qt_metacall(QMetaObject::InvokeMetaMethod, it->methodIndex, param);
  99
 100     ++it;
 101   }
 102
 103   // finally, delete it
 104   delete event;
 105 }
 106
 107 void EventManager::insertHandlers(const QList<Handler> &newHandlers, QList<Handler> &existing) {
 108   foreach(Handler handler, newHandlers) {
 109     if(existing.isEmpty())
 110       existing.append(handler);
 111     else {
 112       // need to insert it at the proper position
 113       QList<Handler>::iterator it = existing.begin();
 114       while(it != existing.end()) {
 115         if(handler.priority > it->priority)
 116           break;
 117         ++it;
 118       }
 119       existing.insert(it, handler);
 120     }
 121   }
 122 }