Ticket #9038: events.patch

backends/base-backend.h

@@ -29 +29 @@
 #include "common/system.h"
 #include "backends/events/default/default-events.h"
 
-class BaseBackend : public OSystem, EventProvider {
+class BaseBackend : public OSystem, Common::EventSource {
 public:
         virtual Common::EventManager *getEventManager();
         virtual void displayMessageOnOSD(const char *msg);

backends/events/default/default-events.cpp

@@ -92 +92 @@
         }
 }
 
-DefaultEventManager::DefaultEventManager(EventProvider *boss) :
-        _boss(boss),
+DefaultEventManager::DefaultEventManager(Common::EventSource *boss) :
         _buttonState(0),
         _modifierState(0),
         _shouldQuit(false),
         _shouldRTL(false),
         _confirmExitDialogActive(false) {
 
-        assert(_boss);
+        assert(boss);
+
+        _dispatcher.registerSource(boss, false);
+        _dispatcher.registerSource(&_artificialEventSource, false);
+
+        _dispatcher.registerObserver(this, kEventManPriority, false);
 
         _recordFile = NULL;
         _recordTimeFile = NULL;
@@ -202 +206 @@
 #endif
 #ifdef ENABLE_KEYMAPPER
         _keymapper = new Common::Keymapper(this);
+        // EventDispatcher will automatically free the keymapper
+        _dispatcher.registerMapper(_keymapper);
         _remap = false;
 #endif
 }
 
 DefaultEventManager::~DefaultEventManager() {
-#ifdef ENABLE_KEYMAPPER
-        delete _keymapper;
-#endif
 #ifdef ENABLE_VKEYBD
         delete _vk;
 #endif
@@ -219 +222 @@
         g_system->unlockMutex(_timeMutex);
         g_system->unlockMutex(_recorderMutex);
 
-        if (!artificialEventQueue.empty())
-                artificialEventQueue.clear();
-
         if (_playbackFile != NULL) {
                 delete _playbackFile;
         }
@@ -381 +381 @@
 
 bool DefaultEventManager::pollEvent(Common::Event &event) {
         uint32 time = g_system->getMillis();
-        bool result;
+        bool result = false;
 
-        if (!artificialEventQueue.empty()) {
-                event = artificialEventQueue.pop();
+        _dispatcher.dispatch();
+        if (!_eventQueue.empty()) {
+                event = _eventQueue.pop();
                 result = true;
-        } else {
-                result = _boss->pollEvent(event);
-
-#ifdef ENABLE_KEYMAPPER
-                if (result) {
-                        // send key press events to keymapper
-                        if (event.type == Common::EVENT_KEYDOWN) {
-                                if (_keymapper->mapKeyDown(event.kbd)) {
-                                        result = false;
-                                }
-                        } else if (event.type == Common::EVENT_KEYUP) {
-                                if (_keymapper->mapKeyUp(event.kbd)) {
-                                        result = false;
-                                }
-                        }
-                }
-#endif
         }
 
         if (_recordMode != kPassthrough)  {
@@ -598 +582 @@
 }
 
 void DefaultEventManager::pushEvent(const Common::Event &event) {
-
         // If already received an EVENT_QUIT, don't add another one
         if (event.type == Common::EVENT_QUIT) {
                 if (!_shouldQuit)
-                        artificialEventQueue.push(event);
+                        _artificialEventSource.addEvent(event);
         } else
-                artificialEventQueue.push(event);
+                _artificialEventSource.addEvent(event);
 }
 
 #endif // !defined(DISABLE_DEFAULT_EVENTMANAGER)

backends/events/default/default-events.h

@@ -41 +41 @@
 }
 
 
-class EventProvider {
-public:
-        virtual ~EventProvider() {}
-        /**
-         * Get the next event in the event queue.
-         * @param event point to an Common::Event struct, which will be filled with the event data.
-         * @return true if an event was retrieved.
-         */
-        virtual bool pollEvent(Common::Event &event) = 0;
-};
-
-
-class DefaultEventManager : public Common::EventManager {
-        EventProvider *_boss;
-
+class DefaultEventManager : public Common::EventManager, Common::EventObserver {
 #ifdef ENABLE_VKEYBD
         Common::VirtualKeyboard *_vk;
 #endif
@@ -65 +51 @@
         bool _remap;
 #endif
 
-        Common::Queue<Common::Event> _artificialEventQueue;
+        Common::ArtificialEventSource _artificialEventSource;
+
+        Common::Queue<Common::Event> _eventQueue;
+        bool notifyEvent(const Common::Event &ev) {
+                _eventQueue.push(ev);
+                return true;
+        }
 
         Common::Point _mousePos;
         int _buttonState;
@@ -128 +120 @@
         void record(Common::Event &event);
         bool playback(Common::Event &event);
 public:
-        DefaultEventManager(EventProvider *boss);
+        DefaultEventManager(Common::EventSource *boss);
         ~DefaultEventManager();
 
         virtual void init();

backends/keymapper/keymapper.cpp

@@ -168 +168 @@
                 _activeMaps.pop();
 }
 
+bool Keymapper::notifyEvent(const Common::Event &ev) {
+        if (ev.type == Common::EVENT_KEYDOWN)
+                return mapKeyDown(ev.kbd);
+        else if (ev.type == Common::EVENT_KEYUP)
+                return mapKeyUp(ev.kbd);
+        else
+                return false;
+}
+
 bool Keymapper::mapKeyDown(const KeyState& key) {
         return mapKey(key, true);
 }
@@ -255 +264 @@
                 }
 
                 evt.mouse = _eventMan->getMousePos();
-                _eventMan->pushEvent(evt);
+                addEvent(evt);
         }
 }
 

backends/keymapper/keymapper.h

@@ -39 +39 @@
 
 namespace Common {
 
-class Keymapper {
+class Keymapper : public Common::EventMapper, private Common::ArtificialEventSource {
 public:
 
         struct MapRecord {
@@ -134 +134 @@
          */
         void popKeymap();
 
+        // Implementation of the EventMapper interface
+        bool notifyEvent(const Common::Event &ev);
+        bool pollEvent(Common::Event &ev) { return Common::ArtificialEventSource::pollEvent(ev); }
+
         /**
          * @brief Map a key press event.
          * If the active keymap contains a Action mapped to the given key, then

new file common/events.cpp

@@ +1 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/events.h"
+
+namespace Common {
+
+EventDispatcher::EventDispatcher() : _mapper(0) {
+}
+
+EventDispatcher::~EventDispatcher() {
+        for (Common::List<SourceEntry>::iterator i = _sources.begin(); i != _sources.end(); ++i) {
+                if (i->autoFree)
+                        delete i->source;
+        }
+
+        for (Common::List<ObserverEntry>::iterator i = _observers.begin(); i != _observers.end(); ++i) {
+                if (i->autoFree)
+                        delete i->observer;
+        }
+
+        delete _mapper;
+        _mapper = 0;
+}
+
+void EventDispatcher::dispatch() {
+        Common::Event event;
+
+        for (Common::List<SourceEntry>::iterator i = _sources.begin(); i != _sources.end(); ++i) {
+                const bool allowMapping = i->source->allowMapping();
+
+                while (i->source->pollEvent(event)) {
+                        // We only try to process the events via the setup event mapper, when
+                        // we have a setup mapper and when the event source allows mapping.
+                        if (_mapper && allowMapping) {
+                                if (_mapper->notifyEvent(event)) {
+                                        // We allow the event mapper to create multiple events, when
+                                        // eating an event.
+                                        while (_mapper->pollEvent(event))
+                                                dispatchEvent(event);
+
+                                        // Try getting another event from the current EventSource.
+                                        continue;
+                                }
+                        }
+
+                        dispatchEvent(event);
+                }
+        }
+}
+
+void EventDispatcher::registerMapper(EventMapper *mapper) {
+        if (_mapper)
+                delete _mapper;
+        _mapper = mapper;
+}
+
+void EventDispatcher::registerSource(EventSource *source, bool autoFree) {
+        SourceEntry newEntry;
+
+        newEntry.source = source;
+        newEntry.autoFree = autoFree;
+
+        _sources.push_back(newEntry);
+}
+
+void EventDispatcher::unregisterSource(EventSource *source) {
+        for (Common::List<SourceEntry>::iterator i = _sources.begin(); i != _sources.end(); ++i) {
+                if (i->source == source) {
+                        if (i->autoFree)
+                                delete source;
+
+                        _sources.erase(i);
+                        return;
+                }
+        }       
+}
+
+void EventDispatcher::registerObserver(EventObserver *obs, uint priority, bool autoFree) {
+        ObserverEntry newEntry;
+
+        newEntry.observer = obs;
+        newEntry.priority = priority;
+        newEntry.autoFree = autoFree;
+
+        for (Common::List<ObserverEntry>::iterator i = _observers.begin(); i != _observers.end(); ++i) {
+                if (i->priority < priority) {
+                        _observers.insert(i, newEntry);
+                        return;
+                }
+        }
+
+        _observers.push_back(newEntry);
+}
+
+void EventDispatcher::unregisterObserver(EventObserver *obs) {
+        for (Common::List<ObserverEntry>::iterator i = _observers.begin(); i != _observers.end(); ++i) {
+                if (i->observer == obs) {
+                        if (i->autoFree)
+                                delete obs;
+
+                        _observers.erase(i);
+                        return;
+                }
+        }
+}
+
+void EventDispatcher::dispatchEvent(const Event &event) {
+        for (Common::List<ObserverEntry>::iterator i = _observers.begin(); i != _observers.end(); ++i) {
+                if (i->observer->notifyEvent(event))
+                        break;
+        }
+}
+
+} // end of namespace Common
+

common/events.h

@@ -31 +31 @@
 #include "common/rect.h"
 #include "common/noncopyable.h"
 
+#include "common/list.h"
+#include "common/singleton.h"
+
 namespace Common {
 
 /**
@@ -126 +129 @@
         Event() : type(EVENT_INVALID), synthetic(false) {}
 };
 
+/**
+ * A source of Events.
+ *
+ * An example for this is OSystem, it provides events created by the system
+ * and or user.
+ */
+class EventSource {
+public:
+        virtual ~EventSource() {}
+
+        /**
+         * Queries a event from the source.
+         *
+         * @param       event   a reference to the event struct, where the event should be stored.
+         * @return      true if an event was polled, false otherwise.
+         */
+        virtual bool pollEvent(Event &event) = 0;
+
+        /**
+         * Checks whether events from this source are allowed to be mapped.
+         *
+         * Possible event sources not allowing mapping are: the event recorder/player and/or
+         * the EventManager, which allows user events to be pushed.
+         *
+         * By default we allow mapping for every event source.
+         */
+        virtual bool allowMapping() const { return true; }
+};
+
+/**
+ * An artificial event source. This is class is used as an event source, which is
+ * made up by client specific events.
+ *
+ * Example usage cases for this are the Keymapper or the DefaultEventManager.
+ */
+class ArtificialEventSource : public EventSource {
+protected:
+        Common::Queue<Common::Event> _artificialEventQueue;
+public:
+        void addEvent(const Common::Event &ev) {
+                _artificialEventQueue.push(ev);
+        }
+
+        bool pollEvent(Common::Event &ev) {
+        if (!_artificialEventQueue.empty()) {
+                        ev = _artificialEventQueue.pop();
+                        return true;
+                } else {
+                        return false;
+                }
+        }
+
+        /**
+         * By default an artificial event source prevents its events
+         * from being mapped.
+         */
+        virtual bool allowMapping() const { return false; }
+};
+
+/**
+ * Object which catches and processes Events.
+ *
+ * An example for this is the Engine object, it is catching events and processing them.
+ */
+class EventObserver {
+public:
+        virtual ~EventObserver() {}
+
+        /**
+         * Notifies the source of an incoming event.
+         *
+         * An obeser is supposed to eat the event, with returning true, when
+         * it might want prevent other observers from preventing to receive
+         * the event. An usage example here is the keymapper:
+         * If it processes an Event, it should 'eat' it and create a new
+         * event, which the EventDispatcher will then catch.
+         *
+         * @param       event   the event, which is incoming.
+         * @return      true if this observer uses this event, false otherwise.
+         */
+        virtual bool notifyEvent(const Event &event) = 0;
+};
+
+/**
+ * A event mapper, which will map events to others.
+ *
+ * An example for this is the Keymapper.
+ */
+class EventMapper : public EventSource, public EventObserver {
+public:
+        /** For event mappers resulting events should never be mapped */
+        bool allowMapping() const { return false; }
+};
+
+/**
+ * Dispatches events from various sources to various observers.
+ *
+ * EventDispatcher is using a priority based approach. Observers
+ * with higher priority will be notified before observers with
+ * lower priority. Because of the possibility that oberservers
+ * might 'eat' events, not all observers might be notified.
+ *
+ * Another speciality is the support for a event mapper, which
+ * will catch events and create new events out of them. This
+ * mapper will be processed before an event is sent to the
+ * observers. 
+ */
+class EventDispatcher {
+public:
+        EventDispatcher();
+        ~EventDispatcher();
+
+        /**
+         * Tries to catch events from the registered event
+         * sources and dispatch them to the observers.
+         *
+         * This dispatches *all* events the sources offer.
+         */
+        void dispatch();
+
+        /**
+         * Registers an event mapper with the dispatcher.
+         *
+         * The ownership of the "mapper" variable will pass
+         * to the EventDispatcher, thus it will be deleted
+         * with "delete", when EventDispatcher is destroyed.
+         *
+         * Note there is only one mapper per EventDispatcher
+         * possible, thus when this method is called twice,
+         * the former mapper will be destroied.
+         */
+        void registerMapper(EventMapper *mapper);
+
+        /**
+         * Queries the setup event mapper.
+         */
+        EventMapper *queryMapper() const { return _mapper; }
+
+        /**
+         * Registers a new EventSource with the Dispatcher.
+         */
+        void registerSource(EventSource *source, bool autoFree);
+
+        /**
+         * Unregisters a EventSource.
+         *
+         * This takes the "autoFree" flag passed to registerSource into account.
+         */
+        void unregisterSource(EventSource *source);
+
+        /**
+         * Registers a new EventObserver with the Dispatcher.
+         */
+        void registerObserver(EventObserver *obs, uint priority, bool autoFree);
+
+        /**
+         * Unregisters a EventObserver.
+         *
+         * This takes the "autoFree" flag passed to registerObserver into account.
+         */
+        void unregisterObserver(EventObserver *obs);
+private:
+        EventMapper *_mapper;
+
+        struct Entry {
+                bool autoFree;
+        };
+
+        struct SourceEntry : public Entry {
+                EventSource *source;
+        };
+        
+        Common::List<SourceEntry> _sources;
+
+        struct ObserverEntry : public Entry {
+                uint priority;
+                EventObserver *observer;
+        };
+
+        Common::List<ObserverEntry> _observers;
+
+        void dispatchEvent(const Event &event);
+};
+
 class Keymapper;
 
 /**
@@ -207 +394 @@
         virtual Common::Keymapper *getKeymapper() = 0;
 #endif
 
-protected:
+        enum {
+                /**
+                 * Priority of the event manager, for now it's lowest since it eats
+                 * *all* events, we might to change that in the future though.
+                 */
+                kEventManPriority = 0
+        };
 
-        Common::Queue<Common::Event> artificialEventQueue;
+        /**
+         * Returns the underlying EventDispatcher.
+         */
+        EventDispatcher *getEventDispatcher() { return &_dispatcher; }
+
+protected:
+        EventDispatcher _dispatcher;
 };
 
 } // End of namespace Common

common/module.mk

@@ -5 +5 @@
         config-file.o \
         config-manager.o \
         debug.o \
+        events.o \
         file.o \
         fs.o \
         hashmap.o \