FreeRDP
Loading...
Searching...
No Matches
wlfreerdp.c
1
22#include <math.h>
23#include <stdio.h>
24#include <errno.h>
25#include <locale.h>
26#include <float.h>
27
28#include <winpr/sysinfo.h>
29#include <winpr/cast.h>
30
31#include <freerdp/client/cmdline.h>
32#include <freerdp/channels/channels.h>
33#include <freerdp/gdi/gdi.h>
34#include <freerdp/client.h>
35#include <freerdp/utils/signal.h>
36#include <freerdp/locale/keyboard.h>
37
38#include <linux/input.h>
39
40#include <uwac/uwac.h>
41
42#include "wlfreerdp.h"
43#include "wlf_input.h"
44#include "wlf_cliprdr.h"
45#include "wlf_disp.h"
46#include "wlf_channels.h"
47#include "wlf_pointer.h"
48
49#define TAG CLIENT_TAG("wayland")
50
51static BOOL wl_update_buffer(wlfContext* context_w, INT32 ix, INT32 iy, INT32 iw, INT32 ih)
52{
53 BOOL res = FALSE;
54 rdpGdi* gdi = NULL;
55 char* data = NULL;
56 UwacSize geometry = { 0 };
57 size_t stride = 0;
58 UwacReturnCode rc = UWAC_ERROR_INTERNAL;
59 RECTANGLE_16 area = { 0 };
60
61 if (!context_w)
62 return FALSE;
63
64 if ((ix < 0) || (iy < 0) || (iw < 0) || (ih < 0))
65 return FALSE;
66
67 EnterCriticalSection(&context_w->critical);
68 UINT32 x = WINPR_ASSERTING_INT_CAST(UINT16, ix);
69 UINT32 y = WINPR_ASSERTING_INT_CAST(UINT16, iy);
70 UINT32 w = WINPR_ASSERTING_INT_CAST(UINT16, iw);
71 UINT32 h = WINPR_ASSERTING_INT_CAST(UINT16, ih);
72 rc = UwacWindowGetDrawingBufferGeometry(context_w->window, &geometry, &stride);
73 data = UwacWindowGetDrawingBuffer(context_w->window);
74
75 if (!data || (rc != UWAC_SUCCESS))
76 goto fail;
77
78 gdi = context_w->common.context.gdi;
79
80 if (!gdi)
81 goto fail;
82
83 /* Ignore output if the surface size does not match. */
84 if (((INT64)x > geometry.width) || ((INT64)y > geometry.height))
85 {
86 res = TRUE;
87 goto fail;
88 }
89
90 area.left = WINPR_ASSERTING_INT_CAST(UINT16, x);
91 area.top = WINPR_ASSERTING_INT_CAST(UINT16, y);
92 area.right = WINPR_ASSERTING_INT_CAST(UINT16, x + w);
93 area.bottom = WINPR_ASSERTING_INT_CAST(UINT16, y + h);
94
95 if (!wlf_copy_image(
96 gdi->primary_buffer, gdi->stride, WINPR_ASSERTING_INT_CAST(size_t, gdi->width),
97 WINPR_ASSERTING_INT_CAST(size_t, gdi->height), data, stride,
98 WINPR_ASSERTING_INT_CAST(size_t, geometry.width),
99 WINPR_ASSERTING_INT_CAST(size_t, geometry.height), &area,
100 freerdp_settings_get_bool(context_w->common.context.settings, FreeRDP_SmartSizing)))
101 goto fail;
102
103 if (!wlf_scale_coordinates(&context_w->common.context, &x, &y, FALSE))
104 goto fail;
105
106 if (!wlf_scale_coordinates(&context_w->common.context, &w, &h, FALSE))
107 goto fail;
108
109 if (UwacWindowAddDamage(context_w->window, x, y, w, h) != UWAC_SUCCESS)
110 goto fail;
111
112 if (UwacWindowSubmitBuffer(context_w->window, false) != UWAC_SUCCESS)
113 goto fail;
114
115 res = TRUE;
116fail:
117 LeaveCriticalSection(&context_w->critical);
118 return res;
119}
120
121static BOOL wl_end_paint(rdpContext* context)
122{
123 rdpGdi* gdi = NULL;
124 wlfContext* context_w = NULL;
125 INT32 x = 0;
126 INT32 y = 0;
127 INT32 w = 0;
128 INT32 h = 0;
129
130 if (!context || !context->gdi || !context->gdi->primary)
131 return FALSE;
132
133 gdi = context->gdi;
134
135 if (gdi->primary->hdc->hwnd->invalid->null)
136 return TRUE;
137
138 x = gdi->primary->hdc->hwnd->invalid->x;
139 y = gdi->primary->hdc->hwnd->invalid->y;
140 w = gdi->primary->hdc->hwnd->invalid->w;
141 h = gdi->primary->hdc->hwnd->invalid->h;
142 context_w = (wlfContext*)context;
143 if (!wl_update_buffer(context_w, x, y, w, h))
144 {
145 return FALSE;
146 }
147
148 gdi->primary->hdc->hwnd->invalid->null = TRUE;
149 gdi->primary->hdc->hwnd->ninvalid = 0;
150 return TRUE;
151}
152
153static BOOL wl_refresh_display(wlfContext* context)
154{
155 rdpGdi* gdi = NULL;
156
157 if (!context || !context->common.context.gdi)
158 return FALSE;
159
160 gdi = context->common.context.gdi;
161 return wl_update_buffer(context, 0, 0, gdi->width, gdi->height);
162}
163
164static BOOL wl_resize_display(rdpContext* context)
165{
166 wlfContext* wlc = (wlfContext*)context;
167 rdpGdi* gdi = context->gdi;
168 rdpSettings* settings = context->settings;
169
170 if (!gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
171 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
172 return FALSE;
173
174 return wl_refresh_display(wlc);
175}
176
177static BOOL wl_pre_connect(freerdp* instance)
178{
179 rdpSettings* settings = NULL;
180 wlfContext* context = NULL;
181 const UwacOutput* output = NULL;
182 UwacSize resolution;
183
184 if (!instance)
185 return FALSE;
186
187 context = (wlfContext*)instance->context;
188 WINPR_ASSERT(context);
189
190 settings = instance->context->settings;
191 WINPR_ASSERT(settings);
192
193 if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
194 return FALSE;
195
196 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
197 return FALSE;
198 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_WAYLAND))
199 return FALSE;
200 PubSub_SubscribeChannelConnected(instance->context->pubSub, wlf_OnChannelConnectedEventHandler);
201 PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
202 wlf_OnChannelDisconnectedEventHandler);
203
204 if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
205 {
206 // Use the resolution of the first display output
207 output = UwacDisplayGetOutput(context->display, 0);
208
209 if ((output != NULL) && (UwacOutputGetResolution(output, &resolution) == UWAC_SUCCESS))
210 {
211 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
212 (UINT32)resolution.width))
213 return FALSE;
214 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
215 (UINT32)resolution.height))
216 return FALSE;
217 }
218 else
219 {
220 WLog_WARN(TAG, "Failed to get output resolution! Check your display settings");
221 }
222 }
223
224 return TRUE;
225}
226
227static BOOL wl_post_connect(freerdp* instance)
228{
229 if (!instance || !instance->context)
230 return FALSE;
231
232 wlfContext* context = (wlfContext*)instance->context;
233 WINPR_ASSERT(context);
234
235 rdpSettings* settings = instance->context->settings;
236 WINPR_ASSERT(settings);
237
238 const char* title = "FreeRDP";
239 const char* wtitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
240 if (wtitle)
241 title = wtitle;
242
243 const char* app_id = "wlfreerdp";
244 const char* wmclass = freerdp_settings_get_string(settings, FreeRDP_WmClass);
245 if (wmclass)
246 app_id = wmclass;
247
248 if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
249 return FALSE;
250
251 rdpGdi* gdi = instance->context->gdi;
252
253 if (!gdi || (gdi->width < 0) || (gdi->height < 0))
254 return FALSE;
255
256 if (!wlf_register_pointer(instance->context->graphics))
257 return FALSE;
258
259 UINT32 w = (UINT32)gdi->width;
260 UINT32 h = (UINT32)gdi->height;
261
262 if (freerdp_settings_get_bool(settings, FreeRDP_SmartSizing) && !context->fullscreen)
263 {
264 const UINT32 sw = freerdp_settings_get_uint32(settings, FreeRDP_SmartSizingWidth);
265 if (sw > 0)
266 w = sw;
267
268 const UINT32 sh = freerdp_settings_get_uint32(settings, FreeRDP_SmartSizingHeight);
269 if (sh > 0)
270 h = sh;
271 }
272
273 context->window = UwacCreateWindowShm(context->display, w, h, WL_SHM_FORMAT_XRGB8888);
274
275 if (!context->window)
276 return FALSE;
277
278 UwacWindowSetFullscreenState(
279 context->window, NULL,
280 freerdp_settings_get_bool(instance->context->settings, FreeRDP_Fullscreen));
281 UwacWindowSetTitle(context->window, title);
282 UwacWindowSetAppId(context->window, app_id);
283 UwacWindowSetOpaqueRegion(context->window, 0, 0, w, h);
284 instance->context->update->EndPaint = wl_end_paint;
285 instance->context->update->DesktopResize = wl_resize_display;
286 const char* KeyboardRemappingList =
287 freerdp_settings_get_string(instance->context->settings, FreeRDP_KeyboardRemappingList);
288
289 context->remap_table = freerdp_keyboard_remap_string_to_list(KeyboardRemappingList);
290 if (!context->remap_table)
291 return FALSE;
292
293 if (!(context->disp = wlf_disp_new(context)))
294 return FALSE;
295
296 context->clipboard = wlf_clipboard_new(context);
297
298 if (!context->clipboard)
299 return FALSE;
300
301 return wl_refresh_display(context);
302}
303
304static void wl_post_disconnect(freerdp* instance)
305{
306 if (!instance)
307 return;
308
309 if (!instance->context)
310 return;
311
312 wlfContext* context = (wlfContext*)instance->context;
313 gdi_free(instance);
314 wlf_clipboard_free(context->clipboard);
315 wlf_disp_free(context->disp);
316
317 if (context->window)
318 UwacDestroyWindow(&context->window);
319 freerdp_keyboard_remap_free(context->remap_table);
320 context->remap_table = NULL;
321}
322
323static BOOL handle_uwac_events(freerdp* instance, UwacDisplay* display)
324{
325 UwacEvent event;
326 wlfContext* context = NULL;
327
328 if (UwacDisplayDispatch(display, 1) < 0)
329 return FALSE;
330
331 context = (wlfContext*)instance->context;
332
333 while (UwacHasEvent(display))
334 {
335 if (UwacNextEvent(display, &event) != UWAC_SUCCESS)
336 return FALSE;
337
338 /*printf("UWAC event type %d\n", event.type);*/
339 switch (event.type)
340 {
341 case UWAC_EVENT_NEW_SEAT:
342 context->seat = event.seat_new.seat;
343 break;
344
345 case UWAC_EVENT_REMOVED_SEAT:
346 context->seat = NULL;
347 break;
348
349 case UWAC_EVENT_FRAME_DONE:
350 {
351 EnterCriticalSection(&context->critical);
352 UwacReturnCode r = UwacWindowSubmitBuffer(context->window, false);
353 LeaveCriticalSection(&context->critical);
354 if (r != UWAC_SUCCESS)
355 return FALSE;
356 }
357 break;
358
359 case UWAC_EVENT_POINTER_ENTER:
360 if (!wlf_handle_pointer_enter(instance, &event.mouse_enter_leave))
361 return FALSE;
362
363 break;
364
365 case UWAC_EVENT_POINTER_MOTION:
366 if (!wlf_handle_pointer_motion(instance, &event.mouse_motion))
367 return FALSE;
368
369 break;
370
371 case UWAC_EVENT_POINTER_BUTTONS:
372 if (!wlf_handle_pointer_buttons(instance, &event.mouse_button))
373 return FALSE;
374
375 break;
376
377 case UWAC_EVENT_POINTER_AXIS:
378 if (!wlf_handle_pointer_axis(instance, &event.mouse_axis))
379 return FALSE;
380 break;
381
382 case UWAC_EVENT_POINTER_AXIS_DISCRETE:
383 if (!wlf_handle_pointer_axis_discrete(instance, &event.mouse_axis))
384 return FALSE;
385 break;
386
387 case UWAC_EVENT_POINTER_FRAME:
388 if (!wlf_handle_pointer_frame(instance, &event.mouse_frame))
389 return FALSE;
390 break;
391 case UWAC_EVENT_POINTER_SOURCE:
392 if (!wlf_handle_pointer_source(instance, &event.mouse_source))
393 return FALSE;
394 break;
395
396 case UWAC_EVENT_KEY:
397 if (!wlf_handle_key(instance, &event.key))
398 return FALSE;
399
400 break;
401
402 case UWAC_EVENT_TOUCH_UP:
403 if (!wlf_handle_touch_up(instance, &event.touchUp))
404 return FALSE;
405
406 break;
407
408 case UWAC_EVENT_TOUCH_DOWN:
409 if (!wlf_handle_touch_down(instance, &event.touchDown))
410 return FALSE;
411
412 break;
413
414 case UWAC_EVENT_TOUCH_MOTION:
415 if (!wlf_handle_touch_motion(instance, &event.touchMotion))
416 return FALSE;
417
418 break;
419
420 case UWAC_EVENT_KEYBOARD_ENTER:
421 if (freerdp_settings_get_bool(instance->context->settings, FreeRDP_GrabKeyboard))
422 UwacSeatInhibitShortcuts(event.keyboard_enter_leave.seat, true);
423
424 if (!wlf_keyboard_enter(instance, &event.keyboard_enter_leave))
425 return FALSE;
426
427 break;
428
429 case UWAC_EVENT_KEYBOARD_MODIFIERS:
430 if (!wlf_keyboard_modifiers(instance, &event.keyboard_modifiers))
431 return FALSE;
432
433 break;
434
435 case UWAC_EVENT_CONFIGURE:
436 if (!wlf_disp_handle_configure(context->disp, event.configure.width,
437 event.configure.height))
438 return FALSE;
439
440 if (!wl_refresh_display(context))
441 return FALSE;
442
443 break;
444
445 case UWAC_EVENT_CLIPBOARD_AVAILABLE:
446 case UWAC_EVENT_CLIPBOARD_OFFER:
447 case UWAC_EVENT_CLIPBOARD_SELECT:
448 if (!wlf_cliprdr_handle_event(context->clipboard, &event.clipboard))
449 return FALSE;
450
451 break;
452
453 case UWAC_EVENT_CLOSE:
454 context->closed = TRUE;
455
456 break;
457
458 default:
459 break;
460 }
461 }
462
463 return TRUE;
464}
465
466static BOOL handle_window_events(freerdp* instance)
467{
468 if (!instance)
469 return FALSE;
470
471 return TRUE;
472}
473
474static int wlfreerdp_run(freerdp* instance)
475{
476 wlfContext* context = NULL;
477 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = { 0 };
478 DWORD status = WAIT_ABANDONED;
479
480 if (!instance)
481 return -1;
482
483 context = (wlfContext*)instance->context;
484
485 if (!context)
486 return -1;
487
488 if (!freerdp_connect(instance))
489 {
490 WLog_Print(context->log, WLOG_ERROR, "Failed to connect");
491 return -1;
492 }
493
494 while (!freerdp_shall_disconnect_context(instance->context))
495 {
496 DWORD count = 0;
497 handles[count++] = context->displayHandle;
498 count += freerdp_get_event_handles(instance->context, &handles[count],
499 ARRAYSIZE(handles) - count);
500
501 if (count <= 2)
502 {
503 WLog_Print(context->log, WLOG_ERROR, "Failed to get FreeRDP file descriptor");
504 break;
505 }
506
507 status = WaitForMultipleObjects(count, handles, FALSE, INFINITE);
508
509 if (WAIT_FAILED == status)
510 {
511 WLog_Print(context->log, WLOG_ERROR, "WaitForMultipleObjects failed");
512 break;
513 }
514
515 if (!handle_uwac_events(instance, context->display))
516 {
517 WLog_Print(context->log, WLOG_ERROR, "error handling UWAC events");
518 break;
519 }
520
521 if (context->closed)
522 {
523 WLog_Print(context->log, WLOG_INFO, "Closed from Wayland");
524 break;
525 }
526
527 if (freerdp_check_event_handles(instance->context) != TRUE)
528 {
529 if (client_auto_reconnect_ex(instance, handle_window_events))
530 continue;
531 else
532 {
533 /*
534 * Indicate an unsuccessful connection attempt if reconnect
535 * did not succeed and no other error was specified.
536 */
537 if (freerdp_error_info(instance) == 0)
538 status = 42;
539 }
540
541 if (freerdp_get_last_error(instance->context) == FREERDP_ERROR_SUCCESS)
542 WLog_Print(context->log, WLOG_ERROR, "Failed to check FreeRDP file descriptor");
543
544 break;
545 }
546 }
547
548 freerdp_disconnect(instance);
549 return WINPR_ASSERTING_INT_CAST(int, status);
550}
551
552static BOOL wlf_client_global_init(void)
553{
554 // NOLINTNEXTLINE(concurrency-mt-unsafe)
555 (void)setlocale(LC_ALL, "");
556
557 if (freerdp_handle_signals() != 0)
558 return FALSE;
559
560 return TRUE;
561}
562
563static void wlf_client_global_uninit(void)
564{
565}
566
567static int wlf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
568{
569 wlfContext* wlf = NULL;
570 const char* str_data = freerdp_get_logon_error_info_data(data);
571 const char* str_type = freerdp_get_logon_error_info_type(type);
572
573 if (!instance || !instance->context)
574 return -1;
575
576 wlf = (wlfContext*)instance->context;
577 WLog_Print(wlf->log, WLOG_INFO, "Logon Error Info %s [%s]", str_data, str_type);
578 return 1;
579}
580
581static void wlf_client_free(freerdp* instance, rdpContext* context)
582{
583 wlfContext* wlf = (wlfContext*)instance->context;
584
585 if (!context)
586 return;
587
588 if (wlf->display)
589 UwacCloseDisplay(&wlf->display);
590
591 if (wlf->displayHandle)
592 (void)CloseHandle(wlf->displayHandle);
593 ArrayList_Free(wlf->events);
594 DeleteCriticalSection(&wlf->critical);
595}
596
597static void* uwac_event_clone(const void* val)
598{
599 UwacEvent* copy = NULL;
600 const UwacEvent* ev = (const UwacEvent*)val;
601
602 copy = calloc(1, sizeof(UwacEvent));
603 if (!copy)
604 return NULL;
605 *copy = *ev;
606 return copy;
607}
608
609static BOOL wlf_client_new(freerdp* instance, rdpContext* context)
610{
611 wObject* obj = NULL;
612 UwacReturnCode status = UWAC_ERROR_INTERNAL;
613 wlfContext* wfl = (wlfContext*)context;
614
615 if (!instance || !context)
616 return FALSE;
617
618 instance->PreConnect = wl_pre_connect;
619 instance->PostConnect = wl_post_connect;
620 instance->PostDisconnect = wl_post_disconnect;
621 instance->LogonErrorInfo = wlf_logon_error_info;
622 wfl->log = WLog_Get(TAG);
623 wfl->display = UwacOpenDisplay(NULL, &status);
624
625 if (!wfl->display || (status != UWAC_SUCCESS) || !wfl->log)
626 return FALSE;
627
628 wfl->displayHandle = CreateFileDescriptorEvent(NULL, FALSE, FALSE,
629 UwacDisplayGetFd(wfl->display), WINPR_FD_READ);
630
631 if (!wfl->displayHandle)
632 return FALSE;
633
634 wfl->events = ArrayList_New(FALSE);
635 if (!wfl->events)
636 return FALSE;
637
638 obj = ArrayList_Object(wfl->events);
639 obj->fnObjectNew = uwac_event_clone;
640 obj->fnObjectFree = free;
641
642 InitializeCriticalSection(&wfl->critical);
643
644 return TRUE;
645}
646
647static int wfl_client_start(rdpContext* context)
648{
649 WINPR_UNUSED(context);
650 return 0;
651}
652
653static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
654{
655 WINPR_ASSERT(pEntryPoints);
656 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
657 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
658 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
659 pEntryPoints->GlobalInit = wlf_client_global_init;
660 pEntryPoints->GlobalUninit = wlf_client_global_uninit;
661 pEntryPoints->ContextSize = sizeof(wlfContext);
662 pEntryPoints->ClientNew = wlf_client_new;
663 pEntryPoints->ClientFree = wlf_client_free;
664 pEntryPoints->ClientStart = wfl_client_start;
665 pEntryPoints->ClientStop = freerdp_client_common_stop;
666 return 0;
667}
668
669int main(int argc, char* argv[])
670{
671 int rc = -1;
672 int status = 0;
673 RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
674 rdpContext* context = NULL;
675 rdpSettings* settings = NULL;
676 wlfContext* wlc = NULL;
677
678 freerdp_client_warn_deprecated(argc, argv);
679
680 RdpClientEntry(&clientEntryPoints);
681 context = freerdp_client_context_new(&clientEntryPoints);
682 if (!context)
683 goto fail;
684 wlc = (wlfContext*)context;
685 settings = context->settings;
686
687 status = freerdp_client_settings_parse_command_line(settings, argc, argv, FALSE);
688 if (status)
689 {
690 rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
691
692 if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
693 wlf_list_monitors(wlc);
694
695 goto fail;
696 }
697
698 if (freerdp_client_start(context) != 0)
699 goto fail;
700
701 rc = wlfreerdp_run(context->instance);
702
703 if (freerdp_client_stop(context) != 0)
704 rc = -1;
705
706fail:
707 freerdp_client_context_free(context);
708 return rc;
709}
710
711BOOL wlf_copy_image(const void* src, size_t srcStride, size_t srcWidth, size_t srcHeight, void* dst,
712 size_t dstStride, size_t dstWidth, size_t dstHeight, const RECTANGLE_16* area,
713 BOOL scale)
714{
715 BOOL rc = FALSE;
716
717 if (!src || !dst || !area)
718 return FALSE;
719
720 if (scale)
721 {
722 WINPR_ASSERT(dstStride <= UINT32_MAX);
723 WINPR_ASSERT(dstWidth <= UINT32_MAX);
724 WINPR_ASSERT(dstHeight <= UINT32_MAX);
725 WINPR_ASSERT(srcStride <= UINT32_MAX);
726 WINPR_ASSERT(srcWidth <= UINT32_MAX);
727 WINPR_ASSERT(srcHeight <= UINT32_MAX);
728 return freerdp_image_scale(dst, PIXEL_FORMAT_BGRA32, (UINT32)dstStride, 0, 0,
729 (UINT32)dstWidth, (UINT32)dstHeight, src, PIXEL_FORMAT_BGRA32,
730 (UINT32)srcStride, 0, 0, (UINT32)srcWidth, (UINT32)srcHeight);
731 }
732 else
733 {
734 const size_t baseSrcOffset = 1ULL * area->top * srcStride + 4ULL * area->left;
735 const size_t baseDstOffset = 1ULL * area->top * dstStride + 4ULL * area->left;
736 const size_t width = MIN((size_t)area->right - area->left, dstWidth - area->left);
737 const size_t height = MIN((size_t)area->bottom - area->top, dstHeight - area->top);
738 const BYTE* psrc = (const BYTE*)src;
739 BYTE* pdst = (BYTE*)dst;
740
741 for (size_t i = 0; i < height; i++)
742 {
743 const size_t srcOffset = i * srcStride + baseSrcOffset;
744 const size_t dstOffset = i * dstStride + baseDstOffset;
745 memcpy(&pdst[dstOffset], &psrc[srcOffset], width * 4);
746 }
747
748 rc = TRUE;
749 }
750
751 return rc;
752}
753
754BOOL wlf_scale_coordinates(rdpContext* context, UINT32* px, UINT32* py, BOOL fromLocalToRDP)
755{
756 wlfContext* wlf = (wlfContext*)context;
757 UwacSize geometry = { 0 };
758
759 if (!context || !px || !py || !context->gdi)
760 return FALSE;
761
762 if (!freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing))
763 return TRUE;
764
765 rdpGdi* gdi = context->gdi;
766
767 if (UwacWindowGetDrawingBufferGeometry(wlf->window, &geometry, NULL) != UWAC_SUCCESS)
768 return FALSE;
769
770 const double sx = 1.0 * geometry.width / (double)gdi->width;
771 const double sy = 1.0 * geometry.height / (double)gdi->height;
772
773 if (!fromLocalToRDP)
774 {
775 *px *= (UINT32)lround(sx);
776 *py *= (UINT32)lround(sy);
777 }
778 else
779 {
780 *px /= (UINT32)lround(sx);
781 *py /= (UINT32)lround(sy);
782 }
783
784 return TRUE;
785}
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_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
freerdp_settings_get_string
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.
RECTANGLE_16
Definition types.h:109
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:57