src/hotkeys.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file hotkeys.cpp Implementation of hotkey related functions */
  11
  12 #include "stdafx.h"
  13 #include "openttd.h"
  14 #include "hotkeys.h"
  15 #include "ini_type.h"
  16 #include "string_func.h"
  17 #include "window_gui.h"
  18
  19 #include "safeguards.h"
  20
  21 char *_hotkeys_file;
  22
  23 /**
  24  * List of all HotkeyLists.
  25  * This is a pointer to ensure initialisation order with the various static HotkeyList instances.
  26  */
  27 static SmallVector<HotkeyList*, 16> *_hotkey_lists = NULL;
  28
  29 /** String representation of a keycode */
  30 struct KeycodeNames {
  31         const char *name;       ///< Name of the keycode
  32         WindowKeyCodes keycode; ///< The keycode
  33 };
  34
  35 /** Array of non-standard keycodes that can be used in the hotkeys config file. */
  36 static const KeycodeNames _keycode_to_name[] = {
  37         {"SHIFT", WKC_SHIFT},
  38         {"CTRL", WKC_CTRL},
  39         {"ALT", WKC_ALT},
  40         {"META", WKC_META},
  41         {"GLOBAL", WKC_GLOBAL_HOTKEY},
  42         {"ESC", WKC_ESC},
  43         {"DEL", WKC_DELETE},
  44         {"RETURN", WKC_RETURN},
  45         {"BACKQUOTE", WKC_BACKQUOTE},
  46         {"F1", WKC_F1},
  47         {"F2", WKC_F2},
  48         {"F3", WKC_F3},
  49         {"F4", WKC_F4},
  50         {"F5", WKC_F5},
  51         {"F6", WKC_F6},
  52         {"F7", WKC_F7},
  53         {"F8", WKC_F8},
  54         {"F9", WKC_F9},
  55         {"F10", WKC_F10},
  56         {"F11", WKC_F11},
  57         {"F12", WKC_F12},
  58         {"PAUSE", WKC_PAUSE},
  59         {"COMMA", WKC_COMMA},
  60         {"NUM_PLUS", WKC_NUM_PLUS},
  61         {"NUM_MINUS", WKC_NUM_MINUS},
  62         {"=", WKC_EQUALS},
  63         {"-", WKC_MINUS},
  64         {"PAGE_UP", WKC_PAGEUP},
  65         {"PAGE_DOWN", WKC_PAGEDOWN},
  66 };
  67
  68 /**
  69  * Try to parse a single part of a keycode.
  70  * @param start Start of the string to parse.
  71  * @param end End of the string to parse.
  72  * @return A keycode if a match is found or 0.
  73  */
  74 static uint16 ParseCode(const char *start, const char *end)
  75 {
  76         assert(start <= end);
  77         while (start < end && *start == ' ') start++;
  78         while (end > start && *end == ' ') end--;
  79         for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
  80                 if (strlen(_keycode_to_name[i].name) == (size_t)(end - start) && strncasecmp(start, _keycode_to_name[i].name, end - start) == 0) {
  81                         return _keycode_to_name[i].keycode;
  82                 }
  83         }
  84         if (end - start == 1) {
  85                 if (*start >= 'a' && *start <= 'z') return *start - ('a'-'A');
  86                 /* Ignore invalid keycodes */
  87                 if (*(const uint8 *)start < 128) return *start;
  88         }
  89         return 0;
  90 }
  91
  92 /**
  93  * Parse a string representation of a keycode.
  94  * @param start Start of the input.
  95  * @param end End of the input.
  96  * @return A valid keycode or 0.
  97  */
  98 static uint16 ParseKeycode(const char *start, const char *end)
  99 {
 100         assert(start <= end);
 101         uint16 keycode = 0;
 102         for (;;) {
 103                 const char *cur = start;
 104                 while (*cur != '+' && cur != end) cur++;
 105                 uint16 code = ParseCode(start, cur);
 106                 if (code == 0) return 0;
 107                 if (code & WKC_SPECIAL_KEYS) {
 108                         /* Some completely wrong keycode we don't support. */
 109                         if (code & ~WKC_SPECIAL_KEYS) return 0;
 110                         keycode |= code;
 111                 } else {
 112                         /* Ignore the code if it has more then 1 letter. */
 113                         if (keycode & ~WKC_SPECIAL_KEYS) return 0;
 114                         keycode |= code;
 115                 }
 116                 if (cur == end) break;
 117                 assert(cur < end);
 118                 start = cur + 1;
 119         }
 120         return keycode;
 121 }
 122
 123 /**
 124  * Parse a string to the keycodes it represents
 125  * @param hotkey The hotkey object to add the keycodes to
 126  * @param value The string to parse
 127  */
 128 static void ParseHotkeys(Hotkey *hotkey, const char *value)
 129 {
 130         const char *start = value;
 131         while (*start != '\0') {
 132                 const char *end = start;
 133                 while (*end != '\0' && *end != ',') end++;
 134                 uint16 keycode = ParseKeycode(start, end);
 135                 if (keycode != 0) hotkey->AddKeycode(keycode);
 136                 start = (*end == ',') ? end + 1: end;
 137         }
 138 }
 139
 140 /**
 141  * Convert a hotkey to it's string representation so it can be written to the
 142  * config file. Separate parts of the keycode (like "CTRL" and "F1" are split
 143  * by a '+'.
 144  * @param keycode The keycode to convert to a string.
 145  * @return A string representation of this keycode.
 146  * @note The return value is a static buffer, stredup the result before calling
 147  *  this function again.
 148  */
 149 static const char *KeycodeToString(uint16 keycode)
 150 {
 151         static char buf[32];
 152         buf[0] = '\0';
 153         bool first = true;
 154         if (keycode & WKC_GLOBAL_HOTKEY) {
 155                 strecat(buf, "GLOBAL", lastof(buf));
 156                 first = false;
 157         }
 158         if (keycode & WKC_SHIFT) {
 159                 if (!first) strecat(buf, "+", lastof(buf));
 160                 strecat(buf, "SHIFT", lastof(buf));
 161                 first = false;
 162         }
 163         if (keycode & WKC_CTRL) {
 164                 if (!first) strecat(buf, "+", lastof(buf));
 165                 strecat(buf, "CTRL", lastof(buf));
 166                 first = false;
 167         }
 168         if (keycode & WKC_ALT) {
 169                 if (!first) strecat(buf, "+", lastof(buf));
 170                 strecat(buf, "ALT", lastof(buf));
 171                 first = false;
 172         }
 173         if (keycode & WKC_META) {
 174                 if (!first) strecat(buf, "+", lastof(buf));
 175                 strecat(buf, "META", lastof(buf));
 176                 first = false;
 177         }
 178         if (!first) strecat(buf, "+", lastof(buf));
 179         keycode = keycode & ~WKC_SPECIAL_KEYS;
 180
 181         for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
 182                 if (_keycode_to_name[i].keycode == keycode) {
 183                         strecat(buf, _keycode_to_name[i].name, lastof(buf));
 184                         return buf;
 185                 }
 186         }
 187         assert(keycode < 128);
 188         char key[2];
 189         key[0] = keycode;
 190         key[1] = '\0';
 191         strecat(buf, key, lastof(buf));
 192         return buf;
 193 }
 194
 195 /**
 196  * Convert all keycodes attached to a hotkey to a single string. If multiple
 197  * keycodes are attached to the hotkey they are split by a comma.
 198  * @param hotkey The keycodes of this hotkey need to be converted to a string.
 199  * @return A string representation of all keycodes.
 200  * @note The return value is a static buffer, stredup the result before calling
 201  *  this function again.
 202  */
 203 const char *SaveKeycodes(const Hotkey *hotkey)
 204 {
 205         static char buf[128];
 206         buf[0] = '\0';
 207         for (uint i = 0; i < hotkey->keycodes.Length(); i++) {
 208                 const char *str = KeycodeToString(hotkey->keycodes[i]);
 209                 if (i > 0) strecat(buf, ",", lastof(buf));
 210                 strecat(buf, str, lastof(buf));
 211         }
 212         return buf;
 213 }
 214
 215 /**
 216  * Create a new Hotkey object with a single default keycode.
 217  * @param default_keycode The default keycode for this hotkey.
 218  * @param name The name of this hotkey.
 219  * @param num Number of this hotkey, should be unique within the hotkey list.
 220  */
 221 Hotkey::Hotkey(uint16 default_keycode, const char *name, int num) :
 222         name(name),
 223         num(num)
 224 {
 225         if (default_keycode != 0) this->AddKeycode(default_keycode);
 226 }
 227
 228 /**
 229  * Create a new Hotkey object with multiple default keycodes.
 230  * @param default_keycodes An array of default keycodes terminated with 0.
 231  * @param name The name of this hotkey.
 232  * @param num Number of this hotkey, should be unique within the hotkey list.
 233  */
 234 Hotkey::Hotkey(const uint16 *default_keycodes, const char *name, int num) :
 235         name(name),
 236         num(num)
 237 {
 238         const uint16 *keycode = default_keycodes;
 239         while (*keycode != 0) {
 240                 this->AddKeycode(*keycode);
 241                 keycode++;
 242         }
 243 }
 244
 245 /**
 246  * Add a keycode to this hotkey, from now that keycode will be matched
 247  * in addition to any previously added keycodes.
 248  * @param keycode The keycode to add.
 249  */
 250 void Hotkey::AddKeycode(uint16 keycode)
 251 {
 252         this->keycodes.Include(keycode);
 253 }
 254
 255 HotkeyList::HotkeyList(const char *ini_group, Hotkey *items, GlobalHotkeyHandlerFunc global_hotkey_handler) :
 256         global_hotkey_handler(global_hotkey_handler), ini_group(ini_group), items(items)
 257 {
 258         if (_hotkey_lists == NULL) _hotkey_lists = new SmallVector<HotkeyList*, 16>();
 259         *_hotkey_lists->Append() = this;
 260 }
 261
 262 HotkeyList::~HotkeyList()
 263 {
 264         _hotkey_lists->Erase(_hotkey_lists->Find(this));
 265 }
 266
 267 /**
 268  * Load HotkeyList from IniFile.
 269  * @param ini IniFile to load from.
 270  */
 271 void HotkeyList::Load(IniFile *ini)
 272 {
 273         IniGroup *group = ini->GetGroup(this->ini_group);
 274         for (Hotkey *hotkey = this->items; hotkey->name != NULL; ++hotkey) {
 275                 IniItem *item = group->GetItem(hotkey->name, false);
 276                 if (item != NULL) {
 277                         hotkey->keycodes.Clear();
 278                         if (item->value != NULL) ParseHotkeys(hotkey, item->value);
 279                 }
 280         }
 281 }
 282
 283 /**
 284  * Save HotkeyList to IniFile.
 285  * @param ini IniFile to save to.
 286  */
 287 void HotkeyList::Save(IniFile *ini) const
 288 {
 289         IniGroup *group = ini->GetGroup(this->ini_group);
 290         for (const Hotkey *hotkey = this->items; hotkey->name != NULL; ++hotkey) {
 291                 IniItem *item = group->GetItem(hotkey->name, true);
 292                 item->SetValue(SaveKeycodes(hotkey));
 293         }
 294 }
 295
 296 /**
 297  * Check if a keycode is bound to something.
 298  * @param keycode The keycode that was pressed
 299  * @param global_only Limit the search to hotkeys defined as 'global'.
 300  * @return The number of the matching hotkey or -1.
 301  */
 302 int HotkeyList::CheckMatch(uint16 keycode, bool global_only) const
 303 {
 304         for (const Hotkey *list = this->items; list->name != NULL; ++list) {
 305                 if (list->keycodes.Contains(keycode | WKC_GLOBAL_HOTKEY) || (!global_only && list->keycodes.Contains(keycode))) {
 306                         return list->num;
 307                 }
 308         }
 309         return -1;
 310 }
 311
 312
 313 static void SaveLoadHotkeys(bool save)
 314 {
 315         IniFile *ini = new IniFile();
 316         ini->LoadFromDisk(_hotkeys_file, NO_DIRECTORY);
 317
 318         for (HotkeyList **list = _hotkey_lists->Begin(); list != _hotkey_lists->End(); ++list) {
 319                 if (save) {
 320                         (*list)->Save(ini);
 321                 } else {
 322                         (*list)->Load(ini);
 323                 }
 324         }
 325
 326         if (save) ini->SaveToDisk(_hotkeys_file);
 327         delete ini;
 328 }
 329
 330
 331 /** Load the hotkeys from the config file */
 332 void LoadHotkeysFromConfig()
 333 {
 334         SaveLoadHotkeys(false);
 335 }
 336
 337 /** Save the hotkeys to the config file */
 338 void SaveHotkeysToConfig()
 339 {
 340         SaveLoadHotkeys(true);
 341 }
 342
 343 void HandleGlobalHotkeys(WChar key, uint16 keycode)
 344 {
 345         for (HotkeyList **list = _hotkey_lists->Begin(); list != _hotkey_lists->End(); ++list) {
 346                 if ((*list)->global_hotkey_handler == NULL) continue;
 347
 348                 int hotkey = (*list)->CheckMatch(keycode, true);
 349                 if (hotkey >= 0 && ((*list)->global_hotkey_handler(hotkey) == ES_HANDLED)) return;
 350         }
 351 }
 352