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	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	ensureActive (SDL_WindowID id)
bool	translateToServer (SDL_WindowID id, float &x, float &y)
void	noteLeftPress (float x, float y)
void	noteServerPointer (float x, float y)
bool	suppressServerInput (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	handleWaylandResize (SDL_WindowID id)

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 44 of file sdl_rail.cpp.

                                    : _context(context)
{
}

Member Function Documentation

completeLocalMoveIfPending()

void SdlRail::completeLocalMoveIfPending

(

)

Definition at line 1262 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return;
  /* Skip Wayland button-up finalize. */
  if (_localMove.wayland)
    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))
    (void)sdl_x11_send_left_button_release(appWindow->window());
 
  /* 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 ii = appWindow->insets();
      px = drag.pointer.x + (x + ii.x) - sp.x;
      py = drag.pointer.y + (y + ii.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(x, y, w, h);
    reportAndAdopt(appWindow, x, y, w, h);
  }
 
  (void)sdl_x11_set_bit_gravity(appWindow->window(), 0 /* reset to default */);
}

completeWaylandResize()

void SdlRail::completeWaylandResize

(

bool

definitive = false

)

Definition at line 1217 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if ((_localMove.id == 0) || !_localMove.wayland)
    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->windowRect();
  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(x, y, w, h);
  reportAndAdopt(appWindow, x, y, w, h);
}

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 347 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || (appWindow->isPopup() && !appWindow->isFullscreen()) || !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 262 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);
}

handleFocus()

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

Definition at line 294 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto appWindow = getWindowBySdlId(id);
  if (!appWindow || (appWindow->isPopup() && !appWindow->isFullscreen()) || !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 947 of file sdl_rail.cpp.

{
  const bool wayland = sdl::utils::isWaylandDriver();
  const bool x11 = sdl::utils::isX11Driver();
  if (!wayland && !x11)
    return;
 
  std::unique_lock lock(_windowsLock);
  auto appWindow = getWindow(windowId);
  if (!appWindow || !appWindow->window() || appWindow->isPopup())
    return;
 
  const bool isMove = (moveType == RAIL_WMSZ_MOVE);
  WLog_DBG(TAG, "local move start id=0x%08" PRIx32 " driver=%s type=%" PRIu16 " %s", windowId,
           wayland ? "wayland" : "x11", moveType, isMove ? "move" : "resize");
  bool started = false;
  if (wayland)
  {
    /* Wayland: positions unreadable, sizes readable. */
    if (isMove)
      started = sdl_wayland_begin_move(appWindow->window());
    else
      started = sdl_wayland_begin_resize(appWindow->window(), railToXdgEdge(moveType));
    if (started && !isMove)
    {
      _localMove = {}; /* clear all per-drag state as a unit before latching this drag */
      _localMove.id = windowId;
      _localMove.wayland = true;
      _localMove.type = moveType;
    }
  }
  else
  {
    /* X11: hand resize to WM, suppress input. */
    started = sdl_x11_begin_move_size(appWindow->window(), railToNetDirection(moveType));
    if (started)
    {
      _localMove = {}; /* clear all per-drag state as a unit before latching this drag */
      _localMove.id = windowId;
      _localMove.type = moveType;
      /* Latch drag anchors for release calculation. */
      _localMove.anchor = _lastPressServer;
      _localMove.pointer = _lastPointerServer;
      /* Clear prior loop-end state on new drag. */
      appWindow->clearLoopEnd();
      /* Set bit gravity to fixed edge. */
      const RailEdges e = railEdges(moveType);
      const int row = e.top ? 2 : (e.bottom ? 0 : 1);
      const int col = e.left ? 2 : (e.right ? 0 : 1);
      (void)sdl_x11_set_bit_gravity(appWindow->window(), row * 3 + col + 1);
    }
  }
  /* Drive local frame during X11/Wayland drag. */
  if (started && (!wayland || !isMove))
  {
    appWindow->setLocalMoveActive(true);
    if (!isMove)
    {
      /* Anchor the stale frame to the fixed edge (opposite the dragged one). */
      const RailEdges e = railEdges(moveType);
      appWindow->setResizeAnchor(e.left, e.top);
    }
  }
  else if (!started)
  {
    WLog_WARN(TAG, "WM move failed for RAIL window 0x%08" PRIx32, windowId);
  }
}

handleMaximized()

void SdlRail::handleMaximized

(

SDL_WindowID

id

)

Definition at line 215 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  /* Skip the echo of reconcile's own SDL_MaximizeWindow (railMaximized already set). */
  if (appWindow->railMaximized())
  {
    WLog_DBG(TAG, "local maximize skipped id=0x%08" PRIx32 " (already rail-maximized)",
             static_cast<UINT32>(appWindow->id()));
    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);
  }
  lock.unlock();
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}

handleMinimized()

void SdlRail::handleMinimized

(

SDL_WindowID

id

)

Definition at line 248 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 273 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  /* Resolve which state a RESTORED event ends; both clear = echo of our own restore, skip. */
  if (appWindow->railMinimized())
    appWindow->setRailMinimized(false);
  else if (appWindow->railMaximized())
    appWindow->setRailMaximized(false);
  else
    return;
  WLog_DBG(TAG, "local restore id=0x%08" PRIx32 " -> SC_RESTORE",
           static_cast<UINT32>(appWindow->id()));
  appWindow->invalidateAll();
  sendSystemCommand(appWindow, SC_RESTORE);
  lock.unlock();
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}

handleWaylandResize()

void SdlRail::handleWaylandResize

(

SDL_WindowID

id

)

Definition at line 1185 of file sdl_rail.cpp.

{
  if (!sdl::utils::isWaylandDriver())
    return;
  std::unique_lock lock(_windowsLock);
  auto* appWindow = getWindowBySdlId(id);
  if (!appWindow || appWindow->isPopup() || !appWindow->window())
    return;
  /* Track resize for active dragged window. */
  if (static_cast<uint32_t>(appWindow->id()) == _localMove.id)
  {
    if (_localMove.wayland)
      _localMove.sawResize = true;
    return;
  }
 
  int w = 0;
  int h = 0;
  SDL_GetWindowSize(appWindow->window(), &w, &h);
  if ((w <= 0) || (h <= 0))
    return;
 
  /* Local window size is the OUTER frame (rect + insets; identical off the inset paths). */
  const SDL_Rect vis = appWindow->outerRect();
  if ((w == vis.w) && (h == vis.h))
    return; /* echo of a size we already reported/applied - nothing new */
 
  /* Compositor snap/tile: report via the debounced sync (never from transitional state). */
  lock.unlock();
  syncGeometry(id);
}

init()

bool SdlRail::init

(

RailClientContext *

rail

)

Definition at line 666 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");
  const RailPlatformCaps& caps = railPlatformCaps();
  WLog_DBG(TAG, "RAIL channel initialized: driver=%s positionsReadable=%d transparentWindows=%d",
           sdl::utils::isWaylandDriver() ? "wayland"
                                         : (sdl::utils::isX11Driver() ? "x11" : "other"),
           caps.positionsReadable ? 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())
    SDL_SetHint(SDL_HINT_VIDEO_X11_ENABLE_XSYNC_EXT, "1");
#endif
  return true;
}

invalidateWindow()

void SdlRail::invalidateWindow

(

SDL_WindowID

id

)

Definition at line 175 of file sdl_rail.cpp.

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

noteDragResize()

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

Definition at line 1063 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if ((_localMove.id == 0) || _localMove.wayland || (_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 91 of file sdl_rail.hpp.

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

noteResizeGrab()

void SdlRail::noteResizeGrab

(

SDL_WindowID

id

)

Definition at line 1173 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return;
  auto* appWindow = getWindowBySdlId(id);
  /* Confirm compositor pointer grab on mouse leave during active drag resize. */
  if (appWindow && (static_cast<uint32_t>(appWindow->id()) == _localMove.id) &&
      _localMove.wayland)
    _localMove.sawResize = true;
}

noteServerPointer()

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

inline

Definition at line 97 of file sdl_rail.hpp.

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

ownsWindow()

bool SdlRail::ownsWindow

(

SDL_WindowID

id

)

Definition at line 169 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 396 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);
  }
 
  /* Cascade deletion to child popups whose SDL parent was deleted. */
  for (auto& [wid, win] : _windows)
  {
    if (win.isDeleted() || !win.window())
      continue;
    for (SDL_Window* p = SDL_GetWindowParent(win.window()); p; p = SDL_GetWindowParent(p))
    {
      auto* owner = getWindowBySdlId(SDL_GetWindowID(p));
      if (!owner || owner->isDeleted())
      {
        win.markDeleted();
        break;
      }
    }
  }
 
  /* Erase deleted windows deepest child first to avoid SDL child double-free. */
  std::vector<std::pair<size_t, uint64_t>> dead;
  for (auto& [wid, win] : _windows)
  {
    if (!win.isDeleted())
      continue;
    size_t depth = 0;
    for (SDL_Window* p = win.window() ? SDL_GetWindowParent(win.window()) : nullptr; p;
         p = SDL_GetWindowParent(p))
      depth++;
    dead.emplace_back(depth, wid);
  }
  std::sort(dead.begin(), dead.end(),
            [](const auto& a, const auto& b) { return a.first > b.first; });
  for (const auto& [depth, wid] : dead)
    _windows.erase(wid);
  /* 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);
    }
  }
 
  /* 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;
}

suppressServerInput()

bool SdlRail::suppressServerInput

(

SDL_WindowID

id

)

Definition at line 864 of file sdl_rail.cpp.

{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return false;
  auto* appWindow = getWindowBySdlId(id);
  return appWindow && appWindow->localMoveActive() && !_localMove.wayland;
}

suppressServerMotion()

bool SdlRail::suppressServerMotion

(

SDL_WindowID

id

)

Definition at line 873 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 1106 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())
    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().positionsReadable;
  int lx = vis.x;
  int ly = vis.y;
  if (posKnown)
    SDL_GetWindowPosition(w->window(), &lx, &ly);
  else
    clampIntoDesktop(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 359 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. */
  const SDL_Point origin = appWindow->serverOrigin();
  x = rpos.x + static_cast<float>(origin.x);
  y = rpos.y + static_cast<float>(origin.y);
  return true;
}

uninit()

bool SdlRail::uninit

(

RailClientContext *

rail

)

Definition at line 711 of file sdl_rail.cpp.

{
  WINPR_ASSERT(rail);
  /* Leave rail->custom set: the server callbacks only assert it, so clearing it would crash a
   * late order in a release build. _enabled gates them instead. */
  std::unique_lock lock(_windowsLock);
  _refreshSent = 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;
  lock.unlock();
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return true;
}

updateWindowFromSurface()

UINT SdlRail::updateWindowFromSurface

(

gdiGfxSurface *

surface

)

Definition at line 619 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 654 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