OpenTTD Source  1.10.0-RC1
hotkeys.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD 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, version 2.
4  * OpenTTD 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.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "stdafx.h"
11 #include "openttd.h"
12 #include "hotkeys.h"
13 #include "ini_type.h"
14 #include "string_func.h"
15 #include "window_gui.h"
16 
17 #include "safeguards.h"
18 
19 char *_hotkeys_file;
20 
25 static std::vector<HotkeyList*> *_hotkey_lists = nullptr;
26 
28 struct KeycodeNames {
29  const char *name;
31 };
32 
34 static const KeycodeNames _keycode_to_name[] = {
35  {"SHIFT", WKC_SHIFT},
36  {"CTRL", WKC_CTRL},
37  {"ALT", WKC_ALT},
38  {"META", WKC_META},
39  {"GLOBAL", WKC_GLOBAL_HOTKEY},
40  {"ESC", WKC_ESC},
41  {"BACKSPACE", WKC_BACKSPACE},
42  {"INS", WKC_INSERT},
43  {"DEL", WKC_DELETE},
44  {"PAGEUP", WKC_PAGEUP},
45  {"PAGEDOWN", WKC_PAGEDOWN},
46  {"END", WKC_END},
47  {"HOME", WKC_HOME},
48  {"RETURN", WKC_RETURN},
49  {"SPACE", WKC_SPACE},
50  {"F1", WKC_F1},
51  {"F2", WKC_F2},
52  {"F3", WKC_F3},
53  {"F4", WKC_F4},
54  {"F5", WKC_F5},
55  {"F6", WKC_F6},
56  {"F7", WKC_F7},
57  {"F8", WKC_F8},
58  {"F9", WKC_F9},
59  {"F10", WKC_F10},
60  {"F11", WKC_F11},
61  {"F12", WKC_F12},
62  {"BACKQUOTE", WKC_BACKQUOTE},
63  {"PAUSE", WKC_PAUSE},
64  {"NUM_DIV", WKC_NUM_DIV},
65  {"NUM_MUL", WKC_NUM_MUL},
66  {"NUM_MINUS", WKC_NUM_MINUS},
67  {"NUM_PLUS", WKC_NUM_PLUS},
68  {"NUM_ENTER", WKC_NUM_ENTER},
69  {"NUM_DOT", WKC_NUM_DECIMAL},
70  {"/", WKC_SLASH},
71  {";", WKC_SEMICOLON},
72  {"=", WKC_EQUALS},
73  {"[", WKC_L_BRACKET},
74  {"\\", WKC_BACKSLASH},
75  {"]", WKC_R_BRACKET},
76  {"'", WKC_SINGLEQUOTE},
77  {",", WKC_COMMA},
78  {"COMMA", WKC_COMMA}, // legacy variant, should be below ","
79  {".", WKC_PERIOD},
80  {"-", WKC_MINUS},
81 };
82 
89 static uint16 ParseCode(const char *start, const char *end)
90 {
91  assert(start <= end);
92  while (start < end && *start == ' ') start++;
93  while (end > start && *end == ' ') end--;
94  for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
95  if (strlen(_keycode_to_name[i].name) == (size_t)(end - start) && strncasecmp(start, _keycode_to_name[i].name, end - start) == 0) {
96  return _keycode_to_name[i].keycode;
97  }
98  }
99  if (end - start == 1) {
100  if (*start >= 'a' && *start <= 'z') return *start - ('a'-'A');
101  /* Ignore invalid keycodes */
102  if (*(const uint8 *)start < 128) return *start;
103  }
104  return 0;
105 }
106 
113 static uint16 ParseKeycode(const char *start, const char *end)
114 {
115  assert(start <= end);
116  uint16 keycode = 0;
117  for (;;) {
118  const char *cur = start;
119  while (*cur != '+' && cur != end) cur++;
120  uint16 code = ParseCode(start, cur);
121  if (code == 0) return 0;
122  if (code & WKC_SPECIAL_KEYS) {
123  /* Some completely wrong keycode we don't support. */
124  if (code & ~WKC_SPECIAL_KEYS) return 0;
125  keycode |= code;
126  } else {
127  /* Ignore the code if it has more then 1 letter. */
128  if (keycode & ~WKC_SPECIAL_KEYS) return 0;
129  keycode |= code;
130  }
131  if (cur == end) break;
132  assert(cur < end);
133  start = cur + 1;
134  }
135  return keycode;
136 }
137 
143 static void ParseHotkeys(Hotkey *hotkey, const char *value)
144 {
145  const char *start = value;
146  while (*start != '\0') {
147  const char *end = start;
148  while (*end != '\0' && *end != ',') end++;
149  uint16 keycode = ParseKeycode(start, end);
150  if (keycode != 0) hotkey->AddKeycode(keycode);
151  start = (*end == ',') ? end + 1: end;
152  }
153 }
154 
164 static const char *KeycodeToString(uint16 keycode)
165 {
166  static char buf[32];
167  buf[0] = '\0';
168  bool first = true;
169  if (keycode & WKC_GLOBAL_HOTKEY) {
170  strecat(buf, "GLOBAL", lastof(buf));
171  first = false;
172  }
173  if (keycode & WKC_SHIFT) {
174  if (!first) strecat(buf, "+", lastof(buf));
175  strecat(buf, "SHIFT", lastof(buf));
176  first = false;
177  }
178  if (keycode & WKC_CTRL) {
179  if (!first) strecat(buf, "+", lastof(buf));
180  strecat(buf, "CTRL", lastof(buf));
181  first = false;
182  }
183  if (keycode & WKC_ALT) {
184  if (!first) strecat(buf, "+", lastof(buf));
185  strecat(buf, "ALT", lastof(buf));
186  first = false;
187  }
188  if (keycode & WKC_META) {
189  if (!first) strecat(buf, "+", lastof(buf));
190  strecat(buf, "META", lastof(buf));
191  first = false;
192  }
193  if (!first) strecat(buf, "+", lastof(buf));
194  keycode = keycode & ~WKC_SPECIAL_KEYS;
195 
196  for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
197  if (_keycode_to_name[i].keycode == keycode) {
198  strecat(buf, _keycode_to_name[i].name, lastof(buf));
199  return buf;
200  }
201  }
202  assert(keycode < 128);
203  char key[2];
204  key[0] = keycode;
205  key[1] = '\0';
206  strecat(buf, key, lastof(buf));
207  return buf;
208 }
209 
218 const char *SaveKeycodes(const Hotkey *hotkey)
219 {
220  static char buf[128];
221  buf[0] = '\0';
222  for (uint i = 0; i < hotkey->keycodes.size(); i++) {
223  const char *str = KeycodeToString(hotkey->keycodes[i]);
224  if (i > 0) strecat(buf, ",", lastof(buf));
225  strecat(buf, str, lastof(buf));
226  }
227  return buf;
228 }
229 
236 Hotkey::Hotkey(uint16 default_keycode, const char *name, int num) :
237  name(name),
238  num(num)
239 {
240  if (default_keycode != 0) this->AddKeycode(default_keycode);
241 }
242 
249 Hotkey::Hotkey(const uint16 *default_keycodes, const char *name, int num) :
250  name(name),
251  num(num)
252 {
253  const uint16 *keycode = default_keycodes;
254  while (*keycode != 0) {
255  this->AddKeycode(*keycode);
256  keycode++;
257  }
258 }
259 
265 void Hotkey::AddKeycode(uint16 keycode)
266 {
267  include(this->keycodes, keycode);
268 }
269 
270 HotkeyList::HotkeyList(const char *ini_group, Hotkey *items, GlobalHotkeyHandlerFunc global_hotkey_handler) :
271  global_hotkey_handler(global_hotkey_handler), ini_group(ini_group), items(items)
272 {
273  if (_hotkey_lists == nullptr) _hotkey_lists = new std::vector<HotkeyList*>();
274  _hotkey_lists->push_back(this);
275 }
276 
277 HotkeyList::~HotkeyList()
278 {
279  _hotkey_lists->erase(std::find(_hotkey_lists->begin(), _hotkey_lists->end(), this));
280 }
281 
287 {
288  IniGroup *group = ini->GetGroup(this->ini_group);
289  for (Hotkey *hotkey = this->items; hotkey->name != nullptr; ++hotkey) {
290  IniItem *item = group->GetItem(hotkey->name, false);
291  if (item != nullptr) {
292  hotkey->keycodes.clear();
293  if (item->value != nullptr) ParseHotkeys(hotkey, item->value);
294  }
295  }
296 }
297 
302 void HotkeyList::Save(IniFile *ini) const
303 {
304  IniGroup *group = ini->GetGroup(this->ini_group);
305  for (const Hotkey *hotkey = this->items; hotkey->name != nullptr; ++hotkey) {
306  IniItem *item = group->GetItem(hotkey->name, true);
307  item->SetValue(SaveKeycodes(hotkey));
308  }
309 }
310 
317 int HotkeyList::CheckMatch(uint16 keycode, bool global_only) const
318 {
319  for (const Hotkey *list = this->items; list->name != nullptr; ++list) {
320  auto begin = list->keycodes.begin();
321  auto end = list->keycodes.end();
322  if (std::find(begin, end, keycode | WKC_GLOBAL_HOTKEY) != end || (!global_only && std::find(begin, end, keycode) != end)) {
323  return list->num;
324  }
325  }
326  return -1;
327 }
328 
329 
330 static void SaveLoadHotkeys(bool save)
331 {
332  IniFile *ini = new IniFile();
333  ini->LoadFromDisk(_hotkeys_file, NO_DIRECTORY);
334 
335  for (HotkeyList *list : *_hotkey_lists) {
336  if (save) {
337  list->Save(ini);
338  } else {
339  list->Load(ini);
340  }
341  }
342 
343  if (save) ini->SaveToDisk(_hotkeys_file);
344  delete ini;
345 }
346 
347 
350 {
351  SaveLoadHotkeys(false);
352 }
353 
356 {
357  SaveLoadHotkeys(true);
358 }
359 
360 void HandleGlobalHotkeys(WChar key, uint16 keycode)
361 {
362  for (HotkeyList *list : *_hotkey_lists) {
363  if (list->global_hotkey_handler == nullptr) continue;
364 
365  int hotkey = list->CheckMatch(keycode, true);
366  if (hotkey >= 0 && (list->global_hotkey_handler(hotkey) == ES_HANDLED)) return;
367  }
368 }
369 
const char * name
Name of the keycode.
Definition: hotkeys.cpp:29
A group within an ini file.
Definition: ini_type.h:36
static char * strecat(char *dst, const char *src, const char *last)
Appends characters from one string to another.
Definition: depend.cpp:97
WindowKeyCodes
Definition: gfx_type.h:27
All data for a single hotkey.
Definition: hotkeys.h:22
Hotkey(uint16 default_keycode, const char *name, int num)
Create a new Hotkey object with a single default keycode.
Definition: hotkeys.cpp:236
, Comma
Definition: gfx_type.h:102
Hotkey related functions.
= Equals
Definition: gfx_type.h:97
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
IniGroup * GetGroup(const char *name, size_t len=0, bool create_new=true)
Get the group with the given name.
Definition: ini_load.cpp:154
Functions, definitions and such used only by the GUI.
A single "line" in an ini file.
Definition: ini_type.h:23
static void ParseHotkeys(Hotkey *hotkey, const char *value)
Parse a string to the keycodes it represents.
Definition: hotkeys.cpp:143
&#39; Single quote
Definition: gfx_type.h:101
Functions related to low-level strings.
void Load(IniFile *ini)
Load HotkeyList from IniFile.
Definition: hotkeys.cpp:286
WindowKeyCodes keycode
The keycode.
Definition: hotkeys.cpp:30
static uint16 ParseKeycode(const char *start, const char *end)
Parse a string representation of a keycode.
Definition: hotkeys.cpp:113
void Save(IniFile *ini) const
Save HotkeyList to IniFile.
Definition: hotkeys.cpp:302
bool SaveToDisk(const char *filename)
Save the Ini file&#39;s data to the disk.
Definition: ini.cpp:41
[ Left square bracket
Definition: gfx_type.h:98
] Right square bracket
Definition: gfx_type.h:100
void SetValue(const char *value)
Replace the current value with another value.
Definition: ini_load.cpp:47
void LoadFromDisk(const char *filename, Subdirectory subdir)
Load the Ini file&#39;s data from the disk.
Definition: ini_load.cpp:210
A path without any base directory.
Definition: fileio_type.h:125
Definition of base types and functions in a cross-platform compatible way.
\ Backslash
Definition: gfx_type.h:99
A number of safeguards to prevent using unsafe methods.
List of hotkeys for a window.
Definition: hotkeys.h:40
/ Forward slash
Definition: gfx_type.h:95
char * value
The value of this item.
Definition: ini_type.h:26
Some generic types.
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
void AddKeycode(uint16 keycode)
Add a keycode to this hotkey, from now that keycode will be matched in addition to any previously add...
Definition: hotkeys.cpp:265
Types related to reading/writing &#39;*.ini&#39; files.
; Semicolon
Definition: gfx_type.h:96
void LoadHotkeysFromConfig()
Load the hotkeys from the config file.
Definition: hotkeys.cpp:349
Ini file that supports both loading and saving.
Definition: ini_type.h:86
bool include(std::vector< T > &vec, const T &item)
Helper function to append an item to a vector if it is not already contained Consider using std::set...
IniItem * GetItem(const char *name, bool create)
Get the item with the given name, and if it doesn&#39;t exist and create is true it creates a new item...
Definition: ini_load.cpp:103
static uint16 ParseCode(const char *start, const char *end)
Try to parse a single part of a keycode.
Definition: hotkeys.cpp:89
static const KeycodeNames _keycode_to_name[]
Array of non-standard keycodes that can be used in the hotkeys config file.
Definition: hotkeys.cpp:34
void SaveHotkeysToConfig()
Save the hotkeys to the config file.
Definition: hotkeys.cpp:355
int CheckMatch(uint16 keycode, bool global_only=false) const
Check if a keycode is bound to something.
Definition: hotkeys.cpp:317
. Period
Definition: gfx_type.h:103
static const char * KeycodeToString(uint16 keycode)
Convert a hotkey to it&#39;s string representation so it can be written to the config file...
Definition: hotkeys.cpp:164
The passed event is handled.
Definition: window_type.h:718
String representation of a keycode.
Definition: hotkeys.cpp:28
uint32 WChar
Type for wide characters, i.e.
Definition: string_type.h:35
const char * SaveKeycodes(const Hotkey *hotkey)
Convert all keycodes attached to a hotkey to a single string.
Definition: hotkeys.cpp:218
Fake keycode bit to indicate global hotkeys.
Definition: gfx_type.h:33
static std::vector< HotkeyList * > * _hotkey_lists
List of all HotkeyLists.
Definition: hotkeys.cpp:25