KEYMAPPER: Remove DefaultEventMapper

Now the keymapper is enabled by default, it does not make sense to have
a separate class anymore.

backends/keymapper/keymapper.cpp

@@ -33,12 +33,14 @@ namespace Common {
 static const uint32 kDelayKeyboardEventMillis = 250;
 static const uint32 kDelayMouseEventMillis = 50;
 
-Keymapper::Keymapper(EventManager *evtMgr) :
+Keymapper::Keymapper(EventManager *eventMan) :
-		_eventMan(evtMgr),
+		_eventMan(eventMan),
 		_enabled(true),
 		_enabledKeymapType(Keymap::kKeymapTypeGlobal),
 		_hardwareInputs(nullptr),
-		_backendDefaultBindings(nullptr) {
+		_backendDefaultBindings(nullptr),
+		_delayedEventSource(new DelayedEventSource()) {
+	_eventMan->getEventDispatcher()->registerSource(_delayedEventSource, true);
 }
 
 Keymapper::~Keymapper() {
@@ -138,12 +140,18 @@ void Keymapper::setEnabledKeymapType(Keymap::KeymapType type) {
 
 List<Event> Keymapper::mapEvent(const Event &ev) {
 	if (!_enabled) {
-		return DefaultEventMapper::mapEvent(ev);
+		List<Event> originalEvent;
+		originalEvent.push_back(ev);
+		return originalEvent;
 	}
 
+	hardcodedEventMapping(ev);
+
 	const HardwareInput *hwInput = findHardwareInput(ev);
 	if (!hwInput) {
-		return DefaultEventMapper::mapEvent(ev);
+		List<Event> originalEvent;
+		originalEvent.push_back(ev);
+		return originalEvent;
 	}
 
 	IncomingEventType incomingEventType = convertToIncomingEventType(ev);
@@ -173,7 +181,8 @@ List<Event> Keymapper::mapEvent(const Event &ev) {
 	}
 
 	if (mappedEvents.empty()) {
-		return DefaultEventMapper::mapEvent(ev);
+		// if it didn't get mapped, just pass it through
+		mappedEvents.push_back(ev);
 	}
 
 	return mappedEvents;
@@ -205,14 +214,14 @@ Event Keymapper::executeAction(const Action *action, IncomingEventType incomingT
 	if (incomingType == kIncomingEventInstant && convertedType != EVENT_INVALID) {
 		// WORKAROUND: Delay the down events coming from non-key hardware events
 		// with a zero delay. This is to prevent DOWN1 DOWN2 UP1 UP2.
-		addDelayedEvent(0, evt);
+		_delayedEventSource->scheduleEvent(evt, 0);
 
 		// non-keys need to send up as well
 		// WORKAROUND: Delay the up events coming from non-key hardware events
 		// This is for engines that run scripts that check on key being down
 		evt.type = convertedType;
 		const uint32 delay = (convertedType == EVENT_KEYUP ? kDelayKeyboardEventMillis : kDelayMouseEventMillis);
-		addDelayedEvent(delay, evt);
+		_delayedEventSource->scheduleEvent(evt, delay);
 	}
 
 	return evt;
@@ -254,4 +263,69 @@ const HardwareInput *Keymapper::findHardwareInput(const Event &event) {
 	}
 }
 
+void Keymapper::hardcodedEventMapping(Event ev) {
+	// TODO: Either add support for long presses to the keymapper
+	// or move this elsewhere as an event observer + source
+#ifdef ENABLE_VKEYBD
+	// Trigger virtual keyboard on long press of more than 1 second
+	// of middle mouse button.
+	const uint32 vkeybdTime = 1000;
+
+	static uint32 vkeybdThen = 0;
+
+	if (ev.type == EVENT_MBUTTONDOWN) {
+		vkeybdThen = g_system->getMillis();
+	}
+
+	if (ev.type == EVENT_MBUTTONUP) {
+		if ((g_system->getMillis() - vkeybdThen) >= vkeybdTime) {
+			Event vkeybdEvent;
+			vkeybdEvent.type = EVENT_VIRTUAL_KEYBOARD;
+
+			// Avoid blocking event from engine.
+			_delayedEventSource->scheduleEvent(vkeybdEvent, 100);
+		}
+	}
+#endif
+
+	if (ev.type == EVENT_JOYBUTTON_DOWN) {
+		if (ev.joystick.button == JOYSTICK_BUTTON_START || ev.joystick.button == JOYSTICK_BUTTON_GUIDE) {
+			ev.type = EVENT_MAINMENU;
+		}
+	}
+}
+
+void DelayedEventSource::scheduleEvent(const Event &ev, uint32 delayMillis) {
+	if (_delayedEvents.empty()) {
+		_delayedEffectiveTime = g_system->getMillis() + delayMillis;
+		delayMillis = 0;
+	}
+	DelayedEventsEntry entry = DelayedEventsEntry(delayMillis, ev);
+	_delayedEvents.push(entry);
+}
+
+bool DelayedEventSource::pollEvent(Event &event) {
+	if (_delayedEvents.empty()) {
+		return false;
+	}
+
+	uint32 now = g_system->getMillis();
+
+	if (now >= _delayedEffectiveTime) {
+		event = _delayedEvents.pop().event;
+
+		if (!_delayedEvents.empty()) {
+			_delayedEffectiveTime += _delayedEvents.front().timerOffset;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+bool DelayedEventSource::allowMapping() const {
+	return false; // Events from this source have already been mapped, and should not be mapped again
+}
+
 } // End of namespace Common

backends/keymapper/keymapper.h

@@ -37,13 +37,14 @@ const char *const kGuiKeymapName = "gui";
 const char *const kGlobalKeymapName = "global";
 
 class Action;
+class DelayedEventSource;
 struct HardwareInput;
 class HardwareInputSet;
 class KeymapperDefaultBindings;
 
 typedef Array<Keymap *> KeymapArray;
 
-class Keymapper : public Common::DefaultEventMapper {
+class Keymapper : public Common::EventMapper {
 public:
 
 	Keymapper(EventManager *eventMan);
@@ -125,6 +126,10 @@ public:
 	void initKeymap(Keymap *keymap, ConfigManager::Domain *domain);
 
 private:
+	EventManager *_eventMan;
+	HardwareInputSet *_hardwareInputs;
+	const KeymapperDefaultBindings *_backendDefaultBindings;
+	DelayedEventSource *_delayedEventSource;
 
 	enum IncomingEventType {
 		kIncomingEventStart,
@@ -132,20 +137,38 @@ private:
 		kIncomingEventInstant
 	};
 
-	HardwareInputSet *_hardwareInputs;
-	const KeymapperDefaultBindings *_backendDefaultBindings;
-
-	Event executeAction(const Action *act, IncomingEventType incomingType);
-	EventType convertStartToEnd(EventType eventType);
-	IncomingEventType convertToIncomingEventType(const Event &ev) const;
-
-	EventManager *_eventMan;
-
 	bool _enabled;
 	Keymap::KeymapType _enabledKeymapType;
 
 	KeymapArray _keymaps;
 
+	Event executeAction(const Action *act, IncomingEventType incomingType);
+	EventType convertStartToEnd(EventType eventType);
+	IncomingEventType convertToIncomingEventType(const Event &ev) const;
+
+	void hardcodedEventMapping(Event ev);
+};
+
+class DelayedEventSource : public EventSource {
+public:
+	// EventSource API
+	bool pollEvent(Event &event) override;
+	bool allowMapping() const override;
+
+	/**
+	 * Schedule an event to be produced after the specified delay
+	 */
+	void scheduleEvent(const Event &ev, uint32 delayMillis);
+
+private:
+	struct DelayedEventsEntry {
+		const uint32 timerOffset;
+		const Event event;
+		DelayedEventsEntry(const uint32 offset, const Event ev) : timerOffset(offset), event(ev) { }
+	};
+
+	Queue<DelayedEventsEntry> _delayedEvents;
+	uint32 _delayedEffectiveTime;
 };
 
 } // End of namespace Common

common/EventDispatcher.cpp

@@ -72,12 +72,6 @@ void EventDispatcher::dispatch() {
 			}
 		}
 	}
-
-	List<Event> delayedEvents = _mapper->getDelayedEvents();
-	for (List<Event>::iterator k = delayedEvents.begin(); k != delayedEvents.end(); ++k) {
-		const Event delayedEvent = *k;
-		dispatchEvent(delayedEvent);
-	}
 }
 
 void EventDispatcher::clearEvents() {

common/EventMapper.cpp

@@ -1,115 +0,0 @@
-/* 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.
- *
- */
-
-#include "common/events.h"
-
-#include "common/system.h"
-#include "common/textconsole.h"
-
-namespace Common {
-
-List<Event> DefaultEventMapper::mapEvent(const Event &ev) {
-	List<Event> events;
-	Event mappedEvent;
-#ifdef ENABLE_VKEYBD
-	// Trigger virtual keyboard on long press of more than 1 second
-	// of middle mouse button.
-	const uint32 vkeybdTime = 1000;
-
-	static uint32 vkeybdThen = 0;
-
-	if (ev.type == EVENT_MBUTTONDOWN) {
-		vkeybdThen = g_system->getMillis();
-	}
-
-	if (ev.type == EVENT_MBUTTONUP) {
-		if ((g_system->getMillis() - vkeybdThen) >= vkeybdTime) {
-			mappedEvent.type = EVENT_VIRTUAL_KEYBOARD;
-
-			// Avoid blocking event from engine.
-			addDelayedEvent(100, ev);
-		}
-	}
-#endif
-
-	if (ev.type == EVENT_KEYDOWN) {
-		if (ev.kbd.hasFlags(KBD_CTRL) && ev.kbd.keycode == KEYCODE_F5) {
-			mappedEvent.type = EVENT_MAINMENU;
-		}
-#ifdef ENABLE_VKEYBD
-		else if (ev.kbd.hasFlags(KBD_CTRL) && ev.kbd.keycode == KEYCODE_F7) {
-			mappedEvent.type = EVENT_VIRTUAL_KEYBOARD;
-
-			// Avoid blocking CTRL-F7 events from engine.
-			addDelayedEvent(100, ev);
-		}
-#endif
-	}
-
-	if (ev.type == EVENT_JOYBUTTON_DOWN) {
-		if (ev.joystick.button == JOYSTICK_BUTTON_START || ev.joystick.button == JOYSTICK_BUTTON_GUIDE) {
-			mappedEvent.type = EVENT_MAINMENU;
-		}
-	}
-
-	// if it didn't get mapped, just pass it through
-	if (mappedEvent.type == EVENT_INVALID)
-		mappedEvent = ev;
-
-	// TODO: this check is not needed post-split
-	if (mappedEvent.type == EVENT_CUSTOM_BACKEND_HARDWARE) {
-		warning("EVENT_CUSTOM_BACKEND_HARDWARE was not mapped");
-		return List<Event>();
-	}
-
-	events.push_back(mappedEvent);
-	return events;
-}
-
-
-void DefaultEventMapper::addDelayedEvent(uint32 millis, Event ev) {
-	if (_delayedEvents.empty()) {
-		_delayedEffectiveTime = g_system->getMillis() + millis;
-		millis = 0;
-	}
-	DelayedEventsEntry entry = DelayedEventsEntry(millis, ev);
-	_delayedEvents.push(entry);
-}
-
-List<Event> DefaultEventMapper::getDelayedEvents() {
-	List<Event> events;
-
-	if (_delayedEvents.empty())
-		return events;
-
-	uint32 now = g_system->getMillis();
-
-	while (!_delayedEvents.empty() && now >= _delayedEffectiveTime) {
-		DelayedEventsEntry entry = _delayedEvents.pop();
-		if (!_delayedEvents.empty())
-			_delayedEffectiveTime += _delayedEvents.front().timerOffset;
-		events.push_back(entry.event);
-	}
-	return events;
-}
-
-} // namespace Common

common/events.h

@@ -283,27 +283,6 @@ public:
 	 * Map an incoming event to one or more action events
 	 */
 	virtual List<Event> mapEvent(const Event &ev) = 0;
-
-	virtual List<Event> getDelayedEvents() = 0;
-};
-
-class DefaultEventMapper : public EventMapper {
-public:
-	DefaultEventMapper() : _delayedEvents(), _delayedEffectiveTime(0) {}
-	// EventMapper interface
-	virtual List<Event> mapEvent(const Event &ev);
-	virtual List<Event> getDelayedEvents();
-protected:
-	virtual void addDelayedEvent(uint32 millis, Event ev);
-
-	struct DelayedEventsEntry {
-		const uint32 timerOffset;
-		const Event event;
-		DelayedEventsEntry(const uint32 offset, const Event ev) : timerOffset(offset), event(ev) { }
-	};
-
-	Queue<DelayedEventsEntry> _delayedEvents;
-	uint32 _delayedEffectiveTime;
 };
 
 /**

common/module.mk

@@ -8,7 +8,6 @@ MODULE_OBJS := \
 	debug.o \
 	error.o \
 	EventDispatcher.o \
-	EventMapper.o \
 	file.o \
 	fs.o \
 	gui_options.o \