SDL3/sdl_window.cpp

 
#include <limits>
#include <sstream>
#include <cmath>
 
#include "sdl_window.hpp"
#include "sdl_utils.hpp"
 
#include <freerdp/utils/string.h>
 
SdlWindow::SdlWindow(SDL_DisplayID id, const std::string& title, const SDL_Rect& rect,
                     [[maybe_unused]] Uint32 flags)
    : _initialW(rect.w), _initialH(rect.h), _displayID(id)
{
  float pd = SDL_GetDisplayContentScale(id);
  if (pd <= 0.0f)
    pd = 1.0f;
  const int createW = static_cast<int>(std::ceil(static_cast<float>(rect.w) / pd));
  const int createH = static_cast<int>(std::ceil(static_cast<float>(rect.h) / pd));
 
  auto props = SDL_CreateProperties();
  SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, title.c_str());
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, rect.x);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, rect.y);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, createW);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, createH);
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN, true);
 
  if (flags & SDL_WINDOW_HIGH_PIXEL_DENSITY)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN, true);
 
  if (flags & SDL_WINDOW_FULLSCREEN)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, true);
 
  if (flags & SDL_WINDOW_BORDERLESS)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN, true);
 
  if (flags & SDL_WINDOW_TRANSPARENT)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN, true);
 
  /* RAIL windows are created hidden until first paint to avoid black flash. */
  if (flags & SDL_WINDOW_HIDDEN)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN, true);
 
  _window = SDL_CreateWindowWithProperties(props);
  SDL_DestroyProperties(props);
  SDL_SetHint(SDL_HINT_APP_NAME, "");
  std::ignore = SDL_SyncWindow(_window);
 
  _renderer = SDL_CreateRenderer(_window, nullptr);
 
  std::ignore = resizeToScale();
 
  _monitor = query(_window, id, true);
}
 
SdlWindow::SdlWindow(SdlWindow&& other) noexcept
    : _window(other._window), _renderer(other._renderer), _renderTarget(other._renderTarget),
      _gdiTexture(other._gdiTexture), _gdiTextureW(other._gdiTextureW),
      _gdiTextureH(other._gdiTextureH), _initialW(other._initialW), _initialH(other._initialH),
      _displayID(other._displayID), _offset_x(other._offset_x), _offset_y(other._offset_y),
      _monitor(other._monitor)
{
  other._window = nullptr;
  other._renderer = nullptr;
  other._renderTarget = nullptr;
  other._gdiTexture = nullptr;
}
 
SdlWindow::~SdlWindow()
{
  if (_gdiTexture)
    SDL_DestroyTexture(_gdiTexture);
  if (_renderTarget)
    SDL_DestroyTexture(_renderTarget);
  if (_renderer)
    SDL_DestroyRenderer(_renderer);
  if (_window)
    SDL_DestroyWindow(_window);
}
 
SDL_WindowID SdlWindow::id() const
{
  if (!_window)
    return 0;
  return SDL_GetWindowID(_window);
}
 
SDL_DisplayID SdlWindow::displayIndex() const
{
  if (!_window)
    return 0;
  return SDL_GetDisplayForWindow(_window);
}
 
SDL_Rect SdlWindow::rect() const
{
  return rect(_window);
}
 
SDL_Rect SdlWindow::bounds() const
{
  SDL_Rect rect = {};
  if (_window)
  {
    if (!SDL_GetWindowPosition(_window, &rect.x, &rect.y))
      return {};
    if (!SDL_GetWindowSize(_window, &rect.w, &rect.h))
      return {};
  }
  return rect;
}
 
SDL_Window* SdlWindow::window() const
{
  return _window;
}
 
SDL_Renderer* SdlWindow::renderer() const
{
  return _renderer;
}
 
Sint32 SdlWindow::offsetX() const
{
  return _offset_x;
}
 
void SdlWindow::setOffsetX(Sint32 x)
{
  _offset_x = x;
}
 
void SdlWindow::setOffsetY(Sint32 y)
{
  _offset_y = y;
}
 
Sint32 SdlWindow::offsetY() const
{
  return _offset_y;
}
 
rdpMonitor SdlWindow::monitor(bool isPrimary) const
{
  auto m = _monitor;
  if (isPrimary)
  {
    m.x = 0;
    m.y = 0;
  }
  return m;
}
 
void SdlWindow::setMonitor(rdpMonitor monitor)
{
  _monitor = monitor;
}
 
float SdlWindow::scale() const
{
  return SDL_GetWindowDisplayScale(_window);
}
 
SDL_DisplayOrientation SdlWindow::orientation() const
{
  const auto did = displayIndex();
  return SDL_GetCurrentDisplayOrientation(did);
}
 
bool SdlWindow::grabKeyboard(bool enable)
{
  if (!_window)
    return false;
  SDL_SetWindowKeyboardGrab(_window, enable);
  return true;
}
 
bool SdlWindow::grabMouse(bool enable)
{
  if (!_window)
    return false;
  SDL_SetWindowMouseGrab(_window, enable);
  return true;
}
 
void SdlWindow::setBordered(bool bordered)
{
  if (_window)
    SDL_SetWindowBordered(_window, bordered);
  /* No SDL_SyncWindow: this runs for every window event, and on macOS each one waited for SDL's
   * sync timeout (2.5 s) while a full screen change was pending. SDL ignores an unchanged border
   * anyway. */
}
 
void SdlWindow::raise()
{
  SDL_RaiseWindow(_window);
  std::ignore = SDL_SyncWindow(_window);
}
 
void SdlWindow::resizeable(bool use)
{
  SDL_SetWindowResizable(_window, use);
  std::ignore = SDL_SyncWindow(_window);
}
 
void SdlWindow::fullscreen(bool enter, bool forceOriginalDisplay)
{
  if (enter && forceOriginalDisplay && _displayID != 0)
  {
    /* Move the window to the desired display. We should not wait
     * for the window to be moved, because some backends can refuse
     * the move. The intent of moving the window is enough for SDL
     * to decide which display will be used for fullscreen. */
    SDL_Rect rect = {};
    std::ignore = SDL_GetDisplayBounds(_displayID, &rect);
    std::ignore = SDL_SetWindowPosition(_window, rect.x, rect.y);
  }
  std::ignore = SDL_SetWindowFullscreen(_window, enter);
  std::ignore = SDL_SyncWindow(_window);
}
 
void SdlWindow::minimize()
{
  SDL_MinimizeWindow(_window);
  std::ignore = SDL_SyncWindow(_window);
}
 
bool SdlWindow::resizeToScale()
{
  if (!_window || _initialW <= 0 || _initialH <= 0)
    return false;
  if ((SDL_GetWindowFlags(_window) & SDL_WINDOW_FULLSCREEN) != 0)
    return true;
 
  float pd = SDL_GetWindowPixelDensity(_window);
  if (pd <= 0.0f)
    pd = 1.0f;
 
  const int targetW = static_cast<int>(std::ceil(static_cast<float>(_initialW) / pd));
  const int targetH = static_cast<int>(std::ceil(static_cast<float>(_initialH) / pd));
 
  int curW = 0;
  int curH = 0;
  if (!SDL_GetWindowSize(_window, &curW, &curH))
    return false;
 
  if (curW == targetW && curH == targetH)
    return true;
 
  return resize({ targetW, targetH });
}
 
bool SdlWindow::resize(const SDL_Point& size)
{
  return SDL_SetWindowSize(_window, size.x, size.y);
}
 
void SdlWindow::ensureRenderTarget()
{
  if (!_renderer)
    return;
 
  int w = 0;
  int h = 0;
  SDL_GetWindowSizeInPixels(_window, &w, &h);
  if (w <= 0 || h <= 0)
    return;
 
  /* Recreate if missing or if window size changed */
  if (_renderTarget)
  {
    float tw = 0;
    float th = 0;
    if (!SDL_GetTextureSize(_renderTarget, &tw, &th))
      return;
    if (static_cast<int>(tw) == w && static_cast<int>(th) == h)
      return;
    SDL_DestroyTexture(_renderTarget);
  }
 
  _renderTarget =
      SDL_CreateTexture(_renderer, SDL_PIXELFORMAT_BGRA32, SDL_TEXTUREACCESS_TARGET, w, h);
  if (!_renderTarget)
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_CreateTexture (render target): %s",
                 SDL_GetError());
    return;
  }
  /* Verbatim, never blended: a transparent window's alpha<0xFF regions would render black. */
  std::ignore = SDL_SetTextureBlendMode(_renderTarget, SDL_BLENDMODE_NONE);
 
  /* Clear once: transparent so windows never flash black before painting. */
  if (SDL_SetRenderTarget(_renderer, _renderTarget))
  {
    std::ignore = SDL_SetRenderDrawColor(_renderer, 0x00, 0x00, 0x00, 0x00);
    std::ignore = SDL_RenderClear(_renderer);
  }
}
 
bool SdlWindow::drawRect(SDL_Surface* surface, SDL_Point offset, const SDL_Rect& srcRect)
{
  WINPR_ASSERT(surface);
  SDL_Rect dstRect = { offset.x + srcRect.x, offset.y + srcRect.y, srcRect.w, srcRect.h };
  return blit(surface, srcRect, dstRect);
}
 
bool SdlWindow::drawRects(SDL_Surface* surface, SDL_Point offset,
                          const std::vector<SDL_Rect>& rects)
{
  if (rects.empty())
  {
    return drawRect(surface, offset, { 0, 0, surface->w, surface->h });
  }
  for (auto& srcRect : rects)
  {
    if (!drawRect(surface, offset, srcRect))
      return false;
  }
  return true;
}
 
bool SdlWindow::drawScaledRect(SDL_Surface* surface, const SDL_FPoint& scale,
                               const SDL_Rect& srcRect)
{
  SDL_Rect dstRect = {};
  float ix = 0.0f;
  float iy = 0.0f;
  const auto modx = std::modf(static_cast<float>(srcRect.x) * scale.x, &ix);
  const auto mody = std::modf(static_cast<float>(srcRect.y) * scale.y, &iy);
  auto sw = std::ceil(static_cast<float>(srcRect.w) * scale.x) + std::ceil(modx);
  auto sh = std::ceil(static_cast<float>(srcRect.h) * scale.y) + std::ceil(mody);
  dstRect.x = static_cast<Sint32>(ix);
  dstRect.w = static_cast<Sint32>(sw);
  dstRect.y = static_cast<Sint32>(iy);
  dstRect.h = static_cast<Sint32>(sh);
  return blit(surface, srcRect, dstRect);
}
 
bool SdlWindow::drawScaledRects(SDL_Surface* surface, const SDL_FPoint& scale,
                                const std::vector<SDL_Rect>& rects)
{
  if (rects.empty())
  {
    return drawScaledRect(surface, scale, { 0, 0, surface->w, surface->h });
  }
  for (const auto& srcRect : rects)
  {
    if (!drawScaledRect(surface, scale, srcRect))
      return false;
  }
  return true;
}
 
bool SdlWindow::fill(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
  if (_renderer)
  {
    ensureRenderTarget();
    if (!SDL_SetRenderTarget(_renderer, _renderTarget))
      return false;
    if (!SDL_SetRenderDrawColor(_renderer, r, g, b, a))
      return false;
    return SDL_RenderClear(_renderer);
  }
  return fill(_window, r, g, b, a);
}
 
bool SdlWindow::fill(SDL_Window* window, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
  auto surface = SDL_GetWindowSurface(window);
  if (!surface)
    return false;
  SDL_Rect rect = { 0, 0, surface->w, surface->h };
  auto color = SDL_MapSurfaceRGBA(surface, r, g, b, a);
 
  return SDL_FillSurfaceRect(surface, &rect, color);
}
 
static rdpMonitor makeMonitor(SDL_DisplayID id, const SDL_Rect& r, float factor,
                              bool forceAsPrimary)
{
  const float dpi = std::roundf(factor * 100.0f);
 
  WINPR_ASSERT(r.w > 0);
  WINPR_ASSERT(r.h > 0);
 
  const auto primary = SDL_GetPrimaryDisplay();
  const auto orientation = SDL_GetCurrentDisplayOrientation(id);
  const auto rdp_orientation = sdl::utils::orientaion_to_rdp(orientation);
 
  rdpMonitor monitor{};
  monitor.orig_screen = id;
  monitor.x = r.x;
  monitor.y = r.y;
  monitor.width = r.w;
  monitor.height = r.h;
  monitor.is_primary = forceAsPrimary || (id == primary);
  monitor.attributes.desktopScaleFactor = static_cast<UINT32>(dpi);
  monitor.attributes.deviceScaleFactor = 100;
  monitor.attributes.orientation = rdp_orientation;
  /* The physical size is in millimetres and ignored outside 10 to 10000 ([MS-RDPBCGR]
   * 2.2.1.3.9.1, [MS-RDPEDISP] 2.2.2.2.1). SDL3 does not know a display's physical size, so
   * leave it at 0 (not given) instead of sending the size in pixels as millimetres. */
  monitor.attributes.physicalWidth = 0;
  monitor.attributes.physicalHeight = 0;
 
  const auto cat = SDL_LOG_CATEGORY_APPLICATION;
  SDL_LogDebug(cat, "monitor.orig_screen                   %" PRIu32, monitor.orig_screen);
  SDL_LogDebug(cat, "monitor.x                             %" PRId32, monitor.x);
  SDL_LogDebug(cat, "monitor.y                             %" PRId32, monitor.y);
  SDL_LogDebug(cat, "monitor.width                         %" PRId32, monitor.width);
  SDL_LogDebug(cat, "monitor.height                        %" PRId32, monitor.height);
  SDL_LogDebug(cat, "monitor.is_primary                    %" PRIu32, monitor.is_primary);
  SDL_LogDebug(cat, "monitor.attributes.desktopScaleFactor %" PRIu32,
               monitor.attributes.desktopScaleFactor);
  SDL_LogDebug(cat, "monitor.attributes.deviceScaleFactor  %" PRIu32,
               monitor.attributes.deviceScaleFactor);
  SDL_LogDebug(cat, "monitor.attributes.orientation        %s",
               freerdp_desktop_rotation_flags_to_string(monitor.attributes.orientation));
  SDL_LogDebug(cat, "monitor.attributes.physicalWidth      %" PRIu32,
               monitor.attributes.physicalWidth);
  SDL_LogDebug(cat, "monitor.attributes.physicalHeight     %" PRIu32,
               monitor.attributes.physicalHeight);
  return monitor;
}
 
rdpMonitor SdlWindow::query(SDL_Window* window, SDL_DisplayID id, bool forceAsPrimary)
{
  if (!window)
    return {};
  return makeMonitor(id, rect(window, forceAsPrimary), SDL_GetWindowDisplayScale(window),
                     forceAsPrimary);
}
 
/* Dummy windows report wrong sizes on Wayland and X11, use the display. */
static rdpMonitor queryDisplay(SDL_DisplayID id, bool forceAsPrimary)
{
  SDL_Rect r = {};
  const SDL_DisplayMode* mode = SDL_GetDesktopDisplayMode(id);
  if (!mode || !SDL_GetDisplayBounds(id, &r))
  {
    SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "display %" PRIu32 ": %s", id, SDL_GetError());
    return {};
  }
  if (forceAsPrimary)
  {
    r.x = 0;
    r.y = 0;
  }
  r.w = static_cast<int>(std::roundf(static_cast<float>(r.w) * mode->pixel_density));
  r.h = static_cast<int>(std::roundf(static_cast<float>(r.h) * mode->pixel_density));
  return makeMonitor(id, r, mode->pixel_density * SDL_GetDisplayContentScale(id), forceAsPrimary);
}
 
SDL_Rect SdlWindow::rect(SDL_Window* window, bool forceAsPrimary)
{
  SDL_Rect rect = {};
  if (!window)
    return {};
 
  if (!forceAsPrimary)
  {
    if (!SDL_GetWindowPosition(window, &rect.x, &rect.y))
      return {};
  }
 
  if (!SDL_GetWindowSizeInPixels(window, &rect.w, &rect.h))
    return {};
 
  const auto flags = SDL_GetWindowFlags(window);
  const auto mask = SDL_WINDOW_FULLSCREEN;
  const auto fs = (flags & mask) == mask;
  if (tryFallback(fs))
  {
    /* On wlroots compositors (Sway, river, etc.), windows that are hidden/unmapped
     * don't get their actual display dimensions. The dummy window returns its creation size
     * (64x64) instead of the display size. This causes validation errors since we require >=
     * 200px. Workaround: If we got dimensions that are too small, query the display directly.
     */
 
    const auto displayID = SDL_GetDisplayForWindow(window);
    SDL_Rect displayBounds = {};
    if (SDL_GetDisplayBounds(displayID, &displayBounds))
    {
      if (forceAsPrimary)
      {
        rect.x = 0;
        rect.y = 0;
      }
      else
      {
        /* The dummy window is centered on the display by the compositor, so its
         * position is not the display origin. Use the display bounds as for w/h. */
        rect.x = displayBounds.x;
        rect.y = displayBounds.y;
      }
      rect.w = displayBounds.w;
      rect.h = displayBounds.h;
 
      const float contentScale = SDL_GetDisplayContentScale(displayID);
      if (contentScale > 1.0f)
      {
        const auto fw = static_cast<float>(rect.w);
        const auto fh = static_cast<float>(rect.h);
        rect.w = static_cast<int>(std::roundf(fw * contentScale));
        rect.h = static_cast<int>(std::roundf(fh * contentScale));
      }
    }
  }
 
  return rect;
}
 
SdlWindow::HighDPIMode SdlWindow::isHighDPIWindowsMode(SDL_Window* window)
{
  if (!window)
    return MODE_INVALID;
 
  const auto id = SDL_GetDisplayForWindow(window);
  if (id == 0)
    return MODE_INVALID;
 
  const auto cs = SDL_GetDisplayContentScale(id);
  const auto ds = SDL_GetWindowDisplayScale(window);
  const auto pd = SDL_GetWindowPixelDensity(window);
 
  /* mac os x style, but no HighDPI display */
  if ((cs == 1.0f) && (ds == 1.0f) && (pd == 1.0f))
    return MODE_NONE;
 
  /* mac os x style HighDPI */
  if ((cs == 1.0f) && (ds > 1.0f) && (pd > 1.0f))
    return MODE_MACOS;
 
  /* rest is windows style */
  return MODE_WINDOWS;
}
 
/* Lazily create or recreate the persistent streaming GDI texture to match `surface`. */
bool SdlWindow::ensureGdiTexture(SDL_Surface* surface)
{
  if (_gdiTexture && (_gdiTextureW == surface->w) && (_gdiTextureH == surface->h))
    return true;
  if (_gdiTexture)
    SDL_DestroyTexture(_gdiTexture);
  _gdiTexture = SDL_CreateTexture(_renderer, surface->format, SDL_TEXTUREACCESS_STREAMING,
                                  surface->w, surface->h);
  if (!_gdiTexture)
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_CreateTexture: %s", SDL_GetError());
    return false;
  }
  std::ignore = SDL_SetTextureBlendMode(_gdiTexture, SDL_BLENDMODE_NONE);
  _gdiTextureW = surface->w;
  _gdiTextureH = surface->h;
  return true;
}
 
bool SdlWindow::blit(SDL_Surface* surface, const SDL_Rect& srcRect, SDL_Rect& dstRect)
{
  if (!_renderer || !surface)
    return false;
 
  ensureRenderTarget();
 
  if (!ensureGdiTexture(surface))
    return false;
 
  /* Upload only the dirty region */
  const auto* details = SDL_GetPixelFormatDetails(surface->format);
  const int bpp = details ? details->bytes_per_pixel : 4;
  const auto* pixels = static_cast<const uint8_t*>(surface->pixels) +
                       (1ll * srcRect.y * surface->pitch) + (1ll * srcRect.x * bpp);
  if (!SDL_UpdateTexture(_gdiTexture, &srcRect, pixels, surface->pitch))
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_UpdateTexture: %s", SDL_GetError());
    return false;
  }
 
  /* Render onto persistent render target to accumulate dirty rects */
  if (!SDL_SetRenderTarget(_renderer, _renderTarget))
    return false;
 
  SDL_FRect fsrc = { static_cast<float>(srcRect.x), static_cast<float>(srcRect.y),
                   static_cast<float>(srcRect.w), static_cast<float>(srcRect.h) };
  SDL_FRect fdst = { static_cast<float>(dstRect.x), static_cast<float>(dstRect.y),
                   static_cast<float>(dstRect.w), static_cast<float>(dstRect.h) };
  if (!SDL_RenderTexture(_renderer, _gdiTexture, &fsrc, &fdst))
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_RenderTexture: %s", SDL_GetError());
    return false;
  }
  return true;
}
 
void SdlWindow::updateSurface()
{
  if (!_renderer)
    return;
 
  ensureRenderTarget();
 
  /* Copy accumulated render target to screen and present */
  if (!SDL_SetRenderTarget(_renderer, nullptr))
    return;
  if (!SDL_RenderTexture(_renderer, _renderTarget, nullptr, nullptr))
    return;
  if (!SDL_RenderPresent(_renderer))
    return;
}
 
bool SdlWindow::paintResizeFrame(SDL_Surface* surface, SDL_Point off, bool contentChanged,
                                 const SDL_Rect& inset, bool fillRevealed, bool dashedBorder)
{
  if (!_renderer || !surface)
    return false;
  ensureRenderTarget();
 
  const int prevW = _gdiTextureW;
  const int prevH = _gdiTextureH;
  if (!ensureGdiTexture(surface))
    return false;
  /* A recreated texture is empty, so upload even when the content did not change. */
  const bool recreated = (_gdiTextureW != prevW) || (_gdiTextureH != prevH);
  if ((contentChanged || recreated) &&
      !SDL_UpdateTexture(_gdiTexture, nullptr, surface->pixels, surface->pitch))
    return false;
 
  if (!SDL_SetRenderTarget(_renderer, _renderTarget))
    return false;
 
  int ww = 0;
  int wh = 0;
  SDL_GetWindowSizeInPixels(_window, &ww, &wh);
  /* The visible frame; the ring outside it (the resize band) stays fully transparent. */
  const SDL_FRect frame = { static_cast<float>(inset.x), static_cast<float>(inset.y),
                          static_cast<float>(ww - inset.x - inset.w),
                          static_cast<float>(wh - inset.y - inset.h) };
 
  /* Translucent fill in revealed area awaiting server frame. */
  constexpr Uint8 kFillAlpha = 0x80;
  std::ignore = SDL_SetRenderDrawBlendMode(_renderer, SDL_BLENDMODE_NONE);
  std::ignore = SDL_SetRenderDrawColor(_renderer, 0, 0, 0, 0);
  std::ignore = SDL_RenderClear(_renderer);
  if (fillRevealed)
  {
    std::ignore = SDL_SetRenderDrawColor(_renderer, 0x2B, 0x2B, 0x2B, kFillAlpha);
    std::ignore = SDL_RenderFillRect(_renderer, &frame);
  }
  SDL_FRect fdst = { static_cast<float>(off.x), static_cast<float>(off.y),
                   static_cast<float>(surface->w), static_cast<float>(surface->h) };
  /* Anchored frame clipped to visible bounds. */
  const SDL_Rect clip = { inset.x, inset.y, ww - inset.x - inset.w, wh - inset.y - inset.h };
  std::ignore = SDL_SetRenderClipRect(_renderer, &clip);
  std::ignore = SDL_RenderTexture(_renderer, _gdiTexture, nullptr, &fdst);
  std::ignore = SDL_SetRenderClipRect(_renderer, nullptr);
 
  /* Dashed border indicating pending resize target. */
  if (dashedBorder)
  {
    std::ignore = SDL_SetRenderDrawColor(_renderer, 0xC8, 0xC8, 0xC8, 0xFF);
    const float dash = 8.0F;
    const float gap = 5.0F;
    const float fx2 = frame.x + frame.w;
    const float fy2 = frame.y + frame.h;
    const float lo = frame.y + 0.5F;
    const float by = fy2 - 0.5F;
    const float lx = frame.x + 0.5F;
    const float rx = fx2 - 0.5F;
    const float step = dash + gap;
    const auto steps = [step](float len)
    { return (len <= 0.0F) ? 0 : static_cast<int>(std::ceil(len / step)); };
    for (int i = 0; i < steps(fx2 - frame.x); i++)
    {
      const float x = frame.x + (static_cast<float>(i) * step);
      const float x2 = (x + dash < fx2) ? (x + dash) : rx;
      std::ignore = SDL_RenderLine(_renderer, x, lo, x2, lo);
      std::ignore = SDL_RenderLine(_renderer, x, by, x2, by);
    }
    for (int i = 0; i < steps(fy2 - frame.y); i++)
    {
      const float y = frame.y + (static_cast<float>(i) * step);
      const float y2 = (y + dash < fy2) ? (y + dash) : by;
      std::ignore = SDL_RenderLine(_renderer, lx, y, lx, y2);
      std::ignore = SDL_RenderLine(_renderer, rx, y, rx, y2);
    }
  }
 
  if (!SDL_SetRenderTarget(_renderer, nullptr))
    return false;
  std::ignore = SDL_RenderTexture(_renderer, _renderTarget, nullptr, nullptr);
  std::ignore = SDL_RenderPresent(_renderer);
  return true;
}
 
SdlWindow SdlWindow::create(SDL_DisplayID id, const std::string& title, Uint32 flags, Uint32 width,
                            Uint32 height)
{
  flags |= SDL_WINDOW_HIGH_PIXEL_DENSITY;
 
  SDL_Rect rect = { static_cast<int>(SDL_WINDOWPOS_CENTERED_DISPLAY(id)),
                  static_cast<int>(SDL_WINDOWPOS_CENTERED_DISPLAY(id)), static_cast<int>(width),
                  static_cast<int>(height) };
 
  if ((flags & SDL_WINDOW_FULLSCREEN) != 0)
  {
    std::ignore = SDL_GetDisplayBounds(id, &rect);
  }
 
  SdlWindow window{ id, title, rect, flags };
 
  if ((flags & SDL_WINDOW_FULLSCREEN) != 0)
  {
    window.setOffsetX(rect.x);
    window.setOffsetY(rect.y);
  }
 
  return window;
}
 
SdlWindow SdlWindow::create(SDL_DisplayID id, const std::string& title, Uint32 flags,
                            const SDL_Rect& rect)
{
  return SdlWindow{ id, title, rect, flags };
}
 
/* Popup constructor: positioned relative to the parent origin. */
SdlWindow::SdlWindow(SDL_Window* parent, const SDL_Rect& rect, bool transparent, bool tooltip)
    : _initialW(rect.w), _initialH(rect.h)
{
  auto props = SDL_CreateProperties();
  SDL_SetPointerProperty(props, SDL_PROP_WINDOW_CREATE_PARENT_POINTER, parent);
  SDL_SetBooleanProperty(props,
                         tooltip ? SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN
                                 : SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN,
                         true);
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN, false);
#if defined(SDL_PROP_WINDOW_CREATE_CONSTRAIN_POPUP_BOOLEAN)
  /* The server places RemoteApp popups; a moved one would map clicks to other points. */
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_CONSTRAIN_POPUP_BOOLEAN, false);
#endif
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN, true);
  /* Transparent so menus' genuine per-pixel alpha (corners/shadow) isn't rendered black. */
  if (transparent)
    SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN, true);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, rect.x);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, rect.y);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, rect.w);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, rect.h);
  /* Hidden until first paint, like the app constructor. */
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN, true);
 
  _window = SDL_CreateWindowWithProperties(props);
  SDL_DestroyProperties(props);
  if (_window)
  {
    std::ignore = SDL_SyncWindow(_window);
    _renderer = SDL_CreateRenderer(_window, nullptr);
    _displayID = SDL_GetDisplayForWindow(_window);
  }
}
 
SdlWindow SdlWindow::createPopup(SDL_Window* parent, const SDL_Rect& rect, bool transparent,
                                 bool tooltip)
{
  return SdlWindow{ parent, rect, transparent, tooltip };
}
 
static SDL_Window* createDummy(SDL_DisplayID id)
{
  const auto x = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
  const auto y = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
  const int w = 64;
  const int h = 64;
 
  auto props = SDL_CreateProperties();
  std::stringstream ss;
  ss << "SdlWindow::query(" << id << ")";
  SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, ss.str().c_str());
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, x);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, y);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, w);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, h);
 
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN, true);
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, false);
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN, true);
  SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN, false);
 
  auto window = SDL_CreateWindowWithProperties(props);
  SDL_DestroyProperties(props);
 
  /* Workaround: we need to properly position the window on the correct monitor
   * before going fullscreen. Otherwise we will get the primary monitor details.
   */
  if (window)
  {
    SDL_Rect rect = {};
    std::ignore = SDL_GetDisplayBounds(id, &rect);
    std::ignore = SDL_SetWindowPosition(window, rect.x, rect.y);
    std::ignore = SDL_SetWindowFullscreen(window, true);
  }
  return window;
}
 
rdpMonitor SdlWindow::query(SDL_DisplayID id, bool forceAsPrimary)
{
  if (sdl::utils::isWaylandDriver() || sdl::utils::isX11Driver())
    return queryDisplay(id, forceAsPrimary);
 
  std::unique_ptr<SDL_Window, void (*)(SDL_Window*)> window(createDummy(id), SDL_DestroyWindow);
  if (!window)
    return {};
 
  std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer*)> renderer(
      SDL_CreateRenderer(window.get(), nullptr), SDL_DestroyRenderer);
 
  if (!SDL_SyncWindow(window.get()))
    return {};
 
  SDL_Event event{};
  while (SDL_PollEvent(&event))
    ;
 
  return query(window.get(), id, forceAsPrimary);
}
 
SDL_Rect SdlWindow::rect(SDL_DisplayID id, bool forceAsPrimary)
{
  std::unique_ptr<SDL_Window, void (*)(SDL_Window*)> window(createDummy(id), SDL_DestroyWindow);
  if (!window)
    return {};
 
  std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer*)> renderer(
      SDL_CreateRenderer(window.get(), nullptr), SDL_DestroyRenderer);
 
  if (!SDL_SyncWindow(window.get()))
    return {};
 
  SDL_Event event{};
  while (SDL_PollEvent(&event))
    ;
 
  return rect(window.get(), forceAsPrimary);
}
 
bool SdlWindow::tryFallback(bool isFullscreen)
{
  /* If we define a custom env variable to use the wlroots hack
   * then enable/disable according to this setting only.
   */
  const auto wlroots_hack = SDL_getenv("FREERDP_WLROOTS_HACK");
  if (wlroots_hack != nullptr)
  {
    const auto enabled = strcmp(wlroots_hack, "0") != 0;
    if (strcmp(wlroots_hack, "force") == 0)
      isFullscreen = true;
    return enabled && isFullscreen;
  }
 
  const auto platform = SDL_GetPlatform();
  if ((platform == nullptr) || (strcmp(platform, "Linux") != 0))
    return false;
 
  const auto driver = SDL_GetCurrentVideoDriver();
  if ((driver == nullptr) || (strcmp(driver, "wayland") != 0))
    return false;
 
  /* Check XDG_SESSION_DESKTOP and XDG_CURRENT_DESKTOP for wlroots-based
   * compositors. The original check only matched Sway, but other wlroots
   * compositors (Hyprland, river, etc.) have the same dummy-window sizing
   * behavior where hidden/unmapped windows return 64x64 instead of the
   * display size. Use strstr for substring matching since XDG_CURRENT_DESKTOP
   * can be a colon-separated list (e.g. "sway:wlroots", "Hyprland").
   */
  auto isWlrootsCompositor = [](const char* value) -> bool
  {
    if (!value)
      return false;
    if (strstr(value, "sway") || strstr(value, "Sway") || strstr(value, "Hyprland") ||
        strstr(value, "hyprland") || strstr(value, "river") || strstr(value, "wlroots"))
      return true;
    return false;
  };
 
  const auto xdg_session = SDL_getenv("XDG_SESSION_DESKTOP");
  if (isWlrootsCompositor(xdg_session))
    return isFullscreen;
 
  const auto xdg_desktop = SDL_getenv("XDG_CURRENT_DESKTOP");
  if (isWlrootsCompositor(xdg_desktop))
    return isFullscreen;
 
  return false;
}