Removed SDL_Keysym

docs/README-migration.md

@@ -347,6 +347,21 @@ The SDL_EVENT_WINDOW_RESIZED event is always sent, even in response to SDL_SetWi
 
 The SDL_EVENT_WINDOW_SIZE_CHANGED event has been removed, and you can use SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED to detect window backbuffer size changes.
 
+The keysym field of key events has been removed to remove one level of indirection, and `sym` has been renamed `key`.
+
+Code that looked like this:
+```c
+    SDL_Event event;
+    SDL_Keycode key = event.key.keysym.sym;
+    SDL_Keymod mod = event.key.keysym.mod;
+```
+now looks like this:
+```c
+    SDL_Event event;
+    SDL_Keycode key = event.key.key;
+    SDL_Keymod mod = event.key.mod;
+```
+
 The gamepad event structures caxis, cbutton, cdevice, ctouchpad, and csensor have been renamed gaxis, gbutton, gdevice, gtouchpad, and gsensor.
 
 The mouseX and mouseY fields of SDL_MouseWheelEvent have been renamed mouse_x and mouse_y.
@@ -899,6 +914,9 @@ The following functions have been renamed:
 The following functions have been removed:
 * SDL_IsTextInputShown()
 
+The following structures have been removed:
+* SDL_Keysym
+
 ## SDL_keycode.h
 
 SDL_Keycode is now Uint32 and the SDLK_* constants are now defines instead of an enum, to more clearly reflect that they are a subset of the possible values of an SDL_Keycode.

include/SDL3/SDL_events.h

@@ -301,16 +301,17 @@ typedef struct SDL_KeyboardDeviceEvent
  */
 typedef struct SDL_KeyboardEvent
 {
-    SDL_EventType type; /**< SDL_EVENT_KEY_DOWN or SDL_EVENT_KEY_UP */
+    SDL_EventType type;     /**< SDL_EVENT_KEY_DOWN or SDL_EVENT_KEY_UP */
     Uint32 reserved;
-    Uint64 timestamp;   /**< In nanoseconds, populated using SDL_GetTicksNS() */
-    SDL_WindowID windowID; /**< The window with keyboard focus, if any */
-    SDL_KeyboardID which;  /**< The keyboard instance id, or 0 if unknown or virtual */
-    Uint8 state;        /**< SDL_PRESSED or SDL_RELEASED */
-    Uint8 repeat;       /**< Non-zero if this is a key repeat */
-    Uint8 padding2;
-    Uint8 padding3;
-    SDL_Keysym keysym;  /**< The key that was pressed or released */
+    Uint64 timestamp;       /**< In nanoseconds, populated using SDL_GetTicksNS() */
+    SDL_WindowID windowID;  /**< The window with keyboard focus, if any */
+    SDL_KeyboardID which;   /**< The keyboard instance id, or 0 if unknown or virtual */
+    SDL_Scancode scancode;  /**< SDL physical key code */
+    SDL_Keycode key;        /**< SDL virtual key code */
+    SDL_Keymod mod;         /**< current key modifiers */
+    Uint16 raw;             /**< The platform dependent scancode for this event */
+    Uint8 state;            /**< SDL_PRESSED or SDL_RELEASED */
+    Uint8 repeat;           /**< Non-zero if this is a key repeat */
 } SDL_KeyboardEvent;
 
 /**

include/SDL3/SDL_keyboard.h

@@ -52,25 +52,6 @@ extern "C" {
  */
 typedef Uint32 SDL_KeyboardID;
 
-/**
- * The SDL keysym structure, used in key events.
- *
- * If you are looking for translated character input, see the
- * SDL_EVENT_TEXT_INPUT event.
- *
- * \since This struct is available since SDL 3.0.0.
- *
- * \sa SDL_Scancode
- * \sa SDL_Keycode
- */
-typedef struct SDL_Keysym
-{
-    SDL_Scancode scancode;      /**< SDL physical key code - see SDL_Scancode for details */
-    SDL_Keycode sym;            /**< SDL virtual key code - see SDL_Keycode for details */
-    SDL_Keymod mod;             /**< current key modifiers */
-    Uint16 raw;                 /**< The platform dependent scancode for this event */
-} SDL_Keysym;
-
 /* Function prototypes */
 
 /**

src/events/SDL_events.c

@@ -338,14 +338,14 @@ static void SDL_LogEvent(const SDL_Event *event)
         break;
 #undef PRINT_KEYDEV_EVENT
 
-#define PRINT_KEY_EVENT(event)                                                                                                   \
-    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u state=%s repeat=%s scancode=%u keycode=%u mod=%u)", \
-                       (uint)event->key.timestamp, (uint)event->key.windowID, (uint)event->key.which,                            \
-                       event->key.state == SDL_PRESSED ? "pressed" : "released",                                                 \
-                       event->key.repeat ? "true" : "false",                                                                     \
-                       (uint)event->key.keysym.scancode,                                                                         \
-                       (uint)event->key.keysym.sym,                                                                              \
-                       (uint)event->key.keysym.mod)
+#define PRINT_KEY_EVENT(event)                                                                                                              \
+    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u state=%s repeat=%s scancode=%u keycode=%u mod=0x%x)", \
+                       (uint)event->key.timestamp, (uint)event->key.windowID, (uint)event->key.which,                                       \
+                       event->key.state == SDL_PRESSED ? "pressed" : "released",                                                            \
+                       event->key.repeat ? "true" : "false",                                                                                \
+                       (uint)event->key.scancode,                                                                                           \
+                       (uint)event->key.key,                                                                                                \
+                       (uint)event->key.mod)
         SDL_EVENT_CASE(SDL_EVENT_KEY_DOWN)
         PRINT_KEY_EVENT(event);
         break;

src/events/SDL_keyboard.c

@@ -399,12 +399,12 @@ static int SDL_SendKeyboardKeyInternal(Uint64 timestamp, Uint32 flags, SDL_Keybo
         SDL_Event event;
         event.type = type;
         event.common.timestamp = timestamp;
+        event.key.scancode = scancode;
+        event.key.key = keycode;
+        event.key.mod = keyboard->modstate;
+        event.key.raw = (Uint16)rawcode;
         event.key.state = state;
         event.key.repeat = repeat;
-        event.key.keysym.scancode = scancode;
-        event.key.keysym.sym = keycode;
-        event.key.keysym.mod = keyboard->modstate;
-        event.key.keysym.raw = (Uint16)rawcode;
         event.key.windowID = keyboard->focus ? keyboard->focus->id : 0;
         event.key.which = keyboardID;
         posted = (SDL_PushEvent(&event) > 0);

src/test/SDL_test_common.c

@@ -1676,9 +1676,9 @@ static void SDLTest_PrintEvent(const SDL_Event *event)
     case SDL_EVENT_KEY_DOWN:
     case SDL_EVENT_KEY_UP: {
         char modstr[64];
-        if (event->key.keysym.mod) {
+        if (event->key.mod) {
             modstr[0] = '\0';
-            SDLTest_PrintModState(modstr, sizeof (modstr), event->key.keysym.mod);
+            SDLTest_PrintModState(modstr, sizeof (modstr), event->key.mod);
         } else {
             SDL_strlcpy(modstr, "NONE", sizeof (modstr));
         }
@@ -1686,9 +1686,9 @@ static void SDLTest_PrintEvent(const SDL_Event *event)
         SDL_Log("SDL EVENT: Keyboard: key %s in window %" SDL_PRIu32 ": scancode 0x%08X = %s, keycode 0x%08" SDL_PRIX32 " = %s, mods = %s",
                 (event->type == SDL_EVENT_KEY_DOWN) ? "pressed" : "released",
                 event->key.windowID,
-                event->key.keysym.scancode,
-                SDL_GetScancodeName(event->key.keysym.scancode),
-                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym),
+                event->key.scancode,
+                SDL_GetScancodeName(event->key.scancode),
+                event->key.key, SDL_GetKeyName(event->key.key),
                 modstr);
         break;
     }
@@ -2097,11 +2097,11 @@ int SDLTest_CommonEventMainCallbacks(SDLTest_CommonState *state, const SDL_Event
         break;
     case SDL_EVENT_KEY_DOWN:
     {
-        SDL_bool withControl = !!(event->key.keysym.mod & SDL_KMOD_CTRL);
-        SDL_bool withShift = !!(event->key.keysym.mod & SDL_KMOD_SHIFT);
-        SDL_bool withAlt = !!(event->key.keysym.mod & SDL_KMOD_ALT);
+        SDL_bool withControl = !!(event->key.mod & SDL_KMOD_CTRL);
+        SDL_bool withShift = !!(event->key.mod & SDL_KMOD_SHIFT);
+        SDL_bool withAlt = !!(event->key.mod & SDL_KMOD_ALT);
 
-        switch (event->key.keysym.sym) {
+        switch (event->key.key) {
             /* Add hotkeys here */
         case SDLK_PRINTSCREEN:
         {
@@ -2158,7 +2158,7 @@ int SDLTest_CommonEventMainCallbacks(SDLTest_CommonState *state, const SDL_Event
                         }
                         if (current_index >= 0) {
                             SDL_DisplayID dest;
-                            if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
+                            if (event->key.key == SDLK_UP || event->key.key == SDLK_LEFT) {
                                 dest = displays[(current_index + num_displays - 1) % num_displays];
                             } else {
                                 dest = displays[(current_index + num_displays + 1) % num_displays];
@@ -2180,16 +2180,16 @@ int SDLTest_CommonEventMainCallbacks(SDLTest_CommonState *state, const SDL_Event
                     int x, y;
                     SDL_GetWindowPosition(window, &x, &y);
 
-                    if (event->key.keysym.sym == SDLK_UP) {
+                    if (event->key.key == SDLK_UP) {
                         y -= delta;
                     }
-                    if (event->key.keysym.sym == SDLK_DOWN) {
+                    if (event->key.key == SDLK_DOWN) {
                         y += delta;
                     }
-                    if (event->key.keysym.sym == SDLK_LEFT) {
+                    if (event->key.key == SDLK_LEFT) {
                         x -= delta;
                     }
-                    if (event->key.keysym.sym == SDLK_RIGHT) {
+                    if (event->key.key == SDLK_RIGHT) {
                         x += delta;
                     }
 

test/checkkeys.c

@@ -159,7 +159,7 @@ static void PrintModifierState(void)
     SDL_Log("Initial state:%s\n", message);
 }
 
-static void PrintKey(SDL_Keysym *sym, SDL_bool pressed, SDL_bool repeat)
+static void PrintKey(SDL_KeyboardEvent *event)
 {
     char message[512];
     char *spot;
@@ -169,24 +169,24 @@ static void PrintKey(SDL_Keysym *sym, SDL_bool pressed, SDL_bool repeat)
     left = sizeof(message);
 
     /* Print the keycode, name and state */
-    if (sym->sym) {
+    if (event->key) {
         print_string(&spot, &left,
                      "Key %s:  raw 0x%.2x, scancode %d = %s, keycode 0x%08X = %s ",
-                     pressed ? "pressed " : "released",
-                     sym->raw,
-                     sym->scancode,
-                     sym->scancode == SDL_SCANCODE_UNKNOWN ? "UNKNOWN" : SDL_GetScancodeName(sym->scancode),
-                     sym->sym, SDL_GetKeyName(sym->sym));
+                     event->state ? "pressed " : "released",
+                     event->raw,
+                     event->scancode,
+                     event->scancode == SDL_SCANCODE_UNKNOWN ? "UNKNOWN" : SDL_GetScancodeName(event->scancode),
+                     event->key, SDL_GetKeyName(event->key));
     } else {
         print_string(&spot, &left,
                      "Unknown Key (raw 0x%.2x, scancode %d = %s) %s ",
-                     sym->raw,
-                     sym->scancode,
-                     sym->scancode == SDL_SCANCODE_UNKNOWN ? "UNKNOWN" : SDL_GetScancodeName(sym->scancode),
-                     pressed ? "pressed " : "released");
+                     event->raw,
+                     event->scancode,
+                     event->scancode == SDL_SCANCODE_UNKNOWN ? "UNKNOWN" : SDL_GetScancodeName(event->scancode),
+                     event->state ? "pressed " : "released");
     }
-    print_modifiers(&spot, &left, sym->mod);
-    if (repeat) {
+    print_modifiers(&spot, &left, event->mod);
+    if (event->repeat) {
         print_string(&spot, &left, " (repeat)");
     }
     SDL_Log("%s\n", message);
@@ -229,9 +229,9 @@ static void loop(void)
         switch (event.type) {
         case SDL_EVENT_KEY_DOWN:
         case SDL_EVENT_KEY_UP:
-            PrintKey(&event.key.keysym, (event.key.state == SDL_PRESSED), (event.key.repeat > 0));
+            PrintKey(&event.key);
             if (event.type == SDL_EVENT_KEY_DOWN) {
-                switch (event.key.keysym.sym) {
+                switch (event.key.key) {
                 case SDLK_BACKSPACE:
                     SDLTest_TextWindowAddText(textwin, "\b");
                     break;

test/checkkeysthreads.c

@@ -120,7 +120,7 @@ PrintModifierState(void)
 }
 
 static void
-PrintKey(SDL_Keysym *sym, SDL_bool pressed, SDL_bool repeat)
+PrintKey(SDL_KeyboardEvent *event)
 {
     char message[512];
     char *spot;
@@ -130,22 +130,22 @@ PrintKey(SDL_Keysym *sym, SDL_bool pressed, SDL_bool repeat)
     left = sizeof(message);
 
     /* Print the keycode, name and state */
-    if (sym->sym) {
+    if (event->key) {
         print_string(&spot, &left,
                      "Key %s:  scancode %d = %s, keycode 0x%08X = %s ",
-                     pressed ? "pressed " : "released",
-                     sym->scancode,
-                     SDL_GetScancodeName(sym->scancode),
-                     sym->sym, SDL_GetKeyName(sym->sym));
+                     event->state ? "pressed " : "released",
+                     event->scancode,
+                     SDL_GetScancodeName(event->scancode),
+                     event->key, SDL_GetKeyName(event->key));
     } else {
         print_string(&spot, &left,
                      "Unknown Key (scancode %d = %s) %s ",
-                     sym->scancode,
-                     SDL_GetScancodeName(sym->scancode),
-                     pressed ? "pressed " : "released");
+                     event->scancode,
+                     SDL_GetScancodeName(event->scancode),
+                     event->state ? "pressed " : "released");
     }
     print_modifiers(&spot, &left);
-    if (repeat) {
+    if (event->repeat) {
         print_string(&spot, &left, " (repeat)");
     }
     SDL_Log("%s\n", message);
@@ -177,7 +177,7 @@ static void loop(void)
         switch (event.type) {
         case SDL_EVENT_KEY_DOWN:
         case SDL_EVENT_KEY_UP:
-            PrintKey(&event.key.keysym, (event.key.state == SDL_PRESSED), (event.key.repeat > 0));
+            PrintKey(&event.key);
             break;
         case SDL_EVENT_TEXT_EDITING:
             PrintText("EDIT", event.text.text);
@@ -221,11 +221,11 @@ static int SDLCALL ping_thread(void *ptr)
 {
     int cnt;
     SDL_Event sdlevent;
-    SDL_memset(&sdlevent, 0, sizeof(SDL_Event));
+    SDL_zero(sdlevent);
     for (cnt = 0; cnt < 10; ++cnt) {
         SDL_Log("sending event (%d/%d) from thread.\n", cnt + 1, 10);
         sdlevent.type = SDL_EVENT_KEY_DOWN;
-        sdlevent.key.keysym.sym = SDLK_1;
+        sdlevent.key.key = SDLK_1;
         SDL_PushEvent(&sdlevent);
         SDL_Delay(1000 + SDL_rand_n(1000));
     }

test/testaudio.c

@@ -1185,8 +1185,8 @@ int SDL_AppEvent(void *appstate, const SDL_Event *event)
 
         case SDL_EVENT_KEY_DOWN:
         case SDL_EVENT_KEY_UP:
-            ctrl_held = ((event->key.keysym.mod & SDL_KMOD_CTRL) != 0);
-            alt_held = ((event->key.keysym.mod & SDL_KMOD_ALT) != 0);
+            ctrl_held = ((event->key.mod & SDL_KMOD_CTRL) != 0);
+            alt_held = ((event->key.mod & SDL_KMOD_ALT) != 0);
             break;
 
         case SDL_EVENT_DROP_FILE:

test/testaudiohotplug.c

@@ -65,7 +65,7 @@ static void iteration(void)
         if (e.type == SDL_EVENT_QUIT) {
             done = 1;
         } else if (e.type == SDL_EVENT_KEY_UP) {
-            if (e.key.keysym.sym == SDLK_ESCAPE) {
+            if (e.key.key == SDLK_ESCAPE) {
                 done = 1;
             }
         } else if (e.type == SDL_EVENT_AUDIO_DEVICE_ADDED) {

test/testaudiorecording.c

@@ -149,7 +149,7 @@ int SDL_AppEvent(void *appstate, const SDL_Event *event)
     if (event->type == SDL_EVENT_QUIT) {
         return SDL_APP_SUCCESS;
     } else if (event->type == SDL_EVENT_KEY_DOWN) {
-        if (event->key.keysym.sym == SDLK_ESCAPE) {
+        if (event->key.key == SDLK_ESCAPE) {
             return SDL_APP_SUCCESS;
         }
     } else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN) {

test/testaudiostreamdynamicresample.c

@@ -218,7 +218,7 @@ static void loop(void)
         }
 #endif
         if (e.type == SDL_EVENT_KEY_DOWN) {
-            SDL_Keycode sym = e.key.keysym.sym;
+            SDL_Keycode sym = e.key.key;
             if (sym == SDLK_q) {
                 if (SDL_AudioDevicePaused(state->audio_id)) {
                     SDL_ResumeAudioDevice(state->audio_id);
@@ -236,8 +236,8 @@ static void loop(void)
                 queue_audio();
             } else if (sym == SDLK_d) {
                 float amount = 1.0f;
-                amount *= (e.key.keysym.mod & SDL_KMOD_CTRL) ? 10.0f : 1.0f;
-                amount *= (e.key.keysym.mod & SDL_KMOD_SHIFT) ? 10.0f : 1.0f;
+                amount *= (e.key.mod & SDL_KMOD_CTRL) ? 10.0f : 1.0f;
+                amount *= (e.key.mod & SDL_KMOD_SHIFT) ? 10.0f : 1.0f;
                 skip_audio(amount);
             }
         }

test/testcamera.c

@@ -198,7 +198,7 @@ int SDL_AppEvent(void *appstate, const SDL_Event *event)
 {
     switch (event->type) {
         case SDL_EVENT_KEY_DOWN: {
-            const SDL_Keycode sym = event->key.keysym.sym;
+            const SDL_Keycode sym = event->key.key;
             if (sym == SDLK_ESCAPE || sym == SDLK_AC_BACK) {
                 SDL_Log("Key : Escape!");
                 return SDL_APP_SUCCESS;

test/testcolorspace.c

@@ -503,7 +503,7 @@ static void loop(void)
     /* Check for events */
     while (SDL_PollEvent(&event)) {
         if (event.type == SDL_EVENT_KEY_DOWN) {
-            switch (event.key.keysym.sym) {
+            switch (event.key.key) {
             case SDLK_ESCAPE:
                 done = 1;
                 break;

test/testcontroller.c

@@ -1846,37 +1846,37 @@ static void loop(void *arg)
 
         case SDL_EVENT_KEY_DOWN:
             if (display_mode == CONTROLLER_MODE_TESTING) {
-                if (event.key.keysym.sym >= SDLK_0 && event.key.keysym.sym <= SDLK_9) {
+                if (event.key.key >= SDLK_0 && event.key.key <= SDLK_9) {
                     if (controller && controller->gamepad) {
-                        int player_index = (event.key.keysym.sym - SDLK_0);
+                        int player_index = (event.key.key - SDLK_0);
 
                         SDL_SetGamepadPlayerIndex(controller->gamepad, player_index);
                     }
                     break;
-                } else if (event.key.keysym.sym == SDLK_a) {
+                } else if (event.key.key == SDLK_a) {
                     OpenVirtualGamepad();
-                } else if (event.key.keysym.sym == SDLK_d) {
+                } else if (event.key.key == SDLK_d) {
                     CloseVirtualGamepad();
-                } else if (event.key.keysym.sym == SDLK_r && (event.key.keysym.mod & SDL_KMOD_CTRL)) {
+                } else if (event.key.key == SDLK_r && (event.key.mod & SDL_KMOD_CTRL)) {
                     SDL_ReloadGamepadMappings();
-                } else if (event.key.keysym.sym == SDLK_ESCAPE) {
+                } else if (event.key.key == SDLK_ESCAPE) {
                     done = SDL_TRUE;
                 }
             } else if (display_mode == CONTROLLER_MODE_BINDING) {
-                if (event.key.keysym.sym == SDLK_c && (event.key.keysym.mod & SDL_KMOD_CTRL)) {
+                if (event.key.key == SDLK_c && (event.key.mod & SDL_KMOD_CTRL)) {
                     if (binding_element == SDL_GAMEPAD_ELEMENT_NAME) {
                         CopyControllerName();
                     } else {
                         CopyMapping();
                     }
-                } else if (event.key.keysym.sym == SDLK_v && (event.key.keysym.mod & SDL_KMOD_CTRL)) {
+                } else if (event.key.key == SDLK_v && (event.key.mod & SDL_KMOD_CTRL)) {
                     if (binding_element == SDL_GAMEPAD_ELEMENT_NAME) {
                         ClearControllerName();
                         PasteControllerName();
                     } else {
                         PasteMapping();
                     }
-                } else if (event.key.keysym.sym == SDLK_x && (event.key.keysym.mod & SDL_KMOD_CTRL)) {
+                } else if (event.key.key == SDLK_x && (event.key.mod & SDL_KMOD_CTRL)) {
                     if (binding_element == SDL_GAMEPAD_ELEMENT_NAME) {
                         CopyControllerName();
                         ClearControllerName();
@@ -1884,19 +1884,19 @@ static void loop(void *arg)
                         CopyMapping();
                         ClearMapping();
                     }
-                } else if (event.key.keysym.sym == SDLK_SPACE) {
+                } else if (event.key.key == SDLK_SPACE) {
                     if (binding_element != SDL_GAMEPAD_ELEMENT_NAME) {
                         ClearBinding();
                     }
-                } else if (event.key.keysym.sym == SDLK_BACKSPACE) {
+                } else if (event.key.key == SDLK_BACKSPACE) {
                     if (binding_element == SDL_GAMEPAD_ELEMENT_NAME) {
                         BackspaceControllerName();
                     }
-                } else if (event.key.keysym.sym == SDLK_RETURN) {
+                } else if (event.key.key == SDLK_RETURN) {
                     if (binding_element == SDL_GAMEPAD_ELEMENT_NAME) {
                         StopBinding();
                     }
-                } else if (event.key.keysym.sym == SDLK_ESCAPE) {
+                } else if (event.key.key == SDLK_ESCAPE) {
                     if (binding_element != SDL_GAMEPAD_ELEMENT_INVALID) {
                         StopBinding();
                     } else {

test/testdrawchessboard.c

@@ -85,7 +85,7 @@ static void loop(void)
             return;
         }
 
-        if ((e.type == SDL_EVENT_KEY_DOWN) && (e.key.keysym.sym == SDLK_ESCAPE)) {
+        if ((e.type == SDL_EVENT_KEY_DOWN) && (e.key.key == SDLK_ESCAPE)) {
             done = 1;
 #ifdef SDL_PLATFORM_EMSCRIPTEN
             emscripten_cancel_main_loop();

test/testffmpeg.c

@@ -1509,7 +1509,7 @@ int main(int argc, char *argv[])
         /* Check for events */
         while (SDL_PollEvent(&event)) {
             if (event.type == SDL_EVENT_QUIT ||
-                (event.type == SDL_EVENT_KEY_DOWN && event.key.keysym.sym == SDLK_ESCAPE)) {
+                (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_ESCAPE)) {
                 done = 1;
             }
         }

test/testgeometry.c

@@ -95,13 +95,13 @@ static void loop(void)
                 }
             }
         } else if (event.type == SDL_EVENT_KEY_DOWN) {
-            if (event.key.keysym.sym == SDLK_LEFT) {
+            if (event.key.key == SDLK_LEFT) {
                 translate_cx -= 1;
-            } else if (event.key.keysym.sym == SDLK_RIGHT) {
+            } else if (event.key.key == SDLK_RIGHT) {
                 translate_cx += 1;
-            } else if (event.key.keysym.sym == SDLK_UP) {
+            } else if (event.key.key == SDLK_UP) {
                 translate_cy -= 1;
-            } else if (event.key.keysym.sym == SDLK_DOWN) {
+            } else if (event.key.key == SDLK_DOWN) {
                 translate_cy += 1;
             } else {
                 SDLTest_CommonEvent(state, &event, &done);

test/testgl.c

@@ -391,10 +391,10 @@ int main(int argc, char *argv[])
         while (SDL_PollEvent(&event)) {
             SDLTest_CommonEvent(state, &event, &done);
             if (event.type == SDL_EVENT_KEY_DOWN) {
-                if (event.key.keysym.sym == SDLK_o) {
+                if (event.key.key == SDLK_o) {
                     swap_interval--;
                     update_swap_interval = SDL_TRUE;
-                } else if (event.key.keysym.sym == SDLK_p) {
+                } else if (event.key.key == SDLK_p) {
                     swap_interval++;
                     update_swap_interval = SDL_TRUE;
                 }

test/testgles2_sdf.c

@@ -337,7 +337,7 @@ static void loop(void)
         switch (event.type) {
         case SDL_EVENT_KEY_DOWN:
         {
-            const int sym = event.key.keysym.sym;
+            const int sym = event.key.key;
 
             if (sym == SDLK_TAB) {
                 SDL_Log("Tab");

test/testhittesting.c

@@ -137,9 +137,9 @@ int main(int argc, char **argv)
                 break;
 
             case SDL_EVENT_KEY_DOWN:
-                if (e.key.keysym.sym == SDLK_ESCAPE) {
+                if (e.key.key == SDLK_ESCAPE) {
                     done = 1;
-                } else if (e.key.keysym.sym == SDLK_x) {
+                } else if (e.key.key == SDLK_x) {
                     if (!areas) {
                         areas = drag_areas;
                         numareas = SDL_arraysize(drag_areas);

test/testime.c

@@ -699,7 +699,7 @@ int main(int argc, char *argv[])
             SDLTest_CommonEvent(state, &event, &done);
             switch (event.type) {
             case SDL_EVENT_KEY_DOWN:
-                switch (event.key.keysym.sym) {
+                switch (event.key.key) {
                 case SDLK_RETURN:
                     text[0] = 0x00;
                     Redraw();
@@ -742,10 +742,10 @@ int main(int argc, char *argv[])
                 }
 
                 SDL_Log("Keyboard: scancode 0x%08X = %s, keycode 0x%08" SDL_PRIX32 " = %s\n",
-                        event.key.keysym.scancode,
-                        SDL_GetScancodeName(event.key.keysym.scancode),
-                        SDL_static_cast(Uint32, event.key.keysym.sym),
-                        SDL_GetKeyName(event.key.keysym.sym));
+                        event.key.scancode,
+                        SDL_GetScancodeName(event.key.scancode),
+                        SDL_static_cast(Uint32, event.key.key),
+                        SDL_GetKeyName(event.key.key));
                 break;
 
             case SDL_EVENT_TEXT_INPUT:

test/testintersections.c

@@ -225,9 +225,9 @@ static void loop(void *arg)
             }
             break;
         case SDL_EVENT_KEY_DOWN:
-            switch (event.key.keysym.sym) {
+            switch (event.key.key) {
             case 'l':
-                if (event.key.keysym.mod & SDL_KMOD_SHIFT) {
+                if (event.key.mod & SDL_KMOD_SHIFT) {
                     num_lines = 0;
                 } else {
                     add_line(
@@ -238,7 +238,7 @@ static void loop(void *arg)
                 }
                 break;
             case 'r':
-                if (event.key.keysym.mod & SDL_KMOD_SHIFT) {
+                if (event.key.mod & SDL_KMOD_SHIFT) {
                     num_rects = 0;
                 } else {
                     add_rect(

test/testmanymouse.c

@@ -391,7 +391,7 @@ static void HandleKeyboardKeyDown(SDL_KeyboardEvent *event)
             continue;
         }
         if (event->which == keyboard_state->instance_id) {
-            switch (event->keysym.sym) {
+            switch (event->key) {
             case SDLK_LEFT:
                 keyboard_state->position.x -= CURSOR_SIZE;
                 if (keyboard_state->position.x < 0.0f) {

test/testmodal.c

@@ -91,25 +91,25 @@ int main(int argc, char *argv[])
                     w1 = NULL;
                 }
             } else if (e.type == SDL_EVENT_KEY_DOWN) {
-                if ((e.key.keysym.sym == SDLK_m || e.key.keysym.sym == SDLK_n) && !w2) {
+                if ((e.key.key == SDLK_m || e.key.key == SDLK_n) && !w2) {
                     if (SDL_CreateWindowAndRenderer("Non-Modal Window", 320, 200, SDL_WINDOW_HIDDEN, &w2, &r2) < 0) {
                         SDL_Log("Failed to create modal window and/or renderer: %s\n", SDL_GetError());
                         exit_code = 1;
                         goto sdl_quit;
                     }
 
-                    if (e.key.keysym.sym == SDLK_m) {
+                    if (e.key.key == SDLK_m) {
                         if (!SDL_SetWindowModalFor(w2, w1)) {
                             SDL_SetWindowTitle(w2, "Modal Window");
                         }
                     }
                     SDL_ShowWindow(w2);
-                } else if (e.key.keysym.sym == SDLK_ESCAPE && w2) {
+                } else if (e.key.key == SDLK_ESCAPE && w2) {
                     SDL_DestroyWindow(w2);
                     r2 = NULL;
                     w2 = NULL;
-                } else if (e.key.keysym.sym == SDLK_h) {
-                    if (e.key.keysym.mod & SDL_KMOD_CTRL) {
+                } else if (e.key.key == SDLK_h) {
+                    if (e.key.mod & SDL_KMOD_CTRL) {
                         /* Hide the parent, which should hide the modal too. */
                         show_deadline = SDL_GetTicksNS() + SDL_SECONDS_TO_NS(3);
                         SDL_HideWindow(w1);
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
                             SDL_HideWindow(w2);
                         }
                     }
-                } else if (e.key.keysym.sym == SDLK_p && w2) {
+                } else if (e.key.key == SDLK_p && w2) {
                     if (SDL_GetWindowFlags(w2) & SDL_WINDOW_MODAL) {
                         /* Unparent the window */
                         if (!SDL_SetWindowModalFor(w2, NULL)) {

test/testmouse.c

@@ -211,14 +211,14 @@ static void loop(void *arg)
             break;
 
         case SDL_EVENT_KEY_DOWN:
-            if (event.key.keysym.sym == SDLK_c) {
+            if (event.key.key == SDLK_c) {
                 int x, y, w, h;
                 SDL_GetWindowPosition(window, &x, &y);
                 SDL_GetWindowSize(window, &w, &h);
                 w /= 2;
                 h /= 2;
 
-                if (event.key.keysym.mod & SDL_KMOD_ALT) {
+                if (event.key.mod & SDL_KMOD_ALT) {
                     SDL_WarpMouseGlobal((float)(x + w), (float)(y + h));
                 } else {
                     SDL_WarpMouseInWindow(window, (float)w, (float)h);
@@ -226,7 +226,7 @@ static void loop(void *arg)
             }
             SDL_FALLTHROUGH;
         case SDL_EVENT_KEY_UP:
-            switch (event.key.keysym.sym) {
+            switch (event.key.key) {
             case SDLK_LSHIFT:
                 isRect = (event.key.state == SDL_PRESSED);
                 if (active) {

test/testoverlay.c

@@ -275,11 +275,11 @@ static void loop(void)
             }
             break;
         case SDL_EVENT_KEY_DOWN:
-            if (event.key.keysym.sym == SDLK_SPACE) {
+            if (event.key.key == SDLK_SPACE) {
                 paused = !paused;
                 break;
             }
-            if (event.key.keysym.sym != SDLK_ESCAPE) {
+            if (event.key.key != SDLK_ESCAPE) {
                 break;
             }
             break;

test/testpopup.c

@@ -171,7 +171,7 @@ static void loop(void)
                 }
             }
         } else if (event.type == SDL_EVENT_KEY_DOWN) {
-            if (event.key.keysym.sym == SDLK_SPACE) {
+            if (event.key.key == SDLK_SPACE) {
                 for (i = 0; i < num_menus; ++i) {
                     if (SDL_GetWindowFlags(menus[i].win) & SDL_WINDOW_HIDDEN) {
                         SDL_ShowWindow(menus[i].win);

test/testshader.c

@@ -532,10 +532,10 @@ int main(int argc, char **argv)
                     done = 1;
                 }
                 if (event.type == SDL_EVENT_KEY_DOWN) {
-                    if (event.key.keysym.sym == SDLK_SPACE) {
+                    if (event.key.key == SDLK_SPACE) {
                         current_shader = (current_shader + 1) % NUM_SHADERS;
                     }
-                    if (event.key.keysym.sym == SDLK_ESCAPE) {
+                    if (event.key.key == SDLK_ESCAPE) {
                         done = 1;
                     }
                 }

test/testshape.c

@@ -111,7 +111,7 @@ int main(int argc, char *argv[])
         while (SDL_PollEvent(&event)) {
             switch (event.type) {
             case SDL_EVENT_KEY_DOWN:
-                if (event.key.keysym.sym == SDLK_ESCAPE) {
+                if (event.key.key == SDLK_ESCAPE) {
                     done = SDL_TRUE;
                 }
                 break;

test/teststreaming.c

@@ -107,7 +107,7 @@ static void loop(void)
     while (SDL_PollEvent(&event)) {
         switch (event.type) {
         case SDL_EVENT_KEY_DOWN:
-            if (event.key.keysym.sym == SDLK_ESCAPE) {
+            if (event.key.key == SDLK_ESCAPE) {
                 done = SDL_TRUE;
             }
             break;

test/testtime.c

@@ -176,7 +176,7 @@ int main(int argc, char *argv[])
         while (SDL_PollEvent(&event)) {
             SDLTest_CommonEvent(state, &event, &done);
             if (event.type == SDL_EVENT_KEY_DOWN) {
-                switch (event.key.keysym.sym) {
+                switch (event.key.key) {
                 case SDLK_UP:
                     if (++cal_month > 12) {
                         cal_month = 1;

test/testwaylandcustom.c

@@ -260,13 +260,13 @@ int main(int argc, char **argv)
         SDL_Event event;
         while (SDL_PollEvent(&event)) {
             if (event.type == SDL_EVENT_KEY_DOWN) {
-                switch (event.key.keysym.sym) {
+                switch (event.key.key) {
                 case SDLK_ESCAPE:
                     done = 1;
                     break;
                 case SDLK_EQUALS:
                     /* Ctrl+ enlarges the window */
-                    if (event.key.keysym.mod & SDL_KMOD_CTRL) {
+                    if (event.key.mod & SDL_KMOD_CTRL) {
                         int w, h;
                         SDL_GetWindowSize(window, &w, &h);
                         SDL_SetWindowSize(window, w * 2, h * 2);
@@ -274,7 +274,7 @@ int main(int argc, char **argv)
                     break;
                 case SDLK_MINUS:
                     /* Ctrl- shrinks the window */
-                    if (event.key.keysym.mod & SDL_KMOD_CTRL) {
+                    if (event.key.mod & SDL_KMOD_CTRL) {
                         int w, h;
                         SDL_GetWindowSize(window, &w, &h);
                         SDL_SetWindowSize(window, w / 2, h / 2);

test/testwm.c

@@ -189,15 +189,15 @@ static void loop(void)
         if (event.type == SDL_EVENT_KEY_UP) {
             SDL_bool updateCursor = SDL_FALSE;
 
-            if (event.key.keysym.sym == SDLK_a) {
+            if (event.key.key == SDLK_a) {
                 SDL_assert(!"Keyboard generated assert");
-            } else if (event.key.keysym.sym == SDLK_LEFT) {
+            } else if (event.key.key == SDLK_LEFT) {
                 --system_cursor;
                 if (system_cursor < 0) {
                     system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
                 }
                 updateCursor = SDL_TRUE;
-            } else if (event.key.keysym.sym == SDLK_RIGHT) {
+            } else if (event.key.key == SDLK_RIGHT) {
                 ++system_cursor;
                 if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
                     system_cursor = 0;

test/testyuv.c

@@ -507,11 +507,11 @@ int main(int argc, char **argv)
                     done = 1;
                 }
                 if (event.type == SDL_EVENT_KEY_DOWN) {
-                    if (event.key.keysym.sym == SDLK_ESCAPE) {
+                    if (event.key.key == SDLK_ESCAPE) {
                         done = 1;
-                    } else if (event.key.keysym.sym == SDLK_LEFT) {
+                    } else if (event.key.key == SDLK_LEFT) {
                         --current;
-                    } else if (event.key.keysym.sym == SDLK_RIGHT) {
+                    } else if (event.key.key == SDLK_RIGHT) {
                         ++current;
                     }
                 }