SdlWindow Class Reference

#include <sdl_window.hpp>

Public Member Functions
	SdlWindow (const std::string &title, Sint32 startupX, Sint32 startupY, Sint32 width, Sint32 height, Uint32 flags)
	SdlWindow (const SdlWindow &other)=delete
	SdlWindow (SdlWindow &&other) noexcept
SdlWindow &	operator= (const SdlWindow &other)=delete
SdlWindow &	operator= (SdlWindow &&other)=delete
Uint32	id () const
int	displayIndex () const
SDL_Rect	rect () const
SDL_Window *	window () const
Sint32	offsetX () const
void	setOffsetX (Sint32 x)
void	setOffsetY (Sint32 y)
Sint32	offsetY () const
bool	grabKeyboard (bool enable)
bool	grabMouse (bool enable)
void	setBordered (bool bordered)
void	raise ()
void	resizeable (bool use)
void	fullscreen (bool enter)
void	minimize ()
bool	fill (Uint8 r=0x00, Uint8 g=0x00, Uint8 b=0x00, Uint8 a=0xff)
bool	blit (SDL_Surface *surface, SDL_Rect src, SDL_Rect &dst)
void	updateSurface ()
	SdlWindow (SdlWindow &&other) noexcept
	SdlWindow (const SdlWindow &other)=delete
SdlWindow &	operator= (const SdlWindow &other)=delete
SdlWindow &	operator= (SdlWindow &&other)=delete
SDL_WindowID	id () const
SDL_DisplayID	displayIndex () const
SDL_Rect	rect () const
SDL_Rect	bounds () const
SDL_Window *	window () const
Sint32	offsetX () const
void	setOffsetX (Sint32 x)
void	setOffsetY (Sint32 y)
Sint32	offsetY () const
rdpMonitor	monitor (bool isPrimary) const
void	setMonitor (rdpMonitor monitor)
float	scale () const
SDL_DisplayOrientation	orientation () const
bool	grabKeyboard (bool enable)
bool	grabMouse (bool enable)
void	setBordered (bool bordered)
void	raise ()
void	resizeable (bool use)
void	fullscreen (bool enter, bool forceOriginalDisplay)
void	minimize ()
bool	resize (const SDL_Point &size)
bool	drawRect (SDL_Surface *surface, SDL_Point offset, const SDL_Rect &srcRect)
bool	drawRects (SDL_Surface *surface, SDL_Point offset, const std::vector< SDL_Rect > &rects={})
bool	drawScaledRect (SDL_Surface *surface, const SDL_FPoint &scale, const SDL_Rect &srcRect)
bool	drawScaledRects (SDL_Surface *surface, const SDL_FPoint &scale, const std::vector< SDL_Rect > &rects={})
bool	fill (Uint8 r=0x00, Uint8 g=0x00, Uint8 b=0x00, Uint8 a=0xff)
bool	blit (SDL_Surface *surface, const SDL_Rect &src, SDL_Rect &dst)
void	updateSurface ()

Static Public Member Functions
static SdlWindow	create (SDL_DisplayID id, const std::string &title, Uint32 flags, Uint32 width=0, Uint32 height=0)
static rdpMonitor	query (SDL_DisplayID id, bool forceAsPrimary=false)

Protected Types
enum	HighDPIMode { MODE_INVALID , MODE_NONE , MODE_WINDOWS , MODE_MACOS }

Protected Member Functions
	SdlWindow (SDL_DisplayID id, const std::string &title, const SDL_Rect &rect, Uint32 flags)

Static Protected Member Functions
static bool	fill (SDL_Window *window, Uint8 r=0x00, Uint8 g=0x00, Uint8 b=0x00, Uint8 a=0xff)
static rdpMonitor	query (SDL_Window *window, SDL_DisplayID id, bool forceAsPrimary=false)
static SDL_Rect	rect (SDL_Window *window, bool forceAsPrimary=false)
static SDL_Rect	rect (SDL_DisplayID id, bool forceAsPrimary=false)
static bool	tryFallback ()
static enum HighDPIMode	isHighDPIWindowsMode (SDL_Window *window)

Detailed Description

FreeRDP: A Remote Desktop Protocol Implementation SDL Client

Copyright 2023 Armin Novak armin.nosp@m..nov.nosp@m.ak@th.nosp@m.inca.nosp@m.st.co.nosp@m.m Copyright 2023 Thincast Technologies GmbH

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Definition at line 25 of file SDL2/sdl_window.hpp.

Member Enumeration Documentation

HighDPIMode

enum SdlWindow::HighDPIMode

protected

Definition at line 96 of file SDL3/sdl_window.hpp.

  {
    MODE_INVALID,
    MODE_NONE,
    MODE_WINDOWS,
    MODE_MACOS
  };

Constructor & Destructor Documentation

SdlWindow() [1/3]

SdlWindow::SdlWindow	(	const std::string &	title,
		Sint32	startupX,
		Sint32	startupY,
		Sint32	width,
		Sint32	height,
		Uint32	flags
	)

FreeRDP: A Remote Desktop Protocol Implementation SDL Client

Copyright 2023 Armin Novak armin.nosp@m..nov.nosp@m.ak@th.nosp@m.inca.nosp@m.st.co.nosp@m.m Copyright 2023 Thincast Technologies GmbH

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Definition at line 23 of file SDL2/sdl_window.cpp.

    : _window(SDL_CreateWindow(title.c_str(), startupX, startupY, width, height, flags))
{
}

SdlWindow() [2/3]

SdlWindow::SdlWindow ( SdlWindow &&  other )

noexcept

Definition at line 29 of file SDL2/sdl_window.cpp.

    : _window(other._window), _offset_x(other._offset_x), _offset_y(other._offset_y)
{
  other._window = nullptr;
}

~SdlWindow()

SdlWindow::~SdlWindow

(

)

Definition at line 35 of file SDL2/sdl_window.cpp.

{
  SDL_DestroyWindow(_window);
}

SdlWindow() [3/3]

SdlWindow::SdlWindow ( SDL_DisplayID  id, const std::string &  title, const SDL_Rect &  rect, Uint32  flags  )

protected

FreeRDP: A Remote Desktop Protocol Implementation SDL Client

Copyright 2023 Armin Novak armin.nosp@m..nov.nosp@m.ak@th.nosp@m.inca.nosp@m.st.co.nosp@m.m Copyright 2023 Thincast Technologies GmbH

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Definition at line 29 of file SDL3/sdl_window.cpp.

    : _displayID(id)
{
  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, rect.w);
  SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, rect.h);
 
  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);
 
  _window = SDL_CreateWindowWithProperties(props);
  SDL_DestroyProperties(props);
 
  auto sc = scale();
  const int iscale = static_cast<int>(sc * 100.0f);
  auto w = 100 * rect.w / iscale;
  auto h = 100 * rect.h / iscale;
  std::ignore = resize({ w, h });
  SDL_SetHint(SDL_HINT_APP_NAME, "");
  std::ignore = SDL_SyncWindow(_window);
 
  _monitor = query(_window, id, true);
}

Member Function Documentation

blit() [1/2]

bool SdlWindow::blit	(	SDL_Surface *	surface,
		const SDL_Rect &	src,
		SDL_Rect &	dst
	)

Definition at line 411 of file SDL3/sdl_window.cpp.

{
  auto screen = SDL_GetWindowSurface(_window);
  if (!screen || !surface)
    return false;
  if (!SDL_SetSurfaceClipRect(surface, &srcRect))
    return true;
  if (!SDL_SetSurfaceClipRect(screen, &dstRect))
    return true;
  if (!SDL_BlitSurfaceScaled(surface, &srcRect, screen, &dstRect, SDL_SCALEMODE_LINEAR))
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_BlitScaled: %s", SDL_GetError());
    return false;
  }
  return true;
}

blit() [2/2]

bool SdlWindow::blit	(	SDL_Surface *	surface,
		SDL_Rect	src,
		SDL_Rect &	dst
	)

Definition at line 187 of file SDL2/sdl_window.cpp.

{
  auto screen = SDL_GetWindowSurface(_window);
  if (!screen || !surface)
    return false;
  if (!SDL_SetClipRect(surface, &srcRect))
    return true;
  if (!SDL_SetClipRect(screen, &dstRect))
    return true;
  auto rc = SDL_BlitScaled(surface, &srcRect, screen, &dstRect);
  if (rc != 0)
  {
    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_BlitScaled: %s [%d]", sdl_error_string(rc), rc);
  }
  return rc == 0;
}

bounds()

SDL_Rect SdlWindow::bounds

(

)

const

Definition at line 94 of file SDL3/sdl_window.cpp.

{
  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;
}

create()

SdlWindow SdlWindow::create ( SDL_DisplayID  id, const std::string &  title, Uint32  flags, Uint32  width = 0, Uint32  height = 0  )

static

Definition at line 433 of file SDL3/sdl_window.cpp.

{
  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;
}

displayIndex()

SDL_DisplayID SdlWindow::displayIndex

(

)

const

Definition at line 47 of file SDL2/sdl_window.cpp.

{
  if (!_window)
    return 0;
  return SDL_GetWindowDisplayIndex(_window);
}

drawRect()

bool SdlWindow::drawRect	(	SDL_Surface *	surface,
		SDL_Point	offset,
		const SDL_Rect &	srcRect
	)

Definition at line 221 of file SDL3/sdl_window.cpp.

{
  WINPR_ASSERT(surface);
  SDL_Rect dstRect = { offset.x + srcRect.x, offset.y + srcRect.y, srcRect.w, srcRect.h };
  return blit(surface, srcRect, dstRect);
}

drawRects()

bool SdlWindow::drawRects	(	SDL_Surface *	surface,
		SDL_Point	offset,
		const std::vector< SDL_Rect > &	rects = {}
	)

Definition at line 228 of file SDL3/sdl_window.cpp.

{
  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;
}

drawScaledRect()

bool SdlWindow::drawScaledRect	(	SDL_Surface *	surface,
		const SDL_FPoint &	scale,
		const SDL_Rect &	srcRect
	)

Definition at line 243 of file SDL3/sdl_window.cpp.

{
  SDL_Rect dstRect = srcRect;
  dstRect.x = static_cast<Sint32>(static_cast<float>(dstRect.x) * scale.x);
  dstRect.w = static_cast<Sint32>(static_cast<float>(dstRect.w) * scale.x);
  dstRect.y = static_cast<Sint32>(static_cast<float>(dstRect.y) * scale.y);
  dstRect.h = static_cast<Sint32>(static_cast<float>(dstRect.h) * scale.y);
  return blit(surface, srcRect, dstRect);
}

drawScaledRects()

bool SdlWindow::drawScaledRects	(	SDL_Surface *	surface,
		const SDL_FPoint &	scale,
		const std::vector< SDL_Rect > &	rects = {}
	)

Definition at line 254 of file SDL3/sdl_window.cpp.

{
  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;
}

fill() [1/2]

bool SdlWindow::fill ( SDL_Window *  window, Uint8  r = 0x00, Uint8  g = 0x00, Uint8  b = 0x00, Uint8  a = 0xff  )

staticprotected

Definition at line 274 of file SDL3/sdl_window.cpp.

{
  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);
}

fill() [2/2]

bool SdlWindow::fill	(	Uint8	r = 0x00,
		Uint8	g = 0x00,
		Uint8	b = 0x00,
		Uint8	a = 0xff
	)

Definition at line 175 of file SDL2/sdl_window.cpp.

{
  auto surface = SDL_GetWindowSurface(_window);
  if (!surface)
    return false;
  SDL_Rect rect = { 0, 0, surface->w, surface->h };
  auto color = SDL_MapRGBA(surface->format, r, g, b, a);
 
  SDL_FillRect(surface, &rect, color);
  return true;
}

fullscreen() [1/2]

void SdlWindow::fullscreen

(

bool

enter

)

Definition at line 131 of file SDL2/sdl_window.cpp.

{
  auto curFlags = SDL_GetWindowFlags(_window);
 
  if (enter)
  {
    if (!(curFlags & SDL_WINDOW_BORDERLESS))
    {
      auto idx = SDL_GetWindowDisplayIndex(_window);
      SDL_DisplayMode mode = {};
      SDL_GetCurrentDisplayMode(idx, &mode);
 
      SDL_RestoreWindow(_window); // Maximize so we can see the caption and
                                  // bits
      SDL_SetWindowBordered(_window, SDL_FALSE);
      SDL_SetWindowPosition(_window, 0, 0);
#if SDL_VERSION_ATLEAST(2, 0, 16)
      SDL_SetWindowAlwaysOnTop(_window, SDL_TRUE);
#endif
      SDL_RaiseWindow(_window);
      SDL_SetWindowSize(_window, mode.w, mode.h);
    }
  }
  else
  {
    if (curFlags & SDL_WINDOW_BORDERLESS)
    {
 
      SDL_SetWindowBordered(_window, SDL_TRUE);
#if SDL_VERSION_ATLEAST(2, 0, 16)
      SDL_SetWindowAlwaysOnTop(_window, SDL_FALSE);
#endif
      SDL_RaiseWindow(_window);
      SDL_MinimizeWindow(_window); // Maximize so we can see the caption and bits
      SDL_MaximizeWindow(_window); // Maximize so we can see the caption and bits
    }
  }
}

fullscreen() [2/2]

void SdlWindow::fullscreen	(	bool	enter,
		bool	forceOriginalDisplay
	)

Definition at line 194 of file SDL3/sdl_window.cpp.

{
  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);
}

grabKeyboard()

bool SdlWindow::grabKeyboard

(

bool

enable

)

Definition at line 90 of file SDL2/sdl_window.cpp.

{
  if (!_window)
    return false;
#if SDL_VERSION_ATLEAST(2, 0, 16)
  SDL_SetWindowKeyboardGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
  return true;
#else
  SDL_LogError(SDL_LOG_CATEGORY_INPUT, "Keyboard grabbing not supported by SDL2 < 2.0.16");
  return false;
#endif
}

grabMouse()

bool SdlWindow::grabMouse

(

bool

enable

)

Definition at line 103 of file SDL2/sdl_window.cpp.

{
  if (!_window)
    return false;
#if SDL_VERSION_ATLEAST(2, 0, 16)
  SDL_SetWindowMouseGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
#else
  SDL_SetWindowGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
#endif
  return true;
}

id()

SDL_WindowID SdlWindow::id

(

)

const

Definition at line 40 of file SDL2/sdl_window.cpp.

{
  if (!_window)
    return 0;
  return SDL_GetWindowID(_window);
}

isHighDPIWindowsMode()

SdlWindow::HighDPIMode SdlWindow::isHighDPIWindowsMode ( SDL_Window *  window )

staticprotected

Definition at line 386 of file SDL3/sdl_window.cpp.

{
  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;
}

minimize()

void SdlWindow::minimize

(

)

Definition at line 170 of file SDL2/sdl_window.cpp.

{
  SDL_MinimizeWindow(_window);
}

monitor()

rdpMonitor SdlWindow::monitor

(

bool

isPrimary

)

const

Definition at line 132 of file SDL3/sdl_window.cpp.

{
  auto m = _monitor;
  if (isPrimary)
  {
    m.x = 0;
    m.y = 0;
  }
  return m;
}

offsetX()

Sint32 SdlWindow::offsetX

(

)

const

Definition at line 70 of file SDL2/sdl_window.cpp.

{
  return _offset_x;
}

offsetY()

Sint32 SdlWindow::offsetY

(

)

const

Definition at line 85 of file SDL2/sdl_window.cpp.

{
  return _offset_y;
}

orientation()

SDL_DisplayOrientation SdlWindow::orientation

(

)

const

Definition at line 153 of file SDL3/sdl_window.cpp.

{
  const auto did = displayIndex();
  return SDL_GetCurrentDisplayOrientation(did);
}

query() [1/2]

rdpMonitor SdlWindow::query ( SDL_DisplayID  id, bool  forceAsPrimary = false  )

static

Definition at line 495 of file SDL3/sdl_window.cpp.

{
  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);
}

query() [2/2]

rdpMonitor SdlWindow::query ( SDL_Window *  window, SDL_DisplayID  id, bool  forceAsPrimary = false  )

staticprotected

Definition at line 285 of file SDL3/sdl_window.cpp.

{
  if (!window)
    return {};
 
  const auto& r = rect(window, forceAsPrimary);
  const float factor = SDL_GetWindowDisplayScale(window);
  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;
  monitor.attributes.physicalWidth = WINPR_ASSERTING_INT_CAST(uint32_t, r.w);
  monitor.attributes.physicalHeight = WINPR_ASSERTING_INT_CAST(uint32_t, r.h);
 
  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;
}

raise()

void SdlWindow::raise

(

)

Definition at line 121 of file SDL2/sdl_window.cpp.

{
  SDL_RaiseWindow(_window);
}

rect() [1/3]

SDL_Rect SdlWindow::rect

(

)

const

Definition at line 54 of file SDL2/sdl_window.cpp.

{
  SDL_Rect rect = {};
  if (_window)
  {
    SDL_GetWindowPosition(_window, &rect.x, &rect.y);
    SDL_GetWindowSize(_window, &rect.w, &rect.h);
  }
  return rect;
}

rect() [2/3]

SDL_Rect SdlWindow::rect ( SDL_DisplayID  id, bool  forceAsPrimary = false  )

staticprotected

Definition at line 514 of file SDL3/sdl_window.cpp.

{
  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);
}

rect() [3/3]

SDL_Rect SdlWindow::rect ( SDL_Window *  window, bool  forceAsPrimary = false  )

staticprotected

Definition at line 334 of file SDL3/sdl_window.cpp.

{
  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 (fs && tryFallback())
  {
    /* 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;
      }
      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;
}

resize()

bool SdlWindow::resize

(

const SDL_Point &

size

)

Definition at line 216 of file SDL3/sdl_window.cpp.

{
  return SDL_SetWindowSize(_window, size.x, size.y);
}

resizeable()

void SdlWindow::resizeable

(

bool

use

)

Definition at line 126 of file SDL2/sdl_window.cpp.

{
  SDL_SetWindowResizable(_window, use ? SDL_TRUE : SDL_FALSE);
}

scale()

float SdlWindow::scale

(

)

const

Definition at line 148 of file SDL3/sdl_window.cpp.

{
  return SDL_GetWindowDisplayScale(_window);
}

setBordered()

void SdlWindow::setBordered

(

bool

bordered

)

Definition at line 115 of file SDL2/sdl_window.cpp.

{
  if (_window)
    SDL_SetWindowBordered(_window, bordered ? SDL_TRUE : SDL_FALSE);
}

setMonitor()

void SdlWindow::setMonitor

(

rdpMonitor

monitor

)

Definition at line 143 of file SDL3/sdl_window.cpp.

{
  _monitor = monitor;
}

setOffsetX()

void SdlWindow::setOffsetX

(

Sint32

x

)

Definition at line 75 of file SDL2/sdl_window.cpp.

{
  _offset_x = x;
}

setOffsetY()

void SdlWindow::setOffsetY

(

Sint32

y

)

Definition at line 80 of file SDL2/sdl_window.cpp.

{
  _offset_y = y;
}

tryFallback()

bool SdlWindow::tryFallback ( )

staticprotected

Definition at line 533 of file SDL3/sdl_window.cpp.

{
  /* 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)
    return strcmp(wlroots_hack, "0") != 0;
 
  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
   *
   * if set and the value is
   * - sway
   *
   * then we need the hack.
   */
  const auto xdg_session = SDL_getenv("XDG_SESSION_DESKTOP");
  if (xdg_session != nullptr)
  {
    if (strcmp(xdg_session, "sway") == 0)
      return true;
  }
 
  /* check XDG_CURRENT_DESKTOP
   *
   * if set and the value is
   * - sway:wlroots
   *
   * then we need the hack.
   */
  const auto xdg_desktop = SDL_getenv("XDG_CURRENT_DESKTOP");
  if (xdg_desktop != nullptr)
  {
    if (strcmp(xdg_desktop, "sway:wlroots") == 0)
      return true;
  }
 
  return false;
}

updateSurface()

void SdlWindow::updateSurface

(

)

Definition at line 204 of file SDL2/sdl_window.cpp.

{
  SDL_UpdateWindowSurface(_window);
}

window()

SDL_Window * SdlWindow::window

(

)

const

Definition at line 65 of file SDL2/sdl_window.cpp.

{
  return _window;
}

---

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

• SDL2/sdl_window.hpp
• SDL3/sdl_window.hpp
• SDL2/sdl_window.cpp
• SDL3/sdl_window.cpp