backends/keymapper/keymapper.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2 *
   3 * ScummVM is the legal property of its developers, whose names
   4 * are too numerous to list here. Please refer to the COPYRIGHT
   5 * file distributed with this source distribution.
   6 *
   7 * This program is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public License
   9 * as published by the Free Software Foundation; either version 2
  10 * of the License, or (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20 *
  21 * $URL$
  22 * $Id$
  23 *
  24 */
  25
  26 #include "backends/keymapper/keymapper.h"
  27
  28 #ifdef ENABLE_KEYMAPPER
  29
  30 #include "common/config-manager.h"
  31
  32 namespace Common {
  33
  34 void Keymapper::Domain::addKeymap(Keymap *map) {
  35         iterator it = find(map->getName());
  36
  37         if (it != end())
  38                 delete it->_value;
  39
  40         setVal(map->getName(), map);
  41 }
  42
  43 void Keymapper::Domain::deleteAllKeyMaps() {
  44         for (iterator it = begin(); it != end(); it++)
  45                 delete it->_value;
  46
  47         clear();
  48 }
  49
  50 Keymap *Keymapper::Domain::getKeymap(const String& name) {
  51         iterator it = find(name);
  52
  53         if (it != end())
  54                 return it->_value;
  55         else
  56                 return 0;
  57 }
  58
  59 Keymapper::Keymapper(EventManager *evtMgr)
  60         : _eventMan(evtMgr), _enabled(true), _hardwareKeys(0) {
  61         ConfigManager::Domain *confDom = ConfMan.getDomain(ConfigManager::kKeymapperDomain);
  62
  63         _globalDomain.setConfigDomain(confDom);
  64 }
  65
  66 Keymapper::~Keymapper() {
  67         delete _hardwareKeys;
  68 }
  69
  70 void Keymapper::registerHardwareKeySet(HardwareKeySet *keys) {
  71         if (_hardwareKeys)
  72                 error("Hardware key set already registered");
  73
  74         if (!keys) {
  75                 warning("No hardware keys are supplied");
  76                 return;
  77         }
  78
  79         _hardwareKeys = keys;
  80 }
  81
  82 void Keymapper::addGlobalKeymap(Keymap *keymap) {
  83         initKeymap(_globalDomain, keymap);
  84 }
  85
  86 void Keymapper::addGameKeymap(Keymap *keymap) {
  87         if (ConfMan.getActiveDomain() == 0)
  88                 error("Call to Keymapper::addGameKeymap when no game loaded");
  89
  90         // Detect whether the active game changed since last call.
  91         // If so, flush the game key configuration.
  92         if (_gameDomain.getConfigDomain() != ConfMan.getActiveDomain()) {
  93                 cleanupGameKeymaps();
  94                 _gameDomain.setConfigDomain(ConfMan.getActiveDomain());
  95         }
  96
  97         initKeymap(_gameDomain, keymap);
  98 }
  99
 100 void Keymapper::initKeymap(Domain &domain, Keymap *map) {
 101         if (!_hardwareKeys) {
 102                 warning("No hardware keys were registered yet (%s)", map->getName().c_str());
 103                 return;
 104         }
 105
 106         map->setConfigDomain(domain.getConfigDomain());
 107         map->loadMappings(_hardwareKeys);
 108
 109         if (map->isComplete(_hardwareKeys) == false) {
 110                 map->automaticMapping(_hardwareKeys);
 111                 map->saveMappings();
 112                 ConfMan.flushToDisk();
 113         }
 114
 115         domain.addKeymap(map);
 116 }
 117
 118 void Keymapper::cleanupGameKeymaps() {
 119         // Flush all game specific keymaps
 120         _gameDomain.deleteAllKeyMaps();
 121
 122         // Now restore the stack of active maps. Re-add all global keymaps, drop
 123         // the game specific (=deleted) ones.
 124         Stack<MapRecord> newStack;
 125
 126         for (int i = 0; i < _activeMaps.size(); i++) {
 127                 if (_activeMaps[i].global)
 128                         newStack.push(_activeMaps[i]);
 129         }
 130
 131         _activeMaps = newStack;
 132 }
 133
 134 Keymap *Keymapper::getKeymap(const String& name, bool &global) {
 135         Keymap *keymap = _gameDomain.getKeymap(name);
 136         global = false;
 137
 138         if (!keymap) {
 139                 keymap = _globalDomain.getKeymap(name);
 140                 global = true;
 141         }
 142
 143         return keymap;
 144 }
 145
 146 bool Keymapper::pushKeymap(const String& name, bool inherit) {
 147         bool global;
 148         Keymap *newMap = getKeymap(name, global);
 149
 150         if (!newMap) {
 151                 warning("Keymap '%s' not registered", name.c_str());
 152                 return false;
 153         }
 154
 155         pushKeymap(newMap, inherit, global);
 156
 157         return true;
 158 }
 159
 160 void Keymapper::pushKeymap(Keymap *newMap, bool inherit, bool global) {
 161         MapRecord mr = {newMap, inherit, global};
 162
 163         _activeMaps.push(mr);
 164 }
 165
 166 void Keymapper::popKeymap() {
 167         if (!_activeMaps.empty())
 168                 _activeMaps.pop();
 169 }
 170
 171 bool Keymapper::notifyEvent(const Common::Event &ev) {
 172         if (ev.type == Common::EVENT_KEYDOWN)
 173                 return mapKeyDown(ev.kbd);
 174         else if (ev.type == Common::EVENT_KEYUP)
 175                 return mapKeyUp(ev.kbd);
 176         else
 177                 return false;
 178 }
 179
 180 bool Keymapper::mapKeyDown(const KeyState& key) {
 181         return mapKey(key, true);
 182 }
 183
 184 bool Keymapper::mapKeyUp(const KeyState& key) {
 185         return mapKey(key, false);
 186 }
 187
 188 bool Keymapper::mapKey(const KeyState& key, bool keyDown) {
 189         if (!_enabled || _activeMaps.empty())
 190                 return false;
 191
 192         Action *action = 0;
 193
 194         if (keyDown) {
 195                 // Search for key in active keymap stack
 196                 for (int i = _activeMaps.size() - 1; i >= 0; --i) {
 197                         MapRecord mr = _activeMaps[i];
 198
 199                         action = mr.keymap->getMappedAction(key);
 200
 201                         if (action || mr.inherit == false)
 202                                 break;
 203                 }
 204
 205                 if (action)
 206                         _keysDown[key] = action;
 207         } else {
 208                 HashMap<KeyState, Action*>::iterator it = _keysDown.find(key);
 209
 210                 if (it != _keysDown.end()) {
 211                         action = it->_value;
 212                         _keysDown.erase(key);
 213                 }
 214         }
 215
 216         if (!action)
 217                 return false;
 218
 219         executeAction(action, keyDown);
 220
 221         return true;
 222 }
 223
 224 Action *Keymapper::getAction(const KeyState& key) {
 225         Action *action = 0;
 226
 227         return action;
 228 }
 229
 230 void Keymapper::executeAction(const Action *action, bool keyDown) {
 231         List<Event>::const_iterator it;
 232
 233         for (it = action->events.begin(); it != action->events.end(); ++it) {
 234                 Event evt = *it;
 235
 236                 switch (evt.type) {
 237                 case EVENT_KEYDOWN:
 238                         if (!keyDown) evt.type = EVENT_KEYUP;
 239                         break;
 240                 case EVENT_KEYUP:
 241                         if (keyDown) evt.type = EVENT_KEYDOWN;
 242                         break;
 243                 case EVENT_LBUTTONDOWN:
 244                         if (!keyDown) evt.type = EVENT_LBUTTONUP;
 245                         break;
 246                 case EVENT_LBUTTONUP:
 247                         if (keyDown) evt.type = EVENT_LBUTTONDOWN;
 248                         break;
 249                 case EVENT_RBUTTONDOWN:
 250                         if (!keyDown) evt.type = EVENT_RBUTTONUP;
 251                         break;
 252                 case EVENT_RBUTTONUP:
 253                         if (keyDown) evt.type = EVENT_RBUTTONDOWN;
 254                         break;
 255                 case EVENT_MBUTTONDOWN:
 256                         if (!keyDown) evt.type = EVENT_MBUTTONUP;
 257                         break;
 258                 case EVENT_MBUTTONUP:
 259                         if (keyDown) evt.type = EVENT_MBUTTONDOWN;
 260                         break;
 261                 default:
 262                         // don't deliver other events on key up
 263                         if (!keyDown) continue;
 264                 }
 265
 266                 evt.mouse = _eventMan->getMousePos();
 267                 addEvent(evt);
 268         }
 269 }
 270
 271 const HardwareKey *Keymapper::findHardwareKey(const KeyState& key) {
 272         return (_hardwareKeys) ? _hardwareKeys->findHardwareKey(key) : 0;
 273 }
 274
 275 } // end of namespace Common
 276
 277 #endif // #ifdef ENABLE_KEYMAPPER