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 std::string _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 std::string_view 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 std::initializer_list<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         {"SLASH", WKC_SLASH},
  71         {"/", WKC_SLASH}, /* deprecated, use SLASH */
  72         {"SEMICOLON", WKC_SEMICOLON},
  73         {";", WKC_SEMICOLON}, /* deprecated, use SEMICOLON */
  74         {"EQUALS", WKC_EQUALS},
  75         {"=", WKC_EQUALS}, /* deprecated, use EQUALS */
  76         {"L_BRACKET", WKC_L_BRACKET},
  77         {"[", WKC_L_BRACKET}, /* deprecated, use L_BRACKET */
  78         {"BACKSLASH", WKC_BACKSLASH},
  79         {"\\", WKC_BACKSLASH}, /* deprecated, use BACKSLASH */
  80         {"R_BRACKET", WKC_R_BRACKET},
  81         {"]", WKC_R_BRACKET}, /* deprecated, use R_BRACKET */
  82         {"SINGLEQUOTE", WKC_SINGLEQUOTE},
  83         {"'", WKC_SINGLEQUOTE}, /* deprecated, use SINGLEQUOTE */
  84         {"COMMA", WKC_COMMA},
  85         {"PERIOD", WKC_PERIOD},
  86         {".", WKC_PERIOD}, /* deprecated, use PERIOD */
  87         {"MINUS", WKC_MINUS},
  88         {"-", WKC_MINUS}, /* deprecated, use MINUS */
  89 };
  90
  91 /**
  92  * Try to parse a single part of a keycode.
  93  * @param start Start of the string to parse.
  94  * @param end End of the string to parse.
  95  * @return A keycode if a match is found or 0.
  96  */
  97 static uint16_t ParseCode(const char *start, const char *end)
  98 {
  99         assert(start <= end);
 100         while (start < end && *start == ' ') start++;
 101         while (end > start && *end == ' ') end--;
 102         std::string_view str{start, end};
 103         for (const auto &kn : _keycode_to_name) {
 104                 if (StrEqualsIgnoreCase(str, kn.name)) {
 105                         return kn.keycode;
 106                 }
 107         }
 108         if (end - start == 1) {
 109                 if (*start >= 'a' && *start <= 'z') return *start - ('a'-'A');
 110                 /* Ignore invalid keycodes */
 111                 if (*(const uint8_t *)start < 128) return *start;
 112         }
 113         return 0;
 114 }
 115
 116 /**
 117  * Parse a string representation of a keycode.
 118  * @param start Start of the input.
 119  * @param end End of the input.
 120  * @return A valid keycode or 0.
 121  */
 122 static uint16_t ParseKeycode(const char *start, const char *end)
 123 {
 124         assert(start <= end);
 125         uint16_t keycode = 0;
 126         for (;;) {
 127                 const char *cur = start;
 128                 while (*cur != '+' && cur != end) cur++;
 129                 uint16_t code = ParseCode(start, cur);
 130                 if (code == 0) return 0;
 131                 if (code & WKC_SPECIAL_KEYS) {
 132                         /* Some completely wrong keycode we don't support. */
 133                         if (code & ~WKC_SPECIAL_KEYS) return 0;
 134                         keycode |= code;
 135                 } else {
 136                         /* Ignore the code if it has more then 1 letter. */
 137                         if (keycode & ~WKC_SPECIAL_KEYS) return 0;
 138                         keycode |= code;
 139                 }
 140                 if (cur == end) break;
 141                 assert(cur < end);
 142                 start = cur + 1;
 143         }
 144         return keycode;
 145 }
 146
 147 /**
 148  * Parse a string to the keycodes it represents
 149  * @param hotkey The hotkey object to add the keycodes to
 150  * @param value The string to parse
 151  */
 152 static void ParseHotkeys(Hotkey &hotkey, const char *value)
 153 {
 154         const char *start = value;
 155         while (*start != '\0') {
 156                 const char *end = start;
 157                 while (*end != '\0' && *end != ',') end++;
 158                 uint16_t keycode = ParseKeycode(start, end);
 159                 if (keycode != 0) hotkey.AddKeycode(keycode);
 160                 start = (*end == ',') ? end + 1: end;
 161         }
 162 }
 163
 164 /**
 165  * Convert a hotkey to it's string representation so it can be written to the
 166  * config file. Separate parts of the keycode (like "CTRL" and "F1" are split
 167  * by a '+'.
 168  * @param keycode The keycode to convert to a string.
 169  * @return A string representation of this keycode.
 170  */
 171 static std::string KeycodeToString(uint16_t keycode)
 172 {
 173         std::string str;
 174         if (keycode & WKC_GLOBAL_HOTKEY) {
 175                 str += "GLOBAL";
 176         }
 177         if (keycode & WKC_SHIFT) {
 178                 if (!str.empty()) str += "+";
 179                 str += "SHIFT";
 180         }
 181         if (keycode & WKC_CTRL) {
 182                 if (!str.empty()) str += "+";
 183                 str += "CTRL";
 184         }
 185         if (keycode & WKC_ALT) {
 186                 if (!str.empty()) str += "+";
 187                 str += "ALT";
 188         }
 189         if (keycode & WKC_META) {
 190                 if (!str.empty()) str += "+";
 191                 str += "META";
 192         }
 193         if (!str.empty()) str += "+";
 194         keycode = keycode & ~WKC_SPECIAL_KEYS;
 195
 196         for (const auto &kn : _keycode_to_name) {
 197                 if (kn.keycode == keycode) {
 198                         str += kn.name;
 199                         return str;
 200                 }
 201         }
 202         assert(keycode < 128);
 203         str.push_back(keycode);
 204         return str;
 205 }
 206
 207 /**
 208  * Convert all keycodes attached to a hotkey to a single string. If multiple
 209  * keycodes are attached to the hotkey they are split by a comma.
 210  * @param hotkey The keycodes of this hotkey need to be converted to a string.
 211  * @return A string representation of all keycodes.
 212  */
 213 std::string SaveKeycodes(const Hotkey &hotkey)
 214 {
 215         std::string str;
 216         for (auto keycode : hotkey.keycodes) {
 217                 if (!str.empty()) str += ",";
 218                 str += KeycodeToString(keycode);
 219         }
 220         return str;
 221 }
 222
 223 /**
 224  * Create a new Hotkey object with a single default keycode.
 225  * @param default_keycode The default keycode for this hotkey.
 226  * @param name The name of this hotkey.
 227  * @param num Number of this hotkey, should be unique within the hotkey list.
 228  */
 229 Hotkey::Hotkey(uint16_t default_keycode, const std::string &name, int num) :
 230         name(name),
 231         num(num)
 232 {
 233         if (default_keycode != 0) this->AddKeycode(default_keycode);
 234 }
 235
 236 /**
 237  * Create a new Hotkey object with multiple default keycodes.
 238  * @param default_keycodes An array of default keycodes terminated with 0.
 239  * @param name The name of this hotkey.
 240  * @param num Number of this hotkey, should be unique within the hotkey list.
 241  */
 242 Hotkey::Hotkey(const std::vector<uint16_t> &default_keycodes, const std::string &name, int num) :
 243         name(name),
 244         num(num)
 245 {
 246         for (uint16_t keycode : default_keycodes) {
 247                 this->AddKeycode(keycode);
 248         }
 249 }
 250
 251 /**
 252  * Add a keycode to this hotkey, from now that keycode will be matched
 253  * in addition to any previously added keycodes.
 254  * @param keycode The keycode to add.
 255  */
 256 void Hotkey::AddKeycode(uint16_t keycode)
 257 {
 258         this->keycodes.insert(keycode);
 259 }
 260
 261 HotkeyList::HotkeyList(const std::string &ini_group, const std::vector<Hotkey> &items, GlobalHotkeyHandlerFunc global_hotkey_handler) :
 262         global_hotkey_handler(global_hotkey_handler), ini_group(ini_group), items(items)
 263 {
 264         if (_hotkey_lists == nullptr) _hotkey_lists = new std::vector<HotkeyList*>();
 265         _hotkey_lists->push_back(this);
 266 }
 267
 268 HotkeyList::~HotkeyList()
 269 {
 270         _hotkey_lists->erase(std::ranges::find(*_hotkey_lists, this));
 271 }
 272
 273 /**
 274  * Load HotkeyList from IniFile.
 275  * @param ini IniFile to load from.
 276  */
 277 void HotkeyList::Load(const IniFile &ini)
 278 {
 279         const IniGroup *group = ini.GetGroup(this->ini_group);
 280         if (group == nullptr) return;
 281         for (Hotkey &hotkey : this->items) {
 282                 const IniItem *item = group->GetItem(hotkey.name);
 283                 if (item != nullptr) {
 284                         hotkey.keycodes.clear();
 285                         if (item->value.has_value()) ParseHotkeys(hotkey, item->value->c_str());
 286                 }
 287         }
 288 }
 289
 290 /**
 291  * Save HotkeyList to IniFile.
 292  * @param ini IniFile to save to.
 293  */
 294 void HotkeyList::Save(IniFile &ini) const
 295 {
 296         IniGroup &group = ini.GetOrCreateGroup(this->ini_group);
 297         for (const Hotkey &hotkey : this->items) {
 298                 IniItem &item = group.GetOrCreateItem(hotkey.name);
 299                 item.SetValue(SaveKeycodes(hotkey));
 300         }
 301 }
 302
 303 /**
 304  * Check if a keycode is bound to something.
 305  * @param keycode The keycode that was pressed
 306  * @param global_only Limit the search to hotkeys defined as 'global'.
 307  * @return The number of the matching hotkey or -1.
 308  */
 309 int HotkeyList::CheckMatch(uint16_t keycode, bool global_only) const
 310 {
 311         for (const Hotkey &hotkey : this->items) {
 312                 auto begin = hotkey.keycodes.begin();
 313                 auto end = hotkey.keycodes.end();
 314                 if (std::find(begin, end, keycode | WKC_GLOBAL_HOTKEY) != end || (!global_only && std::find(begin, end, keycode) != end)) {
 315                         return hotkey.num;
 316                 }
 317         }
 318         return -1;
 319 }
 320
 321
 322 static void SaveLoadHotkeys(bool save)
 323 {
 324         IniFile ini{};
 325         ini.LoadFromDisk(_hotkeys_file, NO_DIRECTORY);
 326
 327         for (HotkeyList *list : *_hotkey_lists) {
 328                 if (save) {
 329                         list->Save(ini);
 330                 } else {
 331                         list->Load(ini);
 332                 }
 333         }
 334
 335         if (save) ini.SaveToDisk(_hotkeys_file);
 336 }
 337
 338
 339 /** Load the hotkeys from the config file */
 340 void LoadHotkeysFromConfig()
 341 {
 342         SaveLoadHotkeys(false);
 343 }
 344
 345 /** Save the hotkeys to the config file */
 346 void SaveHotkeysToConfig()
 347 {
 348         SaveLoadHotkeys(true);
 349 }
 350
 351 void HandleGlobalHotkeys([[maybe_unused]] char32_t key, uint16_t keycode)
 352 {
 353         for (HotkeyList *list : *_hotkey_lists) {
 354                 if (list->global_hotkey_handler == nullptr) continue;
 355
 356                 int hotkey = list->CheckMatch(keycode, true);
 357                 if (hotkey >= 0 && (list->global_hotkey_handler(hotkey) == ES_HANDLED)) return;
 358         }
 359 }
 360