sdl_rail.hpp

 
#pragma once
 
#include <cstdint>
#include <map>
#include <atomic>
#include <mutex>
#include <vector>
 
#include <SDL3/SDL.h>
 
#include <freerdp/client/rail.h>
#include <freerdp/client/rdpgfx.h>
#include <freerdp/gdi/gfx.h>
#include <freerdp/update.h>
 
#include "sdl_rail_window.hpp"
 
class SdlContext;
 
class SdlRail
{
  public:
  explicit SdlRail(SdlContext* context);
  ~SdlRail();
 
  SdlRail(const SdlRail&) = delete;
  SdlRail(SdlRail&&) = delete;
  SdlRail& operator=(const SdlRail&) = delete;
  SdlRail& operator=(SdlRail&&) = delete;
 
  bool init(RailClientContext* rail);
  bool uninit(RailClientContext* rail);
 
  [[nodiscard]] bool enabled() const
  {
    return _enabled;
  }
 
  /* Main thread: whether the desktop window may show; before the RemoteApp starts, only
   * for a logon dialog or a slow start. */
  [[nodiscard]] bool desktopMayShow();
  /* Any thread: the server shows a logon dialog that needs the user (LogonErrorInfo). */
  void noteLogonPrompt();
 
  /* Paint all RAIL windows (window-mapped GFX surface, or legacy desktop region).
   * `damage` = server-updated desktop rects for this cycle (empty = nothing new). */
  bool paint(SDL_Surface* primary, SDL_PixelFormat fallbackFormat,
             const std::vector<SDL_Rect>& damage);
 
  /* Called from the GFX pipeline when a window-mapped surface updated (RDP thread). */
  UINT updateWindowFromSurface(gdiGfxSurface* surface);
 
  /* GFX callback: install as gfx->UpdateWindowFromSurface after gdi_graphics_pipeline_init. */
  static UINT UpdateWindowFromSurface(RdpgfxClientContext* context, gdiGfxSurface* surface);
 
  /* Input routing (main thread): true if the SDL window id is one of our RAIL windows. */
  [[nodiscard]] bool ownsWindow(SDL_WindowID id);
  /* Mark a RAIL window fully dirty and request a repaint (e.g. on expose). */
  void invalidateWindow(SDL_WindowID id);
  /* Local maximize/minimize/restore state handlers. */
  void handleMaximized(SDL_WindowID id);
  void handleMinimized(SDL_WindowID id);
  void handleRestored(SDL_WindowID id);
  void handleClose(SDL_WindowID id);
  /* Local focus change: send ClientActivate, like xf FocusIn/FocusOut. */
  void handleFocus(SDL_WindowID id, bool gained);
  void handleDisplayChanged(SDL_WindowID id, SDL_DisplayID display);
  void updateCoordinates();
  /* Activate window on server if not already active. */
  void ensureActive(SDL_WindowID id);
  /* Rewrite window-local (x,y) to server-absolute; false if id is not a RAIL window. */
  bool translateToServer(SDL_WindowID id, float& x, float& y);
  void notePopupMoved(SDL_WindowID id);
  /* Record position of last left button-down. */
  void noteLeftPress(float x, float y)
  {
    _lastPressServer = { static_cast<int>(x), static_cast<int>(y) };
    _lastPointerServer = _lastPressServer;
  }
  /* Record pointer position on server. */
  void noteServerPointer(float x, float y)
  {
    _lastPointerServer = { static_cast<int>(x), static_cast<int>(y) };
  }
  /* Local move/resize under the WM grab: server input is suppressed meanwhile. */
  bool dragActive(SDL_WindowID id);
  /* Suppress motion events during active local move/resize. */
  bool suppressServerMotion(SDL_WindowID id);
 
  /* Start native interactive window move/resize. */
  void handleLocalMoveRequested(uint32_t windowId, uint16_t moveType);
  /* Track size change during local move. */
  void noteDragResize(SDL_WindowID id, int w, int h);
  /* Sync window geometry to server. */
  void syncGeometry(SDL_WindowID id);
  /* Finalize pending local move/resize. */
  void completeLocalMoveIfPending();
 
  /* Finalize Wayland resize. */
  void completeWaylandResize(bool definitive = false);
  /* Wayland: the compositor runs the interactive resize (mouse leave or configure). */
  void noteResizeGrab(SDL_WindowID id);
  void settleWaylandResize();
 
  private:
  /* Latch a local move/resize; returns the window for a native modal loop. */
  [[nodiscard]] SDL_Window* beginLocalMove(uint32_t windowId, uint16_t moveType);
  /* _windows helpers: callers must hold _windowsLock. */
  [[nodiscard]] SdlRailWindow* getWindow(uint64_t id);
  [[nodiscard]] SdlRailWindow* getWindowBySdlId(SDL_WindowID id);
  /* Send RAIL_ACTIVATE_ORDER and track _clientActiveId; caller holds _windowsLock. */
  void sendClientActivate(uint32_t wid, bool enabled);
  SdlRailWindow* addWindow(uint64_t id, const SDL_Rect& rect);
  /* The window `ownerId` names, if it is a live non-popup app window (a valid popup/dialog
   * parent); else nullptr. Caller holds _windowsLock. */
  [[nodiscard]] SdlRailWindow* resolveParent(uint64_t ownerId);
  [[nodiscard]] SdlRailWindow* resolvePopupParent(const SdlRailWindow& popup);
  [[nodiscard]] bool isShadowFrame(const SdlRailWindow& popup);
 
  void enableRemoteAppMode(bool enable);
  /* Report a work area to the server (SPI_SET_WORK_AREA, server coords). Main thread. No-op if it
   * matches the last one sent. */
  void sendWorkArea(const SDL_Rect& local);
  /* Report a maximized window's WM-given geometry as the work area. Caller holds _windowsLock. */
  void reportMaximizedWorkArea(SdlRailWindow* appWindow);
  /* Clamp an outer origin so its server rect stays on the desktop. */
  void clampIntoDesktop(const SdlRailWindow& appWindow, int& x, int& y, int w, int h) const;
  /* Send a RAIL_SYSCOMMAND_ORDER for the window. Caller holds _windowsLock. */
  void sendSystemCommand(SdlRailWindow* appWindow, uint16_t command);
  /* Realize the server's top-level z-order (X11 only, focus-neutral). Caller holds _windowsLock.
   */
  void applyZOrder();
  /* Session-wide resize margins (guarded by _windowsLock). */
  SDL_Rect _sessionMargins = { 0, 0, 0, 0 };
  SDL_Point _lastPressServer = { 0, 0 };   /* last forwarded left press; main thread */
  SDL_Point _lastPointerServer = { 0, 0 }; /* last forwarded pointer position; main thread */
  /* Server window coordinates are relative to the primary monitor, input coordinates to the
   * top left of the remote desktop. */
  SDL_Point _displayShift = { 0, 0 }; /* local display minus server coordinates */
  SDL_Point _localShift = { 0, 0 };   /* applied to local windows where positions work */
  SDL_Point _inputOrigin = { 0, 0 };  /* top left of the remote desktop */
 
  /* --- RAIL server callbacks (static, dispatched to the instance) --- */
  static UINT server_execute_result(RailClientContext* context,
                                    const RAIL_EXEC_RESULT_ORDER* execResult);
  static UINT server_local_move_size(RailClientContext* context,
                                     const RAIL_LOCALMOVESIZE_ORDER* localMoveSize);
  static UINT server_min_max_info(RailClientContext* context,
                                  const RAIL_MINMAXINFO_ORDER* minMaxInfo);
 
  /* --- window order callbacks (registered on rdpUpdate::window) --- */
  void registerUpdateCallbacks(rdpUpdate* update);
  static BOOL window_common(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                            const WINDOW_STATE_ORDER* windowState);
  /* window_common field handlers (split out for readability). */
  void updateMargins(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                     const WINDOW_STATE_ORDER* state);
  static void updateShowState(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                              const WINDOW_STATE_ORDER* state);
  static void updateVisRects(SdlRailWindow* appWindow, const WINDOW_ORDER_INFO* orderInfo,
                             const WINDOW_STATE_ORDER* state);
  static BOOL window_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                          const WINDOW_ICON_ORDER* windowIcon);
  static BOOL window_cached_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                                 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon);
  static BOOL window_delete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo);
  static BOOL monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
                                const MONITORED_DESKTOP_ORDER* monitoredDesktop);
  static BOOL non_monitored_desktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo);
 
  static SdlRail* get(rdpContext* context);
 
  /* Shared finalize tail (caller holds _windowsLock): report the final rect to the server and
   * adopt it locally. Both the X11 and Wayland completion paths funnel here. */
  void reportAndAdopt(SdlRailWindow* appWindow, int x, int y, int w, int h);
  /* Send ClientWindowMove to server. */
  void sendClientWindowMove(SdlRailWindow* appWindow, const SDL_Rect& serverRect);
  /* Caller holds _windowsLock. */
  void moveToDisplay(SdlRailWindow* appWindow, SDL_DisplayID display);
 
  /* MS-RDPERP icon cache slot for cacheId:cacheEntry; nullptr if out of range. cacheId 0xFF =
   * "do not cache" scratch slot (the spec says 0xFFFF but the field is one byte). */
  [[nodiscard]] SdlRailIcon* iconCacheLookup(uint32_t cacheId, uint32_t cacheEntry);
 
  private:
  /* Win32: redraw while a native size/move loop blocks our loop. */
  static void redrawDuringSizeMove(void* userdata);
  /* Win32: a resize on the native frame drives the local resize frame like a server one. */
  static void nativeResize(void* userdata, SDL_WindowID id, int moveType, bool end);
  SdlContext* _context;
  RailClientContext* _rail = nullptr;
  /* Written on the RDP thread (RemoteApp mode toggles), read lock-free on the main thread. */
  std::atomic<bool> _enabled = false;
  bool _refreshSent = false; /* one full RefreshRect per connection, at first window realize */
  std::atomic<bool> _appStarted = false;
  /* The desktop window may show: RAIL started, a logon prompt, or the hold ran out. */
  std::atomic<bool> _desktopReleased = false;
  std::atomic<uint64_t> _desktopHoldUntil = 0; /* end of the logon desktop hold (ticks) */
  uint32_t _sizeMoveRedraws = 0;
  SDL_WindowID _nativeResizeId = 0; /* window resized on its native frame, 0 = none */
  /* Last work area reported to the server (server coordinates). */
  SDL_Rect _sentWorkArea = { 0, 0, 0, 0 };
  /* Guards _windows (RDP thread mutates, main thread paints/iterates, GFX thread looks up).
   * Erased on the main thread only, so SDL windows are destroyed there. */
  mutable std::mutex _windowsLock;
  std::map<uint64_t, SdlRailWindow> _windows;
  /* Windows awaiting destruction on the main thread. */
  std::multimap<uint64_t, SdlRailWindow> _deadWindows;
  /* State of active interactive WM move/resize. */
  struct LocalMove
  {
    uint32_t id = 0;      /* windowId of the active move, 0 = none (RAIL ids are non-zero) */
    uint16_t type = 0;    /* RAIL_WMSZ_* of the active local move */
    SDL_Point anchor = { 0, 0 };  /* modal-loop anchor (forwarded press) of this drag */
    SDL_Point pointer = { 0, 0 }; /* server's frozen cursor (last forward) of this drag */
    /* Wayland: a WINDOW_RESIZED arrived since the grab started, so the op really resized
     * (guards against a bare pointer re-enter finalizing a no-op click). Main thread. */
    bool sawResize = false;
    Uint64 lastResize = 0; /* time of the last size step */
    /* Server END order arrived while the drag was still pending (app closed its loop early):
     * the completion must not send the synthetic button-up. Guarded by _windowsLock. */
    bool serverEnded = false;
    /* Last WM-imposed size while plain X11 move was active (self-echoes filtered out). */
    bool wmSized = false;
    SDL_Point wmSize = { 0, 0 };
  };
  LocalMove _localMove;
  /* Server move/size loop in progress (_windowsLock). */
  struct
  {
    uint64_t id = 0;
    SDL_DisplayID display = 0;
  } _moveLoop;
  /* Last focused app window ID. */
  uint64_t _focusedAppId = 0;
  /* Server-driven z-order list. */
  std::vector<uint32_t> _zOrder;
  std::vector<uint32_t> _appliedZOrder;
  uint32_t _clientActiveId = 0; /* last window we told the server to activate (ClientActivate) */
  bool _zOrderDirty = false;
  /* Icon cache (RDP thread): index = cacheId * entries + cacheEntry, sized from settings. */
  std::vector<SdlRailIcon> _iconCache;
  SdlRailIcon _iconScratch;
  uint32_t _iconCacheEntries = 0;
};