mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-15 06:08:35 +00:00
342 lines
8.6 KiB
C++
342 lines
8.6 KiB
C++
/* 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.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#include "backends/keymapper/keymap.h"
|
|
|
|
#ifdef ENABLE_KEYMAPPER
|
|
|
|
#include "backends/keymapper/hardware-key.h"
|
|
|
|
#define KEYMAP_KEY_PREFIX "keymap_"
|
|
|
|
namespace Common {
|
|
|
|
Keymap::Keymap(const Keymap& km) : _actions(km._actions), _keymap(), _configDomain(0) {
|
|
List<Action*>::iterator it;
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++) {
|
|
const HardwareKey *hwKey = (*it)->getMappedKey();
|
|
|
|
if (hwKey) {
|
|
_keymap[hwKey->key] = *it;
|
|
}
|
|
}
|
|
}
|
|
|
|
Keymap::~Keymap() {
|
|
List<Action*>::iterator it;
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++)
|
|
delete *it;
|
|
}
|
|
|
|
void Keymap::addAction(Action *action) {
|
|
if (findAction(action->id))
|
|
error("Action with id %s already in KeyMap", action->id);
|
|
|
|
_actions.push_back(action);
|
|
}
|
|
|
|
void Keymap::registerMapping(Action *action, const HardwareKey *hwKey) {
|
|
HashMap<KeyState, Action*>::iterator it;
|
|
|
|
it = _keymap.find(hwKey->key);
|
|
|
|
// if key is already mapped to a different action then un-map it
|
|
if (it != _keymap.end() && action != it->_value) {
|
|
it->_value->mapKey(0);
|
|
}
|
|
|
|
_keymap[hwKey->key] = action;
|
|
}
|
|
|
|
void Keymap::unregisterMapping(Action *action) {
|
|
const HardwareKey *hwKey = action->getMappedKey();
|
|
|
|
if (hwKey) {
|
|
_keymap.erase(hwKey->key);
|
|
}
|
|
}
|
|
|
|
Action *Keymap::getAction(const char *id) {
|
|
return findAction(id);
|
|
}
|
|
|
|
Action *Keymap::findAction(const char *id) {
|
|
List<Action*>::iterator it;
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++) {
|
|
if (strncmp((*it)->id, id, ACTION_ID_SIZE) == 0)
|
|
return *it;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const Action *Keymap::findAction(const char *id) const {
|
|
List<Action*>::const_iterator it;
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++) {
|
|
if (strncmp((*it)->id, id, ACTION_ID_SIZE) == 0)
|
|
return *it;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
Action *Keymap::getMappedAction(const KeyState& ks) const {
|
|
HashMap<KeyState, Action*>::iterator it;
|
|
|
|
it = _keymap.find(ks);
|
|
|
|
if (it == _keymap.end())
|
|
return 0;
|
|
else
|
|
return it->_value;
|
|
}
|
|
|
|
void Keymap::setConfigDomain(ConfigManager::Domain *dom) {
|
|
_configDomain = dom;
|
|
}
|
|
|
|
void Keymap::loadMappings(const HardwareKeySet *hwKeys) {
|
|
if (!_configDomain)
|
|
return;
|
|
|
|
ConfigManager::Domain::iterator it;
|
|
String prefix = KEYMAP_KEY_PREFIX + _name + "_";
|
|
|
|
for (it = _configDomain->begin(); it != _configDomain->end(); it++) {
|
|
const String& key = it->_key;
|
|
|
|
if (!key.hasPrefix(prefix.c_str()))
|
|
continue;
|
|
|
|
// parse Action ID
|
|
const char *actionId = key.c_str() + prefix.size();
|
|
Action *ua = getAction(actionId);
|
|
|
|
if (!ua) {
|
|
warning("'%s' keymap does not contain Action with ID %s",
|
|
_name.c_str(), actionId);
|
|
_configDomain->erase(key);
|
|
|
|
continue;
|
|
}
|
|
|
|
const HardwareKey *hwKey = hwKeys->findHardwareKey(it->_value.c_str());
|
|
|
|
if (!hwKey) {
|
|
warning("HardwareKey with ID %s not known", it->_value.c_str());
|
|
_configDomain->erase(key);
|
|
continue;
|
|
}
|
|
|
|
ua->mapKey(hwKey);
|
|
}
|
|
}
|
|
|
|
void Keymap::saveMappings() {
|
|
if (!_configDomain)
|
|
return;
|
|
|
|
List<Action*>::const_iterator it;
|
|
String prefix = KEYMAP_KEY_PREFIX + _name + "_";
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++) {
|
|
uint actIdLen = strlen((*it)->id);
|
|
|
|
actIdLen = (actIdLen > ACTION_ID_SIZE) ? ACTION_ID_SIZE : actIdLen;
|
|
|
|
String actId((*it)->id, (*it)->id + actIdLen);
|
|
char hwId[HWKEY_ID_SIZE+1];
|
|
|
|
memset(hwId, 0, HWKEY_ID_SIZE+1);
|
|
|
|
if ((*it)->getMappedKey()) {
|
|
memcpy(hwId, (*it)->getMappedKey()->hwKeyId, HWKEY_ID_SIZE);
|
|
}
|
|
_configDomain->setVal(prefix + actId, hwId);
|
|
}
|
|
}
|
|
|
|
bool Keymap::isComplete(const HardwareKeySet *hwKeys) {
|
|
List<Action*>::iterator it;
|
|
bool allMapped = true;
|
|
uint numberMapped = 0;
|
|
|
|
for (it = _actions.begin(); it != _actions.end(); it++) {
|
|
if ((*it)->getMappedKey()) {
|
|
numberMapped++;
|
|
} else {
|
|
allMapped = false;
|
|
}
|
|
}
|
|
|
|
return allMapped || (numberMapped == hwKeys->size());
|
|
}
|
|
|
|
// TODO:
|
|
// - current weakness:
|
|
// - if an action finds a key with required type but a parent action with
|
|
// higher priority is using it, that key is never used
|
|
void Keymap::automaticMapping(HardwareKeySet *hwKeys) {
|
|
// Create copies of action and key lists.
|
|
List<Action*> actions(_actions);
|
|
List<const HardwareKey*> keys(hwKeys->getHardwareKeys());
|
|
|
|
List<Action*>::iterator actIt;
|
|
List<const HardwareKey*>::iterator keyIt, selectedKey;
|
|
|
|
// Remove actions and keys from local lists that have already been mapped.
|
|
actIt = actions.begin();
|
|
|
|
while (actIt != actions.end()) {
|
|
Action *act = *actIt;
|
|
const HardwareKey *key = act->getMappedKey();
|
|
|
|
if (key) {
|
|
keys.remove(key);
|
|
actIt = actions.erase(actIt);
|
|
} else {
|
|
++actIt;
|
|
}
|
|
}
|
|
|
|
// Sort remaining actions by priority.
|
|
ActionPriorityComp priorityComp;
|
|
sort(actions.begin(), actions.end(), priorityComp);
|
|
|
|
// First mapping pass:
|
|
// - Match if a key's preferred action type is the same as the action's
|
|
// type, or vice versa.
|
|
// - Priority is given to:
|
|
// - keys that match action types over key types.
|
|
// - keys that have not been used by parent maps.
|
|
// - If a key has been used by a parent map the new action must have a
|
|
// higher priority than the parent action.
|
|
// - As soon as the number of skipped actions equals the number of keys
|
|
// remaining we stop matching. This means that the second pass will assign keys
|
|
// to these higher priority skipped actions.
|
|
uint skipped = 0;
|
|
actIt = actions.begin();
|
|
|
|
while (actIt != actions.end() && skipped < keys.size()) {
|
|
selectedKey = keys.end();
|
|
int matchRank = 0;
|
|
Action *act = *actIt;
|
|
|
|
for (keyIt = keys.begin(); keyIt != keys.end(); ++keyIt) {
|
|
if ((*keyIt)->preferredAction == act->type && act->type != kGenericActionType) {
|
|
Action *parentAct = getParentMappedAction((*keyIt)->key);
|
|
|
|
if (!parentAct) {
|
|
selectedKey = keyIt;
|
|
break;
|
|
} else if (parentAct->priority <= act->priority && matchRank < 3) {
|
|
selectedKey = keyIt;
|
|
matchRank = 3;
|
|
}
|
|
} else if ((*keyIt)->type == act->preferredKey && act->preferredKey != kGenericKeyType && matchRank < 2) {
|
|
Action *parentAct = getParentMappedAction((*keyIt)->key);
|
|
|
|
if (!parentAct) {
|
|
selectedKey = keyIt;
|
|
matchRank = 2;
|
|
} else if (parentAct->priority <= act->priority && matchRank < 1) {
|
|
selectedKey = keyIt;
|
|
matchRank = 1;
|
|
}
|
|
}
|
|
}
|
|
if (selectedKey != keys.end()) {
|
|
// Map action and delete action & key from local lists.
|
|
act->mapKey(*selectedKey);
|
|
keys.erase(selectedKey);
|
|
actIt = actions.erase(actIt);
|
|
} else {
|
|
// Skip action (will be mapped in next pass).
|
|
++actIt;
|
|
++skipped;
|
|
}
|
|
}
|
|
|
|
// Second mapping pass:
|
|
// - Maps any remaining actions to keys
|
|
// - priority given to:
|
|
// - keys that have no parent action
|
|
// - keys whose parent action has lower priority than the new action
|
|
// - keys whose parent action has the lowest priority
|
|
// - is guaranteed to match a key if they are not all used up
|
|
for (actIt = actions.begin(); actIt != actions.end(); ++actIt) {
|
|
selectedKey = keys.end();
|
|
|
|
int matchRank = 0;
|
|
int lowestPriority = 0;
|
|
Action *act = *actIt;
|
|
|
|
for (keyIt = keys.begin(); keyIt != keys.end(); ++keyIt) {
|
|
Action *parentAct = getParentMappedAction((*keyIt)->key);
|
|
|
|
if (!parentAct) {
|
|
selectedKey = keyIt;
|
|
break;
|
|
} else if (matchRank < 2) {
|
|
if (parentAct->priority <= act->priority) {
|
|
matchRank = 2;
|
|
selectedKey = keyIt;
|
|
} else if (parentAct->priority < lowestPriority || matchRank == 0) {
|
|
matchRank = 1;
|
|
lowestPriority = parentAct->priority;
|
|
selectedKey = keyIt;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selectedKey != keys.end()) {
|
|
act->mapKey(*selectedKey);
|
|
keys.erase(selectedKey);
|
|
} else {// no match = no keys left
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Action *Keymap::getParentMappedAction(KeyState key) {
|
|
if (_parent) {
|
|
Action *act = _parent->getMappedAction(key);
|
|
|
|
if (act)
|
|
return act;
|
|
else
|
|
return _parent->getParentMappedAction(key);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
} // end of namespace Common
|
|
|
|
#endif // #ifdef ENABLE_KEYMAPPER
|