FreeRDP
Loading...
Searching...
No Matches
xf_rail.c
1
20#include <freerdp/config.h>
21
22#include <X11/Xlib.h>
23#include <X11/Xatom.h>
24#include <X11/Xutil.h>
25
26#include <winpr/cast.h>
27#include <winpr/assert.h>
28#include <winpr/wlog.h>
29#include <winpr/print.h>
30#include <winpr/sysinfo.h>
31
32#include <freerdp/client/rail.h>
33
34#include "xf_window.h"
35#include "xf_rail.h"
36#include "xf_utils.h"
37
38#include <freerdp/log.h>
39
40WINPR_ATTR_NODISCARD
41static const char* error_code2str(UINT32 code)
42{
43#define EVCASE(x) \
44 case x: \
45 return #x
46 switch (code)
47 {
48 EVCASE(RAIL_EXEC_S_OK);
49 EVCASE(RAIL_EXEC_E_HOOK_NOT_LOADED);
50 EVCASE(RAIL_EXEC_E_DECODE_FAILED);
51 EVCASE(RAIL_EXEC_E_NOT_IN_ALLOWLIST);
52 EVCASE(RAIL_EXEC_E_FILE_NOT_FOUND);
53 EVCASE(RAIL_EXEC_E_FAIL);
54 EVCASE(RAIL_EXEC_E_SESSION_LOCKED);
55 default:
56 return "RAIL_EXEC_E_UNKNOWN";
57 }
58#undef EVCASE
59}
60
61WINPR_ATTR_NODISCARD
62static const char* movetype2str(UINT32 code)
63{
64#define EVCASE(x) \
65 case x: \
66 return #x
67
68 switch (code)
69 {
70
71 EVCASE(RAIL_WMSZ_LEFT);
72 EVCASE(RAIL_WMSZ_RIGHT);
73 EVCASE(RAIL_WMSZ_TOP);
74 EVCASE(RAIL_WMSZ_TOPLEFT);
75 EVCASE(RAIL_WMSZ_TOPRIGHT);
76 EVCASE(RAIL_WMSZ_BOTTOM);
77 EVCASE(RAIL_WMSZ_BOTTOMLEFT);
78 EVCASE(RAIL_WMSZ_BOTTOMRIGHT);
79 EVCASE(RAIL_WMSZ_MOVE);
80 EVCASE(RAIL_WMSZ_KEYMOVE);
81 EVCASE(RAIL_WMSZ_KEYSIZE);
82 default:
83 return "RAIL_WMSZ_INVALID";
84 }
85#undef EVCASE
86}
87
88struct xf_rail_icon
89{
90 long* data;
91 int length;
92};
93typedef struct xf_rail_icon xfRailIcon;
94
95struct xf_rail_icon_cache
96{
97 xfRailIcon* entries;
98 UINT32 numCaches;
99 UINT32 numCacheEntries;
100 xfRailIcon scratch;
101};
102
103typedef struct
104{
105 xfContext* xfc;
106 const RECTANGLE_16* rect;
107} rail_paint_fn_arg_t;
108
109BOOL xf_rail_enable_remoteapp_mode(xfContext* xfc)
110{
111 WINPR_ASSERT(xfc);
112 if (!xfc->remote_app)
113 {
114 rdpGdi* gdi = xfc->common.context.gdi;
115 WINPR_ASSERT(gdi);
116
117 const BOOL old = gdi->suppressOutput;
118 gdi->suppressOutput = TRUE;
119 xfc->remote_app = TRUE;
120 xfc->drawable = xf_CreateDummyWindow(xfc);
121 xf_DestroyDesktopWindow(xfc, xfc->window);
122 xfc->window = nullptr;
123
124 gdi->suppressOutput = old;
125 }
126 return TRUE;
127}
128
129BOOL xf_rail_disable_remoteapp_mode(xfContext* xfc)
130{
131 WINPR_ASSERT(xfc);
132 if (xfc->remote_app)
133 {
134 rdpGdi* gdi = xfc->common.context.gdi;
135 WINPR_ASSERT(gdi);
136
137 const BOOL old = gdi->suppressOutput;
138 gdi->suppressOutput = TRUE;
139
140 xfc->remote_app = FALSE;
141 xf_DestroyDummyWindow(xfc, xfc->drawable);
142 xf_destroy_window(xfc);
143 xf_create_window(xfc);
144 xf_create_image(xfc);
145
146 gdi->suppressOutput = old;
147 }
148 return TRUE;
149}
150
151WINPR_ATTR_NODISCARD
152static BOOL xf_rail_select_workarea_events(xfContext* xfc)
153{
154 WINPR_ASSERT(xfc);
155
156 XWindowAttributes attributes = WINPR_C_ARRAY_INIT;
157 const Window root = DefaultRootWindow(xfc->display);
158 const int rc = LogDynAndXGetWindowAttributes(xfc->log, xfc->display, root, &attributes);
159 if (rc != 1)
160 return FALSE;
161
162 LogDynAndXSelectInput(xfc->log, xfc->display, root,
163 attributes.your_event_mask | PropertyChangeMask);
164 return TRUE;
165}
166
167WINPR_ATTR_NODISCARD
168static BOOL xf_rail_get_workarea(xfContext* xfc, xfWorkArea* workArea)
169{
170 WINPR_ASSERT(xfc);
171 WINPR_ASSERT(workArea);
172
173 /* xf_GetWorkArea overwrites xfc->workArea; restore it (RAIL keeps it full). */
174 const xfWorkArea saved = xfc->workArea;
175 const BOOL rc = xf_GetWorkArea(xfc);
176 *workArea = xfc->workArea;
177 xfc->workArea = saved;
178 return rc;
179}
180
181/* Report the real work area so the server maximizes RemoteApp windows within the panel. */
182WINPR_ATTR_NODISCARD
183static UINT xf_rail_send_workarea(xfContext* xfc)
184{
185 WINPR_ASSERT(xfc);
186
187 if (!xfc->remote_app || !xfc->rail)
188 return CHANNEL_RC_OK;
189
190 xfWorkArea current = WINPR_C_ARRAY_INIT;
191 if (!xf_rail_get_workarea(xfc, &current))
192 return CHANNEL_RC_OK;
193
194 if ((current.x == xfc->railWorkArea.x) && (current.y == xfc->railWorkArea.y) &&
195 (current.width == xfc->railWorkArea.width) && (current.height == xfc->railWorkArea.height))
196 {
197 WLog_Print(xfc->log, WLOG_DEBUG,
198 "Suppressing work area %" PRId32 ",%" PRId32 " %" PRIu32 "x%" PRIu32
199 ": unchanged",
200 current.x, current.y, current.width, current.height);
201 return CHANNEL_RC_OK;
202 }
203
204 const INT64 right = (INT64)current.x + current.width;
205 const INT64 bottom = (INT64)current.y + current.height;
206 const RAIL_SYSPARAM_ORDER sysparam = { .params = SPI_MASK_SET_WORK_AREA,
207 .workArea.left =
208 WINPR_CXX_COMPAT_CAST(UINT16, current.x),
209 .workArea.top = WINPR_CXX_COMPAT_CAST(UINT16, current.y),
210 .workArea.right = WINPR_CXX_COMPAT_CAST(UINT16, right),
211 .workArea.bottom =
212 WINPR_CXX_COMPAT_CAST(UINT16, bottom) };
213
214 WLog_Print(xfc->log, WLOG_DEBUG,
215 "Sending work area %" PRId32 ",%" PRId32 " %" PRIu32 "x%" PRIu32, current.x,
216 current.y, current.width, current.height);
217 const UINT rc = xfc->rail->ClientSystemParam(xfc->rail, &sysparam);
218 if (rc == CHANNEL_RC_OK)
219 xfc->railWorkArea = current;
220
221 return rc;
222}
223
224BOOL xf_rail_schedule_workarea(xfContext* xfc)
225{
226 WINPR_ASSERT(xfc);
227
228 xfWorkArea current = WINPR_C_ARRAY_INIT;
229 if (!xf_rail_get_workarea(xfc, &current))
230 {
231 WLog_Print(xfc->log, WLOG_DEBUG, "Suppressing work area update: current value unavailable");
232 return TRUE;
233 }
234
235 return xf_rail_send_workarea(xfc) == CHANNEL_RC_OK;
236}
237
238BOOL xf_rail_send_activate(xfContext* xfc, Window xwindow, BOOL enabled)
239{
240 RAIL_ACTIVATE_ORDER activate = WINPR_C_ARRAY_INIT;
241 xfAppWindow* appWindow = xf_AppWindowFromX11Window(xfc, xwindow);
242
243 if (!appWindow)
244 {
245 WLog_Print(xfc->log, WLOG_DEBUG, "xf_rail_send_activate: ignoring unknown window 0x%08lx",
246 xwindow);
247 return TRUE;
248 }
249
250 if (enabled)
251 xf_SetWindowStyle(xfc, appWindow, appWindow->dwStyle, appWindow->dwExStyle);
252
253 WINPR_ASSERT(appWindow->windowId <= UINT32_MAX);
254 activate.windowId = (UINT32)appWindow->windowId;
255 xf_rail_return_window(appWindow, FALSE);
256
257 activate.enabled = enabled;
258 const UINT rc = xfc->rail->ClientActivate(xfc->rail, &activate);
259 return rc == CHANNEL_RC_OK;
260}
261
262BOOL xf_rail_send_client_system_command(xfContext* xfc, UINT64 windowId, UINT16 command)
263{
264 WINPR_ASSERT(xfc);
265 WINPR_ASSERT(xfc->rail);
266 WINPR_ASSERT(xfc->rail->ClientSystemCommand);
267 if (windowId > UINT32_MAX)
268 return FALSE;
269
270 const RAIL_SYSCOMMAND_ORDER syscommand = { .windowId = (UINT32)windowId, .command = command };
271 const UINT rc = xfc->rail->ClientSystemCommand(xfc->rail, &syscommand);
272 return rc == CHANNEL_RC_OK;
273}
274
281BOOL xf_rail_adjust_position(xfContext* xfc, xfAppWindow* appWindow)
282{
283 RAIL_WINDOW_MOVE_ORDER windowMove = WINPR_C_ARRAY_INIT;
284
285 WINPR_ASSERT(xfc);
286 WINPR_ASSERT(appWindow);
287
288 if (!appWindow->is_mapped || appWindow->local_move.state != LMS_NOT_ACTIVE)
289 return FALSE;
290
291 /* NOTE: this geometry report is required - if it is dropped the server no
292 * longer knows where the window manager placed the window and all mouse
293 * events are routed to the wrong coordinates (buttons stop responding).
294 * The window size feedback loop is handled in xf_rail_window_common(). */
295 if (appWindow->x != appWindow->windowOffsetX || appWindow->y != appWindow->windowOffsetY ||
296 appWindow->width != (INT64)appWindow->windowWidth ||
297 appWindow->height != (INT64)appWindow->windowHeight)
298 {
299 WINPR_ASSERT(appWindow->windowId <= UINT32_MAX);
300 windowMove.windowId = (UINT32)appWindow->windowId;
301 /*
302 * Calculate new size/position for the rail window(new values for
303 * windowOffsetX/windowOffsetY/windowWidth/windowHeight) on the server
304 */
305 const INT16 left = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginLeft);
306 const INT16 right = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginRight);
307 const INT16 top = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginTop);
308 const INT16 bottom = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginBottom);
309 windowMove.left = WINPR_ASSERTING_INT_CAST(INT16, appWindow->x - left);
310 windowMove.top = WINPR_ASSERTING_INT_CAST(INT16, appWindow->y - top);
311 windowMove.right = WINPR_ASSERTING_INT_CAST(INT16, appWindow->x + appWindow->width + right);
312 windowMove.bottom =
313 WINPR_ASSERTING_INT_CAST(INT16, appWindow->y + appWindow->height + bottom);
314 const UINT rc = xfc->rail->ClientWindowMove(xfc->rail, &windowMove);
315 return rc == CHANNEL_RC_OK;
316 }
317 return TRUE;
318}
319
320BOOL xf_rail_end_local_move(xfContext* xfc, xfAppWindow* appWindow)
321{
322 int x = 0;
323 int y = 0;
324 int child_x = 0;
325 int child_y = 0;
326 unsigned int mask = 0;
327 Window root_window = 0;
328 Window child_window = 0;
329
330 WINPR_ASSERT(xfc);
331 WINPR_ASSERT(appWindow);
332
333 if ((appWindow->local_move.direction == NET_WM_MOVERESIZE_MOVE_KEYBOARD) ||
334 (appWindow->local_move.direction == NET_WM_MOVERESIZE_SIZE_KEYBOARD))
335 {
336 RAIL_WINDOW_MOVE_ORDER windowMove = WINPR_C_ARRAY_INIT;
337
338 /*
339 * For keyboard moves send and explicit update to RDP server
340 */
341 WINPR_ASSERT(appWindow->windowId <= UINT32_MAX);
342 windowMove.windowId = (UINT32)appWindow->windowId;
343 /*
344 * Calculate new size/position for the rail window(new values for
345 * windowOffsetX/windowOffsetY/windowWidth/windowHeight) on the server
346 *
347 */
348 const INT16 left = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginLeft);
349 const INT16 right = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginRight);
350 const INT16 top = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginTop);
351 const INT16 bottom = WINPR_ASSERTING_INT_CAST(INT16, appWindow->resizeMarginBottom);
352 const INT16 w = WINPR_ASSERTING_INT_CAST(INT16, appWindow->width + right);
353 const INT16 h = WINPR_ASSERTING_INT_CAST(INT16, appWindow->height + bottom);
354 windowMove.left = WINPR_ASSERTING_INT_CAST(INT16, appWindow->x - left);
355 windowMove.top = WINPR_ASSERTING_INT_CAST(INT16, appWindow->y - top);
356 windowMove.right = WINPR_ASSERTING_INT_CAST(INT16, appWindow->x + w); /* In the update to
357 RDP the position is one past the window */
358 windowMove.bottom = WINPR_ASSERTING_INT_CAST(INT16, appWindow->y + h);
359 const UINT rc = xfc->rail->ClientWindowMove(xfc->rail, &windowMove);
360 if (rc != CHANNEL_RC_OK)
361 return FALSE;
362 }
363
364 /*
365 * Simulate button up at new position to end the local move (per RDP spec)
366 */
367 XQueryPointer(xfc->display, appWindow->handle, &root_window, &child_window, &x, &y, &child_x,
368 &child_y, &mask);
369
370 /* only send the mouse coordinates if not a keyboard move or size */
371 if ((appWindow->local_move.direction != NET_WM_MOVERESIZE_MOVE_KEYBOARD) &&
372 (appWindow->local_move.direction != NET_WM_MOVERESIZE_SIZE_KEYBOARD))
373 {
374 if (!freerdp_client_send_button_event(&xfc->common, FALSE, PTR_FLAGS_BUTTON1, x, y))
375 return FALSE;
376 }
377
378 /*
379 * Proactively update the RAIL window dimensions. There is a race condition where
380 * we can start to receive GDI orders for the new window dimensions before we
381 * receive the RAIL ORDER for the new window size. This avoids that race condition.
382 */
383 appWindow->windowOffsetX = appWindow->x;
384 appWindow->windowOffsetY = appWindow->y;
385 appWindow->windowWidth = WINPR_ASSERTING_INT_CAST(uint32_t, appWindow->width);
386 appWindow->windowHeight = WINPR_ASSERTING_INT_CAST(uint32_t, appWindow->height);
387 appWindow->local_move.state = LMS_TERMINATING;
388 return TRUE;
389}
390
391BOOL xf_rail_paint_surface(xfContext* xfc, UINT64 windowId, const RECTANGLE_16* rect)
392{
393 xfAppWindow* appWindow = xf_rail_get_window(xfc, windowId, FALSE);
394
395 WINPR_ASSERT(rect);
396
397 if (!appWindow)
398 return FALSE;
399
400 const RECTANGLE_16 windowRect = {
401 .left = WINPR_ASSERTING_INT_CAST(UINT16, MAX(appWindow->x, 0)),
402 .top = WINPR_ASSERTING_INT_CAST(UINT16, MAX(appWindow->y, 0)),
403 .right = WINPR_ASSERTING_INT_CAST(UINT16, MAX(appWindow->x + appWindow->width, 0)),
404 .bottom = WINPR_ASSERTING_INT_CAST(UINT16, MAX(appWindow->y + appWindow->height, 0))
405 };
406
407 REGION16 windowInvalidRegion = WINPR_C_ARRAY_INIT;
408 region16_init(&windowInvalidRegion);
409 if (!region16_union_rect(&windowInvalidRegion, &windowInvalidRegion, &windowRect))
410 return FALSE;
411 if (!region16_intersect_rect(&windowInvalidRegion, &windowInvalidRegion, rect))
412 return FALSE;
413
414 if (!region16_is_empty(&windowInvalidRegion))
415 {
416 const RECTANGLE_16* extents = region16_extents(&windowInvalidRegion);
417
418 const RECTANGLE_16 updateRect = {
419 .left = WINPR_ASSERTING_INT_CAST(UINT16, extents->left - appWindow->x),
420 .top = WINPR_ASSERTING_INT_CAST(UINT16, extents->top - appWindow->y),
421 .right = WINPR_ASSERTING_INT_CAST(UINT16, extents->right - appWindow->x),
422 .bottom = WINPR_ASSERTING_INT_CAST(UINT16, extents->bottom - appWindow->y)
423 };
424
425 xf_UpdateWindowArea(xfc, appWindow, updateRect.left, updateRect.top,
426 updateRect.right - updateRect.left, updateRect.bottom - updateRect.top);
427 }
428 region16_uninit(&windowInvalidRegion);
429 xf_rail_return_window(appWindow, FALSE);
430 return TRUE;
431}
432
433WINPR_ATTR_NODISCARD
434static BOOL rail_paint_fn(const void* pvkey, WINPR_ATTR_UNUSED void* value, void* pvarg)
435{
436 rail_paint_fn_arg_t* arg = pvarg;
437 WINPR_ASSERT(pvkey);
438 WINPR_ASSERT(arg);
439
440 const UINT64 key = *(const UINT64*)pvkey;
441 return xf_rail_paint_surface(arg->xfc, key, arg->rect);
442}
443
444BOOL xf_rail_paint(xfContext* xfc, const RECTANGLE_16* rect)
445{
446 rail_paint_fn_arg_t arg = { .xfc = xfc, .rect = rect };
447
448 WINPR_ASSERT(xfc);
449 WINPR_ASSERT(rect);
450
451 if (!xfc->railWindows)
452 return TRUE;
453
454 return HashTable_Foreach(xfc->railWindows, rail_paint_fn, &arg);
455}
456
457#define window_state_log_style(log, windowState) \
458 window_state_log_style_int((log), (windowState), __FILE__, __func__, __LINE__)
459static void window_state_log_style_int(wLog* log, const WINDOW_STATE_ORDER* windowState,
460 const char* file, const char* fkt, size_t line)
461{
462 const DWORD log_level = WLOG_DEBUG;
463
464 WINPR_ASSERT(log);
465 WINPR_ASSERT(windowState);
466 if (WLog_IsLevelActive(log, log_level))
467 {
468 char buffer1[128] = WINPR_C_ARRAY_INIT;
469 char buffer2[128] = WINPR_C_ARRAY_INIT;
470
471 window_styles_to_string(windowState->style, buffer1, sizeof(buffer1));
472 window_styles_ex_to_string(windowState->extendedStyle, buffer2, sizeof(buffer2));
473 WLog_PrintTextMessage(log, log_level, line, file, fkt, "windowStyle={%s, %s}", buffer1,
474 buffer2);
475 }
476}
477
478/* RemoteApp Core Protocol Extension */
479WINPR_ATTR_NODISCARD
480static BOOL xf_rail_window_common(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
481 const WINDOW_STATE_ORDER* windowState)
482{
483 BOOL rc = FALSE;
484 xfContext* xfc = (xfContext*)context;
485
486 WINPR_ASSERT(xfc);
487 WINPR_ASSERT(orderInfo);
488 WINPR_ASSERT(windowState);
489
490 UINT32 fieldFlags = orderInfo->fieldFlags;
491 BOOL position_or_size_updated = FALSE;
492 xfAppWindow* appWindow = xf_rail_get_window(xfc, orderInfo->windowId, FALSE);
493
494 if (fieldFlags & WINDOW_ORDER_STATE_NEW)
495 {
496 if (!appWindow)
497 appWindow = xf_rail_add_window(xfc, orderInfo->windowId, windowState->windowOffsetX,
498 windowState->windowOffsetY, windowState->windowWidth,
499 windowState->windowHeight, 0xFFFFFFFF);
500
501 if (!appWindow)
502 goto fail;
503
504 appWindow->dwStyle = windowState->style;
505 appWindow->dwExStyle = windowState->extendedStyle;
506 window_state_log_style(xfc->log, windowState);
507
508 /* Ensure window always gets a window title */
509 if (fieldFlags & WINDOW_ORDER_FIELD_TITLE)
510 {
511 char* title = rail_string_to_utf8_string(&windowState->titleInfo);
512 if (!title)
513 {
514 WLog_Print(xfc->log, WLOG_ERROR, "failed to duplicate window title string");
515 /* error handled below */
516 }
517
518 appWindow->title = title;
519 }
520 else
521 {
522 if (!(appWindow->title = _strdup("RdpRailWindow")))
523 WLog_Print(xfc->log, WLOG_ERROR, "failed to duplicate default window title string");
524 }
525
526 if (!appWindow->title)
527 goto fail;
528
529 xf_AppWindowInit(xfc, appWindow);
530 }
531
532 if (!appWindow)
533 return FALSE;
534
535 /* Keep track of any position/size update so that we can force a refresh of the window */
536 if ((fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET) ||
537 (fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE) ||
538 (fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET) ||
539 (fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE) ||
540 (fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA) ||
541 (fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET) ||
542 (fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY))
543 {
544 position_or_size_updated = TRUE;
545 }
546
547 /* Update Parameters */
548
549 if (fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET)
550 {
551 appWindow->windowOffsetX = windowState->windowOffsetX;
552 appWindow->windowOffsetY = windowState->windowOffsetY;
553 }
554
555 if (fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE)
556 {
557 /* Coalesce bursts of server side window size updates.
558 *
559 * When a RemoteApp dialog opens, the server sends a sequence of window
560 * sizes (~45 frames, ~15ms apart) - a window open animation performed
561 * by rdpshell. The client applies every frame and reports the resulting
562 * geometry back, which makes the server shrink the window again by its
563 * frame size. That feedback loop runs away and collapses the dialog to
564 * a 1px wide strip: it "flashes and disappears".
565 *
566 * Keep only the first update of such a burst (which is close to the
567 * real size) and ignore the rest for a second. Positions are still
568 * reported, so mouse input keeps working. */
569 const UINT64 now = winpr_GetTickCount64NS() / 1000000ULL;
570 const BOOL burst =
571 (appWindow->lastWndSizeUpdate != 0) && ((now - appWindow->lastWndSizeUpdate) < 1000);
572 const UINT32 newW = windowState->windowWidth;
573 const UINT32 newH = windowState->windowHeight;
574 const BOOL degenerate = (newW < 32) || (newH < 32);
575 const BOOL hadSane = (appWindow->windowWidth >= 32) && (appWindow->windowHeight >= 32);
576
577 if ((degenerate && hadSane) || burst)
578 {
579 WLog_Print(xfc->log, WLOG_DEBUG,
580 "coalescing RAIL window size %" PRIu32 "x%" PRIu32
581 " (burst=%d degenerate=%d)",
582 newW, newH, burst, degenerate);
583 }
584 else
585 {
586 appWindow->windowWidth = newW;
587 appWindow->windowHeight = newH;
588 appWindow->lastWndSizeUpdate = now;
589 }
590 }
591
592 if (fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_X)
593 {
594 appWindow->resizeMarginLeft = windowState->resizeMarginLeft;
595 appWindow->resizeMarginRight = windowState->resizeMarginRight;
596 }
597
598 if (fieldFlags & WINDOW_ORDER_FIELD_RESIZE_MARGIN_Y)
599 {
600 appWindow->resizeMarginTop = windowState->resizeMarginTop;
601 appWindow->resizeMarginBottom = windowState->resizeMarginBottom;
602 }
603
604 if (fieldFlags & WINDOW_ORDER_FIELD_OWNER)
605 {
606 appWindow->ownerWindowId = windowState->ownerWindowId;
607 }
608
609 if (fieldFlags & WINDOW_ORDER_FIELD_STYLE)
610 {
611 appWindow->dwStyle = windowState->style;
612 appWindow->dwExStyle = windowState->extendedStyle;
613 window_state_log_style(xfc->log, windowState);
614 }
615
616 if (fieldFlags & WINDOW_ORDER_FIELD_SHOW)
617 {
618 appWindow->showState = windowState->showState;
619 }
620
621 if (fieldFlags & WINDOW_ORDER_FIELD_TITLE)
622 {
623 char* title = rail_string_to_utf8_string(&windowState->titleInfo);
624 if (!title)
625 {
626 WLog_Print(xfc->log, WLOG_ERROR, "failed to duplicate window title string");
627 goto fail;
628 }
629
630 free(appWindow->title);
631 appWindow->title = title;
632 }
633
634 if (fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_OFFSET)
635 {
636 appWindow->clientOffsetX = windowState->clientOffsetX;
637 appWindow->clientOffsetY = windowState->clientOffsetY;
638 }
639
640 if (fieldFlags & WINDOW_ORDER_FIELD_CLIENT_AREA_SIZE)
641 {
642 appWindow->clientAreaWidth = windowState->clientAreaWidth;
643 appWindow->clientAreaHeight = windowState->clientAreaHeight;
644 }
645
646 if (fieldFlags & WINDOW_ORDER_FIELD_WND_CLIENT_DELTA)
647 {
648 appWindow->windowClientDeltaX = windowState->windowClientDeltaX;
649 appWindow->windowClientDeltaY = windowState->windowClientDeltaY;
650 }
651
652 if (fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS)
653 {
654 if (appWindow->windowRects)
655 {
656 free(appWindow->windowRects);
657 appWindow->windowRects = nullptr;
658 }
659
660 appWindow->numWindowRects = windowState->numWindowRects;
661
662 if (appWindow->numWindowRects)
663 {
664 appWindow->windowRects =
665 (RECTANGLE_16*)calloc(appWindow->numWindowRects, sizeof(RECTANGLE_16));
666
667 if (!appWindow->windowRects)
668 goto fail;
669
670 CopyMemory(appWindow->windowRects, windowState->windowRects,
671 appWindow->numWindowRects * sizeof(RECTANGLE_16));
672 }
673 }
674
675 if (fieldFlags & WINDOW_ORDER_FIELD_VIS_OFFSET)
676 {
677 appWindow->visibleOffsetX = windowState->visibleOffsetX;
678 appWindow->visibleOffsetY = windowState->visibleOffsetY;
679 }
680
681 if (fieldFlags & WINDOW_ORDER_FIELD_VISIBILITY)
682 {
683 if (appWindow->visibilityRects)
684 {
685 free(appWindow->visibilityRects);
686 appWindow->visibilityRects = nullptr;
687 }
688
689 appWindow->numVisibilityRects = windowState->numVisibilityRects;
690
691 if (appWindow->numVisibilityRects)
692 {
693 appWindow->visibilityRects =
694 (RECTANGLE_16*)calloc(appWindow->numVisibilityRects, sizeof(RECTANGLE_16));
695
696 if (!appWindow->visibilityRects)
697 goto fail;
698
699 CopyMemory(appWindow->visibilityRects, windowState->visibilityRects,
700 appWindow->numVisibilityRects * sizeof(RECTANGLE_16));
701 }
702 }
703
704 /* Update Window */
705
706 if (fieldFlags & WINDOW_ORDER_FIELD_STYLE)
707 {
708 }
709
710 if (fieldFlags & WINDOW_ORDER_FIELD_SHOW)
711 {
712 xf_ShowWindow(xfc, appWindow, WINPR_ASSERTING_INT_CAST(UINT8, appWindow->showState));
713 }
714
715 if (fieldFlags & WINDOW_ORDER_FIELD_TITLE)
716 {
717 if (appWindow->title)
718 xf_SetWindowText(xfc, appWindow, appWindow->title);
719 }
720
721 if (position_or_size_updated)
722 {
723 const INT32 visibilityRectsOffsetX =
724 (appWindow->visibleOffsetX -
725 (appWindow->clientOffsetX - appWindow->windowClientDeltaX));
726 const INT32 visibilityRectsOffsetY =
727 (appWindow->visibleOffsetY -
728 (appWindow->clientOffsetY - appWindow->windowClientDeltaY));
729
730 /*
731 * The rail server like to set the window to a small size when it is minimized even though
732 * it is hidden in some cases this can cause the window not to restore back to its original
733 * size. Therefore we don't update our local window when that rail window state is minimized
734 */
735 if (appWindow->rail_state != WINDOW_SHOW_MINIMIZED)
736 {
737 const BOOL maximized = (appWindow->dwStyle & WS_MAXIMIZE) != 0;
738 /* Leave maximized windows to the WM, which honors the work area. */
739 if (maximized || (appWindow->x == (INT64)appWindow->windowOffsetX &&
740 appWindow->y == (INT64)appWindow->windowOffsetY &&
741 appWindow->width == (INT64)appWindow->windowWidth &&
742 appWindow->height == (INT64)appWindow->windowHeight))
743 {
744 xf_UpdateWindowArea(xfc, appWindow, 0, 0,
745 WINPR_ASSERTING_INT_CAST(int, appWindow->windowWidth),
746 WINPR_ASSERTING_INT_CAST(int, appWindow->windowHeight));
747 }
748 else
749 {
750 xf_MoveWindow(xfc, appWindow, appWindow->windowOffsetX, appWindow->windowOffsetY,
751 WINPR_ASSERTING_INT_CAST(int, appWindow->windowWidth),
752 WINPR_ASSERTING_INT_CAST(int, appWindow->windowHeight));
753 }
754
755 /* Show a maximized window fully; its frame-inset visibility rects would clip it. */
756 if (maximized)
757 xf_ClearWindowVisibilityRects(xfc, appWindow);
758 else
759 xf_SetWindowVisibilityRects(
760 xfc, appWindow, WINPR_ASSERTING_INT_CAST(uint32_t, visibilityRectsOffsetX),
761 WINPR_ASSERTING_INT_CAST(uint32_t, visibilityRectsOffsetY),
762 appWindow->visibilityRects,
763 WINPR_ASSERTING_INT_CAST(int, appWindow->numVisibilityRects));
764 }
765
766 if (appWindow->rail_state == WINDOW_SHOW_MAXIMIZED)
767 {
768 xf_SendClientEvent(xfc, appWindow->handle, xfc->NET_WM_STATE, 4, NET_WM_STATE_ADD,
769 xfc->NET_WM_STATE_MAXIMIZED_VERT, xfc->NET_WM_STATE_MAXIMIZED_HORZ,
770 0, 0);
771 }
772 }
773
774 if (fieldFlags & (WINDOW_ORDER_STATE_NEW | WINDOW_ORDER_FIELD_STYLE))
775 xf_SetWindowStyle(xfc, appWindow, appWindow->dwStyle, appWindow->dwExStyle);
776
777 /* We should only be using the visibility rects for shaping the window */
778 /*if (fieldFlags & WINDOW_ORDER_FIELD_WND_RECTS)
779 {
780 xf_SetWindowRects(xfc, appWindow, appWindow->windowRects, appWindow->numWindowRects);
781 }*/
782 rc = TRUE;
783fail:
784 xf_rail_return_window(appWindow, FALSE);
785 return rc;
786}
787
788WINPR_ATTR_NODISCARD
789static BOOL xf_rail_window_delete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
790{
791 xfContext* xfc = (xfContext*)context;
792 WINPR_ASSERT(xfc);
793 return xf_rail_del_window(xfc, orderInfo->windowId);
794}
795
796static void RailIconCache_Free(xfRailIconCache* cache)
797{
798 if (!cache)
799 return;
800
801 for (UINT32 i = 0; i < cache->numCaches * cache->numCacheEntries; i++)
802 {
803 xfRailIcon* cur = &cache->entries[i];
804 free(cur->data);
805 }
806
807 free(cache->scratch.data);
808 free(cache->entries);
809 free(cache);
810}
811
812WINPR_ATTR_MALLOC(RailIconCache_Free, 1)
813static xfRailIconCache* RailIconCache_New(wLog* log, rdpSettings* settings)
814{
815 xfRailIconCache* cache = calloc(1, sizeof(xfRailIconCache));
816
817 if (!cache)
818 return nullptr;
819
820 cache->numCaches = freerdp_settings_get_uint32(settings, FreeRDP_RemoteAppNumIconCaches);
821 cache->numCacheEntries =
822 freerdp_settings_get_uint32(settings, FreeRDP_RemoteAppNumIconCacheEntries);
823 cache->entries = calloc(1ull * cache->numCaches * cache->numCacheEntries, sizeof(xfRailIcon));
824
825 if (!cache->entries)
826 {
827 WLog_Print(log, WLOG_ERROR,
828 "failed to allocate icon cache %" PRIu32 " x %" PRIu32 " entries",
829 cache->numCaches, cache->numCacheEntries);
830 free(cache);
831 return nullptr;
832 }
833
834 return cache;
835}
836
837WINPR_ATTR_NODISCARD
838static xfRailIcon* RailIconCache_Lookup(xfRailIconCache* cache, UINT8 cacheId, UINT16 cacheEntry)
839{
840 WINPR_ASSERT(cache);
841 /*
842 * MS-RDPERP 2.2.1.2.3 Icon Info (TS_ICON_INFO)
843 *
844 * CacheId (1 byte):
845 * If the value is 0xFFFF, the icon SHOULD NOT be cached.
846 *
847 * Yes, the spec says "0xFFFF" in the 2018-03-16 revision,
848 * but the actual protocol field is 1-byte wide.
849 */
850 if (cacheId == 0xFF)
851 return &cache->scratch;
852
853 if (cacheId >= cache->numCaches)
854 return nullptr;
855
856 if (cacheEntry >= cache->numCacheEntries)
857 return nullptr;
858
859 return &cache->entries[cache->numCacheEntries * cacheId + cacheEntry];
860}
861
862/*
863 * _NET_WM_ICON format is defined as "array of CARDINAL" values which for
864 * Xlib must be represented with an array of C's "long" values. Note that
865 * "long" != "INT32" on 64-bit systems. Therefore we can't simply cast
866 * the bitmap data as (unsigned char*), we have to copy all the pixels.
867 *
868 * The first two values are width and height followed by actual color data
869 * in ARGB format (e.g., 0xFFFF0000L is opaque red), pixels are in normal,
870 * left-to-right top-down order.
871 */
872WINPR_ATTR_NODISCARD
873static BOOL convert_rail_icon(const ICON_INFO* iconInfo, xfRailIcon* railIcon)
874{
875 WINPR_ASSERT(iconInfo);
876 WINPR_ASSERT(railIcon);
877
878 BYTE* nextPixel = nullptr;
879 long* pixels = nullptr;
880 BYTE* argbPixels = calloc(1ull * iconInfo->width * iconInfo->height, 4);
881
882 if (!argbPixels)
883 goto error;
884
885 if (!freerdp_image_copy_from_icon_data(
886 argbPixels, PIXEL_FORMAT_ARGB32, 0, 0, 0,
887 WINPR_ASSERTING_INT_CAST(UINT16, iconInfo->width),
888 WINPR_ASSERTING_INT_CAST(UINT16, iconInfo->height), iconInfo->bitsColor,
889 WINPR_ASSERTING_INT_CAST(UINT16, iconInfo->cbBitsColor), iconInfo->bitsMask,
890 WINPR_ASSERTING_INT_CAST(UINT16, iconInfo->cbBitsMask), iconInfo->colorTable,
891 WINPR_ASSERTING_INT_CAST(UINT16, iconInfo->cbColorTable), iconInfo->bpp))
892 goto error;
893
894 {
895 const UINT32 nelements = 2 + iconInfo->width * iconInfo->height;
896 pixels = realloc(railIcon->data, nelements * sizeof(long));
897
898 if (!pixels)
899 goto error;
900
901 railIcon->data = pixels;
902
903 railIcon->length = WINPR_ASSERTING_INT_CAST(int, nelements);
904 pixels[0] = iconInfo->width;
905 pixels[1] = iconInfo->height;
906 nextPixel = argbPixels;
907
908 for (UINT32 i = 2; i < nelements; i++)
909 {
910 pixels[i] = FreeRDPReadColor(nextPixel, PIXEL_FORMAT_BGRA32);
911 nextPixel += 4;
912 }
913 }
914
915 free(argbPixels);
916 return TRUE;
917error:
918 free(argbPixels);
919 return FALSE;
920}
921
922static void xf_rail_set_window_icon(xfContext* xfc, xfAppWindow* railWindow, xfRailIcon* icon,
923 BOOL replace)
924{
925 WINPR_ASSERT(xfc);
926
927 LogDynAndXChangeProperty(xfc->log, xfc->display, railWindow->handle, xfc->NET_WM_ICON,
928 XA_CARDINAL, 32, replace ? PropModeReplace : PropModeAppend,
929 (unsigned char*)icon->data, icon->length);
930 LogDynAndXFlush(xfc->log, xfc->display);
931}
932
933WINPR_ATTR_NODISCARD
934static BOOL xf_rail_window_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
935 const WINDOW_ICON_ORDER* windowIcon)
936{
937 BOOL rc = FALSE;
938 xfContext* xfc = (xfContext*)context;
939 BOOL replaceIcon = 0;
940 xfAppWindow* railWindow = xf_rail_get_window(xfc, orderInfo->windowId, FALSE);
941
942 if (!railWindow)
943 return TRUE;
944
945 WINPR_ASSERT(windowIcon);
946 WINPR_ASSERT(windowIcon->iconInfo);
947 xfRailIcon* icon = RailIconCache_Lookup(
948 xfc->railIconCache, WINPR_ASSERTING_INT_CAST(UINT8, windowIcon->iconInfo->cacheId),
949 WINPR_ASSERTING_INT_CAST(UINT16, windowIcon->iconInfo->cacheEntry));
950
951 if (!icon)
952 {
953 WLog_Print(xfc->log, WLOG_WARN, "failed to get icon from cache %02X:%04X",
954 windowIcon->iconInfo->cacheId, windowIcon->iconInfo->cacheEntry);
955 }
956 else if (!convert_rail_icon(windowIcon->iconInfo, icon))
957 {
958 WLog_Print(xfc->log, WLOG_WARN, "failed to convert icon for window %08X",
959 orderInfo->windowId);
960 }
961 else
962 {
963 replaceIcon = !!(orderInfo->fieldFlags & WINDOW_ORDER_STATE_NEW);
964 xf_rail_set_window_icon(xfc, railWindow, icon, replaceIcon);
965 rc = TRUE;
966 }
967 xf_rail_return_window(railWindow, FALSE);
968 return rc;
969}
970
971WINPR_ATTR_NODISCARD
972static BOOL xf_rail_window_cached_icon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
973 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
974{
975 BOOL rc = FALSE;
976 xfContext* xfc = (xfContext*)context;
977 WINPR_ASSERT(orderInfo);
978
979 BOOL replaceIcon = 0;
980 xfAppWindow* railWindow = xf_rail_get_window(xfc, orderInfo->windowId, FALSE);
981
982 if (!railWindow)
983 return TRUE;
984
985 WINPR_ASSERT(windowCachedIcon);
986
987 xfRailIcon* icon = RailIconCache_Lookup(
988 xfc->railIconCache, WINPR_ASSERTING_INT_CAST(UINT8, windowCachedIcon->cachedIcon.cacheId),
989 WINPR_ASSERTING_INT_CAST(UINT16, windowCachedIcon->cachedIcon.cacheEntry));
990
991 if (!icon)
992 {
993 WLog_Print(xfc->log, WLOG_WARN, "failed to get icon from cache %02X:%04X",
994 windowCachedIcon->cachedIcon.cacheId, windowCachedIcon->cachedIcon.cacheEntry);
995 }
996 else
997 {
998 replaceIcon = !!(orderInfo->fieldFlags & WINDOW_ORDER_STATE_NEW);
999 xf_rail_set_window_icon(xfc, railWindow, icon, replaceIcon);
1000 rc = TRUE;
1001 }
1002 xf_rail_return_window(railWindow, FALSE);
1003 return rc;
1004}
1005
1006WINPR_ATTR_NODISCARD
1007static BOOL
1008xf_rail_notify_icon_common(WINPR_ATTR_UNUSED rdpContext* context,
1009 const WINDOW_ORDER_INFO* orderInfo,
1010 WINPR_ATTR_UNUSED const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1011{
1012 xfContext* xfc = (xfContext*)context;
1013 WINPR_ASSERT(xfc);
1014
1015 WLog_Print(xfc->log, WLOG_ERROR, "TODO: implement");
1016 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_VERSION)
1017 {
1018 }
1019
1020 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_TIP)
1021 {
1022 }
1023
1024 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_INFO_TIP)
1025 {
1026 }
1027
1028 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_STATE)
1029 {
1030 }
1031
1032 if (orderInfo->fieldFlags & WINDOW_ORDER_ICON)
1033 {
1034 }
1035
1036 if (orderInfo->fieldFlags & WINDOW_ORDER_CACHED_ICON)
1037 {
1038 }
1039
1040 return TRUE;
1041}
1042
1043WINPR_ATTR_NODISCARD
1044static BOOL xf_rail_notify_icon_create(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1045 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1046{
1047 return xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
1048}
1049
1050WINPR_ATTR_NODISCARD
1051static BOOL xf_rail_notify_icon_update(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1052 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1053{
1054 return xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
1055}
1056
1057WINPR_ATTR_NODISCARD
1058static BOOL xf_rail_notify_icon_delete(WINPR_ATTR_UNUSED rdpContext* context,
1059 WINPR_ATTR_UNUSED const WINDOW_ORDER_INFO* orderInfo)
1060{
1061 xfContext* xfc = (xfContext*)context;
1062 WINPR_ASSERT(xfc);
1063
1064 WLog_Print(xfc->log, WLOG_ERROR, "TODO: implement");
1065 return TRUE;
1066}
1067
1068WINPR_ATTR_NODISCARD
1069static BOOL
1070xf_rail_monitored_desktop(WINPR_ATTR_UNUSED rdpContext* context,
1071 WINPR_ATTR_UNUSED const WINDOW_ORDER_INFO* orderInfo,
1072 WINPR_ATTR_UNUSED const MONITORED_DESKTOP_ORDER* monitoredDesktop)
1073{
1074 const UINT32 mask = WINDOW_ORDER_TYPE_DESKTOP | WINDOW_ORDER_FIELD_DESKTOP_HOOKED |
1075 WINDOW_ORDER_FIELD_DESKTOP_ARC_BEGAN |
1076 WINDOW_ORDER_FIELD_DESKTOP_ARC_COMPLETED |
1077 WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND | WINDOW_ORDER_FIELD_DESKTOP_ZORDER;
1078 xfContext* xfc = (xfContext*)context;
1079
1080 if (!context || !orderInfo || !monitoredDesktop)
1081 return FALSE;
1082
1083 if ((orderInfo->fieldFlags & WINDOW_ORDER_TYPE_DESKTOP) == 0)
1084 {
1085 WLog_Print(xfc->log, WLOG_WARN, "WINDOW_ORDER_TYPE_DESKTOP flag missing!");
1086 return FALSE;
1087 }
1088
1089 if ((orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ARC_BEGAN) &&
1090 (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_HOOKED))
1091 {
1092 // discard all windows/notify icons
1093 WLog_Print(xfc->log, WLOG_WARN,
1094 "TODO: implement WINDOW_ORDER_FIELD_DESKTOP_ARC_BEGAN && "
1095 "WINDOW_ORDER_FIELD_DESKTOP_HOOKED");
1096 }
1097 else if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_HOOKED)
1098 {
1099 WLog_Print(xfc->log, WLOG_WARN, "TODO: implement WINDOW_ORDER_FIELD_DESKTOP_HOOKED");
1100 }
1101 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ARC_COMPLETED)
1102 {
1103 WLog_Print(xfc->log, WLOG_DEBUG,
1104 "WINDOW_ORDER_FIELD_DESKTOP_ARC_COMPLETED -> switch to RAILS mode");
1105 if (!xf_rail_enable_remoteapp_mode(xfc))
1106 return FALSE;
1107
1108 if (!xf_rail_select_workarea_events(xfc))
1109 return FALSE;
1110
1111 const char* app =
1112 freerdp_settings_get_string(context->settings, FreeRDP_RemoteApplicationProgram);
1113 if ((app != nullptr) && (strnlen(app, 1) > 0))
1114 {
1115 if (client_rail_server_start_cmd(xfc->rail) != CHANNEL_RC_OK)
1116 return FALSE;
1117 if (xf_rail_send_workarea(xfc) != CHANNEL_RC_OK)
1118 return FALSE;
1119 }
1120 }
1121 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND)
1122 {
1123 WLog_Print(xfc->log, WLOG_WARN, "TODO: implement WINDOW_ORDER_FIELD_DESKTOP_ACTIVE_WND");
1124 }
1125 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_ZORDER)
1126 {
1127 WLog_Print(xfc->log, WLOG_WARN, "TODO: implement WINDOW_ORDER_FIELD_DESKTOP_ZORDER");
1128 }
1129 if (orderInfo->fieldFlags & ~mask)
1130 {
1131 WLog_Print(xfc->log, WLOG_WARN, "unknown flags 0x%08" PRIx32 "!", orderInfo->fieldFlags);
1132 }
1133 return TRUE;
1134}
1135
1136WINPR_ATTR_NODISCARD
1137static BOOL xf_rail_non_monitored_desktop(rdpContext* context,
1138 WINPR_ATTR_UNUSED const WINDOW_ORDER_INFO* orderInfo)
1139{
1140 xfContext* xfc = (xfContext*)context;
1141 const UINT32 mask = WINDOW_ORDER_TYPE_DESKTOP | WINDOW_ORDER_FIELD_DESKTOP_NONE;
1142
1143 if (!context || !orderInfo)
1144 return FALSE;
1145
1146 if ((orderInfo->fieldFlags & WINDOW_ORDER_TYPE_DESKTOP) == 0)
1147 {
1148 WLog_Print(xfc->log, WLOG_WARN, "TODO: implement WINDOW_ORDER_TYPE_DESKTOP");
1149 return FALSE;
1150 }
1151 if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_DESKTOP_NONE)
1152 {
1153 WLog_Print(xfc->log, WLOG_WARN, "TODO: implement WINDOW_ORDER_FIELD_DESKTOP_NONE");
1154 }
1155 if (orderInfo->fieldFlags & ~mask)
1156 {
1157 WLog_Print(xfc->log, WLOG_WARN, "unknown flags 0x%08" PRIx32 "!", orderInfo->fieldFlags);
1158 }
1159
1160 return xf_rail_disable_remoteapp_mode(xfc);
1161}
1162
1163static void xf_rail_register_update_callbacks(rdpUpdate* update)
1164{
1165 WINPR_ASSERT(update);
1166
1167 rdpWindowUpdate* window = update->window;
1168 WINPR_ASSERT(window);
1169
1170 window->WindowCreate = xf_rail_window_common;
1171 window->WindowUpdate = xf_rail_window_common;
1172 window->WindowDelete = xf_rail_window_delete;
1173 window->WindowIcon = xf_rail_window_icon;
1174 window->WindowCachedIcon = xf_rail_window_cached_icon;
1175 window->NotifyIconCreate = xf_rail_notify_icon_create;
1176 window->NotifyIconUpdate = xf_rail_notify_icon_update;
1177 window->NotifyIconDelete = xf_rail_notify_icon_delete;
1178 window->MonitoredDesktop = xf_rail_monitored_desktop;
1179 window->NonMonitoredDesktop = xf_rail_non_monitored_desktop;
1180}
1181
1182/* RemoteApp Virtual Channel Extension */
1183
1189WINPR_ATTR_NODISCARD
1190static UINT xf_rail_server_execute_result(RailClientContext* context,
1191 const RAIL_EXEC_RESULT_ORDER* execResult)
1192{
1193 WINPR_ASSERT(context);
1194 WINPR_ASSERT(execResult);
1195
1196 xfContext* xfc = (xfContext*)context->custom;
1197 WINPR_ASSERT(xfc);
1198
1199 if (execResult->execResult != RAIL_EXEC_S_OK)
1200 {
1201 WLog_Print(
1202 xfc->log, WLOG_ERROR, "RAIL exec error: execResult=%s [0x%08" PRIx32 "] NtError=0x%X\n",
1203 error_code2str(execResult->execResult), execResult->execResult, execResult->rawResult);
1204 freerdp_abort_connect_context(&xfc->common.context);
1205 }
1206
1207 return CHANNEL_RC_OK;
1208}
1209
1215WINPR_ATTR_NODISCARD
1216static UINT xf_rail_server_system_param(WINPR_ATTR_UNUSED RailClientContext* context,
1217 WINPR_ATTR_UNUSED const RAIL_SYSPARAM_ORDER* sysparam)
1218{
1219 WINPR_ASSERT(context);
1220
1221 xfContext* xfc = (xfContext*)context->custom;
1222 WINPR_ASSERT(xfc);
1223
1224 // TODO: Actually apply param
1225 WLog_Print(xfc->log, WLOG_ERROR, "TODO: implement");
1226 return CHANNEL_RC_OK;
1227}
1228
1234WINPR_ATTR_NODISCARD
1235static UINT xf_rail_server_local_move_size(RailClientContext* context,
1236 const RAIL_LOCALMOVESIZE_ORDER* localMoveSize)
1237{
1238 int x = 0;
1239 int y = 0;
1240 int direction = 0;
1241 Window child_window = 0;
1242 WINPR_ASSERT(context);
1243 WINPR_ASSERT(localMoveSize);
1244
1245 xfContext* xfc = (xfContext*)context->custom;
1246 xfAppWindow* appWindow = xf_rail_get_window(xfc, localMoveSize->windowId, FALSE);
1247
1248 if (!appWindow)
1249 return ERROR_INTERNAL_ERROR;
1250
1251 WLog_Print(xfc->log, WLOG_TRACE, "%s [0x%08" PRIx32 "]",
1252 movetype2str(localMoveSize->moveSizeType), localMoveSize->moveSizeType);
1253 switch (localMoveSize->moveSizeType)
1254 {
1255 case RAIL_WMSZ_LEFT:
1256 direction = NET_WM_MOVERESIZE_SIZE_LEFT;
1257 x = localMoveSize->posX;
1258 y = localMoveSize->posY;
1259 break;
1260
1261 case RAIL_WMSZ_RIGHT:
1262 direction = NET_WM_MOVERESIZE_SIZE_RIGHT;
1263 x = localMoveSize->posX;
1264 y = localMoveSize->posY;
1265 break;
1266
1267 case RAIL_WMSZ_TOP:
1268 direction = NET_WM_MOVERESIZE_SIZE_TOP;
1269 x = localMoveSize->posX;
1270 y = localMoveSize->posY;
1271 break;
1272
1273 case RAIL_WMSZ_TOPLEFT:
1274 direction = NET_WM_MOVERESIZE_SIZE_TOPLEFT;
1275 x = localMoveSize->posX;
1276 y = localMoveSize->posY;
1277 break;
1278
1279 case RAIL_WMSZ_TOPRIGHT:
1280 direction = NET_WM_MOVERESIZE_SIZE_TOPRIGHT;
1281 x = localMoveSize->posX;
1282 y = localMoveSize->posY;
1283 break;
1284
1285 case RAIL_WMSZ_BOTTOM:
1286 direction = NET_WM_MOVERESIZE_SIZE_BOTTOM;
1287 x = localMoveSize->posX;
1288 y = localMoveSize->posY;
1289 break;
1290
1291 case RAIL_WMSZ_BOTTOMLEFT:
1292 direction = NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT;
1293 x = localMoveSize->posX;
1294 y = localMoveSize->posY;
1295 break;
1296
1297 case RAIL_WMSZ_BOTTOMRIGHT:
1298 direction = NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT;
1299 x = localMoveSize->posX;
1300 y = localMoveSize->posY;
1301 break;
1302
1303 case RAIL_WMSZ_MOVE:
1304 direction = NET_WM_MOVERESIZE_MOVE;
1305 XTranslateCoordinates(xfc->display, appWindow->handle, RootWindowOfScreen(xfc->screen),
1306 localMoveSize->posX, localMoveSize->posY, &x, &y, &child_window);
1307 break;
1308
1309 case RAIL_WMSZ_KEYMOVE:
1310 direction = NET_WM_MOVERESIZE_MOVE_KEYBOARD;
1311 x = localMoveSize->posX;
1312 y = localMoveSize->posY;
1313 /* FIXME: local keyboard moves not working */
1314 break;
1315
1316 case RAIL_WMSZ_KEYSIZE:
1317 direction = NET_WM_MOVERESIZE_SIZE_KEYBOARD;
1318 x = localMoveSize->posX;
1319 y = localMoveSize->posY;
1320 /* FIXME: local keyboard moves not working */
1321 break;
1322 default:
1323 break;
1324 }
1325
1326 if (localMoveSize->isMoveSizeStart)
1327 xf_StartLocalMoveSize(xfc, appWindow, direction, x, y);
1328 else
1329 xf_EndLocalMoveSize(xfc, appWindow);
1330
1331 xf_rail_return_window(appWindow, FALSE);
1332 return CHANNEL_RC_OK;
1333}
1334
1340WINPR_ATTR_NODISCARD
1341static UINT xf_rail_server_min_max_info(RailClientContext* context,
1342 const RAIL_MINMAXINFO_ORDER* minMaxInfo)
1343{
1344 WINPR_ASSERT(context);
1345 WINPR_ASSERT(minMaxInfo);
1346
1347 xfContext* xfc = (xfContext*)context->custom;
1348 xfAppWindow* appWindow = xf_rail_get_window(xfc, minMaxInfo->windowId, FALSE);
1349
1350 if (appWindow)
1351 {
1352 xf_SetWindowMinMaxInfo(xfc, appWindow, minMaxInfo->maxWidth, minMaxInfo->maxHeight,
1353 minMaxInfo->maxPosX, minMaxInfo->maxPosY, minMaxInfo->minTrackWidth,
1354 minMaxInfo->minTrackHeight, minMaxInfo->maxTrackWidth,
1355 minMaxInfo->maxTrackHeight);
1356 }
1357 xf_rail_return_window(appWindow, FALSE);
1358
1359 return CHANNEL_RC_OK;
1360}
1361
1367WINPR_ATTR_NODISCARD
1368static UINT
1369xf_rail_server_language_bar_info(WINPR_ATTR_UNUSED RailClientContext* context,
1370 WINPR_ATTR_UNUSED const RAIL_LANGBAR_INFO_ORDER* langBarInfo)
1371{
1372 WINPR_ASSERT(context);
1373
1374 xfContext* xfc = (xfContext*)context->custom;
1375 WINPR_ASSERT(xfc);
1376
1377 WLog_Print(xfc->log, WLOG_ERROR, "TODO: implement");
1378 return CHANNEL_RC_OK;
1379}
1380
1386WINPR_ATTR_NODISCARD
1387static UINT
1388xf_rail_server_get_appid_response(WINPR_ATTR_UNUSED RailClientContext* context,
1389 WINPR_ATTR_UNUSED const RAIL_GET_APPID_RESP_ORDER* getAppIdResp)
1390{
1391 WINPR_ASSERT(context);
1392
1393 xfContext* xfc = (xfContext*)context->custom;
1394 WINPR_ASSERT(xfc);
1395
1396 WLog_Print(xfc->log, WLOG_ERROR, "TODO: implement");
1397 return CHANNEL_RC_OK;
1398}
1399
1400WINPR_ATTR_NODISCARD
1401static BOOL rail_window_key_equals(const void* key1, const void* key2)
1402{
1403 const UINT64* k1 = (const UINT64*)key1;
1404 const UINT64* k2 = (const UINT64*)key2;
1405
1406 if (!k1 || !k2)
1407 return FALSE;
1408
1409 return *k1 == *k2;
1410}
1411
1412WINPR_ATTR_NODISCARD
1413static UINT32 rail_window_key_hash(const void* key)
1414{
1415 const UINT64* k1 = (const UINT64*)key;
1416 return (UINT32)*k1;
1417}
1418
1419static void rail_window_free(void* value)
1420{
1421 xfAppWindow* appWindow = (xfAppWindow*)value;
1422
1423 if (!appWindow)
1424 return;
1425
1426 xf_DestroyWindow(appWindow->xfc, appWindow);
1427}
1428
1429int xf_rail_init(xfContext* xfc, RailClientContext* rail)
1430{
1431 rdpContext* context = (rdpContext*)xfc;
1432
1433 if (!xfc || !rail)
1434 return 0;
1435
1436 xfc->rail = rail;
1437 xf_rail_register_update_callbacks(context->update);
1438 rail->custom = (void*)xfc;
1439 rail->ServerExecuteResult = xf_rail_server_execute_result;
1440 rail->ServerSystemParam = xf_rail_server_system_param;
1441 rail->ServerLocalMoveSize = xf_rail_server_local_move_size;
1442 rail->ServerMinMaxInfo = xf_rail_server_min_max_info;
1443 rail->ServerLanguageBarInfo = xf_rail_server_language_bar_info;
1444 rail->ServerGetAppIdResponse = xf_rail_server_get_appid_response;
1445 xfc->railWindows = HashTable_New(TRUE);
1446
1447 if (!xfc->railWindows)
1448 return 0;
1449
1450 if (!HashTable_SetHashFunction(xfc->railWindows, rail_window_key_hash))
1451 goto fail;
1452 {
1453 wObject* obj = HashTable_KeyObject(xfc->railWindows);
1454 obj->fnObjectEquals = rail_window_key_equals;
1455 }
1456 {
1457 wObject* obj = HashTable_ValueObject(xfc->railWindows);
1458 obj->fnObjectFree = rail_window_free;
1459 }
1460 xfc->railIconCache = RailIconCache_New(xfc->log, xfc->common.context.settings);
1461
1462 if (!xfc->railIconCache)
1463 {
1464 }
1465
1466 return 1;
1467fail:
1468 HashTable_Free(xfc->railWindows);
1469 return 0;
1470}
1471
1472int xf_rail_uninit(xfContext* xfc, RailClientContext* rail)
1473{
1474 WINPR_UNUSED(rail);
1475
1476 if (xfc->rail)
1477 {
1478 xfc->rail->custom = nullptr;
1479 xfc->rail = nullptr;
1480 }
1481
1482 if (xfc->railWindows)
1483 {
1484 HashTable_Free(xfc->railWindows);
1485 xfc->railWindows = nullptr;
1486 }
1487
1488 if (xfc->railIconCache)
1489 {
1490 RailIconCache_Free(xfc->railIconCache);
1491 xfc->railIconCache = nullptr;
1492 }
1493
1494 return 1;
1495}
1496
1497xfAppWindow* xf_rail_add_window(xfContext* xfc, UINT64 id, INT32 x, INT32 y, UINT32 width,
1498 UINT32 height, UINT32 surfaceId)
1499{
1500 if (!xfc)
1501 return nullptr;
1502
1503 xfAppWindow* appWindow = (xfAppWindow*)calloc(1, sizeof(xfAppWindow));
1504
1505 if (!appWindow)
1506 return nullptr;
1507
1508 appWindow->xfc = xfc;
1509 appWindow->windowId = id;
1510 appWindow->surfaceId = surfaceId;
1511 appWindow->x = x;
1512 appWindow->y = y;
1513 appWindow->width = WINPR_ASSERTING_INT_CAST(int, width);
1514 appWindow->height = WINPR_ASSERTING_INT_CAST(int, height);
1515
1516 xf_AppWindowsLock(xfc);
1517 if (!xf_AppWindowCreate(xfc, appWindow))
1518 goto fail;
1519
1520 if (!HashTable_Insert(xfc->railWindows, &appWindow->windowId, (void*)appWindow))
1521 goto fail;
1522 return appWindow;
1523fail:
1524 rail_window_free(appWindow);
1525 xf_AppWindowsUnlock(xfc);
1526 return nullptr;
1527}
1528
1529BOOL xf_rail_del_window(xfContext* xfc, UINT64 id)
1530{
1531 if (!xfc)
1532 return FALSE;
1533
1534 if (!xfc->railWindows)
1535 return FALSE;
1536
1537 xf_lock_x11(xfc);
1538 const BOOL res = HashTable_Remove(xfc->railWindows, &id);
1539 xf_unlock_x11(xfc);
1540 return res;
1541}
1542
1543void xf_rail_return_windowFrom(xfAppWindow* window, BOOL alreadyLocked, const char* file,
1544 const char* fkt, size_t line)
1545{
1546 if (!window)
1547 return;
1548
1549 if (alreadyLocked)
1550 return;
1551
1552 xfAppWindowsUnlockFrom(window->xfc, file, fkt, line);
1553}
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
ICON_INFO
Definition include/freerdp/window.h:166
MONITORED_DESKTOP_ORDER
Definition include/freerdp/window.h:251
NOTIFY_ICON_STATE_ORDER
Definition include/freerdp/window.h:241
RAIL_ACTIVATE_ORDER
Definition rail.h:415
RAIL_EXEC_RESULT_ORDER
Definition rail.h:378
RAIL_GET_APPID_RESP_ORDER
Definition rail.h:477
RAIL_LANGBAR_INFO_ORDER
Definition rail.h:483
RAIL_LOCALMOVESIZE_ORDER
Definition rail.h:454
RAIL_MINMAXINFO_ORDER
Definition rail.h:441
RAIL_SYSCOMMAND_ORDER
Definition rail.h:428
RAIL_SYSPARAM_ORDER
Definition rail.h:395
RAIL_WINDOW_MOVE_ORDER
Definition rail.h:463
RECTANGLE_16
Definition types.h:109
WINDOW_CACHED_ICON_ORDER
Definition include/freerdp/window.h:236
WINDOW_ICON_ORDER
Definition include/freerdp/window.h:231
WINDOW_ORDER_INFO
Definition include/freerdp/window.h:159
WINDOW_STATE_ORDER
Definition include/freerdp/window.h:195
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectEquals
WINPR_ATTR_NODISCARD OBJECT_EQUALS_FN fnObjectEquals
Definition collections.h:61