hotkeys.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "stdafx.h"
#include "core/backup_type.hpp"
#include "gfx_func.h"
#include "openttd.h"
#include "hotkeys.h"
#include "ini_type.h"
#include "string_func.h"
#include "window_gui.h"
#include "core/string_consumer.hpp"
 
#include "safeguards.h"
 
std::string _hotkeys_file;

static std::vector<HotkeyList*> *_hotkey_lists = nullptr;

struct KeycodeNames {
  const std::string_view name; 
  WindowKeyCodes keycode; 
};

static const std::initializer_list<KeycodeNames> _keycode_to_name = {
  {"SHIFT", WKC_SHIFT},
  {"CTRL", WKC_CTRL},
  {"ALT", WKC_ALT},
  {"META", WKC_META},
  {"GLOBAL", WKC_GLOBAL_HOTKEY},
  {"ESC", WKC_ESC},
  {"BACKSPACE", WKC_BACKSPACE},
  {"INS", WKC_INSERT},
  {"DEL", WKC_DELETE},
  {"PAGEUP", WKC_PAGEUP},
  {"PAGEDOWN", WKC_PAGEDOWN},
  {"END", WKC_END},
  {"HOME", WKC_HOME},
  {"RETURN", WKC_RETURN},
  {"SPACE", WKC_SPACE},
  {"F1", WKC_F1},
  {"F2", WKC_F2},
  {"F3", WKC_F3},
  {"F4", WKC_F4},
  {"F5", WKC_F5},
  {"F6", WKC_F6},
  {"F7", WKC_F7},
  {"F8", WKC_F8},
  {"F9", WKC_F9},
  {"F10", WKC_F10},
  {"F11", WKC_F11},
  {"F12", WKC_F12},
  {"BACKQUOTE", WKC_BACKQUOTE},
  {"PAUSE", WKC_PAUSE},
  {"NUM_DIV", WKC_NUM_DIV},
  {"NUM_MUL", WKC_NUM_MUL},
  {"NUM_MINUS", WKC_NUM_MINUS},
  {"NUM_PLUS", WKC_NUM_PLUS},
  {"NUM_ENTER", WKC_NUM_ENTER},
  {"NUM_DOT", WKC_NUM_DECIMAL},
  {"SLASH", WKC_SLASH},
  {"/", WKC_SLASH}, /* deprecated, use SLASH */
  {"SEMICOLON", WKC_SEMICOLON},
  {";", WKC_SEMICOLON}, /* deprecated, use SEMICOLON */
  {"EQUALS", WKC_EQUALS},
  {"=", WKC_EQUALS}, /* deprecated, use EQUALS */
  {"L_BRACKET", WKC_L_BRACKET},
  {"[", WKC_L_BRACKET}, /* deprecated, use L_BRACKET */
  {"BACKSLASH", WKC_BACKSLASH},
  {"\\", WKC_BACKSLASH}, /* deprecated, use BACKSLASH */
  {"R_BRACKET", WKC_R_BRACKET},
  {"]", WKC_R_BRACKET}, /* deprecated, use R_BRACKET */
  {"SINGLEQUOTE", WKC_SINGLEQUOTE},
  {"'", WKC_SINGLEQUOTE}, /* deprecated, use SINGLEQUOTE */
  {"COMMA", WKC_COMMA},
  {"PERIOD", WKC_PERIOD},
  {".", WKC_PERIOD}, /* deprecated, use PERIOD */
  {"MINUS", WKC_MINUS},
  {"-", WKC_MINUS}, /* deprecated, use MINUS */
};

static std::optional<uint16_t> ParseCode(std::string_view keystr)
{
  keystr = StrTrimView(keystr, StringConsumer::WHITESPACE_NO_NEWLINE);
  for (const auto &kn : _keycode_to_name) {
    if (StrEqualsIgnoreCase(keystr, kn.name)) {
      return kn.keycode;
    }
  }
  if (keystr.size() == 1) {
    auto c = keystr[0];
    if (c >= 'a' && c <= 'z') return c - ('a'-'A');
    /* Ignore invalid keycodes */
    if (static_cast<uint8_t>(c) < 128) return c;
  }
  return std::nullopt;
}

static std::optional<uint16_t> ParseKeycode(std::string_view keystr)
{
  if (keystr.empty()) return std::nullopt;
  StringConsumer consumer{keystr};
  uint16_t keycode = 0;
  while (consumer.AnyBytesLeft()) {
    auto cur = consumer.ReadUntilChar('+', StringConsumer::SKIP_ONE_SEPARATOR);
    auto code = ParseCode(cur);
    if (!code.has_value()) return std::nullopt;
    if (*code & WKC_SPECIAL_KEYS) {
      /* Some completely wrong keycode we don't support. */
      if (*code & ~WKC_SPECIAL_KEYS) return std::nullopt;
      keycode |= *code;
    } else {
      /* Ignore the code if it has more then 1 letter. */
      if (keycode & ~WKC_SPECIAL_KEYS) return std::nullopt;
      keycode |= *code;
    }
  }
  return keycode;
}

static void ParseHotkeys(Hotkey &hotkey, std::string_view value)
{
  StringConsumer consumer{value};
  while (consumer.AnyBytesLeft()) {
    auto keystr = consumer.ReadUntilChar(',', StringConsumer::SKIP_ONE_SEPARATOR);
    auto keycode = ParseKeycode(keystr);
    if (keycode.has_value()) hotkey.AddKeycode(*keycode);
  }
}

static std::string KeycodeToString(uint16_t keycode)
{
  std::string str;
  if (keycode & WKC_GLOBAL_HOTKEY) {
    str += "GLOBAL";
  }
  if (keycode & WKC_SHIFT) {
    if (!str.empty()) str += "+";
    str += "SHIFT";
  }
  if (keycode & WKC_CTRL) {
    if (!str.empty()) str += "+";
    str += "CTRL";
  }
  if (keycode & WKC_ALT) {
    if (!str.empty()) str += "+";
    str += "ALT";
  }
  if (keycode & WKC_META) {
    if (!str.empty()) str += "+";
    str += "META";
  }
  if (!str.empty()) str += "+";
  keycode = keycode & ~WKC_SPECIAL_KEYS;
 
  for (const auto &kn : _keycode_to_name) {
    if (kn.keycode == keycode) {
      str += kn.name;
      return str;
    }
  }
  assert(keycode < 128);
  str.push_back(keycode);
  return str;
}

std::string SaveKeycodes(const Hotkey &hotkey)
{
  std::string str;
  for (auto keycode : hotkey.keycodes) {
    if (!str.empty()) str += ",";
    str += KeycodeToString(keycode);
  }
  return str;
}

Hotkey::Hotkey(uint16_t default_keycode, const std::string &name, int num) :
  name(name),
  num(num)
{
  if (default_keycode != 0) this->AddKeycode(default_keycode);
}

Hotkey::Hotkey(const std::vector<uint16_t> &default_keycodes, const std::string &name, int num) :
  name(name),
  num(num)
{
  for (uint16_t keycode : default_keycodes) {
    this->AddKeycode(keycode);
  }
}

void Hotkey::AddKeycode(uint16_t keycode)
{
  this->keycodes.insert(keycode);
}
 
HotkeyList::HotkeyList(const std::string &ini_group, const std::vector<Hotkey> &items, GlobalHotkeyHandlerFunc global_hotkey_handler) :
  global_hotkey_handler(global_hotkey_handler), ini_group(ini_group), items(items)
{
  if (_hotkey_lists == nullptr) _hotkey_lists = new std::vector<HotkeyList*>();
  _hotkey_lists->push_back(this);
}

HotkeyList::~HotkeyList()
{
  _hotkey_lists->erase(std::ranges::find(*_hotkey_lists, this));
}

void HotkeyList::Load(const IniFile &ini)
{
  const IniGroup *group = ini.GetGroup(this->ini_group);
  if (group == nullptr) return;
  for (Hotkey &hotkey : this->items) {
    const IniItem *item = group->GetItem(hotkey.name);
    if (item != nullptr) {
      hotkey.keycodes.clear();
      if (item->value.has_value()) ParseHotkeys(hotkey, *item->value);
    }
  }
}

void HotkeyList::Save(IniFile &ini) const
{
  IniGroup &group = ini.GetOrCreateGroup(this->ini_group);
  for (const Hotkey &hotkey : this->items) {
    IniItem &item = group.GetOrCreateItem(hotkey.name);
    item.SetValue(SaveKeycodes(hotkey));
  }
}

int HotkeyList::CheckMatch(uint16_t keycode, bool global_only) const
{
  for (const Hotkey &hotkey : this->items) {
    auto begin = hotkey.keycodes.begin();
    auto end = hotkey.keycodes.end();
    if (std::find(begin, end, keycode | WKC_GLOBAL_HOTKEY) != end || (!global_only && std::find(begin, end, keycode) != end)) {
      return hotkey.num;
    }
  }
  return -1;
}
 
 
static void SaveLoadHotkeys(bool save)
{
  IniFile ini{};
  ini.LoadFromDisk(_hotkeys_file, Subdirectory::None);
 
  for (HotkeyList *list : *_hotkey_lists) {
    if (save) {
      list->Save(ini);
    } else {
      list->Load(ini);
    }
  }
 
  if (save) ini.SaveToDisk(_hotkeys_file);
}
 

void LoadHotkeysFromConfig()
{
  SaveLoadHotkeys(false);
}

void SaveHotkeysToConfig()
{
  SaveLoadHotkeys(true);
}

static EventState HandleGlobalHotkey(HotkeyList::GlobalHotkeyHandlerFunc func, int hotkey)
{
  /* Clear global modifier keys so they do not interfere with modifiers assigned to hotkeys. */
  AutoRestoreBackup _shift_backup{_shift_pressed, false};
  AutoRestoreBackup _ctrl_backup{_ctrl_pressed, false};
 
  return func(hotkey);
}
 
void HandleGlobalHotkeys([[maybe_unused]] char32_t key, uint16_t keycode)
{
  for (HotkeyList *list : *_hotkey_lists) {
    if (list->global_hotkey_handler == nullptr) continue;
 
    int hotkey = list->CheckMatch(keycode, true);
    if (hotkey >= 0 && HandleGlobalHotkey(list->global_hotkey_handler, hotkey) == EventState::Handled) return;
  }
}