FreeRDP
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Static Protected Member Functions
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 resizeToPixelSize (const SDL_Point &size)
 
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 (bool isFullscreen)
 
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 97 of file SDL3/sdl_window.hpp.

98 {
99 MODE_INVALID,
100 MODE_NONE,
101 MODE_WINDOWS,
102 MODE_MACOS
103 };

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.

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

◆ SdlWindow() [2/3]

SdlWindow::SdlWindow ( SdlWindow &&  other)
noexcept

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

30 : _window(other._window), _offset_x(other._offset_x), _offset_y(other._offset_y)
31{
32 other._window = nullptr;
33}

◆ ~SdlWindow()

SdlWindow::~SdlWindow ( )

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

36{
37 SDL_DestroyWindow(_window);
38}

◆ 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.

31 : _displayID(id)
32{
33 auto props = SDL_CreateProperties();
34 SDL_SetStringProperty(props, SDL_PROP_WINDOW_CREATE_TITLE_STRING, title.c_str());
35 SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_X_NUMBER, rect.x);
36 SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_Y_NUMBER, rect.y);
37 SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, rect.w);
38 SDL_SetNumberProperty(props, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, rect.h);
39
40 if (flags & SDL_WINDOW_HIGH_PIXEL_DENSITY)
41 SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN, true);
42
43 if (flags & SDL_WINDOW_FULLSCREEN)
44 SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, true);
45
46 if (flags & SDL_WINDOW_BORDERLESS)
47 SDL_SetBooleanProperty(props, SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN, true);
48
49 _window = SDL_CreateWindowWithProperties(props);
50 SDL_DestroyProperties(props);
51
52 std::ignore = resizeToPixelSize({ rect.w, rect.h });
53 SDL_SetHint(SDL_HINT_APP_NAME, "");
54 std::ignore = SDL_SyncWindow(_window);
55
56 _monitor = query(_window, id, true);
57}

Member Function Documentation

◆ blit() [1/2]

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

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

417{
418 auto screen = SDL_GetWindowSurface(_window);
419 if (!screen || !surface)
420 return false;
421 if (!SDL_SetSurfaceClipRect(surface, &srcRect))
422 return true;
423 if (!SDL_SetSurfaceClipRect(screen, &dstRect))
424 return true;
425 if (!SDL_BlitSurfaceScaled(surface, &srcRect, screen, &dstRect, SDL_SCALEMODE_LINEAR))
426 {
427 SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_BlitScaled: %s", SDL_GetError());
428 return false;
429 }
430 return true;
431}

◆ 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.

188{
189 auto screen = SDL_GetWindowSurface(_window);
190 if (!screen || !surface)
191 return false;
192 if (!SDL_SetClipRect(surface, &srcRect))
193 return true;
194 if (!SDL_SetClipRect(screen, &dstRect))
195 return true;
196 auto rc = SDL_BlitScaled(surface, &srcRect, screen, &dstRect);
197 if (rc != 0)
198 {
199 SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL_BlitScaled: %s [%d]", sdl_error_string(rc), rc);
200 }
201 return rc == 0;
202}

◆ bounds()

SDL_Rect SdlWindow::bounds ( ) const

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

91{
92 SDL_Rect rect = {};
93 if (_window)
94 {
95 if (!SDL_GetWindowPosition(_window, &rect.x, &rect.y))
96 return {};
97 if (!SDL_GetWindowSize(_window, &rect.w, &rect.h))
98 return {};
99 }
100 return rect;
101}

◆ create()

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

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

440{
441 flags |= SDL_WINDOW_HIGH_PIXEL_DENSITY;
442
443 SDL_Rect rect = { static_cast<int>(SDL_WINDOWPOS_CENTERED_DISPLAY(id)),
444 static_cast<int>(SDL_WINDOWPOS_CENTERED_DISPLAY(id)), static_cast<int>(width),
445 static_cast<int>(height) };
446
447 if ((flags & SDL_WINDOW_FULLSCREEN) != 0)
448 {
449 std::ignore = SDL_GetDisplayBounds(id, &rect);
450 }
451
452 SdlWindow window{ id, title, rect, flags };
453
454 if ((flags & (SDL_WINDOW_FULLSCREEN)) != 0)
455 {
456 window.setOffsetX(rect.x);
457 window.setOffsetY(rect.y);
458 }
459
460 return window;
461}

◆ displayIndex()

SDL_DisplayID SdlWindow::displayIndex ( ) const

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

48{
49 if (!_window)
50 return 0;
51 return SDL_GetWindowDisplayIndex(_window);
52}

◆ drawRect()

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

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

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

◆ drawRects()

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

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

235{
236 if (rects.empty())
237 {
238 return drawRect(surface, offset, { 0, 0, surface->w, surface->h });
239 }
240 for (auto& srcRect : rects)
241 {
242 if (!drawRect(surface, offset, srcRect))
243 return false;
244 }
245 return true;
246}

◆ drawScaledRect()

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

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

250{
251 SDL_Rect dstRect = srcRect;
252 dstRect.x = static_cast<Sint32>(static_cast<float>(dstRect.x) * scale.x);
253 dstRect.w = static_cast<Sint32>(static_cast<float>(dstRect.w) * scale.x);
254 dstRect.y = static_cast<Sint32>(static_cast<float>(dstRect.y) * scale.y);
255 dstRect.h = static_cast<Sint32>(static_cast<float>(dstRect.h) * scale.y);
256 return blit(surface, srcRect, dstRect);
257}

◆ drawScaledRects()

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

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

261{
262 if (rects.empty())
263 {
264 return drawScaledRect(surface, scale, { 0, 0, surface->w, surface->h });
265 }
266 for (const auto& srcRect : rects)
267 {
268 if (!drawScaledRect(surface, scale, srcRect))
269 return false;
270 }
271 return true;
272}

◆ 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 279 of file SDL3/sdl_window.cpp.

280{
281 auto surface = SDL_GetWindowSurface(window);
282 if (!surface)
283 return false;
284 SDL_Rect rect = { 0, 0, surface->w, surface->h };
285 auto color = SDL_MapSurfaceRGBA(surface, r, g, b, a);
286
287 return SDL_FillSurfaceRect(surface, &rect, color);
288}

◆ 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.

176{
177 auto surface = SDL_GetWindowSurface(_window);
178 if (!surface)
179 return false;
180 SDL_Rect rect = { 0, 0, surface->w, surface->h };
181 auto color = SDL_MapRGBA(surface->format, r, g, b, a);
182
183 SDL_FillRect(surface, &rect, color);
184 return true;
185}

◆ fullscreen() [1/2]

void SdlWindow::fullscreen ( bool  enter)

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

132{
133 auto curFlags = SDL_GetWindowFlags(_window);
134
135 if (enter)
136 {
137 if (!(curFlags & SDL_WINDOW_BORDERLESS))
138 {
139 auto idx = SDL_GetWindowDisplayIndex(_window);
140 SDL_DisplayMode mode = {};
141 SDL_GetCurrentDisplayMode(idx, &mode);
142
143 SDL_RestoreWindow(_window); // Maximize so we can see the caption and
144 // bits
145 SDL_SetWindowBordered(_window, SDL_FALSE);
146 SDL_SetWindowPosition(_window, 0, 0);
147#if SDL_VERSION_ATLEAST(2, 0, 16)
148 SDL_SetWindowAlwaysOnTop(_window, SDL_TRUE);
149#endif
150 SDL_RaiseWindow(_window);
151 SDL_SetWindowSize(_window, mode.w, mode.h);
152 }
153 }
154 else
155 {
156 if (curFlags & SDL_WINDOW_BORDERLESS)
157 {
158
159 SDL_SetWindowBordered(_window, SDL_TRUE);
160#if SDL_VERSION_ATLEAST(2, 0, 16)
161 SDL_SetWindowAlwaysOnTop(_window, SDL_FALSE);
162#endif
163 SDL_RaiseWindow(_window);
164 SDL_MinimizeWindow(_window); // Maximize so we can see the caption and bits
165 SDL_MaximizeWindow(_window); // Maximize so we can see the caption and bits
166 }
167 }
168}

◆ fullscreen() [2/2]

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

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

191{
192 if (enter && forceOriginalDisplay && _displayID != 0)
193 {
194 /* Move the window to the desired display. We should not wait
195 * for the window to be moved, because some backends can refuse
196 * the move. The intent of moving the window is enough for SDL
197 * to decide which display will be used for fullscreen. */
198 SDL_Rect rect = {};
199 std::ignore = SDL_GetDisplayBounds(_displayID, &rect);
200 std::ignore = SDL_SetWindowPosition(_window, rect.x, rect.y);
201 }
202 std::ignore = SDL_SetWindowFullscreen(_window, enter);
203 std::ignore = SDL_SyncWindow(_window);
204}

◆ grabKeyboard()

bool SdlWindow::grabKeyboard ( bool  enable)

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

91{
92 if (!_window)
93 return false;
94#if SDL_VERSION_ATLEAST(2, 0, 16)
95 SDL_SetWindowKeyboardGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
96 return true;
97#else
98 SDL_LogError(SDL_LOG_CATEGORY_INPUT, "Keyboard grabbing not supported by SDL2 < 2.0.16");
99 return false;
100#endif
101}

◆ grabMouse()

bool SdlWindow::grabMouse ( bool  enable)

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

104{
105 if (!_window)
106 return false;
107#if SDL_VERSION_ATLEAST(2, 0, 16)
108 SDL_SetWindowMouseGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
109#else
110 SDL_SetWindowGrab(_window, enable ? SDL_TRUE : SDL_FALSE);
111#endif
112 return true;
113}

◆ id()

SDL_WindowID SdlWindow::id ( ) const

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

41{
42 if (!_window)
43 return 0;
44 return SDL_GetWindowID(_window);
45}

◆ isHighDPIWindowsMode()

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

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

392{
393 if (!window)
394 return MODE_INVALID;
395
396 const auto id = SDL_GetDisplayForWindow(window);
397 if (id == 0)
398 return MODE_INVALID;
399
400 const auto cs = SDL_GetDisplayContentScale(id);
401 const auto ds = SDL_GetWindowDisplayScale(window);
402 const auto pd = SDL_GetWindowPixelDensity(window);
403
404 /* mac os x style, but no HighDPI display */
405 if ((cs == 1.0f) && (ds == 1.0f) && (pd == 1.0f))
406 return MODE_NONE;
407
408 /* mac os x style HighDPI */
409 if ((cs == 1.0f) && (ds > 1.0f) && (pd > 1.0f))
410 return MODE_MACOS;
411
412 /* rest is windows style */
413 return MODE_WINDOWS;
414}

◆ minimize()

void SdlWindow::minimize ( )

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

171{
172 SDL_MinimizeWindow(_window);
173}

◆ monitor()

rdpMonitor SdlWindow::monitor ( bool  isPrimary) const

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

129{
130 auto m = _monitor;
131 if (isPrimary)
132 {
133 m.x = 0;
134 m.y = 0;
135 }
136 return m;
137}

◆ offsetX()

Sint32 SdlWindow::offsetX ( ) const

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

71{
72 return _offset_x;
73}

◆ offsetY()

Sint32 SdlWindow::offsetY ( ) const

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

86{
87 return _offset_y;
88}

◆ orientation()

SDL_DisplayOrientation SdlWindow::orientation ( ) const

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

150{
151 const auto did = displayIndex();
152 return SDL_GetCurrentDisplayOrientation(did);
153}

◆ query() [1/2]

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

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

501{
502 std::unique_ptr<SDL_Window, void (*)(SDL_Window*)> window(createDummy(id), SDL_DestroyWindow);
503 if (!window)
504 return {};
505
506 std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer*)> renderer(
507 SDL_CreateRenderer(window.get(), nullptr), SDL_DestroyRenderer);
508
509 if (!SDL_SyncWindow(window.get()))
510 return {};
511
512 SDL_Event event{};
513 while (SDL_PollEvent(&event))
514 ;
515
516 return query(window.get(), id, forceAsPrimary);
517}

◆ query() [2/2]

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

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

291{
292 if (!window)
293 return {};
294
295 const auto& r = rect(window, forceAsPrimary);
296 const float factor = SDL_GetWindowDisplayScale(window);
297 const float dpi = std::roundf(factor * 100.0f);
298
299 WINPR_ASSERT(r.w > 0);
300 WINPR_ASSERT(r.h > 0);
301
302 const auto primary = SDL_GetPrimaryDisplay();
303 const auto orientation = SDL_GetCurrentDisplayOrientation(id);
304 const auto rdp_orientation = sdl::utils::orientaion_to_rdp(orientation);
305
306 rdpMonitor monitor{};
307 monitor.orig_screen = id;
308 monitor.x = r.x;
309 monitor.y = r.y;
310 monitor.width = r.w;
311 monitor.height = r.h;
312 monitor.is_primary = forceAsPrimary || (id == primary);
313 monitor.attributes.desktopScaleFactor = static_cast<UINT32>(dpi);
314 monitor.attributes.deviceScaleFactor = 100;
315 monitor.attributes.orientation = rdp_orientation;
316 monitor.attributes.physicalWidth = WINPR_ASSERTING_INT_CAST(uint32_t, r.w);
317 monitor.attributes.physicalHeight = WINPR_ASSERTING_INT_CAST(uint32_t, r.h);
318
319 const auto cat = SDL_LOG_CATEGORY_APPLICATION;
320 SDL_LogDebug(cat, "monitor.orig_screen %" PRIu32, monitor.orig_screen);
321 SDL_LogDebug(cat, "monitor.x %" PRId32, monitor.x);
322 SDL_LogDebug(cat, "monitor.y %" PRId32, monitor.y);
323 SDL_LogDebug(cat, "monitor.width %" PRId32, monitor.width);
324 SDL_LogDebug(cat, "monitor.height %" PRId32, monitor.height);
325 SDL_LogDebug(cat, "monitor.is_primary %" PRIu32, monitor.is_primary);
326 SDL_LogDebug(cat, "monitor.attributes.desktopScaleFactor %" PRIu32,
327 monitor.attributes.desktopScaleFactor);
328 SDL_LogDebug(cat, "monitor.attributes.deviceScaleFactor %" PRIu32,
329 monitor.attributes.deviceScaleFactor);
330 SDL_LogDebug(cat, "monitor.attributes.orientation %s",
331 freerdp_desktop_rotation_flags_to_string(monitor.attributes.orientation));
332 SDL_LogDebug(cat, "monitor.attributes.physicalWidth %" PRIu32,
333 monitor.attributes.physicalWidth);
334 SDL_LogDebug(cat, "monitor.attributes.physicalHeight %" PRIu32,
335 monitor.attributes.physicalHeight);
336 return monitor;
337}
rdpMonitor
Definition settings_types.h:431

◆ raise()

void SdlWindow::raise ( )

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

122{
123 SDL_RaiseWindow(_window);
124}

◆ rect() [1/3]

SDL_Rect SdlWindow::rect ( ) const

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

55{
56 SDL_Rect rect = {};
57 if (_window)
58 {
59 SDL_GetWindowPosition(_window, &rect.x, &rect.y);
60 SDL_GetWindowSize(_window, &rect.w, &rect.h);
61 }
62 return rect;
63}

◆ rect() [2/3]

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

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

520{
521 std::unique_ptr<SDL_Window, void (*)(SDL_Window*)> window(createDummy(id), SDL_DestroyWindow);
522 if (!window)
523 return {};
524
525 std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer*)> renderer(
526 SDL_CreateRenderer(window.get(), nullptr), SDL_DestroyRenderer);
527
528 if (!SDL_SyncWindow(window.get()))
529 return {};
530
531 SDL_Event event{};
532 while (SDL_PollEvent(&event))
533 ;
534
535 return rect(window.get(), forceAsPrimary);
536}

◆ rect() [3/3]

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

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

340{
341 SDL_Rect rect = {};
342 if (!window)
343 return {};
344
345 if (!forceAsPrimary)
346 {
347 if (!SDL_GetWindowPosition(window, &rect.x, &rect.y))
348 return {};
349 }
350
351 if (!SDL_GetWindowSizeInPixels(window, &rect.w, &rect.h))
352 return {};
353
354 const auto flags = SDL_GetWindowFlags(window);
355 const auto mask = SDL_WINDOW_FULLSCREEN;
356 const auto fs = (flags & mask) == mask;
357 if (tryFallback(fs))
358 {
359 /* On wlroots compositors (Sway, river, etc.), windows that are hidden/unmapped
360 * don't get their actual display dimensions. The dummy window returns its creation size
361 * (64x64) instead of the display size. This causes validation errors since we require >=
362 * 200px. Workaround: If we got dimensions that are too small, query the display directly.
363 */
364
365 const auto displayID = SDL_GetDisplayForWindow(window);
366 SDL_Rect displayBounds = {};
367 if (SDL_GetDisplayBounds(displayID, &displayBounds))
368 {
369 if (forceAsPrimary)
370 {
371 rect.x = 0;
372 rect.y = 0;
373 }
374 rect.w = displayBounds.w;
375 rect.h = displayBounds.h;
376
377 const float contentScale = SDL_GetDisplayContentScale(displayID);
378 if (contentScale > 1.0f)
379 {
380 const auto fw = static_cast<float>(rect.w);
381 const auto fh = static_cast<float>(rect.h);
382 rect.w = static_cast<int>(std::roundf(fw * contentScale));
383 rect.h = static_cast<int>(std::roundf(fh * contentScale));
384 }
385 }
386 }
387
388 return rect;
389}

◆ resize()

bool SdlWindow::resize ( const SDL_Point &  size)

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

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

◆ resizeable()

void SdlWindow::resizeable ( bool  use)

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

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

◆ resizeToPixelSize()

bool SdlWindow::resizeToPixelSize ( const SDL_Point &  size)

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

213{
214 auto sc = scale();
215 const int iscale = static_cast<int>(sc * 100.0f);
216 auto w = 100 * size.x / iscale;
217 auto h = 100 * size.y / iscale;
218 return resize({ w, h });
219}

◆ scale()

float SdlWindow::scale ( ) const

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

145{
146 return SDL_GetWindowDisplayScale(_window);
147}

◆ setBordered()

void SdlWindow::setBordered ( bool  bordered)

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

116{
117 if (_window)
118 SDL_SetWindowBordered(_window, bordered ? SDL_TRUE : SDL_FALSE);
119}

◆ setMonitor()

void SdlWindow::setMonitor ( rdpMonitor  monitor)

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

140{
141 _monitor = monitor;
142}

◆ setOffsetX()

void SdlWindow::setOffsetX ( Sint32  x)

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

76{
77 _offset_x = x;
78}

◆ setOffsetY()

void SdlWindow::setOffsetY ( Sint32  y)

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

81{
82 _offset_y = y;
83}

◆ tryFallback()

bool SdlWindow::tryFallback ( bool  isFullscreen)
staticprotected

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

539{
540 /* If we define a custom env variable to use the wlroots hack
541 * then enable/disable according to this setting only.
542 */
543 const auto wlroots_hack = SDL_getenv("FREERDP_WLROOTS_HACK");
544 if (wlroots_hack != nullptr)
545 {
546 const auto enabled = strcmp(wlroots_hack, "0") != 0;
547 if (strcmp(wlroots_hack, "force") == 0)
548 isFullscreen = true;
549 return enabled && isFullscreen;
550 }
551
552 const auto platform = SDL_GetPlatform();
553 if ((platform == nullptr) || (strcmp(platform, "Linux") != 0))
554 return false;
555
556 const auto driver = SDL_GetCurrentVideoDriver();
557 if ((driver == nullptr) || (strcmp(driver, "wayland") != 0))
558 return false;
559
560 /* check XDG_SESSION_DESKTOP
561 *
562 * if set and the value is
563 * - sway
564 *
565 * then we need the hack.
566 */
567 const auto xdg_session = SDL_getenv("XDG_SESSION_DESKTOP");
568 if (xdg_session != nullptr)
569 {
570 if (strcmp(xdg_session, "sway") == 0)
571 return isFullscreen;
572 }
573
574 /* check XDG_CURRENT_DESKTOP
575 *
576 * if set and the value is
577 * - sway:wlroots
578 *
579 * then we need the hack.
580 */
581 const auto xdg_desktop = SDL_getenv("XDG_CURRENT_DESKTOP");
582 if (xdg_desktop != nullptr)
583 {
584 if (strcmp(xdg_desktop, "sway:wlroots") == 0)
585 return isFullscreen;
586 }
587
588 return false;
589}

◆ updateSurface()

void SdlWindow::updateSurface ( )

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

205{
206 SDL_UpdateWindowSurface(_window);
207}

◆ window()

SDL_Window * SdlWindow::window ( ) const

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

66{
67 return _window;
68}
The documentation for this class was generated from the following files: