KBM Input Bug Fixes / Added Binds v2 (#3109)

* fixed nonload issues with background music (#3094)

* Fixing my pull request branch

* Pull request change part 2

* Continued changes to project and altered kbm_help_dialog.h text to QStringLiterals

* Finalized commit and changed kbm_help_dialog.h

* KBM Input Bug Fixes / Added Binds

Fixed input issues where some inputs would not bind when pressing (side mouse buttons, some symbols, etc). Also, fixed up code formatting in altered files (removed C-style casts and replaced with C++ <static_casts>, added a few macros and one member functions).
This is v2 of my commit, addressing all issues brought up by @kalaposfos

* Updated C-style casts in kbm_gui.cpp

* Fixed formatting from clang-format

* Updated expendable sections location and changed order of appearance

* Merged PR #3098 into kbm_gui.cpp

* Updates from running clang-format

* Potential MacOS error fix

Changes std::string to std::string_view, which prevented MacOS from building

* Undid MacOS commit for new PR

* Revert "Undid MacOS commit for new PR"

This reverts commit fc376c5e1f.

* Updated SDL_INVALID_ID=UINT32_MAX macro to SDL_UNMAPPED=UINT32_MAX-1

* Update from merge conflicts

Updated SDL_INVALID_ID=UINT32_MAX macro to SDL_UNMAPPED=UINT32_MAX-1

* FIxed memory.cpp errors from testing PR  #3117 (MacOS fixes)

* Removed "kp;"

* Fixed help dialogue from kalaposfos' changes

Fixed 3 edits made by kalaposfos from a recent commit.

---------

Co-authored-by: georgemoralis <giorgosmrls@gmail.com>

src/input/input_handler.cpp

@@ -185,7 +185,7 @@ InputBinding GetBindingFromString(std::string& line) {
         if (string_to_keyboard_key_map.find(t) != string_to_keyboard_key_map.end()) {
             input = InputID(InputType::KeyboardMouse, string_to_keyboard_key_map.at(t));
         } else if (string_to_axis_map.find(t) != string_to_axis_map.end()) {
-            input = InputID(InputType::Axis, (u32)string_to_axis_map.at(t).axis);
+            input = InputID(InputType::Axis, string_to_axis_map.at(t).axis);
         } else if (string_to_cbutton_map.find(t) != string_to_cbutton_map.end()) {
             input = InputID(InputType::Controller, string_to_cbutton_map.at(t));
         } else {
@@ -236,19 +236,15 @@ void ParseInputConfig(const std::string game_id = "") {
         line.erase(std::remove_if(line.begin(), line.end(),
                                   [](unsigned char c) { return std::isspace(c); }),
                    line.end());
-
         if (line.empty()) {
             continue;
         }
+
         // Truncate lines starting at #
         std::size_t comment_pos = line.find('#');
         if (comment_pos != std::string::npos) {
             line = line.substr(0, comment_pos);
         }
-        // Remove trailing semicolon
-        if (!line.empty() && line[line.length() - 1] == ';') {
-            line = line.substr(0, line.length() - 1);
-        }
         if (line.empty()) {
             continue;
         }
@@ -263,8 +259,13 @@ void ParseInputConfig(const std::string game_id = "") {
 
         std::string output_string = line.substr(0, equal_pos);
         std::string input_string = line.substr(equal_pos + 1);
-        std::size_t comma_pos = input_string.find(',');
+        // Remove trailing semicolon from input_string
+        if (!input_string.empty() && input_string[input_string.length() - 1] == ';' &&
+            input_string != ";") {
+            line = line.substr(0, line.length() - 1);
+        }
 
+        std::size_t comma_pos = input_string.find(',');
         auto parseInt = [](const std::string& s) -> std::optional<int> {
             try {
                 return std::stoi(s);
@@ -382,7 +383,6 @@ void ParseInputConfig(const std::string game_id = "") {
         BindingConnection connection(InputID(), nullptr);
         auto button_it = string_to_cbutton_map.find(output_string);
         auto axis_it = string_to_axis_map.find(output_string);
-
         if (binding.IsEmpty()) {
             LOG_WARNING(Input, "Invalid format at line: {}, data: \"{}\", skipping line.",
                         lineCount, line);
@@ -420,7 +420,7 @@ void ParseInputConfig(const std::string game_id = "") {
 u32 GetMouseWheelEvent(const SDL_Event& event) {
     if (event.type != SDL_EVENT_MOUSE_WHEEL && event.type != SDL_EVENT_MOUSE_WHEEL_OFF) {
         LOG_WARNING(Input, "Something went wrong with wheel input parsing!");
-        return (u32)-1;
+        return SDL_UNMAPPED;
     }
     if (event.wheel.y > 0) {
         return SDL_MOUSE_WHEEL_UP;
@@ -431,7 +431,7 @@ u32 GetMouseWheelEvent(const SDL_Event& event) {
     } else if (event.wheel.x < 0) {
         return SDL_MOUSE_WHEEL_LEFT;
     }
-    return (u32)-1;
+    return SDL_UNMAPPED;
 }
 
 InputEvent InputBinding::GetInputEventFromSDLEvent(const SDL_Event& e) {
@@ -441,16 +441,19 @@ InputEvent InputBinding::GetInputEventFromSDLEvent(const SDL_Event& e) {
         return InputEvent(InputType::KeyboardMouse, e.key.key, e.key.down, 0);
     case SDL_EVENT_MOUSE_BUTTON_DOWN:
     case SDL_EVENT_MOUSE_BUTTON_UP:
-        return InputEvent(InputType::KeyboardMouse, (u32)e.button.button, e.button.down, 0);
+        return InputEvent(InputType::KeyboardMouse, static_cast<u32>(e.button.button),
+                          e.button.down, 0);
     case SDL_EVENT_MOUSE_WHEEL:
     case SDL_EVENT_MOUSE_WHEEL_OFF:
         return InputEvent(InputType::KeyboardMouse, GetMouseWheelEvent(e),
                           e.type == SDL_EVENT_MOUSE_WHEEL, 0);
     case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
     case SDL_EVENT_GAMEPAD_BUTTON_UP:
-        return InputEvent(InputType::Controller, (u32)e.gbutton.button, e.gbutton.down, 0);
+        return InputEvent(InputType::Controller, static_cast<u32>(e.gbutton.button), e.gbutton.down,
+                          0); // clang made me do it
     case SDL_EVENT_GAMEPAD_AXIS_MOTION:
-        return InputEvent(InputType::Axis, (u32)e.gaxis.axis, true, e.gaxis.value / 256);
+        return InputEvent(InputType::Axis, static_cast<u32>(e.gaxis.axis), true,
+                          e.gaxis.value / 256); // this too
     default:
         return InputEvent();
     }
@@ -589,7 +592,7 @@ void ControllerOutput::FinalizeUpdate() {
 bool UpdatePressedKeys(InputEvent event) {
     // Skip invalid inputs
     InputID input = event.input;
-    if (input.sdl_id == (u32)-1) {
+    if (input.sdl_id == SDL_UNMAPPED) {
         return false;
     }
     if (input.type == InputType::Axis) {

src/input/input_handler.h

@@ -56,7 +56,7 @@ class InputID {
 public:
     InputType type;
     u32 sdl_id;
-    InputID(InputType d = InputType::Count, u32 i = (u32)-1) : type(d), sdl_id(i) {}
+    InputID(InputType d = InputType::Count, u32 i = SDL_UNMAPPED) : type(d), sdl_id(i) {}
     bool operator==(const InputID& o) const {
         return type == o.type && sdl_id == o.sdl_id;
     }
@@ -70,7 +70,7 @@ public:
         return *this != InputID();
     }
     std::string ToString() {
-        return fmt::format("({}: {:x})", input_type_names[(u8)type], sdl_id);
+        return fmt::format("({}: {:x})", input_type_names[static_cast<u8>(type)], sdl_id);
     }
 };
 
@@ -138,6 +138,7 @@ const std::map<std::string, AxisMapping> string_to_axis_map = {
     {"axis_right_y", {SDL_GAMEPAD_AXIS_RIGHTY, 127}},
 };
 const std::map<std::string, u32> string_to_keyboard_key_map = {
+    // alphanumeric
     {"a", SDLK_A},
     {"b", SDLK_B},
     {"c", SDLK_C},
@@ -174,6 +175,73 @@ const std::map<std::string, u32> string_to_keyboard_key_map = {
     {"7", SDLK_7},
     {"8", SDLK_8},
     {"9", SDLK_9},
+
+    // symbols
+    {"`", SDLK_GRAVE},
+    {"~", SDLK_TILDE},
+    {"!", SDLK_EXCLAIM},
+    {"@", SDLK_AT},
+    {"#", SDLK_HASH},
+    {"$", SDLK_DOLLAR},
+    {"%", SDLK_PERCENT},
+    {"^", SDLK_CARET},
+    {"&", SDLK_AMPERSAND},
+    {"*", SDLK_ASTERISK},
+    {"(", SDLK_LEFTPAREN},
+    {")", SDLK_RIGHTPAREN},
+    {"-", SDLK_MINUS},
+    {"_", SDLK_UNDERSCORE},
+    {"=", SDLK_EQUALS},
+    {"+", SDLK_PLUS},
+    {"[", SDLK_LEFTBRACKET},
+    {"]", SDLK_RIGHTBRACKET},
+    {"{", SDLK_LEFTBRACE},
+    {"}", SDLK_RIGHTBRACE},
+    {"\\", SDLK_BACKSLASH},
+    {"|", SDLK_PIPE},
+    {";", SDLK_SEMICOLON},
+    {":", SDLK_COLON},
+    {"'", SDLK_APOSTROPHE},
+    {"\"", SDLK_DBLAPOSTROPHE},
+    {",", SDLK_COMMA},
+    {"<", SDLK_LESS},
+    {".", SDLK_PERIOD},
+    {">", SDLK_GREATER},
+    {"/", SDLK_SLASH},
+    {"?", SDLK_QUESTION},
+
+    // special keys
+    {"escape", SDLK_ESCAPE},
+    {"printscreen", SDLK_PRINTSCREEN},
+    {"scrolllock", SDLK_SCROLLLOCK},
+    {"pausebreak", SDLK_PAUSE},
+    {"backspace", SDLK_BACKSPACE},
+    {"delete", SDLK_DELETE},
+    {"insert", SDLK_INSERT},
+    {"home", SDLK_HOME},
+    {"end", SDLK_END},
+    {"pgup", SDLK_PAGEUP},
+    {"pgdown", SDLK_PAGEDOWN},
+    {"tab", SDLK_TAB},
+    {"capslock", SDLK_CAPSLOCK},
+    {"enter", SDLK_RETURN},
+    {"lshift", SDLK_LSHIFT},
+    {"rshift", SDLK_RSHIFT},
+    {"lctrl", SDLK_LCTRL},
+    {"rctrl", SDLK_RCTRL},
+    {"lalt", SDLK_LALT},
+    {"ralt", SDLK_RALT},
+    {"lmeta", SDLK_LGUI},
+    {"rmeta", SDLK_RGUI},
+    {"lwin", SDLK_LGUI},
+    {"rwin", SDLK_RGUI},
+    {"space", SDLK_SPACE},
+    {"up", SDLK_UP},
+    {"down", SDLK_DOWN},
+    {"left", SDLK_LEFT},
+    {"right", SDLK_RIGHT},
+
+    // keypad
     {"kp0", SDLK_KP_0},
     {"kp1", SDLK_KP_1},
     {"kp2", SDLK_KP_2},
@@ -184,43 +252,16 @@ const std::map<std::string, u32> string_to_keyboard_key_map = {
     {"kp7", SDLK_KP_7},
     {"kp8", SDLK_KP_8},
     {"kp9", SDLK_KP_9},
-    {"comma", SDLK_COMMA},
-    {"period", SDLK_PERIOD},
-    {"question", SDLK_QUESTION},
-    {"semicolon", SDLK_SEMICOLON},
-    {"minus", SDLK_MINUS},
-    {"underscore", SDLK_UNDERSCORE},
-    {"lparenthesis", SDLK_LEFTPAREN},
-    {"rparenthesis", SDLK_RIGHTPAREN},
-    {"lbracket", SDLK_LEFTBRACKET},
-    {"rbracket", SDLK_RIGHTBRACKET},
-    {"lbrace", SDLK_LEFTBRACE},
-    {"rbrace", SDLK_RIGHTBRACE},
-    {"backslash", SDLK_BACKSLASH},
-    {"dash", SDLK_SLASH},
-    {"enter", SDLK_RETURN},
-    {"space", SDLK_SPACE},
-    {"tab", SDLK_TAB},
-    {"backspace", SDLK_BACKSPACE},
-    {"escape", SDLK_ESCAPE},
-    {"left", SDLK_LEFT},
-    {"right", SDLK_RIGHT},
-    {"up", SDLK_UP},
-    {"down", SDLK_DOWN},
-    {"lctrl", SDLK_LCTRL},
-    {"rctrl", SDLK_RCTRL},
-    {"lshift", SDLK_LSHIFT},
-    {"rshift", SDLK_RSHIFT},
-    {"lalt", SDLK_LALT},
-    {"ralt", SDLK_RALT},
-    {"lmeta", SDLK_LGUI},
-    {"rmeta", SDLK_RGUI},
-    {"lwin", SDLK_LGUI},
-    {"rwin", SDLK_RGUI},
-    {"home", SDLK_HOME},
-    {"end", SDLK_END},
-    {"pgup", SDLK_PAGEUP},
-    {"pgdown", SDLK_PAGEDOWN},
+    {"kp.", SDLK_KP_PERIOD},
+    {"kp,", SDLK_KP_COMMA},
+    {"kp/", SDLK_KP_DIVIDE},
+    {"kp*", SDLK_KP_MULTIPLY},
+    {"kp-", SDLK_KP_MINUS},
+    {"kp+", SDLK_KP_PLUS},
+    {"kp=", SDLK_KP_EQUALS},
+    {"kpenter", SDLK_KP_ENTER},
+
+    // mouse
     {"leftbutton", SDL_BUTTON_LEFT},
     {"rightbutton", SDL_BUTTON_RIGHT},
     {"middlebutton", SDL_BUTTON_MIDDLE},
@@ -230,15 +271,8 @@ const std::map<std::string, u32> string_to_keyboard_key_map = {
     {"mousewheeldown", SDL_MOUSE_WHEEL_DOWN},
     {"mousewheelleft", SDL_MOUSE_WHEEL_LEFT},
     {"mousewheelright", SDL_MOUSE_WHEEL_RIGHT},
-    {"kpperiod", SDLK_KP_PERIOD},
-    {"kpcomma", SDLK_KP_COMMA},
-    {"kpdivide", SDLK_KP_DIVIDE},
-    {"kpmultiply", SDLK_KP_MULTIPLY},
-    {"kpminus", SDLK_KP_MINUS},
-    {"kpplus", SDLK_KP_PLUS},
-    {"kpenter", SDLK_KP_ENTER},
-    {"kpequals", SDLK_KP_EQUALS},
-    {"capslock", SDLK_CAPSLOCK},
+
+    // no binding
     {"unmapped", SDL_UNMAPPED},
 };
 
@@ -335,6 +369,7 @@ public:
     // returns an InputEvent based on the event type (keyboard, mouse buttons/wheel, or controller)
     static InputEvent GetInputEventFromSDLEvent(const SDL_Event& e);
 };
+
 class ControllerOutput {
     static GameController* controller;