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

KEYMAPPER: Remove automapping dead code

Browse source
This commit is contained in:
Tarek Soliman 2012-02-21 06:57:32 -06:00
parent d0c655f1fa
commit aa42d78658
15 changed files with 257 additions and 499 deletions
Download patch file Download diff file Expand all files Collapse all files

5
backends/keymapper/action.cpp
View file

@ -28,9 +28,8 @@
namespace Common { namespace Common {
Action::Action(Keymap *boss, const char *i, String des, ActionType typ, Action::Action(Keymap *boss, const char *i, String des, int pri, int flg)
KeyType prefKey, int pri, int flg) : _boss(boss), description(des),
: _boss(boss), description(des), type(typ), preferredKey(prefKey),
priority(pri), flags(flg), _hwKey(0) { priority(pri), flags(flg), _hwKey(0) {
assert(i); assert(i);
assert(_boss); assert(_boss);

5
backends/keymapper/action.h
View file

@ -27,7 +27,6 @@
#ifdef ENABLE_KEYMAPPER #ifdef ENABLE_KEYMAPPER
#include "backends/keymapper/types.h"
#include "common/events.h" #include "common/events.h"
#include "common/func.h" #include "common/func.h"
#include "common/list.h" #include "common/list.h"
@ -54,8 +53,6 @@ struct Action {
/** Events to be sent when mapped key is pressed */ /** Events to be sent when mapped key is pressed */
List<Event> events; List<Event> events;
ActionType type;
KeyType preferredKey;
int priority; int priority;
int group; int group;
int flags; int flags;
@ -67,8 +64,6 @@ private:
public: public:
Action(Keymap *boss, const char *id, String des = "", Action(Keymap *boss, const char *id, String des = "",
ActionType typ = kGenericActionType,
KeyType prefKey = kGenericKeyType,
int pri = 0, int flg = 0 ); int pri = 0, int flg = 0 );
void addEvent(const Event &evt) { void addEvent(const Event &evt) {

12
backends/keymapper/hardware-key.h
View file

@ -27,7 +27,6 @@
#ifdef ENABLE_KEYMAPPER #ifdef ENABLE_KEYMAPPER
#include "backends/keymapper/types.h"
#include "common/textconsole.h" #include "common/textconsole.h"
namespace Common { namespace Common {
@ -50,12 +49,8 @@ struct HardwareKey {
*/ */
KeyState key; KeyState key;
KeyType type; HardwareKey(const char *i, KeyState ky = KeyState(), String desc = "")
ActionType preferredAction; : key(ky), description(desc) {
HardwareKey(const char *i, KeyState ky = KeyState(), String desc = "",
KeyType typ = kGenericKeyType, ActionType prefAct = kGenericActionType)
: key(ky), description(desc), type(typ), preferredAction(prefAct) {
assert(i); assert(i);
Common::strlcpy(hwKeyId, i, HWKEY_ID_SIZE); Common::strlcpy(hwKeyId, i, HWKEY_ID_SIZE);
} }
@ -69,7 +64,6 @@ struct KeyTableEntry {
KeyCode keycode; KeyCode keycode;
uint16 ascii; uint16 ascii;
const char *desc; const char *desc;
KeyType preferredAction;
bool shiftable; bool shiftable;
}; };
@ -170,7 +164,7 @@ public:
snprintf(fullKeyDesc, 100, "%s%s", mod->desc, key->desc); snprintf(fullKeyDesc, 100, "%s%s", mod->desc, key->desc);
} }
addHardwareKey(new HardwareKey(fullKeyId, KeyState(key->keycode, ascii, mod->flag), fullKeyDesc, key->preferredAction )); addHardwareKey(new HardwareKey(fullKeyId, KeyState(key->keycode, ascii, mod->flag), fullKeyDesc));
} }
} }
} }

141
backends/keymapper/keymap.cpp
View file

@ -212,147 +212,6 @@ bool Keymap::isComplete(const HardwareKeySet *hwKeys) {
return allMapped || (numberMapped == hwKeys->size()); 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) {
#if 0 //disabling the broken automapper for now
// 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;
}
}
#endif
}
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 } // End of namespace Common
#endif // #ifdef ENABLE_KEYMAPPER #endif // #ifdef ENABLE_KEYMAPPER

11
backends/keymapper/keymap.h
View file

@ -52,7 +52,7 @@ template<> struct Hash<KeyState>
class Keymap { class Keymap {
public: public:
Keymap(const String& name, Keymap *parent = 0) : _name(name), _parent(parent) {} Keymap(const String& name) : _name(name) {}
Keymap(const Keymap& km); Keymap(const Keymap& km);
~Keymap(); ~Keymap();
@ -91,9 +91,6 @@ public:
*/ */
void saveMappings(); void saveMappings();
void automaticMapping(HardwareKeySet *hwKeys);
/** /**
* Returns true if all UserAction's in Keymap are mapped, or, * Returns true if all UserAction's in Keymap are mapped, or,
* all HardwareKey's from the given set have been used up. * all HardwareKey's from the given set have been used up.
@ -101,7 +98,6 @@ public:
bool isComplete(const HardwareKeySet *hwKeys); bool isComplete(const HardwareKeySet *hwKeys);
const String& getName() { return _name; } const String& getName() { return _name; }
Keymap *getParent() { return _parent; }
private: private:
friend struct Action; friend struct Action;
@ -131,12 +127,7 @@ private:
Action *findAction(const char *id); Action *findAction(const char *id);
const Action *findAction(const char *id) const; const Action *findAction(const char *id) const;
void internalMapKey(Action *action, HardwareKey *hwKey);
Action *getParentMappedAction(KeyState key);
String _name; String _name;
Keymap *_parent;
List<Action *> _actions; List<Action *> _actions;
HashMap<KeyState, Action *> _keymap; HashMap<KeyState, Action *> _keymap;
ConfigManager::Domain *_configDomain; ConfigManager::Domain *_configDomain;

1
backends/keymapper/keymapper.cpp
View file

@ -104,7 +104,6 @@ void Keymapper::initKeymap(Domain &domain, Keymap *map) {
map->loadMappings(_hardwareKeys); map->loadMappings(_hardwareKeys);
if (map->isComplete(_hardwareKeys) == false) { if (map->isComplete(_hardwareKeys) == false) {
map->automaticMapping(_hardwareKeys);
map->saveMappings(); map->saveMappings();
ConfMan.flushToDisk(); ConfMan.flushToDisk();
} }

74
backends/keymapper/types.h
View file

@ -1,74 +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.
*
*/
#ifndef KEYMAPPER_TYPES_H
#define KEYMAPPER_TYPES_H
#include "common/scummsys.h"
#ifdef ENABLE_KEYMAPPER
namespace Common {
enum KeyType {
kGenericKeyType,
kDirUpKeyType,
kDirDownKeyType,
kDirLeftKeyType,
kDirRightKeyType,
kActionKeyType,
kTriggerLeftKeyType,
kTriggerRightKeyType,
kStartKeyType,
kSelectKeyType,
/* ... */
kKeyTypeMax
};
enum ActionType {
kGenericActionType,
// common actions
kDirUpActionType,
kDirDownActionType,
kDirLeftActionType,
kDirRightActionType,
kLeftClickActionType,
kRightClickActionType,
kSaveActionType,
kMenuActionType,
kQuitActionType,
kVirtualKeyboardActionType,
kKeyRemapActionType,
kVolumeUpActionType,
kVolumeDownActionType,
kActionTypeMax
};
} // End of namespace Common
#endif // #ifdef ENABLE_KEYMAPPER
#endif // #ifndef KEYMAPPER_TYPES_H

7
backends/platform/android/events.cpp
View file

@ -227,17 +227,14 @@ void OSystem_Android::setupKeymapper() {
HardwareKeySet *keySet = new HardwareKeySet(); HardwareKeySet *keySet = new HardwareKeySet();
keySet->addHardwareKey( keySet->addHardwareKey(
new HardwareKey("n", KeyState(KEYCODE_n), "n (vk)", new HardwareKey("n", KeyState(KEYCODE_n), "n (vk)"));
kTriggerLeftKeyType,
kVirtualKeyboardActionType));
mapper->registerHardwareKeySet(keySet); mapper->registerHardwareKeySet(keySet);
Keymap *globalMap = new Keymap(kGlobalKeymapName); Keymap *globalMap = new Keymap(kGlobalKeymapName);
Action *act; Action *act;
act = new Action(globalMap, "VIRT", "Display keyboard", act = new Action(globalMap, "VIRT", "Display keyboard");
kVirtualKeyboardActionType);
act->addKeyEvent(KeyState(KEYCODE_F7, ASCII_F7, 0)); act->addKeyEvent(KeyState(KEYCODE_F7, ASCII_F7, 0));
mapper->addGlobalKeymap(globalMap); mapper->addGlobalKeymap(globalMap);

75
backends/platform/linuxmoto/hardwarekeys.cpp
View file

@ -33,60 +33,59 @@ struct Key {
KeyCode keycode; KeyCode keycode;
uint16 ascii; uint16 ascii;
const char *desc; const char *desc;
KeyType preferredAction;
bool shiftable; bool shiftable;
}; };
static const Key keys[] = { static const Key keys[] = {
{ "FIRE", KEYCODE_RETURN, ASCII_RETURN, "Fire", kActionKeyType, false }, { "FIRE", KEYCODE_RETURN, ASCII_RETURN, "Fire", false },
{ "CAMERA", KEYCODE_PAUSE, 0, "Camera", kActionKeyType, false }, { "CAMERA", KEYCODE_PAUSE, 0, "Camera", false },
{ "HANGUP", KEYCODE_ESCAPE, ASCII_ESCAPE, "Hangup", kStartKeyType, false }, { "HANGUP", KEYCODE_ESCAPE, ASCII_ESCAPE, "Hangup", false },
{ "CALL", KEYCODE_SPACE, ASCII_SPACE, "Call", kActionKeyType, false }, { "CALL", KEYCODE_SPACE, ASCII_SPACE, "Call", false },
{ "PLUS", KEYCODE_PLUS, '+', "+", kActionKeyType, false }, { "PLUS", KEYCODE_PLUS, '+', "+", false },
{ "MINUS", KEYCODE_MINUS, '-', "-", kActionKeyType, false }, { "MINUS", KEYCODE_MINUS, '-', "-", false },
#ifdef MOTOMAGX #ifdef MOTOMAGX
{"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", kActionKeyType, false}, {"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", false},
{"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", kActionKeyType, false}, {"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", false},
{"HASH", KEYCODE_HASH, '#', "#", kActionKeyType, false}, {"HASH", KEYCODE_HASH, '#', "#", false},
{"ASTERISK", KEYCODE_ASTERISK, '*', "*", kActionKeyType, false}, {"ASTERISK", KEYCODE_ASTERISK, '*', "*", false},
{"LEFTSOFT", KEYCODE_F9, ASCII_F9, "LeftSoft", kActionKeyType, false}, {"LEFTSOFT", KEYCODE_F9, ASCII_F9, "LeftSoft", false},
{"RIGHTSOFT", KEYCODE_F11, ASCII_F11, "RightSoft", kActionKeyType, false}, {"RIGHTSOFT", KEYCODE_F11, ASCII_F11, "RightSoft", false},
{"0", KEYCODE_0, '0', "0", kActionKeyType, false}, {"0", KEYCODE_0, '0', "0", false},
{"1", KEYCODE_1, '1', "1", kActionKeyType, false}, {"1", KEYCODE_1, '1', "1", false},
{"2", KEYCODE_2, '2', "2", kActionKeyType, false}, {"2", KEYCODE_2, '2', "2", false},
{"3", KEYCODE_3, '3', "3", kActionKeyType, false}, {"3", KEYCODE_3, '3', "3", false},
{"4", KEYCODE_4, '4', "4", kActionKeyType, false}, {"4", KEYCODE_4, '4', "4", false},
{"5", KEYCODE_5, '5', "5", kActionKeyType, false}, {"5", KEYCODE_5, '5', "5", false},
{"6", KEYCODE_6, '6', "6", kActionKeyType, false}, {"6", KEYCODE_6, '6', "6", false},
{"7", KEYCODE_7, '7', "7", kActionKeyType, false}, {"7", KEYCODE_7, '7', "7", false},
{"8", KEYCODE_8, '8', "8", kActionKeyType, false}, {"8", KEYCODE_8, '8', "8", false},
{"9", KEYCODE_9, '9', "9", kActionKeyType, false}, {"9", KEYCODE_9, '9', "9", false},
#endif #endif
#ifdef MOTOEZX #ifdef MOTOEZX
{ "a", KEYCODE_a, 'a', "a", kActionKeyType, true }, { "a", KEYCODE_a, 'a', "a", true },
{ "b", KEYCODE_b, 'b', "b", kActionKeyType, true }, { "b", KEYCODE_b, 'b', "b", true },
{ "c", KEYCODE_c, 'c', "c", kActionKeyType, true }, { "c", KEYCODE_c, 'c', "c", true },
{ "d", KEYCODE_d, 'd', "d", kActionKeyType, true }, { "d", KEYCODE_d, 'd', "d", true },
{ "e", KEYCODE_e, 'e', "e", kActionKeyType, true }, { "e", KEYCODE_e, 'e', "e", true },
{ "f", KEYCODE_f, 'f', "f", kActionKeyType, true }, { "f", KEYCODE_f, 'f', "f", true },
{ "g", KEYCODE_g, 'g', "g", kActionKeyType, true }, { "g", KEYCODE_g, 'g', "g", true },
{ "h", KEYCODE_h, 'h', "h", kActionKeyType, true }, { "h", KEYCODE_h, 'h', "h", true },
{ "i", KEYCODE_i, 'i', "i", kActionKeyType, true }, { "i", KEYCODE_i, 'i', "i", true },
{ "j", KEYCODE_j, 'j', "j", kActionKeyType, true }, { "j", KEYCODE_j, 'j', "j", true },
#endif #endif
// Numeric keypad // Numeric keypad
// Arrows + Home/End pad // Arrows + Home/End pad
{"UP", KEYCODE_UP, 0, "Up", kDirUpKeyType, false}, {"UP", KEYCODE_UP, 0, "Up", false},
{"DOWN", KEYCODE_DOWN, 0, "Down", kDirDownKeyType, false}, {"DOWN", KEYCODE_DOWN, 0, "Down", false},
{"RIGHT", KEYCODE_RIGHT, 0, "Right", kDirRightKeyType, false}, {"RIGHT", KEYCODE_RIGHT, 0, "Right", false},
{"LEFT", KEYCODE_LEFT, 0, "Left", kDirLeftKeyType, false}, {"LEFT", KEYCODE_LEFT, 0, "Left", false},
// Function keys // Function keys
// Miscellaneous function keys // Miscellaneous function keys
{0, KEYCODE_INVALID, 0, 0, kGenericKeyType, false} {0, KEYCODE_INVALID, 0, 0, false}
}; };
struct Mod { struct Mod {

163
backends/platform/maemo/maemo-keys.h
View file

@ -41,97 +41,96 @@ static const ModifierTableEntry maemoModifiers[] = {
}; };
static const KeyTableEntry maemoKeys[] = { static const KeyTableEntry maemoKeys[] = {
{"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", kActionKeyType, false}, {"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", false},
{"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", kActionKeyType, false}, {"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", false},
{"CLEAR", KEYCODE_CLEAR, 0, "Clear", kActionKeyType, false}, {"CLEAR", KEYCODE_CLEAR, 0, "Clear", false},
{"RETURN", KEYCODE_RETURN, ASCII_RETURN, "MCenter", kActionKeyType, false}, {"RETURN", KEYCODE_RETURN, ASCII_RETURN, "MCenter", false},
{"ESCAPE", KEYCODE_ESCAPE, ASCII_ESCAPE, "Esc", kStartKeyType, false}, {"ESCAPE", KEYCODE_ESCAPE, ASCII_ESCAPE, "Esc", false},
{"SPACE", KEYCODE_SPACE, ASCII_SPACE, "Space", kActionKeyType, false}, {"SPACE", KEYCODE_SPACE, ASCII_SPACE, "Space", false},
{"EXCLAIM", KEYCODE_EXCLAIM, '!', "!", kActionKeyType, false}, {"EXCLAIM", KEYCODE_EXCLAIM, '!', "!", false},
{"QUOTEDBL", KEYCODE_QUOTEDBL, '"', "\"", kActionKeyType, false}, {"QUOTEDBL", KEYCODE_QUOTEDBL, '"', "\"", false},
{"HASH", KEYCODE_HASH, '#', "#", kActionKeyType, false}, {"HASH", KEYCODE_HASH, '#', "#", false},
{"DOLLAR", KEYCODE_DOLLAR, '$', "$", kActionKeyType, false}, {"DOLLAR", KEYCODE_DOLLAR, '$', "$", false},
{"AMPERSAND", KEYCODE_AMPERSAND, '&', "&", kActionKeyType, false}, {"AMPERSAND", KEYCODE_AMPERSAND, '&', "&", false},
{"QUOTE", KEYCODE_QUOTE, '\'', "'", kActionKeyType, false}, {"QUOTE", KEYCODE_QUOTE, '\'', "'", false},
{"LEFTPAREN", KEYCODE_LEFTPAREN, '(', "(", kActionKeyType, false}, {"LEFTPAREN", KEYCODE_LEFTPAREN, '(', "(", false},
{"RIGHTPAREN", KEYCODE_RIGHTPAREN, ')', ")", kActionKeyType, false}, {"RIGHTPAREN", KEYCODE_RIGHTPAREN, ')', ")", false},
{"ASTERISK", KEYCODE_ASTERISK, '*', "*", kActionKeyType, false}, {"ASTERISK", KEYCODE_ASTERISK, '*', "*", false},
{"PLUS", KEYCODE_PLUS, '+', "+", kActionKeyType, false}, {"PLUS", KEYCODE_PLUS, '+', "+", false},
{"COMMA", KEYCODE_COMMA, ',', ",", kActionKeyType, false}, {"COMMA", KEYCODE_COMMA, ',', ",", false},
{"MINUS", KEYCODE_MINUS, '-', "-", kActionKeyType, false}, {"MINUS", KEYCODE_MINUS, '-', "-", false},
{"PERIOD", KEYCODE_PERIOD, '.', ".", kActionKeyType, false}, {"PERIOD", KEYCODE_PERIOD, '.', ".", false},
{"SLASH", KEYCODE_SLASH, '/', "/", kActionKeyType, false}, {"SLASH", KEYCODE_SLASH, '/', "/", false},
{"0", KEYCODE_0, '0', "0", kActionKeyType, false}, {"0", KEYCODE_0, '0', "0", false},
{"1", KEYCODE_1, '1', "1", kActionKeyType, false}, {"1", KEYCODE_1, '1', "1", false},
{"2", KEYCODE_2, '2', "2", kActionKeyType, false}, {"2", KEYCODE_2, '2', "2", false},
{"3", KEYCODE_3, '3', "3", kActionKeyType, false}, {"3", KEYCODE_3, '3', "3", false},
{"4", KEYCODE_4, '4', "4", kActionKeyType, false}, {"4", KEYCODE_4, '4', "4", false},
{"5", KEYCODE_5, '5', "5", kActionKeyType, false}, {"5", KEYCODE_5, '5', "5", false},
{"6", KEYCODE_6, '6', "6", kActionKeyType, false}, {"6", KEYCODE_6, '6', "6", false},
{"7", KEYCODE_7, '7', "7", kActionKeyType, false}, {"7", KEYCODE_7, '7', "7", false},
{"8", KEYCODE_8, '8', "8", kActionKeyType, false}, {"8", KEYCODE_8, '8', "8", false},
{"9", KEYCODE_9, '9', "9", kActionKeyType, false}, {"9", KEYCODE_9, '9', "9", false},
{"COLON", KEYCODE_COLON, ':', ":", kActionKeyType, false}, {"COLON", KEYCODE_COLON, ':', ":", false},
{"SEMICOLON", KEYCODE_SEMICOLON, ';', ";", kActionKeyType, false}, {"SEMICOLON", KEYCODE_SEMICOLON, ';', ";", false},
{"LESS", KEYCODE_LESS, '<', "<", kActionKeyType, false}, {"LESS", KEYCODE_LESS, '<', "<", false},
{"EQUALS", KEYCODE_EQUALS, '=', "=", kActionKeyType, false}, {"EQUALS", KEYCODE_EQUALS, '=', "=", false},
{"GREATER", KEYCODE_GREATER, '>', ">", kActionKeyType, false}, {"GREATER", KEYCODE_GREATER, '>', ">", false},
{"QUESTION", KEYCODE_QUESTION, '?', "?", kActionKeyType, false}, {"QUESTION", KEYCODE_QUESTION, '?', "?", false},
{"AT", KEYCODE_AT, '@', "@", kActionKeyType, false}, {"AT", KEYCODE_AT, '@', "@", false},
{"LEFTBRACKET", KEYCODE_LEFTBRACKET, '[', "[", kActionKeyType, false}, {"LEFTBRACKET", KEYCODE_LEFTBRACKET, '[', "[", false},
{"BACKSLASH", KEYCODE_BACKSLASH, '\\', "\\", kActionKeyType, false}, {"BACKSLASH", KEYCODE_BACKSLASH, '\\', "\\", false},
{"RIGHTBRACKET", KEYCODE_RIGHTBRACKET, ']', "]", kActionKeyType, false}, {"RIGHTBRACKET", KEYCODE_RIGHTBRACKET, ']', "]", false},
{"CARET", KEYCODE_CARET, '^', "^", kActionKeyType, false}, {"CARET", KEYCODE_CARET, '^', "^", false},
{"UNDERSCORE", KEYCODE_UNDERSCORE, '_', "_", kActionKeyType, false}, {"UNDERSCORE", KEYCODE_UNDERSCORE, '_', "_", false},
{"BACKQUOTE", KEYCODE_BACKQUOTE, '`', "`", kActionKeyType, false}, {"BACKQUOTE", KEYCODE_BACKQUOTE, '`', "`", false},
{"a", KEYCODE_a, 'a', "a", kActionKeyType, true}, {"a", KEYCODE_a, 'a', "a", true},
{"b", KEYCODE_b, 'b', "b", kActionKeyType, true}, {"b", KEYCODE_b, 'b', "b", true},
{"c", KEYCODE_c, 'c', "c", kActionKeyType, true}, {"c", KEYCODE_c, 'c', "c", true},
{"d", KEYCODE_d, 'd', "d", kActionKeyType, true}, {"d", KEYCODE_d, 'd', "d", true},
{"e", KEYCODE_e, 'e', "e", kActionKeyType, true}, {"e", KEYCODE_e, 'e', "e", true},
{"f", KEYCODE_f, 'f', "f", kActionKeyType, true}, {"f", KEYCODE_f, 'f', "f", true},
{"g", KEYCODE_g, 'g', "g", kActionKeyType, true}, {"g", KEYCODE_g, 'g', "g", true},
{"h", KEYCODE_h, 'h', "h", kActionKeyType, true}, {"h", KEYCODE_h, 'h', "h", true},
{"i", KEYCODE_i, 'i', "i", kActionKeyType, true}, {"i", KEYCODE_i, 'i', "i", true},
{"j", KEYCODE_j, 'j', "j", kActionKeyType, true}, {"j", KEYCODE_j, 'j', "j", true},
{"k", KEYCODE_k, 'k', "k", kActionKeyType, true}, {"k", KEYCODE_k, 'k', "k", true},
{"l", KEYCODE_l, 'l', "l", kActionKeyType, true}, {"l", KEYCODE_l, 'l', "l", true},
{"m", KEYCODE_m, 'm', "m", kActionKeyType, true}, {"m", KEYCODE_m, 'm', "m", true},
{"n", KEYCODE_n, 'n', "n", kActionKeyType, true}, {"n", KEYCODE_n, 'n', "n", true},
{"o", KEYCODE_o, 'o', "o", kActionKeyType, true}, {"o", KEYCODE_o, 'o', "o", true},
{"p", KEYCODE_p, 'p', "p", kActionKeyType, true}, {"p", KEYCODE_p, 'p', "p", true},
{"q", KEYCODE_q, 'q', "q", kActionKeyType, true}, {"q", KEYCODE_q, 'q', "q", true},
{"r", KEYCODE_r, 'r', "r", kActionKeyType, true}, {"r", KEYCODE_r, 'r', "r", true},
{"s", KEYCODE_s, 's', "s", kActionKeyType, true}, {"s", KEYCODE_s, 's', "s", true},
{"t", KEYCODE_t, 't', "t", kActionKeyType, true}, {"t", KEYCODE_t, 't', "t", true},
{"u", KEYCODE_u, 'u', "u", kActionKeyType, true}, {"u", KEYCODE_u, 'u', "u", true},
{"v", KEYCODE_v, 'v', "v", kActionKeyType, true}, {"v", KEYCODE_v, 'v', "v", true},
{"w", KEYCODE_w, 'w', "w", kActionKeyType, true}, {"w", KEYCODE_w, 'w', "w", true},
{"x", KEYCODE_x, 'x', "x", kActionKeyType, true}, {"x", KEYCODE_x, 'x', "x", true},
{"y", KEYCODE_y, 'y', "y", kActionKeyType, true}, {"y", KEYCODE_y, 'y', "y", true},
{"z", KEYCODE_z, 'z', "z", kActionKeyType, true}, {"z", KEYCODE_z, 'z', "z", true},
{"DELETE", KEYCODE_DELETE, 0, "Del", kActionKeyType, false}, {"DELETE", KEYCODE_DELETE, 0, "Del", false},
{"KP_ENTER", KEYCODE_KP_ENTER, 0, "Enter", kActionKeyType, false}, {"KP_ENTER", KEYCODE_KP_ENTER, 0, "Enter", false},
// Arrows + Home/End pad // Arrows + Home/End pad
{"UP", KEYCODE_UP, 0, "Up", kDirUpKeyType, false}, {"UP", KEYCODE_UP, 0, "Up", false},
{"DOWN", KEYCODE_DOWN, 0, "Down", kDirDownKeyType, false}, {"DOWN", KEYCODE_DOWN, 0, "Down", false},
{"RIGHT", KEYCODE_RIGHT, 0, "Right", kDirRightKeyType, false}, {"RIGHT", KEYCODE_RIGHT, 0, "Right", false},
{"LEFT", KEYCODE_LEFT, 0, "Left", kDirLeftKeyType, false}, {"LEFT", KEYCODE_LEFT, 0, "Left", false},
// Function keys // Function keys
{"MENU", KEYCODE_F11, 0, "Menu", kActionKeyType, false}, {"MENU", KEYCODE_F11, 0, "Menu", false},
{"HOME", KEYCODE_F12, 0, "Home", kActionKeyType, false}, {"HOME", KEYCODE_F12, 0, "Home", false},
{"FULLSCREEN", KEYCODE_F13, 0, "FullScreen", kActionKeyType, false}, {"FULLSCREEN", KEYCODE_F13, 0, "FullScreen", false},
{"ZOOMPLUS", KEYCODE_F14, 0, "Zoom+", kActionKeyType, false}, {"ZOOMPLUS", KEYCODE_F14, 0, "Zoom+", false},
{"ZOOMMINUS", KEYCODE_F15, 0, "Zoom-", kActionKeyType, false}, {"ZOOMMINUS", KEYCODE_F15, 0, "Zoom-", false},
{0, KEYCODE_INVALID, 0, 0, kGenericKeyType, false} {0, KEYCODE_INVALID, 0, 0, false}
}; };
} // namespace Common } // namespace Common
#endif // ifndef PLATFORM_SDL_MAEMO_KEYS_H #endif // ifndef PLATFORM_SDL_MAEMO_KEYS_H

4
backends/platform/maemo/maemo.cpp
View file

@ -189,13 +189,13 @@ Common::Keymap *OSystem_SDL_Maemo::getGlobalKeymap() {
evt.customType = Maemo::kEventClickMode; evt.customType = Maemo::kEventClickMode;
act->addEvent(evt); act->addEvent(evt);
act = new Action(globalMap, "LCLK", _("Left Click"), kLeftClickActionType); act = new Action(globalMap, "LCLK", _("Left Click"));
act->addLeftClickEvent(); act->addLeftClickEvent();
act = new Action(globalMap, "MCLK", _("Middle Click")); act = new Action(globalMap, "MCLK", _("Middle Click"));
act->addMiddleClickEvent(); act->addMiddleClickEvent();
act = new Action(globalMap, "RCLK", _("Right Click"), kRightClickActionType); act = new Action(globalMap, "RCLK", _("Right Click"));
act->addRightClickEvent(); act->addRightClickEvent();
return globalMap; return globalMap;

242
backends/platform/sdl/hardwarekeys.cpp
View file

@ -29,139 +29,139 @@
using namespace Common; using namespace Common;
static const KeyTableEntry sdlKeys[] = { static const KeyTableEntry sdlKeys[] = {
{"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", kActionKeyType, false}, {"BACKSPACE", KEYCODE_BACKSPACE, ASCII_BACKSPACE, "Backspace", false},
{"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", kActionKeyType, false}, {"TAB", KEYCODE_TAB, ASCII_TAB, "Tab", false},
{"CLEAR", KEYCODE_CLEAR, 0, "Clear", kActionKeyType, false}, {"CLEAR", KEYCODE_CLEAR, 0, "Clear", false},
{"RETURN", KEYCODE_RETURN, ASCII_RETURN, "Return", kActionKeyType, false}, {"RETURN", KEYCODE_RETURN, ASCII_RETURN, "Return", false},
{"PAUSE", KEYCODE_PAUSE, 0, "Pause", kActionKeyType, false}, {"PAUSE", KEYCODE_PAUSE, 0, "Pause", false},
{"ESCAPE", KEYCODE_ESCAPE, ASCII_ESCAPE, "Esc", kStartKeyType, false}, {"ESCAPE", KEYCODE_ESCAPE, ASCII_ESCAPE, "Esc", false},
{"SPACE", KEYCODE_SPACE, ASCII_SPACE, "Space", kActionKeyType, false}, {"SPACE", KEYCODE_SPACE, ASCII_SPACE, "Space", false},
{"EXCLAIM", KEYCODE_EXCLAIM, '!', "!", kActionKeyType, false}, {"EXCLAIM", KEYCODE_EXCLAIM, '!', "!", false},
{"QUOTEDBL", KEYCODE_QUOTEDBL, '"', "\"", kActionKeyType, false}, {"QUOTEDBL", KEYCODE_QUOTEDBL, '"', "\"", false},
{"HASH", KEYCODE_HASH, '#', "#", kActionKeyType, false}, {"HASH", KEYCODE_HASH, '#', "#", false},
{"DOLLAR", KEYCODE_DOLLAR, '$', "$", kActionKeyType, false}, {"DOLLAR", KEYCODE_DOLLAR, '$', "$", false},
{"AMPERSAND", KEYCODE_AMPERSAND, '&', "&", kActionKeyType, false}, {"AMPERSAND", KEYCODE_AMPERSAND, '&', "&", false},
{"QUOTE", KEYCODE_QUOTE, '\'', "'", kActionKeyType, false}, {"QUOTE", KEYCODE_QUOTE, '\'', "'", false},
{"LEFTPAREN", KEYCODE_LEFTPAREN, '(', "(", kActionKeyType, false}, {"LEFTPAREN", KEYCODE_LEFTPAREN, '(', "(", false},
{"RIGHTPAREN", KEYCODE_RIGHTPAREN, ')', ")", kActionKeyType, false}, {"RIGHTPAREN", KEYCODE_RIGHTPAREN, ')', ")", false},
{"ASTERISK", KEYCODE_ASTERISK, '*', "*", kActionKeyType, false}, {"ASTERISK", KEYCODE_ASTERISK, '*', "*", false},
{"PLUS", KEYCODE_PLUS, '+', "+", kActionKeyType, false}, {"PLUS", KEYCODE_PLUS, '+', "+", false},
{"COMMA", KEYCODE_COMMA, ',', ",", kActionKeyType, false}, {"COMMA", KEYCODE_COMMA, ',', ",", false},
{"MINUS", KEYCODE_MINUS, '-', "-", kActionKeyType, false}, {"MINUS", KEYCODE_MINUS, '-', "-", false},
{"PERIOD", KEYCODE_PERIOD, '.', ".", kActionKeyType, false}, {"PERIOD", KEYCODE_PERIOD, '.', ".", false},
{"SLASH", KEYCODE_SLASH, '/', "/", kActionKeyType, false}, {"SLASH", KEYCODE_SLASH, '/', "/", false},
{"0", KEYCODE_0, '0', "0", kActionKeyType, false}, {"0", KEYCODE_0, '0', "0", false},
{"1", KEYCODE_1, '1', "1", kActionKeyType, false}, {"1", KEYCODE_1, '1', "1", false},
{"2", KEYCODE_2, '2', "2", kActionKeyType, false}, {"2", KEYCODE_2, '2', "2", false},
{"3", KEYCODE_3, '3', "3", kActionKeyType, false}, {"3", KEYCODE_3, '3', "3", false},
{"4", KEYCODE_4, '4', "4", kActionKeyType, false}, {"4", KEYCODE_4, '4', "4", false},
{"5", KEYCODE_5, '5', "5", kActionKeyType, false}, {"5", KEYCODE_5, '5', "5", false},
{"6", KEYCODE_6, '6', "6", kActionKeyType, false}, {"6", KEYCODE_6, '6', "6", false},
{"7", KEYCODE_7, '7', "7", kActionKeyType, false}, {"7", KEYCODE_7, '7', "7", false},
{"8", KEYCODE_8, '8', "8", kActionKeyType, false}, {"8", KEYCODE_8, '8', "8", false},
{"9", KEYCODE_9, '9', "9", kActionKeyType, false}, {"9", KEYCODE_9, '9', "9", false},
{"COLON", KEYCODE_COLON, ':', ":", kActionKeyType, false}, {"COLON", KEYCODE_COLON, ':', ":", false},
{"SEMICOLON", KEYCODE_SEMICOLON, ';', ";", kActionKeyType, false}, {"SEMICOLON", KEYCODE_SEMICOLON, ';', ";", false},
{"LESS", KEYCODE_LESS, '<', "<", kActionKeyType, false}, {"LESS", KEYCODE_LESS, '<', "<", false},
{"EQUALS", KEYCODE_EQUALS, '=', "=", kActionKeyType, false}, {"EQUALS", KEYCODE_EQUALS, '=', "=", false},
{"GREATER", KEYCODE_GREATER, '>', ">", kActionKeyType, false}, {"GREATER", KEYCODE_GREATER, '>', ">", false},
{"QUESTION", KEYCODE_QUESTION, '?', "?", kActionKeyType, false}, {"QUESTION", KEYCODE_QUESTION, '?', "?", false},
{"AT", KEYCODE_AT, '@', "@", kActionKeyType, false}, {"AT", KEYCODE_AT, '@', "@", false},
{"LEFTBRACKET", KEYCODE_LEFTBRACKET, '[', "[", kActionKeyType, false}, {"LEFTBRACKET", KEYCODE_LEFTBRACKET, '[', "[", false},
{"BACKSLASH", KEYCODE_BACKSLASH, '\\', "\\", kActionKeyType, false}, {"BACKSLASH", KEYCODE_BACKSLASH, '\\', "\\", false},
{"RIGHTBRACKET", KEYCODE_RIGHTBRACKET, ']', "]", kActionKeyType, false}, {"RIGHTBRACKET", KEYCODE_RIGHTBRACKET, ']', "]", false},
{"CARET", KEYCODE_CARET, '^', "^", kActionKeyType, false}, {"CARET", KEYCODE_CARET, '^', "^", false},
{"UNDERSCORE", KEYCODE_UNDERSCORE, '_', "_", kActionKeyType, false}, {"UNDERSCORE", KEYCODE_UNDERSCORE, '_', "_", false},
{"BACKQUOTE", KEYCODE_BACKQUOTE, '`', "`", kActionKeyType, false}, {"BACKQUOTE", KEYCODE_BACKQUOTE, '`', "`", false},
{"a", KEYCODE_a, 'a', "a", kActionKeyType, true}, {"a", KEYCODE_a, 'a', "a", true},
{"b", KEYCODE_b, 'b', "b", kActionKeyType, true}, {"b", KEYCODE_b, 'b', "b", true},
{"c", KEYCODE_c, 'c', "c", kActionKeyType, true}, {"c", KEYCODE_c, 'c', "c", true},
{"d", KEYCODE_d, 'd', "d", kActionKeyType, true}, {"d", KEYCODE_d, 'd', "d", true},
{"e", KEYCODE_e, 'e', "e", kActionKeyType, true}, {"e", KEYCODE_e, 'e', "e", true},
{"f", KEYCODE_f, 'f', "f", kActionKeyType, true}, {"f", KEYCODE_f, 'f', "f", true},
{"g", KEYCODE_g, 'g', "g", kActionKeyType, true}, {"g", KEYCODE_g, 'g', "g", true},
{"h", KEYCODE_h, 'h', "h", kActionKeyType, true}, {"h", KEYCODE_h, 'h', "h", true},
{"i", KEYCODE_i, 'i', "i", kActionKeyType, true}, {"i", KEYCODE_i, 'i', "i", true},
{"j", KEYCODE_j, 'j', "j", kActionKeyType, true}, {"j", KEYCODE_j, 'j', "j", true},
{"k", KEYCODE_k, 'k', "k", kActionKeyType, true}, {"k", KEYCODE_k, 'k', "k", true},
{"l", KEYCODE_l, 'l', "l", kActionKeyType, true}, {"l", KEYCODE_l, 'l', "l", true},
{"m", KEYCODE_m, 'm', "m", kActionKeyType, true}, {"m", KEYCODE_m, 'm', "m", true},
{"n", KEYCODE_n, 'n', "n", kActionKeyType, true}, {"n", KEYCODE_n, 'n', "n", true},
{"o", KEYCODE_o, 'o', "o", kActionKeyType, true}, {"o", KEYCODE_o, 'o', "o", true},
{"p", KEYCODE_p, 'p', "p", kActionKeyType, true}, {"p", KEYCODE_p, 'p', "p", true},
{"q", KEYCODE_q, 'q', "q", kActionKeyType, true}, {"q", KEYCODE_q, 'q', "q", true},
{"r", KEYCODE_r, 'r', "r", kActionKeyType, true}, {"r", KEYCODE_r, 'r', "r", true},
{"s", KEYCODE_s, 's', "s", kActionKeyType, true}, {"s", KEYCODE_s, 's', "s", true},
{"t", KEYCODE_t, 't', "t", kActionKeyType, true}, {"t", KEYCODE_t, 't', "t", true},
{"u", KEYCODE_u, 'u', "u", kActionKeyType, true}, {"u", KEYCODE_u, 'u', "u", true},
{"v", KEYCODE_v, 'v', "v", kActionKeyType, true}, {"v", KEYCODE_v, 'v', "v", true},
{"w", KEYCODE_w, 'w', "w", kActionKeyType, true}, {"w", KEYCODE_w, 'w', "w", true},
{"x", KEYCODE_x, 'x', "x", kActionKeyType, true}, {"x", KEYCODE_x, 'x', "x", true},
{"y", KEYCODE_y, 'y', "y", kActionKeyType, true}, {"y", KEYCODE_y, 'y', "y", true},
{"z", KEYCODE_z, 'z', "z", kActionKeyType, true}, {"z", KEYCODE_z, 'z', "z", true},
{"DELETE", KEYCODE_DELETE, 0, "Del", kActionKeyType, false}, {"DELETE", KEYCODE_DELETE, 0, "Del", false},
// Numeric keypad // Numeric keypad
{"KP0", KEYCODE_KP0, 0, "KP0", kActionKeyType, false}, {"KP0", KEYCODE_KP0, 0, "KP0", false},
{"KP1", KEYCODE_KP1, 0, "KP1", kActionKeyType, false}, {"KP1", KEYCODE_KP1, 0, "KP1", false},
{"KP2", KEYCODE_KP2, 0, "KP2", kActionKeyType, false}, {"KP2", KEYCODE_KP2, 0, "KP2", false},
{"KP3", KEYCODE_KP3, 0, "KP3", kActionKeyType, false}, {"KP3", KEYCODE_KP3, 0, "KP3", false},
{"KP4", KEYCODE_KP4, 0, "KP4", kActionKeyType, false}, {"KP4", KEYCODE_KP4, 0, "KP4", false},
{"KP5", KEYCODE_KP5, 0, "KP5", kActionKeyType, false}, {"KP5", KEYCODE_KP5, 0, "KP5", false},
{"KP6", KEYCODE_KP6, 0, "KP6", kActionKeyType, false}, {"KP6", KEYCODE_KP6, 0, "KP6", false},
{"KP7", KEYCODE_KP7, 0, "KP7", kActionKeyType, false}, {"KP7", KEYCODE_KP7, 0, "KP7", false},
{"KP8", KEYCODE_KP8, 0, "KP8", kActionKeyType, false}, {"KP8", KEYCODE_KP8, 0, "KP8", false},
{"KP9", KEYCODE_KP9, 0, "KP9", kActionKeyType, false}, {"KP9", KEYCODE_KP9, 0, "KP9", false},
{"KP_PERIOD", KEYCODE_KP_PERIOD, 0, "KP.", kActionKeyType, false}, {"KP_PERIOD", KEYCODE_KP_PERIOD, 0, "KP.", false},
{"KP_DIVIDE", KEYCODE_KP_DIVIDE, 0, "KP/", kActionKeyType, false}, {"KP_DIVIDE", KEYCODE_KP_DIVIDE, 0, "KP/", false},
{"KP_MULTIPLY", KEYCODE_KP_MULTIPLY, 0, "KP*", kActionKeyType, false}, {"KP_MULTIPLY", KEYCODE_KP_MULTIPLY, 0, "KP*", false},
{"KP_MINUS", KEYCODE_KP_MINUS, 0, "KP-", kActionKeyType, false}, {"KP_MINUS", KEYCODE_KP_MINUS, 0, "KP-", false},
{"KP_PLUS", KEYCODE_KP_PLUS, 0, "KP+", kActionKeyType, false}, {"KP_PLUS", KEYCODE_KP_PLUS, 0, "KP+", false},
{"KP_ENTER", KEYCODE_KP_ENTER, 0, "KP Enter", kActionKeyType, false}, {"KP_ENTER", KEYCODE_KP_ENTER, 0, "KP Enter", false},
{"KP_EQUALS", KEYCODE_KP_EQUALS, 0, "KP=", kActionKeyType, false}, {"KP_EQUALS", KEYCODE_KP_EQUALS, 0, "KP=", false},
// Arrows + Home/End pad // Arrows + Home/End pad
{"UP", KEYCODE_UP, 0, "Up", kDirUpKeyType, false}, {"UP", KEYCODE_UP, 0, "Up", false},
{"DOWN", KEYCODE_DOWN, 0, "Down", kDirDownKeyType, false}, {"DOWN", KEYCODE_DOWN, 0, "Down", false},
{"RIGHT", KEYCODE_RIGHT, 0, "Right", kDirRightKeyType, false}, {"RIGHT", KEYCODE_RIGHT, 0, "Right", false},
{"LEFT", KEYCODE_LEFT, 0, "Left", kDirLeftKeyType, false}, {"LEFT", KEYCODE_LEFT, 0, "Left", false},
{"INSERT", KEYCODE_INSERT, 0, "Insert", kActionKeyType, false}, {"INSERT", KEYCODE_INSERT, 0, "Insert", false},
{"HOME", KEYCODE_HOME, 0, "Home", kActionKeyType, false}, {"HOME", KEYCODE_HOME, 0, "Home", false},
{"END", KEYCODE_END, 0, "End", kActionKeyType, false}, {"END", KEYCODE_END, 0, "End", false},
{"PAGEUP", KEYCODE_PAGEUP, 0, "PgUp", kActionKeyType, false}, {"PAGEUP", KEYCODE_PAGEUP, 0, "PgUp", false},
{"PAGEDOWN", KEYCODE_PAGEDOWN, 0, "PgDn", kActionKeyType, false}, {"PAGEDOWN", KEYCODE_PAGEDOWN, 0, "PgDn", false},
// Function keys // Function keys
{"F1", KEYCODE_F1, ASCII_F1, "F1", kActionKeyType, false}, {"F1", KEYCODE_F1, ASCII_F1, "F1", false},
{"F2", KEYCODE_F2, ASCII_F2, "F2", kActionKeyType, false}, {"F2", KEYCODE_F2, ASCII_F2, "F2", false},
{"F3", KEYCODE_F3, ASCII_F3, "F3", kActionKeyType, false}, {"F3", KEYCODE_F3, ASCII_F3, "F3", false},
{"F4", KEYCODE_F4, ASCII_F4, "F4", kActionKeyType, false}, {"F4", KEYCODE_F4, ASCII_F4, "F4", false},
{"F5", KEYCODE_F5, ASCII_F5, "F5", kActionKeyType, false}, {"F5", KEYCODE_F5, ASCII_F5, "F5", false},
{"F6", KEYCODE_F6, ASCII_F6, "F6", kActionKeyType, false}, {"F6", KEYCODE_F6, ASCII_F6, "F6", false},
{"F7", KEYCODE_F7, ASCII_F7, "F7", kActionKeyType, false}, {"F7", KEYCODE_F7, ASCII_F7, "F7", false},
{"F8", KEYCODE_F8, ASCII_F8, "F8", kActionKeyType, false}, {"F8", KEYCODE_F8, ASCII_F8, "F8", false},
{"F9", KEYCODE_F9, ASCII_F9, "F9", kActionKeyType, false}, {"F9", KEYCODE_F9, ASCII_F9, "F9", false},
{"F10", KEYCODE_F10, ASCII_F10, "F10", kActionKeyType, false}, {"F10", KEYCODE_F10, ASCII_F10, "F10", false},
{"F11", KEYCODE_F11, ASCII_F11, "F11", kActionKeyType, false}, {"F11", KEYCODE_F11, ASCII_F11, "F11", false},
{"F12", KEYCODE_F12, ASCII_F12, "F12", kActionKeyType, false}, {"F12", KEYCODE_F12, ASCII_F12, "F12", false},
{"F13", KEYCODE_F13, 0, "F13", kActionKeyType, false}, {"F13", KEYCODE_F13, 0, "F13", false},
{"F14", KEYCODE_F14, 0, "F14", kActionKeyType, false}, {"F14", KEYCODE_F14, 0, "F14", false},
{"F15", KEYCODE_F15, 0, "F15", kActionKeyType, false}, {"F15", KEYCODE_F15, 0, "F15", false},
// Miscellaneous function keys // Miscellaneous function keys
{"HELP", KEYCODE_HELP, 0, "Help", kActionKeyType, false}, {"HELP", KEYCODE_HELP, 0, "Help", false},
{"PRINT", KEYCODE_PRINT, 0, "Print", kActionKeyType, false}, {"PRINT", KEYCODE_PRINT, 0, "Print", false},
{"SYSREQ", KEYCODE_SYSREQ, 0, "SysRq", kActionKeyType, false}, {"SYSREQ", KEYCODE_SYSREQ, 0, "SysRq", false},
{"BREAK", KEYCODE_BREAK, 0, "Break", kActionKeyType, false}, {"BREAK", KEYCODE_BREAK, 0, "Break", false},
{"MENU", KEYCODE_MENU, 0, "Menu", kActionKeyType, false}, {"MENU", KEYCODE_MENU, 0, "Menu", false},
// Power Macintosh power key // Power Macintosh power key
{"POWER", KEYCODE_POWER, 0, "Power", kActionKeyType, false}, {"POWER", KEYCODE_POWER, 0, "Power", false},
// Some european keyboards // Some european keyboards
{"EURO", KEYCODE_EURO, 0, "Euro", kActionKeyType, false}, {"EURO", KEYCODE_EURO, 0, "Euro", false},
// Atari keyboard has Undo // Atari keyboard has Undo
{"UNDO", KEYCODE_UNDO, 0, "Undo", kActionKeyType, false}, {"UNDO", KEYCODE_UNDO, 0, "Undo", false},
{0, KEYCODE_INVALID, 0, 0, kGenericKeyType, false} {0, KEYCODE_INVALID, 0, 0, false}
}; };
static const ModifierTableEntry sdlModifiers[] = { static const ModifierTableEntry sdlModifiers[] = {

2
backends/platform/webos/webos.cpp
View file

@ -58,7 +58,7 @@ HardwareKeySet *OSystem_SDL_WebOS::getHardwareKeySet() {
// Add WebOS specific keys // Add WebOS specific keys
keySet->addHardwareKey(new HardwareKey("FORWARD", keySet->addHardwareKey(new HardwareKey("FORWARD",
KeyState((KeyCode) 229, 229, 0), "Forward", kActionKeyType)); KeyState((KeyCode) 229, 229, 0), "Forward"));
// Return the modified hardware key set // Return the modified hardware key set
return keySet; return keySet;

6
base/main.cpp
View file

@ -274,7 +274,7 @@ static void setupKeymapper(OSystem &system) {
// Now create the global keymap // Now create the global keymap
Keymap *primaryGlobalKeymap = new Keymap(kGlobalKeymapName); Keymap *primaryGlobalKeymap = new Keymap(kGlobalKeymapName);
Action *act; Action *act;
act = new Action(primaryGlobalKeymap, "MENU", _("Menu"), kMenuActionType); act = new Action(primaryGlobalKeymap, "MENU", _("Menu"));
act->addEvent(EVENT_MAINMENU); act->addEvent(EVENT_MAINMENU);
act = new Action(primaryGlobalKeymap, "SKCT", _("Skip")); act = new Action(primaryGlobalKeymap, "SKCT", _("Skip"));
@ -287,11 +287,11 @@ static void setupKeymapper(OSystem &system) {
act->addKeyEvent(KeyState(KEYCODE_PERIOD, '.', 0)); act->addKeyEvent(KeyState(KEYCODE_PERIOD, '.', 0));
#ifdef ENABLE_VKEYBD #ifdef ENABLE_VKEYBD
act = new Action(primaryGlobalKeymap, "VIRT", _("Display keyboard"), kVirtualKeyboardActionType); act = new Action(primaryGlobalKeymap, "VIRT", _("Display keyboard"));
act->addEvent(EVENT_VIRTUAL_KEYBOARD); act->addEvent(EVENT_VIRTUAL_KEYBOARD);
#endif #endif
act = new Action(primaryGlobalKeymap, "REMP", _("Remap keys"), kKeyRemapActionType); act = new Action(primaryGlobalKeymap, "REMP", _("Remap keys"));
act->addEvent(EVENT_KEYMAPPER_REMAP); act->addEvent(EVENT_KEYMAPPER_REMAP);
act = new Action(primaryGlobalKeymap, "FULS", _("Toggle FullScreen")); act = new Action(primaryGlobalKeymap, "FULS", _("Toggle FullScreen"));

8
gui/gui-manager.cpp
View file

@ -112,18 +112,18 @@ void GuiManager::initKeymap() {
Action *act; Action *act;
Keymap *guiMap = new Keymap(kGuiKeymapName); Keymap *guiMap = new Keymap(kGuiKeymapName);
act = new Action(guiMap, "CLOS", _("Close"), kQuitActionType); act = new Action(guiMap, "CLOS", _("Close"));
act->addKeyEvent(KeyState(KEYCODE_ESCAPE, ASCII_ESCAPE, 0)); act->addKeyEvent(KeyState(KEYCODE_ESCAPE, ASCII_ESCAPE, 0));
act = new Action(guiMap, "CLIK", _("Mouse click"), kLeftClickActionType); act = new Action(guiMap, "CLIK", _("Mouse click"));
act->addLeftClickEvent(); act->addLeftClickEvent();
#ifdef ENABLE_VKEYBD #ifdef ENABLE_VKEYBD
act = new Action(guiMap, "VIRT", _("Display keyboard"), kVirtualKeyboardActionType); act = new Action(guiMap, "VIRT", _("Display keyboard"));
act->addEvent(EVENT_VIRTUAL_KEYBOARD); act->addEvent(EVENT_VIRTUAL_KEYBOARD);
#endif #endif
act = new Action(guiMap, "REMP", _("Remap keys"), kKeyRemapActionType); act = new Action(guiMap, "REMP", _("Remap keys"));
act->addEvent(EVENT_KEYMAPPER_REMAP); act->addEvent(EVENT_KEYMAPPER_REMAP);
act = new Action(guiMap, "FULS", _("Toggle FullScreen")); act = new Action(guiMap, "FULS", _("Toggle FullScreen"));