Ticket #8711: backends-lib.v3.patch

D:/programming/projects/gsoc/scummvm/backends/events/default/default-events.cpp

@@ -49 +49 @@
         uint32 time = _boss->getMillis();
         bool result;
         
-        result = _boss->pollEvent(event);
+        result = _boss->pollMappedEvent(event);
         
         if (result) {
                 event.synthetic = false;
@@ -128 +128 @@
         return result;
 }
 
+void DefaultEventManager::registerActionMappings(const Common::MappingList mappings) {
+        _boss->getKeyMapper()->registerActionMappings(mappings);
+}
+void DefaultEventManager::unregisterActionMappings() {
+        _boss->getKeyMapper()->unregisterActionMappings();
+}
+
+
 #endif // !defined(DISABLE_DEFAULT_EVENTMANAGER)

D:/programming/projects/gsoc/scummvm/backends/events/default/default-events.h

@@ -67 +67 @@
 
         virtual bool pollEvent(Common::Event &event);
 
+        virtual void registerActionMappings(const Common::MappingList);
+        virtual void unregisterActionMappings();
+
         virtual Common::Point getMousePos() const { return _mousePos; }
         virtual int getButtonState() const { return _buttonState; }
         virtual int getModifierState() const { return _modifierState; }

D:/programming/projects/gsoc/scummvm/backends/platform/sdl/sdl.cpp

@@ -257 +257 @@
         memset(&_mouseCurState, 0, sizeof(_mouseCurState));
 
         _inited = false;
+
+        // init keys available for the device
+        _availableKeys.push_front(Common::KEYCODE_F5);
+        _availableKeys.push_front(Common::KEYCODE_p);
+        _availableKeys.push_front(Common::KEYCODE_ESCAPE);
 }
 
 OSystem_SDL::~OSystem_SDL() {

D:/programming/projects/gsoc/scummvm/backends/platform/sdl/events.cpp

@@ -445 +445 @@
         return false;
 }
 
+Common::KeyCodeList OSystem_SDL::getAvailableKeys() const {
+        return _availableKeys;
+}
+
 bool OSystem_SDL::remapKey(SDL_Event &ev, Common::Event &event) {
 #ifdef LINUPY
         // On Yopy map the End button to quit

D:/programming/projects/gsoc/scummvm/backends/platform/sdl/sdl-common.h

@@ -34 +34 @@
 #include "graphics/scaler.h"
 #include "backends/intern.h"
 
+#include "backends/platform/common/common-system.h"
 
+
 namespace Audio {
         class Mixer;
 }
@@ -66 +68 @@
 };
 
 
-class OSystem_SDL : public OSystem {
+class OSystem_SDL : public OSystem_Common {
 public:
         OSystem_SDL();
         virtual ~OSystem_SDL();
@@ -131 +133 @@
         // Returns true if an event was retrieved.
         virtual bool pollEvent(Common::Event &event); // overloaded by CE backend
 
+        virtual std::list<Common::KeyCode> getAvailableKeys() const;
+
         // Set function that generates samples
         typedef void (*SoundProc)(void *param, byte *buf, int len);
         virtual bool setSoundCallback(SoundProc proc, void *param); // overloaded by CE backend
@@ -411 +415 @@
         virtual bool remapKey(SDL_Event &ev, Common::Event &event);
 
         void handleScalerHotkeys(const SDL_KeyboardEvent &key);
+
+private:
+        Common::KeyCodeList _availableKeys;
 };
 
 #endif

D:/programming/projects/gsoc/scummvm/backends/platform/common/common-system.h

@@ +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.
+ *
+ */
+
+#ifndef PLATFORM_COMMON_SYSTEM_H
+#define PLATFORM_COMMON_SYSTEM_H
+
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/keyboard.h"
+#include "common/events.h"
+
+#include "backends/platform/common/virtual-keyboard.h"
+#include "backends/platform/common/key-mapper.h"
+
+class OSystem_Common : public OSystem {
+
+public:
+        OSystem_Common();
+        ~OSystem_Common();
+
+        virtual bool pollMappedEvent(Common::Event &);
+        virtual KeyMapper *getKeyMapper();
+
+protected:
+
+        virtual Common::KeyCodeList getAvailableKeys() const = 0;
+
+private:
+
+        KeyMapper *_keyMapper;
+        VirtualKeyboard *_virtualKeyboard;
+
+};
+
+#endif

D:/programming/projects/gsoc/scummvm/backends/platform/common/key-mapper.h

@@ +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.
+ *
+ */
+
+#ifndef COMMON_KEY_MAPPER_H
+#define COMMON_KEY_MAPPER_H
+
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "common/keyboard.h"
+#include "common/events.h"
+
+#include <list>
+#include <map>
+
+typedef std::map<Common::KeyState, Common::ActionMapping> KeyActionMap;
+
+class KeyMapper {
+
+public:
+
+        KeyMapper(Common::KeyCodeList);
+
+        virtual void registerActionMappings(const Common::MappingList);
+        virtual void unregisterActionMappings();
+
+        void resolve(Common::Event &);
+
+private:
+        bool _registered;
+        Common::KeyCodeList _availableKeys; // keys available on the device
+        Common::MappingList _needsMapping; // mappings which default keys are not in the available keys
+        KeyActionMap _mappings; // available keys and action mappings
+};
+
+#endif
+ No newline at end of file

D:/programming/projects/gsoc/scummvm/backends/platform/common/virtual-keyboard.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.
+ *
+ */
+
+#include "backends/platform/common/virtual-keyboard.h"
+
+VirtualKeyboard::VirtualKeyboard() {
+}
+
+void VirtualKeyboard::resolve(Common::Event &event) {
+}

D:/programming/projects/gsoc/scummvm/backends/platform/common/virtual-keyboard.h

@@ +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.
+ *
+ */
+
+#ifndef COMMON_VIRTUAL_KEYBOARD_H
+#define COMMON_VIRTUAL_KEYBOARD_H
+
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "common/events.h"
+
+class VirtualKeyboard {
+
+public:
+        VirtualKeyboard();
+        void resolve(Common::Event &);
+};
+
+#endif
+ No newline at end of file

D:/programming/projects/gsoc/scummvm/backends/platform/common/key-mapper.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.
+ *
+ */
+
+#include "backends/platform/common/key-mapper.h"
+
+KeyMapper::KeyMapper(Common::KeyCodeList availableKeys) :
+        _availableKeys(availableKeys),
+        _registered(false) {
+}
+
+void KeyMapper::registerActionMappings(const Common::MappingList supportedActions) {
+        this->unregisterActionMappings();
+        // check if the backend supports any of the default keys
+        Common::MappingList tmpList = supportedActions;
+        for (Common::MappingList::iterator mIt = tmpList.begin(); mIt != tmpList.end(); mIt++) {
+                bool found = false;
+                for (Common::KeyCodeList::iterator kcIt = _availableKeys.begin(); !found && kcIt != _availableKeys.end(); kcIt++) {
+                        // TODO add support for flags
+                        if (mIt->defaultKey.keycode == *kcIt) {
+                                // TODO check the behaviour of map. Maybe heap objects should be used
+                                _mappings[mIt->defaultKey] = *mIt;
+                                found = true;
+                        }
+                }
+                if (!found) {
+                        _needsMapping.push_back(*mIt);
+                }
+        }
+        // open the keys dialog or look up mappings in the tables for the rest of actions
+        // ...
+        _registered = true;
+}
+
+void KeyMapper::unregisterActionMappings() {
+        _needsMapping.clear();
+        _mappings.clear();
+        _registered = false;
+}
+
+void KeyMapper::resolve(Common::Event &event) {
+        if (!_registered || _mappings.empty()) {
+                return;
+        }
+        KeyActionMap::iterator it =  _mappings.find(event.kbd);
+        if (it != _mappings.end()) {
+                event.kbd = it->second.defaultKey;
+                event.type = it->second.type;
+        }
+}

D:/programming/projects/gsoc/scummvm/backends/platform/common/module.mk

@@ +1 @@
+MODULE := backends/platform/common
+
+MODULE_OBJS := \
+        common-system.o
+
+MODULE_DIRS += \
+        backends/platform/common/
+
+# We don't use the rules.mk here on purpose
+OBJS := $(addprefix $(MODULE)/, $(MODULE_OBJS)) $(OBJS)

D:/programming/projects/gsoc/scummvm/backends/platform/common/common-system.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.
+ *
+ */
+#include "backends/platform/common/common-system.h"
+
+OSystem_Common::OSystem_Common() {
+        _keyMapper = NULL;
+        _virtualKeyboard = new VirtualKeyboard();
+}
+
+OSystem_Common::~OSystem_Common() {
+        if (_keyMapper) {
+                delete _keyMapper;
+        }
+        delete _virtualKeyboard;
+}
+bool OSystem_Common::pollMappedEvent(Common::Event &event) {
+
+        bool result = true;
+        if (pollEvent(event)) { // calling virtual superclass function
+                bool lbutton = event.type == Common::EVENT_LBUTTONDOWN || event.type == Common::EVENT_LBUTTONUP;
+                if (getFeatureState(kFeatureVirtualKeyboard) && lbutton) { // possible a virtual keyboard event
+                        _virtualKeyboard->resolve(event); // try to resolve a virtual keyboard event
+                }
+                getKeyMapper()->resolve(event);
+        } else {
+                result = false;
+        }
+        return result;
+}
+
+KeyMapper *OSystem_Common::getKeyMapper() {
+        if (!_keyMapper) {
+                _keyMapper = new KeyMapper(getAvailableKeys());
+        }
+        return _keyMapper;
+}

D:/programming/projects/gsoc/scummvm/common/keyboard.h

@@ -28 +28 @@
 
 #include "common/scummsys.h"
 
+#include <list>
+
 namespace Common {
 
 enum KeyCode {
@@ -181 +183 @@
         KEYCODE_UNDO        = 322       // Atari keyboard has Undo
 };
 
+typedef std::list<Common::KeyCode> KeyCodeList;
+
 /**
  * List of certan special and some fake 'ascii' values used in keyboard events.
  * The values for the function keys listed here are based on what certain SCUMM
@@ -259 +263 @@
                 keycode = KEYCODE_INVALID;
                 ascii = flags = 0;
         }
+
+        bool operator <(const KeyState keyState) const {
+                return keycode < keyState.keycode;
+        }
+
+        bool operator ==(const KeyState keyState) const {
+                return (keycode == keyState.keycode) && (flags == keyState.flags);
+        }
+
 };
 
 } // End of namespace Common

D:/programming/projects/gsoc/scummvm/common/system.h

@@ -31 +31 @@
 #include "common/noncopyable.h"
 #include "common/rect.h"
 
+#include "backends/platform/common/key-mapper.h"
+
 namespace Audio {
         class Mixer;
 }
@@ -724 +726 @@
          */
         virtual bool pollEvent(Common::Event &event) = 0;
 
+        /**
+         * Get the next event with resolved key mapping from 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 pollMappedEvent(Common::Event &event) = 0;
+
+        virtual KeyMapper *getKeyMapper() = 0;
+
 public:
+
         /** Get the number of milliseconds since the program was started. */
         virtual uint32 getMillis() = 0;
 
@@ -743 +755 @@
          */
         virtual Common::EventManager *getEventManager();
 
+
         //@}
 
 
@@ -894 +907 @@
          * refer to the SaveFileManager documentation.
          */
         virtual Common::SaveFileManager *getSavefileManager() = 0;
-
         //@}
 };
 

D:/programming/projects/gsoc/scummvm/common/events.h

@@ -28 +28 @@
 
 #include "common/keyboard.h"
 #include "common/rect.h"
-#include "common/system.h"
 #include "common/noncopyable.h"
 
+#include <list>
+
 namespace Common {
 
 /**
@@ -107 +108 @@
           * Keyboard data; only valid for keyboard events (EVENT_KEYDOWN and
           * EVENT_KEYUP). For all other event types, content is undefined.
           */
-        KeyState kbd;
+        Common::KeyState kbd;
         /**
          * The mouse coordinates, in virtual screen coordinates. Only valid
          * for mouse events.
@@ -117 +118 @@
         Common::Point mouse;
 };
 
+enum Priority {
+        PRIORITY_HIGHEST,
+        PRIORITY_HIGH,
+        PRIORITY_LOW,
+        PRIORITY_LOWEST
+};
 
+struct ActionMapping {
+        Common::KeyState defaultKey;  // default key combo used for mapping; includes modifier state
+        Common::EventType type;  // event type like key up/down, quit, save/load
+        String description; // human readable description, for a GUI keymapping config dialog
+        Common::Priority priority; // mapping priority
+
+        ActionMapping(Common::KeyState ks = Common::KeyState(Common::KEYCODE_ESCAPE), 
+                Common::EventType et = Common::EVENT_KEYDOWN, String d = "Action name", 
+                Common::Priority p = Common::PRIORITY_HIGHEST) {
+                
+                defaultKey = ks;
+                type = et;
+                description = d;
+                priority = p;
+        }
+};
+
+typedef std::list<Common::ActionMapping> MappingList;
+
 /**
  * The EventManager provides user input events to the client code.
  * In addition, it keeps track of the state of various input devices,
@@ -166 +192 @@
         // TODO: Keyboard repeat support?
         
         // TODO: Consider removing OSystem::getScreenChangeID and
-        // replacing it by a generic getScreenChangeID method here
+        // replacing it by a generic getScreenChaneID method here
+
+        virtual void registerActionMappings(const MappingList) = 0;
+
+        virtual void unregisterActionMappings() = 0;
 };
 
 } // End of namespace Common

D:/programming/projects/gsoc/scummvm/engines/cruise/cruise_main.cpp

@@ -30 +30 @@
 #include "cruise/cruise_main.h"
 #include "cruise/cell.h"
 
+#include "common/system.h"
+
 namespace Cruise {
 
 unsigned int timer = 0;

D:/programming/projects/gsoc/scummvm/engines/sky/sky.cpp

@@ -30 +30 @@
 #include "common/config-manager.h"
 #include "common/file.h"
 #include "common/fs.h"
+#include "common/keyboard.h"
 #include "common/events.h"
 #include "common/system.h"
 #include "common/timer.h"
@@ -183 +184 @@
 
 SkyEngine::SkyEngine(OSystem *syst)
         : Engine(syst), _fastMode(0), _debugger(0) {
+        Common::MappingList mappings;
+
+        Common::KeyState key = Common::KeyState(Common::KEYCODE_F5);
+        Common::ActionMapping mapping = Common::ActionMapping(key, Common::EVENT_KEYDOWN, "Menu", Common::PRIORITY_HIGHEST);
+        mappings.push_back(mapping);
+
+        
+        key = Common::KeyState(Common::KEYCODE_ESCAPE);
+        mapping = Common::ActionMapping(key, Common::EVENT_KEYDOWN, "Esc", Common::PRIORITY_HIGHEST);
+        mappings.push_back(mapping);
+
+        key = Common::KeyState(Common::KEYCODE_p);
+        mapping = Common::ActionMapping(key, Common::EVENT_KEYDOWN, "Pause", Common::PRIORITY_HIGHEST);
+        mappings.push_back(mapping);
+
+        _eventMan->registerActionMappings(mappings);
 }
 
 SkyEngine::~SkyEngine() {

D:/programming/projects/gsoc/scummvm/engines/gob/mult_v2.cpp

@@ -1153 +1153 @@
 
                 if (_multData->imdIndices[i] != -1) {
                         int fileN;
-                        char *imdFile;
+                        char *imdFile = NULL;
                         int dir;
                         int startFrame;
 

D:/programming/projects/gsoc/scummvm/engines/parallaction/dialogue.cpp

@@ -28 +28 @@
 #include "common/events.h"
 #include "parallaction/parallaction.h"
 
+#include "common/system.h"
 
 
+
 namespace Parallaction {
 
 #define SKIPPED_ANSWER             1000

D:/programming/projects/gsoc/scummvm/engines/parallaction/parallaction.cpp

@@ -30 +30 @@
 #include "common/file.h"
 #include "common/util.h"
 
+#include "common/system.h"
+
 #include "sound/mididrv.h"
 #include "sound/mixer.h"