FreeRDP
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Modules Pages
xf_disp.c
1
20#include <math.h>
21#include <winpr/assert.h>
22#include <winpr/sysinfo.h>
23
24#include <freerdp/timer.h>
25
26#include <X11/Xutil.h>
27
28#ifdef WITH_XRANDR
29#include <X11/extensions/Xrandr.h>
30#include <X11/extensions/randr.h>
31
32#if (RANDR_MAJOR * 100 + RANDR_MINOR) >= 105
33#define USABLE_XRANDR
34#endif
35
36#endif
37
38#include "xf_disp.h"
39#include "xf_monitor.h"
40
41#include <freerdp/log.h>
42#define TAG CLIENT_TAG("x11disp")
43#define RESIZE_MIN_DELAY_NS 200000UL /* minimum delay in ms between two resizes */
44
45struct s_xfDispContext
46{
47 xfContext* xfc;
48 DispClientContext* disp;
49 BOOL haveXRandr;
50 int eventBase;
51 int errorBase;
52 UINT32 lastSentWidth;
53 UINT32 lastSentHeight;
54 BYTE reserved[4];
55 UINT64 lastSentDate;
56 UINT32 targetWidth;
57 UINT32 targetHeight;
58 BOOL activated;
59 BOOL fullscreen;
60 UINT16 lastSentDesktopOrientation;
61 BYTE reserved2[2];
62 UINT32 lastSentDesktopScaleFactor;
63 UINT32 lastSentDeviceScaleFactor;
64 BYTE reserved3[4];
65 FreeRDP_TimerID timerID;
66};
67
68static BOOL xf_disp_check_context(void* context, xfContext** ppXfc, xfDispContext** ppXfDisp,
69 rdpSettings** ppSettings);
70static BOOL xf_disp_sendResize(xfDispContext* xfDisp, BOOL fromTimer);
71static UINT xf_disp_sendLayout(DispClientContext* disp, const rdpMonitor* monitors,
72 UINT32 nmonitors);
73
74static BOOL xf_disp_settings_changed(xfDispContext* xfDisp)
75{
76 rdpSettings* settings = NULL;
77
78 WINPR_ASSERT(xfDisp);
79 WINPR_ASSERT(xfDisp->xfc);
80
81 settings = xfDisp->xfc->common.context.settings;
82 WINPR_ASSERT(settings);
83
84 if (xfDisp->lastSentWidth != xfDisp->targetWidth)
85 return TRUE;
86
87 if (xfDisp->lastSentHeight != xfDisp->targetHeight)
88 return TRUE;
89
90 if (xfDisp->lastSentDesktopOrientation !=
91 freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation))
92 return TRUE;
93
94 if (xfDisp->lastSentDesktopScaleFactor !=
95 freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor))
96 return TRUE;
97
98 if (xfDisp->lastSentDeviceScaleFactor !=
99 freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor))
100 return TRUE;
101
102 if (xfDisp->fullscreen != xfDisp->xfc->fullscreen)
103 return TRUE;
104
105 return FALSE;
106}
107
108static BOOL xf_update_last_sent(xfDispContext* xfDisp)
109{
110 rdpSettings* settings = NULL;
111
112 WINPR_ASSERT(xfDisp);
113 WINPR_ASSERT(xfDisp->xfc);
114
115 settings = xfDisp->xfc->common.context.settings;
116 WINPR_ASSERT(settings);
117
118 xfDisp->lastSentWidth = xfDisp->targetWidth;
119 xfDisp->lastSentHeight = xfDisp->targetHeight;
120 xfDisp->lastSentDesktopOrientation =
121 freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
122 xfDisp->lastSentDesktopScaleFactor =
123 freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
124 xfDisp->lastSentDeviceScaleFactor =
125 freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
126 xfDisp->fullscreen = xfDisp->xfc->fullscreen;
127 return TRUE;
128}
129
130static uint64_t xf_disp_OnTimer(rdpContext* context, WINPR_ATTR_UNUSED void* userdata,
131 WINPR_ATTR_UNUSED FreeRDP_TimerID timerID,
132 WINPR_ATTR_UNUSED uint64_t timestamp,
133 WINPR_ATTR_UNUSED uint64_t interval)
134
135{
136 xfContext* xfc = NULL;
137 xfDispContext* xfDisp = NULL;
138 rdpSettings* settings = NULL;
139
140 if (!xf_disp_check_context(context, &xfc, &xfDisp, &settings))
141 return interval;
142
143 if (!xfDisp->activated)
144 return interval;
145
146 xf_disp_sendResize(xfDisp, TRUE);
147 xfDisp->timerID = 0;
148 return 0;
149}
150
151static BOOL update_timer(xfDispContext* xfDisp, uint64_t intervalNS)
152{
153 WINPR_ASSERT(xfDisp);
154
155 if (xfDisp->timerID == 0)
156 {
157 rdpContext* context = &xfDisp->xfc->common.context;
158
159 xfDisp->timerID = freerdp_timer_add(context, intervalNS, xf_disp_OnTimer, NULL, true);
160 }
161 return TRUE;
162}
163
164BOOL xf_disp_sendResize(xfDispContext* xfDisp, BOOL fromTimer)
165{
166 DISPLAY_CONTROL_MONITOR_LAYOUT layout = { 0 };
167
168 if (!xfDisp || !xfDisp->xfc)
169 return FALSE;
170
171 /* If there is already a timer running skip the update and wait for the timer to expire. */
172 if ((xfDisp->timerID != 0) && !fromTimer)
173 return TRUE;
174
175 xfContext* xfc = xfDisp->xfc;
176 rdpSettings* settings = xfc->common.context.settings;
177
178 if (!settings)
179 return FALSE;
180
181 if (!xfDisp->activated || !xfDisp->disp)
182 return update_timer(xfDisp, RESIZE_MIN_DELAY_NS);
183
184 const uint64_t diff = winpr_GetTickCount64NS() - xfDisp->lastSentDate;
185 if (diff < RESIZE_MIN_DELAY_NS)
186 {
187 const uint64_t interval = RESIZE_MIN_DELAY_NS - diff;
188 return update_timer(xfDisp, interval);
189 }
190
191 if (!xf_disp_settings_changed(xfDisp))
192 return TRUE;
193
194 xfDisp->lastSentDate = winpr_GetTickCount64NS();
195
196 const UINT32 mcount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
197 if (mcount > 1)
198 {
199 const rdpMonitor* monitors =
200 freerdp_settings_get_pointer(settings, FreeRDP_MonitorDefArray);
201 if (xf_disp_sendLayout(xfDisp->disp, monitors, mcount) != CHANNEL_RC_OK)
202 return FALSE;
203 }
204 else
205 {
206 layout.Flags = DISPLAY_CONTROL_MONITOR_PRIMARY;
207 layout.Top = layout.Left = 0;
208 layout.Width = xfDisp->targetWidth;
209 layout.Height = xfDisp->targetHeight;
210 layout.Orientation = freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
211 layout.DesktopScaleFactor =
212 freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
213 layout.DeviceScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
214
215 const double dw = xfDisp->targetWidth / 75.0 * 25.4;
216 const double dh = xfDisp->targetHeight / 75.0 * 25.4;
217 layout.PhysicalWidth = (UINT32)lround(dw);
218 layout.PhysicalHeight = (UINT32)lround(dh);
219
220 if (IFCALLRESULT(CHANNEL_RC_OK, xfDisp->disp->SendMonitorLayout, xfDisp->disp, 1,
221 &layout) != CHANNEL_RC_OK)
222 return FALSE;
223 }
224
225 return xf_update_last_sent(xfDisp);
226}
227
228static BOOL xf_disp_queueResize(xfDispContext* xfDisp, UINT32 width, UINT32 height)
229{
230 if ((xfDisp->targetWidth == (INT64)width) && (xfDisp->targetHeight == (INT64)height))
231 return TRUE;
232 xfDisp->targetWidth = width;
233 xfDisp->targetHeight = height;
234 return xf_disp_sendResize(xfDisp, FALSE);
235}
236
237static BOOL xf_disp_set_window_resizable(xfDispContext* xfDisp)
238{
239 XSizeHints* size_hints = NULL;
240
241 if (!(size_hints = XAllocSizeHints()))
242 return FALSE;
243
244 size_hints->flags = PMinSize | PMaxSize | PWinGravity;
245 size_hints->win_gravity = NorthWestGravity;
246 size_hints->min_width = size_hints->min_height = 320;
247 size_hints->max_width = size_hints->max_height = 8192;
248
249 if (xfDisp->xfc->window)
250 XSetWMNormalHints(xfDisp->xfc->display, xfDisp->xfc->window->handle, size_hints);
251
252 XFree(size_hints);
253 return TRUE;
254}
255
256BOOL xf_disp_check_context(void* context, xfContext** ppXfc, xfDispContext** ppXfDisp,
257 rdpSettings** ppSettings)
258{
259 xfContext* xfc = NULL;
260
261 if (!context)
262 return FALSE;
263
264 xfc = (xfContext*)context;
265
266 if (!(xfc->xfDisp))
267 return FALSE;
268
269 if (!xfc->common.context.settings)
270 return FALSE;
271
272 *ppXfc = xfc;
273 *ppXfDisp = xfc->xfDisp;
274 *ppSettings = xfc->common.context.settings;
275 return TRUE;
276}
277
278static void xf_disp_OnActivated(void* context, const ActivatedEventArgs* e)
279{
280 xfContext* xfc = NULL;
281 xfDispContext* xfDisp = NULL;
282 rdpSettings* settings = NULL;
283
284 if (!xf_disp_check_context(context, &xfc, &xfDisp, &settings))
285 return;
286
287 if (xfDisp->activated && !xfc->fullscreen)
288 {
289 xf_disp_set_window_resizable(xfDisp);
290
291 if (e->firstActivation)
292 return;
293
294 xf_disp_sendResize(xfDisp, FALSE);
295 }
296}
297
298static void xf_disp_OnGraphicsReset(void* context, const GraphicsResetEventArgs* e)
299{
300 xfContext* xfc = NULL;
301 xfDispContext* xfDisp = NULL;
302 rdpSettings* settings = NULL;
303
304 WINPR_UNUSED(e);
305
306 if (!xf_disp_check_context(context, &xfc, &xfDisp, &settings))
307 return;
308
309 if (xfDisp->activated && !freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
310 {
311 xf_disp_set_window_resizable(xfDisp);
312 xf_disp_sendResize(xfDisp, FALSE);
313 }
314}
315
316static void xf_disp_OnWindowStateChange(void* context, const WindowStateChangeEventArgs* e)
317{
318 xfContext* xfc = NULL;
319 xfDispContext* xfDisp = NULL;
320 rdpSettings* settings = NULL;
321
322 WINPR_UNUSED(e);
323
324 if (!xf_disp_check_context(context, &xfc, &xfDisp, &settings))
325 return;
326
327 if (!xfDisp->activated || !xfc->fullscreen)
328 return;
329
330 xf_disp_sendResize(xfDisp, FALSE);
331}
332
333xfDispContext* xf_disp_new(xfContext* xfc)
334{
335 xfDispContext* ret = NULL;
336 const rdpSettings* settings = NULL;
337 wPubSub* pubSub = NULL;
338
339 WINPR_ASSERT(xfc);
340
341 pubSub = xfc->common.context.pubSub;
342 WINPR_ASSERT(pubSub);
343
344 settings = xfc->common.context.settings;
345 WINPR_ASSERT(settings);
346
347 ret = calloc(1, sizeof(xfDispContext));
348
349 if (!ret)
350 return NULL;
351
352 ret->xfc = xfc;
353#ifdef USABLE_XRANDR
354
355 if (XRRQueryExtension(xfc->display, &ret->eventBase, &ret->errorBase))
356 {
357 ret->haveXRandr = TRUE;
358 }
359
360#endif
361 ret->lastSentWidth = ret->targetWidth =
362 freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
363 ret->lastSentHeight = ret->targetHeight =
364 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
365 PubSub_SubscribeActivated(pubSub, xf_disp_OnActivated);
366 PubSub_SubscribeGraphicsReset(pubSub, xf_disp_OnGraphicsReset);
367 PubSub_SubscribeWindowStateChange(pubSub, xf_disp_OnWindowStateChange);
368 return ret;
369}
370
371void xf_disp_free(xfDispContext* disp)
372{
373 if (!disp)
374 return;
375
376 if (disp->xfc)
377 {
378 wPubSub* pubSub = disp->xfc->common.context.pubSub;
379 PubSub_UnsubscribeActivated(pubSub, xf_disp_OnActivated);
380 PubSub_UnsubscribeGraphicsReset(pubSub, xf_disp_OnGraphicsReset);
381 PubSub_UnsubscribeWindowStateChange(pubSub, xf_disp_OnWindowStateChange);
382 }
383
384 free(disp);
385}
386
387UINT xf_disp_sendLayout(DispClientContext* disp, const rdpMonitor* monitors, UINT32 nmonitors)
388{
389 UINT ret = CHANNEL_RC_OK;
390 xfDispContext* xfDisp = NULL;
391 rdpSettings* settings = NULL;
392 DISPLAY_CONTROL_MONITOR_LAYOUT* layouts = NULL;
393
394 WINPR_ASSERT(disp);
395 WINPR_ASSERT(monitors);
396 WINPR_ASSERT(nmonitors > 0);
397
398 xfDisp = (xfDispContext*)disp->custom;
399 WINPR_ASSERT(xfDisp);
400 WINPR_ASSERT(xfDisp->xfc);
401
402 settings = xfDisp->xfc->common.context.settings;
403 WINPR_ASSERT(settings);
404
405 layouts = calloc(nmonitors, sizeof(DISPLAY_CONTROL_MONITOR_LAYOUT));
406
407 if (!layouts)
408 return CHANNEL_RC_NO_MEMORY;
409
410 for (UINT32 i = 0; i < nmonitors; i++)
411 {
412 const rdpMonitor* monitor = &monitors[i];
413 DISPLAY_CONTROL_MONITOR_LAYOUT* layout = &layouts[i];
414
415 layout->Flags = (monitor->is_primary ? DISPLAY_CONTROL_MONITOR_PRIMARY : 0);
416 layout->Left = monitor->x;
417 layout->Top = monitor->y;
418 layout->Width = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
419 layout->Height = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
420 layout->Orientation = ORIENTATION_LANDSCAPE;
421 layout->PhysicalWidth = monitor->attributes.physicalWidth;
422 layout->PhysicalHeight = monitor->attributes.physicalHeight;
423
424 switch (monitor->attributes.orientation)
425 {
426 case 90:
427 layout->Orientation = ORIENTATION_PORTRAIT;
428 break;
429
430 case 180:
431 layout->Orientation = ORIENTATION_LANDSCAPE_FLIPPED;
432 break;
433
434 case 270:
435 layout->Orientation = ORIENTATION_PORTRAIT_FLIPPED;
436 break;
437
438 case 0:
439 default:
440 /* MS-RDPEDISP - 2.2.2.2.1:
441 * Orientation (4 bytes): A 32-bit unsigned integer that specifies the
442 * orientation of the monitor in degrees. Valid values are 0, 90, 180
443 * or 270
444 *
445 * So we default to ORIENTATION_LANDSCAPE
446 */
447 layout->Orientation = ORIENTATION_LANDSCAPE;
448 break;
449 }
450
451 layout->DesktopScaleFactor =
452 freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
453 layout->DeviceScaleFactor =
454 freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
455 }
456
457 ret = IFCALLRESULT(CHANNEL_RC_OK, disp->SendMonitorLayout, disp, nmonitors, layouts);
458 free(layouts);
459 return ret;
460}
461
462BOOL xf_disp_handle_xevent(xfContext* xfc, const XEvent* event)
463{
464 xfDispContext* xfDisp = NULL;
465 rdpSettings* settings = NULL;
466 UINT32 maxWidth = 0;
467 UINT32 maxHeight = 0;
468
469 if (!xfc || !event)
470 return FALSE;
471
472 xfDisp = xfc->xfDisp;
473
474 if (!xfDisp)
475 return FALSE;
476
477 settings = xfc->common.context.settings;
478
479 if (!settings)
480 return FALSE;
481
482 if (!xfDisp->haveXRandr || !xfDisp->disp)
483 return TRUE;
484
485#ifdef USABLE_XRANDR
486
487 if (event->type != xfDisp->eventBase + RRScreenChangeNotify)
488 return TRUE;
489
490#endif
491 xf_detect_monitors(xfc, &maxWidth, &maxHeight);
492 const rdpMonitor* monitors = freerdp_settings_get_pointer(settings, FreeRDP_MonitorDefArray);
493 const UINT32 mcount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
494 return xf_disp_sendLayout(xfDisp->disp, monitors, mcount) == CHANNEL_RC_OK;
495}
496
497BOOL xf_disp_handle_configureNotify(xfContext* xfc, int width, int height)
498{
499 xfDispContext* xfDisp = NULL;
500
501 if (!xfc)
502 return FALSE;
503
504 xfDisp = xfc->xfDisp;
505
506 if (!xfDisp)
507 return FALSE;
508
509 return xf_disp_queueResize(xfDisp, WINPR_ASSERTING_INT_CAST(uint32_t, width),
510 WINPR_ASSERTING_INT_CAST(uint32_t, height));
511}
512
513static UINT xf_DisplayControlCaps(DispClientContext* disp, UINT32 maxNumMonitors,
514 UINT32 maxMonitorAreaFactorA, UINT32 maxMonitorAreaFactorB)
515{
516 /* we're called only if dynamic resolution update is activated */
517 xfDispContext* xfDisp = NULL;
518 rdpSettings* settings = NULL;
519
520 WINPR_ASSERT(disp);
521
522 xfDisp = (xfDispContext*)disp->custom;
523 WINPR_ASSERT(xfDisp);
524 WINPR_ASSERT(xfDisp->xfc);
525
526 settings = xfDisp->xfc->common.context.settings;
527 WINPR_ASSERT(settings);
528
529 WLog_DBG(TAG,
530 "DisplayControlCapsPdu: MaxNumMonitors: %" PRIu32 " MaxMonitorAreaFactorA: %" PRIu32
531 " MaxMonitorAreaFactorB: %" PRIu32 "",
532 maxNumMonitors, maxMonitorAreaFactorA, maxMonitorAreaFactorB);
533 xfDisp->activated = TRUE;
534
535 if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
536 return CHANNEL_RC_OK;
537
538 WLog_DBG(TAG, "DisplayControlCapsPdu: setting the window as resizable");
539 return xf_disp_set_window_resizable(xfDisp) ? CHANNEL_RC_OK : CHANNEL_RC_NO_MEMORY;
540}
541
542BOOL xf_disp_init(xfDispContext* xfDisp, DispClientContext* disp)
543{
544 rdpSettings* settings = NULL;
545
546 if (!xfDisp || !xfDisp->xfc || !disp)
547 return FALSE;
548
549 settings = xfDisp->xfc->common.context.settings;
550
551 if (!settings)
552 return FALSE;
553
554 xfDisp->disp = disp;
555 disp->custom = (void*)xfDisp;
556
557 if (freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate))
558 {
559 disp->DisplayControlCaps = xf_DisplayControlCaps;
560#ifdef USABLE_XRANDR
561
562 if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
563 {
564 /* ask X11 to notify us of screen changes */
565 XRRSelectInput(xfDisp->xfc->display, DefaultRootWindow(xfDisp->xfc->display),
566 RRScreenChangeNotifyMask);
567 }
568
569#endif
570 }
571
572 return TRUE;
573}
574
575BOOL xf_disp_uninit(xfDispContext* xfDisp, DispClientContext* disp)
576{
577 if (!xfDisp || !disp)
578 return FALSE;
579
580 xfDisp->disp = NULL;
581 return TRUE;
582}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_get_uint16
FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id)
Returns a UINT16 settings value.
freerdp_settings_get_pointer
FREERDP_API const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
Definition common/settings.c:1403
rdpMonitor
Definition settings_types.h:423
DISPLAY_CONTROL_MONITOR_LAYOUT
Definition channels/disp.h:65