src/hotkeys.cpp

   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
   8 /** @file hotkeys.cpp Implementation of hotkey related functions */
   9
  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
  21 /**
  22  * List of all HotkeyLists.
  23  * This is a pointer to ensure initialisation order with the various static HotkeyList instances.
  24  */
  25 static std::vector<HotkeyList*> *_hotkey_lists = nullptr;
  26
  27 /** String representation of a keycode */
  28 struct KeycodeNames {
  29         const char *name;       ///< Name of the keycode
  30         WindowKeyCodes keycode; ///< The keycode
  31 };
  32
  33 /** Array of non-standard keycodes that can be used in the hotkeys config file. */
  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
  83 /**
  84  * Try to parse a single part of a keycode.
  85  * @param start Start of the string to parse.
  86  * @param end End of the string to parse.
  87  * @return A keycode if a match is found or 0.
  88  */
  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
 107 /**
 108  * Parse a string representation of a keycode.
 109  * @param start Start of the input.
 110  * @param end End of the input.
 111  * @return A valid keycode or 0.
 112  */
 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
 138 /**
 139  * Parse a string to the keycodes it represents
 140  * @param hotkey The hotkey object to add the keycodes to
 141  * @param value The string to parse
 142  */
 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
 155 /**
 156  * Convert a hotkey to it's string representation so it can be written to the
 157  * config file. Separate parts of the keycode (like "CTRL" and "F1" are split
 158  * by a '+'.
 159  * @param keycode The keycode to convert to a string.
 160  * @return A string representation of this keycode.
 161  * @note The return value is a static buffer, stredup the result before calling
 162  *  this function again.
 163  */
 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
 210 /**
 211  * Convert all keycodes attached to a hotkey to a single string. If multiple
 212  * keycodes are attached to the hotkey they are split by a comma.
 213  * @param hotkey The keycodes of this hotkey need to be converted to a string.
 214  * @return A string representation of all keycodes.
 215  * @note The return value is a static buffer, stredup the result before calling
 216  *  this function again.
 217  */
 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
 230 /**
 231  * Create a new Hotkey object with a single default keycode.
 232  * @param default_keycode The default keycode for this hotkey.
 233  * @param name The name of this hotkey.
 234  * @param num Number of this hotkey, should be unique within the hotkey list.
 235  */
 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
 243 /**
 244  * Create a new Hotkey object with multiple default keycodes.
 245  * @param default_keycodes An array of default keycodes terminated with 0.
 246  * @param name The name of this hotkey.
 247  * @param num Number of this hotkey, should be unique within the hotkey list.
 248  */
 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
 260 /**
 261  * Add a keycode to this hotkey, from now that keycode will be matched
 262  * in addition to any previously added keycodes.
 263  * @param keycode The keycode to add.
 264  */
 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
 282 /**
 283  * Load HotkeyList from IniFile.
 284  * @param ini IniFile to load from.
 285  */
 286 void HotkeyList::Load(IniFile *ini)
 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
 298 /**
 299  * Save HotkeyList to IniFile.
 300  * @param ini IniFile to save to.
 301  */
 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
 311 /**
 312  * Check if a keycode is bound to something.
 313  * @param keycode The keycode that was pressed
 314  * @param global_only Limit the search to hotkeys defined as 'global'.
 315  * @return The number of the matching hotkey or -1.
 316  */
 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
 348 /** Load the hotkeys from the config file */
 349 void LoadHotkeysFromConfig()
 350 {
 351         SaveLoadHotkeys(false);
 352 }
 353
 354 /** Save the hotkeys to the config file */
 355 void SaveHotkeysToConfig()
 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