Fix #10490: Allow ships to exit depots if another is not moving at the exit point...
[openttd-github.git] / src / hotkeys.cpp
blob2260e456ea42b388a204880e93a9c1e102487659
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 */
8 /** @file hotkeys.cpp Implementation of hotkey related functions */
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"
17 #include "safeguards.h"
19 std::string _hotkeys_file;
21 /**
22 * List of all HotkeyLists.
23 * This is a pointer to ensure initialisation order with the various static HotkeyList instances.
25 static std::vector<HotkeyList*> *_hotkey_lists = nullptr;
27 /** String representation of a keycode */
28 struct KeycodeNames {
29 const char *name; ///< Name of the keycode
30 WindowKeyCodes keycode; ///< The keycode
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 {"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 */
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.
97 static uint16_t ParseCode(const char *start, const char *end)
99 assert(start <= end);
100 while (start < end && *start == ' ') start++;
101 while (end > start && *end == ' ') end--;
102 std::string_view str{start, (size_t)(end - start)};
103 for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
104 if (StrEqualsIgnoreCase(str, _keycode_to_name[i].name)) {
105 return _keycode_to_name[i].keycode;
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;
113 return 0;
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.
122 static uint16_t ParseKeycode(const char *start, const char *end)
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;
140 if (cur == end) break;
141 assert(cur < end);
142 start = cur + 1;
144 return keycode;
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
152 static void ParseHotkeys(Hotkey &hotkey, const char *value)
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;
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.
171 static std::string KeycodeToString(uint16_t keycode)
173 std::string str;
174 if (keycode & WKC_GLOBAL_HOTKEY) {
175 str += "GLOBAL";
177 if (keycode & WKC_SHIFT) {
178 if (!str.empty()) str += "+";
179 str += "SHIFT";
181 if (keycode & WKC_CTRL) {
182 if (!str.empty()) str += "+";
183 str += "CTRL";
185 if (keycode & WKC_ALT) {
186 if (!str.empty()) str += "+";
187 str += "ALT";
189 if (keycode & WKC_META) {
190 if (!str.empty()) str += "+";
191 str += "META";
193 if (!str.empty()) str += "+";
194 keycode = keycode & ~WKC_SPECIAL_KEYS;
196 for (uint i = 0; i < lengthof(_keycode_to_name); i++) {
197 if (_keycode_to_name[i].keycode == keycode) {
198 str += _keycode_to_name[i].name;
199 return str;
202 assert(keycode < 128);
203 str.push_back(keycode);
204 return str;
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.
213 std::string SaveKeycodes(const Hotkey &hotkey)
215 std::string str;
216 for (auto keycode : hotkey.keycodes) {
217 if (!str.empty()) str += ",";
218 str += KeycodeToString(keycode);
220 return str;
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.
229 Hotkey::Hotkey(uint16_t default_keycode, const std::string &name, int num) :
230 name(name),
231 num(num)
233 if (default_keycode != 0) this->AddKeycode(default_keycode);
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.
242 Hotkey::Hotkey(const std::vector<uint16_t> &default_keycodes, const std::string &name, int num) :
243 name(name),
244 num(num)
246 for (uint16_t keycode : default_keycodes) {
247 this->AddKeycode(keycode);
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.
256 void Hotkey::AddKeycode(uint16_t keycode)
258 this->keycodes.insert(keycode);
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)
264 if (_hotkey_lists == nullptr) _hotkey_lists = new std::vector<HotkeyList*>();
265 _hotkey_lists->push_back(this);
268 HotkeyList::~HotkeyList()
270 _hotkey_lists->erase(std::find(_hotkey_lists->begin(), _hotkey_lists->end(), this));
274 * Load HotkeyList from IniFile.
275 * @param ini IniFile to load from.
277 void HotkeyList::Load(const IniFile &ini)
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());
291 * Save HotkeyList to IniFile.
292 * @param ini IniFile to save to.
294 void HotkeyList::Save(IniFile &ini) const
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));
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.
309 int HotkeyList::CheckMatch(uint16_t keycode, bool global_only) const
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;
318 return -1;
322 static void SaveLoadHotkeys(bool save)
324 IniFile ini{};
325 ini.LoadFromDisk(_hotkeys_file, NO_DIRECTORY);
327 for (HotkeyList *list : *_hotkey_lists) {
328 if (save) {
329 list->Save(ini);
330 } else {
331 list->Load(ini);
335 if (save) ini.SaveToDisk(_hotkeys_file);
339 /** Load the hotkeys from the config file */
340 void LoadHotkeysFromConfig()
342 SaveLoadHotkeys(false);
345 /** Save the hotkeys to the config file */
346 void SaveHotkeysToConfig()
348 SaveLoadHotkeys(true);
351 void HandleGlobalHotkeys([[maybe_unused]] char32_t key, uint16_t keycode)
353 for (HotkeyList *list : *_hotkey_lists) {
354 if (list->global_hotkey_handler == nullptr) continue;
356 int hotkey = list->CheckMatch(keycode, true);
357 if (hotkey >= 0 && (list->global_hotkey_handler(hotkey) == ES_HANDLED)) return;