Expose the keymap separately from the event keycode

This adds functions to query the keymap:
* SDL_GetCurrentKeymap()
* SDL_GetKeymapKeycode()
* SDL_GetKeymapScancode()
* SDL_ReleaseKeymap()

and these are distinct from the function to query the event keycode associated with a scancode, which might be affected by SDL_HINT_KEYCODE_OPTIONS.

Also added an SDL_bool parameter to SDL_GetKeyName() and SDL_GetKeyFromName() to enable upper case handling of the name.

src/dynapi/SDL_dynapi.sym

@@ -199,6 +199,7 @@ SDL3_0.0.0 {
     SDL_GetCurrentCameraDriver;
     SDL_GetCurrentDisplayMode;
     SDL_GetCurrentDisplayOrientation;
+    SDL_GetCurrentKeymap;
     SDL_GetCurrentRenderOutputSize;
     SDL_GetCurrentThreadID;
     SDL_GetCurrentTime;
@@ -211,8 +212,6 @@ SDL3_0.0.0 {
     SDL_GetDaysInMonth;
     SDL_GetDefaultAssertionHandler;
     SDL_GetDefaultCursor;
-    SDL_GetDefaultKeyFromScancode;
-    SDL_GetDefaultScancodeFromKey;
     SDL_GetDesktopDisplayMode;
     SDL_GetDirect3D9AdapterIndex;
     SDL_GetDisplayBounds;
@@ -329,6 +328,8 @@ SDL3_0.0.0 {
     SDL_GetKeyboardNameForID;
     SDL_GetKeyboardState;
     SDL_GetKeyboards;
+    SDL_GetKeymapKeycode;
+    SDL_GetKeymapScancode;
     SDL_GetLogOutputFunction;
     SDL_GetLogPriority;
     SDL_GetMasksForPixelFormat;
@@ -413,7 +414,6 @@ SDL3_0.0.0 {
     SDL_GetRendererProperties;
     SDL_GetRevision;
     SDL_GetSIMDAlignment;
-    SDL_GetScancodeFromKey;
     SDL_GetScancodeFromName;
     SDL_GetScancodeName;
     SDL_GetSemaphoreValue;
@@ -644,6 +644,7 @@ SDL3_0.0.0 {
     SDL_RegisterApp;
     SDL_RegisterEvents;
     SDL_ReleaseCameraFrame;
+    SDL_ReleaseKeymap;
     SDL_ReloadGamepadMappings;
     SDL_RemovePath;
     SDL_RemoveStoragePath;

src/dynapi/SDL_dynapi_overrides.h

@@ -224,6 +224,7 @@
 #define SDL_GetCurrentCameraDriver SDL_GetCurrentCameraDriver_REAL
 #define SDL_GetCurrentDisplayMode SDL_GetCurrentDisplayMode_REAL
 #define SDL_GetCurrentDisplayOrientation SDL_GetCurrentDisplayOrientation_REAL
+#define SDL_GetCurrentKeymap SDL_GetCurrentKeymap_REAL
 #define SDL_GetCurrentRenderOutputSize SDL_GetCurrentRenderOutputSize_REAL
 #define SDL_GetCurrentThreadID SDL_GetCurrentThreadID_REAL
 #define SDL_GetCurrentTime SDL_GetCurrentTime_REAL
@@ -236,8 +237,6 @@
 #define SDL_GetDaysInMonth SDL_GetDaysInMonth_REAL
 #define SDL_GetDefaultAssertionHandler SDL_GetDefaultAssertionHandler_REAL
 #define SDL_GetDefaultCursor SDL_GetDefaultCursor_REAL
-#define SDL_GetDefaultKeyFromScancode SDL_GetDefaultKeyFromScancode_REAL
-#define SDL_GetDefaultScancodeFromKey SDL_GetDefaultScancodeFromKey_REAL
 #define SDL_GetDesktopDisplayMode SDL_GetDesktopDisplayMode_REAL
 #define SDL_GetDirect3D9AdapterIndex SDL_GetDirect3D9AdapterIndex_REAL
 #define SDL_GetDisplayBounds SDL_GetDisplayBounds_REAL
@@ -354,6 +353,8 @@
 #define SDL_GetKeyboardNameForID SDL_GetKeyboardNameForID_REAL
 #define SDL_GetKeyboardState SDL_GetKeyboardState_REAL
 #define SDL_GetKeyboards SDL_GetKeyboards_REAL
+#define SDL_GetKeymapKeycode SDL_GetKeymapKeycode_REAL
+#define SDL_GetKeymapScancode SDL_GetKeymapScancode_REAL
 #define SDL_GetLogOutputFunction SDL_GetLogOutputFunction_REAL
 #define SDL_GetLogPriority SDL_GetLogPriority_REAL
 #define SDL_GetMasksForPixelFormat SDL_GetMasksForPixelFormat_REAL
@@ -438,7 +439,6 @@
 #define SDL_GetRendererProperties SDL_GetRendererProperties_REAL
 #define SDL_GetRevision SDL_GetRevision_REAL
 #define SDL_GetSIMDAlignment SDL_GetSIMDAlignment_REAL
-#define SDL_GetScancodeFromKey SDL_GetScancodeFromKey_REAL
 #define SDL_GetScancodeFromName SDL_GetScancodeFromName_REAL
 #define SDL_GetScancodeName SDL_GetScancodeName_REAL
 #define SDL_GetSemaphoreValue SDL_GetSemaphoreValue_REAL
@@ -669,6 +669,7 @@
 #define SDL_RegisterApp SDL_RegisterApp_REAL
 #define SDL_RegisterEvents SDL_RegisterEvents_REAL
 #define SDL_ReleaseCameraFrame SDL_ReleaseCameraFrame_REAL
+#define SDL_ReleaseKeymap SDL_ReleaseKeymap_REAL
 #define SDL_ReloadGamepadMappings SDL_ReloadGamepadMappings_REAL
 #define SDL_RemovePath SDL_RemovePath_REAL
 #define SDL_RemoveStoragePath SDL_RemoveStoragePath_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -244,6 +244,7 @@ SDL_DYNAPI_PROC(const char*,SDL_GetCurrentAudioDriver,(void),(),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetCurrentCameraDriver,(void),(),return)
 SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetCurrentDisplayMode,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetCurrentDisplayOrientation,(SDL_DisplayID a),(a),return)
+SDL_DYNAPI_PROC(SDL_Keymap*,SDL_GetCurrentKeymap,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetCurrentRenderOutputSize,(SDL_Renderer *a, int *b, int *c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_ThreadID,SDL_GetCurrentThreadID,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetCurrentTime,(SDL_Time *a),(a),return)
@@ -256,8 +257,6 @@ SDL_DYNAPI_PROC(int,SDL_GetDayOfYear,(int a, int b, int c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_GetDaysInMonth,(int a, int b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetDefaultAssertionHandler,(void),(),return)
 SDL_DYNAPI_PROC(SDL_Cursor*,SDL_GetDefaultCursor,(void),(),return)
-SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetDefaultKeyFromScancode,(SDL_Scancode a, SDL_Keymod b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetDefaultScancodeFromKey,(SDL_Keycode a, SDL_Keymod *b),(a,b),return)
 SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetDesktopDisplayMode,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetDirect3D9AdapterIndex,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetDisplayBounds,(SDL_DisplayID a, SDL_Rect *b),(a,b),return)
@@ -367,13 +366,15 @@ SDL_DYNAPI_PROC(SDL_JoystickType,SDL_GetJoystickTypeForID,(SDL_JoystickID a),(a)
 SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickVendor,(SDL_Joystick *a),(a),return)
 SDL_DYNAPI_PROC(Uint16,SDL_GetJoystickVendorForID,(SDL_JoystickID a),(a),return)
 SDL_DYNAPI_PROC(SDL_JoystickID*,SDL_GetJoysticks,(int *a),(a),return)
-SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeyFromName,(const char *a),(a),return)
+SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeyFromName,(const char *a, SDL_bool b),(a, b),return)
 SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeyFromScancode,(SDL_Scancode a, SDL_Keymod b),(a,b),return)
-SDL_DYNAPI_PROC(const char*,SDL_GetKeyName,(SDL_Keycode a),(a),return)
+SDL_DYNAPI_PROC(const char*,SDL_GetKeyName,(SDL_Keycode a, SDL_bool b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_Window*,SDL_GetKeyboardFocus,(void),(),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetKeyboardNameForID,(SDL_KeyboardID a),(a),return)
 SDL_DYNAPI_PROC(const Uint8*,SDL_GetKeyboardState,(int *a),(a),return)
 SDL_DYNAPI_PROC(SDL_KeyboardID*,SDL_GetKeyboards,(int *a),(a),return)
+SDL_DYNAPI_PROC(SDL_Keycode,SDL_GetKeymapKeycode,(SDL_Keymap *a, SDL_Scancode b, SDL_Keymod c),(a,b,c),return)
+SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetKeymapScancode,(SDL_Keymap *a, SDL_Keycode b, SDL_Keymod *c),(a,b,c),return)
 SDL_DYNAPI_PROC(void,SDL_GetLogOutputFunction,(SDL_LogOutputFunction *a, void **b),(a,b),)
 SDL_DYNAPI_PROC(SDL_LogPriority,SDL_GetLogPriority,(int a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetMasksForPixelFormat,(SDL_PixelFormat a, int *b, Uint32 *c, Uint32 *d, Uint32 *e, Uint32 *f),(a,b,c,d,e,f),return)
@@ -458,7 +459,6 @@ SDL_DYNAPI_PROC(const char *,SDL_GetRendererName,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRendererProperties,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetRevision,(void),(),return)
 SDL_DYNAPI_PROC(size_t,SDL_GetSIMDAlignment,(void),(),return)
-SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetScancodeFromKey,(SDL_Keycode a, SDL_Keymod *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_Scancode,SDL_GetScancodeFromName,(const char *a),(a),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetScancodeName,(SDL_Scancode a),(a),return)
 SDL_DYNAPI_PROC(Uint32,SDL_GetSemaphoreValue,(SDL_Semaphore *a),(a),return)
@@ -680,6 +680,7 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_ReadU8,(SDL_IOStream *a, Uint8 *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_RegisterApp,(const char *a, Uint32 b, void *c),(a,b,c),return)
 SDL_DYNAPI_PROC(Uint32,SDL_RegisterEvents,(int a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_ReleaseCameraFrame,(SDL_Camera *a, SDL_Surface *b),(a,b),return)
+SDL_DYNAPI_PROC(void,SDL_ReleaseKeymap,(SDL_Keymap *a),(a),)
 SDL_DYNAPI_PROC(int,SDL_ReloadGamepadMappings,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_RemovePath,(const char *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_RemoveStoragePath,(SDL_Storage *a, const char *b),(a,b),return)

src/events/SDL_keyboard.c

@@ -225,12 +225,19 @@ void SDL_ResetKeyboard(void)
     }
 }
 
+SDL_Keymap *SDL_GetCurrentKeymap(void)
+{
+    SDL_Keyboard *keyboard = &SDL_keyboard;
+
+    return keyboard->keymap;
+}
+
 void SDL_SetKeymap(SDL_Keymap *keymap, SDL_bool send_event)
 {
     SDL_Keyboard *keyboard = &SDL_keyboard;
 
     if (keyboard->keymap) {
-        SDL_DestroyKeymap(keyboard->keymap);
+        SDL_ReleaseKeymap(keyboard->keymap);
     }
 
     keyboard->keymap = keymap;
@@ -424,8 +431,9 @@ static SDL_Keycode SDL_ConvertNumpadKeycode(SDL_Keycode keycode, SDL_bool numloc
     }
 }
 
-static SDL_Keycode SDL_GetEventKeycode(SDL_Keyboard *keyboard, SDL_Scancode scancode, SDL_Keymod modstate)
+SDL_Keycode SDL_GetKeyFromScancode(SDL_Scancode scancode, SDL_Keymod modstate)
 {
+    SDL_Keyboard *keyboard = &SDL_keyboard;
     SDL_bool numlock = (modstate & SDL_KMOD_NUM) != 0;
     SDL_Keycode keycode;
 
@@ -434,7 +442,7 @@ static SDL_Keycode SDL_GetEventKeycode(SDL_Keyboard *keyboard, SDL_Scancode scan
 
     if ((keyboard->keycode_options & KEYCODE_OPTION_LATIN_LETTERS) &&
          keyboard->non_latin_letters) {
-        keycode = SDL_GetDefaultKeyFromScancode(scancode, modstate);
+        keycode = SDL_GetKeymapKeycode(NULL, scancode, modstate);
     } else {
         if ((keyboard->keycode_options & KEYCODE_OPTION_FRENCH_NUMBERS) &&
             keyboard->french_numbers &&
@@ -443,7 +451,7 @@ static SDL_Keycode SDL_GetEventKeycode(SDL_Keyboard *keyboard, SDL_Scancode scan
             modstate |= SDL_KMOD_SHIFT;
         }
 
-        keycode = SDL_GetKeyFromScancode(scancode, modstate);
+        keycode = SDL_GetKeymapKeycode(keyboard->keymap, scancode, modstate);
     }
 
     if (keyboard->keycode_options & KEYCODE_OPTION_HIDE_NUMPAD) {
@@ -501,7 +509,7 @@ static int SDL_SendKeyboardKeyInternal(Uint64 timestamp, Uint32 flags, SDL_Keybo
         /* Update internal keyboard state */
         keyboard->keystate[scancode] = state;
 
-        keycode = SDL_GetEventKeycode(keyboard, scancode, keyboard->modstate);
+        keycode = SDL_GetKeyFromScancode(scancode, keyboard->modstate);
 
     } else if (rawcode == 0) {
         /* Nothing to do! */
@@ -607,8 +615,9 @@ static int SDL_SendKeyboardKeyInternal(Uint64 timestamp, Uint32 flags, SDL_Keybo
 
 int SDL_SendKeyboardUnicodeKey(Uint64 timestamp, Uint32 ch)
 {
+    SDL_Keyboard *keyboard = &SDL_keyboard;
     SDL_Keymod modstate = SDL_KMOD_NONE;
-    SDL_Scancode scancode = SDL_GetScancodeFromKey(ch, &modstate);
+    SDL_Scancode scancode = SDL_GetKeymapScancode(keyboard->keymap, ch, &modstate);
 
     // Make sure we have this keycode in our keymap
     if (scancode == SDL_SCANCODE_UNKNOWN && ch < SDLK_SCANCODE_MASK) {
@@ -836,7 +845,7 @@ void SDL_QuitKeyboard(void)
     SDL_keyboards = NULL;
 
     if (SDL_keyboard.keymap) {
-        SDL_DestroyKeymap(SDL_keyboard.keymap);
+        SDL_ReleaseKeymap(SDL_keyboard.keymap);
         SDL_keyboard.keymap = NULL;
     }
 
@@ -879,13 +888,3 @@ void SDL_ToggleModState(const SDL_Keymod modstate, const SDL_bool toggle)
     }
 }
 
-SDL_Keycode SDL_GetKeyFromScancode(SDL_Scancode scancode, SDL_Keymod modstate)
-{
-    return SDL_GetKeymapKeycode(SDL_keyboard.keymap, scancode, modstate);
-}
-
-SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode key, SDL_Keymod *modstate)
-{
-    return SDL_GetKeymapScancode(SDL_keyboard.keymap, key, modstate);
-}
-

src/events/SDL_keymap.c

@@ -26,10 +26,14 @@
 
 struct SDL_Keymap
 {
+    int refcount;
     SDL_HashTable *scancode_to_keycode;
     SDL_HashTable *keycode_to_scancode;
 };
 
+static SDL_Keycode SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode, SDL_Keymod modstate);
+static SDL_Scancode SDL_GetDefaultScancodeFromKey(SDL_Keycode key, SDL_Keymod *modstate);
+
 SDL_Keymap *SDL_CreateKeymap(void)
 {
     SDL_Keymap *keymap = (SDL_Keymap *)SDL_malloc(sizeof(*keymap));
@@ -37,15 +41,23 @@ SDL_Keymap *SDL_CreateKeymap(void)
         return NULL;
     }
 
+    keymap->refcount = 1;
     keymap->scancode_to_keycode = SDL_CreateHashTable(NULL, 64, SDL_HashID, SDL_KeyMatchID, NULL, SDL_FALSE);
     keymap->keycode_to_scancode = SDL_CreateHashTable(NULL, 64, SDL_HashID, SDL_KeyMatchID, NULL, SDL_FALSE);
     if (!keymap->scancode_to_keycode || !keymap->keycode_to_scancode) {
-        SDL_DestroyKeymap(keymap);
+        SDL_ReleaseKeymap(keymap);
         return NULL;
     }
     return keymap;
 }
 
+void SDL_AcquireKeymap(SDL_Keymap *keymap)
+{
+    if (keymap) {
+        ++keymap->refcount;
+    }
+}
+
 static SDL_Keymod NormalizeModifierStateForKeymap(SDL_Keymod modstate)
 {
     // The modifiers that affect the keymap are: SHIFT, CAPS, ALT, and MODE
@@ -116,21 +128,20 @@ SDL_Scancode SDL_GetKeymapScancode(SDL_Keymap *keymap, SDL_Keycode keycode, SDL_
     return scancode;
 }
 
-void SDL_ResetKeymap(SDL_Keymap *keymap)
+void SDL_ReleaseKeymap(SDL_Keymap *keymap)
 {
-    if (keymap) {
-        SDL_EmptyHashTable(keymap->scancode_to_keycode);
-        SDL_EmptyHashTable(keymap->keycode_to_scancode);
+    if (!keymap) {
+        return;
     }
-}
 
-void SDL_DestroyKeymap(SDL_Keymap *keymap)
-{
-    if (keymap) {
-        SDL_DestroyHashTable(keymap->scancode_to_keycode);
-        SDL_DestroyHashTable(keymap->keycode_to_scancode);
-        SDL_free(keymap);
+    --keymap->refcount;
+    if (keymap->refcount != 0) {
+        return;
     }
+
+    SDL_DestroyHashTable(keymap->scancode_to_keycode);
+    SDL_DestroyHashTable(keymap->keycode_to_scancode);
+    SDL_free(keymap);
 }
 
 static const SDL_Keycode normal_default_symbols[] = {
@@ -193,7 +204,7 @@ static const SDL_Keycode shifted_default_symbols[] = {
     SDLK_QUESTION
 };
 
-SDL_Keycode SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode, SDL_Keymod modstate)
+static SDL_Keycode SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode, SDL_Keymod modstate)
 {
     if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
         SDL_InvalidParamError("scancode");
@@ -594,7 +605,7 @@ SDL_Keycode SDL_GetDefaultKeyFromScancode(SDL_Scancode scancode, SDL_Keymod mods
     }
 }
 
-SDL_Scancode SDL_GetDefaultScancodeFromKey(SDL_Keycode key, SDL_Keymod *modstate)
+static SDL_Scancode SDL_GetDefaultScancodeFromKey(SDL_Keycode key, SDL_Keymod *modstate)
 {
     if (modstate) {
         *modstate = SDL_KMOD_NONE;
@@ -984,7 +995,7 @@ SDL_Scancode SDL_GetScancodeFromName(const char *name)
     return SDL_SCANCODE_UNKNOWN;
 }
 
-const char *SDL_GetKeyName(SDL_Keycode key)
+const char *SDL_GetKeyName(SDL_Keycode key, SDL_bool uppercase)
 {
     char name[8];
     char *end;
@@ -1007,23 +1018,28 @@ const char *SDL_GetKeyName(SDL_Keycode key)
     case SDLK_DELETE:
         return SDL_GetScancodeName(SDL_SCANCODE_DELETE);
     default:
-        // SDL_Keycode is defined as the unshifted key on the keyboard,
-        // but the key name is defined as the letter printed on that key,
-        // which is usually the shifted capital letter.
-        if (key >= 'a' && key <= 'z') {
-            key = 'A' + (key - 'a');
-        } else if (key > 0x7F) {
-            SDL_Scancode scancode = SDL_GetScancodeFromKey(key, SDL_KMOD_NONE);
-            if (scancode != SDL_SCANCODE_UNKNOWN) {
-                if (key >= 0x0E00 && key <= 0x0E7F) {
-                    // Thai keyboards are QWERTY plus Thai characters, so let's use the ASCII key names
-                    return SDL_GetScancodeName(scancode);
-                }
+        if (uppercase) {
+            // SDL_Keycode is defined as the unshifted key on the keyboard,
+            // but the key name is defined as the letter printed on that key,
+            // which is usually the shifted capital letter.
+            if (key >= 'a' && key <= 'z') {
+                key = 'A' + (key - 'a');
+            } else if (key > 0x7F) {
+                SDL_Keymap *keymap = SDL_GetCurrentKeymap();
+                SDL_Scancode scancode = SDL_GetKeymapScancode(keymap, key, NULL);
+                if (scancode != SDL_SCANCODE_UNKNOWN) {
+                    if (key >= 0x0E00 && key <= 0x0E7F) {
+                        // Thai keyboards are QWERTY plus Thai characters, so let's use the ASCII key names
+                        SDL_ReleaseKeymap(keymap);
+                        return SDL_GetScancodeName(scancode);
+                    }
 
-                SDL_Keycode capital = SDL_GetKeyFromScancode(scancode, SDL_KMOD_SHIFT);
-                if (capital > 0x7F || (capital >= 'A' && capital <= 'Z')) {
-                    key = capital;
+                    SDL_Keycode capital = SDL_GetKeymapKeycode(keymap, scancode, SDL_KMOD_SHIFT);
+                    if (capital > 0x7F || (capital >= 'A' && capital <= 'Z')) {
+                        key = capital;
+                    }
                 }
+                SDL_ReleaseKeymap(keymap);
             }
         }
 
@@ -1033,7 +1049,7 @@ const char *SDL_GetKeyName(SDL_Keycode key)
     }
 }
 
-SDL_Keycode SDL_GetKeyFromName(const char *name)
+SDL_Keycode SDL_GetKeyFromName(const char *name, SDL_bool uppercase)
 {
     SDL_Keycode key;
 
@@ -1051,35 +1067,53 @@ SDL_Keycode SDL_GetKeyFromName(const char *name)
             key |= (Uint16)(name[++i] & 0x3F) << 12;
             key |= (Uint16)(name[++i] & 0x3F) << 6;
             key |= (Uint16)(name[++i] & 0x3F);
-            return key;
+        } else {
+            key = SDLK_UNKNOWN;
         }
-        return SDLK_UNKNOWN;
     } else if (key >= 0xE0) {
         if (SDL_strlen(name) == 3) {
             int i = 0;
             key = (Uint16)(name[i] & 0x0F) << 12;
             key |= (Uint16)(name[++i] & 0x3F) << 6;
             key |= (Uint16)(name[++i] & 0x3F);
-            return key;
+        } else {
+            key = SDLK_UNKNOWN;
         }
-        return SDLK_UNKNOWN;
     } else if (key >= 0xC0) {
         if (SDL_strlen(name) == 2) {
             int i = 0;
             key = (Uint16)(name[i] & 0x1F) << 6;
             key |= (Uint16)(name[++i] & 0x3F);
-            return key;
+        } else {
+            key = SDLK_UNKNOWN;
         }
         return SDLK_UNKNOWN;
     } else {
-        if (SDL_strlen(name) == 1) {
-            if (key >= 'A' && key <= 'Z') {
-                key += 32;
-            }
-            return key;
+        if (SDL_strlen(name) != 1) {
+            key = SDLK_UNKNOWN;
         }
-
-        /* Get the scancode for this name, and the associated keycode */
-        return SDL_GetKeyFromScancode(SDL_GetScancodeFromName(name), SDL_KMOD_NONE);
     }
+
+    if (key != SDLK_UNKNOWN) {
+        if (uppercase) {
+            // SDL_Keycode is defined as the unshifted key on the keyboard,
+            // but the key name is defined as the letter printed on that key,
+            // which is usually the shifted capital letter.
+            if (key >= 'A' && key <= 'Z') {
+                key = 'a' + (key - 'A');
+            } else if (key > 0x7F) {
+                SDL_Keymap *keymap = SDL_GetCurrentKeymap();
+                SDL_Keymod modstate;
+                SDL_Scancode scancode = SDL_GetKeymapScancode(keymap, key, &modstate);
+                if (scancode != SDL_SCANCODE_UNKNOWN && (modstate & SDL_KMOD_SHIFT)) {
+                    key = SDL_GetKeymapKeycode(keymap, scancode, SDL_KMOD_NONE);
+                }
+                SDL_ReleaseKeymap(keymap);
+            }
+        }
+        return key;
+    }
+
+    /* Get the scancode for this name, and the associated keycode */
+    return SDL_GetKeyFromScancode(SDL_GetScancodeFromName(name), SDL_KMOD_NONE);
 }

src/events/SDL_keymap_c.h

@@ -25,13 +25,11 @@
 
 #include "../SDL_hashtable.h"
 
-typedef struct SDL_Keymap SDL_Keymap;
-
 SDL_Keymap *SDL_CreateKeymap(void);
+void SDL_AcquireKeymap(SDL_Keymap *keymap);
 void SDL_SetKeymapEntry(SDL_Keymap *keymap, SDL_Scancode scancode, SDL_Keymod modstate, SDL_Keycode keycode);
 SDL_Keycode SDL_GetKeymapKeycode(SDL_Keymap *keymap, SDL_Scancode scancode, SDL_Keymod modstate);
 SDL_Scancode SDL_GetKeymapScancode(SDL_Keymap *keymap, SDL_Keycode keycode, SDL_Keymod *modstate);
-void SDL_ResetKeymap(SDL_Keymap *keymap);
-void SDL_DestroyKeymap(SDL_Keymap *keymap);
+void SDL_ReleaseKeymap(SDL_Keymap *keymap);
 
 #endif /* SDL_keymap_c_h_ */

src/test/SDL_test_common.c

@@ -1717,7 +1717,7 @@ void SDLTest_PrintEvent(const SDL_Event *event)
                 event->key.windowID,
                 event->key.scancode,
                 SDL_GetScancodeName(event->key.scancode),
-                event->key.key, SDL_GetKeyName(event->key.key),
+                event->key.key, SDL_GetKeyName(event->key.key, SDL_TRUE),
                 modstr);
         break;
     }

src/video/cocoa/SDL_cocoakeyboard.m

@@ -326,7 +326,7 @@ static void UpdateKeymap(SDL_CocoaVideoData *data, SDL_bool send_event)
             SDL_Scancode scancode = darwin_scancode_table[i];
             if (scancode == SDL_SCANCODE_UNKNOWN ||
                 scancode == SDL_SCANCODE_DELETE ||
-                (SDL_GetDefaultKeyFromScancode(scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK)) {
+                (SDL_GetKeymapKeycode(NULL, scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK)) {
                 continue;
             }
 

src/video/wayland/SDL_waylandevents.c

@@ -1124,7 +1124,7 @@ static void Wayland_keymap_iter(struct xkb_keymap *keymap, xkb_keycode_t key, vo
 
             /* Note: The default SDL scancode table sets this to right alt instead of AltGr/Mode, so handle it separately. */
             if (syms[0] != XKB_KEY_ISO_Level3_Shift) {
-                keycode = SDL_GetDefaultKeyFromScancode(sc, sdlKeymap->modstate);
+                keycode = SDL_GetKeymapKeycode(NULL, sc, sdlKeymap->modstate);
             } else {
                 keycode = SDLK_MODE;
             }
@@ -1185,7 +1185,7 @@ static void Wayland_UpdateKeymap(struct SDL_WaylandInput *input)
         keymap.state = WAYLAND_xkb_state_new(input->xkb.keymap);
         if (!keymap.state) {
             SDL_SetError("failed to create XKB state");
-            SDL_DestroyKeymap(keymap.keymap);
+            SDL_ReleaseKeymap(keymap.keymap);
             return;
         }
 

src/video/windows/SDL_windowskeyboard.c

@@ -107,7 +107,7 @@ void WIN_UpdateKeymap(SDL_bool send_event)
             scancode = windows_scancode_table[i];
             if (scancode == SDL_SCANCODE_UNKNOWN ||
                 scancode == SDL_SCANCODE_DELETE ||
-                (SDL_GetDefaultKeyFromScancode(scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK)) {
+                (SDL_GetKeymapKeycode(NULL, scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK)) {
 
                 /* The Colemak mapping swaps Backspace and CapsLock */
                 if (mods[m] == SDL_KMOD_NONE &&

src/video/x11/SDL_x11keyboard.c

@@ -280,7 +280,7 @@ int X11_InitKeyboard(SDL_VideoDevice *_this)
             if (scancode == data->key_layout[i]) {
                 continue;
             }
-            if ((SDL_GetDefaultKeyFromScancode(scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK) && X11_ScancodeIsRemappable(scancode)) {
+            if ((SDL_GetKeymapKeycode(NULL, scancode, SDL_KMOD_NONE) & SDLK_SCANCODE_MASK) && X11_ScancodeIsRemappable(scancode)) {
                 /* Not a character key and the scancode is safe to remap */
 #ifdef DEBUG_KEYBOARD
                 SDL_Log("Changing scancode, was %d (%s), now %d (%s)\n", data->key_layout[i], SDL_GetScancodeName(data->key_layout[i]), scancode, SDL_GetScancodeName(scancode));
@@ -382,7 +382,7 @@ void X11_UpdateKeymap(SDL_VideoDevice *_this, SDL_bool send_event)
 
             if (!keycode) {
                 SDL_Scancode keyScancode = SDL_GetScancodeFromKeySym(keysym, (KeyCode)i);
-                keycode = SDL_GetDefaultKeyFromScancode(keyScancode, keymod_masks[m].sdl_mask);
+                keycode = SDL_GetKeymapKeycode(NULL, keyScancode, keymod_masks[m].sdl_mask);
             }
             SDL_SetKeymapEntry(keymap, scancode, keymod_masks[m].sdl_mask, keycode);
         }