Merge 3513e5c906 into 5800b874d7

Add MAIN_WII_KEYBOARD_TRANSLATION to toggle the layout translation

Source/Core/Common/CMakeLists.txt

@@ -95,6 +95,8 @@ add_library(common
   JitRegister.h
   JsonUtil.h
   JsonUtil.cpp
+  Keyboard.h
+  Keyboard.cpp
   Lazy.h
   LinearDiskCache.h
   Logging/ConsoleListener.h
@@ -350,6 +352,11 @@ if(OPROFILE_FOUND)
   target_link_libraries(common PRIVATE OProfile::OProfile)
 endif()
 
+if(ENABLE_SDL)
+  target_link_libraries(common PRIVATE SDL2::SDL2)
+  target_compile_definitions(common PRIVATE -DHAVE_SDL2)
+endif()
+
 if(ENABLE_LLVM)
   find_package(LLVM CONFIG)
   if(LLVM_FOUND)

Source/Core/Common/Keyboard.cpp

@@ -0,0 +1,326 @@
+// Copyright 2025 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "Common/Keyboard.h"
+
+#include <array>
+#include <map>
+#include <mutex>
+#include <utility>
+
+#ifdef HAVE_SDL2
+#include <SDL_events.h>
+#include <SDL_keyboard.h>
+
+// Will be overridden by Dolphin's SDL InputBackend
+u32 Common::KeyboardContext::s_sdl_init_event_type(-1);
+u32 Common::KeyboardContext::s_sdl_update_event_type(-1);
+u32 Common::KeyboardContext::s_sdl_quit_event_type(-1);
+#endif
+
+#include "Core/Config/MainSettings.h"
+#include "Core/Config/SYSCONFSettings.h"
+#include "DiscIO/Enums.h"
+
+namespace
+{
+// Translate HID usage ID based on the host and the game keyboard layout:
+//  - we need to take into account the host layout as we receive raw scan codes
+//  - we need to consider the game layout as it might be different from the host one
+u8 TranslateUsageID(u8 usage_id, int host_layout, int game_layout)
+{
+  if (host_layout == game_layout)
+    return usage_id;
+
+  // Currently, the translation is partial (i.e. alpha only)
+  if (usage_id != Common::HIDUsageID::M_AZERTY &&
+      (usage_id < Common::HIDUsageID::A || usage_id > Common::HIDUsageID::Z))
+  {
+    return usage_id;
+  }
+
+  switch (host_layout | game_layout)
+  {
+  case Common::KeyboardLayout::AZERTY_QWERTZ:
+  {
+    static const std::map<u8, u8> TO_QWERTZ{
+        {Common::HIDUsageID::A_AZERTY, Common::HIDUsageID::A},
+        {Common::HIDUsageID::Z_AZERTY, Common::HIDUsageID::Z_QWERTZ},
+        {Common::HIDUsageID::Y, Common::HIDUsageID::Y_QWERTZ},
+        {Common::HIDUsageID::Q_AZERTY, Common::HIDUsageID::Q},
+        {Common::HIDUsageID::M_AZERTY, Common::HIDUsageID::M},
+        {Common::HIDUsageID::W_AZERTY, Common::HIDUsageID::W},
+        {Common::HIDUsageID::M, Common::HIDUsageID::M_AZERTY},
+    };
+    static const std::map<u8, u8> TO_AZERTY{
+        {Common::HIDUsageID::Q, Common::HIDUsageID::Q_AZERTY},
+        {Common::HIDUsageID::W, Common::HIDUsageID::W_AZERTY},
+        {Common::HIDUsageID::Z_QWERTZ, Common::HIDUsageID::Z_AZERTY},
+        {Common::HIDUsageID::A, Common::HIDUsageID::A_AZERTY},
+        {Common::HIDUsageID::M_AZERTY, Common::HIDUsageID::M},
+        {Common::HIDUsageID::Y_QWERTZ, Common::HIDUsageID::Y},
+        {Common::HIDUsageID::M, Common::HIDUsageID::M_AZERTY},
+    };
+    const auto& map = game_layout == Common::KeyboardLayout::QWERTZ ? TO_QWERTZ : TO_AZERTY;
+    if (const auto it{map.find(usage_id)}; it != map.end())
+      return it->second;
+    break;
+  }
+  case Common::KeyboardLayout::QWERTY_AZERTY:
+  {
+    static constexpr std::array<std::pair<u8, u8>, 3> BI_MAP{
+        {{Common::HIDUsageID::Q, Common::HIDUsageID::A},
+         {Common::HIDUsageID::W, Common::HIDUsageID::Z},
+         {Common::HIDUsageID::M, Common::HIDUsageID::M_AZERTY}}};
+    for (const auto& [a, b] : BI_MAP)
+    {
+      if (usage_id == a)
+        return b;
+      else if (usage_id == b)
+        return a;
+    }
+    break;
+  }
+  case Common::KeyboardLayout::QWERTY_QWERTZ:
+  {
+    if (usage_id == Common::HIDUsageID::Y)
+      return Common::HIDUsageID::Z;
+    else if (usage_id == Common::HIDUsageID::Z)
+      return Common::HIDUsageID::Y;
+    break;
+  }
+  default:
+    // Shouldn't happen
+    break;
+  }
+  return usage_id;
+}
+
+int GetHostLayout()
+{
+  const int layout = Config::Get(Config::MAIN_WII_KEYBOARD_HOST_LAYOUT);
+  if (layout != Common::KeyboardLayout::AUTO)
+    return layout;
+
+#ifdef HAVE_SDL2
+  if (const SDL_Keycode key_code = SDL_GetKeyFromScancode(SDL_SCANCODE_Y); key_code == SDLK_z)
+  {
+    return Common::KeyboardLayout::QWERTZ;
+  }
+  if (const SDL_Keycode key_code = SDL_GetKeyFromScancode(SDL_SCANCODE_Q); key_code == SDLK_a)
+  {
+    return Common::KeyboardLayout::AZERTY;
+  }
+#endif
+
+  return Common::KeyboardLayout::QWERTY;
+}
+
+int GetGameLayout()
+{
+  const int layout = Config::Get(Config::MAIN_WII_KEYBOARD_GAME_LAYOUT);
+  if (layout != Common::KeyboardLayout::AUTO)
+    return layout;
+
+  const DiscIO::Language language =
+      static_cast<DiscIO::Language>(Config::Get(Config::SYSCONF_LANGUAGE));
+  switch (language)
+  {
+  case DiscIO::Language::French:
+    return Common::KeyboardLayout::AZERTY;
+  case DiscIO::Language::German:
+    return Common::KeyboardLayout::QWERTZ;
+  default:
+    return Common::KeyboardLayout::QWERTY;
+  }
+}
+
+u8 MapVirtualKeyToHID(u8 virtual_key, int host_layout, int game_layout)
+{
+  // SDL2 keyboard state uses scan codes already based on HID usage id
+  u8 usage_id = virtual_key;
+  if (Config::Get(Config::MAIN_WII_KEYBOARD_TRANSLATION))
+    usage_id = TranslateUsageID(usage_id, host_layout, game_layout);
+  return usage_id;
+}
+
+std::weak_ptr<Common::KeyboardContext> s_keyboard_context;
+std::mutex s_keyboard_context_mutex;
+
+// Will be updated by DolphinQt's Host:
+//  - SetRenderHandle
+//  - SetFullscreen
+Common::KeyboardContext::HandlerState s_handler_state{};
+}  // Anonymous namespace
+
+namespace Common
+{
+KeyboardContext::KeyboardContext()
+{
+  if (Config::Get(Config::MAIN_WII_KEYBOARD))
+    Init();
+}
+
+KeyboardContext::~KeyboardContext()
+{
+  if (Config::Get(Config::MAIN_WII_KEYBOARD))
+    Quit();
+}
+
+void KeyboardContext::Init()
+{
+#ifdef HAVE_SDL2
+  SDL_Event event{s_sdl_init_event_type};
+  SDL_PushEvent(&event);
+  m_keyboard_state = SDL_GetKeyboardState(nullptr);
+#endif
+  UpdateLayout();
+  m_is_ready = true;
+}
+
+void KeyboardContext::Quit()
+{
+  m_is_ready = false;
+#ifdef HAVE_SDL2
+  SDL_Event event{s_sdl_quit_event_type};
+  SDL_PushEvent(&event);
+#endif
+}
+
+const void* KeyboardContext::HandlerState::GetHandle() const
+{
+  if (is_rendering_to_main && !is_fullscreen)
+    return main_handle;
+  return renderer_handle;
+}
+
+void KeyboardContext::NotifyInit()
+{
+  if (auto self = s_keyboard_context.lock())
+    self->Init();
+}
+
+void KeyboardContext::NotifyHandlerChanged(const KeyboardContext::HandlerState& state)
+{
+  s_handler_state = state;
+  if (s_keyboard_context.expired())
+    return;
+#ifdef HAVE_SDL2
+  SDL_Event event{s_sdl_update_event_type};
+  SDL_PushEvent(&event);
+#endif
+}
+
+void KeyboardContext::NotifyQuit()
+{
+  if (auto self = s_keyboard_context.lock())
+    self->Quit();
+}
+
+void KeyboardContext::UpdateLayout()
+{
+  if (auto self = s_keyboard_context.lock())
+  {
+    self->m_host_layout = GetHostLayout();
+    self->m_game_layout = GetGameLayout();
+  }
+}
+
+const void* KeyboardContext::GetWindowHandle()
+{
+  return s_handler_state.GetHandle();
+}
+
+std::shared_ptr<KeyboardContext> KeyboardContext::GetInstance()
+{
+  const std::lock_guard guard(s_keyboard_context_mutex);
+  std::shared_ptr<KeyboardContext> ptr = s_keyboard_context.lock();
+  if (!ptr)
+  {
+    ptr = std::shared_ptr<KeyboardContext>(new KeyboardContext);
+    s_keyboard_context = ptr;
+  }
+  return ptr;
+}
+
+HIDPressedState KeyboardContext::GetPressedState() const
+{
+  return m_is_ready ? HIDPressedState{.modifiers = PollHIDModifiers(),
+                                      .pressed_keys = PollHIDPressedKeys()} :
+                      HIDPressedState{};
+}
+
+bool KeyboardContext::IsVirtualKeyPressed(int virtual_key) const
+{
+#ifdef HAVE_SDL2
+  if (virtual_key >= SDL_NUM_SCANCODES)
+    return false;
+  return m_keyboard_state[virtual_key] == 1;
+#else
+  // TODO: Android implementation
+  return false;
+#endif
+}
+
+u8 KeyboardContext::PollHIDModifiers() const
+{
+  u8 modifiers = 0;
+
+  using VkHidPair = std::pair<int, u8>;
+
+  // References:
+  // https://wiki.libsdl.org/SDL2/SDL_Scancode
+  // https://www.usb.org/document-library/device-class-definition-hid-111
+  //
+  // HID modifier: Bit 0 - LEFT CTRL
+  // HID modifier: Bit 1 - LEFT SHIFT
+  // HID modifier: Bit 2 - LEFT ALT
+  // HID modifier: Bit 3 - LEFT GUI
+  // HID modifier: Bit 4 - RIGHT CTRL
+  // HID modifier: Bit 5 - RIGHT SHIFT
+  // HID modifier: Bit 6 - RIGHT ALT
+  // HID modifier: Bit 7 - RIGHT GUI
+  static const std::vector<VkHidPair> MODIFIERS_MAP{
+#ifdef HAVE_SDL2
+      {SDL_SCANCODE_LCTRL, 0x01}, {SDL_SCANCODE_LSHIFT, 0x02}, {SDL_SCANCODE_LALT, 0x04},
+      {SDL_SCANCODE_LGUI, 0x08},  {SDL_SCANCODE_RCTRL, 0x10},  {SDL_SCANCODE_RSHIFT, 0x20},
+      {SDL_SCANCODE_RALT, 0x40},  {SDL_SCANCODE_RGUI, 0x80}
+#else
+  // TODO: Android implementation
+#endif
+  };
+
+  for (const auto& [virtual_key, hid_modifier] : MODIFIERS_MAP)
+  {
+    if (IsVirtualKeyPressed(virtual_key))
+      modifiers |= hid_modifier;
+  }
+
+  return modifiers;
+}
+
+HIDPressedKeys KeyboardContext::PollHIDPressedKeys() const
+{
+  HIDPressedKeys pressed_keys{};
+  auto it = pressed_keys.begin();
+
+#ifdef HAVE_SDL2
+  const std::size_t begin = SDL_SCANCODE_A;
+  const std::size_t end = SDL_SCANCODE_LCTRL;
+#else
+  const std::size_t begin = 0;
+  const std::size_t end = 0;
+#endif
+
+  for (std::size_t virtual_key = begin; virtual_key < end; ++virtual_key)
+  {
+    if (!IsVirtualKeyPressed(static_cast<int>(virtual_key)))
+      continue;
+
+    *it = MapVirtualKeyToHID(static_cast<u8>(virtual_key), m_host_layout, m_game_layout);
+    if (++it == pressed_keys.end())
+      break;
+  }
+  return pressed_keys;
+}
+}  // namespace Common

Source/Core/Common/Keyboard.h

@@ -0,0 +1,126 @@
+// Copyright 2025 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+
+#include "Common/CommonTypes.h"
+
+namespace Common
+{
+namespace HIDUsageID
+{
+// See HID Usage Tables - Keyboard (0x07):
+// https://usb.org/sites/default/files/hut1_21.pdf
+enum
+{
+  A = 0x04,
+  B,
+  C,
+  D,
+  E,
+  F,
+  G,
+  H,
+  I,
+  J,
+  K,
+  L,
+  M,
+  N,
+  O,
+  P,
+  Q,
+  R,
+  S,
+  T,
+  U,
+  V,
+  W,
+  X,
+  Y,
+  Z,
+  COLON = 0x33,
+  A_AZERTY = Q,
+  M_AZERTY = COLON,
+  Q_AZERTY = A,
+  W_AZERTY = Z,
+  Z_AZERTY = W,
+  Y_QWERTZ = Z,
+  Z_QWERTZ = Y,
+};
+}  // namespace HIDUsageID
+
+namespace KeyboardLayout
+{
+enum
+{
+  AUTO = 0,
+  QWERTY = 1,
+  AZERTY = 2,
+  QWERTZ = 4,
+  // Translation
+  QWERTY_AZERTY = QWERTY | AZERTY,
+  QWERTY_QWERTZ = QWERTY | QWERTZ,
+  AZERTY_QWERTZ = AZERTY | QWERTZ
+};
+}
+using HIDPressedKeys = std::array<u8, 6>;
+
+struct HIDPressedState
+{
+  u8 modifiers = 0;
+  HIDPressedKeys pressed_keys{};
+
+  auto operator<=>(const HIDPressedState&) const = default;
+};
+
+class KeyboardContext
+{
+public:
+  ~KeyboardContext();
+
+  struct HandlerState
+  {
+    const void* main_handle = nullptr;
+    const void* renderer_handle = nullptr;
+    bool is_fullscreen = false;
+    bool is_rendering_to_main = false;
+
+    const void* GetHandle() const;
+  };
+
+  static void NotifyInit();
+  static void NotifyHandlerChanged(const HandlerState& state);
+  static void NotifyQuit();
+  static void UpdateLayout();
+  static const void* GetWindowHandle();
+  static std::shared_ptr<KeyboardContext> GetInstance();
+
+  HIDPressedState GetPressedState() const;
+
+#ifdef HAVE_SDL2
+  static u32 s_sdl_init_event_type;
+  static u32 s_sdl_update_event_type;
+  static u32 s_sdl_quit_event_type;
+#endif
+
+private:
+  KeyboardContext();
+
+  void Init();
+  void Quit();
+  bool IsVirtualKeyPressed(int virtual_key) const;
+  u8 PollHIDModifiers() const;
+  HIDPressedKeys PollHIDPressedKeys() const;
+
+  bool m_is_ready = false;
+  int m_host_layout = KeyboardLayout::AUTO;
+  int m_game_layout = KeyboardLayout::AUTO;
+#ifdef HAVE_SDL2
+  const u8* m_keyboard_state = nullptr;
+#endif
+};
+}  // namespace Common

Source/Core/Core/Config/MainSettings.cpp

@@ -189,6 +189,10 @@ const Info<bool> MAIN_WII_SD_CARD_ENABLE_FOLDER_SYNC{
     {System::Main, "Core", "WiiSDCardEnableFolderSync"}, false};
 const Info<u64> MAIN_WII_SD_CARD_FILESIZE{{System::Main, "Core", "WiiSDCardFilesize"}, 0};
 const Info<bool> MAIN_WII_KEYBOARD{{System::Main, "Core", "WiiKeyboard"}, false};
+const Info<int> MAIN_WII_KEYBOARD_HOST_LAYOUT{{System::Main, "Core", "WiiKeyboardHostLayout"}, 0};
+const Info<int> MAIN_WII_KEYBOARD_GAME_LAYOUT{{System::Main, "Core", "WiiKeyboardGameLayout"}, 0};
+const Info<bool> MAIN_WII_KEYBOARD_TRANSLATION{{System::Main, "Core", "WiiKeyboardTranslation"},
+                                               false};
 const Info<bool> MAIN_WIIMOTE_CONTINUOUS_SCANNING{
     {System::Main, "Core", "WiimoteContinuousScanning"}, false};
 const Info<std::string> MAIN_WIIMOTE_AUTO_CONNECT_ADDRESSES{

Source/Core/Core/Config/MainSettings.h

@@ -107,6 +107,9 @@ extern const Info<bool> MAIN_WII_SD_CARD;
 extern const Info<bool> MAIN_WII_SD_CARD_ENABLE_FOLDER_SYNC;
 extern const Info<u64> MAIN_WII_SD_CARD_FILESIZE;
 extern const Info<bool> MAIN_WII_KEYBOARD;
+extern const Info<int> MAIN_WII_KEYBOARD_HOST_LAYOUT;
+extern const Info<int> MAIN_WII_KEYBOARD_GAME_LAYOUT;
+extern const Info<bool> MAIN_WII_KEYBOARD_TRANSLATION;
 extern const Info<bool> MAIN_WIIMOTE_CONTINUOUS_SCANNING;
 extern const Info<std::string> MAIN_WIIMOTE_AUTO_CONNECT_ADDRESSES;
 extern const Info<bool> MAIN_WIIMOTE_ENABLE_SPEAKER;

Source/Core/Core/IOS/USB/USB_KBD.cpp

@@ -3,9 +3,6 @@
 
 #include "Core/IOS/USB/USB_KBD.h"
 
-#include <array>
-#include <queue>
-
 #include "Common/FileUtil.h"
 #include "Common/IniFile.h"
 #include "Common/Logging/Log.h"
@@ -16,169 +13,11 @@
 #include "Core/System.h"
 #include "InputCommon/ControlReference/ControlReference.h"  // For background input check
 
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
 namespace IOS::HLE
 {
-namespace
-{
-// Crazy ugly
-#ifdef _WIN32
-constexpr std::array<u8, 256> s_key_codes_qwerty{
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2A,  // Backspace
-    0x2B,  // Tab
-    0x00, 0x00,
-    0x00,  // Clear
-    0x28,  // Return
-    0x00, 0x00,
-    0x00,  // Shift
-    0x00,  // Control
-    0x00,  // ALT
-    0x48,  // Pause
-    0x39,  // Capital
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x29,  // Escape
-    0x00, 0x00, 0x00, 0x00,
-    0x2C,  // Space
-    0x4B,  // Prior
-    0x4E,  // Next
-    0x4D,  // End
-    0x4A,  // Home
-    0x50,  // Left
-    0x52,  // Up
-    0x4F,  // Right
-    0x51,  // Down
-    0x00, 0x00, 0x00,
-    0x46,  // Print screen
-    0x49,  // Insert
-    0x4C,  // Delete
-    0x00,
-    // 0 -> 9
-    0x27, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00,
-    // A -> Z
-    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
-    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // Numpad 0 -> 9
-    0x62, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61,
-    0x55,  // Multiply
-    0x57,  // Add
-    0x00,  // Separator
-    0x56,  // Subtract
-    0x63,  // Decimal
-    0x54,  // Divide
-    // F1 -> F12
-    0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-    // F13 -> F24
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x53,  // Numlock
-    0x47,  // Scroll lock
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // Modifier keys
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x33,  // ';'
-    0x2E,  // Plus
-    0x36,  // Comma
-    0x2D,  // Minus
-    0x37,  // Period
-    0x38,  // '/'
-    0x35,  // '~'
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2F,  // '['
-    0x32,  // '\'
-    0x30,  // ']'
-    0x34,  // '''
-    0x00,  //
-    0x00,  // Nothing interesting past this point.
-};
-
-constexpr std::array<u8, 256> s_key_codes_azerty{
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2A,  // Backspace
-    0x2B,  // Tab
-    0x00, 0x00,
-    0x00,  // Clear
-    0x28,  // Return
-    0x00, 0x00,
-    0x00,  // Shift
-    0x00,  // Control
-    0x00,  // ALT
-    0x48,  // Pause
-    0x39,  // Capital
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x29,  // Escape
-    0x00, 0x00, 0x00, 0x00,
-    0x2C,  // Space
-    0x4B,  // Prior
-    0x4E,  // Next
-    0x4D,  // End
-    0x4A,  // Home
-    0x50,  // Left
-    0x52,  // Up
-    0x4F,  // Right
-    0x51,  // Down
-    0x00, 0x00, 0x00,
-    0x46,  // Print screen
-    0x49,  // Insert
-    0x4C,  // Delete
-    0x00,
-    // 0 -> 9
-    0x27, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00,
-    // A -> Z
-    0x14, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x33, 0x11, 0x12, 0x13,
-    0x04, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1D, 0x1B, 0x1C, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // Numpad 0 -> 9
-    0x62, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61,
-    0x55,  // Multiply
-    0x57,  // Add
-    0x00,  // Separator
-    0x56,  // Substract
-    0x63,  // Decimal
-    0x54,  // Divide
-    // F1 -> F12
-    0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
-    // F13 -> F24
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00,
-    0x53,  // Numlock
-    0x47,  // Scroll lock
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // Modifier keys
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x30,  // '$'
-    0x2E,  // Plus
-    0x10,  // Comma
-    0x00,  // Minus
-    0x36,  // Period
-    0x37,  // '/'
-    0x34,  // ' '
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x2D,  // ')'
-    0x32,  // '\'
-    0x2F,  // '^'
-    0x00,  // ' '
-    0x38,  // '!'
-    0x00,  // Nothing interesting past this point.
-};
-#else
-constexpr std::array<u8, 256> s_key_codes_qwerty{};
-
-constexpr std::array<u8, 256> s_key_codes_azerty{};
-#endif
-}  // Anonymous namespace
-
-USB_KBD::MessageData::MessageData(MessageType type, u8 modifiers_, PressedKeyData pressed_keys_)
-    : msg_type{Common::swap32(static_cast<u32>(type))}, modifiers{modifiers_},
-      pressed_keys{pressed_keys_}
+USB_KBD::MessageData::MessageData(MessageType type, const Common::HIDPressedState& state)
+    : msg_type{Common::swap32(static_cast<u32>(type))}, modifiers{state.modifiers},
+      pressed_keys{state.pressed_keys}
 {
 }
 
@@ -192,18 +31,24 @@ USB_KBD::USB_KBD(EmulationKernel& ios, const std::string& device_name)
 std::optional<IPCReply> USB_KBD::Open(const OpenRequest& request)
 {
   INFO_LOG_FMT(IOS, "USB_KBD: Open");
-  Common::IniFile ini;
-  ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
-  ini.GetOrCreateSection("USB Keyboard")->Get("Layout", &m_keyboard_layout, KBD_LAYOUT_QWERTY);
 
   m_message_queue = {};
-  m_old_key_buffer.fill(false);
-  m_old_modifiers = 0x00;
+  m_previous_state = {};
+  m_keyboard_context = Common::KeyboardContext::GetInstance();
 
-  // m_message_queue.emplace(MessageType::KeyboardConnect, 0, PressedKeyData{});
+  // m_message_queue.emplace(MessageType::KeyboardConnect, {});
   return Device::Open(request);
 }
 
+std::optional<IPCReply> USB_KBD::Close(u32 fd)
+{
+  INFO_LOG_FMT(IOS, "USB_KBD: Close");
+
+  m_keyboard_context.reset();
+
+  return Device::Close(fd);
+}
+
 std::optional<IPCReply> USB_KBD::Write(const ReadWriteRequest& request)
 {
   // Stubbed.
@@ -223,91 +68,20 @@ std::optional<IPCReply> USB_KBD::IOCtl(const IOCtlRequest& request)
   return IPCReply(IPC_SUCCESS);
 }
 
-bool USB_KBD::IsKeyPressed(int key) const
-{
-#ifdef _WIN32
-  return (GetAsyncKeyState(key) & 0x8000) != 0;
-#else
-  // TODO: do it for non-Windows platforms
-  return false;
-#endif
-}
-
 void USB_KBD::Update()
 {
-  if (!Config::Get(Config::MAIN_WII_KEYBOARD) || Core::WantsDeterminism() || !m_is_active)
+  if (!Config::Get(Config::MAIN_WII_KEYBOARD) || Core::WantsDeterminism() || !m_is_active ||
+      !m_keyboard_context)
+  {
+    return;
+  }
+
+  const auto current_state = m_keyboard_context->GetPressedState();
+
+  if (current_state == m_previous_state)
     return;
 
-  u8 modifiers = 0x00;
-  PressedKeyData pressed_keys{0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-  bool got_event = false;
-  size_t num_pressed_keys = 0;
-  for (size_t i = 0; i < m_old_key_buffer.size(); i++)
-  {
-    const bool key_pressed_now = IsKeyPressed(static_cast<int>(i));
-    const bool key_pressed_before = m_old_key_buffer[i];
-    u8 key_code = 0;
-
-    if (key_pressed_now ^ key_pressed_before)
-    {
-      if (key_pressed_now)
-      {
-        switch (m_keyboard_layout)
-        {
-        case KBD_LAYOUT_QWERTY:
-          key_code = s_key_codes_qwerty[i];
-          break;
-
-        case KBD_LAYOUT_AZERTY:
-          key_code = s_key_codes_azerty[i];
-          break;
-        }
-
-        if (key_code == 0x00)
-          continue;
-
-        pressed_keys[num_pressed_keys] = key_code;
-
-        num_pressed_keys++;
-        if (num_pressed_keys == pressed_keys.size())
-          break;
-      }
-
-      got_event = true;
-    }
-
-    m_old_key_buffer[i] = key_pressed_now;
-  }
-
-#ifdef _WIN32
-  if (GetAsyncKeyState(VK_LCONTROL) & 0x8000)
-    modifiers |= 0x01;
-  if (GetAsyncKeyState(VK_LSHIFT) & 0x8000)
-    modifiers |= 0x02;
-  if (GetAsyncKeyState(VK_MENU) & 0x8000)
-    modifiers |= 0x04;
-  if (GetAsyncKeyState(VK_LWIN) & 0x8000)
-    modifiers |= 0x08;
-  if (GetAsyncKeyState(VK_RCONTROL) & 0x8000)
-    modifiers |= 0x10;
-  if (GetAsyncKeyState(VK_RSHIFT) & 0x8000)
-    modifiers |= 0x20;
-  // TODO: VK_MENU is for ALT, not for ALT GR (ALT GR seems to work though...)
-  if (GetAsyncKeyState(VK_MENU) & 0x8000)
-    modifiers |= 0x40;
-  if (GetAsyncKeyState(VK_RWIN) & 0x8000)
-    modifiers |= 0x80;
-#else
-// TODO: modifiers for non-Windows platforms
-#endif
-
-  if (modifiers ^ m_old_modifiers)
-  {
-    got_event = true;
-    m_old_modifiers = modifiers;
-  }
-
-  if (got_event)
-    m_message_queue.emplace(MessageType::Event, modifiers, pressed_keys);
+  m_message_queue.emplace(MessageType::Event, current_state);
+  m_previous_state = std::move(current_state);
 }
 }  // namespace IOS::HLE

Source/Core/Core/IOS/USB/USB_KBD.h

@@ -3,12 +3,11 @@
 
 #pragma once
 
-#include <array>
 #include <queue>
 #include <string>
-#include <type_traits>
 
 #include "Common/CommonTypes.h"
+#include "Common/Keyboard.h"
 #include "Core/IOS/Device.h"
 #include "Core/IOS/IOS.h"
 
@@ -20,6 +19,7 @@ public:
   USB_KBD(EmulationKernel& ios, const std::string& device_name);
 
   std::optional<IPCReply> Open(const OpenRequest& request) override;
+  std::optional<IPCReply> Close(u32 fd) override;
   std::optional<IPCReply> Write(const ReadWriteRequest& request) override;
   std::optional<IPCReply> IOCtl(const IOCtlRequest& request) override;
   void Update() override;
@@ -32,8 +32,6 @@ private:
     Event = 2
   };
 
-  using PressedKeyData = std::array<u8, 6>;
-
 #pragma pack(push, 1)
   struct MessageData
   {
@@ -41,26 +39,15 @@ private:
     u32 unk1 = 0;
     u8 modifiers = 0;
     u8 unk2 = 0;
-    PressedKeyData pressed_keys{};
+    Common::HIDPressedKeys pressed_keys{};
 
-    MessageData(MessageType msg_type, u8 modifiers, PressedKeyData pressed_keys);
+    MessageData(MessageType msg_type, const Common::HIDPressedState& state);
   };
   static_assert(std::is_trivially_copyable_v<MessageData>,
                 "MessageData must be trivially copyable, as it's copied into emulated memory.");
 #pragma pack(pop)
   std::queue<MessageData> m_message_queue;
-
-  std::array<bool, 256> m_old_key_buffer{};
-  u8 m_old_modifiers = 0;
-
-  bool IsKeyPressed(int key) const;
-
-  // This stuff should probably die
-  enum
-  {
-    KBD_LAYOUT_QWERTY = 0,
-    KBD_LAYOUT_AZERTY = 1
-  };
-  int m_keyboard_layout = KBD_LAYOUT_QWERTY;
+  Common::HIDPressedState m_previous_state;
+  std::shared_ptr<Common::KeyboardContext> m_keyboard_context;
 };
 }  // namespace IOS::HLE

Source/Core/DolphinLib.props

@@ -133,6 +133,7 @@
     <ClInclude Include="Common\IOFile.h" />
     <ClInclude Include="Common\JitRegister.h" />
     <ClInclude Include="Common\JsonUtil.h" />
+    <ClInclude Include="Common\Keyboard.h" />
     <ClInclude Include="Common\Lazy.h" />
     <ClInclude Include="Common\LdrWatcher.h" />
     <ClInclude Include="Common\LinearDiskCache.h" />
@@ -836,6 +837,7 @@
     <ClCompile Include="Common\IOFile.cpp" />
     <ClCompile Include="Common\JitRegister.cpp" />
     <ClCompile Include="Common\JsonUtil.cpp" />
+    <ClCompile Include="Common\Keyboard.cpp" />
     <ClCompile Include="Common\LdrWatcher.cpp" />
     <ClCompile Include="Common\Logging\ConsoleListenerWin.cpp" />
     <ClCompile Include="Common\Logging\LogManager.cpp" />

Source/Core/DolphinQt/CMakeLists.txt

@@ -247,6 +247,8 @@ add_executable(dolphin-emu
   DiscordHandler.h
   DiscordJoinRequestDialog.cpp
   DiscordJoinRequestDialog.h
+  EmulatedUSB/Keyboard.cpp
+  EmulatedUSB/Keyboard.h
   EmulatedUSB/WiiSpeakWindow.cpp
   EmulatedUSB/WiiSpeakWindow.h
   FIFO/FIFOAnalyzer.cpp

Source/Core/DolphinQt/DolphinQt.vcxproj

@@ -157,6 +157,7 @@
     <ClCompile Include="Debugger\WatchWidget.cpp" />
     <ClCompile Include="DiscordHandler.cpp" />
     <ClCompile Include="DiscordJoinRequestDialog.cpp" />
+    <ClCompile Include="EmulatedUSB\Keyboard.cpp" />
     <ClCompile Include="EmulatedUSB\WiiSpeakWindow.cpp" />
     <ClCompile Include="FIFO\FIFOAnalyzer.cpp" />
     <ClCompile Include="FIFO\FIFOPlayerWindow.cpp" />
@@ -376,6 +377,7 @@
     <QtMoc Include="Debugger\WatchWidget.h" />
     <QtMoc Include="DiscordHandler.h" />
     <QtMoc Include="DiscordJoinRequestDialog.h" />
+    <QtMoc Include="EmulatedUSB\Keyboard.h" />
     <QtMoc Include="EmulatedUSB\WiiSpeakWindow.h" />
     <QtMoc Include="FIFO\FIFOAnalyzer.h" />
     <QtMoc Include="FIFO\FIFOPlayerWindow.h" />

Source/Core/DolphinQt/EmulatedUSB/Keyboard.cpp

@@ -0,0 +1,90 @@
+// Copyright 2025 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "DolphinQt/EmulatedUSB/Keyboard.h"
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QVBoxLayout>
+
+#include "Common/Keyboard.h"
+#include "Core/Config/MainSettings.h"
+#include "DolphinQt/Config/ConfigControls/ConfigBool.h"
+#include "DolphinQt/Settings.h"
+
+KeyboardWindow::KeyboardWindow(QWidget* parent) : QWidget(parent)
+{
+  // i18n: Window for managing the Wii keyboard emulation
+  setWindowTitle(tr("Keyboard Manager"));
+  setObjectName(QStringLiteral("keyboard_manager"));
+  setMinimumSize(QSize(500, 200));
+
+  auto* main_layout = new QVBoxLayout();
+
+  {
+    auto* group = new QGroupBox();
+    auto* hbox_layout = new QHBoxLayout();
+    hbox_layout->setAlignment(Qt::AlignHCenter);
+    auto* checkbox_emulate = new QCheckBox(tr("Emulate USB keyboard"), this);
+    checkbox_emulate->setChecked(Settings::Instance().IsUSBKeyboardConnected());
+    connect(checkbox_emulate, &QCheckBox::toggled, this, &KeyboardWindow::EmulateKeyboard);
+    connect(&Settings::Instance(), &Settings::USBKeyboardConnectionChanged, checkbox_emulate,
+            &QCheckBox::setChecked);
+    hbox_layout->addWidget(checkbox_emulate);
+    group->setLayout(hbox_layout);
+
+    main_layout->addWidget(group);
+  }
+
+  {
+    auto* group = new QGroupBox(tr("Layout Configuration"));
+    auto* grid_layout = new QGridLayout();
+    auto* checkbox_translate =
+        new ConfigBool(tr("Enable partial translation"), Config::MAIN_WII_KEYBOARD_TRANSLATION);
+    grid_layout->addWidget(checkbox_translate, 0, 0, 1, 2, Qt::AlignLeft);
+
+    auto create_combo = [checkbox_translate, grid_layout](int row, const QString& name,
+                                                          const auto& config_info) {
+      grid_layout->addWidget(new QLabel(name), row, 0);
+      auto* combo = new QComboBox();
+
+      combo->addItem(tr("Automatic detection"), Common::KeyboardLayout::AUTO);
+      combo->addItem(QStringLiteral("QWERTY"), Common::KeyboardLayout::QWERTY);
+      combo->addItem(QStringLiteral("AZERTY"), Common::KeyboardLayout::AZERTY);
+      combo->addItem(QStringLiteral("QWERTZ"), Common::KeyboardLayout::QWERTZ);
+      combo->setCurrentIndex(combo->findData(Config::Get(config_info)));
+      combo->setEnabled(checkbox_translate->isChecked());
+
+      connect(combo, &QComboBox::currentIndexChanged, combo, [combo, config_info] {
+        const auto keyboard_layout = combo->currentData();
+        if (!keyboard_layout.isValid())
+          return;
+
+        Config::SetBaseOrCurrent(config_info, keyboard_layout.toInt());
+        Common::KeyboardContext::UpdateLayout();
+      });
+      connect(checkbox_translate, &QCheckBox::toggled, combo, &QComboBox::setEnabled);
+
+      grid_layout->addWidget(combo, row, 1);
+    };
+
+    create_combo(1, tr("Host layout:"), Config::MAIN_WII_KEYBOARD_HOST_LAYOUT);
+    create_combo(2, tr("Game layout:"), Config::MAIN_WII_KEYBOARD_GAME_LAYOUT);
+    group->setLayout(grid_layout);
+
+    main_layout->addWidget(group);
+  }
+
+  setLayout(main_layout);
+}
+
+KeyboardWindow::~KeyboardWindow() = default;
+
+void KeyboardWindow::EmulateKeyboard(bool emulate) const
+{
+  Settings::Instance().SetUSBKeyboardConnected(emulate);
+}

Source/Core/DolphinQt/EmulatedUSB/Keyboard.h

@@ -0,0 +1,17 @@
+// Copyright 2025 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QWidget>
+
+class KeyboardWindow : public QWidget
+{
+  Q_OBJECT
+public:
+  explicit KeyboardWindow(QWidget* parent = nullptr);
+  ~KeyboardWindow() override;
+
+private:
+  void EmulateKeyboard(bool emulate) const;
+};

Source/Core/DolphinQt/Host.cpp

@@ -16,6 +16,7 @@
 #endif
 
 #include "Common/Common.h"
+#include "Common/Keyboard.h"
 
 #include "Core/Config/MainSettings.h"
 #include "Core/ConfigManager.h"
@@ -62,6 +63,11 @@ void Host::SetRenderHandle(void* handle)
 {
   m_render_to_main = Config::Get(Config::MAIN_RENDER_TO_MAIN);
 
+  Common::KeyboardContext::NotifyHandlerChanged({.main_handle = m_main_window_handle.load(),
+                                                 .renderer_handle = handle,
+                                                 .is_fullscreen = m_render_fullscreen.load(),
+                                                 .is_rendering_to_main = m_render_to_main.load()});
+
   if (m_render_handle == handle)
     return;
 
@@ -176,6 +182,11 @@ void Host::SetRenderFullscreen(bool fullscreen)
 {
   m_render_fullscreen = fullscreen;
 
+  Common::KeyboardContext::NotifyHandlerChanged({.main_handle = m_main_window_handle.load(),
+                                                 .renderer_handle = m_render_handle.load(),
+                                                 .is_fullscreen = fullscreen,
+                                                 .is_rendering_to_main = m_render_to_main.load()});
+
   if (g_gfx && g_gfx->IsFullscreen() != fullscreen && g_ActiveConfig.ExclusiveFullscreenEnabled())
   {
     RunWithGPUThreadInactive([fullscreen] { g_gfx->SetFullscreen(fullscreen); });

Source/Core/DolphinQt/MainWindow.cpp

@@ -94,6 +94,7 @@
 #include "DolphinQt/Debugger/ThreadWidget.h"
 #include "DolphinQt/Debugger/WatchWidget.h"
 #include "DolphinQt/DiscordHandler.h"
+#include "DolphinQt/EmulatedUSB/Keyboard.h"
 #include "DolphinQt/EmulatedUSB/WiiSpeakWindow.h"
 #include "DolphinQt/FIFO/FIFOPlayerWindow.h"
 #include "DolphinQt/GCMemcardManager.h"
@@ -580,6 +581,7 @@ void MainWindow::ConnectMenuBar()
   connect(m_menu_bar, &MenuBar::ShowSkylanderPortal, this, &MainWindow::ShowSkylanderPortal);
   connect(m_menu_bar, &MenuBar::ShowInfinityBase, this, &MainWindow::ShowInfinityBase);
   connect(m_menu_bar, &MenuBar::ShowWiiSpeakWindow, this, &MainWindow::ShowWiiSpeakWindow);
+  connect(m_menu_bar, &MenuBar::ShowKeyboard, this, &MainWindow::ShowKeyboard);
   connect(m_menu_bar, &MenuBar::ConnectWiiRemote, this, &MainWindow::OnConnectWiiRemote);
 
 #ifdef USE_RETRO_ACHIEVEMENTS
@@ -1433,6 +1435,19 @@ void MainWindow::ShowWiiSpeakWindow()
   m_wii_speak_window->activateWindow();
 }
 
+void MainWindow::ShowKeyboard()
+{
+  if (!m_keyboard_window)
+  {
+    m_keyboard_window = new KeyboardWindow();
+  }
+
+  SetQWidgetWindowDecorations(m_keyboard_window);
+  m_keyboard_window->show();
+  m_keyboard_window->raise();
+  m_keyboard_window->activateWindow();
+}
+
 void MainWindow::StateLoad()
 {
   QString dialog_path = (Config::Get(Config::MAIN_CURRENT_STATE_PATH).empty()) ?

Source/Core/DolphinQt/MainWindow.h

@@ -37,6 +37,7 @@ class GCTASInputWindow;
 class GraphicsWindow;
 class HotkeyScheduler;
 class InfinityBaseWindow;
+class KeyboardWindow;
 class JITWidget;
 class LogConfigWidget;
 class LogWidget;
@@ -178,6 +179,7 @@ private:
   void ShowSkylanderPortal();
   void ShowInfinityBase();
   void ShowWiiSpeakWindow();
+  void ShowKeyboard();
   void ShowMemcardManager();
   void ShowResourcePackManager();
   void ShowCheatsManager();
@@ -251,6 +253,7 @@ private:
   SkylanderPortalWindow* m_skylander_window = nullptr;
   InfinityBaseWindow* m_infinity_window = nullptr;
   WiiSpeakWindow* m_wii_speak_window = nullptr;
+  KeyboardWindow* m_keyboard_window = nullptr;
   MappingWindow* m_hotkey_window = nullptr;
   FreeLookWindow* m_freelook_window = nullptr;
 

Source/Core/DolphinQt/MenuBar.cpp

@@ -281,6 +281,7 @@ void MenuBar::AddToolsMenu()
   usb_device_menu->addAction(tr("&Skylanders Portal"), this, &MenuBar::ShowSkylanderPortal);
   usb_device_menu->addAction(tr("&Infinity Base"), this, &MenuBar::ShowInfinityBase);
   usb_device_menu->addAction(tr("&Wii Speak"), this, &MenuBar::ShowWiiSpeakWindow);
+  usb_device_menu->addAction(tr("&Keyboard"), this, &MenuBar::ShowKeyboard);
   tools_menu->addMenu(usb_device_menu);
 
   tools_menu->addSeparator();

Source/Core/DolphinQt/MenuBar.h

@@ -95,6 +95,7 @@ signals:
   void ShowSkylanderPortal();
   void ShowInfinityBase();
   void ShowWiiSpeakWindow();
+  void ShowKeyboard();
   void ConnectWiiRemote(int id);
 
 #ifdef USE_RETRO_ACHIEVEMENTS

Source/Core/DolphinQt/Settings.cpp

@@ -24,6 +24,7 @@
 #include "Common/Config/Config.h"
 #include "Common/Contains.h"
 #include "Common/FileUtil.h"
+#include "Common/Keyboard.h"
 #include "Common/StringUtil.h"
 
 #include "Core/AchievementManager.h"
@@ -791,6 +792,10 @@ void Settings::SetUSBKeyboardConnected(bool connected)
   if (IsUSBKeyboardConnected() != connected)
   {
     Config::SetBaseOrCurrent(Config::MAIN_WII_KEYBOARD, connected);
+    if (connected)
+      Common::KeyboardContext::NotifyInit();
+    else
+      Common::KeyboardContext::NotifyQuit();
     emit USBKeyboardConnectionChanged(connected);
   }
 }

Source/Core/InputCommon/ControllerInterface/SDL/SDL.cpp

@@ -3,6 +3,7 @@
 
 #include "InputCommon/ControllerInterface/SDL/SDL.h"
 
+#include <optional>
 #include <thread>
 #include <vector>
 
@@ -13,12 +14,46 @@
 #include <SDL.h>
 
 #include "Common/Event.h"
+#include "Common/Keyboard.h"
 #include "Common/Logging/Log.h"
 #include "Common/ScopeGuard.h"
+#include "Core/Host.h"
 
 #include "InputCommon/ControllerInterface/ControllerInterface.h"
 #include "InputCommon/ControllerInterface/SDL/SDLGamepad.h"
 
+namespace
+{
+using UniqueSDLWindow = std::unique_ptr<SDL_Window, void (*)(SDL_Window*)>;
+
+std::optional<const char*> UpdateKeyboardHandle(UniqueSDLWindow* unique_window)
+{
+  std::optional<const char*> error;
+
+  // Doesn't seem to work with X11 until SDL 3.10:
+  //  - https://github.com/libsdl-org/SDL/pull/10467
+  const void* keyboard_handle = Common::KeyboardContext::GetWindowHandle();
+  SDL_Window* keyboard_window = SDL_CreateWindowFrom(keyboard_handle);
+  if (keyboard_window == nullptr)
+    error = SDL_GetError();
+
+  unique_window->reset(keyboard_window);
+  if (error.has_value())
+    return error;
+
+  // SDL aggressive hooking might make the window borderless sometimes
+  if (!Host_RendererIsFullscreen())
+  {
+    SDL_SetWindowFullscreen(keyboard_window, 0);
+    SDL_SetWindowBordered(keyboard_window, SDL_TRUE);
+  }
+
+  Common::KeyboardContext::UpdateLayout();
+
+  return error;
+}
+}  // namespace
+
 namespace ciface::SDL
 {
 
@@ -39,6 +74,7 @@ private:
   Uint32 m_stop_event_type;
   Uint32 m_populate_event_type;
   std::thread m_hotplug_thread;
+  UniqueSDLWindow m_keyboard_window{nullptr, SDL_DestroyWindow};
 };
 
 std::unique_ptr<ciface::InputBackend> CreateInputBackend(ControllerInterface* controller_interface)
@@ -145,7 +181,7 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
         return;
       }
 
-      const Uint32 custom_events_start = SDL_RegisterEvents(2);
+      const Uint32 custom_events_start = SDL_RegisterEvents(5);
       if (custom_events_start == static_cast<Uint32>(-1))
       {
         ERROR_LOG_FMT(CONTROLLERINTERFACE, "SDL failed to register custom events");
@@ -153,6 +189,9 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
       }
       m_stop_event_type = custom_events_start;
       m_populate_event_type = custom_events_start + 1;
+      Common::KeyboardContext::s_sdl_init_event_type = custom_events_start + 2;
+      Common::KeyboardContext::s_sdl_update_event_type = custom_events_start + 3;
+      Common::KeyboardContext::s_sdl_quit_event_type = custom_events_start + 4;
 
       // Drain all of the events and add the initial joysticks before returning. Otherwise, the
       // individual joystick events as well as the custom populate event will be handled _after_
@@ -276,6 +315,44 @@ bool InputBackend::HandleEventAndContinue(const SDL_Event& e)
   {
     return false;
   }
+  else if (e.type == Common::KeyboardContext::s_sdl_init_event_type)
+  {
+    if (const int error = SDL_InitSubSystem(SDL_INIT_VIDEO); error != 0)
+    {
+      ERROR_LOG_FMT(IOS_USB, "SDL failed to init subsystem to capture keyboard input: {}",
+                    SDL_GetError());
+      return true;
+    }
+
+    if (const auto error = UpdateKeyboardHandle(&m_keyboard_window); error.has_value())
+    {
+      ERROR_LOG_FMT(IOS_USB, "SDL failed to attach window to capture keyboard input: {}", *error);
+      return true;
+    }
+  }
+  else if (e.type == Common::KeyboardContext::s_sdl_update_event_type)
+  {
+    if (!SDL_WasInit(SDL_INIT_VIDEO))
+      return true;
+
+    // Release previous SDLWindow
+    m_keyboard_window.reset();
+
+    if (const auto error = UpdateKeyboardHandle(&m_keyboard_window); error.has_value())
+    {
+      ERROR_LOG_FMT(IOS_USB, "SDL failed to switch window to capture keyboard input: {}", *error);
+      return true;
+    }
+  }
+  else if (e.type == Common::KeyboardContext::s_sdl_quit_event_type)
+  {
+    m_keyboard_window.reset();
+    SDL_QuitSubSystem(SDL_INIT_VIDEO);
+  }
+  else if (e.type == SDL_KEYMAPCHANGED)
+  {
+    Common::KeyboardContext::UpdateLayout();
+  }
 
   return true;
 }