thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

KEYMAPPER: Remove DefaultEventMapper

Browse source 
Now the keymapper is enabled by default, it does not make sense to have
a separate class anymore.
This commit is contained in:
Bastien Bouclet 2017-08-14 18:22:50 +02:00
parent d2f09a4bfc
commit ec9c394787
6 changed files with 115 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

90
backends/keymapper/keymapper.cpp
View file

@ -33,12 +33,14 @@ namespace Common {
static const uint32 kDelayKeyboardEventMillis = 250;
static const uint32 kDelayMouseEventMillis = 50;
Keymapper::Keymapper(EventManager *evtMgr) :
_eventMan(evtMgr),
Keymapper::Keymapper(EventManager *eventMan) :
_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

43
backends/keymapper/keymapper.h
View file

@ -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

6
common/EventDispatcher.cpp
View file

@ -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() {

115
common/EventMapper.cpp
View file

@ -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

21
common/events.h
View file

@ -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;
};
/**

1
common/module.mk
View file

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