FreeRDP
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Modules Pages
message.c
1
22#include <freerdp/config.h>
23
24#include <winpr/assert.h>
25
26#include "rdp.h"
27#include "message.h"
28#include "transport.h"
29
30#include <freerdp/log.h>
31#include <freerdp/freerdp.h>
32
33#include <winpr/crt.h>
34#include <winpr/stream.h>
35#include <winpr/collections.h>
36
37#include "../cache/pointer.h"
38#include "../cache/bitmap.h"
39#include "../cache/palette.h"
40#include "../cache/glyph.h"
41#include "../cache/brush.h"
42#include "../cache/cache.h"
43
44#define TAG FREERDP_TAG("core.message")
45
46/* Update */
47
48static BOOL update_message_BeginPaint(rdpContext* context)
49{
50 rdp_update_internal* up = NULL;
51
52 if (!context || !context->update)
53 return FALSE;
54
55 up = update_cast(context->update);
56 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, BeginPaint), NULL,
57 NULL);
58}
59
60static BOOL update_message_EndPaint(rdpContext* context)
61{
62 rdp_update_internal* up = NULL;
63
64 if (!context || !context->update)
65 return FALSE;
66
67 up = update_cast(context->update);
68 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, EndPaint), NULL,
69 NULL);
70}
71
72static BOOL update_message_SetBounds(rdpContext* context, const rdpBounds* bounds)
73{
74 rdpBounds* wParam = NULL;
75 rdp_update_internal* up = NULL;
76
77 if (!context || !context->update)
78 return FALSE;
79
80 if (bounds)
81 {
82 wParam = (rdpBounds*)malloc(sizeof(rdpBounds));
83
84 if (!wParam)
85 return FALSE;
86
87 CopyMemory(wParam, bounds, sizeof(rdpBounds));
88 }
89
90 up = update_cast(context->update);
91 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SetBounds),
92 (void*)wParam, NULL);
93}
94
95static BOOL update_message_Synchronize(rdpContext* context)
96{
97 rdp_update_internal* up = NULL;
98
99 if (!context || !context->update)
100 return FALSE;
101
102 up = update_cast(context->update);
103 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, Synchronize), NULL,
104 NULL);
105}
106
107static BOOL update_message_DesktopResize(rdpContext* context)
108{
109 rdp_update_internal* up = NULL;
110
111 if (!context || !context->update)
112 return FALSE;
113
114 up = update_cast(context->update);
115 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, DesktopResize), NULL,
116 NULL);
117}
118
119static BOOL update_message_BitmapUpdate(rdpContext* context, const BITMAP_UPDATE* bitmap)
120{
121 BITMAP_UPDATE* wParam = NULL;
122 rdp_update_internal* up = NULL;
123
124 if (!context || !context->update || !bitmap)
125 return FALSE;
126
127 wParam = copy_bitmap_update(context, bitmap);
128
129 if (!wParam)
130 return FALSE;
131
132 up = update_cast(context->update);
133 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, BitmapUpdate),
134 (void*)wParam, NULL);
135}
136
137static BOOL update_message_Palette(rdpContext* context, const PALETTE_UPDATE* palette)
138{
139 PALETTE_UPDATE* wParam = NULL;
140 rdp_update_internal* up = NULL;
141
142 if (!context || !context->update || !palette)
143 return FALSE;
144
145 wParam = copy_palette_update(context, palette);
146
147 if (!wParam)
148 return FALSE;
149
150 up = update_cast(context->update);
151 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, Palette),
152 (void*)wParam, NULL);
153}
154
155static BOOL update_message_PlaySound(rdpContext* context, const PLAY_SOUND_UPDATE* playSound)
156{
157 PLAY_SOUND_UPDATE* wParam = NULL;
158 rdp_update_internal* up = NULL;
159
160 if (!context || !context->update || !playSound)
161 return FALSE;
162
163 wParam = (PLAY_SOUND_UPDATE*)malloc(sizeof(PLAY_SOUND_UPDATE));
164
165 if (!wParam)
166 return FALSE;
167
168 CopyMemory(wParam, playSound, sizeof(PLAY_SOUND_UPDATE));
169
170 up = update_cast(context->update);
171 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, PlaySound),
172 (void*)wParam, NULL);
173}
174
175static BOOL update_message_SetKeyboardIndicators(rdpContext* context, UINT16 led_flags)
176{
177 rdp_update_internal* up = NULL;
178
179 if (!context || !context->update)
180 return FALSE;
181
182 up = update_cast(context->update);
183 return MessageQueue_Post(up->queue, (void*)context,
184 MakeMessageId(Update, SetKeyboardIndicators), (void*)(size_t)led_flags,
185 NULL);
186}
187
188static BOOL update_message_SetKeyboardImeStatus(rdpContext* context, UINT16 imeId, UINT32 imeState,
189 UINT32 imeConvMode)
190{
191 rdp_update_internal* up = NULL;
192
193 if (!context || !context->update)
194 return FALSE;
195
196 up = update_cast(context->update);
197 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SetKeyboardImeStatus),
198 (void*)(size_t)((((UINT32)imeId << 16UL) & 0xFFFF0000) | imeState),
199 (void*)(size_t)imeConvMode);
200}
201
202static BOOL update_message_RefreshRect(rdpContext* context, BYTE count, const RECTANGLE_16* areas)
203{
204 RECTANGLE_16* lParam = NULL;
205 rdp_update_internal* up = NULL;
206
207 if (!context || !context->update || !areas)
208 return FALSE;
209
210 lParam = (RECTANGLE_16*)calloc(count, sizeof(RECTANGLE_16));
211
212 if (!lParam)
213 return FALSE;
214
215 CopyMemory(lParam, areas, sizeof(RECTANGLE_16) * count);
216
217 up = update_cast(context->update);
218 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, RefreshRect),
219 (void*)(size_t)count, (void*)lParam);
220}
221
222static BOOL update_message_SuppressOutput(rdpContext* context, BYTE allow, const RECTANGLE_16* area)
223{
224 RECTANGLE_16* lParam = NULL;
225 rdp_update_internal* up = NULL;
226
227 if (!context || !context->update)
228 return FALSE;
229
230 if (area)
231 {
232 lParam = (RECTANGLE_16*)malloc(sizeof(RECTANGLE_16));
233
234 if (!lParam)
235 return FALSE;
236
237 CopyMemory(lParam, area, sizeof(RECTANGLE_16));
238 }
239
240 up = update_cast(context->update);
241 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SuppressOutput),
242 (void*)(size_t)allow, (void*)lParam);
243}
244
245static BOOL update_message_SurfaceCommand(rdpContext* context, wStream* s)
246{
247 wStream* wParam = NULL;
248 rdp_update_internal* up = NULL;
249
250 if (!context || !context->update || !s)
251 return FALSE;
252
253 wParam = Stream_New(NULL, Stream_GetRemainingLength(s));
254
255 if (!wParam)
256 return FALSE;
257
258 Stream_Copy(s, wParam, Stream_GetRemainingLength(s));
259 Stream_SetPosition(wParam, 0);
260
261 up = update_cast(context->update);
262 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceCommand),
263 (void*)wParam, NULL);
264}
265
266static BOOL update_message_SurfaceBits(rdpContext* context,
267 const SURFACE_BITS_COMMAND* surfaceBitsCommand)
268{
269 SURFACE_BITS_COMMAND* wParam = NULL;
270 rdp_update_internal* up = NULL;
271
272 if (!context || !context->update || !surfaceBitsCommand)
273 return FALSE;
274
275 wParam = copy_surface_bits_command(context, surfaceBitsCommand);
276
277 if (!wParam)
278 return FALSE;
279
280 up = update_cast(context->update);
281 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceBits),
282 (void*)wParam, NULL);
283}
284
285static BOOL update_message_SurfaceFrameMarker(rdpContext* context,
286 const SURFACE_FRAME_MARKER* surfaceFrameMarker)
287{
288 SURFACE_FRAME_MARKER* wParam = NULL;
289 rdp_update_internal* up = NULL;
290
291 if (!context || !context->update || !surfaceFrameMarker)
292 return FALSE;
293
294 wParam = (SURFACE_FRAME_MARKER*)malloc(sizeof(SURFACE_FRAME_MARKER));
295
296 if (!wParam)
297 return FALSE;
298
299 CopyMemory(wParam, surfaceFrameMarker, sizeof(SURFACE_FRAME_MARKER));
300
301 up = update_cast(context->update);
302 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(Update, SurfaceFrameMarker),
303 (void*)wParam, NULL);
304}
305
306static BOOL update_message_SurfaceFrameAcknowledge(rdpContext* context, UINT32 frameId)
307{
308 rdp_update_internal* up = NULL;
309
310 if (!context || !context->update)
311 return FALSE;
312
313 up = update_cast(context->update);
314 return MessageQueue_Post(up->queue, (void*)context,
315 MakeMessageId(Update, SurfaceFrameAcknowledge), (void*)(size_t)frameId,
316 NULL);
317}
318
319/* Primary Update */
320
321static BOOL update_message_DstBlt(rdpContext* context, const DSTBLT_ORDER* dstBlt)
322{
323 DSTBLT_ORDER* wParam = NULL;
324 rdp_update_internal* up = NULL;
325
326 if (!context || !context->update || !dstBlt)
327 return FALSE;
328
329 wParam = (DSTBLT_ORDER*)malloc(sizeof(DSTBLT_ORDER));
330
331 if (!wParam)
332 return FALSE;
333
334 CopyMemory(wParam, dstBlt, sizeof(DSTBLT_ORDER));
335
336 up = update_cast(context->update);
337 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, DstBlt),
338 (void*)wParam, NULL);
339}
340
341static BOOL update_message_PatBlt(rdpContext* context, PATBLT_ORDER* patBlt)
342{
343 PATBLT_ORDER* wParam = NULL;
344 rdp_update_internal* up = NULL;
345
346 if (!context || !context->update || !patBlt)
347 return FALSE;
348
349 wParam = (PATBLT_ORDER*)malloc(sizeof(PATBLT_ORDER));
350
351 if (!wParam)
352 return FALSE;
353
354 CopyMemory(wParam, patBlt, sizeof(PATBLT_ORDER));
355 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
356
357 up = update_cast(context->update);
358 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PatBlt),
359 (void*)wParam, NULL);
360}
361
362static BOOL update_message_ScrBlt(rdpContext* context, const SCRBLT_ORDER* scrBlt)
363{
364 SCRBLT_ORDER* wParam = NULL;
365 rdp_update_internal* up = NULL;
366
367 if (!context || !context->update || !scrBlt)
368 return FALSE;
369
370 wParam = (SCRBLT_ORDER*)malloc(sizeof(SCRBLT_ORDER));
371
372 if (!wParam)
373 return FALSE;
374
375 CopyMemory(wParam, scrBlt, sizeof(SCRBLT_ORDER));
376
377 up = update_cast(context->update);
378 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, ScrBlt),
379 (void*)wParam, NULL);
380}
381
382static BOOL update_message_OpaqueRect(rdpContext* context, const OPAQUE_RECT_ORDER* opaqueRect)
383{
384 OPAQUE_RECT_ORDER* wParam = NULL;
385 rdp_update_internal* up = NULL;
386
387 if (!context || !context->update || !opaqueRect)
388 return FALSE;
389
390 wParam = (OPAQUE_RECT_ORDER*)malloc(sizeof(OPAQUE_RECT_ORDER));
391
392 if (!wParam)
393 return FALSE;
394
395 CopyMemory(wParam, opaqueRect, sizeof(OPAQUE_RECT_ORDER));
396
397 up = update_cast(context->update);
398 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, OpaqueRect),
399 (void*)wParam, NULL);
400}
401
402static BOOL update_message_DrawNineGrid(rdpContext* context,
403 const DRAW_NINE_GRID_ORDER* drawNineGrid)
404{
405 DRAW_NINE_GRID_ORDER* wParam = NULL;
406 rdp_update_internal* up = NULL;
407
408 if (!context || !context->update || !drawNineGrid)
409 return FALSE;
410
411 wParam = (DRAW_NINE_GRID_ORDER*)malloc(sizeof(DRAW_NINE_GRID_ORDER));
412
413 if (!wParam)
414 return FALSE;
415
416 CopyMemory(wParam, drawNineGrid, sizeof(DRAW_NINE_GRID_ORDER));
417
418 up = update_cast(context->update);
419 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, DrawNineGrid),
420 (void*)wParam, NULL);
421}
422
423static BOOL update_message_MultiDstBlt(rdpContext* context, const MULTI_DSTBLT_ORDER* multiDstBlt)
424{
425 MULTI_DSTBLT_ORDER* wParam = NULL;
426 rdp_update_internal* up = NULL;
427
428 if (!context || !context->update || !multiDstBlt)
429 return FALSE;
430
431 wParam = (MULTI_DSTBLT_ORDER*)malloc(sizeof(MULTI_DSTBLT_ORDER));
432
433 if (!wParam)
434 return FALSE;
435
436 CopyMemory(wParam, multiDstBlt, sizeof(MULTI_DSTBLT_ORDER));
437
438 up = update_cast(context->update);
439 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiDstBlt),
440 (void*)wParam, NULL);
441}
442
443static BOOL update_message_MultiPatBlt(rdpContext* context, const MULTI_PATBLT_ORDER* multiPatBlt)
444{
445 MULTI_PATBLT_ORDER* wParam = NULL;
446 rdp_update_internal* up = NULL;
447
448 if (!context || !context->update || !multiPatBlt)
449 return FALSE;
450
451 wParam = (MULTI_PATBLT_ORDER*)malloc(sizeof(MULTI_PATBLT_ORDER));
452
453 if (!wParam)
454 return FALSE;
455
456 CopyMemory(wParam, multiPatBlt, sizeof(MULTI_PATBLT_ORDER));
457 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
458
459 up = update_cast(context->update);
460 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiPatBlt),
461 (void*)wParam, NULL);
462}
463
464static BOOL update_message_MultiScrBlt(rdpContext* context, const MULTI_SCRBLT_ORDER* multiScrBlt)
465{
466 MULTI_SCRBLT_ORDER* wParam = NULL;
467 rdp_update_internal* up = NULL;
468
469 if (!context || !context->update || !multiScrBlt)
470 return FALSE;
471
472 wParam = (MULTI_SCRBLT_ORDER*)malloc(sizeof(MULTI_SCRBLT_ORDER));
473
474 if (!wParam)
475 return FALSE;
476
477 CopyMemory(wParam, multiScrBlt, sizeof(MULTI_SCRBLT_ORDER));
478
479 up = update_cast(context->update);
480 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MultiScrBlt),
481 (void*)wParam, NULL);
482}
483
484static BOOL update_message_MultiOpaqueRect(rdpContext* context,
485 const MULTI_OPAQUE_RECT_ORDER* multiOpaqueRect)
486{
487 MULTI_OPAQUE_RECT_ORDER* wParam = NULL;
488 rdp_update_internal* up = NULL;
489
490 if (!context || !context->update || !multiOpaqueRect)
491 return FALSE;
492
493 wParam = (MULTI_OPAQUE_RECT_ORDER*)malloc(sizeof(MULTI_OPAQUE_RECT_ORDER));
494
495 if (!wParam)
496 return FALSE;
497
498 CopyMemory(wParam, multiOpaqueRect, sizeof(MULTI_OPAQUE_RECT_ORDER));
499
500 up = update_cast(context->update);
501 return MessageQueue_Post(up->queue, (void*)context,
502 MakeMessageId(PrimaryUpdate, MultiOpaqueRect), (void*)wParam, NULL);
503}
504
505static BOOL update_message_MultiDrawNineGrid(rdpContext* context,
506 const MULTI_DRAW_NINE_GRID_ORDER* multiDrawNineGrid)
507{
508 MULTI_DRAW_NINE_GRID_ORDER* wParam = NULL;
509 rdp_update_internal* up = NULL;
510
511 if (!context || !context->update || !multiDrawNineGrid)
512 return FALSE;
513
514 wParam = (MULTI_DRAW_NINE_GRID_ORDER*)malloc(sizeof(MULTI_DRAW_NINE_GRID_ORDER));
515
516 if (!wParam)
517 return FALSE;
518
519 CopyMemory(wParam, multiDrawNineGrid, sizeof(MULTI_DRAW_NINE_GRID_ORDER));
520 /* TODO: complete copy */
521
522 up = update_cast(context->update);
523 return MessageQueue_Post(up->queue, (void*)context,
524 MakeMessageId(PrimaryUpdate, MultiDrawNineGrid), (void*)wParam, NULL);
525}
526
527static BOOL update_message_LineTo(rdpContext* context, const LINE_TO_ORDER* lineTo)
528{
529 LINE_TO_ORDER* wParam = NULL;
530 rdp_update_internal* up = NULL;
531
532 if (!context || !context->update || !lineTo)
533 return FALSE;
534
535 wParam = (LINE_TO_ORDER*)malloc(sizeof(LINE_TO_ORDER));
536
537 if (!wParam)
538 return FALSE;
539
540 CopyMemory(wParam, lineTo, sizeof(LINE_TO_ORDER));
541
542 up = update_cast(context->update);
543 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, LineTo),
544 (void*)wParam, NULL);
545}
546
547static BOOL update_message_Polyline(rdpContext* context, const POLYLINE_ORDER* polyline)
548{
549 POLYLINE_ORDER* wParam = NULL;
550 rdp_update_internal* up = NULL;
551
552 if (!context || !context->update || !polyline)
553 return FALSE;
554
555 wParam = (POLYLINE_ORDER*)malloc(sizeof(POLYLINE_ORDER));
556
557 if (!wParam)
558 return FALSE;
559
560 CopyMemory(wParam, polyline, sizeof(POLYLINE_ORDER));
561 wParam->points = (DELTA_POINT*)calloc(wParam->numDeltaEntries, sizeof(DELTA_POINT));
562
563 if (!wParam->points)
564 {
565 free(wParam);
566 return FALSE;
567 }
568
569 CopyMemory(wParam->points, polyline->points, sizeof(DELTA_POINT) * wParam->numDeltaEntries);
570
571 up = update_cast(context->update);
572 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, Polyline),
573 (void*)wParam, NULL);
574}
575
576static BOOL update_message_MemBlt(rdpContext* context, MEMBLT_ORDER* memBlt)
577{
578 MEMBLT_ORDER* wParam = NULL;
579 rdp_update_internal* up = NULL;
580
581 if (!context || !context->update || !memBlt)
582 return FALSE;
583
584 wParam = (MEMBLT_ORDER*)malloc(sizeof(MEMBLT_ORDER));
585
586 if (!wParam)
587 return FALSE;
588
589 CopyMemory(wParam, memBlt, sizeof(MEMBLT_ORDER));
590
591 up = update_cast(context->update);
592 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, MemBlt),
593 (void*)wParam, NULL);
594}
595
596static BOOL update_message_Mem3Blt(rdpContext* context, MEM3BLT_ORDER* mem3Blt)
597{
598 MEM3BLT_ORDER* wParam = NULL;
599 rdp_update_internal* up = NULL;
600
601 if (!context || !context->update || !mem3Blt)
602 return FALSE;
603
604 wParam = (MEM3BLT_ORDER*)malloc(sizeof(MEM3BLT_ORDER));
605
606 if (!wParam)
607 return FALSE;
608
609 CopyMemory(wParam, mem3Blt, sizeof(MEM3BLT_ORDER));
610 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
611
612 up = update_cast(context->update);
613 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, Mem3Blt),
614 (void*)wParam, NULL);
615}
616
617static BOOL update_message_SaveBitmap(rdpContext* context, const SAVE_BITMAP_ORDER* saveBitmap)
618{
619 SAVE_BITMAP_ORDER* wParam = NULL;
620 rdp_update_internal* up = NULL;
621
622 if (!context || !context->update || !saveBitmap)
623 return FALSE;
624
625 wParam = (SAVE_BITMAP_ORDER*)malloc(sizeof(SAVE_BITMAP_ORDER));
626
627 if (!wParam)
628 return FALSE;
629
630 CopyMemory(wParam, saveBitmap, sizeof(SAVE_BITMAP_ORDER));
631
632 up = update_cast(context->update);
633 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, SaveBitmap),
634 (void*)wParam, NULL);
635}
636
637static BOOL update_message_GlyphIndex(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
638{
639 GLYPH_INDEX_ORDER* wParam = NULL;
640 rdp_update_internal* up = NULL;
641
642 if (!context || !context->update || !glyphIndex)
643 return FALSE;
644
645 wParam = (GLYPH_INDEX_ORDER*)malloc(sizeof(GLYPH_INDEX_ORDER));
646
647 if (!wParam)
648 return FALSE;
649
650 CopyMemory(wParam, glyphIndex, sizeof(GLYPH_INDEX_ORDER));
651 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
652
653 up = update_cast(context->update);
654 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, GlyphIndex),
655 (void*)wParam, NULL);
656}
657
658static BOOL update_message_FastIndex(rdpContext* context, const FAST_INDEX_ORDER* fastIndex)
659{
660 FAST_INDEX_ORDER* wParam = NULL;
661 rdp_update_internal* up = NULL;
662
663 if (!context || !context->update || !fastIndex)
664 return FALSE;
665
666 wParam = (FAST_INDEX_ORDER*)malloc(sizeof(FAST_INDEX_ORDER));
667
668 if (!wParam)
669 return FALSE;
670
671 CopyMemory(wParam, fastIndex, sizeof(FAST_INDEX_ORDER));
672
673 up = update_cast(context->update);
674 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, FastIndex),
675 (void*)wParam, NULL);
676}
677
678static BOOL update_message_FastGlyph(rdpContext* context, const FAST_GLYPH_ORDER* fastGlyph)
679{
680 FAST_GLYPH_ORDER* wParam = NULL;
681 rdp_update_internal* up = NULL;
682
683 if (!context || !context->update || !fastGlyph)
684 return FALSE;
685
686 wParam = (FAST_GLYPH_ORDER*)malloc(sizeof(FAST_GLYPH_ORDER));
687
688 if (!wParam)
689 return FALSE;
690
691 CopyMemory(wParam, fastGlyph, sizeof(FAST_GLYPH_ORDER));
692
693 if (wParam->cbData > 1)
694 {
695 wParam->glyphData.aj = (BYTE*)malloc(fastGlyph->glyphData.cb);
696
697 if (!wParam->glyphData.aj)
698 {
699 free(wParam);
700 return FALSE;
701 }
702
703 CopyMemory(wParam->glyphData.aj, fastGlyph->glyphData.aj, fastGlyph->glyphData.cb);
704 }
705 else
706 {
707 wParam->glyphData.aj = NULL;
708 }
709
710 up = update_cast(context->update);
711 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, FastGlyph),
712 (void*)wParam, NULL);
713}
714
715static BOOL update_message_PolygonSC(rdpContext* context, const POLYGON_SC_ORDER* polygonSC)
716{
717 POLYGON_SC_ORDER* wParam = NULL;
718 rdp_update_internal* up = NULL;
719
720 if (!context || !context->update || !polygonSC)
721 return FALSE;
722
723 wParam = (POLYGON_SC_ORDER*)malloc(sizeof(POLYGON_SC_ORDER));
724
725 if (!wParam)
726 return FALSE;
727
728 CopyMemory(wParam, polygonSC, sizeof(POLYGON_SC_ORDER));
729 wParam->points = (DELTA_POINT*)calloc(wParam->numPoints, sizeof(DELTA_POINT));
730
731 if (!wParam->points)
732 {
733 free(wParam);
734 return FALSE;
735 }
736
737 CopyMemory(wParam->points, polygonSC, sizeof(DELTA_POINT) * wParam->numPoints);
738
739 up = update_cast(context->update);
740 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PolygonSC),
741 (void*)wParam, NULL);
742}
743
744static BOOL update_message_PolygonCB(rdpContext* context, POLYGON_CB_ORDER* polygonCB)
745{
746 POLYGON_CB_ORDER* wParam = NULL;
747 rdp_update_internal* up = NULL;
748
749 if (!context || !context->update || !polygonCB)
750 return FALSE;
751
752 wParam = (POLYGON_CB_ORDER*)malloc(sizeof(POLYGON_CB_ORDER));
753
754 if (!wParam)
755 return FALSE;
756
757 CopyMemory(wParam, polygonCB, sizeof(POLYGON_CB_ORDER));
758 wParam->points = (DELTA_POINT*)calloc(wParam->numPoints, sizeof(DELTA_POINT));
759
760 if (!wParam->points)
761 {
762 free(wParam);
763 return FALSE;
764 }
765
766 CopyMemory(wParam->points, polygonCB, sizeof(DELTA_POINT) * wParam->numPoints);
767 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
768
769 up = update_cast(context->update);
770 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, PolygonCB),
771 (void*)wParam, NULL);
772}
773
774static BOOL update_message_EllipseSC(rdpContext* context, const ELLIPSE_SC_ORDER* ellipseSC)
775{
776 ELLIPSE_SC_ORDER* wParam = NULL;
777 rdp_update_internal* up = NULL;
778
779 if (!context || !context->update || !ellipseSC)
780 return FALSE;
781
782 wParam = (ELLIPSE_SC_ORDER*)malloc(sizeof(ELLIPSE_SC_ORDER));
783
784 if (!wParam)
785 return FALSE;
786
787 CopyMemory(wParam, ellipseSC, sizeof(ELLIPSE_SC_ORDER));
788
789 up = update_cast(context->update);
790 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, EllipseSC),
791 (void*)wParam, NULL);
792}
793
794static BOOL update_message_EllipseCB(rdpContext* context, const ELLIPSE_CB_ORDER* ellipseCB)
795{
796 ELLIPSE_CB_ORDER* wParam = NULL;
797 rdp_update_internal* up = NULL;
798
799 if (!context || !context->update || !ellipseCB)
800 return FALSE;
801
802 wParam = (ELLIPSE_CB_ORDER*)malloc(sizeof(ELLIPSE_CB_ORDER));
803
804 if (!wParam)
805 return FALSE;
806
807 CopyMemory(wParam, ellipseCB, sizeof(ELLIPSE_CB_ORDER));
808 wParam->brush.data = (BYTE*)wParam->brush.p8x8;
809
810 up = update_cast(context->update);
811 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PrimaryUpdate, EllipseCB),
812 (void*)wParam, NULL);
813}
814
815/* Secondary Update */
816
817static BOOL update_message_CacheBitmap(rdpContext* context,
818 const CACHE_BITMAP_ORDER* cacheBitmapOrder)
819{
820 CACHE_BITMAP_ORDER* wParam = NULL;
821 rdp_update_internal* up = NULL;
822
823 if (!context || !context->update || !cacheBitmapOrder)
824 return FALSE;
825
826 wParam = copy_cache_bitmap_order(context, cacheBitmapOrder);
827
828 if (!wParam)
829 return FALSE;
830
831 up = update_cast(context->update);
832 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheBitmap),
833 (void*)wParam, NULL);
834}
835
836static BOOL update_message_CacheBitmapV2(rdpContext* context,
837 CACHE_BITMAP_V2_ORDER* cacheBitmapV2Order)
838{
839 CACHE_BITMAP_V2_ORDER* wParam = NULL;
840 rdp_update_internal* up = NULL;
841
842 if (!context || !context->update || !cacheBitmapV2Order)
843 return FALSE;
844
845 wParam = copy_cache_bitmap_v2_order(context, cacheBitmapV2Order);
846
847 if (!wParam)
848 return FALSE;
849
850 up = update_cast(context->update);
851 return MessageQueue_Post(up->queue, (void*)context,
852 MakeMessageId(SecondaryUpdate, CacheBitmapV2), (void*)wParam, NULL);
853}
854
855static BOOL update_message_CacheBitmapV3(rdpContext* context,
856 CACHE_BITMAP_V3_ORDER* cacheBitmapV3Order)
857{
858 CACHE_BITMAP_V3_ORDER* wParam = NULL;
859 rdp_update_internal* up = NULL;
860
861 if (!context || !context->update || !cacheBitmapV3Order)
862 return FALSE;
863
864 wParam = copy_cache_bitmap_v3_order(context, cacheBitmapV3Order);
865
866 if (!wParam)
867 return FALSE;
868
869 up = update_cast(context->update);
870 return MessageQueue_Post(up->queue, (void*)context,
871 MakeMessageId(SecondaryUpdate, CacheBitmapV3), (void*)wParam, NULL);
872}
873
874static BOOL update_message_CacheColorTable(rdpContext* context,
875 const CACHE_COLOR_TABLE_ORDER* cacheColorTableOrder)
876{
877 CACHE_COLOR_TABLE_ORDER* wParam = NULL;
878 rdp_update_internal* up = NULL;
879
880 if (!context || !context->update || !cacheColorTableOrder)
881 return FALSE;
882
883 wParam = copy_cache_color_table_order(context, cacheColorTableOrder);
884
885 if (!wParam)
886 return FALSE;
887
888 up = update_cast(context->update);
889 return MessageQueue_Post(up->queue, (void*)context,
890 MakeMessageId(SecondaryUpdate, CacheColorTable), (void*)wParam, NULL);
891}
892
893static BOOL update_message_CacheGlyph(rdpContext* context, const CACHE_GLYPH_ORDER* cacheGlyphOrder)
894{
895 CACHE_GLYPH_ORDER* wParam = NULL;
896 rdp_update_internal* up = NULL;
897
898 if (!context || !context->update || !cacheGlyphOrder)
899 return FALSE;
900
901 wParam = copy_cache_glyph_order(context, cacheGlyphOrder);
902
903 if (!wParam)
904 return FALSE;
905
906 up = update_cast(context->update);
907 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheGlyph),
908 (void*)wParam, NULL);
909}
910
911static BOOL update_message_CacheGlyphV2(rdpContext* context,
912 const CACHE_GLYPH_V2_ORDER* cacheGlyphV2Order)
913{
914 CACHE_GLYPH_V2_ORDER* wParam = NULL;
915 rdp_update_internal* up = NULL;
916
917 if (!context || !context->update || !cacheGlyphV2Order)
918 return FALSE;
919
920 wParam = copy_cache_glyph_v2_order(context, cacheGlyphV2Order);
921
922 if (!wParam)
923 return FALSE;
924
925 up = update_cast(context->update);
926 return MessageQueue_Post(up->queue, (void*)context,
927 MakeMessageId(SecondaryUpdate, CacheGlyphV2), (void*)wParam, NULL);
928}
929
930static BOOL update_message_CacheBrush(rdpContext* context, const CACHE_BRUSH_ORDER* cacheBrushOrder)
931{
932 CACHE_BRUSH_ORDER* wParam = NULL;
933 rdp_update_internal* up = NULL;
934
935 if (!context || !context->update || !cacheBrushOrder)
936 return FALSE;
937
938 wParam = copy_cache_brush_order(context, cacheBrushOrder);
939
940 if (!wParam)
941 return FALSE;
942
943 up = update_cast(context->update);
944 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(SecondaryUpdate, CacheBrush),
945 (void*)wParam, NULL);
946}
947
948/* Alternate Secondary Update */
949
950static BOOL
951update_message_CreateOffscreenBitmap(rdpContext* context,
952 const CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
953{
954 CREATE_OFFSCREEN_BITMAP_ORDER* wParam = NULL;
955 rdp_update_internal* up = NULL;
956
957 if (!context || !context->update || !createOffscreenBitmap)
958 return FALSE;
959
960 wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*)malloc(sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
961
962 if (!wParam)
963 return FALSE;
964
965 CopyMemory(wParam, createOffscreenBitmap, sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
966 wParam->deleteList.cIndices = createOffscreenBitmap->deleteList.cIndices;
967 wParam->deleteList.sIndices = wParam->deleteList.cIndices;
968 wParam->deleteList.indices = (UINT16*)calloc(wParam->deleteList.cIndices, sizeof(UINT16));
969
970 if (!wParam->deleteList.indices)
971 {
972 free(wParam);
973 return FALSE;
974 }
975
976 CopyMemory(wParam->deleteList.indices, createOffscreenBitmap->deleteList.indices,
977 wParam->deleteList.cIndices);
978
979 up = update_cast(context->update);
980 return MessageQueue_Post(up->queue, (void*)context,
981 MakeMessageId(AltSecUpdate, CreateOffscreenBitmap), (void*)wParam,
982 NULL);
983}
984
985static BOOL update_message_SwitchSurface(rdpContext* context,
986 const SWITCH_SURFACE_ORDER* switchSurface)
987{
988 SWITCH_SURFACE_ORDER* wParam = NULL;
989 rdp_update_internal* up = NULL;
990
991 if (!context || !context->update || !switchSurface)
992 return FALSE;
993
994 wParam = (SWITCH_SURFACE_ORDER*)malloc(sizeof(SWITCH_SURFACE_ORDER));
995
996 if (!wParam)
997 return FALSE;
998
999 CopyMemory(wParam, switchSurface, sizeof(SWITCH_SURFACE_ORDER));
1000
1001 up = update_cast(context->update);
1002 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, SwitchSurface),
1003 (void*)wParam, NULL);
1004}
1005
1006static BOOL
1007update_message_CreateNineGridBitmap(rdpContext* context,
1008 const CREATE_NINE_GRID_BITMAP_ORDER* createNineGridBitmap)
1009{
1010 CREATE_NINE_GRID_BITMAP_ORDER* wParam = NULL;
1011 rdp_update_internal* up = NULL;
1012
1013 if (!context || !context->update || !createNineGridBitmap)
1014 return FALSE;
1015
1016 wParam = (CREATE_NINE_GRID_BITMAP_ORDER*)malloc(sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
1017
1018 if (!wParam)
1019 return FALSE;
1020
1021 CopyMemory(wParam, createNineGridBitmap, sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
1022
1023 up = update_cast(context->update);
1024 return MessageQueue_Post(up->queue, (void*)context,
1025 MakeMessageId(AltSecUpdate, CreateNineGridBitmap), (void*)wParam,
1026 NULL);
1027}
1028
1029static BOOL update_message_FrameMarker(rdpContext* context, const FRAME_MARKER_ORDER* frameMarker)
1030{
1031 FRAME_MARKER_ORDER* wParam = NULL;
1032 rdp_update_internal* up = NULL;
1033
1034 if (!context || !context->update || !frameMarker)
1035 return FALSE;
1036
1037 wParam = (FRAME_MARKER_ORDER*)malloc(sizeof(FRAME_MARKER_ORDER));
1038
1039 if (!wParam)
1040 return FALSE;
1041
1042 CopyMemory(wParam, frameMarker, sizeof(FRAME_MARKER_ORDER));
1043
1044 up = update_cast(context->update);
1045 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, FrameMarker),
1046 (void*)wParam, NULL);
1047}
1048
1049static BOOL update_message_StreamBitmapFirst(rdpContext* context,
1050 const STREAM_BITMAP_FIRST_ORDER* streamBitmapFirst)
1051{
1052 STREAM_BITMAP_FIRST_ORDER* wParam = NULL;
1053 rdp_update_internal* up = NULL;
1054
1055 if (!context || !context->update || !streamBitmapFirst)
1056 return FALSE;
1057
1058 wParam = (STREAM_BITMAP_FIRST_ORDER*)malloc(sizeof(STREAM_BITMAP_FIRST_ORDER));
1059
1060 if (!wParam)
1061 return FALSE;
1062
1063 CopyMemory(wParam, streamBitmapFirst, sizeof(STREAM_BITMAP_FIRST_ORDER));
1064 /* TODO: complete copy */
1065
1066 up = update_cast(context->update);
1067 return MessageQueue_Post(up->queue, (void*)context,
1068 MakeMessageId(AltSecUpdate, StreamBitmapFirst), (void*)wParam, NULL);
1069}
1070
1071static BOOL update_message_StreamBitmapNext(rdpContext* context,
1072 const STREAM_BITMAP_NEXT_ORDER* streamBitmapNext)
1073{
1074 STREAM_BITMAP_NEXT_ORDER* wParam = NULL;
1075 rdp_update_internal* up = NULL;
1076
1077 if (!context || !context->update || !streamBitmapNext)
1078 return FALSE;
1079
1080 wParam = (STREAM_BITMAP_NEXT_ORDER*)malloc(sizeof(STREAM_BITMAP_NEXT_ORDER));
1081
1082 if (!wParam)
1083 return FALSE;
1084
1085 CopyMemory(wParam, streamBitmapNext, sizeof(STREAM_BITMAP_NEXT_ORDER));
1086 /* TODO: complete copy */
1087
1088 up = update_cast(context->update);
1089 return MessageQueue_Post(up->queue, (void*)context,
1090 MakeMessageId(AltSecUpdate, StreamBitmapNext), (void*)wParam, NULL);
1091}
1092
1093static BOOL update_message_DrawGdiPlusFirst(rdpContext* context,
1094 const DRAW_GDIPLUS_FIRST_ORDER* drawGdiPlusFirst)
1095{
1096 DRAW_GDIPLUS_FIRST_ORDER* wParam = NULL;
1097 rdp_update_internal* up = NULL;
1098
1099 if (!context || !context->update || !drawGdiPlusFirst)
1100 return FALSE;
1101
1102 wParam = (DRAW_GDIPLUS_FIRST_ORDER*)malloc(sizeof(DRAW_GDIPLUS_FIRST_ORDER));
1103
1104 if (!wParam)
1105 return FALSE;
1106
1107 CopyMemory(wParam, drawGdiPlusFirst, sizeof(DRAW_GDIPLUS_FIRST_ORDER));
1108 /* TODO: complete copy */
1109 up = update_cast(context->update);
1110 return MessageQueue_Post(up->queue, (void*)context,
1111 MakeMessageId(AltSecUpdate, DrawGdiPlusFirst), (void*)wParam, NULL);
1112}
1113
1114static BOOL update_message_DrawGdiPlusNext(rdpContext* context,
1115 const DRAW_GDIPLUS_NEXT_ORDER* drawGdiPlusNext)
1116{
1117 DRAW_GDIPLUS_NEXT_ORDER* wParam = NULL;
1118 rdp_update_internal* up = NULL;
1119
1120 if (!context || !context->update || !drawGdiPlusNext)
1121 return FALSE;
1122
1123 wParam = (DRAW_GDIPLUS_NEXT_ORDER*)malloc(sizeof(DRAW_GDIPLUS_NEXT_ORDER));
1124
1125 if (!wParam)
1126 return FALSE;
1127
1128 CopyMemory(wParam, drawGdiPlusNext, sizeof(DRAW_GDIPLUS_NEXT_ORDER));
1129 /* TODO: complete copy */
1130
1131 up = update_cast(context->update);
1132 return MessageQueue_Post(up->queue, (void*)context,
1133 MakeMessageId(AltSecUpdate, DrawGdiPlusNext), (void*)wParam, NULL);
1134}
1135
1136static BOOL update_message_DrawGdiPlusEnd(rdpContext* context,
1137 const DRAW_GDIPLUS_END_ORDER* drawGdiPlusEnd)
1138{
1139 DRAW_GDIPLUS_END_ORDER* wParam = NULL;
1140 rdp_update_internal* up = NULL;
1141
1142 if (!context || !context->update || !drawGdiPlusEnd)
1143 return FALSE;
1144
1145 wParam = (DRAW_GDIPLUS_END_ORDER*)malloc(sizeof(DRAW_GDIPLUS_END_ORDER));
1146
1147 if (!wParam)
1148 return FALSE;
1149
1150 CopyMemory(wParam, drawGdiPlusEnd, sizeof(DRAW_GDIPLUS_END_ORDER));
1151 /* TODO: complete copy */
1152
1153 up = update_cast(context->update);
1154 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(AltSecUpdate, DrawGdiPlusEnd),
1155 (void*)wParam, NULL);
1156}
1157
1158static BOOL
1159update_message_DrawGdiPlusCacheFirst(rdpContext* context,
1160 const DRAW_GDIPLUS_CACHE_FIRST_ORDER* drawGdiPlusCacheFirst)
1161{
1162 DRAW_GDIPLUS_CACHE_FIRST_ORDER* wParam = NULL;
1163 rdp_update_internal* up = NULL;
1164
1165 if (!context || !context->update || !drawGdiPlusCacheFirst)
1166 return FALSE;
1167
1168 wParam = (DRAW_GDIPLUS_CACHE_FIRST_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
1169
1170 if (!wParam)
1171 return FALSE;
1172
1173 CopyMemory(wParam, drawGdiPlusCacheFirst, sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
1174 /* TODO: complete copy */
1175
1176 up = update_cast(context->update);
1177 return MessageQueue_Post(up->queue, (void*)context,
1178 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheFirst), (void*)wParam,
1179 NULL);
1180}
1181
1182static BOOL
1183update_message_DrawGdiPlusCacheNext(rdpContext* context,
1184 const DRAW_GDIPLUS_CACHE_NEXT_ORDER* drawGdiPlusCacheNext)
1185{
1186 DRAW_GDIPLUS_CACHE_NEXT_ORDER* wParam = NULL;
1187 rdp_update_internal* up = NULL;
1188
1189 if (!context || !context->update || !drawGdiPlusCacheNext)
1190 return FALSE;
1191
1192 wParam = (DRAW_GDIPLUS_CACHE_NEXT_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
1193
1194 if (!wParam)
1195 return FALSE;
1196
1197 CopyMemory(wParam, drawGdiPlusCacheNext, sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
1198 /* TODO: complete copy */
1199
1200 up = update_cast(context->update);
1201 return MessageQueue_Post(up->queue, (void*)context,
1202 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheNext), (void*)wParam,
1203 NULL);
1204}
1205
1206static BOOL
1207update_message_DrawGdiPlusCacheEnd(rdpContext* context,
1208 const DRAW_GDIPLUS_CACHE_END_ORDER* drawGdiPlusCacheEnd)
1209{
1210 DRAW_GDIPLUS_CACHE_END_ORDER* wParam = NULL;
1211 rdp_update_internal* up = NULL;
1212
1213 if (!context || !context->update || !drawGdiPlusCacheEnd)
1214 return FALSE;
1215
1216 wParam = (DRAW_GDIPLUS_CACHE_END_ORDER*)malloc(sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
1217
1218 if (!wParam)
1219 return FALSE;
1220
1221 CopyMemory(wParam, drawGdiPlusCacheEnd, sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
1222 /* TODO: complete copy */
1223
1224 up = update_cast(context->update);
1225 return MessageQueue_Post(up->queue, (void*)context,
1226 MakeMessageId(AltSecUpdate, DrawGdiPlusCacheEnd), (void*)wParam, NULL);
1227}
1228
1229/* Window Update */
1230
1231static BOOL update_message_WindowCreate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1232 const WINDOW_STATE_ORDER* windowState)
1233{
1234 WINDOW_ORDER_INFO* wParam = NULL;
1235 WINDOW_STATE_ORDER* lParam = NULL;
1236 rdp_update_internal* up = NULL;
1237
1238 if (!context || !context->update || !orderInfo || !windowState)
1239 return FALSE;
1240
1241 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1242
1243 if (!wParam)
1244 return FALSE;
1245
1246 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1247 lParam = (WINDOW_STATE_ORDER*)malloc(sizeof(WINDOW_STATE_ORDER));
1248
1249 if (!lParam)
1250 {
1251 free(wParam);
1252 return FALSE;
1253 }
1254
1255 CopyMemory(lParam, windowState, sizeof(WINDOW_STATE_ORDER));
1256
1257 up = update_cast(context->update);
1258 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowCreate),
1259 (void*)wParam, (void*)lParam);
1260}
1261
1262static BOOL update_message_WindowUpdate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1263 const WINDOW_STATE_ORDER* windowState)
1264{
1265 WINDOW_ORDER_INFO* wParam = NULL;
1266 WINDOW_STATE_ORDER* lParam = NULL;
1267 rdp_update_internal* up = NULL;
1268
1269 if (!context || !context->update || !orderInfo || !windowState)
1270 return FALSE;
1271
1272 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1273
1274 if (!wParam)
1275 return FALSE;
1276
1277 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1278 lParam = (WINDOW_STATE_ORDER*)malloc(sizeof(WINDOW_STATE_ORDER));
1279
1280 if (!lParam)
1281 {
1282 free(wParam);
1283 return FALSE;
1284 }
1285
1286 CopyMemory(lParam, windowState, sizeof(WINDOW_STATE_ORDER));
1287
1288 up = update_cast(context->update);
1289 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowUpdate),
1290 (void*)wParam, (void*)lParam);
1291}
1292
1293static BOOL update_message_WindowIcon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1294 const WINDOW_ICON_ORDER* windowIcon)
1295{
1296 WINDOW_ORDER_INFO* wParam = NULL;
1297 WINDOW_ICON_ORDER* lParam = NULL;
1298 rdp_update_internal* up = NULL;
1299
1300 if (!context || !context->update || !orderInfo || !windowIcon)
1301 return FALSE;
1302
1303 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1304
1305 if (!wParam)
1306 return FALSE;
1307
1308 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1309 lParam = (WINDOW_ICON_ORDER*)calloc(1, sizeof(WINDOW_ICON_ORDER));
1310
1311 if (!lParam)
1312 goto out_fail;
1313
1314 lParam->iconInfo = calloc(1, sizeof(ICON_INFO));
1315
1316 if (!lParam->iconInfo)
1317 goto out_fail;
1318
1319 CopyMemory(lParam, windowIcon, sizeof(WINDOW_ICON_ORDER));
1320 WLog_VRB(TAG, "update_message_WindowIcon");
1321
1322 if (windowIcon->iconInfo->cbBitsColor > 0)
1323 {
1324 lParam->iconInfo->bitsColor = (BYTE*)malloc(windowIcon->iconInfo->cbBitsColor);
1325
1326 if (!lParam->iconInfo->bitsColor)
1327 goto out_fail;
1328
1329 CopyMemory(lParam->iconInfo->bitsColor, windowIcon->iconInfo->bitsColor,
1330 windowIcon->iconInfo->cbBitsColor);
1331 }
1332
1333 if (windowIcon->iconInfo->cbBitsMask > 0)
1334 {
1335 lParam->iconInfo->bitsMask = (BYTE*)malloc(windowIcon->iconInfo->cbBitsMask);
1336
1337 if (!lParam->iconInfo->bitsMask)
1338 goto out_fail;
1339
1340 CopyMemory(lParam->iconInfo->bitsMask, windowIcon->iconInfo->bitsMask,
1341 windowIcon->iconInfo->cbBitsMask);
1342 }
1343
1344 if (windowIcon->iconInfo->cbColorTable > 0)
1345 {
1346 lParam->iconInfo->colorTable = (BYTE*)malloc(windowIcon->iconInfo->cbColorTable);
1347
1348 if (!lParam->iconInfo->colorTable)
1349 goto out_fail;
1350
1351 CopyMemory(lParam->iconInfo->colorTable, windowIcon->iconInfo->colorTable,
1352 windowIcon->iconInfo->cbColorTable);
1353 }
1354
1355 up = update_cast(context->update);
1356 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowIcon),
1357 (void*)wParam, (void*)lParam);
1358out_fail:
1359
1360 if (lParam && lParam->iconInfo)
1361 {
1362 free(lParam->iconInfo->bitsColor);
1363 free(lParam->iconInfo->bitsMask);
1364 free(lParam->iconInfo->colorTable);
1365 free(lParam->iconInfo);
1366 }
1367
1368 free(lParam);
1369 free(wParam);
1370 return FALSE;
1371}
1372
1373static BOOL update_message_WindowCachedIcon(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1374 const WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
1375{
1376 WINDOW_ORDER_INFO* wParam = NULL;
1377 WINDOW_CACHED_ICON_ORDER* lParam = NULL;
1378 rdp_update_internal* up = NULL;
1379
1380 if (!context || !context->update || !orderInfo || !windowCachedIcon)
1381 return FALSE;
1382
1383 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1384
1385 if (!wParam)
1386 return FALSE;
1387
1388 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1389 lParam = (WINDOW_CACHED_ICON_ORDER*)malloc(sizeof(WINDOW_CACHED_ICON_ORDER));
1390
1391 if (!lParam)
1392 {
1393 free(wParam);
1394 return FALSE;
1395 }
1396
1397 CopyMemory(lParam, windowCachedIcon, sizeof(WINDOW_CACHED_ICON_ORDER));
1398
1399 up = update_cast(context->update);
1400 return MessageQueue_Post(up->queue, (void*)context,
1401 MakeMessageId(WindowUpdate, WindowCachedIcon), (void*)wParam,
1402 (void*)lParam);
1403}
1404
1405static BOOL update_message_WindowDelete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
1406{
1407 WINDOW_ORDER_INFO* wParam = NULL;
1408 rdp_update_internal* up = NULL;
1409
1410 if (!context || !context->update || !orderInfo)
1411 return FALSE;
1412
1413 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1414
1415 if (!wParam)
1416 return FALSE;
1417
1418 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1419
1420 up = update_cast(context->update);
1421 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(WindowUpdate, WindowDelete),
1422 (void*)wParam, NULL);
1423}
1424
1425static BOOL update_message_NotifyIconCreate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1426 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1427{
1428 WINDOW_ORDER_INFO* wParam = NULL;
1429 NOTIFY_ICON_STATE_ORDER* lParam = NULL;
1430 rdp_update_internal* up = NULL;
1431
1432 if (!context || !context->update || !orderInfo || !notifyIconState)
1433 return FALSE;
1434
1435 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1436
1437 if (!wParam)
1438 return FALSE;
1439
1440 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1441 lParam = (NOTIFY_ICON_STATE_ORDER*)malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
1442
1443 if (!lParam)
1444 {
1445 free(wParam);
1446 return FALSE;
1447 }
1448
1449 CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
1450
1451 up = update_cast(context->update);
1452 return MessageQueue_Post(up->queue, (void*)context,
1453 MakeMessageId(WindowUpdate, NotifyIconCreate), (void*)wParam,
1454 (void*)lParam);
1455}
1456
1457static BOOL update_message_NotifyIconUpdate(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1458 const NOTIFY_ICON_STATE_ORDER* notifyIconState)
1459{
1460 WINDOW_ORDER_INFO* wParam = NULL;
1461 NOTIFY_ICON_STATE_ORDER* lParam = NULL;
1462 rdp_update_internal* up = NULL;
1463
1464 if (!context || !context->update || !orderInfo || !notifyIconState)
1465 return FALSE;
1466
1467 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1468
1469 if (!wParam)
1470 return FALSE;
1471
1472 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1473 lParam = (NOTIFY_ICON_STATE_ORDER*)malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
1474
1475 if (!lParam)
1476 {
1477 free(wParam);
1478 return FALSE;
1479 }
1480
1481 CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
1482
1483 up = update_cast(context->update);
1484 return MessageQueue_Post(up->queue, (void*)context,
1485 MakeMessageId(WindowUpdate, NotifyIconUpdate), (void*)wParam,
1486 (void*)lParam);
1487}
1488
1489static BOOL update_message_NotifyIconDelete(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo)
1490{
1491 WINDOW_ORDER_INFO* wParam = NULL;
1492 rdp_update_internal* up = NULL;
1493
1494 if (!context || !context->update || !orderInfo)
1495 return FALSE;
1496
1497 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1498
1499 if (!wParam)
1500 return FALSE;
1501
1502 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1503
1504 up = update_cast(context->update);
1505 return MessageQueue_Post(up->queue, (void*)context,
1506 MakeMessageId(WindowUpdate, NotifyIconDelete), (void*)wParam, NULL);
1507}
1508
1509static BOOL update_message_MonitoredDesktop(rdpContext* context, const WINDOW_ORDER_INFO* orderInfo,
1510 const MONITORED_DESKTOP_ORDER* monitoredDesktop)
1511{
1512 WINDOW_ORDER_INFO* wParam = NULL;
1513 MONITORED_DESKTOP_ORDER* lParam = NULL;
1514 rdp_update_internal* up = NULL;
1515
1516 if (!context || !context->update || !orderInfo || !monitoredDesktop)
1517 return FALSE;
1518
1519 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1520
1521 if (!wParam)
1522 return FALSE;
1523
1524 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1525 lParam = (MONITORED_DESKTOP_ORDER*)malloc(sizeof(MONITORED_DESKTOP_ORDER));
1526
1527 if (!lParam)
1528 {
1529 free(wParam);
1530 return FALSE;
1531 }
1532
1533 CopyMemory(lParam, monitoredDesktop, sizeof(MONITORED_DESKTOP_ORDER));
1534 lParam->windowIds = NULL;
1535
1536 if (lParam->numWindowIds)
1537 {
1538 lParam->windowIds = (UINT32*)calloc(lParam->numWindowIds, sizeof(UINT32));
1539 CopyMemory(lParam->windowIds, monitoredDesktop->windowIds, lParam->numWindowIds);
1540 }
1541
1542 up = update_cast(context->update);
1543 return MessageQueue_Post(up->queue, (void*)context,
1544 MakeMessageId(WindowUpdate, MonitoredDesktop), (void*)wParam,
1545 (void*)lParam);
1546}
1547
1548static BOOL update_message_NonMonitoredDesktop(rdpContext* context,
1549 const WINDOW_ORDER_INFO* orderInfo)
1550{
1551 WINDOW_ORDER_INFO* wParam = NULL;
1552 rdp_update_internal* up = NULL;
1553
1554 if (!context || !context->update || !orderInfo)
1555 return FALSE;
1556
1557 wParam = (WINDOW_ORDER_INFO*)malloc(sizeof(WINDOW_ORDER_INFO));
1558
1559 if (!wParam)
1560 return FALSE;
1561
1562 CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
1563
1564 up = update_cast(context->update);
1565 return MessageQueue_Post(up->queue, (void*)context,
1566 MakeMessageId(WindowUpdate, NonMonitoredDesktop), (void*)wParam, NULL);
1567}
1568
1569/* Pointer Update */
1570
1571static BOOL update_message_PointerPosition(rdpContext* context,
1572 const POINTER_POSITION_UPDATE* pointerPosition)
1573{
1574 POINTER_POSITION_UPDATE* wParam = NULL;
1575 rdp_update_internal* up = NULL;
1576
1577 if (!context || !context->update || !pointerPosition)
1578 return FALSE;
1579
1580 wParam = copy_pointer_position_update(context, pointerPosition);
1581
1582 if (!wParam)
1583 return FALSE;
1584
1585 up = update_cast(context->update);
1586 return MessageQueue_Post(up->queue, (void*)context,
1587 MakeMessageId(PointerUpdate, PointerPosition), (void*)wParam, NULL);
1588}
1589
1590static BOOL update_message_PointerSystem(rdpContext* context,
1591 const POINTER_SYSTEM_UPDATE* pointerSystem)
1592{
1593 POINTER_SYSTEM_UPDATE* wParam = NULL;
1594 rdp_update_internal* up = NULL;
1595
1596 if (!context || !context->update || !pointerSystem)
1597 return FALSE;
1598
1599 wParam = copy_pointer_system_update(context, pointerSystem);
1600
1601 if (!wParam)
1602 return FALSE;
1603
1604 up = update_cast(context->update);
1605 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerSystem),
1606 (void*)wParam, NULL);
1607}
1608
1609static BOOL update_message_PointerColor(rdpContext* context,
1610 const POINTER_COLOR_UPDATE* pointerColor)
1611{
1612 POINTER_COLOR_UPDATE* wParam = NULL;
1613 rdp_update_internal* up = NULL;
1614
1615 if (!context || !context->update || !pointerColor)
1616 return FALSE;
1617
1618 wParam = copy_pointer_color_update(context, pointerColor);
1619
1620 if (!wParam)
1621 return FALSE;
1622
1623 up = update_cast(context->update);
1624 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerColor),
1625 (void*)wParam, NULL);
1626}
1627
1628static BOOL update_message_PointerLarge(rdpContext* context, const POINTER_LARGE_UPDATE* pointer)
1629{
1630 POINTER_LARGE_UPDATE* wParam = NULL;
1631 rdp_update_internal* up = NULL;
1632
1633 if (!context || !context->update || !pointer)
1634 return FALSE;
1635
1636 wParam = copy_pointer_large_update(context, pointer);
1637
1638 if (!wParam)
1639 return FALSE;
1640
1641 up = update_cast(context->update);
1642 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerLarge),
1643 (void*)wParam, NULL);
1644}
1645
1646static BOOL update_message_PointerNew(rdpContext* context, const POINTER_NEW_UPDATE* pointerNew)
1647{
1648 POINTER_NEW_UPDATE* wParam = NULL;
1649 rdp_update_internal* up = NULL;
1650
1651 if (!context || !context->update || !pointerNew)
1652 return FALSE;
1653
1654 wParam = copy_pointer_new_update(context, pointerNew);
1655
1656 if (!wParam)
1657 return FALSE;
1658
1659 up = update_cast(context->update);
1660 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerNew),
1661 (void*)wParam, NULL);
1662}
1663
1664static BOOL update_message_PointerCached(rdpContext* context,
1665 const POINTER_CACHED_UPDATE* pointerCached)
1666{
1667 POINTER_CACHED_UPDATE* wParam = NULL;
1668 rdp_update_internal* up = NULL;
1669
1670 if (!context || !context->update || !pointerCached)
1671 return FALSE;
1672
1673 wParam = copy_pointer_cached_update(context, pointerCached);
1674
1675 if (!wParam)
1676 return FALSE;
1677
1678 up = update_cast(context->update);
1679 return MessageQueue_Post(up->queue, (void*)context, MakeMessageId(PointerUpdate, PointerCached),
1680 (void*)wParam, NULL);
1681}
1682
1683/* Message Queue */
1684static BOOL update_message_free_update_class(wMessage* msg, int type)
1685{
1686 rdpContext* context = NULL;
1687
1688 if (!msg)
1689 return FALSE;
1690
1691 context = (rdpContext*)msg->context;
1692
1693 switch (type)
1694 {
1695 case Update_BeginPaint:
1696 break;
1697
1698 case Update_EndPaint:
1699 break;
1700
1701 case Update_SetBounds:
1702 free(msg->wParam);
1703 break;
1704
1705 case Update_Synchronize:
1706 break;
1707
1708 case Update_DesktopResize:
1709 break;
1710
1711 case Update_BitmapUpdate:
1712 {
1713 BITMAP_UPDATE* wParam = (BITMAP_UPDATE*)msg->wParam;
1714 free_bitmap_update(context, wParam);
1715 }
1716 break;
1717
1718 case Update_Palette:
1719 {
1720 PALETTE_UPDATE* palette = (PALETTE_UPDATE*)msg->wParam;
1721 free_palette_update(context, palette);
1722 }
1723 break;
1724
1725 case Update_PlaySound:
1726 free(msg->wParam);
1727 break;
1728
1729 case Update_RefreshRect:
1730 free(msg->lParam);
1731 break;
1732
1733 case Update_SuppressOutput:
1734 free(msg->lParam);
1735 break;
1736
1737 case Update_SurfaceCommand:
1738 {
1739 wStream* s = (wStream*)msg->wParam;
1740 Stream_Free(s, TRUE);
1741 }
1742 break;
1743
1744 case Update_SurfaceBits:
1745 {
1746 SURFACE_BITS_COMMAND* wParam = (SURFACE_BITS_COMMAND*)msg->wParam;
1747 free_surface_bits_command(context, wParam);
1748 }
1749 break;
1750
1751 case Update_SurfaceFrameMarker:
1752 free(msg->wParam);
1753 break;
1754
1755 case Update_SurfaceFrameAcknowledge:
1756 case Update_SetKeyboardIndicators:
1757 case Update_SetKeyboardImeStatus:
1758 break;
1759
1760 default:
1761 return FALSE;
1762 }
1763
1764 return TRUE;
1765}
1766
1767static BOOL update_message_process_update_class(rdpUpdateProxy* proxy, wMessage* msg, int type)
1768{
1769 BOOL rc = FALSE;
1770
1771 if (!proxy || !msg)
1772 return FALSE;
1773
1774 switch (type)
1775 {
1776 case Update_BeginPaint:
1777 rc = IFCALLRESULT(TRUE, proxy->BeginPaint, msg->context);
1778 break;
1779
1780 case Update_EndPaint:
1781 rc = IFCALLRESULT(TRUE, proxy->EndPaint, msg->context);
1782 break;
1783
1784 case Update_SetBounds:
1785 rc = IFCALLRESULT(TRUE, proxy->SetBounds, msg->context, (rdpBounds*)msg->wParam);
1786 break;
1787
1788 case Update_Synchronize:
1789 rc = IFCALLRESULT(TRUE, proxy->Synchronize, msg->context);
1790 break;
1791
1792 case Update_DesktopResize:
1793 rc = IFCALLRESULT(TRUE, proxy->DesktopResize, msg->context);
1794 break;
1795
1796 case Update_BitmapUpdate:
1797 rc = IFCALLRESULT(TRUE, proxy->BitmapUpdate, msg->context, (BITMAP_UPDATE*)msg->wParam);
1798 break;
1799
1800 case Update_Palette:
1801 rc = IFCALLRESULT(TRUE, proxy->Palette, msg->context, (PALETTE_UPDATE*)msg->wParam);
1802 break;
1803
1804 case Update_PlaySound:
1805 rc =
1806 IFCALLRESULT(TRUE, proxy->PlaySound, msg->context, (PLAY_SOUND_UPDATE*)msg->wParam);
1807 break;
1808
1809 case Update_RefreshRect:
1810 rc = IFCALLRESULT(TRUE, proxy->RefreshRect, msg->context, (BYTE)(size_t)msg->wParam,
1811 (RECTANGLE_16*)msg->lParam);
1812 break;
1813
1814 case Update_SuppressOutput:
1815 rc = IFCALLRESULT(TRUE, proxy->SuppressOutput, msg->context, (BYTE)(size_t)msg->wParam,
1816 (RECTANGLE_16*)msg->lParam);
1817 break;
1818
1819 case Update_SurfaceCommand:
1820 rc = IFCALLRESULT(TRUE, proxy->SurfaceCommand, msg->context, (wStream*)msg->wParam);
1821 break;
1822
1823 case Update_SurfaceBits:
1824 rc = IFCALLRESULT(TRUE, proxy->SurfaceBits, msg->context,
1825 (SURFACE_BITS_COMMAND*)msg->wParam);
1826 break;
1827
1828 case Update_SurfaceFrameMarker:
1829 rc = IFCALLRESULT(TRUE, proxy->SurfaceFrameMarker, msg->context,
1830 (SURFACE_FRAME_MARKER*)msg->wParam);
1831 break;
1832
1833 case Update_SurfaceFrameAcknowledge:
1834 rc = IFCALLRESULT(TRUE, proxy->SurfaceFrameAcknowledge, msg->context,
1835 (UINT32)(size_t)msg->wParam);
1836 break;
1837
1838 case Update_SetKeyboardIndicators:
1839 rc = IFCALLRESULT(TRUE, proxy->SetKeyboardIndicators, msg->context,
1840 (UINT16)(size_t)msg->wParam);
1841 break;
1842
1843 case Update_SetKeyboardImeStatus:
1844 {
1845 const UINT16 imeId = ((size_t)msg->wParam) >> 16 & 0xFFFF;
1846 const UINT32 imeState = ((size_t)msg->wParam) & 0xFFFF;
1847 const UINT32 imeConvMode = ((size_t)msg->lParam) & 0xFFFFFFFFUL;
1848 rc = IFCALLRESULT(TRUE, proxy->SetKeyboardImeStatus, msg->context, imeId, imeState,
1849 imeConvMode);
1850 }
1851 break;
1852
1853 default:
1854 break;
1855 }
1856
1857 return rc;
1858}
1859
1860static BOOL update_message_free_primary_update_class(wMessage* msg, int type)
1861{
1862 if (!msg)
1863 return FALSE;
1864
1865 switch (type)
1866 {
1867 case PrimaryUpdate_DstBlt:
1868 free(msg->wParam);
1869 break;
1870
1871 case PrimaryUpdate_PatBlt:
1872 free(msg->wParam);
1873 break;
1874
1875 case PrimaryUpdate_ScrBlt:
1876 free(msg->wParam);
1877 break;
1878
1879 case PrimaryUpdate_OpaqueRect:
1880 free(msg->wParam);
1881 break;
1882
1883 case PrimaryUpdate_DrawNineGrid:
1884 free(msg->wParam);
1885 break;
1886
1887 case PrimaryUpdate_MultiDstBlt:
1888 free(msg->wParam);
1889 break;
1890
1891 case PrimaryUpdate_MultiPatBlt:
1892 free(msg->wParam);
1893 break;
1894
1895 case PrimaryUpdate_MultiScrBlt:
1896 free(msg->wParam);
1897 break;
1898
1899 case PrimaryUpdate_MultiOpaqueRect:
1900 free(msg->wParam);
1901 break;
1902
1903 case PrimaryUpdate_MultiDrawNineGrid:
1904 free(msg->wParam);
1905 break;
1906
1907 case PrimaryUpdate_LineTo:
1908 free(msg->wParam);
1909 break;
1910
1911 case PrimaryUpdate_Polyline:
1912 {
1913 POLYLINE_ORDER* wParam = (POLYLINE_ORDER*)msg->wParam;
1914 free(wParam->points);
1915 free(wParam);
1916 }
1917 break;
1918
1919 case PrimaryUpdate_MemBlt:
1920 free(msg->wParam);
1921 break;
1922
1923 case PrimaryUpdate_Mem3Blt:
1924 free(msg->wParam);
1925 break;
1926
1927 case PrimaryUpdate_SaveBitmap:
1928 free(msg->wParam);
1929 break;
1930
1931 case PrimaryUpdate_GlyphIndex:
1932 free(msg->wParam);
1933 break;
1934
1935 case PrimaryUpdate_FastIndex:
1936 free(msg->wParam);
1937 break;
1938
1939 case PrimaryUpdate_FastGlyph:
1940 {
1941 FAST_GLYPH_ORDER* wParam = (FAST_GLYPH_ORDER*)msg->wParam;
1942 free(wParam->glyphData.aj);
1943 free(wParam);
1944 }
1945 break;
1946
1947 case PrimaryUpdate_PolygonSC:
1948 {
1949 POLYGON_SC_ORDER* wParam = (POLYGON_SC_ORDER*)msg->wParam;
1950 free(wParam->points);
1951 free(wParam);
1952 }
1953 break;
1954
1955 case PrimaryUpdate_PolygonCB:
1956 {
1957 POLYGON_CB_ORDER* wParam = (POLYGON_CB_ORDER*)msg->wParam;
1958 free(wParam->points);
1959 free(wParam);
1960 }
1961 break;
1962
1963 case PrimaryUpdate_EllipseSC:
1964 free(msg->wParam);
1965 break;
1966
1967 case PrimaryUpdate_EllipseCB:
1968 free(msg->wParam);
1969 break;
1970
1971 default:
1972 return FALSE;
1973 }
1974
1975 return TRUE;
1976}
1977
1978static BOOL update_message_process_primary_update_class(rdpUpdateProxy* proxy, wMessage* msg,
1979 int type)
1980{
1981 if (!proxy || !msg)
1982 return FALSE;
1983
1984 switch (type)
1985 {
1986 case PrimaryUpdate_DstBlt:
1987 return IFCALLRESULT(TRUE, proxy->DstBlt, msg->context, (DSTBLT_ORDER*)msg->wParam);
1988
1989 case PrimaryUpdate_PatBlt:
1990 return IFCALLRESULT(TRUE, proxy->PatBlt, msg->context, (PATBLT_ORDER*)msg->wParam);
1991
1992 case PrimaryUpdate_ScrBlt:
1993 return IFCALLRESULT(TRUE, proxy->ScrBlt, msg->context, (SCRBLT_ORDER*)msg->wParam);
1994
1995 case PrimaryUpdate_OpaqueRect:
1996 return IFCALLRESULT(TRUE, proxy->OpaqueRect, msg->context,
1997 (OPAQUE_RECT_ORDER*)msg->wParam);
1998
1999 case PrimaryUpdate_DrawNineGrid:
2000 return IFCALLRESULT(TRUE, proxy->DrawNineGrid, msg->context,
2001 (DRAW_NINE_GRID_ORDER*)msg->wParam);
2002
2003 case PrimaryUpdate_MultiDstBlt:
2004 return IFCALLRESULT(TRUE, proxy->MultiDstBlt, msg->context,
2005 (MULTI_DSTBLT_ORDER*)msg->wParam);
2006
2007 case PrimaryUpdate_MultiPatBlt:
2008 return IFCALLRESULT(TRUE, proxy->MultiPatBlt, msg->context,
2009 (MULTI_PATBLT_ORDER*)msg->wParam);
2010
2011 case PrimaryUpdate_MultiScrBlt:
2012 return IFCALLRESULT(TRUE, proxy->MultiScrBlt, msg->context,
2013 (MULTI_SCRBLT_ORDER*)msg->wParam);
2014
2015 case PrimaryUpdate_MultiOpaqueRect:
2016 return IFCALLRESULT(TRUE, proxy->MultiOpaqueRect, msg->context,
2017 (MULTI_OPAQUE_RECT_ORDER*)msg->wParam);
2018
2019 case PrimaryUpdate_MultiDrawNineGrid:
2020 return IFCALLRESULT(TRUE, proxy->MultiDrawNineGrid, msg->context,
2021 (MULTI_DRAW_NINE_GRID_ORDER*)msg->wParam);
2022
2023 case PrimaryUpdate_LineTo:
2024 return IFCALLRESULT(TRUE, proxy->LineTo, msg->context, (LINE_TO_ORDER*)msg->wParam);
2025
2026 case PrimaryUpdate_Polyline:
2027 return IFCALLRESULT(TRUE, proxy->Polyline, msg->context, (POLYLINE_ORDER*)msg->wParam);
2028
2029 case PrimaryUpdate_MemBlt:
2030 return IFCALLRESULT(TRUE, proxy->MemBlt, msg->context, (MEMBLT_ORDER*)msg->wParam);
2031
2032 case PrimaryUpdate_Mem3Blt:
2033 return IFCALLRESULT(TRUE, proxy->Mem3Blt, msg->context, (MEM3BLT_ORDER*)msg->wParam);
2034
2035 case PrimaryUpdate_SaveBitmap:
2036 return IFCALLRESULT(TRUE, proxy->SaveBitmap, msg->context,
2037 (SAVE_BITMAP_ORDER*)msg->wParam);
2038
2039 case PrimaryUpdate_GlyphIndex:
2040 return IFCALLRESULT(TRUE, proxy->GlyphIndex, msg->context,
2041 (GLYPH_INDEX_ORDER*)msg->wParam);
2042
2043 case PrimaryUpdate_FastIndex:
2044 return IFCALLRESULT(TRUE, proxy->FastIndex, msg->context,
2045 (FAST_INDEX_ORDER*)msg->wParam);
2046
2047 case PrimaryUpdate_FastGlyph:
2048 return IFCALLRESULT(TRUE, proxy->FastGlyph, msg->context,
2049 (FAST_GLYPH_ORDER*)msg->wParam);
2050
2051 case PrimaryUpdate_PolygonSC:
2052 return IFCALLRESULT(TRUE, proxy->PolygonSC, msg->context,
2053 (POLYGON_SC_ORDER*)msg->wParam);
2054
2055 case PrimaryUpdate_PolygonCB:
2056 return IFCALLRESULT(TRUE, proxy->PolygonCB, msg->context,
2057 (POLYGON_CB_ORDER*)msg->wParam);
2058
2059 case PrimaryUpdate_EllipseSC:
2060 return IFCALLRESULT(TRUE, proxy->EllipseSC, msg->context,
2061 (ELLIPSE_SC_ORDER*)msg->wParam);
2062
2063 case PrimaryUpdate_EllipseCB:
2064 return IFCALLRESULT(TRUE, proxy->EllipseCB, msg->context,
2065 (ELLIPSE_CB_ORDER*)msg->wParam);
2066
2067 default:
2068 return FALSE;
2069 }
2070}
2071
2072static BOOL update_message_free_secondary_update_class(wMessage* msg, int type)
2073{
2074 rdpContext* context = NULL;
2075
2076 if (!msg)
2077 return FALSE;
2078
2079 context = msg->context;
2080
2081 switch (type)
2082 {
2083 case SecondaryUpdate_CacheBitmap:
2084 {
2085 CACHE_BITMAP_ORDER* wParam = (CACHE_BITMAP_ORDER*)msg->wParam;
2086 free_cache_bitmap_order(context, wParam);
2087 }
2088 break;
2089
2090 case SecondaryUpdate_CacheBitmapV2:
2091 {
2092 CACHE_BITMAP_V2_ORDER* wParam = (CACHE_BITMAP_V2_ORDER*)msg->wParam;
2093 free_cache_bitmap_v2_order(context, wParam);
2094 }
2095 break;
2096
2097 case SecondaryUpdate_CacheBitmapV3:
2098 {
2099 CACHE_BITMAP_V3_ORDER* wParam = (CACHE_BITMAP_V3_ORDER*)msg->wParam;
2100 free_cache_bitmap_v3_order(context, wParam);
2101 }
2102 break;
2103
2104 case SecondaryUpdate_CacheColorTable:
2105 {
2106 CACHE_COLOR_TABLE_ORDER* wParam = (CACHE_COLOR_TABLE_ORDER*)msg->wParam;
2107 free_cache_color_table_order(context, wParam);
2108 }
2109 break;
2110
2111 case SecondaryUpdate_CacheGlyph:
2112 {
2113 CACHE_GLYPH_ORDER* wParam = (CACHE_GLYPH_ORDER*)msg->wParam;
2114 free_cache_glyph_order(context, wParam);
2115 }
2116 break;
2117
2118 case SecondaryUpdate_CacheGlyphV2:
2119 {
2120 CACHE_GLYPH_V2_ORDER* wParam = (CACHE_GLYPH_V2_ORDER*)msg->wParam;
2121 free_cache_glyph_v2_order(context, wParam);
2122 }
2123 break;
2124
2125 case SecondaryUpdate_CacheBrush:
2126 {
2127 CACHE_BRUSH_ORDER* wParam = (CACHE_BRUSH_ORDER*)msg->wParam;
2128 free_cache_brush_order(context, wParam);
2129 }
2130 break;
2131
2132 default:
2133 return FALSE;
2134 }
2135
2136 return TRUE;
2137}
2138
2139static BOOL update_message_process_secondary_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2140 int type)
2141{
2142 if (!proxy || !msg)
2143 return FALSE;
2144
2145 switch (type)
2146 {
2147 case SecondaryUpdate_CacheBitmap:
2148 return IFCALLRESULT(TRUE, proxy->CacheBitmap, msg->context,
2149 (CACHE_BITMAP_ORDER*)msg->wParam);
2150
2151 case SecondaryUpdate_CacheBitmapV2:
2152 return IFCALLRESULT(TRUE, proxy->CacheBitmapV2, msg->context,
2153 (CACHE_BITMAP_V2_ORDER*)msg->wParam);
2154
2155 case SecondaryUpdate_CacheBitmapV3:
2156 return IFCALLRESULT(TRUE, proxy->CacheBitmapV3, msg->context,
2157 (CACHE_BITMAP_V3_ORDER*)msg->wParam);
2158
2159 case SecondaryUpdate_CacheColorTable:
2160 return IFCALLRESULT(TRUE, proxy->CacheColorTable, msg->context,
2161 (CACHE_COLOR_TABLE_ORDER*)msg->wParam);
2162
2163 case SecondaryUpdate_CacheGlyph:
2164 return IFCALLRESULT(TRUE, proxy->CacheGlyph, msg->context,
2165 (CACHE_GLYPH_ORDER*)msg->wParam);
2166
2167 case SecondaryUpdate_CacheGlyphV2:
2168 return IFCALLRESULT(TRUE, proxy->CacheGlyphV2, msg->context,
2169 (CACHE_GLYPH_V2_ORDER*)msg->wParam);
2170
2171 case SecondaryUpdate_CacheBrush:
2172 return IFCALLRESULT(TRUE, proxy->CacheBrush, msg->context,
2173 (CACHE_BRUSH_ORDER*)msg->wParam);
2174
2175 default:
2176 return FALSE;
2177 }
2178}
2179
2180static BOOL update_message_free_altsec_update_class(wMessage* msg, int type)
2181{
2182 if (!msg)
2183 return FALSE;
2184
2185 switch (type)
2186 {
2187 case AltSecUpdate_CreateOffscreenBitmap:
2188 {
2189 CREATE_OFFSCREEN_BITMAP_ORDER* wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*)msg->wParam;
2190 free(wParam->deleteList.indices);
2191 free(wParam);
2192 }
2193 break;
2194
2195 case AltSecUpdate_SwitchSurface:
2196 free(msg->wParam);
2197 break;
2198
2199 case AltSecUpdate_CreateNineGridBitmap:
2200 free(msg->wParam);
2201 break;
2202
2203 case AltSecUpdate_FrameMarker:
2204 free(msg->wParam);
2205 break;
2206
2207 case AltSecUpdate_StreamBitmapFirst:
2208 free(msg->wParam);
2209 break;
2210
2211 case AltSecUpdate_StreamBitmapNext:
2212 free(msg->wParam);
2213 break;
2214
2215 case AltSecUpdate_DrawGdiPlusFirst:
2216 free(msg->wParam);
2217 break;
2218
2219 case AltSecUpdate_DrawGdiPlusNext:
2220 free(msg->wParam);
2221 break;
2222
2223 case AltSecUpdate_DrawGdiPlusEnd:
2224 free(msg->wParam);
2225 break;
2226
2227 case AltSecUpdate_DrawGdiPlusCacheFirst:
2228 free(msg->wParam);
2229 break;
2230
2231 case AltSecUpdate_DrawGdiPlusCacheNext:
2232 free(msg->wParam);
2233 break;
2234
2235 case AltSecUpdate_DrawGdiPlusCacheEnd:
2236 free(msg->wParam);
2237 break;
2238
2239 default:
2240 return FALSE;
2241 }
2242
2243 return TRUE;
2244}
2245
2246static BOOL update_message_process_altsec_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2247 int type)
2248{
2249 if (!proxy || !msg)
2250 return FALSE;
2251
2252 switch (type)
2253 {
2254 case AltSecUpdate_CreateOffscreenBitmap:
2255 return IFCALLRESULT(TRUE, proxy->CreateOffscreenBitmap, msg->context,
2256 (CREATE_OFFSCREEN_BITMAP_ORDER*)msg->wParam);
2257
2258 case AltSecUpdate_SwitchSurface:
2259 return IFCALLRESULT(TRUE, proxy->SwitchSurface, msg->context,
2260 (SWITCH_SURFACE_ORDER*)msg->wParam);
2261
2262 case AltSecUpdate_CreateNineGridBitmap:
2263 return IFCALLRESULT(TRUE, proxy->CreateNineGridBitmap, msg->context,
2264 (CREATE_NINE_GRID_BITMAP_ORDER*)msg->wParam);
2265
2266 case AltSecUpdate_FrameMarker:
2267 return IFCALLRESULT(TRUE, proxy->FrameMarker, msg->context,
2268 (FRAME_MARKER_ORDER*)msg->wParam);
2269
2270 case AltSecUpdate_StreamBitmapFirst:
2271 return IFCALLRESULT(TRUE, proxy->StreamBitmapFirst, msg->context,
2272 (STREAM_BITMAP_FIRST_ORDER*)msg->wParam);
2273
2274 case AltSecUpdate_StreamBitmapNext:
2275 return IFCALLRESULT(TRUE, proxy->StreamBitmapNext, msg->context,
2276 (STREAM_BITMAP_NEXT_ORDER*)msg->wParam);
2277
2278 case AltSecUpdate_DrawGdiPlusFirst:
2279 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusFirst, msg->context,
2280 (DRAW_GDIPLUS_FIRST_ORDER*)msg->wParam);
2281
2282 case AltSecUpdate_DrawGdiPlusNext:
2283 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusNext, msg->context,
2284 (DRAW_GDIPLUS_NEXT_ORDER*)msg->wParam);
2285
2286 case AltSecUpdate_DrawGdiPlusEnd:
2287 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusEnd, msg->context,
2288 (DRAW_GDIPLUS_END_ORDER*)msg->wParam);
2289
2290 case AltSecUpdate_DrawGdiPlusCacheFirst:
2291 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheFirst, msg->context,
2292 (DRAW_GDIPLUS_CACHE_FIRST_ORDER*)msg->wParam);
2293
2294 case AltSecUpdate_DrawGdiPlusCacheNext:
2295 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheNext, msg->context,
2296 (DRAW_GDIPLUS_CACHE_NEXT_ORDER*)msg->wParam);
2297
2298 case AltSecUpdate_DrawGdiPlusCacheEnd:
2299 return IFCALLRESULT(TRUE, proxy->DrawGdiPlusCacheEnd, msg->context,
2300 (DRAW_GDIPLUS_CACHE_END_ORDER*)msg->wParam);
2301
2302 default:
2303 return FALSE;
2304 }
2305}
2306
2307static BOOL update_message_free_window_update_class(wMessage* msg, int type)
2308{
2309 if (!msg)
2310 return FALSE;
2311
2312 switch (type)
2313 {
2314 case WindowUpdate_WindowCreate:
2315 free(msg->wParam);
2316 free(msg->lParam);
2317 break;
2318
2319 case WindowUpdate_WindowUpdate:
2320 free(msg->wParam);
2321 free(msg->lParam);
2322 break;
2323
2324 case WindowUpdate_WindowIcon:
2325 {
2326 WINDOW_ORDER_INFO* orderInfo = (WINDOW_ORDER_INFO*)msg->wParam;
2327 WINDOW_ICON_ORDER* windowIcon = (WINDOW_ICON_ORDER*)msg->lParam;
2328
2329 if (windowIcon->iconInfo->cbBitsColor > 0)
2330 {
2331 free(windowIcon->iconInfo->bitsColor);
2332 }
2333
2334 if (windowIcon->iconInfo->cbBitsMask > 0)
2335 {
2336 free(windowIcon->iconInfo->bitsMask);
2337 }
2338
2339 if (windowIcon->iconInfo->cbColorTable > 0)
2340 {
2341 free(windowIcon->iconInfo->colorTable);
2342 }
2343
2344 free(orderInfo);
2345 free(windowIcon->iconInfo);
2346 free(windowIcon);
2347 }
2348 break;
2349
2350 case WindowUpdate_WindowCachedIcon:
2351 free(msg->wParam);
2352 free(msg->lParam);
2353 break;
2354
2355 case WindowUpdate_WindowDelete:
2356 free(msg->wParam);
2357 break;
2358
2359 case WindowUpdate_NotifyIconCreate:
2360 free(msg->wParam);
2361 free(msg->lParam);
2362 break;
2363
2364 case WindowUpdate_NotifyIconUpdate:
2365 free(msg->wParam);
2366 free(msg->lParam);
2367 break;
2368
2369 case WindowUpdate_NotifyIconDelete:
2370 free(msg->wParam);
2371 break;
2372
2373 case WindowUpdate_MonitoredDesktop:
2374 {
2375 MONITORED_DESKTOP_ORDER* lParam = (MONITORED_DESKTOP_ORDER*)msg->lParam;
2376 free(msg->wParam);
2377 free(lParam->windowIds);
2378 free(lParam);
2379 }
2380 break;
2381
2382 case WindowUpdate_NonMonitoredDesktop:
2383 free(msg->wParam);
2384 break;
2385
2386 default:
2387 return FALSE;
2388 }
2389
2390 return TRUE;
2391}
2392
2393static BOOL update_message_process_window_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2394 int type)
2395{
2396 if (!proxy || !msg)
2397 return FALSE;
2398
2399 switch (type)
2400 {
2401 case WindowUpdate_WindowCreate:
2402 return IFCALLRESULT(TRUE, proxy->WindowCreate, msg->context,
2403 (WINDOW_ORDER_INFO*)msg->wParam, (WINDOW_STATE_ORDER*)msg->lParam);
2404
2405 case WindowUpdate_WindowUpdate:
2406 return IFCALLRESULT(TRUE, proxy->WindowCreate, msg->context,
2407 (WINDOW_ORDER_INFO*)msg->wParam, (WINDOW_STATE_ORDER*)msg->lParam);
2408
2409 case WindowUpdate_WindowIcon:
2410 {
2411 WINDOW_ORDER_INFO* orderInfo = (WINDOW_ORDER_INFO*)msg->wParam;
2412 WINDOW_ICON_ORDER* windowIcon = (WINDOW_ICON_ORDER*)msg->lParam;
2413 return IFCALLRESULT(TRUE, proxy->WindowIcon, msg->context, orderInfo, windowIcon);
2414 }
2415
2416 case WindowUpdate_WindowCachedIcon:
2417 return IFCALLRESULT(TRUE, proxy->WindowCachedIcon, msg->context,
2418 (WINDOW_ORDER_INFO*)msg->wParam,
2419 (WINDOW_CACHED_ICON_ORDER*)msg->lParam);
2420
2421 case WindowUpdate_WindowDelete:
2422 return IFCALLRESULT(TRUE, proxy->WindowDelete, msg->context,
2423 (WINDOW_ORDER_INFO*)msg->wParam);
2424
2425 case WindowUpdate_NotifyIconCreate:
2426 return IFCALLRESULT(TRUE, proxy->NotifyIconCreate, msg->context,
2427 (WINDOW_ORDER_INFO*)msg->wParam,
2428 (NOTIFY_ICON_STATE_ORDER*)msg->lParam);
2429
2430 case WindowUpdate_NotifyIconUpdate:
2431 return IFCALLRESULT(TRUE, proxy->NotifyIconUpdate, msg->context,
2432 (WINDOW_ORDER_INFO*)msg->wParam,
2433 (NOTIFY_ICON_STATE_ORDER*)msg->lParam);
2434
2435 case WindowUpdate_NotifyIconDelete:
2436 return IFCALLRESULT(TRUE, proxy->NotifyIconDelete, msg->context,
2437 (WINDOW_ORDER_INFO*)msg->wParam);
2438
2439 case WindowUpdate_MonitoredDesktop:
2440 return IFCALLRESULT(TRUE, proxy->MonitoredDesktop, msg->context,
2441 (WINDOW_ORDER_INFO*)msg->wParam,
2442 (MONITORED_DESKTOP_ORDER*)msg->lParam);
2443
2444 case WindowUpdate_NonMonitoredDesktop:
2445 return IFCALLRESULT(TRUE, proxy->NonMonitoredDesktop, msg->context,
2446 (WINDOW_ORDER_INFO*)msg->wParam);
2447
2448 default:
2449 return FALSE;
2450 }
2451}
2452
2453static BOOL update_message_free_pointer_update_class(wMessage* msg, int type)
2454{
2455 rdpContext* context = NULL;
2456
2457 if (!msg)
2458 return FALSE;
2459
2460 context = msg->context;
2461
2462 switch (type)
2463 {
2464 case PointerUpdate_PointerPosition:
2465 {
2466 POINTER_POSITION_UPDATE* wParam = (POINTER_POSITION_UPDATE*)msg->wParam;
2467 free_pointer_position_update(context, wParam);
2468 }
2469 break;
2470
2471 case PointerUpdate_PointerSystem:
2472 {
2473 POINTER_SYSTEM_UPDATE* wParam = (POINTER_SYSTEM_UPDATE*)msg->wParam;
2474 free_pointer_system_update(context, wParam);
2475 }
2476 break;
2477
2478 case PointerUpdate_PointerCached:
2479 {
2480 POINTER_CACHED_UPDATE* wParam = (POINTER_CACHED_UPDATE*)msg->wParam;
2481 free_pointer_cached_update(context, wParam);
2482 }
2483 break;
2484
2485 case PointerUpdate_PointerColor:
2486 {
2487 POINTER_COLOR_UPDATE* wParam = (POINTER_COLOR_UPDATE*)msg->wParam;
2488 free_pointer_color_update(context, wParam);
2489 }
2490 break;
2491
2492 case PointerUpdate_PointerNew:
2493 {
2494 POINTER_NEW_UPDATE* wParam = (POINTER_NEW_UPDATE*)msg->wParam;
2495 free_pointer_new_update(context, wParam);
2496 }
2497 break;
2498
2499 default:
2500 return FALSE;
2501 }
2502
2503 return TRUE;
2504}
2505
2506static BOOL update_message_process_pointer_update_class(rdpUpdateProxy* proxy, wMessage* msg,
2507 int type)
2508{
2509 if (!proxy || !msg)
2510 return FALSE;
2511
2512 switch (type)
2513 {
2514 case PointerUpdate_PointerPosition:
2515 return IFCALLRESULT(TRUE, proxy->PointerPosition, msg->context,
2516 (POINTER_POSITION_UPDATE*)msg->wParam);
2517
2518 case PointerUpdate_PointerSystem:
2519 return IFCALLRESULT(TRUE, proxy->PointerSystem, msg->context,
2520 (POINTER_SYSTEM_UPDATE*)msg->wParam);
2521
2522 case PointerUpdate_PointerColor:
2523 return IFCALLRESULT(TRUE, proxy->PointerColor, msg->context,
2524 (POINTER_COLOR_UPDATE*)msg->wParam);
2525
2526 case PointerUpdate_PointerNew:
2527 return IFCALLRESULT(TRUE, proxy->PointerNew, msg->context,
2528 (POINTER_NEW_UPDATE*)msg->wParam);
2529
2530 case PointerUpdate_PointerCached:
2531 return IFCALLRESULT(TRUE, proxy->PointerCached, msg->context,
2532 (POINTER_CACHED_UPDATE*)msg->wParam);
2533
2534 default:
2535 return FALSE;
2536 }
2537}
2538
2539static BOOL update_message_free_class(wMessage* msg, int msgClass, int msgType)
2540{
2541 BOOL status = FALSE;
2542
2543 switch (msgClass)
2544 {
2545 case Update_Class:
2546 status = update_message_free_update_class(msg, msgType);
2547 break;
2548
2549 case PrimaryUpdate_Class:
2550 status = update_message_free_primary_update_class(msg, msgType);
2551 break;
2552
2553 case SecondaryUpdate_Class:
2554 status = update_message_free_secondary_update_class(msg, msgType);
2555 break;
2556
2557 case AltSecUpdate_Class:
2558 status = update_message_free_altsec_update_class(msg, msgType);
2559 break;
2560
2561 case WindowUpdate_Class:
2562 status = update_message_free_window_update_class(msg, msgType);
2563 break;
2564
2565 case PointerUpdate_Class:
2566 status = update_message_free_pointer_update_class(msg, msgType);
2567 break;
2568
2569 default:
2570 break;
2571 }
2572
2573 if (!status)
2574 WLog_ERR(TAG, "Unknown message: class: %d type: %d", msgClass, msgType);
2575
2576 return status;
2577}
2578
2579static int update_message_process_class(rdpUpdateProxy* proxy, wMessage* msg, int msgClass,
2580 int msgType)
2581{
2582 BOOL status = FALSE;
2583
2584 switch (msgClass)
2585 {
2586 case Update_Class:
2587 status = update_message_process_update_class(proxy, msg, msgType);
2588 break;
2589
2590 case PrimaryUpdate_Class:
2591 status = update_message_process_primary_update_class(proxy, msg, msgType);
2592 break;
2593
2594 case SecondaryUpdate_Class:
2595 status = update_message_process_secondary_update_class(proxy, msg, msgType);
2596 break;
2597
2598 case AltSecUpdate_Class:
2599 status = update_message_process_altsec_update_class(proxy, msg, msgType);
2600 break;
2601
2602 case WindowUpdate_Class:
2603 status = update_message_process_window_update_class(proxy, msg, msgType);
2604 break;
2605
2606 case PointerUpdate_Class:
2607 status = update_message_process_pointer_update_class(proxy, msg, msgType);
2608 break;
2609
2610 default:
2611 status = FALSE;
2612 break;
2613 }
2614
2615 if (!status)
2616 {
2617 WLog_ERR(TAG, "message: class: %d type: %d failed", msgClass, msgType);
2618 return -1;
2619 }
2620
2621 return 0;
2622}
2623
2624int update_message_queue_process_message(rdpUpdate* update, wMessage* message)
2625{
2626 int status = 0;
2627 int msgClass = 0;
2628 int msgType = 0;
2629 rdp_update_internal* up = update_cast(update);
2630
2631 if (!update || !message)
2632 return -1;
2633
2634 if (message->id == WMQ_QUIT)
2635 return 0;
2636
2637 msgClass = GetMessageClass(message->id);
2638 msgType = GetMessageType(message->id);
2639 status = update_message_process_class(up->proxy, message, msgClass, msgType);
2640 update_message_free_class(message, msgClass, msgType);
2641
2642 if (status < 0)
2643 return -1;
2644
2645 return 1;
2646}
2647
2648int update_message_queue_free_message(wMessage* message)
2649{
2650 int msgClass = 0;
2651 int msgType = 0;
2652
2653 if (!message)
2654 return -1;
2655
2656 if (message->id == WMQ_QUIT)
2657 return 0;
2658
2659 msgClass = GetMessageClass(message->id);
2660 msgType = GetMessageType(message->id);
2661 return update_message_free_class(message, msgClass, msgType);
2662}
2663
2664int update_message_queue_process_pending_messages(rdpUpdate* update)
2665{
2666 int status = 1;
2667 wMessage message = { 0 };
2668 rdp_update_internal* up = update_cast(update);
2669
2670 wMessageQueue* queue = up->queue;
2671
2672 while (MessageQueue_Peek(queue, &message, TRUE))
2673 {
2674 status = update_message_queue_process_message(update, &message);
2675
2676 if (!status)
2677 break;
2678 }
2679
2680 return status;
2681}
2682
2683static BOOL update_message_register_interface(rdpUpdateProxy* message, rdpUpdate* update)
2684{
2685 rdpPrimaryUpdate* primary = NULL;
2686 rdpSecondaryUpdate* secondary = NULL;
2687 rdpAltSecUpdate* altsec = NULL;
2688 rdpWindowUpdate* window = NULL;
2689 rdpPointerUpdate* pointer = NULL;
2690
2691 if (!message || !update)
2692 return FALSE;
2693
2694 primary = update->primary;
2695 secondary = update->secondary;
2696 altsec = update->altsec;
2697 window = update->window;
2698 pointer = update->pointer;
2699
2700 if (!primary || !secondary || !altsec || !window || !pointer)
2701 return FALSE;
2702
2703 /* Update */
2704 message->BeginPaint = update->BeginPaint;
2705 message->EndPaint = update->EndPaint;
2706 message->SetBounds = update->SetBounds;
2707 message->Synchronize = update->Synchronize;
2708 message->DesktopResize = update->DesktopResize;
2709 message->BitmapUpdate = update->BitmapUpdate;
2710 message->Palette = update->Palette;
2711 message->PlaySound = update->PlaySound;
2712 message->SetKeyboardIndicators = update->SetKeyboardIndicators;
2713 message->SetKeyboardImeStatus = update->SetKeyboardImeStatus;
2714 message->RefreshRect = update->RefreshRect;
2715 message->SuppressOutput = update->SuppressOutput;
2716 message->SurfaceCommand = update->SurfaceCommand;
2717 message->SurfaceBits = update->SurfaceBits;
2718 message->SurfaceFrameMarker = update->SurfaceFrameMarker;
2719 message->SurfaceFrameAcknowledge = update->SurfaceFrameAcknowledge;
2720 update->BeginPaint = update_message_BeginPaint;
2721 update->EndPaint = update_message_EndPaint;
2722 update->SetBounds = update_message_SetBounds;
2723 update->Synchronize = update_message_Synchronize;
2724 update->DesktopResize = update_message_DesktopResize;
2725 update->BitmapUpdate = update_message_BitmapUpdate;
2726 update->Palette = update_message_Palette;
2727 update->PlaySound = update_message_PlaySound;
2728 update->SetKeyboardIndicators = update_message_SetKeyboardIndicators;
2729 update->SetKeyboardImeStatus = update_message_SetKeyboardImeStatus;
2730 update->RefreshRect = update_message_RefreshRect;
2731 update->SuppressOutput = update_message_SuppressOutput;
2732 update->SurfaceCommand = update_message_SurfaceCommand;
2733 update->SurfaceBits = update_message_SurfaceBits;
2734 update->SurfaceFrameMarker = update_message_SurfaceFrameMarker;
2735 update->SurfaceFrameAcknowledge = update_message_SurfaceFrameAcknowledge;
2736 /* Primary Update */
2737 message->DstBlt = primary->DstBlt;
2738 message->PatBlt = primary->PatBlt;
2739 message->ScrBlt = primary->ScrBlt;
2740 message->OpaqueRect = primary->OpaqueRect;
2741 message->DrawNineGrid = primary->DrawNineGrid;
2742 message->MultiDstBlt = primary->MultiDstBlt;
2743 message->MultiPatBlt = primary->MultiPatBlt;
2744 message->MultiScrBlt = primary->MultiScrBlt;
2745 message->MultiOpaqueRect = primary->MultiOpaqueRect;
2746 message->MultiDrawNineGrid = primary->MultiDrawNineGrid;
2747 message->LineTo = primary->LineTo;
2748 message->Polyline = primary->Polyline;
2749 message->MemBlt = primary->MemBlt;
2750 message->Mem3Blt = primary->Mem3Blt;
2751 message->SaveBitmap = primary->SaveBitmap;
2752 message->GlyphIndex = primary->GlyphIndex;
2753 message->FastIndex = primary->FastIndex;
2754 message->FastGlyph = primary->FastGlyph;
2755 message->PolygonSC = primary->PolygonSC;
2756 message->PolygonCB = primary->PolygonCB;
2757 message->EllipseSC = primary->EllipseSC;
2758 message->EllipseCB = primary->EllipseCB;
2759 primary->DstBlt = update_message_DstBlt;
2760 primary->PatBlt = update_message_PatBlt;
2761 primary->ScrBlt = update_message_ScrBlt;
2762 primary->OpaqueRect = update_message_OpaqueRect;
2763 primary->DrawNineGrid = update_message_DrawNineGrid;
2764 primary->MultiDstBlt = update_message_MultiDstBlt;
2765 primary->MultiPatBlt = update_message_MultiPatBlt;
2766 primary->MultiScrBlt = update_message_MultiScrBlt;
2767 primary->MultiOpaqueRect = update_message_MultiOpaqueRect;
2768 primary->MultiDrawNineGrid = update_message_MultiDrawNineGrid;
2769 primary->LineTo = update_message_LineTo;
2770 primary->Polyline = update_message_Polyline;
2771 primary->MemBlt = update_message_MemBlt;
2772 primary->Mem3Blt = update_message_Mem3Blt;
2773 primary->SaveBitmap = update_message_SaveBitmap;
2774 primary->GlyphIndex = update_message_GlyphIndex;
2775 primary->FastIndex = update_message_FastIndex;
2776 primary->FastGlyph = update_message_FastGlyph;
2777 primary->PolygonSC = update_message_PolygonSC;
2778 primary->PolygonCB = update_message_PolygonCB;
2779 primary->EllipseSC = update_message_EllipseSC;
2780 primary->EllipseCB = update_message_EllipseCB;
2781 /* Secondary Update */
2782 message->CacheBitmap = secondary->CacheBitmap;
2783 message->CacheBitmapV2 = secondary->CacheBitmapV2;
2784 message->CacheBitmapV3 = secondary->CacheBitmapV3;
2785 message->CacheColorTable = secondary->CacheColorTable;
2786 message->CacheGlyph = secondary->CacheGlyph;
2787 message->CacheGlyphV2 = secondary->CacheGlyphV2;
2788 message->CacheBrush = secondary->CacheBrush;
2789 secondary->CacheBitmap = update_message_CacheBitmap;
2790 secondary->CacheBitmapV2 = update_message_CacheBitmapV2;
2791 secondary->CacheBitmapV3 = update_message_CacheBitmapV3;
2792 secondary->CacheColorTable = update_message_CacheColorTable;
2793 secondary->CacheGlyph = update_message_CacheGlyph;
2794 secondary->CacheGlyphV2 = update_message_CacheGlyphV2;
2795 secondary->CacheBrush = update_message_CacheBrush;
2796 /* Alternate Secondary Update */
2797 message->CreateOffscreenBitmap = altsec->CreateOffscreenBitmap;
2798 message->SwitchSurface = altsec->SwitchSurface;
2799 message->CreateNineGridBitmap = altsec->CreateNineGridBitmap;
2800 message->FrameMarker = altsec->FrameMarker;
2801 message->StreamBitmapFirst = altsec->StreamBitmapFirst;
2802 message->StreamBitmapNext = altsec->StreamBitmapNext;
2803 message->DrawGdiPlusFirst = altsec->DrawGdiPlusFirst;
2804 message->DrawGdiPlusNext = altsec->DrawGdiPlusNext;
2805 message->DrawGdiPlusEnd = altsec->DrawGdiPlusEnd;
2806 message->DrawGdiPlusCacheFirst = altsec->DrawGdiPlusCacheFirst;
2807 message->DrawGdiPlusCacheNext = altsec->DrawGdiPlusCacheNext;
2808 message->DrawGdiPlusCacheEnd = altsec->DrawGdiPlusCacheEnd;
2809 altsec->CreateOffscreenBitmap = update_message_CreateOffscreenBitmap;
2810 altsec->SwitchSurface = update_message_SwitchSurface;
2811 altsec->CreateNineGridBitmap = update_message_CreateNineGridBitmap;
2812 altsec->FrameMarker = update_message_FrameMarker;
2813 altsec->StreamBitmapFirst = update_message_StreamBitmapFirst;
2814 altsec->StreamBitmapNext = update_message_StreamBitmapNext;
2815 altsec->DrawGdiPlusFirst = update_message_DrawGdiPlusFirst;
2816 altsec->DrawGdiPlusNext = update_message_DrawGdiPlusNext;
2817 altsec->DrawGdiPlusEnd = update_message_DrawGdiPlusEnd;
2818 altsec->DrawGdiPlusCacheFirst = update_message_DrawGdiPlusCacheFirst;
2819 altsec->DrawGdiPlusCacheNext = update_message_DrawGdiPlusCacheNext;
2820 altsec->DrawGdiPlusCacheEnd = update_message_DrawGdiPlusCacheEnd;
2821 /* Window Update */
2822 message->WindowCreate = window->WindowCreate;
2823 message->WindowUpdate = window->WindowUpdate;
2824 message->WindowIcon = window->WindowIcon;
2825 message->WindowCachedIcon = window->WindowCachedIcon;
2826 message->WindowDelete = window->WindowDelete;
2827 message->NotifyIconCreate = window->NotifyIconCreate;
2828 message->NotifyIconUpdate = window->NotifyIconUpdate;
2829 message->NotifyIconDelete = window->NotifyIconDelete;
2830 message->MonitoredDesktop = window->MonitoredDesktop;
2831 message->NonMonitoredDesktop = window->NonMonitoredDesktop;
2832 window->WindowCreate = update_message_WindowCreate;
2833 window->WindowUpdate = update_message_WindowUpdate;
2834 window->WindowIcon = update_message_WindowIcon;
2835 window->WindowCachedIcon = update_message_WindowCachedIcon;
2836 window->WindowDelete = update_message_WindowDelete;
2837 window->NotifyIconCreate = update_message_NotifyIconCreate;
2838 window->NotifyIconUpdate = update_message_NotifyIconUpdate;
2839 window->NotifyIconDelete = update_message_NotifyIconDelete;
2840 window->MonitoredDesktop = update_message_MonitoredDesktop;
2841 window->NonMonitoredDesktop = update_message_NonMonitoredDesktop;
2842 /* Pointer Update */
2843 message->PointerPosition = pointer->PointerPosition;
2844 message->PointerSystem = pointer->PointerSystem;
2845 message->PointerColor = pointer->PointerColor;
2846 message->PointerLarge = pointer->PointerLarge;
2847 message->PointerNew = pointer->PointerNew;
2848 message->PointerCached = pointer->PointerCached;
2849 pointer->PointerPosition = update_message_PointerPosition;
2850 pointer->PointerSystem = update_message_PointerSystem;
2851 pointer->PointerColor = update_message_PointerColor;
2852 pointer->PointerLarge = update_message_PointerLarge;
2853 pointer->PointerNew = update_message_PointerNew;
2854 pointer->PointerCached = update_message_PointerCached;
2855 return TRUE;
2856}
2857
2858static DWORD WINAPI update_message_proxy_thread(LPVOID arg)
2859{
2860 rdpUpdate* update = (rdpUpdate*)arg;
2861 wMessage message = { 0 };
2862 rdp_update_internal* up = update_cast(update);
2863
2864 while (MessageQueue_Wait(up->queue))
2865 {
2866 int status = 0;
2867
2868 if (MessageQueue_Peek(up->queue, &message, TRUE))
2869 status = update_message_queue_process_message(update, &message);
2870
2871 if (!status)
2872 break;
2873 }
2874
2875 ExitThread(0);
2876 return 0;
2877}
2878
2879rdpUpdateProxy* update_message_proxy_new(rdpUpdate* update)
2880{
2881 rdpUpdateProxy* message = NULL;
2882
2883 if (!update)
2884 return NULL;
2885
2886 if (!(message = (rdpUpdateProxy*)calloc(1, sizeof(rdpUpdateProxy))))
2887 return NULL;
2888
2889 message->update = update;
2890 update_message_register_interface(message, update);
2891
2892 if (!(message->thread = CreateThread(NULL, 0, update_message_proxy_thread, update, 0, NULL)))
2893 {
2894 WLog_ERR(TAG, "Failed to create proxy thread");
2895 free(message);
2896 return NULL;
2897 }
2898
2899 return message;
2900}
2901
2902void update_message_proxy_free(rdpUpdateProxy* message)
2903{
2904 if (message)
2905 {
2906 rdp_update_internal* up = update_cast(message->update);
2907 if (MessageQueue_PostQuit(up->queue, 0))
2908 (void)WaitForSingleObject(message->thread, INFINITE);
2909
2910 (void)CloseHandle(message->thread);
2911 free(message);
2912 }
2913}
2914
2915/* Event Queue */
2916static int input_message_free_input_class(wMessage* msg, int type)
2917{
2918 int status = 0;
2919
2920 WINPR_UNUSED(msg);
2921
2922 switch (type)
2923 {
2924 case Input_SynchronizeEvent:
2925 break;
2926
2927 case Input_KeyboardEvent:
2928 break;
2929
2930 case Input_UnicodeKeyboardEvent:
2931 break;
2932
2933 case Input_MouseEvent:
2934 break;
2935
2936 case Input_ExtendedMouseEvent:
2937 break;
2938
2939 case Input_FocusInEvent:
2940 break;
2941
2942 case Input_KeyboardPauseEvent:
2943 break;
2944
2945 default:
2946 status = -1;
2947 break;
2948 }
2949
2950 return status;
2951}
2952
2953static int input_message_process_input_class(rdpInputProxy* proxy, wMessage* msg, int type)
2954{
2955 int status = 0;
2956
2957 if (!proxy || !msg)
2958 return -1;
2959
2960 switch (type)
2961 {
2962 case Input_SynchronizeEvent:
2963 IFCALL(proxy->SynchronizeEvent, msg->context, (UINT32)(size_t)msg->wParam);
2964 break;
2965
2966 case Input_KeyboardEvent:
2967 IFCALL(proxy->KeyboardEvent, msg->context, (UINT16)(size_t)msg->wParam,
2968 (UINT8)(size_t)msg->lParam);
2969 break;
2970
2971 case Input_UnicodeKeyboardEvent:
2972 IFCALL(proxy->UnicodeKeyboardEvent, msg->context, (UINT16)(size_t)msg->wParam,
2973 (UINT16)(size_t)msg->lParam);
2974 break;
2975
2976 case Input_MouseEvent:
2977 {
2978 UINT32 pos = 0;
2979 UINT16 x = 0;
2980 UINT16 y = 0;
2981 pos = (UINT32)(size_t)msg->lParam;
2982 x = ((pos & 0xFFFF0000) >> 16);
2983 y = (pos & 0x0000FFFF);
2984 IFCALL(proxy->MouseEvent, msg->context, (UINT16)(size_t)msg->wParam, x, y);
2985 }
2986 break;
2987
2988 case Input_ExtendedMouseEvent:
2989 {
2990 UINT32 pos = 0;
2991 UINT16 x = 0;
2992 UINT16 y = 0;
2993 pos = (UINT32)(size_t)msg->lParam;
2994 x = ((pos & 0xFFFF0000) >> 16);
2995 y = (pos & 0x0000FFFF);
2996 IFCALL(proxy->ExtendedMouseEvent, msg->context, (UINT16)(size_t)msg->wParam, x, y);
2997 }
2998 break;
2999
3000 case Input_FocusInEvent:
3001 IFCALL(proxy->FocusInEvent, msg->context, (UINT16)(size_t)msg->wParam);
3002 break;
3003
3004 case Input_KeyboardPauseEvent:
3005 IFCALL(proxy->KeyboardPauseEvent, msg->context);
3006 break;
3007
3008 default:
3009 status = -1;
3010 break;
3011 }
3012
3013 return status;
3014}
3015
3016static int input_message_free_class(wMessage* msg, int msgClass, int msgType)
3017{
3018 int status = 0;
3019
3020 switch (msgClass)
3021 {
3022 case Input_Class:
3023 status = input_message_free_input_class(msg, msgType);
3024 break;
3025
3026 default:
3027 status = -1;
3028 break;
3029 }
3030
3031 if (status < 0)
3032 WLog_ERR(TAG, "Unknown event: class: %d type: %d", msgClass, msgType);
3033
3034 return status;
3035}
3036
3037static int input_message_process_class(rdpInputProxy* proxy, wMessage* msg, int msgClass,
3038 int msgType)
3039{
3040 int status = 0;
3041
3042 switch (msgClass)
3043 {
3044 case Input_Class:
3045 status = input_message_process_input_class(proxy, msg, msgType);
3046 break;
3047
3048 default:
3049 status = -1;
3050 break;
3051 }
3052
3053 if (status < 0)
3054 WLog_ERR(TAG, "Unknown event: class: %d type: %d", msgClass, msgType);
3055
3056 return status;
3057}
3058
3059int input_message_queue_free_message(wMessage* message)
3060{
3061 int status = 0;
3062 int msgClass = 0;
3063 int msgType = 0;
3064
3065 if (!message)
3066 return -1;
3067
3068 if (message->id == WMQ_QUIT)
3069 return 0;
3070
3071 msgClass = GetMessageClass(message->id);
3072 msgType = GetMessageType(message->id);
3073 status = input_message_free_class(message, msgClass, msgType);
3074
3075 if (status < 0)
3076 return -1;
3077
3078 return 1;
3079}
3080
3081int input_message_queue_process_message(rdpInput* input, wMessage* message)
3082{
3083 int status = 0;
3084 int msgClass = 0;
3085 int msgType = 0;
3086 rdp_input_internal* in = input_cast(input);
3087
3088 if (!message)
3089 return -1;
3090
3091 if (message->id == WMQ_QUIT)
3092 return 0;
3093
3094 msgClass = GetMessageClass(message->id);
3095 msgType = GetMessageType(message->id);
3096 status = input_message_process_class(in->proxy, message, msgClass, msgType);
3097 input_message_free_class(message, msgClass, msgType);
3098
3099 if (status < 0)
3100 return -1;
3101
3102 return 1;
3103}
3104
3105int input_message_queue_process_pending_messages(rdpInput* input)
3106{
3107 int status = 1;
3108 wMessage message = { 0 };
3109 rdp_input_internal* in = input_cast(input);
3110
3111 if (!in->queue)
3112 return -1;
3113
3114 wMessageQueue* queue = in->queue;
3115
3116 while (MessageQueue_Peek(queue, &message, TRUE))
3117 {
3118 status = input_message_queue_process_message(input, &message);
3119
3120 if (!status)
3121 break;
3122 }
3123
3124 return status;
3125}
BITMAP_UPDATE
Definition include/freerdp/update.h:72
CACHE_BITMAP_ORDER
Definition secondary.h:76
CACHE_BITMAP_V2_ORDER
Definition secondary.h:89
CACHE_BITMAP_V3_ORDER
Definition secondary.h:118
CACHE_BRUSH_ORDER
Definition secondary.h:153
CACHE_COLOR_TABLE_ORDER
Definition secondary.h:129
CACHE_GLYPH_ORDER
Definition secondary.h:136
CACHE_GLYPH_V2_ORDER
Definition secondary.h:144
CREATE_NINE_GRID_BITMAP_ORDER
Definition altsec.h:75
CREATE_OFFSCREEN_BITMAP_ORDER
Definition altsec.h:52
DELTA_POINT
Definition primary.h:225
DRAW_GDIPLUS_CACHE_END_ORDER
Definition altsec.h:150
DRAW_GDIPLUS_CACHE_FIRST_ORDER
Definition altsec.h:131
DRAW_GDIPLUS_CACHE_NEXT_ORDER
Definition altsec.h:141
DRAW_GDIPLUS_END_ORDER
Definition altsec.h:123
DRAW_GDIPLUS_FIRST_ORDER
Definition altsec.h:109
DRAW_GDIPLUS_NEXT_ORDER
Definition altsec.h:117
DRAW_NINE_GRID_ORDER
Definition primary.h:129
DSTBLT_ORDER
Definition primary.h:88
ELLIPSE_CB_ORDER
Definition primary.h:405
ELLIPSE_SC_ORDER
Definition primary.h:394
FAST_GLYPH_ORDER
Definition primary.h:345
FAST_INDEX_ORDER
Definition primary.h:323
FRAME_MARKER_ORDER
Definition altsec.h:84
GLYPH_INDEX_ORDER
Definition primary.h:300
ICON_INFO
Definition include/freerdp/window.h:166
LINE_TO_ORDER
Definition primary.h:211
MEM3BLT_ORDER
Definition primary.h:257
MEMBLT_ORDER
Definition primary.h:242
MONITORED_DESKTOP_ORDER
Definition include/freerdp/window.h:251
MULTI_DRAW_NINE_GRID_ORDER
Definition primary.h:199
MULTI_DSTBLT_ORDER
Definition primary.h:146
MULTI_OPAQUE_RECT_ORDER
Definition primary.h:187
MULTI_PATBLT_ORDER
Definition primary.h:158
MULTI_SCRBLT_ORDER
Definition primary.h:173
NOTIFY_ICON_STATE_ORDER
Definition include/freerdp/window.h:241
OPAQUE_RECT_ORDER
Definition primary.h:120
PALETTE_UPDATE
Definition include/freerdp/update.h:81
PATBLT_ORDER
Definition primary.h:97
PLAY_SOUND_UPDATE
Definition include/freerdp/update.h:89
POINTER_CACHED_UPDATE
Definition include/freerdp/pointer.h:85
POINTER_COLOR_UPDATE
Definition include/freerdp/pointer.h:52
POINTER_LARGE_UPDATE
Definition include/freerdp/pointer.h:65
POINTER_NEW_UPDATE
Definition include/freerdp/pointer.h:79
POINTER_POSITION_UPDATE
Definition include/freerdp/pointer.h:41
POINTER_SYSTEM_UPDATE
Definition include/freerdp/pointer.h:47
POLYGON_CB_ORDER
Definition primary.h:379
POLYGON_SC_ORDER
Definition primary.h:367
POLYLINE_ORDER
Definition primary.h:231
RECTANGLE_16
Definition types.h:109
SAVE_BITMAP_ORDER
Definition primary.h:275
SCRBLT_ORDER
Definition primary.h:109
STREAM_BITMAP_FIRST_ORDER
Definition altsec.h:89
STREAM_BITMAP_NEXT_ORDER
Definition altsec.h:101
SURFACE_BITS_COMMAND
Definition include/freerdp/update.h:123
SURFACE_FRAME_MARKER
Definition include/freerdp/update.h:134
SWITCH_SURFACE_ORDER
Definition altsec.h:60
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
rdp_input_internal
Definition libfreerdp/core/input.h:34
rdp_update_internal
Definition libfreerdp/core/update.h:46