Ticket #8711: backends-lib.v3.2.patch

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

@@ -35 +35 @@
 
 DefaultEventManager::DefaultEventManager(OSystem *boss) :
         _boss(boss),
+        _keyMapper(boss->getKeyMapper()),
+        _virtualKeyboard(boss->getVirtualKeyboard()),
         _buttonState(0),
         _modifierState(0),
         _shouldQuit(false) {
@@ -52 +54 @@
         result = _boss->pollEvent(event);
         
         if (result) {
+                // check if we have to resolve virtual keyboard event
+                bool lbutton = event.type == Common::EVENT_LBUTTONDOWN || event.type == Common::EVENT_LBUTTONUP;
+                if (_boss->getFeatureState(OSystem::kFeatureVirtualKeyboard) && _virtualKeyboard && lbutton) { // possibly a virtual keyboard event
+                        _virtualKeyboard->resolve(event); // try to resolve a virtual keyboard event
+                }
+
+                // check if we have to resolve key mapping
+                if (_keyMapper) {
+                        _keyMapper->resolve(event);
+                }
+
                 event.synthetic = false;
                 switch (event.type) {
                 case Common::EVENT_KEYDOWN:
@@ -128 +141 @@
         return result;
 }
 
+void DefaultEventManager::registerActions(const Common::ActionList actions) {
+        _keyMapper->registerActions(actions);
+}
+void DefaultEventManager::unregisterActions() {
+        _keyMapper->unregisterActions();
+}
+
+
 #endif // !defined(DISABLE_DEFAULT_EVENTMANAGER)

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

@@ -43 +43 @@
 
 class DefaultEventManager : public Common::EventManager {
         OSystem *_boss;
+        KeyMapper *_keyMapper;
+        VirtualKeyboard *_virtualKeyboard;
 
         Common::Point _mousePos;
         int _buttonState;
@@ -67 +69 @@
 
         virtual bool pollEvent(Common::Event &event);
 
+        virtual void registerActions(const Common::ActionList);
+        virtual void unregisterActions();
+
         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;
+
+        _keyMapper = new KeyMapper();
+        _virtualKeyboard = new VirtualKeyboard();
 }
 
 OSystem_SDL::~OSystem_SDL() {
@@ -271 +274 @@
         delete _savefile;
         delete _mixer;
         delete _timer;
+
+        delete _keyMapper;
+        delete _virtualKeyboard;
 }
 
 uint32 OSystem_SDL::getMillis() {

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

@@ -444 +444 @@
         }
         return false;
 }
+KeyMapper *OSystem_SDL::getKeyMapper() {
+        return _keyMapper;
+}
 
+VirtualKeyboard *OSystem_SDL::getVirtualKeyboard() {
+        return _virtualKeyboard;
+}
+
 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

@@ -131 +131 @@
         // Returns true if an event was retrieved.
         virtual bool pollEvent(Common::Event &event); // overloaded by CE backend
 
+        virtual KeyMapper *getKeyMapper();
+
+        virtual VirtualKeyboard *getVirtualKeyboard();
+
         // 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:
+        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::UserAction> KeyActionMap;
+
+class KeyMapper {
+
+public:
+
+        KeyMapper();
+
+        virtual void registerActions(const Common::ActionList);
+        virtual void unregisterActions();
+
+        virtual void mapActions();
+
+        void resolve(Common::Event &);
+
+private:
+        bool _registered;
+        Common::ActionList _supportedActions;
+        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/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/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() :
+        _registered(false) {
+}
+
+void KeyMapper::registerActions(const Common::ActionList supportedActions) {
+        this->unregisterActions();
+        _supportedActions = supportedActions;
+        for (Common::ActionList::iterator mIt = _supportedActions.begin(); mIt != _supportedActions.end(); mIt++) {
+                // actions are mapped to default keys to substitute later the type of event
+                _mappings[mIt->defaultKey] = *mIt;
+        }
+        // open the keys dialog or look up mappings in the tables for the rest of actions
+        // ...
+        _registered = true;
+}
+
+void KeyMapper::unregisterActions() {
+        _supportedActions.clear();
+        _mappings.clear();
+        _registered = false;
+}
+
+void KeyMapper::mapActions() {
+}
+
+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;
+                if (it->second.type != Common::EVENT_INVALID) {
+                        event.type = it->second.type;
+                }
+        }
+}

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

@@ -28 +28 @@
 
 #include "common/scummsys.h"
 
+#include <list>
+
 namespace Common {
 
 enum KeyCode {
@@ -259 +261 @@
                 keycode = KEYCODE_INVALID;
                 ascii = flags = 0;
         }
+
+        bool operator <(const KeyState keyState) const {
+                return keycode < keyState.keycode;
+        }
+
 };
 
 } // 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"
+#include "backends/platform/common/virtual-keyboard.h"
+
 namespace Audio {
         class Mixer;
 }
@@ -724 +727 @@
          */
         virtual bool pollEvent(Common::Event &event) = 0;
 
+        virtual KeyMapper *getKeyMapper() { return NULL; }
+
+        virtual VirtualKeyboard *getVirtualKeyboard() { return NULL; }
+
 public:
+
         /** Get the number of milliseconds since the program was started. */
         virtual uint32 getMillis() = 0;
 
@@ -743 +751 @@
          */
         virtual Common::EventManager *getEventManager();
 
+
         //@}
 
 
@@ -894 +903 @@
          * 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 {
 
 /**
@@ -43 +44 @@
  *       indicates which button was pressed.
  */
 enum EventType {
+
+        EVENT_INVALID = 0,
         /** A key was pressed, details in Event::kbd. */
         EVENT_KEYDOWN = 1,
         /** A key was released, details in Event::kbd. */
@@ -107 +110 @@
           * 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.
@@ -115 +118 @@
          * screen area as defined by the most recent call to initSize().
          */
         Common::Point mouse;
+
+        Event(Common::EventType et = Common::EVENT_INVALID, bool s = false, 
+                Common::KeyState ks = Common::KeyState(), Common::Point p = Common::Point()) {
+                
+                type = et;
+                synthetic = s;
+                kbd = ks;
+                mouse = p;
+        }
+
+        void reset() {
+                type = Common::EVENT_INVALID;
+                synthetic = false;
+                kbd = Common::KeyState();
+                mouse = Common::Point();
+        }
 };
 
+enum Priority {
+        PRIORITY_HIGHEST,
+        PRIORITY_HIGH,
+        PRIORITY_NORMAL,
+        PRIORITY_LOW,
+        PRIORITY_LOWEST
+};
 
+struct UserAction {
+        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
+
+        UserAction(Common::KeyState ks = Common::KeyState(Common::KEYCODE_ESCAPE), 
+                Common::EventType et = Common::EVENT_KEYDOWN, String d = "Action name", 
+                Common::Priority p = Common::PRIORITY_NORMAL) {
+                
+                defaultKey = ks;
+                type = et;
+                description = d;
+                priority = p;
+        }
+
+        UserAction(Common::KeyState ks, String d, Common::Priority p = Common::PRIORITY_NORMAL) {
+                defaultKey = ks;
+                type = Common::EVENT_INVALID;
+                description = d;
+                priority = p;
+        }
+
+};
+
+typedef std::list<Common::UserAction> ActionList;
+
 /**
  * The EventManager provides user input events to the client code.
  * In addition, it keeps track of the state of various input devices,
@@ -166 +219 @@
         // 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 registerActions(const ActionList) = 0;
+
+        virtual void unregisterActions() = 0;
 };
 
 } // End of namespace Common

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::ActionList actions;
+
+        Common::KeyState key = Common::KeyState(Common::KEYCODE_F5);
+        Common::UserAction action = Common::UserAction(key, "Menu");
+        actions.push_back(action);
+
+        
+        key = Common::KeyState(Common::KEYCODE_ESCAPE);
+        action = Common::UserAction(key, "Esc");
+        actions.push_back(action);
+
+        key = Common::KeyState(Common::KEYCODE_p);
+        action = Common::UserAction(key, "Pause");
+        actions.push_back(action);
+
+        _eventMan->registerActions(actions);
 }
 
 SkyEngine::~SkyEngine() {