sdl_rail.cpp

 
#include <algorithm>
#include <tuple>
#include <utility>
#include <vector>
 
#include <winpr/assert.h>
#include <winpr/platform.h>
#include <winpr/cast.h>
 
#include <freerdp/freerdp.h>
#include <freerdp/log.h>
#include <freerdp/codec/color.h>
#include <freerdp/codec/region.h>
#include <freerdp/client/rail.h>
 
#include "sdl_rail.hpp"
#include "sdl_context.hpp"
#include "sdl_rail_platform.hpp"
#include "sdl_types.hpp"
#include "sdl_utils.hpp"
#include "sdl_wayland.hpp"
#include "sdl_x11.hpp"
 
#define TAG CLIENT_TAG("sdl.rail")
 
SdlRail::SdlRail(SdlContext* context) : _context(context)
{
}
 
SdlRail::~SdlRail() = default;
 
SdlRail* SdlRail::get(rdpContext* context)
{
  auto sdl = get_context(context);
  if (!sdl)
    return nullptr;
  return &sdl->getRailChannelContext();
}
 
SdlRailWindow* SdlRail::getWindow(uint64_t id)
{
  auto it = _windows.find(id);
  return (it == _windows.end()) ? nullptr : &it->second;
}
 
SdlRailWindow* SdlRail::getWindowBySdlId(SDL_WindowID id)
{
  if (id == 0)
    return nullptr;
  for (auto& it : _windows)
  {
    if (it.second.sdlId() == id)
      return &it.second;
  }
  return nullptr;
}
 
/* Test if popup adjoins window edge from outside. */
static bool adjoinsOutside(const SDL_Rect& popup, const SDL_Rect& win)
{
  SDL_Rect hit{};
  if (SDL_GetRectIntersection(&popup, &win, &hit))
    return false;
  const SDL_Rect grown = { win.x - 1, win.y - 1, win.w + 2, win.h + 2 };
  return SDL_GetRectIntersection(&popup, &grown, &hit);
}
 
/* Fullscreen popups (e.g. slide shows) act as toplevels and can parent popups. */
static bool canParentPopup(const SdlRailWindow& w)
{
  return (!w.isPopup() || w.isFullscreen()) && (w.window() != nullptr);
}
 
SdlRailWindow* SdlRail::resolveParent(uint64_t ownerId)
{
  auto* owner = getWindow(ownerId);
  if (owner && canParentPopup(*owner))
    return owner;
  return nullptr;
}
 
/* Pick a popup's parent app window: ownerWindowId -> geometric containment -> focused -> any app.
 */
SdlRailWindow* SdlRail::resolvePopupParent(const SdlRailWindow& popup)
{
  SdlRailWindow* chosen = resolveParent(popup.owner());
  if (!chosen)
  {
    const SDL_Rect pr = popup.windowRect();
    const SDL_Point origin = { pr.x, pr.y };
    for (uint32_t id : _zOrder)
    {
      auto* w = getWindow(id);
      if (!w || !canParentPopup(*w))
        continue;
      const SDL_Rect wr = w->windowRect();
      if (SDL_PointInRect(&origin, &wr))
      {
        chosen = w;
        break;
      }
    }
    if (!chosen)
    {
      for (auto& other : _windows)
      {
        auto& w = other.second;
        if (!canParentPopup(w))
          continue;
        const SDL_Rect wr = w.windowRect();
        if (SDL_PointInRect(&origin, &wr))
        {
          chosen = &w;
          break;
        }
      }
    }
  }
  if (!chosen)
    chosen = resolveParent(_focusedAppId);
  if (!chosen)
  {
    for (auto& other : _windows)
    {
      auto& w = other.second;
      if (canParentPopup(w))
      {
        chosen = &w;
        break;
      }
    }
  }
  return chosen;
}
 
/* Identify companion shadow frames adjoining owner window. */
bool SdlRail::isShadowFrame(const SdlRailWindow& popup)
{
  if (!popup.isLayered())
    return false;
  const SDL_Rect pr = popup.windowRect();
  for (auto& other : _windows)
  {
    auto& w = other.second;
    if (canParentPopup(w) && adjoinsOutside(pr, w.windowRect()))
      return true;
  }
  return false;
}
 
bool SdlRail::ownsWindow(SDL_WindowID id)
{
  std::unique_lock lock(_windowsLock);
  return getWindowBySdlId(id) != nullptr;
}
 
void SdlRail::invalidateWindow(SDL_WindowID id)
{
  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);
}
 
/* Caller holds _windowsLock. */
void SdlRail::sendSystemCommand(SdlRailWindow* appWindow, uint16_t command)
{
  if (!_rail || !_rail->ClientSystemCommand)
    return;
  RAIL_SYSCOMMAND_ORDER syscommand = {};
  syscommand.windowId = static_cast<UINT32>(appWindow->id());
  syscommand.command = command;
  std::ignore = _rail->ClientSystemCommand(_rail, &syscommand);
}
 
void SdlRail::sendWorkArea(const SDL_Rect& area)
{
  if (!_rail || !_rail->ClientSystemParam || (area.w <= 0) || (area.h <= 0))
    return;
  if (SDL_RectsEqual(&area, &_sentWorkArea))
    return;
 
  RAIL_SYSPARAM_ORDER param = {};
  /* ClientSystemParam dispatches on the params mask, not .param. */
  param.params = SPI_MASK_SET_WORK_AREA;
  param.workArea.left = WINPR_ASSERTING_INT_CAST(UINT16, area.x);
  param.workArea.top = WINPR_ASSERTING_INT_CAST(UINT16, area.y);
  param.workArea.right = WINPR_ASSERTING_INT_CAST(UINT16, area.x + area.w);
  param.workArea.bottom = WINPR_ASSERTING_INT_CAST(UINT16, area.y + area.h);
  if (_rail->ClientSystemParam(_rail, &param) == CHANNEL_RC_OK)
    _sentWorkArea = area;
}
 
void SdlRail::handleMaximized(SDL_WindowID id)
{
  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);
}
 
void SdlRail::handleMinimized(SDL_WindowID id)
{
  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);
}
 
void SdlRail::handleClose(SDL_WindowID id)
{
  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);
}
 
void SdlRail::handleRestored(SDL_WindowID id)
{
  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);
}
 
void SdlRail::handleFocus(SDL_WindowID id, bool gained)
{
  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);
}
 
/* Send RAIL_ACTIVATE_ORDER and track the active window id. Caller holds _windowsLock. */
void SdlRail::sendClientActivate(uint32_t wid, bool enabled)
{
  if (!_rail || !_rail->ClientActivate)
    return;
  if (enabled)
    _clientActiveId = wid;
  RAIL_ACTIVATE_ORDER activate = {};
  activate.windowId = wid;
  activate.enabled = enabled;
  std::ignore = _rail->ClientActivate(_rail, &activate);
}
 
/* Activate clicked window on server to route input correctly. */
void SdlRail::ensureActive(SDL_WindowID id)
{
  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);
}
 
bool SdlRail::translateToServer(SDL_WindowID id, float& x, float& y)
{
  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;
}
 
SdlRailWindow* SdlRail::addWindow(uint64_t id, const SDL_Rect& rect)
{
  /* Move deleted entry aside so new window can reuse the ID. */
  auto it = _windows.find(id);
  if ((it != _windows.end()) && it->second.isDeleted())
  {
    WLog_DBG(TAG, "window recreate id=0x%08" PRIx32 " reused a deleted entry",
             static_cast<uint32_t>(id));
    _deadWindows.insert(_windows.extract(it));
  }
  /* emplace is a no-op if the id already exists; either way first->second is the window. */
  auto res = _windows.emplace(std::piecewise_construct, std::forward_as_tuple(id),
                              std::forward_as_tuple(id, rect));
  return &res.first->second;
}
 
void SdlRail::enableRemoteAppMode(bool enable)
{
  _enabled = enable;
}
 
bool SdlRail::paint(SDL_Surface* primary, SDL_PixelFormat fallbackFormat,
                    const std::vector<SDL_Rect>& damage)
{
  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;
}
 
/* Caller holds _windowsLock (main thread). */
void SdlRail::applyZOrder()
{
  if (!_zOrderDirty)
    return;
  /* X11 only: Wayland/Win/macOS have no reparenting-safe, focus-neutral restack path here. */
  if (!railPlatformCaps().supportsRestack)
  {
    _zOrderDirty = false;
    return;
  }
  /* Never restack the window the WM is actively dragging; keep dirty and retry after the move. */
  if (_localMove.id != 0)
  {
    WLog_VRB(TAG, "zorder apply deferred: local move 0x%08" PRIx32 " active", _localMove.id);
    return;
  }
  /* Restack top-level windows (skip popups and hidden windows). */
  std::vector<SDL_Window*> stack;
  std::vector<uint32_t> applied;
  stack.reserve(_zOrder.size());
  applied.reserve(_zOrder.size());
  for (uint32_t id : _zOrder)
  {
    auto* w = getWindow(id);
    if (w && !w->isPopup() && w->window() &&
        ((SDL_GetWindowFlags(w->window()) & SDL_WINDOW_HIDDEN) == 0))
    {
      stack.push_back(w->window());
      applied.push_back(id);
    }
  }
  /* Dedup against the restacked set; menus and unrealized windows are filtered out. */
  if (applied == _appliedZOrder)
  {
    _zOrderDirty = false;
    return;
  }
  if (stack.size() >= 2)
  {
    std::ignore = sdl_x11_restack_windows(stack);
  }
 
  _appliedZOrder = std::move(applied);
  _zOrderDirty = false;
}
 
UINT SdlRail::updateWindowFromSurface(gdiGfxSurface* surface)
{
  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;
}
 
UINT SdlRail::UpdateWindowFromSurface(RdpgfxClientContext* context, gdiGfxSurface* surface)
{
  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);
}
 
bool SdlRail::init(RailClientContext* rail)
{
  _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;
}
 
bool SdlRail::uninit(WINPR_ATTR_UNUSED RailClientContext* rail)
{
  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;
}
 
void SdlRail::registerUpdateCallbacks(rdpUpdate* update)
{
  WINPR_ASSERT(update);
  auto window = update->window;
  WINPR_ASSERT(window);
 
  window->WindowCreate = SdlRail::window_common;
  window->WindowUpdate = SdlRail::window_common;
  window->WindowIcon = SdlRail::window_icon;
  window->WindowCachedIcon = SdlRail::window_cached_icon;
  window->WindowDelete = SdlRail::window_delete;
  window->MonitoredDesktop = SdlRail::monitored_desktop;
  window->NonMonitoredDesktop = SdlRail::non_monitored_desktop;
}
 
/* --- server callbacks --- */
 
UINT SdlRail::server_execute_result(RailClientContext* context,
                                    const RAIL_EXEC_RESULT_ORDER* execResult)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(execResult);
  auto rail = static_cast<SdlRail*>(context->custom);
  WINPR_ASSERT(rail);
 
  if (execResult->execResult != RAIL_EXEC_S_OK)
  {
    WLog_ERR(TAG, "RAIL exec error: execResult=0x%04" PRIx16 " rawResult=0x%08" PRIx32,
             execResult->execResult, execResult->rawResult);
    freerdp_abort_connect_context(rail->_context->context());
  }
  else
  {
    WLog_DBG(TAG, "RemoteApp exec OK, enabling RAIL mode");
    rail->enableRemoteAppMode(true);
  }
  return CHANNEL_RC_OK;
}
 
UINT SdlRail::server_local_move_size(RailClientContext* context,
                                     const RAIL_LOCALMOVESIZE_ORDER* localMoveSize)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(localMoveSize);
 
  /* Start native move/resize to avoid dual-authority geometry races. */
  if (localMoveSize->isMoveSizeStart && (localMoveSize->moveSizeType >= RAIL_WMSZ_LEFT) &&
      (localMoveSize->moveSizeType <= RAIL_WMSZ_MOVE))
  {
    WLog_DBG(TAG, "server move/size start id=0x%08" PRIx32 " type=%" PRIu16 " pos=%d,%d",
             localMoveSize->windowId, localMoveSize->moveSizeType, localMoveSize->posX,
             localMoveSize->posY);
    (void)sdl_push_user_event(SDL_EVENT_USER_RAIL_MOVE, localMoveSize->windowId,
                              static_cast<int>(localMoveSize->moveSizeType));
  }
  else if (!localMoveSize->isMoveSizeStart)
  {
    WLog_DBG(TAG, "server move/size end id=0x%08" PRIx32, localMoveSize->windowId);
    /* Server ended the move/size: resume applying geometry + input (covers Wayland move). */
    auto rail = static_cast<SdlRail*>(context->custom);
    if (rail)
    {
      std::unique_lock lock(rail->_windowsLock);
      /* Ignore server END order during Wayland resize unless unstarted. */
      const bool ownedByWaylandResize = rail->_localMove.wayland &&
                                        (rail->_localMove.id == localMoveSize->windowId) &&
                                        rail->_localMove.sawResize;
      if (!ownedByWaylandResize)
      {
        if (auto* appWindow = rail->getWindow(localMoveSize->windowId))
          appWindow->setLocalMoveActive(false);
        if (rail->_localMove.id == localMoveSize->windowId)
        {
          if (rail->_localMove.wayland)
          {
            /* Wayland drag completed. */
            rail->_localMove = {};
            if (auto* appWindow = rail->getWindow(localMoveSize->windowId))
              appWindow->invalidateAll();
            (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
          }
          else
          {
            /* Server ended drag loop early. */
            rail->_localMove.serverEnded = true;
          }
        }
      }
      /* Execute deferred actions now that modal loop has closed. */
      auto* appWindow = rail->getWindow(localMoveSize->windowId);
      if (appWindow && appWindow->loopEndPending())
      {
        const auto actions = appWindow->takeLoopEnd();
        if (actions.maximize && appWindow->railMaximized())
        {
          WLog_DBG(TAG, "deferred SC_MAXIMIZE id=0x%08" PRIx32, localMoveSize->windowId);
          rail->sendSystemCommand(appWindow, SC_MAXIMIZE);
        }
        if (actions.snap)
        {
          /* Send deferred snap resize. */
          WLog_DBG(TAG, "deferred snap resize id=0x%08" PRIx32 " rect=%d,%d %dx%d",
                   localMoveSize->windowId, actions.snapRect.x, actions.snapRect.y,
                   actions.snapRect.w, actions.snapRect.h);
          rail->sendClientWindowMove(appWindow, actions.snapRect);
        }
        /* WM resize can land after button-up (e.g. KDE tiling) while syncGeometry was
         * latched out. Sync post-loop geometry now; also needed for deferred snaps where
         * snapRect preceded the WM's final tile size. */
        if (appWindow->window() && !appWindow->effectivelyMaximized() &&
            !appWindow->localMoveSizeChanged())
        {
          const SDL_WindowID sdlId = appWindow->sdlId();
          lock.unlock();
          rail->syncGeometry(sdlId);
        }
      }
    }
  }
  return CHANNEL_RC_OK;
}
 
/* X11 only: suppress button-up during modal loop. */
bool SdlRail::suppressServerInput(SDL_WindowID id)
{
  std::unique_lock lock(_windowsLock);
  if (_localMove.id == 0)
    return false;
  auto* appWindow = getWindowBySdlId(id);
  return appWindow && appWindow->localMoveActive() && !_localMove.wayland;
}
 
bool SdlRail::suppressServerMotion(SDL_WindowID id)
{
  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();
}
 
/* RAIL_WMSZ_* -> _NET_WM_MOVERESIZE direction (0..7 = resize edges, 8 = move). */
static int railToNetDirection(uint16_t moveType)
{
  switch (moveType)
  {
    case RAIL_WMSZ_TOPLEFT:
      return 0;
    case RAIL_WMSZ_TOP:
      return 1;
    case RAIL_WMSZ_TOPRIGHT:
      return 2;
    case RAIL_WMSZ_RIGHT:
      return 3;
    case RAIL_WMSZ_BOTTOMRIGHT:
      return 4;
    case RAIL_WMSZ_BOTTOM:
      return 5;
    case RAIL_WMSZ_BOTTOMLEFT:
      return 6;
    case RAIL_WMSZ_LEFT:
      return 7;
    case RAIL_WMSZ_MOVE:
    default:
      return 8;
  }
}
 
/* RAIL_WMSZ_* <-> XDG_TOPLEVEL_RESIZE_EDGE_* edge mappings. */
static constexpr struct
{
  uint16_t rail;
  uint32_t xdg;
} kRailXdgEdges[] = {
  { RAIL_WMSZ_TOP, 1 },      { RAIL_WMSZ_BOTTOM, 2 },       { RAIL_WMSZ_LEFT, 4 },
  { RAIL_WMSZ_TOPLEFT, 5 },  { RAIL_WMSZ_BOTTOMLEFT, 6 },   { RAIL_WMSZ_RIGHT, 8 },
  { RAIL_WMSZ_TOPRIGHT, 9 }, { RAIL_WMSZ_BOTTOMRIGHT, 10 },
};
 
/* RAIL_WMSZ_* -> XDG_TOPLEVEL_RESIZE_EDGE_* (0 = none, e.g. RAIL_WMSZ_MOVE). */
static uint32_t railToXdgEdge(uint16_t moveType)
{
  for (const auto& e : kRailXdgEdges)
    if (e.rail == moveType)
      return e.xdg;
  return 0;
}
 
/* Which window edges a RAIL_WMSZ_* drag moves; the opposite edges stay anchored. */
struct RailEdges
{
  bool left = false;
  bool right = false;
  bool top = false;
  bool bottom = false;
};
static RailEdges railEdges(uint16_t t)
{
  return { (t == RAIL_WMSZ_TOPLEFT) || (t == RAIL_WMSZ_LEFT) || (t == RAIL_WMSZ_BOTTOMLEFT),
         (t == RAIL_WMSZ_TOPRIGHT) || (t == RAIL_WMSZ_RIGHT) || (t == RAIL_WMSZ_BOTTOMRIGHT),
         (t == RAIL_WMSZ_TOPLEFT) || (t == RAIL_WMSZ_TOP) || (t == RAIL_WMSZ_TOPRIGHT),
         (t == RAIL_WMSZ_BOTTOMLEFT) || (t == RAIL_WMSZ_BOTTOM) ||
             (t == RAIL_WMSZ_BOTTOMRIGHT) };
}
 
void SdlRail::handleLocalMoveRequested(uint32_t windowId, uint16_t moveType)
{
  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);
  }
}
 
/* Send ClientWindowMove with full frame geometry including server margins (caller holds
 * _windowsLock). */
void SdlRail::sendClientWindowMove(SdlRailWindow* appWindow, const SDL_Rect& serverRect)
{
  const SDL_Rect fm = appWindow->frameMargins();
  RAIL_WINDOW_MOVE_ORDER move = {};
  move.windowId = static_cast<UINT32>(appWindow->id());
  move.left = WINPR_ASSERTING_INT_CAST(INT16, serverRect.x - fm.x);
  move.top = WINPR_ASSERTING_INT_CAST(INT16, serverRect.y - fm.y);
  move.right = WINPR_ASSERTING_INT_CAST(INT16, serverRect.x + serverRect.w + fm.w);
  move.bottom = WINPR_ASSERTING_INT_CAST(INT16, serverRect.y + serverRect.h + fm.h);
  if (_rail && _rail->ClientWindowMove &&
      (_rail->ClientWindowMove(_rail, &move) != CHANNEL_RC_OK))
    WLog_WARN(TAG, "ClientWindowMove failed for RAIL window 0x%08" PRIx32, move.windowId);
}
 
/* Report final geometry and adopt locally. */
void SdlRail::reportAndAdopt(SdlRailWindow* appWindow, int x, int y, int w, int h)
{
  /* Local geometry -> server rect: strip the client-side band insets. */
  const SDL_Rect rect = appWindow->serverRect({ x, y, w, h });
  /* Report outer frame to server (inflate by margins). */
  const bool maximized = appWindow->effectivelyMaximized();
  /* Report geometry if changed. */
  const SDL_Rect cur = appWindow->windowRect();
  const bool unchanged = SDL_RectsEqual(&rect, &cur);
  if (!maximized && !unchanged)
    sendClientWindowMove(appWindow, rect);
 
  /* Adopt WM final geometry and resume input routing. */
  if (maximized)
    appWindow->setLocalMoveActive(false); /* geometry is WM/server-owned while maximized */
  else
    appWindow->adoptLocalGeometry(rect);
  /* Repaint now: the last presented frame may still be the resize placeholder. */
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
}
 
void SdlRail::clampIntoDesktop(int& x, int& y, int w, int h) const
{
  auto* settings = _context->context()->settings;
  const int dw = static_cast<int>(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth));
  const int dh = static_cast<int>(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
  x = std::clamp(x, 0, std::max(0, dw - w));
  y = std::clamp(y, 0, std::max(0, dh - h));
}
 
void SdlRail::noteDragResize(SDL_WindowID id, int w, int h)
{
  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 };
}
 
/* Update server work area from maximized window bounds (caller holds _windowsLock). */
void SdlRail::reportMaximizedWorkArea(SdlRailWindow* appWindow)
{
  int w = 0;
  int h = 0;
  SDL_GetWindowSize(appWindow->window(), &w, &h);
  if ((w <= 0) || (h <= 0))
    return;
  int x = 0;
  int y = 0;
  if (railPlatformCaps().positionsReadable)
    SDL_GetWindowPosition(appWindow->window(), &x, &y);
 
  /* Clip work area within primary display bounds. */
  SDL_Rect primary{};
  if (!SDL_GetDisplayBounds(SDL_GetPrimaryDisplay(), &primary))
    return;
  const SDL_Rect area = { x, y, w, h };
  SDL_Rect overlap{};
  if (!SDL_GetRectIntersection(&area, &primary, &overlap) || !SDL_RectsEqual(&overlap, &area))
    return;
  sendWorkArea(area);
}
 
void SdlRail::syncGeometry(SDL_WindowID id)
{
  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);
}
 
void SdlRail::noteResizeGrab(SDL_WindowID id)
{
  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;
}
 
void SdlRail::handleWaylandResize(SDL_WindowID id)
{
  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);
}
 
void SdlRail::completeWaylandResize(bool definitive)
{
  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);
}
 
void SdlRail::completeLocalMoveIfPending()
{
  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 */);
}
 
UINT SdlRail::server_min_max_info(RailClientContext* context,
                                  const RAIL_MINMAXINFO_ORDER* minMaxInfo)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(minMaxInfo);
  auto rail = static_cast<SdlRail*>(context->custom);
  WINPR_ASSERT(rail);
 
  std::unique_lock lock(rail->_windowsLock);
  auto appWindow = rail->getWindow(minMaxInfo->windowId);
  if (appWindow)
  {
    WLog_VRB(TAG, "server minmax id=0x%08" PRIx32 " min=%dx%d max=%dx%d", minMaxInfo->windowId,
             minMaxInfo->minTrackWidth, minMaxInfo->minTrackHeight, minMaxInfo->maxTrackWidth,
             minMaxInfo->maxTrackHeight);
    appWindow->setMinMaxSize({ minMaxInfo->minTrackWidth, minMaxInfo->minTrackHeight },
                             { minMaxInfo->maxTrackWidth, minMaxInfo->maxTrackHeight });
    lock.unlock();
    (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  }
  return CHANNEL_RC_OK;
}
 
/* --- window order callbacks --- */
 
/* Non-zero edge means margins exist; all-zero means "no band". */
static bool marginsSet(const SDL_Rect& m)
{
  return m.x || m.y || m.w || m.h;
}
 
/* RESIZE_MARGIN fields: set this window's frame margins and seed/backfill the session BAND. */
void SdlRail::updateMargins(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                            const WINDOW_STATE_ORDER* state)
{
  const UINT32 fieldFlags = orderInfo->fieldFlags;
  SDL_Rect m = appWindow->frameMargins(); /* raw server margins as the base */
  if (fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X)
  {
    m.x = static_cast<int>(state->resizeMarginLeft);
    m.w = static_cast<int>(state->resizeMarginRight);
  }
  if (fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y)
  {
    m.y = static_cast<int>(state->resizeMarginTop);
    m.h = static_cast<int>(state->resizeMarginBottom);
  }
  /* Use window's own frame margins; session margin serves as fallback for band sizing. */
  appWindow->setFrameMargins(m);
  SDL_Rect& sm = _sessionMargins;
  if (marginsSet(m) && !marginsSet(sm))
  {
    sm = m;
    /* Backfill band of earlier zero-announce windows. */
    for (auto& [id, w] : _windows)
      if (!marginsSet(w.resizeMargins()))
        w.setResizeMargins(m.x, m.y, m.w, m.h);
  }
  const SDL_Rect bandSrc = marginsSet(m) ? m : sm;
  appWindow->setResizeMargins(bandSrc.x, bandSrc.y, bandSrc.w, bandSrc.h);
  WLog_DBG(TAG, "margins id=0x%08" PRIx32 " raw L%d T%d R%d B%d", orderInfo->windowId, m.x, m.y,
           m.w, m.h);
}
 
/* SHOW field: mirror the server's show-state (visibility + maximize/minimize) locally. */
void SdlRail::updateShowState(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                              const WINDOW_STATE_ORDER* state)
{
  WLog_DBG(TAG, "server showState id=0x%08" PRIx32 " state=0x%02" PRIx32, orderInfo->windowId,
           state->showState);
  appWindow->setVisible(state->showState != WINDOW_HIDE);
  switch (state->showState)
  {
    case WINDOW_SHOW_MAXIMIZED:
      appWindow->setServerMaximized(true);
      appWindow->setServerMinimized(false);
      break;
    case WINDOW_SHOW_MINIMIZED:
      appWindow->setServerMinimized(true);
      break;
    case WINDOW_SHOW:
      appWindow->setServerMaximized(false);
      appWindow->setServerMinimized(false);
      break;
    default:
      break;
  }
}
 
/* VISIBILITY field: convert the server's visibility rects (window-relative) and store them. */
void SdlRail::updateVisRects(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                             const WINDOW_STATE_ORDER* state)
{
  std::vector<SDL_Rect> rects;
  rects.reserve(state->numVisibilityRects);
  for (UINT32 i = 0; i < state->numVisibilityRects; i++)
  {
    const RECTANGLE_16& r = state->visibilityRects[i];
    rects.push_back({ r.left, r.top, r.right - r.left, r.bottom - r.top });
  }
  if (rects.empty())
    WLog_DBG(TAG, "visrects id=0x%08" PRIx32 " n=0", orderInfo->windowId);
  else
    WLog_DBG(TAG, "visrects id=0x%08" PRIx32 " n=%zu first=%dx%d+%d+%d", orderInfo->windowId,
             rects.size(), rects.at(0).w, rects.at(0).h, rects.at(0).x, rects.at(0).y);
  appWindow->setVisibilityRects(std::move(rects));
}
 
BOOL SdlRail::window_common(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                            const WINDOW_STATE_ORDER* windowState)
{
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(windowState);
  auto rail = SdlRail::get(context);
  if (!rail)
    return FALSE;
 
  const UINT32 fieldFlags = orderInfo->fieldFlags;
  std::unique_lock lock(rail->_windowsLock);
  auto appWindow = rail->getWindow(orderInfo->windowId);
 
  if (fieldFlags & WINDOW_ORDER_STATE_NEW)
  {
    const SDL_Rect rect = { static_cast<int>(windowState->windowOffsetX),
                          static_cast<int>(windowState->windowOffsetY),
                          static_cast<int>(windowState->windowWidth),
                          static_cast<int>(windowState->windowHeight) };
    appWindow = rail->addWindow(orderInfo->windowId, rect);
    if (!appWindow)
      return FALSE;
 
    WLog_DBG(TAG,
             "window create id=0x%08" PRIx32 " %dx%d+%d+%d style=0x%08" PRIx32
             " ex=0x%08" PRIx32 " owner=0x%08" PRIx32,
             orderInfo->windowId, rect.w, rect.h, rect.x, rect.y, windowState->style,
             windowState->extendedStyle, windowState->ownerWindowId);
    /* Seed resize band margins from session default. */
    const SDL_Rect& sm = rail->_sessionMargins;
    if (marginsSet(sm))
      appWindow->setResizeMargins(sm.x, sm.y, sm.w, sm.h);
    /* The SDL window is created lazily on the main thread (reconcile), as SDL requires. */
  }
 
  if (!appWindow)
    return FALSE;
 
  if (fieldFlags & (WINDOW_ORDER_FIELD_WND_OFFSET | WINDOW_ORDER_FIELD_WND_SIZE))
  {
    SDL_Rect r = appWindow->windowRect();
    if (fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET)
    {
      r.x = static_cast<int>(windowState->windowOffsetX);
      r.y = static_cast<int>(windowState->windowOffsetY);
    }
    if (fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE)
    {
      r.w = static_cast<int>(windowState->windowWidth);
      r.h = static_cast<int>(windowState->windowHeight);
    }
    WLog_VRB(TAG, "server geom id=0x%08" PRIx32 " rect=%d,%d %dx%d", orderInfo->windowId, r.x,
             r.y, r.w, r.h);
    appWindow->updateWindowRect(r);
  }
  if (fieldFlags & WINDOW_ORDER_FIELD_OWNER)
    appWindow->setOwner(windowState->ownerWindowId);
  if (fieldFlags & (WINDOW_ORDER_FIELD_RESIZE_MARGIN_X | WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y))
    rail->updateMargins(appWindow, orderInfo, windowState);
  if (fieldFlags & WINDOW_ORDER_FIELD_STYLE)
    appWindow->setStyle(windowState->style, windowState->extendedStyle);
  if (fieldFlags & WINDOW_ORDER_FIELD_TITLE)
  {
    char* title = rail_string_to_utf8_string(&windowState->titleInfo);
    if (title)
    {
      appWindow->setTitle(title);
      free(title);
    }
  }
 
  if (fieldFlags & WINDOW_ORDER_FIELD_SHOW)
    updateShowState(appWindow, orderInfo, windowState);
 
  if (fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET)
  {
    WLog_DBG(TAG, "visoff id=0x%08" PRIx32 " %d,%d", orderInfo->windowId,
             windowState->visibleOffsetX, windowState->visibleOffsetY);
    appWindow->setVisibleOffset({ static_cast<int>(windowState->visibleOffsetX),
                                  static_cast<int>(windowState->visibleOffsetY) });
  }
  if (fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY)
    updateVisRects(appWindow, orderInfo, windowState);
 
  /* Wake the main thread to create/move/show/paint the SDL window(s). */
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return TRUE;
}
 
SdlRailIcon* SdlRail::iconCacheLookup(uint32_t cacheId, uint32_t cacheEntry)
{
  if (cacheId == 0xFF)
    return &_iconScratch;
  const size_t idx = static_cast<size_t>(cacheId) * _iconCacheEntries + cacheEntry;
  if ((_iconCacheEntries == 0) || (cacheEntry >= _iconCacheEntries) || (idx >= _iconCache.size()))
    return nullptr;
  return &_iconCache.at(idx);
}
 
/* ICON_INFO (1/4/8/16/24/32 bpp + AND mask) -> BGRA32, like xf convert_rail_icon. */
static bool convertRailIcon(const ICON_INFO* info, SdlRailIcon& icon)
{
  icon.w = info->width;
  icon.h = info->height;
  icon.bgra.assign(4ULL * info->width * info->height, 0);
  return freerdp_image_copy_from_icon_data(
             icon.bgra.data(), PIXEL_FORMAT_BGRA32, 0, 0, 0,
             WINPR_ASSERTING_INT_CAST(UINT16, info->width),
             WINPR_ASSERTING_INT_CAST(UINT16, info->height), info->bitsColor,
             WINPR_ASSERTING_INT_CAST(UINT16, info->cbBitsColor), info->bitsMask,
             WINPR_ASSERTING_INT_CAST(UINT16, info->cbBitsMask), info->colorTable,
             WINPR_ASSERTING_INT_CAST(UINT16, info->cbColorTable), info->bpp) == TRUE;
}
 
BOOL SdlRail::window_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                          const WINDOW_ICON_ORDER* windowIcon)
{
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(windowIcon);
  WINPR_ASSERT(windowIcon->iconInfo);
  auto rail = SdlRail::get(context);
  if (!rail)
    return FALSE;
 
  std::unique_lock lock(rail->_windowsLock);
  auto appWindow = rail->getWindow(orderInfo->windowId);
  if (!appWindow)
    return TRUE;
 
  /* Decode into the cache slot so a later WindowCachedIcon can reference it. */
  const ICON_INFO* info = windowIcon->iconInfo;
  auto* icon = rail->iconCacheLookup(info->cacheId, info->cacheEntry);
  if (!icon || !convertRailIcon(info, *icon))
  {
    WLog_WARN(TAG, "failed to decode icon %02" PRIX32 ":%04" PRIX32 " for window 0x%08" PRIx32,
              info->cacheId, info->cacheEntry, orderInfo->windowId);
    return TRUE;
  }
  appWindow->setIcon(*icon);
  lock.unlock();
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return TRUE;
}
 
BOOL SdlRail::window_cached_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                                 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
{
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(windowCachedIcon);
  auto rail = SdlRail::get(context);
  if (!rail)
    return FALSE;
 
  std::unique_lock lock(rail->_windowsLock);
  auto appWindow = rail->getWindow(orderInfo->windowId);
  if (!appWindow)
    return TRUE;
 
  const CACHED_ICON_INFO& cached = windowCachedIcon->cachedIcon;
  auto* icon = rail->iconCacheLookup(cached.cacheId, cached.cacheEntry);
  if (!icon || icon->bgra.empty())
  {
    WLog_WARN(TAG,
              "cached icon %02" PRIX32 ":%04" PRIX32 " not in cache (window 0x%08" PRIx32 ")",
              cached.cacheId, cached.cacheEntry, orderInfo->windowId);
    return TRUE;
  }
  appWindow->setIcon(*icon);
  lock.unlock();
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return TRUE;
}
 
BOOL SdlRail::window_delete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
{
  WINPR_ASSERT(orderInfo);
  auto rail = SdlRail::get(context);
  if (!rail)
    return FALSE;
 
  /* Mark only; erased on the main thread (paint) so the SDL window dies there. */
  std::unique_lock lock(rail->_windowsLock);
  auto appWindow = rail->getWindow(orderInfo->windowId);
  if (appWindow)
  {
    WLog_DBG(TAG, "window delete id=0x%08" PRIx32, orderInfo->windowId);
    appWindow->markDeleted();
  }
 
  /* Clear cached references to deleted window id. */
  if (rail->_localMove.id == orderInfo->windowId)
    rail->_localMove = {};
  if (rail->_clientActiveId == orderInfo->windowId)
    rail->_clientActiveId = 0;
  if (rail->_focusedAppId == orderInfo->windowId)
    rail->_focusedAppId = 0;
  lock.unlock();
 
  (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE);
  return TRUE;
}
 
BOOL SdlRail::monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                                const MONITORED_DESKTOP_ORDER* monitoredDesktop)
{
  WINPR_ASSERT(orderInfo);
  WINPR_ASSERT(monitoredDesktop);
  auto rail = SdlRail::get(context);
  if (!rail)
    return FALSE;
 
  /* Launch the RemoteApp on DESKTOP_ARC_COMPLETED, like xf_rail_monitored_desktop. */
  if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ARC_COMPLETED)
  {
    rail->enableRemoteAppMode(true);
    const char* app =
        freerdp_settings_get_string(context->settings, FreeRDP_RemoteApplicationProgram);
    if (app && (strnlen(app, 1) > 0))
    {
      WLog_DBG(TAG, "RAIL mode enabled (monitored desktop); launching '%s'", app);
      if (client_rail_server_start_cmd(rail->_rail) != CHANNEL_RC_OK)
      {
        WLog_ERR(TAG, "client_rail_server_start_cmd failed for '%s'", app);
        return FALSE;
      }
    }
  }
 
  /* Authoritative top-level z-order (windowIds[0] topmost); capture it, paint() realizes it. */
  if (orderInfo->fieldFlags &
      (WINDOW_ORDER_FIELD_DESKTOP_ZORDER | WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND))
  {
    std::unique_lock lock(rail->_windowsLock);
    if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
    {
      /* Server changed active window: sync our ClientActivate dedup to avoid skipping
       * re-clicks. */
      rail->_clientActiveId = monitoredDesktop->activeWindowId;
    }
    if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
    {
      if (monitoredDesktop->windowIds && (monitoredDesktop->numWindowIds > 0))
        rail->_zOrder.assign(monitoredDesktop->windowIds,
                             monitoredDesktop->windowIds + monitoredDesktop->numWindowIds);
      else
        rail->_zOrder.clear();
      rail->_zOrderDirty = true;
      lock.unlock();
      (void)sdl_push_user_event(SDL_EVENT_USER_UPDATE); /* wake the main thread to restack */
    }
  }
  return TRUE;
}
 
BOOL SdlRail::non_monitored_desktop(rdpContext* context,
                                    WINPR_ATTR_UNUSED const WINDOW_ORDER_INFO* orderInfo)
{
  WINPR_ASSERT(orderInfo);
  auto rail = SdlRail::get(context);
  if (rail)
  {
    WLog_DBG(TAG, "RAIL mode disabled (non-monitored desktop)");
    rail->enableRemoteAppMode(false);
  }
  return TRUE;
}