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 594 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 609 of file sdl_kbd.cpp.

{
  freerdp_keyboard_remap_free(_remapTable);
}

Member Function Documentation

handleEvent()

bool sdlInput::handleEvent

(

const SDL_KeyboardEvent &

ev

)

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

{
  const UINT32 rdp_scancode = scancode_to_rdp(ev.scancode);
  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 692 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 560 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 516 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 376 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
 
  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 571 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 666 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 585 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 484 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 417 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 439 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