SdlRail Class Reference

#include <sdl_rail.hpp>

Public Member Functions
	SdlRail (SdlContext *context)
	SdlRail (const SdlRail &)=delete
	SdlRail (SdlRail &&)=delete
SdlRail &	operator= (const SdlRail &)=delete
SdlRail &	operator= (SdlRail &&)=delete
bool	init (RailClientContext *rail)
bool	uninit (RailClientContext *rail)
bool	enabled () const
bool	desktopMayShow ()
void	noteLogonPrompt ()
bool	paint (SDL_Surface *primary, SDL_PixelFormat fallbackFormat, const std::vector< SDL_Rect > &damage)
UINT	updateWindowFromSurface (gdiGfxSurface *surface)
bool	ownsWindow (SDL_WindowID id)
void	invalidateWindow (SDL_WindowID id)
void	handleMaximized (SDL_WindowID id)
void	handleMinimized (SDL_WindowID id)
void	handleRestored (SDL_WindowID id)
void	handleClose (SDL_WindowID id)
void	handleFocus (SDL_WindowID id, bool gained)
void	handleDisplayChanged (SDL_WindowID id, SDL_DisplayID display)
void	updateCoordinates ()
void	ensureActive (SDL_WindowID id)
bool	translateToServer (SDL_WindowID id, float &x, float &y)
void	notePopupMoved (SDL_WindowID id)
void	noteLeftPress (float x, float y)
void	noteServerPointer (float x, float y)
bool	dragActive (SDL_WindowID id)
bool	suppressServerMotion (SDL_WindowID id)
void	handleLocalMoveRequested (uint32_t windowId, uint16_t moveType)
void	noteDragResize (SDL_WindowID id, int w, int h)
void	syncGeometry (SDL_WindowID id)
void	completeLocalMoveIfPending ()
void	completeWaylandResize (bool definitive=false)
void	noteResizeGrab (SDL_WindowID id)
void	settleWaylandResize ()

Static Public Member Functions
static UINT	UpdateWindowFromSurface (RdpgfxClientContext *context, gdiGfxSurface *surface)

Detailed Description

RAIL channel handler for the SDL3 client.

Server-authoritative: the server drives window geometry via WINDOW_ORDER and the local borderless windows follow (the RemoteApp frame is server-drawn content). Interactive move/resize is handed to the local WM only on a server request (ServerLocalMoveSize).

Definition at line 45 of file sdl_rail.hpp.

Constructor & Destructor Documentation

SdlRail()

SdlRail::SdlRail ( SdlContext *  context )

explicit

Definition at line 48 of file sdl_rail.cpp.

                                    : _context(context)
{
}

~SdlRail()

SdlRail::~SdlRail

(

)

Definition at line 52 of file sdl_rail.cpp.

{
  railPlatformSetNativeLoopHandler({});
}

Member Function Documentation

completeLocalMoveIfPending()

void SdlRail::completeLocalMoveIfPending

(

)

Definition at line 1455 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return;
  /* Skip Wayland button-up finalize. */
  if (compositorDrag())
    return;
 
  /* Snapshot and clear drag state atomically under lock. */
  const LocalMove drag = _localMove;
  _localMove = {};
 
  auto appWindow = getWindow(drag.id);
  if (!appWindow || !appWindow->window() || appWindow->isDeleted())
    return; /* window gone mid-drag: nothing to release into or report for */
 
  /* Send synthetic button release if WM grab consumed physical release. */
  if ((SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON_LMASK) &&
      !(SDL_GetGlobalMouseState(nullptr, nullptr) & SDL_BUTTON_LMASK))
    if (!railPlatformReleaseButton(appWindow->window()))
      WLog_WARN(TAG, "synthetic button release failed");
 
  /* Finalize WM resize before reading final size. */
  (void)SDL_SyncWindow(appWindow->window());
 
  int x = 0;
  int y = 0;
  int w = 0;
  int h = 0;
  SDL_GetWindowSize(appWindow->window(), &w, &h);
  SDL_GetWindowPosition(appWindow->window(), &x, &y);
  const bool isMove = (drag.type == RAIL_WMSZ_MOVE);
  const SDL_Rect start = appWindow->outerRect(); /* position frozen at drag start */
  /* Preserve server size during move; defer WM snap/tile size sync until loop END to avoid
   * server drag-restore conflict. */
  if (isMove)
  {
    if (!appWindow->effectivelyMaximized() && drag.wmSized &&
        !appWindow->localMoveSizeChanged())
    {
      /* Adopt WM size if window was resized during move. */
      w = drag.wmSize.x;
      h = drag.wmSize.y;
      appWindow->deferSnap(appWindow->serverRect({ x, y, w, h }));
    }
    else
    {
      w = start.w;
      h = start.h;
    }
  }
  /* Finalize modal loop unless server closed it early. */
  if (!drag.serverEnded)
  {
    int px = drag.anchor.x;
    int py = drag.anchor.y;
    if (isMove && appWindow->localMoveSizeChanged())
    {
      /* Measure delta from server anchor on drag-restore. */
      const SDL_Point sp = appWindow->localMoveServerPos();
      const SDL_Rect now = appWindow->serverRect({ x, y, w, h });
      px = drag.pointer.x + now.x - sp.x;
      py = drag.pointer.y + now.y - sp.y;
    }
    else if (!appWindow->effectivelyMaximized())
    {
      const RailEdges e = railEdges(drag.type);
      if (isMove || e.left)
        px += x - start.x;
      else if (e.right)
        px += (x + w) - (start.x + start.w);
      if (isMove || e.top)
        py += y - start.y;
      else if (e.bottom)
        py += (y + h) - (start.y + start.h);
    }
    (void)freerdp_client_send_button_event(_context->common(), FALSE, PTR_FLAGS_BUTTON1, px,
                                           py);
    /* Server loop unwinding: wait for explicit END order to gate deferred SC_MAXIMIZE. */
    appWindow->armLoopEnd();
 
    /* Adopt local geometry without sending ClientWindowMove during mouse drags. */
    const SDL_Rect rect = appWindow->serverRect({ x, y, w, h });
    const bool restoredMidDrag = appWindow->localMoveSizeChanged();
    appWindow->adoptLocalGeometry(rect);
    /* Drag complete: apply pending server resize delayed during WM grab. */
    if (restoredMidDrag)
      appWindow->markGeometryDirty();
    (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  }
  else if (!isMove)
  {
    /* Sync final resize geometry if server closed loop early. */
    clampIntoDesktop(*appWindow, x, y, w, h);
    reportAndAdopt(appWindow, x, y, w, h);
  }
 
  railPlatformEndDrag(appWindow->window());
}

completeWaylandResize()

void SdlRail::completeWaylandResize

(

bool

definitive = false

)

Definition at line 1410 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if ((_localMove.id == 0) || !compositorDrag())
    return;
  /* Finalize drag resize on window enter if resize occurred. */
  if (!_localMove.sawResize)
  {
    if (definitive)
    {
      if (auto* appWindow = getWindow(_localMove.id))
      {
        appWindow->setLocalMoveActive(false);
        /* Repaint now: the dashed placeholder is on screen and an undamaged window would
         * otherwise keep it until the next server frame. */
        appWindow->invalidateAll();
        (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
      }
      _localMove = {}; /* Snapshot and clear drag state under lock. */
    }
    return;
  }
 
  /* Snapshot and clear drag state atomically under lock. */
  const LocalMove drag = _localMove;
  _localMove = {};
 
  auto appWindow = getWindow(drag.id);
  if (!appWindow || !appWindow->window())
    return;
 
  (void)SDL_SyncWindow(appWindow->window());
  int w = 0;
  int h = 0;
  SDL_GetWindowSize(appWindow->window(), &w, &h);
 
  /* Derive Wayland origin from anchor edge. */
  const SDL_Rect start = appWindow->outerRect();
  const RailEdges e = railEdges(drag.type);
  int x = e.left ? (start.x + start.w - w) : start.x;
  int y = e.top ? (start.y + start.h - h) : start.y;
  clampIntoDesktop(*appWindow, x, y, w, h);
  reportAndAdopt(appWindow, x, y, w, h);
}

desktopMayShow()

bool SdlRail::desktopMayShow

(

)

Definition at line 477 of file sdl_rail.cpp.

{
  if (_desktopReleased)
    return true;
  const uint64_t now = SDL_GetTicks();
  if (_desktopHoldUntil == 0)
  {
    _desktopHoldUntil = now + kDesktopHoldMs;
    /* Frames may stop coming while the logon waits; wake up to re-check. */
    if (!sdl_push_update_after(kDesktopHoldMs + 1))
      WLog_WARN(TAG, "SDL_AddTimer failed: %s", SDL_GetError());
    WLog_DBG(TAG, "RemoteApp starting: holding the logon desktop back");
    return false;
  }
  if (now < _desktopHoldUntil)
    return false;
  WLog_DBG(TAG, "RemoteApp not started after %" PRIu32 " ms, showing the desktop",
           kDesktopHoldMs);
  _desktopReleased = true;
  return true;
}

dragActive()

bool SdlRail::dragActive

(

SDL_WindowID

id

)

Definition at line 1049 of file sdl_rail.cpp.

{
  return !compositorDrag() && suppressServerMotion(id);
}

enabled()

bool SdlRail::enabled ( ) const

inline

Definition at line 59 of file sdl_rail.hpp.

  {
    return _enabled;
  }

ensureActive()

void SdlRail::ensureActive

(

SDL_WindowID

id

)

Definition at line 372 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || !appWindow->activatable() || !appWindow->window())
    return;
  const auto wid = static_cast<uint32_t>(appWindow->id());
  if (wid == _clientActiveId)
    return;
  sendClientActivate(wid, true);
}

handleClose()

void SdlRail::handleClose

(

SDL_WindowID

id

)

Definition at line 280 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || !appWindow->window())
    return;
  WLog_DBG(TAG, "local close id=0x%08" PRIx32 " -> SC_CLOSE",
           static_cast<UINT32>(appWindow->id()));
  sendSystemCommand(appWindow, SC_CLOSE);
}

handleDisplayChanged()

void SdlRail::handleDisplayChanged	(	SDL_WindowID	id,
		SDL_DisplayID	display
	)

Definition at line 1167 of file sdl_rail.cpp.

{
  if (railPlatformCaps().supportsWindowPositions)
    return;
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || appWindow->effectivelyMaximized())
    return;
  /* The end of the server move loop would undo it. */
  if (_moveLoop.id == appWindow->id())
  {
    _moveLoop.display = display;
    return;
  }
  moveToDisplay(appWindow, display);
}

handleFocus()

void SdlRail::handleFocus	(	SDL_WindowID	id,
		bool	gained
	)

Definition at line 319 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto appWindow = getWindowBySdlId(id);
  if (!appWindow || !appWindow->activatable() || !appWindow->window())
    return;
 
  /* Ignore focus loss while dragging: mapping restore shadow frames can steal focus
   * and cancel the server modal loop. */
  if (!gained && (_localMove.id == static_cast<uint32_t>(appWindow->id())))
    return;
 
  /* Fallback parent for orphaned popups. */
  if (gained)
    _focusedAppId = appWindow->id();
 
  /* Only report activation, never deactivation (see the X11 client, #13422).
   * The server treats a deactivation of the owner as "no active window in
   * this application" and closes popups/menus that have just been opened
   * when the compositor moves focus to them. The activation that follows
   * (or an explicit click, see ensureActive()) is enough to route input. */
  if (!gained)
    return;
 
  /* A window owned by this one is currently active (e.g. a profile card or
   * a transient dialog). On a real desktop the owner is only activated by a
   * click; focus-follows-mouse compositors hand focus back on hover, which
   * would make the server close the owned popup. Leave that to
   * ensureActive() (explicit click). */
  const auto* active = getWindow(_clientActiveId);
  if (active && (active != appWindow) &&
      (active->owner() == static_cast<uint32_t>(appWindow->id())))
    return;
 
  /* ClientActivate only. Do NOT SDL_RaiseWindow to avoid WM focus loops. */
  const auto wid = static_cast<uint32_t>(appWindow->id());
  sendClientActivate(wid, true);
}

handleLocalMoveRequested()

void SdlRail::handleLocalMoveRequested	(	uint32_t	windowId,
		uint16_t	moveType
	)

Definition at line 1109 of file sdl_rail.cpp.

{
  /* Native modal loop: runs unlocked until the drag ends. */
  SDL_Window* sdlWindow = beginLocalMove(windowId, moveType);
  if (!sdlWindow)
    return;
  _sizeMoveRedraws = 0;
  railPlatformRunModalDrag(sdlWindow, moveType);
  WLog_DBG(TAG, "modal drag end id=0x%08" PRIx32 " redraws=%" PRIu32, windowId, _sizeMoveRedraws);
  completeLocalMoveIfPending();
}

handleMaximized()

void SdlRail::handleMaximized

(

SDL_WindowID

id

)

Definition at line 230 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  /* Skip echo of programmatic maximize, but trigger reconcile to update insets. */
  if (appWindow->railMaximized())
  {
    WLog_DBG(TAG, "local maximize skipped id=0x%08" PRIx32 " (already rail-maximized)",
             static_cast<UINT32>(appWindow->id()));
 
    if (!sdl_push_user_event(SDL_EVENT_USER_UPDATE))
      WLog_WARN(TAG, "sdl_push_user_event failed");
    return;
  }
  appWindow->setRailMaximized(true);
  /* Force full repaint (skips dirty-rect). */
  appWindow->invalidateAll();
  /* Defer SC_MAXIMIZE if modal move loop is still open. */
  if (appWindow->loopEndPending())
  {
    appWindow->deferMaximize();
    WLog_DBG(TAG, "local maximize deferred id=0x%08" PRIx32 " (modal loop open)",
             static_cast<UINT32>(appWindow->id()));
  }
  else
  {
    WLog_DBG(TAG, "local maximize id=0x%08" PRIx32 " -> SC_MAXIMIZE",
             static_cast<UINT32>(appWindow->id()));
    sendSystemCommand(appWindow, SC_MAXIMIZE);
  }
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}

handleMinimized()

void SdlRail::handleMinimized

(

SDL_WindowID

id

)

Definition at line 266 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  if (appWindow->railMinimized())
    return; /* echo of reconcile's own SDL_MinimizeWindow */
  appWindow->setRailMinimized(true);
  WLog_DBG(TAG, "local minimize id=0x%08" PRIx32 " -> SC_MINIMIZE",
           static_cast<UINT32>(appWindow->id()));
  sendSystemCommand(appWindow, SC_MINIMIZE);
}

handleRestored()

void SdlRail::handleRestored

(

SDL_WindowID

id

)

Definition at line 291 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  /* Resolve restored state; trigger reconcile in case WM cleared flags asynchronously. */
  if (appWindow->railMinimized())
  {
    appWindow->setRailMinimized(false);
    appWindow->noteLocalRestore();
  }
  else if (appWindow->railMaximized())
    appWindow->setRailMaximized(false);
  else
  {
    if (!sdl_push_user_event(SDL_EVENT_USER_UPDATE))
      WLog_WARN(TAG, "sdl_push_user_event failed");
    return;
  }
  WLog_DBG(TAG, "local restore id=0x%08" PRIx32 " -> SC_RESTORE",
           static_cast<UINT32>(appWindow->id()));
  appWindow->invalidateAll();
  sendSystemCommand(appWindow, SC_RESTORE);
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}

init()

bool SdlRail::init

(

RailClientContext *

rail

)

Definition at line 821 of file sdl_rail.cpp.

{
  _rail = rail;
  if (!rail)
    return false;
 
  registerUpdateCallbacks(_context->context()->update);
 
  {
    std::unique_lock lock(_windowsLock);
    /* Move previous windows to deadWindows for main-thread teardown. */
    for (auto it = _windows.begin(); it != _windows.end();)
    {
      auto cur = it++;
      _deadWindows.insert(_windows.extract(cur));
    }
    auto* settings = _context->context()->settings;
    const uint32_t caches =
        freerdp_settings_get_uint32(settings, FreeRDP_RemoteAppNumIconCaches);
    _iconCacheEntries =
        freerdp_settings_get_uint32(settings, FreeRDP_RemoteAppNumIconCacheEntries);
    _iconCache.assign(static_cast<size_t>(caches) * _iconCacheEntries, {});
  }
 
  rail->custom = this;
  rail->ServerExecuteResult = SdlRail::server_execute_result;
  /* ServerSystemParam not implemented: the server only sends screensaver state here. */
  rail->ServerLocalMoveSize = SdlRail::server_local_move_size;
  rail->ServerMinMaxInfo = SdlRail::server_min_max_info;
  /* Keep default ServerHandshake. */
 
  WLog_WARN(TAG, "RemoteApp/RAIL support in the SDL client is experimental");
  {
    std::unique_lock lock(_windowsLock);
    updateCoordinates();
  }
  const RailPlatformCaps& caps = railPlatformCaps();
  railPlatformSetNativeLoopHandler({ this, redrawDuringSizeMove, nativeResize });
  WLog_DBG(TAG, "RAIL channel initialized: driver=%s windowPositions=%d transparentWindows=%d",
           SDL_GetCurrentVideoDriver(), caps.supportsWindowPositions ? 1 : 0,
           caps.supportsTransparentWindows ? 1 : 0);
#if SDL_VERSION_ATLEAST(3, 4, 10)
  /* Synchronize WM-driven X11 resizes via _NET_WM_SYNC_REQUEST to prevent torn frames. */
  if (sdl::utils::isX11Driver())
  {
    if (!SDL_SetHint(SDL_HINT_VIDEO_X11_ENABLE_XSYNC_EXT, "1"))
      WLog_WARN(TAG, "SDL_SetHint(SDL_HINT_VIDEO_X11_ENABLE_XSYNC_EXT) failed: %s",
                SDL_GetError());
  }
#endif
  /* Like Windows, the click that activates a window also reaches the app. */
  if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"))
    WLog_WARN(TAG, "SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH) failed: %s", SDL_GetError());
  return true;
}

invalidateWindow()

void SdlRail::invalidateWindow

(

SDL_WindowID

id

)

Definition at line 182 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow)
    return;
  appWindow->invalidateAll();
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}

noteDragResize()

void SdlRail::noteDragResize	(	SDL_WindowID	id,
		int	w,
		int	h
	)

Definition at line 1258 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if ((_localMove.id == 0) || compositorDrag() || (_localMove.type != RAIL_WMSZ_MOVE))
    return;
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || (static_cast<uint32_t>(appWindow->id()) != _localMove.id))
    return;
  /* Filter out reconcile echo from server drag-restore. */
  if (appWindow->localMoveSizeChanged())
  {
    const SDL_Rect outer = appWindow->outerRect();
    if ((w == outer.w) && (h == outer.h))
      return;
  }
  _localMove.wmSized = true;
  _localMove.wmSize = { w, h };
}

noteLeftPress()

void SdlRail::noteLeftPress ( float  x, float  y  )

inline

Definition at line 100 of file sdl_rail.hpp.

  {
    _lastPressServer = { static_cast<int>(x), static_cast<int>(y) };
    _lastPointerServer = _lastPressServer;
  }

noteLogonPrompt()

void SdlRail::noteLogonPrompt

(

)

Definition at line 499 of file sdl_rail.cpp.

{
  if (_desktopReleased.exchange(true))
    return;
  WLog_DBG(TAG, "logon dialog on the server, showing the desktop");
  if (!sdl_push_user_event(SDL_EVENT_USER_UPDATE))
    WLog_WARN(TAG, "sdl_push_user_event failed");
}

notePopupMoved()

void SdlRail::notePopupMoved

(

SDL_WindowID

id

)

Definition at line 412 of file sdl_rail.cpp.

{
  /* X11 input already matches the server rect; only Wayland lags behind it. */
  if (railPlatformCaps().supportsWindowPositions)
    return;
  std::unique_lock lock(_windowsLock);
  auto* w = getWindowBySdlId(id);
  if (!w || !w->isPopup())
    return;
  w->notePlaced();
  /* Show the held frame now: that commit applies the move. */
  if (!sdl_push_user_event(SDL_EVENT_USER_UPDATE))
    WLog_WARN(TAG, "could not wake the paint loop for a moved popup");
}

noteResizeGrab()

void SdlRail::noteResizeGrab

(

SDL_WindowID

id

)

Definition at line 1394 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return;
  auto* appWindow = getWindowBySdlId(id);
  /* Mouse leave or a configure during the drag: the compositor resize is under way. */
  if (!appWindow || (static_cast<uint32_t>(appWindow->id()) != _localMove.id) ||
      !compositorDrag())
    return;
  _localMove.sawResize = true;
  _localMove.lastResize = SDL_GetTicks();
  if (SDL_AddTimer(kResizeSettleMs, resizeSettleTimer, this) == 0)
    WLog_WARN(TAG, "resize settle timer failed: %s", SDL_GetError());
}

noteServerPointer()

void SdlRail::noteServerPointer ( float  x, float  y  )

inline

Definition at line 106 of file sdl_rail.hpp.

  {
    _lastPointerServer = { static_cast<int>(x), static_cast<int>(y) };
  }

ownsWindow()

bool SdlRail::ownsWindow

(

SDL_WindowID

id

)

Definition at line 176 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  return getWindowBySdlId(id) != nullptr;
}

paint()

bool SdlRail::paint	(	SDL_Surface *	primary,
		SDL_PixelFormat	fallbackFormat,
		const std::vector< SDL_Rect > &	damage
	)

Definition at line 508 of file sdl_rail.cpp.

{
  if (!_enabled)
    return true;
 
  std::unique_lock lock(_windowsLock);
 
  /* Report workarea once (avoids maximizing under local panels). */
  if (_sentWorkArea.w == 0)
  {
    SDL_Rect usable{};
    if (SDL_GetDisplayUsableBounds(SDL_GetPrimaryDisplay(), &usable))
      sendWorkArea(usable);
  }
 
  /* Windows whose SDL parent is going away (deleted by the server, or displaced by a same-id
   * recreate, see addWindow). Popups owned by that window die with it (the server deletes
   * them too), and so do non-popup windows, as before. Any other popup keeps its entry: the
   * server still owns it. A popup without an owner (e.g. a tray notification) is parented to
   * the focused app window as a fallback; deleting it locally when that window closes
   * desynchronizes us from the server, which keeps sending orders for it. It only drops its
   * local SDL window here and the next pass re-creates it under a new parent.
   * SDL destroys child windows together with their parent, so every window that is about to
   * lose its SDL window (deleted, displaced, or under one of those) releases it here, deepest
   * child first, before any entry is destroyed below. */
  std::vector<std::pair<size_t, SdlRailWindow*>> release;
  for (auto& [wid, win] : _windows)
  {
    if (!win.window())
      continue;
    size_t depth = 0;
    bool orphan = false;
    bool ownerDeleted = false;
    for (SDL_Window* p = SDL_GetWindowParent(win.window()); p; p = SDL_GetWindowParent(p))
    {
      depth++;
      auto* owner = getWindowBySdlId(SDL_GetWindowID(p));
      if (!owner)
        orphan = true;
      else if (owner->isDeleted())
      {
        orphan = true;
        if (owner->id() == win.owner())
          ownerDeleted = true;
      }
    }
    if (orphan && !win.isDeleted() && (ownerDeleted || !win.isPopup()))
      win.markDeleted();
    if (orphan || win.isDeleted())
      release.emplace_back(depth, &win);
  }
  for (auto& [wid, win] : _deadWindows)
  {
    if (!win.window())
      continue;
    size_t depth = 0;
    for (SDL_Window* p = SDL_GetWindowParent(win.window()); p; p = SDL_GetWindowParent(p))
      depth++;
    release.emplace_back(depth, &win);
  }
  std::sort(release.begin(), release.end(),
            [](const auto& a, const auto& b) { return a.first > b.first; });
  for (auto& [depth, win] : release)
    win->releaseWindow();
 
  /* Erase deleted windows; their SDL windows are gone already. */
  for (auto it = _windows.begin(); it != _windows.end();)
    it = it->second.isDeleted() ? _windows.erase(it) : std::next(it);
  /* Windows displaced by a same-id recreate (addWindow) also die here, on the main thread. */
  _deadWindows.clear();
 
  /* App windows first so popup parents exist before their popups. */
  for (auto& it : _windows)
  {
    auto& win = it.second;
    if (win.isPopup())
      continue;
    /* Parent owned dialogs to owner. */
    SDL_Window* parent = nullptr;
    SDL_Rect parentRect{};
    auto* owner = resolveParent(win.owner());
    if (owner && (owner != &win))
    {
      parent = owner->window();
      parentRect = owner->outerRect(); /* the SDL window's on-screen geometry */
    }
    win.paint(primary, fallbackFormat, damage, parent, parentRect);
    /* Adopt WM-refused geometry and update server. */
    SDL_Rect refusedOuter{};
    if (win.takeWmOverride(refusedOuter))
    {
      const SDL_Rect rect = win.serverRect(refusedOuter);
      const SDL_Rect cur = win.windowRect();
      WLog_DBG(TAG,
               "wm-refused adopt id=0x%08" PRIx32
               " outer=%dx%d -> srv=%d,%d %dx%d (was %dx%d)",
               static_cast<uint32_t>(win.id()), refusedOuter.w, refusedOuter.h, rect.x,
               rect.y, rect.w, rect.h, cur.w, cur.h);
      if (!SDL_RectsEqual(&rect, &cur))
        sendClientWindowMove(&win, rect);
      win.adoptLocalGeometry(rect);
    }
    /* Resend a size the server left unanswered. */
    SDL_Rect unconfirmed{};
    if (win.takeUnconfirmedReport(unconfirmed) && !win.railMinimized() &&
        !win.effectivelyMaximized())
    {
      WLog_DBG(TAG, "size resent id=0x%08" PRIx32 " %dx%d (not confirmed)",
               static_cast<uint32_t>(win.id()), unconfirmed.w, unconfirmed.h);
      sendClientWindowMove(&win, unconfirmed);
    }
    if (win.takeRestoreRetry())
    {
      WLog_DBG(TAG, "restore resent id=0x%08" PRIx32, static_cast<uint32_t>(win.id()));
      sendSystemCommand(&win, SC_RESTORE);
    }
  }
 
  /* Request full repaint after first window is realized (fixes reconnect blank windows). */
  if (!_refreshSent)
  {
    for (auto& it : _windows)
    {
      if (it.second.isPopup() || !it.second.window())
        continue;
      auto* ctx = &_context->common()->context;
      const auto dw = static_cast<UINT16>(
          freerdp_settings_get_uint32(ctx->settings, FreeRDP_DesktopWidth));
      const auto dh = static_cast<UINT16>(
          freerdp_settings_get_uint32(ctx->settings, FreeRDP_DesktopHeight));
      const RECTANGLE_16 all = { 0, 0, dw, dh };
      if (ctx->update && ctx->update->RefreshRect)
        (void)ctx->update->RefreshRect(ctx, 1, &all);
      _refreshSent = true;
      WLog_DBG(TAG, "refresh-rect sent (first app window realized)");
      break;
    }
  }
 
  for (auto& it : _windows)
  {
    auto& popup = it.second;
    if (!popup.isPopup())
      continue;
 
    /* Latch shadow frame classification once identified. */
    if (!popup.isFrame() && isShadowFrame(popup))
      popup.setFrame(true);
 
    /* Anchor drop shadow to adjoining visible popup. */
    if (popup.isLayered())
    {
      constexpr int reach = 48; /* shadow offset+blur spread from its popup, server px */
      const SDL_Rect sr = popup.windowRect();
      bool anchored = false;
      for (auto& other : _windows)
      {
        auto& cand = other.second;
        if ((&cand == &popup) || !cand.isPopup() || cand.isLayered() || !cand.window() ||
            ((SDL_GetWindowFlags(cand.window()) & SDL_WINDOW_HIDDEN) != 0))
          continue;
        SDL_Rect zone = cand.windowRect();
        zone.x -= reach;
        zone.y -= reach;
        zone.w += 2 * reach;
        zone.h += 2 * reach;
        /* Shadow must be contained within reach zone to distinguish popup shadows from
         * app frame edge shadows. */
        const bool inside = (sr.x >= zone.x) && (sr.y >= zone.y) &&
                            (sr.x + sr.w <= zone.x + zone.w) &&
                            (sr.y + sr.h <= zone.y + zone.h);
        if (inside)
        {
          anchored = true;
          break;
        }
      }
      popup.setShadowAnchored(anchored);
    }
 
    SdlRailWindow* chosen = nullptr;
    /* Existing popups have an immutable SDL parent; position against it. */
    if (auto* pw = popup.window())
    {
      SDL_Window* p = SDL_GetWindowParent(pw);
      chosen = p ? getWindowBySdlId(SDL_GetWindowID(p)) : nullptr;
    }
    else
    {
      chosen = resolvePopupParent(popup);
      if (!chosen)
        WLog_DBG(TAG, "popup id=0x%08" PRIx32 " has no parent app window",
                 static_cast<UINT32>(popup.id()));
    }
 
    SDL_Window* parent = nullptr;
    SDL_Rect parentRect{};
    if (chosen)
    {
      parent = chosen->window();
      parentRect = chosen->outerRect(); /* the SDL window's on-screen geometry */
    }
    popup.paint(primary, fallbackFormat, damage, parent, parentRect);
  }
 
  /* All live windows now have real X11 handles: realize the server's z-order. */
  applyZOrder();
  return true;
}

settleWaylandResize()

void SdlRail::settleWaylandResize

(

)

Definition at line 1383 of file sdl_rail.cpp.

{
  {
    std::unique_lock lock(_windowsLock);
    if ((_localMove.id == 0) || !compositorDrag() || !_localMove.sawResize ||
        (SDL_GetTicks() - _localMove.lastResize < kResizeSettleMs))
      return;
  }
  completeWaylandResize();
}

suppressServerMotion()

bool SdlRail::suppressServerMotion

(

SDL_WindowID

id

)

Definition at line 1054 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return false;
  auto* appWindow = getWindowBySdlId(id);
  /* Suppress motion events during active local move. */
  return appWindow && appWindow->localMoveActive();
}

syncGeometry()

void SdlRail::syncGeometry

(

SDL_WindowID

id

)

Definition at line 1304 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* w = getWindowBySdlId(id);
  if (!w || !w->window() || w->isDeleted() || w->isPopup())
    return;
 
  /* Geometry is server/WM-owned when maximized or minimized. */
  if (w->effectivelyMaximized())
  {
    reportMaximizedWorkArea(w);
    return;
  }
  if (w->railMinimized())
    return;
 
  const auto wid = static_cast<uint32_t>(w->id());
  /* Skip geometry sync while awaiting server restored rect. */
  if (w->localMoveActive() || (_localMove.id == wid) || w->loopEndPending() ||
      w->stateTransitionPending() || w->awaitingRestoreRect() || w->insetsStale())
    return;
 
  int lw = 0;
  int lh = 0;
  SDL_GetWindowSize(w->window(), &lw, &lh);
  if ((lw <= 0) || (lh <= 0))
    return;
 
  /* Ignore invalid zero-content window size updates. */
  const SDL_Rect ins = w->insets();
  if (((lw - ins.x - ins.w) <= 0) || ((lh - ins.y - ins.h) <= 0))
  {
    WLog_DBG(TAG, "geometry sync id=0x%08" PRIx32 " %dx%d dropped (content collapsed)", wid, lw,
             lh);
    return;
  }
 
  const SDL_Rect vis = w->outerRect();
  const bool posKnown = railPlatformCaps().supportsWindowPositions;
  int lx = vis.x;
  int ly = vis.y;
  if (posKnown)
    SDL_GetWindowPosition(w->window(), &lx, &ly);
  else
    clampIntoDesktop(*w, lx, ly, lw, lh);
 
  /* Check if window settled at applied target. */
  if ((lw == vis.w) && (lh == vis.h) && (!posKnown || ((lx == vis.x) && (ly == vis.y))))
  {
    w->clearGeomApplyPending();
    return; /* Ignore self-echo when geometry converged. */
  }
 
  /* Drop transient echo events while client geometry application is in flight. */
  if (w->geomApplyPending())
  {
    /* Allow live Wayland compositor resize to advance beyond in-flight apply. */
    const bool overtaken = !posKnown && ((lw > vis.w) || (lh > vis.h));
    if (!overtaken)
      return;
    w->clearGeomApplyPending();
  }
 
  WLog_DBG(TAG, "geometry sync id=0x%08" PRIx32 " local=%d,%d %dx%d (sync)", wid, lx, ly, lw, lh);
  reportAndAdopt(w, lx, ly, lw, lh);
}

translateToServer()

bool SdlRail::translateToServer	(	SDL_WindowID	id,
		float &	x,
		float &	y
	)

Definition at line 384 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow)
    return false;
  SDL_FPoint rpos = { x, y };
  if (auto* renderer = appWindow->renderer())
    (void)SDL_RenderCoordinatesFromWindow(renderer, x, y, &rpos.x, &rpos.y);
  /* Window-local to server-absolute, aligned with surface blit anchor. */
  SDL_Point origin = appWindow->serverOrigin();
  SDL_Point rel{};
  if (appWindow->isPopup() && !railPlatformCaps().supportsWindowPositions &&
      appWindow->placedRel(rel))
  {
    auto* sdlParent = SDL_GetWindowParent(appWindow->window());
    if (auto* parent = sdlParent ? getWindowBySdlId(SDL_GetWindowID(sdlParent)) : nullptr)
    {
      const SDL_Rect pr = parent->outerRect();
      origin = { pr.x + rel.x, pr.y + rel.y };
    }
  }
  /* Input is relative to the top left of the remote desktop, not to the primary monitor. */
  x = rpos.x + static_cast<float>(origin.x - _inputOrigin.x);
  y = rpos.y + static_cast<float>(origin.y - _inputOrigin.y);
  return true;
}

uninit()

bool SdlRail::uninit

(

RailClientContext *

rail

)

Definition at line 877 of file sdl_rail.cpp.

{
  WINPR_ASSERT(rail);
  /* The caller clears rail->custom next; server callbacks return early on nullptr. */
  std::unique_lock lock(_windowsLock);
  _refreshSent = false;
  _appStarted = false;
  /* Reset session and move state on reconnect. */
  _localMove = {};
  _sessionMargins = {};
  _sentWorkArea = {};
  _clientActiveId = 0;
  _focusedAppId = 0;
  _zOrder.clear();
  _appliedZOrder.clear();
  _zOrderDirty = false;
  _iconCache.clear();
  _iconScratch = {};
  /* Mark windows for main-thread teardown. */
  WLog_DBG(TAG, "RAIL channel uninit, marking %zu windows for main-thread teardown",
           _windows.size());
  for (auto& kv : _windows)
    kv.second.markDeleted();
  _rail = nullptr;
  _enabled = false;
  /* The next connection logs on again: hold its logon desktop back too. */
  _desktopReleased = false;
  _desktopHoldUntil = 0;
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return true;
}

updateCoordinates()

void SdlRail::updateCoordinates

(

)

Definition at line 445 of file sdl_rail.cpp.

{
  const auto* settings = _context->common()->context.settings;
  _displayShift = { freerdp_settings_get_int32(settings, FreeRDP_MonitorLocalShiftX),
                  freerdp_settings_get_int32(settings, FreeRDP_MonitorLocalShiftY) };
  _localShift = railPlatformCaps().supportsWindowPositions ? _displayShift : SDL_Point{ 0, 0 };
  _inputOrigin = { 0, 0 };
  const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
  for (UINT32 x = 0; x < count; x++)
  {
    const auto* mon = static_cast<const rdpMonitor*>(
        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x));
    if (!mon)
      continue;
    _inputOrigin.x = std::min(_inputOrigin.x, mon->x);
    _inputOrigin.y = std::min(_inputOrigin.y, mon->y);
  }
  WLog_DBG(TAG, "coordinates: display shift %d,%d window shift %d,%d input origin %d,%d",
           _displayShift.x, _displayShift.y, _localShift.x, _localShift.y, _inputOrigin.x,
           _inputOrigin.y);
}

updateWindowFromSurface()

UINT SdlRail::updateWindowFromSurface

(

gdiGfxSurface *

surface

)

Definition at line 774 of file sdl_rail.cpp.

{
  if (!surface)
    return CHANNEL_RC_OK;
 
  std::unique_lock lock(_windowsLock);
  auto appWindow = getWindow(surface->windowId);
  if (!appWindow)
  {
    /* Drop GFX surface for unknown windows (repaints later). */
    WLog_VRB(TAG, "gfx surface for untracked id=0x%08" PRIx64, surface->windowId);
    return CHANNEL_RC_OK;
  }
 
  /* Clamp mapped dimensions to allocated surface bounds. */
  const uint32_t w =
      std::min(surface->mappedWidth ? surface->mappedWidth : surface->width, surface->width);
  const uint32_t h =
      std::min(surface->mappedHeight ? surface->mappedHeight : surface->height, surface->height);
 
  /* Consume per-frame damage. */
  UINT32 nbRects = 0;
  const RECTANGLE_16* rects = region16_rects(&surface->invalidRegion, &nbRects);
  /* Skip undamaged surfaces during EndFrame. */
  const bool remapped = appWindow->takeSurfaceChange(surface->surfaceId);
  if ((nbRects == 0) && !remapped)
    return CHANNEL_RC_OK;
  appWindow->updateGfxSurface(surface->data, surface->scanline, w, h, rects, nbRects,
                              surface->format);
  region16_clear(&surface->invalidRegion);
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return CHANNEL_RC_OK;
}

UpdateWindowFromSurface()

UINT SdlRail::UpdateWindowFromSurface ( RdpgfxClientContext *  context, gdiGfxSurface *  surface  )

static

Definition at line 809 of file sdl_rail.cpp.

{
  WINPR_ASSERT(context);
  auto gdi = static_cast<rdpGdi*>(context->custom);
  if (!gdi || !gdi->context)
    return CHANNEL_RC_OK;
  auto sdl = get_context(gdi->context);
  if (!sdl)
    return CHANNEL_RC_OK;
  return sdl->getRailChannelContext().updateWindowFromSurface(surface);
}

---

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

• sdl_rail.hpp
• sdl_rail.cpp