sdlInput Class Reference

#include <sdl_kbd.hpp>

Public Member Functions
	sdlInput (SdlContext *sdl)
	sdlInput (const sdlInput &other)=delete
	sdlInput (sdlInput &&other)=delete
sdlInput &	operator= (const sdlInput &other)=delete
sdlInput &	operator= (sdlInput &&other)=delete
BOOL	keyboard_sync_state ()
BOOL	keyboard_focus_in ()
BOOL	keyboard_handle_event (const SDL_KeyboardEvent *ev)
BOOL	keyboard_grab (Uint32 windowID, bool enable)
BOOL	mouse_focus (Uint32 windowID)
BOOL	mouse_grab (Uint32 windowID, SDL_bool enable)
	sdlInput (SdlContext *sdl)
	sdlInput (const sdlInput &other)=delete
	sdlInput (sdlInput &&other)=delete
sdlInput &	operator= (const sdlInput &other)=delete
sdlInput &	operator= (sdlInput &&other)=delete
bool	initialize ()
bool	keyboard_sync_state ()
bool	keyboard_focus_in ()
bool	handleEvent (const SDL_KeyboardEvent &ev)
bool	keyboard_grab (Uint32 windowID, bool enable)
bool	mouse_focus (Uint32 windowID)
bool	mouse_grab (Uint32 windowID, bool enable)
bool	prefToEnabled ()
uint32_t	prefToMask ()

Static Public Member Functions
static BOOL	keyboard_set_indicators (rdpContext *context, UINT16 led_flags)
static BOOL	keyboard_set_ime_status (rdpContext *context, UINT16 imeId, UINT32 imeState, UINT32 imeConvMode)
static bool	prefToEnabled ()
static uint32_t	prefToMask ()
static uint32_t	prefKeyValue (const std::string &key, uint32_t fallback=SDL_SCANCODE_UNKNOWN)
static BOOL	keyboard_set_indicators (rdpContext *context, UINT16 led_flags)
static BOOL	keyboard_set_ime_status (rdpContext *context, UINT16 imeId, UINT32 imeState, UINT32 imeConvMode)
static uint32_t	prefKeyValue (const std::string &key, uint32_t fallback=SDL_SCANCODE_UNKNOWN)

Detailed Description

FreeRDP: A Remote Desktop Protocol Implementation SDL Client keyboard helper

Copyright 2022 Armin Novak armin.nosp@m..nov.nosp@m.ak@th.nosp@m.inca.nosp@m.st.co.nosp@m.m

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Definition at line 34 of file sdl_kbd.hpp.

Constructor & Destructor Documentation

sdlInput()

sdlInput::sdlInput ( SdlContext *  sdl )

explicit

Definition at line 595 of file sdl_kbd.cpp.

    : _sdl(sdl), _lastWindowID(UINT32_MAX), _hotkeysEnabled(prefToEnabled()),
      _hotkeyModmask(prefToMask())
{
  auto list =
      freerdp_settings_get_string(_sdl->context()->settings, FreeRDP_KeyboardRemappingList);
  _remapTable = freerdp_keyboard_remap_string_to_list(list);
  assert(_remapTable);
  _hotkeyFullscreen = prefKeyValue("SDL_Fullscreen", SDL_SCANCODE_RETURN);
  _hotkeyResizable = prefKeyValue("SDL_Resizeable", SDL_SCANCODE_R);
  _hotkeyGrab = prefKeyValue("SDL_Grab", SDL_SCANCODE_G);
  _hotkeyDisconnect = prefKeyValue("SDL_Disconnect", SDL_SCANCODE_D);
  _hotkeyMinimize = prefKeyValue("SDL_Minimize", SDL_SCANCODE_M);
}

~sdlInput()

sdlInput::~sdlInput

(

)

Definition at line 610 of file sdl_kbd.cpp.

{
  freerdp_keyboard_remap_free(_remapTable);
}

Member Function Documentation

handleEvent()

bool sdlInput::handleEvent

(

const SDL_KeyboardEvent &

ev

)

Definition at line 551 of file SDL3/sdl_input.cpp.

{
  UINT32 rdp_scancode = scancode_to_rdp(ev.scancode);
#if defined(_WIN32)
  /* CJK IMEs on Windows may set the extended bit for Right Shift, producing
   * the invalid scan code E0 36. SDL maps that event to SDL_SCANCODE_UNKNOWN,
   * so normalize it in the same way as the native Windows client. */
  if ((rdp_scancode == RDP_SCANCODE_UNKNOWN) && (ev.raw == 0xE036))
    rdp_scancode = RDP_SCANCODE_RSHIFT;
#endif
  const SDL_Keymod mods = SDL_GetModState();
 
  if (_hotkeysEnabled && (mods & _hotkeyModmask) == _hotkeyModmask)
  {
    if (ev.type == SDL_EVENT_KEY_DOWN)
    {
      if (ev.scancode == _hotkeyFullscreen)
      {
        WLog_Print(_sdl->getWLog(), WLOG_INFO, "%s+<%s> pressed, toggling fullscreen state",
                   masktostr(_hotkeyModmask).c_str(), sdl_scancode_name(_hotkeyFullscreen));
        if (!keyboard_sync_state())
          return false;
        return _sdl->toggleFullscreen();
      }
      if (ev.scancode == _hotkeyResizable)
      {
        WLog_Print(_sdl->getWLog(), WLOG_INFO, "%s+<%s> pressed, toggling resizeable state",
                   masktostr(_hotkeyModmask).c_str(), sdl_scancode_name(_hotkeyResizable));
        if (!keyboard_sync_state())
          return false;
        return _sdl->toggleResizeable();
      }
 
      if (ev.scancode == _hotkeyGrab)
      {
        WLog_Print(_sdl->getWLog(), WLOG_INFO, "%s+<%s> pressed, toggling grab state",
                   masktostr(_hotkeyModmask).c_str(), sdl_scancode_name(_hotkeyGrab));
        if (!keyboard_sync_state())
          return false;
        return keyboard_grab(ev.windowID, !_sdl->grabKeyboard());
      }
      if (ev.scancode == _hotkeyDisconnect)
      {
        WLog_Print(_sdl->getWLog(), WLOG_INFO, "%s+<%s> pressed, disconnecting RDP session",
                   masktostr(_hotkeyModmask).c_str(), sdl_scancode_name(_hotkeyDisconnect));
        if (!keyboard_sync_state())
          return false;
        freerdp_abort_connect_context(_sdl->context());
        return true;
      }
      if (ev.scancode == _hotkeyMinimize)
      {
        WLog_Print(_sdl->getWLog(), WLOG_INFO, "%s+<%s> pressed, minimizing client",
                   masktostr(_hotkeyModmask).c_str(), sdl_scancode_name(_hotkeyMinimize));
        if (!keyboard_sync_state())
          return false;
        return _sdl->setMinimized();
      }
    }
  }
 
#if defined(WITH_DEBUG_KBD)
  {
    const BOOL ex = RDP_SCANCODE_EXTENDED(rdp_scancode);
    const DWORD sc = RDP_SCANCODE_CODE(rdp_scancode);
    WLog_Print(_sdl->getWLog(), WLOG_DEBUG,
               "SDL keycode: %02" PRIX32 " -> rdp code: [%04" PRIx16 "] %02" PRIX8 "%s",
               ev.scancode, rdp_scancode, sc, ex ? " extended" : "");
  }
#endif
 
  auto scancode = freerdp_keyboard_remap_key(_remapTable, rdp_scancode);
#if defined(WITH_DEBUG_KBD)
  {
    const BOOL ex = RDP_SCANCODE_EXTENDED(scancode);
    const DWORD sc = RDP_SCANCODE_CODE(scancode);
    WLog_Print(_sdl->getWLog(), WLOG_DEBUG,
               "SDL keycode: %02" PRIX32 " -> remapped rdp code: [%04" PRIx16 "] %02" PRIX8
               "%s",
               ev.scancode, scancode, sc, ex ? " extended" : "");
  }
#endif
  return freerdp_input_send_keyboard_event_ex(_sdl->context()->input,
                                              ev.type == SDL_EVENT_KEY_DOWN, ev.repeat, scancode);
}

initialize()

bool sdlInput::initialize

(

)

Definition at line 691 of file SDL3/sdl_input.cpp.

{
  auto settings = _sdl->context()->settings;
  WINPR_ASSERT(settings);
  WINPR_ASSERT(!_remapTable);
 
  {
    auto list = freerdp_settings_get_string(settings, FreeRDP_KeyboardRemappingList);
    _remapTable = freerdp_keyboard_remap_string_to_list(list);
    if (!_remapTable)
      return false;
  }
 
  if (freerdp_settings_get_uint32(settings, FreeRDP_KeyboardLayout) == 0)
  {
    DWORD KeyboardLayout = 0;
 
    freerdp_detect_keyboard_layout_from_system_locale(&KeyboardLayout);
    if (KeyboardLayout == 0)
      KeyboardLayout = ENGLISH_UNITED_STATES;
 
    if (!freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, KeyboardLayout))
      return false;
  }
  return true;
}

keyboard_focus_in()

bool sdlInput::keyboard_focus_in

(

)

Definition at line 323 of file sdl_kbd.cpp.

{
  auto input = _sdl->context()->input;
  WINPR_ASSERT(input);
 
  auto syncFlags = sdl_get_kbd_flags();
  freerdp_input_send_focus_in_event(input, WINPR_ASSERTING_INT_CAST(UINT16, syncFlags));
 
  /* finish with a mouse pointer position like mstsc.exe if required */
  // TODO: fullscreen/remote app
  int x = 0;
  int y = 0;
  if (_sdl->fullscreen)
  {
    SDL_GetGlobalMouseState(&x, &y);
  }
  else
  {
    SDL_GetMouseState(&x, &y);
  }
  auto w = SDL_GetMouseFocus();
  if (w)
  {
    auto id = SDL_GetWindowID(w);
    sdl_scale_coordinates(_sdl, id, &x, &y, TRUE, TRUE);
  }
  return freerdp_client_send_button_event(_sdl->common(), FALSE, PTR_FLAGS_MOVE, x, y);
}

keyboard_grab()

bool sdlInput::keyboard_grab	(	Uint32	windowID,
		bool	enable
	)

Definition at line 561 of file sdl_kbd.cpp.

{
  auto it = _sdl->windows.find(windowID);
  if (it == _sdl->windows.end())
    return FALSE;
 
  auto status = enable && _sdl->grab_kbd_enabled;
  _sdl->grab_kbd = status;
  return it->second.grabKeyboard(status);
}

keyboard_handle_event()

BOOL sdlInput::keyboard_handle_event

(

const SDL_KeyboardEvent *

ev

)

Definition at line 517 of file sdl_kbd.cpp.

{
  WINPR_ASSERT(ev);
  const UINT32 rdp_scancode = sdl_scancode_to_rdp(ev->keysym.scancode);
  const SDL_Keymod mods = SDL_GetModState();
 
  if (_hotkeysEnabled && (mods & _hotkeyModmask) == _hotkeyModmask)
  {
    if (ev->type == SDL_KEYDOWN)
    {
      if (ev->keysym.scancode == _hotkeyFullscreen)
      {
        _sdl->update_fullscreen(!_sdl->fullscreen);
        return TRUE;
      }
      if (ev->keysym.scancode == _hotkeyResizable)
      {
        _sdl->update_resizeable(!_sdl->resizeable);
        return TRUE;
      }
 
      if (ev->keysym.scancode == _hotkeyGrab)
      {
        keyboard_grab(ev->windowID, !_sdl->grab_kbd);
        return TRUE;
      }
      if (ev->keysym.scancode == _hotkeyDisconnect)
      {
        freerdp_abort_connect_context(_sdl->context());
        return TRUE;
      }
      if (ev->keysym.scancode == _hotkeyMinimize)
      {
        _sdl->update_minimize();
        return TRUE;
      }
    }
  }
 
  auto scancode = freerdp_keyboard_remap_key(_remapTable, rdp_scancode);
  return freerdp_input_send_keyboard_event_ex(_sdl->context()->input, ev->type == SDL_KEYDOWN,
                                              ev->repeat, scancode);
}

keyboard_set_ime_status()

BOOL sdlInput::keyboard_set_ime_status ( rdpContext *  context, UINT16  imeId, UINT32  imeState, UINT32  imeConvMode  )

static

Definition at line 377 of file sdl_kbd.cpp.

{
  if (!context)
    return FALSE;
 
  WLog_WARN(TAG,
            "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
            ", imeConvMode=%08" PRIx32 ") ignored",
            imeId, imeState, imeConvMode);
  return TRUE;
}

keyboard_set_indicators()

BOOL sdlInput::keyboard_set_indicators ( rdpContext *  context, UINT16  led_flags  )

static

Definition at line 353 of file sdl_kbd.cpp.

{
  WINPR_UNUSED(context);
 
  int state = KMOD_NONE;
 
  if ((led_flags & KBD_SYNC_NUM_LOCK) != 0)
    state |= KMOD_NUM;
  if ((led_flags & KBD_SYNC_CAPS_LOCK) != 0)
    state |= KMOD_CAPS;
#if SDL_VERSION_ATLEAST(2, 0, 18)
  if ((led_flags & KBD_SYNC_SCROLL_LOCK) != 0)
    state |= KMOD_SCROLL;
#endif
 
  // TODO: KBD_SYNC_KANA_LOCK
 
  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
  SDL_SetModState(static_cast<SDL_Keymod>(state));
 
  return TRUE;
}

keyboard_sync_state()

bool sdlInput::keyboard_sync_state

(

)

Definition at line 317 of file sdl_kbd.cpp.

{
  const auto syncFlags = sdl_get_kbd_flags();
  return freerdp_input_send_synchronize_event(_sdl->context()->input, syncFlags);
}

mouse_focus()

bool sdlInput::mouse_focus

(

Uint32

windowID

)

Definition at line 572 of file sdl_kbd.cpp.

{
  if (_lastWindowID != windowID)
  {
    _lastWindowID = windowID;
    auto it = _sdl->windows.find(windowID);
    if (it == _sdl->windows.end())
      return FALSE;
 
    it->second.raise();
  }
  return TRUE;
}

mouse_grab() [1/2]

bool sdlInput::mouse_grab	(	Uint32	windowID,
		bool	enable
	)

Definition at line 665 of file SDL3/sdl_input.cpp.

{
  auto window = _sdl->getWindowForId(windowID);
  if (!window)
    return false;
  if (!_sdl->setGrabMouse(enable))
    WLog_Print(_sdl->getWLog(), WLOG_WARN, "Failed to ungrab mouse");
  return window->grabMouse(enable);
}

mouse_grab() [2/2]

BOOL sdlInput::mouse_grab	(	Uint32	windowID,
		SDL_bool	enable
	)

Definition at line 586 of file sdl_kbd.cpp.

{
  auto it = _sdl->windows.find(windowID);
  if (it == _sdl->windows.end())
    return FALSE;
  _sdl->grab_mouse = enable;
  return it->second.grabMouse(enable);
}

prefKeyValue()

uint32_t sdlInput::prefKeyValue ( const std::string &  key, uint32_t  fallback = SDL_SCANCODE_UNKNOWN  )

static

Definition at line 485 of file sdl_kbd.cpp.

{
  auto item = SdlPref::instance()->get_string(key);
  if (item.empty())
    return fallback;
  auto val = sdl_scancode_val(item.c_str());
  if (val == SDL_SCANCODE_UNKNOWN)
    return fallback;
  return val;
}

prefToEnabled()

bool sdlInput::prefToEnabled ( )

static

Definition at line 418 of file sdl_kbd.cpp.

{
  bool enable = true;
  const auto& m = getSdlMap();
  for (const auto& val : SdlPref::instance()->get_array("SDL_KeyModMask", { "KMOD_RSHIFT" }))
  {
    auto it = m.find(val);
    if (it != m.end())
    {
      if (it->second == KMOD_NONE)
        enable = false;
    }
    else
    {
      WLog_WARN(TAG, "Invalid config::SDL_KeyModMask entry value '%s', disabling hotkeys",
                val.c_str());
      enable = false;
    }
  }
  return enable;
}

prefToMask()

uint32_t sdlInput::prefToMask ( )

static

Definition at line 440 of file sdl_kbd.cpp.

{
  const auto& mapping = getSdlMap();
  uint32_t mod = KMOD_NONE;
  for (const auto& val : SdlPref::instance()->get_array("SDL_KeyModMask", { "KMOD_RSHIFT" }))
  {
    auto it = mapping.find(val);
    if (it != mapping.end())
      mod |= it->second;
  }
  return mod;
}

---

The documentation for this class was generated from the following files:

• sdl_kbd.hpp
• SDL3/sdl_input.hpp
• sdl_kbd.cpp
• SDL3/sdl_input.cpp