ReactOS  0.4.14-dev-317-g96040ec
orders.c
Go to the documentation of this file.
1 /* -*- c-basic-offset: 8 -*-
2  rdesktop: A Remote Desktop Protocol client.
3  RDP order processing
4  Copyright (C) Matthew Chapman 1999-2005
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License along
17  with this program; if not, write to the Free Software Foundation, Inc.,
18  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20 
21 #include "rdesktop.h"
22 #include "orders.h"
23 
24 /* Read field indicating which parameters are present */
25 static void
27 {
28  uint8 bits;
29  int i;
30 
31  if (flags & RDP_ORDER_SMALL)
32  {
33  size--;
34  }
35 
36  if (flags & RDP_ORDER_TINY)
37  {
38  if (size < 2)
39  size = 0;
40  else
41  size -= 2;
42  }
43 
44  *present = 0;
45  for (i = 0; i < size; i++)
46  {
47  in_uint8(s, bits);
48  *present |= bits << (i * 8);
49  }
50 }
51 
52 /* Read a co-ordinate (16-bit, or 8-bit delta) */
53 static void
55 {
56  sint8 change;
57 
58  if (delta)
59  {
60  in_uint8(s, change);
61  *coord += change;
62  }
63  else
64  {
65  in_uint16_le(s, *coord);
66  }
67 }
68 
69 /* Parse a delta co-ordinate in polyline/polygon order form */
70 static int
72 {
73  int value = buffer[(*offset)++];
74  int two_byte = value & 0x80;
75 
76  if (value & 0x40) /* sign bit */
77  value |= ~0x3f;
78  else
79  value &= 0x3f;
80 
81  if (two_byte)
82  value = (value << 8) | buffer[(*offset)++];
83 
84  return value;
85 }
86 
87 /* Read a colour entry */
88 static void
90 {
91  uint32 i;
92  in_uint8(s, i);
93  *colour = i;
94  in_uint8(s, i);
95  *colour |= i << 8;
96  in_uint8(s, i);
97  *colour |= i << 16;
98 }
99 
100 /* Parse bounds information */
101 static BOOL
103 {
104  uint8 present;
105 
106  in_uint8(s, present);
107 
108  if (present & 1)
109  rdp_in_coord(s, &bounds->left, False);
110  else if (present & 16)
111  rdp_in_coord(s, &bounds->left, True);
112 
113  if (present & 2)
114  rdp_in_coord(s, &bounds->top, False);
115  else if (present & 32)
116  rdp_in_coord(s, &bounds->top, True);
117 
118  if (present & 4)
119  rdp_in_coord(s, &bounds->right, False);
120  else if (present & 64)
121  rdp_in_coord(s, &bounds->right, True);
122 
123  if (present & 8)
124  rdp_in_coord(s, &bounds->bottom, False);
125  else if (present & 128)
126  rdp_in_coord(s, &bounds->bottom, True);
127 
128  return s_check(s);
129 }
130 
131 /* Parse a pen */
132 static BOOL
133 rdp_parse_pen(STREAM s, PEN * pen, uint32 present)
134 {
135  if (present & 1)
136  in_uint8(s, pen->style);
137 
138  if (present & 2)
139  in_uint8(s, pen->width);
140 
141  if (present & 4)
142  rdp_in_colour(s, &pen->colour);
143 
144  return s_check(s);
145 }
146 
147 /* Parse a brush */
148 static BOOL
149 rdp_parse_brush(STREAM s, BRUSH * brush, uint32 present)
150 {
151  if (present & 1)
152  in_uint8(s, brush->xorigin);
153 
154  if (present & 2)
155  in_uint8(s, brush->yorigin);
156 
157  if (present & 4)
158  in_uint8(s, brush->style);
159 
160  if (present & 8)
161  in_uint8(s, brush->pattern[0]);
162 
163  if (present & 16)
164  in_uint8a(s, &brush->pattern[1], 7);
165 
166  return s_check(s);
167 }
168 
169 /* Process a destination blt order */
170 static void
172 {
173  if (present & 0x01)
174  rdp_in_coord(s, &os->x, delta);
175 
176  if (present & 0x02)
177  rdp_in_coord(s, &os->y, delta);
178 
179  if (present & 0x04)
180  rdp_in_coord(s, &os->cx, delta);
181 
182  if (present & 0x08)
183  rdp_in_coord(s, &os->cy, delta);
184 
185  if (present & 0x10)
186  in_uint8(s, os->opcode);
187 
188  DEBUG(("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",
189  os->opcode, os->x, os->y, os->cx, os->cy));
190 
191 #if 0
192  ui_destblt(This, ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);
193 #else
194  ui_destblt(This, os->opcode, os->x, os->y, os->cx, os->cy);
195 #endif
196 }
197 
198 /* Process a pattern blt order */
199 static void
201 {
202  if (present & 0x0001)
203  rdp_in_coord(s, &os->x, delta);
204 
205  if (present & 0x0002)
206  rdp_in_coord(s, &os->y, delta);
207 
208  if (present & 0x0004)
209  rdp_in_coord(s, &os->cx, delta);
210 
211  if (present & 0x0008)
212  rdp_in_coord(s, &os->cy, delta);
213 
214  if (present & 0x0010)
215  in_uint8(s, os->opcode);
216 
217  if (present & 0x0020)
218  rdp_in_colour(s, &os->bgcolour);
219 
220  if (present & 0x0040)
221  rdp_in_colour(s, &os->fgcolour);
222 
223  rdp_parse_brush(s, &os->brush, present >> 7);
224 
225  DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n", os->opcode, os->x,
226  os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour));
227 
228 #if 0
229  ui_patblt(This, ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
230  &os->brush, os->bgcolour, os->fgcolour);
231 #else
232  ui_patblt(This, os->opcode, os->x, os->y, os->cx, os->cy,
233  &os->brush, os->bgcolour, os->fgcolour);
234 #endif
235 }
236 
237 /* Process a screen blt order */
238 static void
240 {
241  if (present & 0x0001)
242  rdp_in_coord(s, &os->x, delta);
243 
244  if (present & 0x0002)
245  rdp_in_coord(s, &os->y, delta);
246 
247  if (present & 0x0004)
248  rdp_in_coord(s, &os->cx, delta);
249 
250  if (present & 0x0008)
251  rdp_in_coord(s, &os->cy, delta);
252 
253  if (present & 0x0010)
254  in_uint8(s, os->opcode);
255 
256  if (present & 0x0020)
257  rdp_in_coord(s, &os->srcx, delta);
258 
259  if (present & 0x0040)
260  rdp_in_coord(s, &os->srcy, delta);
261 
262  DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",
263  os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy));
264 
265 #if 0
266  ui_screenblt(This, ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
267 #else
268  ui_screenblt(This, os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
269 #endif
270 }
271 
272 /* Process a line order */
273 static void
275 {
276  if (present & 0x0001)
277  in_uint16_le(s, os->mixmode);
278 
279  if (present & 0x0002)
280  rdp_in_coord(s, &os->startx, delta);
281 
282  if (present & 0x0004)
283  rdp_in_coord(s, &os->starty, delta);
284 
285  if (present & 0x0008)
286  rdp_in_coord(s, &os->endx, delta);
287 
288  if (present & 0x0010)
289  rdp_in_coord(s, &os->endy, delta);
290 
291  if (present & 0x0020)
292  rdp_in_colour(s, &os->bgcolour);
293 
294  if (present & 0x0040)
295  in_uint8(s, os->opcode);
296 
297  rdp_parse_pen(s, &os->pen, present >> 7);
298 
299  DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dy=%d,fg=0x%x)\n",
300  os->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
301 
302  if (os->opcode < 0x01 || os->opcode > 0x10)
303  {
304  error("bad ROP2 0x%x\n", os->opcode);
305  return;
306  }
307 
308 #if 0
309  ui_line(This, os->opcode - 1, os->startx, os->starty, os->endx, os->endy, &os->pen);
310 #else
311  ui_line(This, os->opcode, os->startx, os->starty, os->endx, os->endy, &os->pen);
312 #endif
313 }
314 
315 /* Process an opaque rectangle order */
316 static void
318 {
319  uint32 i;
320  if (present & 0x01)
321  rdp_in_coord(s, &os->x, delta);
322 
323  if (present & 0x02)
324  rdp_in_coord(s, &os->y, delta);
325 
326  if (present & 0x04)
327  rdp_in_coord(s, &os->cx, delta);
328 
329  if (present & 0x08)
330  rdp_in_coord(s, &os->cy, delta);
331 
332  if (present & 0x10)
333  {
334  in_uint8(s, i);
335  os->colour = (os->colour & 0xffffff00) | i;
336  }
337 
338  if (present & 0x20)
339  {
340  in_uint8(s, i);
341  os->colour = (os->colour & 0xffff00ff) | (i << 8);
342  }
343 
344  if (present & 0x40)
345  {
346  in_uint8(s, i);
347  os->colour = (os->colour & 0xff00ffff) | (i << 16);
348  }
349 
350  DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n", os->x, os->y, os->cx, os->cy, os->colour));
351 
352  ui_rect(This, os->x, os->y, os->cx, os->cy, os->colour);
353 }
354 
355 /* Process a desktop save order */
356 static void
358 {
359  int width, height;
360 
361  if (present & 0x01)
362  in_uint32_le(s, os->offset);
363 
364  if (present & 0x02)
365  rdp_in_coord(s, &os->left, delta);
366 
367  if (present & 0x04)
368  rdp_in_coord(s, &os->top, delta);
369 
370  if (present & 0x08)
371  rdp_in_coord(s, &os->right, delta);
372 
373  if (present & 0x10)
374  rdp_in_coord(s, &os->bottom, delta);
375 
376  if (present & 0x20)
377  in_uint8(s, os->action);
378 
379  DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",
380  os->left, os->top, os->right, os->bottom, os->offset, os->action));
381 
382  width = os->right - os->left + 1;
383  height = os->bottom - os->top + 1;
384 
385  if (os->action == 0)
386  ui_desktop_save(This, os->offset, os->left, os->top, width, height);
387  else
388  ui_desktop_restore(This, os->offset, os->left, os->top, width, height);
389 }
390 
391 /* Process a memory blt order */
392 static void
394 {
395  HBITMAP bitmap;
396 
397  if (present & 0x0001)
398  {
399  in_uint8(s, os->cache_id);
400  in_uint8(s, os->colour_table);
401  }
402 
403  if (present & 0x0002)
404  rdp_in_coord(s, &os->x, delta);
405 
406  if (present & 0x0004)
407  rdp_in_coord(s, &os->y, delta);
408 
409  if (present & 0x0008)
410  rdp_in_coord(s, &os->cx, delta);
411 
412  if (present & 0x0010)
413  rdp_in_coord(s, &os->cy, delta);
414 
415  if (present & 0x0020)
416  in_uint8(s, os->opcode);
417 
418  if (present & 0x0040)
419  rdp_in_coord(s, &os->srcx, delta);
420 
421  if (present & 0x0080)
422  rdp_in_coord(s, &os->srcy, delta);
423 
424  if (present & 0x0100)
425  in_uint16_le(s, os->cache_idx);
426 
427  DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",
428  os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx));
429 
431  if (bitmap == NULL)
432  return;
433 
434 #if 0
435  ui_memblt(This, ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
436 #else
437  ui_memblt(This, os->opcode, os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
438 #endif
439 }
440 
441 /* Process a 3-way blt order */
442 static void
444 {
445  HBITMAP bitmap;
446 
447  if (present & 0x000001)
448  {
449  in_uint8(s, os->cache_id);
450  in_uint8(s, os->colour_table);
451  }
452 
453  if (present & 0x000002)
454  rdp_in_coord(s, &os->x, delta);
455 
456  if (present & 0x000004)
457  rdp_in_coord(s, &os->y, delta);
458 
459  if (present & 0x000008)
460  rdp_in_coord(s, &os->cx, delta);
461 
462  if (present & 0x000010)
463  rdp_in_coord(s, &os->cy, delta);
464 
465  if (present & 0x000020)
466  in_uint8(s, os->opcode);
467 
468  if (present & 0x000040)
469  rdp_in_coord(s, &os->srcx, delta);
470 
471  if (present & 0x000080)
472  rdp_in_coord(s, &os->srcy, delta);
473 
474  if (present & 0x000100)
475  rdp_in_colour(s, &os->bgcolour);
476 
477  if (present & 0x000200)
478  rdp_in_colour(s, &os->fgcolour);
479 
480  rdp_parse_brush(s, &os->brush, present >> 10);
481 
482  if (present & 0x008000)
483  in_uint16_le(s, os->cache_idx);
484 
485  if (present & 0x010000)
486  in_uint16_le(s, os->unknown);
487 
488  DEBUG(("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
489  os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx,
490  os->brush.style, os->bgcolour, os->fgcolour));
491 
493  if (bitmap == NULL)
494  return;
495 
496  ui_triblt(This, os->opcode, os->x, os->y, os->cx, os->cy,
497  bitmap, os->srcx, os->srcy, &os->brush, os->bgcolour, os->fgcolour);
498 }
499 
500 /* Process a polygon order */
501 static void
503 {
504  int index, data, next;
505  uint8 flags = 0;
506  POINT *points;
507 
508  if (present & 0x01)
509  rdp_in_coord(s, &os->x, delta);
510 
511  if (present & 0x02)
512  rdp_in_coord(s, &os->y, delta);
513 
514  if (present & 0x04)
515  in_uint8(s, os->opcode);
516 
517  if (present & 0x08)
518  in_uint8(s, os->fillmode);
519 
520  if (present & 0x10)
521  rdp_in_colour(s, &os->fgcolour);
522 
523  if (present & 0x20)
524  in_uint8(s, os->npoints);
525 
526  if (present & 0x40)
527  {
528  in_uint8(s, os->datasize);
529  in_uint8a(s, os->data, os->datasize);
530  }
531 
532  DEBUG(("POLYGON(x=%d,y=%d,op=0x%x,fm=%d,fg=0x%x,n=%d,sz=%d)\n",
533  os->x, os->y, os->opcode, os->fillmode, os->fgcolour, os->npoints, os->datasize));
534 
535  DEBUG(("Data: "));
536 
537  for (index = 0; index < os->datasize; index++)
538  DEBUG(("%02x ", os->data[index]));
539 
540  DEBUG(("\n"));
541 
542  if (os->opcode < 0x01 || os->opcode > 0x10)
543  {
544  error("bad ROP2 0x%x\n", os->opcode);
545  return;
546  }
547 
548  points = (POINT *) malloc((os->npoints + 1) * sizeof(POINT));
549 
550  if(points == NULL)
551  return;
552 
553  memset(points, 0, (os->npoints + 1) * sizeof(POINT));
554 
555  points[0].x = os->x;
556  points[0].y = os->y;
557 
558  index = 0;
559  data = ((os->npoints - 1) / 4) + 1;
560  for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
561  {
562  if ((next - 1) % 4 == 0)
563  flags = os->data[index++];
564 
565  if (~flags & 0x80)
566  points[next].x = parse_delta(os->data, &data);
567 
568  if (~flags & 0x40)
569  points[next].y = parse_delta(os->data, &data);
570 
571  flags <<= 2;
572  }
573 
574  if (next - 1 == os->npoints)
575 #if 0
576  ui_polygon(This, os->opcode - 1, os->fillmode, points, os->npoints + 1, NULL, 0,
577  os->fgcolour);
578 #else
579  ui_polygon(This, os->opcode, os->fillmode, points, os->npoints + 1, NULL, 0,
580  os->fgcolour);
581 #endif
582  else
583  error("polygon parse error\n");
584 
585  free(points);
586 }
587 
588 /* Process a polygon2 order */
589 static void
591 {
592  int index, data, next;
593  uint8 flags = 0;
594  POINT *points;
595 
596  if (present & 0x0001)
597  rdp_in_coord(s, &os->x, delta);
598 
599  if (present & 0x0002)
600  rdp_in_coord(s, &os->y, delta);
601 
602  if (present & 0x0004)
603  in_uint8(s, os->opcode);
604 
605  if (present & 0x0008)
606  in_uint8(s, os->fillmode);
607 
608  if (present & 0x0010)
609  rdp_in_colour(s, &os->bgcolour);
610 
611  if (present & 0x0020)
612  rdp_in_colour(s, &os->fgcolour);
613 
614  rdp_parse_brush(s, &os->brush, present >> 6);
615 
616  if (present & 0x0800)
617  in_uint8(s, os->npoints);
618 
619  if (present & 0x1000)
620  {
621  in_uint8(s, os->datasize);
622  in_uint8a(s, os->data, os->datasize);
623  }
624 
625  DEBUG(("POLYGON2(x=%d,y=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x,n=%d,sz=%d)\n",
626  os->x, os->y, os->opcode, os->fillmode, os->brush.style, os->bgcolour, os->fgcolour,
627  os->npoints, os->datasize));
628 
629  DEBUG(("Data: "));
630 
631  for (index = 0; index < os->datasize; index++)
632  DEBUG(("%02x ", os->data[index]));
633 
634  DEBUG(("\n"));
635 
636  if (os->opcode < 0x01 || os->opcode > 0x10)
637  {
638  error("bad ROP2 0x%x\n", os->opcode);
639  return;
640  }
641 
642  points = (POINT *) malloc((os->npoints + 1) * sizeof(POINT));
643 
644  if(points == NULL)
645  return;
646 
647  memset(points, 0, (os->npoints + 1) * sizeof(POINT));
648 
649  points[0].x = os->x;
650  points[0].y = os->y;
651 
652  index = 0;
653  data = ((os->npoints - 1) / 4) + 1;
654  for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
655  {
656  if ((next - 1) % 4 == 0)
657  flags = os->data[index++];
658 
659  if (~flags & 0x80)
660  points[next].x = parse_delta(os->data, &data);
661 
662  if (~flags & 0x40)
663  points[next].y = parse_delta(os->data, &data);
664 
665  flags <<= 2;
666  }
667 
668  if (next - 1 == os->npoints)
669 #if 0
670  ui_polygon(This, os->opcode - 1, os->fillmode, points, os->npoints + 1,
671  &os->brush, os->bgcolour, os->fgcolour);
672 #else
673  ui_polygon(This, os->opcode, os->fillmode, points, os->npoints + 1,
674  &os->brush, os->bgcolour, os->fgcolour);
675 #endif
676  else
677  error("polygon2 parse error\n");
678 
679  free(points);
680 }
681 
682 /* Process a polyline order */
683 static void
685 {
686  int index, next, data;
687  uint8 flags = 0;
688  PEN pen;
689  POINT *points;
690 
691  if (present & 0x01)
692  rdp_in_coord(s, &os->x, delta);
693 
694  if (present & 0x02)
695  rdp_in_coord(s, &os->y, delta);
696 
697  if (present & 0x04)
698  in_uint8(s, os->opcode);
699 
700  if (present & 0x10)
701  rdp_in_colour(s, &os->fgcolour);
702 
703  if (present & 0x20)
704  in_uint8(s, os->lines);
705 
706  if (present & 0x40)
707  {
708  in_uint8(s, os->datasize);
709  in_uint8a(s, os->data, os->datasize);
710  }
711 
712  DEBUG(("POLYLINE(x=%d,y=%d,op=0x%x,fg=0x%x,n=%d,sz=%d)\n",
713  os->x, os->y, os->opcode, os->fgcolour, os->lines, os->datasize));
714 
715  DEBUG(("Data: "));
716 
717  for (index = 0; index < os->datasize; index++)
718  DEBUG(("%02x ", os->data[index]));
719 
720  DEBUG(("\n"));
721 
722  if (os->opcode < 0x01 || os->opcode > 0x10)
723  {
724  error("bad ROP2 0x%x\n", os->opcode);
725  return;
726  }
727 
728  points = (POINT *) malloc((os->lines + 1) * sizeof(POINT));
729 
730  if(points == NULL)
731  return;
732 
733  memset(points, 0, (os->lines + 1) * sizeof(POINT));
734 
735  points[0].x = os->x;
736  points[0].y = os->y;
737  pen.style = pen.width = 0;
738  pen.colour = os->fgcolour;
739 
740  index = 0;
741  data = ((os->lines - 1) / 4) + 1;
742  for (next = 1; (next <= os->lines) && (data < os->datasize); next++)
743  {
744  if ((next - 1) % 4 == 0)
745  flags = os->data[index++];
746 
747  if (~flags & 0x80)
748  points[next].x = parse_delta(os->data, &data);
749 
750  if (~flags & 0x40)
751  points[next].y = parse_delta(os->data, &data);
752 
753  flags <<= 2;
754  }
755 
756  if (next - 1 == os->lines)
757 #if 0
758  ui_polyline(This, os->opcode - 1, points, os->lines + 1, &pen);
759 #else
760  ui_polyline(This, os->opcode, points, os->lines + 1, &pen);
761 #endif
762  else
763  error("polyline parse error\n");
764 
765  free(points);
766 }
767 
768 /* Process an ellipse order */
769 static void
771 {
772  if (present & 0x01)
773  rdp_in_coord(s, &os->left, delta);
774 
775  if (present & 0x02)
776  rdp_in_coord(s, &os->top, delta);
777 
778  if (present & 0x04)
779  rdp_in_coord(s, &os->right, delta);
780 
781  if (present & 0x08)
782  rdp_in_coord(s, &os->bottom, delta);
783 
784  if (present & 0x10)
785  in_uint8(s, os->opcode);
786 
787  if (present & 0x20)
788  in_uint8(s, os->fillmode);
789 
790  if (present & 0x40)
791  rdp_in_colour(s, &os->fgcolour);
792 
793  DEBUG(("ELLIPSE(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,fg=0x%x)\n", os->left, os->top,
794  os->right, os->bottom, os->opcode, os->fillmode, os->fgcolour));
795 
796 #if 0
797  ui_ellipse(This, os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
798  os->bottom - os->top, NULL, 0, os->fgcolour);
799 #else
800  ui_ellipse(This, os->opcode, os->fillmode, os->left, os->top, os->right - os->left,
801  os->bottom - os->top, NULL, 0, os->fgcolour);
802 #endif
803 }
804 
805 /* Process an ellipse2 order */
806 static void
808 {
809  if (present & 0x0001)
810  rdp_in_coord(s, &os->left, delta);
811 
812  if (present & 0x0002)
813  rdp_in_coord(s, &os->top, delta);
814 
815  if (present & 0x0004)
816  rdp_in_coord(s, &os->right, delta);
817 
818  if (present & 0x0008)
819  rdp_in_coord(s, &os->bottom, delta);
820 
821  if (present & 0x0010)
822  in_uint8(s, os->opcode);
823 
824  if (present & 0x0020)
825  in_uint8(s, os->fillmode);
826 
827  if (present & 0x0040)
828  rdp_in_colour(s, &os->bgcolour);
829 
830  if (present & 0x0080)
831  rdp_in_colour(s, &os->fgcolour);
832 
833  rdp_parse_brush(s, &os->brush, present >> 8);
834 
835  DEBUG(("ELLIPSE2(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
836  os->left, os->top, os->right, os->bottom, os->opcode, os->fillmode, os->brush.style,
837  os->bgcolour, os->fgcolour));
838 
839 #if 0
840  ui_ellipse(This, os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
841  os->bottom - os->top, &os->brush, os->bgcolour, os->fgcolour);
842 #else
843  ui_ellipse(This, os->opcode, os->fillmode, os->left, os->top, os->right - os->left,
844  os->bottom - os->top, &os->brush, os->bgcolour, os->fgcolour);
845 #endif
846 }
847 
848 /* Process a text order */
849 static void
851 {
852  int i;
853 
854  if (present & 0x000001)
855  in_uint8(s, os->font);
856 
857  if (present & 0x000002)
858  in_uint8(s, os->flags);
859 
860  if (present & 0x000004)
861  in_uint8(s, os->opcode);
862 
863  if (present & 0x000008)
864  in_uint8(s, os->mixmode);
865 
866  if (present & 0x000010)
867  rdp_in_colour(s, &os->fgcolour);
868 
869  if (present & 0x000020)
870  rdp_in_colour(s, &os->bgcolour);
871 
872  if (present & 0x000040)
873  in_uint16_le(s, os->clipleft);
874 
875  if (present & 0x000080)
876  in_uint16_le(s, os->cliptop);
877 
878  if (present & 0x000100)
879  in_uint16_le(s, os->clipright);
880 
881  if (present & 0x000200)
882  in_uint16_le(s, os->clipbottom);
883 
884  if (present & 0x000400)
885  in_uint16_le(s, os->boxleft);
886 
887  if (present & 0x000800)
888  in_uint16_le(s, os->boxtop);
889 
890  if (present & 0x001000)
891  in_uint16_le(s, os->boxright);
892 
893  if (present & 0x002000)
894  in_uint16_le(s, os->boxbottom);
895 
896  rdp_parse_brush(s, &os->brush, present >> 14);
897 
898  if (present & 0x080000)
899  in_uint16_le(s, os->x);
900 
901  if (present & 0x100000)
902  in_uint16_le(s, os->y);
903 
904  if (present & 0x200000)
905  {
906  in_uint8(s, os->length);
907  in_uint8a(s, os->text, os->length);
908  }
909 
910  DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,br=%d,bb=%d,bs=%d,bg=0x%x,fg=0x%x,font=%d,fl=0x%x,op=0x%x,mix=%d,n=%d)\n", os->x, os->y, os->clipleft, os->cliptop, os->clipright, os->clipbottom, os->boxleft, os->boxtop, os->boxright, os->boxbottom, os->brush.style, os->bgcolour, os->fgcolour, os->font, os->flags, os->opcode, os->mixmode, os->length));
911 
912  DEBUG(("Text: "));
913 
914  for (i = 0; i < os->length; i++)
915  DEBUG(("%02x ", os->text[i]));
916 
917  DEBUG(("\n"));
918 
919 #if 0
920  ui_draw_text(This, os->font, os->flags, os->opcode - 1, os->mixmode, os->x, os->y,
921  os->clipleft, os->cliptop, os->clipright - os->clipleft,
922  os->clipbottom - os->cliptop, os->boxleft, os->boxtop,
923  os->boxright - os->boxleft, os->boxbottom - os->boxtop,
924  &os->brush, os->bgcolour, os->fgcolour, os->text, os->length);
925 #else
926  ui_draw_text(This, os->font, os->flags, os->opcode, os->mixmode, os->x, os->y,
927  os->clipleft, os->cliptop, os->clipright - os->clipleft,
928  os->clipbottom - os->cliptop, os->boxleft, os->boxtop,
929  os->boxright - os->boxleft, os->boxbottom - os->boxtop,
930  &os->brush, os->bgcolour, os->fgcolour, os->text, os->length);
931 #endif
932 }
933 
934 /* Process a raw bitmap cache order */
935 static void
937 {
938  HBITMAP bitmap;
939  uint16 cache_idx, bufsize;
940  uint8 cache_id, width, height, bpp, Bpp;
941  uint8 *data;
942 
943  in_uint8(s, cache_id);
944  in_uint8s(s, 1); /* pad */
945  in_uint8(s, width);
946  in_uint8(s, height);
947  in_uint8(s, bpp);
948  Bpp = (bpp + 7) / 8;
950  in_uint16_le(s, cache_idx);
951  in_uint8p(s, data, bufsize);
952 
953  DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
954 #if 0
955  inverted = (uint8 *) xmalloc(width * height * Bpp);
956  for (y = 0; y < height; y++)
957  {
958  memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
959  width * Bpp);
960  }
961 #endif
962 
963 #if 0
964  bitmap = ui_create_bitmap(This, width, height, inverted);
965  xfree(inverted);
966 #else
968 #endif
969 
970  cache_put_bitmap(This, cache_id, cache_idx, bitmap);
971 }
972 
973 /* Process a bitmap cache order */
974 static void
976 {
977  HBITMAP bitmap;
978  uint16 cache_idx, size;
979  uint8 cache_id, width, height, bpp, Bpp;
980  uint8 *data, *bmpdata;
981  uint16 bufsize, pad2, row_size, final_size;
982  uint8 pad1;
983 
984  pad2 = row_size = final_size = 0xffff; /* Shut the compiler up */
985 
986  in_uint8(s, cache_id);
987  in_uint8(s, pad1); /* pad */
988  in_uint8(s, width);
989  in_uint8(s, height);
990  in_uint8(s, bpp);
991  Bpp = (bpp + 7) / 8;
992  in_uint16_le(s, bufsize); /* bufsize */
993  in_uint16_le(s, cache_idx);
994 
995  if (This->use_rdp5)
996  {
997  size = bufsize;
998  }
999  else
1000  {
1001 
1002  /* Begin compressedBitmapData */
1003  in_uint16_le(s, pad2); /* pad */
1004  in_uint16_le(s, size);
1005  /* in_uint8s(s, 4); *//* row_size, final_size */
1006  in_uint16_le(s, row_size);
1007  in_uint16_le(s, final_size);
1008 
1009  }
1010  in_uint8p(s, data, size);
1011 
1012  DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d,bpp=%d,size=%d,pad1=%d,bufsize=%d,pad2=%d,rs=%d,fs=%d)\n", width, height, cache_id, cache_idx, bpp, size, pad1, bufsize, pad2, row_size, final_size));
1013 
1014  bmpdata = (uint8 *) malloc(width * height * Bpp);
1015 
1016  if(bmpdata == NULL)
1017  return;
1018 
1019  if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
1020  {
1021  bitmap = ui_create_bitmap(This, width, height, bmpdata);
1022  cache_put_bitmap(This, cache_id, cache_idx, bitmap);
1023  }
1024  else
1025  {
1026  DEBUG(("Failed to decompress bitmap data\n"));
1027  }
1028 
1029  free(bmpdata);
1030 }
1031 
1032 /* Process a bitmap cache v2 order */
1033 static void
1035 {
1036  HBITMAP bitmap;
1037  uint8 cache_id, cache_idx_low, width, height, Bpp;
1038  uint16 cache_idx, bufsize;
1039  uint8 *data, *bmpdata, *bitmap_id;
1040 
1041  bitmap_id = NULL; /* prevent compiler warning */
1042  cache_id = flags & ID_MASK;
1043  Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
1044 
1045  if (flags & PERSIST)
1046  {
1047  in_uint8p(s, bitmap_id, 8);
1048  }
1049 
1050  if (flags & SQUARE)
1051  {
1052  in_uint8(s, width);
1053  height = width;
1054  }
1055  else
1056  {
1057  in_uint8(s, width);
1058  in_uint8(s, height);
1059  }
1060 
1062  bufsize &= BUFSIZE_MASK;
1063  in_uint8(s, cache_idx);
1064 
1065  if (cache_idx & LONG_FORMAT)
1066  {
1067  in_uint8(s, cache_idx_low);
1068  cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
1069  }
1070 
1071  in_uint8p(s, data, bufsize);
1072 
1073  DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
1074  compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
1075 
1076  if (compressed)
1077  {
1078  bmpdata = (uint8 *) malloc(width * height * Bpp);
1079 
1080  if(bmpdata == NULL)
1081  return;
1082 
1083  if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
1084  {
1085  DEBUG(("Failed to decompress bitmap data\n"));
1086  free(bmpdata);
1087  return;
1088  }
1089  }
1090  else
1091  {
1092 #if 0
1093  for (y = 0; y < height; y++)
1094  memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
1095  &data[y * (width * Bpp)], width * Bpp);
1096 #else
1097  bmpdata = data;
1098 #endif
1099  }
1100 
1101  bitmap = ui_create_bitmap(This, width, height, bmpdata);
1102 
1103  if (bitmap)
1104  {
1105  cache_put_bitmap(This, cache_id, cache_idx, bitmap);
1106  if (flags & PERSIST)
1107  pstcache_save_bitmap(This, cache_id, cache_idx, bitmap_id, width, height,
1108  width * height * Bpp, bmpdata);
1109  }
1110  else
1111  {
1112  DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
1113  }
1114 
1115  if (compressed)
1116  free(bmpdata);
1117 }
1118 
1119 /* Process a colourmap cache order */
1120 static void
1122 {
1123  COLOURENTRY *entry;
1124  COLOURMAP map;
1125  HCOLOURMAP hmap;
1126  uint8 cache_id;
1127  int i;
1128 
1129  in_uint8(s, cache_id);
1130  in_uint16_le(s, map.ncolours);
1131 
1132  map.colours = (COLOURENTRY *) malloc(sizeof(COLOURENTRY) * map.ncolours);
1133 
1134  if(map.colours == NULL)
1135  {
1136  in_uint8s(s, map.ncolours * 4);
1137  return;
1138  }
1139 
1140  for (i = 0; i < map.ncolours; i++)
1141  {
1142  entry = &map.colours[i];
1143  in_uint8(s, entry->blue);
1144  in_uint8(s, entry->green);
1145  in_uint8(s, entry->red);
1146  in_uint8s(s, 1); /* pad */
1147  }
1148 
1149  DEBUG(("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours));
1150 
1151  hmap = ui_create_colourmap(This, &map);
1152 
1153  if (cache_id)
1154  ui_set_colourmap(This, hmap);
1155 
1156  free(map.colours);
1157 }
1158 
1159 /* Process a font cache order */
1160 static void
1162 {
1163  HGLYPH bitmap;
1164  uint8 font, nglyphs;
1165  uint16 character, offset, baseline, width, height;
1166  int i, datasize;
1167  uint8 *data;
1168 
1169  in_uint8(s, font);
1170  in_uint8(s, nglyphs);
1171 
1172  DEBUG(("FONTCACHE(font=%d,n=%d)\n", font, nglyphs));
1173 
1174  for (i = 0; i < nglyphs; i++)
1175  {
1176  in_uint16_le(s, character);
1177  in_uint16_le(s, offset);
1178  in_uint16_le(s, baseline);
1179  in_uint16_le(s, width);
1180  in_uint16_le(s, height);
1181 
1182  datasize = (height * ((width + 7) / 8) + 3) & ~3;
1183  in_uint8p(s, data, datasize);
1184 
1186  cache_put_font(This, font, character, offset, baseline, width, height, bitmap);
1187  }
1188 }
1189 
1190 /* Process a secondary order */
1191 static void
1193 {
1194  /* The length isn't calculated correctly by the server.
1195  * For very compact orders the length becomes negative
1196  * so a signed integer must be used. */
1197  uint16 length;
1198  uint16 flags;
1199  uint8 type;
1200  uint8 *next_order;
1201 
1202  in_uint16_le(s, length);
1203  in_uint16_le(s, flags); /* used by bmpcache2 */
1204  in_uint8(s, type);
1205 
1206  next_order = s->p + (sint16) length + 7;
1207 
1208  switch (type)
1209  {
1212  break;
1213 
1214  case RDP_ORDER_COLCACHE:
1216  break;
1217 
1218  case RDP_ORDER_BMPCACHE:
1220  break;
1221 
1222  case RDP_ORDER_FONTCACHE:
1224  break;
1225 
1227  process_bmpcache2(This, s, flags, False); /* uncompressed */
1228  break;
1229 
1230  case RDP_ORDER_BMPCACHE2:
1231  process_bmpcache2(This, s, flags, True); /* compressed */
1232  break;
1233 
1234  default:
1235  unimpl("secondary order %d\n", type);
1236  }
1237 
1238  s->p = next_order;
1239 }
1240 
1241 /* Process an order PDU */
1242 void
1244 {
1245  RDP_ORDER_STATE *os = &This->orders.order_state;
1246  uint32 present;
1247  uint8 order_flags;
1248  int size, processed = 0;
1249  BOOL delta;
1250 
1251  while (processed < num_orders)
1252  {
1253  in_uint8(s, order_flags);
1254 
1255  if (!(order_flags & RDP_ORDER_STANDARD))
1256  {
1257  error("order parsing failed\n");
1258  break;
1259  }
1260 
1261  if (order_flags & RDP_ORDER_SECONDARY)
1262  {
1264  }
1265  else
1266  {
1267  if (order_flags & RDP_ORDER_CHANGE)
1268  {
1269  in_uint8(s, os->order_type);
1270  }
1271 
1272  switch (os->order_type)
1273  {
1274  case RDP_ORDER_TRIBLT:
1275  case RDP_ORDER_TEXT2:
1276  size = 3;
1277  break;
1278 
1279  case RDP_ORDER_PATBLT:
1280  case RDP_ORDER_MEMBLT:
1281  case RDP_ORDER_LINE:
1282  case RDP_ORDER_POLYGON2:
1283  case RDP_ORDER_ELLIPSE2:
1284  size = 2;
1285  break;
1286 
1287  default:
1288  size = 1;
1289  }
1290 
1291  rdp_in_present(s, &present, order_flags, size);
1292 
1293  if (order_flags & RDP_ORDER_BOUNDS)
1294  {
1295  if (!(order_flags & RDP_ORDER_LASTBOUNDS))
1296  rdp_parse_bounds(s, &os->bounds);
1297 
1298  ui_set_clip(This, os->bounds.left,
1299  os->bounds.top,
1300  os->bounds.right -
1301  os->bounds.left + 1,
1302  os->bounds.bottom - os->bounds.top + 1);
1303  }
1304 
1305  delta = order_flags & RDP_ORDER_DELTA;
1306 
1307  switch (os->order_type)
1308  {
1309  case RDP_ORDER_DESTBLT:
1310  process_destblt(This, s, &os->destblt, present, delta);
1311  break;
1312 
1313  case RDP_ORDER_PATBLT:
1314  process_patblt(This, s, &os->patblt, present, delta);
1315  break;
1316 
1317  case RDP_ORDER_SCREENBLT:
1318  process_screenblt(This, s, &os->screenblt, present, delta);
1319  break;
1320 
1321  case RDP_ORDER_LINE:
1322  process_line(This, s, &os->line, present, delta);
1323  break;
1324 
1325  case RDP_ORDER_RECT:
1326  process_rect(This, s, &os->rect, present, delta);
1327  break;
1328 
1329  case RDP_ORDER_DESKSAVE:
1330  process_desksave(This, s, &os->desksave, present, delta);
1331  break;
1332 
1333  case RDP_ORDER_MEMBLT:
1334  process_memblt(This, s, &os->memblt, present, delta);
1335  break;
1336 
1337  case RDP_ORDER_TRIBLT:
1338  process_triblt(This, s, &os->triblt, present, delta);
1339  break;
1340 
1341  case RDP_ORDER_POLYGON:
1342  process_polygon(This, s, &os->polygon, present, delta);
1343  break;
1344 
1345  case RDP_ORDER_POLYGON2:
1346  process_polygon2(This, s, &os->polygon2, present, delta);
1347  break;
1348 
1349  case RDP_ORDER_POLYLINE:
1350  process_polyline(This, s, &os->polyline, present, delta);
1351  break;
1352 
1353  case RDP_ORDER_ELLIPSE:
1354  process_ellipse(This, s, &os->ellipse, present, delta);
1355  break;
1356 
1357  case RDP_ORDER_ELLIPSE2:
1358  process_ellipse2(This, s, &os->ellipse2, present, delta);
1359  break;
1360 
1361  case RDP_ORDER_TEXT2:
1362  process_text2(This, s, &os->text2, present, delta);
1363  break;
1364 
1365  default:
1366  unimpl("order %d\n", os->order_type);
1367  return;
1368  }
1369 
1370  if (order_flags & RDP_ORDER_BOUNDS)
1372  }
1373 
1374  processed++;
1375  }
1376 #if 0
1377  /* not true when RDP_COMPRESSION is set */
1378  if (s->p != This->next_packet)
1379  error("%d bytes remaining\n", (int) (This->next_packet - s->p));
1380 #endif
1381 
1382 }
1383 
1384 /* Reset order state */
1385 void
1387 {
1388  memset(&This->orders.order_state, 0, sizeof(This->orders.order_state));
1389  This->orders.order_state.order_type = RDP_ORDER_PATBLT;
1390 }
sint16 x
Definition: orders.h:203
Definition: types.h:72
uint32 fgcolour
Definition: orders.h:177
#define RDP_ORDER_TINY
Definition: orders.h:27
sint16 srcx
Definition: orders.h:162
GLint GLint GLsizei width
Definition: gl.h:1546
void ui_memblt(uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy)
void ui_set_colourmap(RD_HCOLOURMAP map)
Definition: qtewin.cpp:1527
#define LONG_FORMAT
Definition: orders.h:333
uint8 datasize
Definition: orders.h:179
void ui_rect(int x, int y, int cx, int cy, int colour)
Definition: uimain.c:573
sint16 bottom
Definition: orders.h:127
uint32 bgcolour
Definition: orders.h:250
sint16 x
Definition: orders.h:60
#define MODE_MASK
Definition: orders.h:326
static SIZE_T datasize
Definition: asm.c:30
#define error(str)
Definition: mkdosfs.c:1605
void process_orders(STREAM s, uint16 num_orders)
Definition: orders.c:1311
sint16 y
Definition: orders.h:113
uint8 opcode
Definition: orders.h:233
sint16 top
Definition: orders.h:230
sint16 cy
Definition: orders.h:63
sint16 x
Definition: orders.h:157
signed char sint8
Definition: types.h:29
uint8 data[MAX_DATA]
Definition: orders.h:196
void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
Definition: uimain.c:567
sint16 y
Definition: orders.h:174
sint16 clipleft
Definition: orders.h:252
sint16 top
Definition: orders.h:125
sint16 x
Definition: orders.h:137
Definition: mk_font.cpp:20
static void process_bmpcache(RDPCLIENT *This, STREAM s)
Definition: orders.c:975
static void process_raw_bmpcache(RDPCLIENT *This, STREAM s)
Definition: orders.c:936
uint32 colour
Definition: orders.h:116
uint8 opcode
Definition: orders.h:104
RD_HCOLOURMAP ui_create_colourmap(COLOURMAP *colours)
Definition: uimain.c:336
#define ROP2_S(rop3)
Definition: constants.h:263
#define RDP_ORDER_DELTA
Definition: orders.h:24
unsigned int uint32
Definition: types.h:32
#define free
Definition: debug_ros.c:5
Definition: types.h:82
static BOOL rdp_parse_brush(STREAM s, BRUSH *brush, uint32 present)
Definition: orders.c:149
uint32 offset
Definition: orders.h:123
GLintptr offset
Definition: glext.h:5920
void ui_set_clip(int x, int y, int cx, int cy)
Definition: uimain.c:320
sint16 cx
Definition: orders.h:87
uint8 data[MAX_DATA]
Definition: orders.h:209
void ui_polyline(uint8 opcode, RD_POINT *points, int npoints, PEN *pen)
Definition: uimain.c:679
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
uint16 cache_idx
Definition: orders.h:164
#define RDP_ORDER_SECONDARY
Definition: orders.h:21
static void process_triblt(RDPCLIENT *This, STREAM s, TRIBLT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:443
GLuint buffer
Definition: glext.h:5915
uint32 bgcolour
Definition: orders.h:191
void ui_reset_clip(void)
Definition: uimain.c:328
LINE_ORDER line
Definition: orders.h:277
#define RDP_ORDER_CHANGE
Definition: orders.h:23
sint16 y
Definition: orders.h:158
GLenum GLuint GLsizei bufsize
Definition: glext.h:7473
#define RDP_ORDER_SMALL
Definition: orders.h:26
static void process_desksave(RDPCLIENT *This, STREAM s, DESKSAVE_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:357
#define in_uint8p(s, v, n)
Definition: parse.h:89
void ui_patblt(uint8 opcode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:597
uint32 fgcolour
Definition: orders.h:222
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
uint8 opcode
Definition: orders.h:189
sint16 cx
Definition: orders.h:114
PATBLT_ORDER patblt
Definition: orders.h:275
uint8 fillmode
Definition: orders.h:234
static void process_colcache(RDPCLIENT *This, STREAM s)
Definition: orders.c:1121
BRUSH brush
Definition: orders.h:260
uint8 opcode
Definition: orders.h:161
sint16 left
Definition: orders.h:229
#define s_check(s)
Definition: parse.h:42
static void process_line(RDPCLIENT *This, STREAM s, LINE_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:274
uint8 data[MAX_DATA]
Definition: orders.h:180
sint16 right
Definition: types.h:76
GLuint coord
Definition: glext.h:9511
static void process_fontcache(RDPCLIENT *This, STREAM s)
Definition: orders.c:1161
uint32 fgcolour
Definition: orders.h:251
sint16 x
Definition: orders.h:112
sint16 srcx
Definition: orders.h:90
uint8 flags
Definition: orders.h:247
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
SCREENBLT_ORDER screenblt
Definition: orders.h:276
sint16 boxleft
Definition: orders.h:256
#define PERSIST
Definition: orders.h:328
ELLIPSE_ORDER ellipse
Definition: orders.h:285
sint16 cx
Definition: orders.h:139
void ui_ellipse(uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:699
static void process_text2(RDPCLIENT *This, STREAM s, TEXT2_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:850
void * xmalloc(int size)
Definition: uimain.c:747
unsigned int BOOL
Definition: ntddk_ex.h:94
TRIBLT_ORDER triblt
Definition: orders.h:281
void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
Definition: uimain.c:607
uint32 fgcolour
Definition: orders.h:237
RD_BOOL bitmap_decompress(uint8 *output, int width, int height, uint8 *input, int size, int Bpp)
Definition: bitmap.c:884
RD_HBITMAP cache_get_bitmap(uint8 id, uint16 idx)
Definition: cache.c:195
#define BUFSIZE_MASK
Definition: orders.h:334
#define RDP_ORDER_LASTBOUNDS
Definition: orders.h:25
DESKSAVE_ORDER desksave
Definition: orders.h:279
uint8 width
Definition: types.h:85
static void process_memblt(RDPCLIENT *This, STREAM s, MEMBLT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:393
BRUSH brush
Definition: orders.h:78
RD_HBITMAP ui_create_bitmap(int width, int height, uint8 *data)
Definition: uimain.c:277
sint16 endy
Definition: orders.h:102
sint16 right
Definition: orders.h:126
void cache_put_bitmap(uint8 id, uint16 idx, RD_HBITMAP bitmap)
Definition: cache.c:218
uint32 fgcolour
Definition: orders.h:145
smooth NULL
Definition: ftsmooth.c:416
sint16 x
Definition: orders.h:71
void ui_line(uint8 opcode, int startx, int starty, int endx, int endy, PEN *pen)
Definition: uimain.c:513
#define in_uint8s(s, n)
Definition: parse.h:91
static BOOL rdp_parse_pen(STREAM s, PEN *pen, uint32 present)
Definition: orders.c:133
uint8 colour_table
Definition: orders.h:135
sint16 y
Definition: orders.h:262
GLuint index
Definition: glext.h:6031
static void process_secondary_order(RDPCLIENT *This, STREAM s)
Definition: orders.c:1192
sint16 cy
Definition: orders.h:74
static void rdp_in_present(STREAM s, uint32 *present, uint8 flags, int size)
Definition: orders.c:26
sint16 clipright
Definition: orders.h:254
sint16 left
Definition: orders.h:216
static void rdp_in_colour(STREAM s, uint32 *colour)
Definition: orders.c:89
DESTBLT_ORDER destblt
Definition: orders.h:274
#define RDP_ORDER_BOUNDS
Definition: orders.h:22
#define POINT
Definition: precomp.h:30
POLYLINE_ORDER polyline
Definition: orders.h:284
sint16 x
Definition: orders.h:85
uint32 bgcolour
Definition: orders.h:103
sint16 left
Definition: types.h:74
Definition: uimain.c:88
#define True
Definition: types.h:24
sint16 endx
Definition: orders.h:101
static void process_screenblt(RDPCLIENT *This, STREAM s, SCREENBLT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:239
static void process_ellipse(RDPCLIENT *This, STREAM s, ELLIPSE_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:770
void ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y, int clipx, int clipy, int clipcx, int clipcy, int boxx, int boxy, int boxcx, int boxcy, BRUSH *brush, int bgcolour, int fgcolour, uint8 *text, uint8 length)
Definition: uimain.c:412
#define False
Definition: types.h:25
sint16 y
Definition: orders.h:204
static void process_ellipse2(RDPCLIENT *This, STREAM s, ELLIPSE2_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:807
GLsizeiptr size
Definition: glext.h:5919
void xfree(void *mem)
Definition: uimain.c:758
sint16 cx
Definition: orders.h:73
MEMBLT_ORDER memblt
Definition: orders.h:280
sint16 boxbottom
Definition: orders.h:259
if(!(yy_init))
Definition: macro.lex.yy.c:714
static void process_destblt(RDPCLIENT *This, STREAM s, DESTBLT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:171
BRUSH brush
Definition: orders.h:193
sint16 startx
Definition: orders.h:99
#define RDP_ORDER_STANDARD
Definition: orders.h:20
RECT_ORDER rect
Definition: orders.h:278
POLYGON_ORDER polygon
Definition: orders.h:282
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
static int parse_delta(uint8 *buffer, int *offset)
Definition: orders.c:71
sint16 bottom
Definition: types.h:77
Definition: brush.hpp:15
sint16 cx
Definition: orders.h:62
BOUNDS bounds
Definition: orders.h:272
static void process_polygon2(RDPCLIENT *This, STREAM s, POLYGON2_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:590
sint16 y
Definition: orders.h:86
uint8 order_type
Definition: orders.h:271
#define ROP2_P(rop3)
Definition: constants.h:264
unsigned char uint8
Definition: types.h:28
sint16 cy
Definition: orders.h:88
uint8 cache_id
Definition: orders.h:136
Definition: _map.h:44
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static void process_polygon(RDPCLIENT *This, STREAM s, POLYGON_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:502
void ui_polygon(uint8 opcode, uint8 fillmode, RD_POINT *point, int npoints, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:671
sint16 top
Definition: orders.h:217
void reset_order_state(void)
Definition: orders.c:1454
GLbitfield flags
Definition: glext.h:7161
#define ID_MASK
Definition: orders.h:325
uint32 colour
Definition: types.h:86
static void rdp_in_coord(STREAM s, sint16 *coord, BOOL delta)
Definition: orders.c:54
GLsizei const GLfloat * points
Definition: glext.h:8112
uint32 bgcolour
Definition: orders.h:236
uint8 cache_id
Definition: orders.h:156
sint16 x
Definition: orders.h:187
#define index(s, c)
Definition: various.h:29
Definition: parse.h:22
uint32 fgcolour
Definition: orders.h:192
uint8 datasize
Definition: orders.h:208
uint32_t entry
Definition: isohybrid.c:63
sint16 top
Definition: types.h:75
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
signed short sint16
Definition: types.h:31
sint16 left
Definition: orders.h:124
sint16 srcy
Definition: orders.h:91
sint16 srcy
Definition: orders.h:143
GLsizei const GLfloat * value
Definition: glext.h:6069
uint8 mixmode
Definition: orders.h:249
uint8 fillmode
Definition: orders.h:176
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
static void process_patblt(RDPCLIENT *This, STREAM s, PATBLT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:200
uint16 unknown
Definition: orders.h:148
#define in_uint8a(s, v, n)
Definition: parse.h:90
sint16 starty
Definition: orders.h:100
sint16 clipbottom
Definition: orders.h:255
void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
Definition: uimain.c:581
static BOOL rdp_parse_bounds(STREAM s, BOUNDS *bounds)
Definition: orders.c:102
void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
Definition: uimain.c:561
sint16 y
Definition: orders.h:188
uint8 opcode
Definition: orders.h:64
static void process_polyline(RDPCLIENT *This, STREAM s, POLYLINE_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:684
static unsigned __int64 next
Definition: rand_nt.c:6
uint8 opcode
Definition: orders.h:89
sint16 cy
Definition: orders.h:140
uint32 fgcolour
Definition: orders.h:206
void cache_put_font(uint8 font, uint16 character, uint16 offset, uint16 baseline, uint16 width, uint16 height, RD_HGLYPH pixmap)
Definition: cache.c:296
sint16 x
Definition: orders.h:173
BRUSH brush
Definition: orders.h:146
unsigned short uint16
Definition: types.h:30
uint8 style
Definition: types.h:84
uint16 cache_idx
Definition: orders.h:147
uint8 lines
Definition: orders.h:207
BRUSH brush
Definition: orders.h:235
uint32 bgcolour
Definition: orders.h:76
#define in_uint8(s, v)
Definition: parse.h:88
uint8 opcode
Definition: orders.h:141
ELLIPSE2_ORDER ellipse2
Definition: orders.h:286
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
sint16 boxright
Definition: orders.h:258
uint8 text[MAX_TEXT]
Definition: orders.h:264
uint16 mixmode
Definition: orders.h:98
#define SQUARE
Definition: orders.h:327
#define MODE_SHIFT
Definition: orders.h:331
sint16 right
Definition: orders.h:218
static int processed(const type_t *type)
Definition: typegen.c:2236
sint16 srcx
Definition: orders.h:142
POLYGON2_ORDER polygon2
Definition: orders.h:283
uint8 opcode
Definition: orders.h:175
uint8 opcode
Definition: orders.h:205
sint16 y
Definition: orders.h:61
sint16 cx
Definition: orders.h:159
sint16 x
Definition: orders.h:261
RD_HGLYPH ui_create_glyph(int width, int height, uint8 *data)
Definition: uimain.c:234
uint8 opcode
Definition: orders.h:248
uint8 opcode
Definition: orders.h:220
#define malloc
Definition: debug_ros.c:4
sint16 y
Definition: orders.h:138
void unimpl(char *format,...)
Definition: uimain.c:801
DWORD bpp
Definition: surface.c:181
static HBITMAP bitmap
Definition: clipboard.c:1344
void ui_triblt(uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy, BRUSH *brush, int bgcolour, int fgcolour)
sint16 bottom
Definition: orders.h:232
#define DEBUG(args)
Definition: rdesktop.h:129
static HBITMAP
Definition: button.c:44
sint16 right
Definition: orders.h:231
uint8 npoints
Definition: orders.h:194
sint16 srcy
Definition: orders.h:163
sint16 boxtop
Definition: orders.h:257
sint16 cy
Definition: orders.h:115
#define in_uint32_le(s, v)
Definition: parse.h:56
static void process_rect(RDPCLIENT *This, STREAM s, RECT_ORDER *os, uint32 present, BOOL delta)
Definition: orders.c:317
uint8 fillmode
Definition: orders.h:190
sint16 cliptop
Definition: orders.h:253
uint8 action
Definition: orders.h:128
static void process_bmpcache2(RDPCLIENT *This, STREAM s, uint16 flags, BOOL compressed)
Definition: orders.c:1034
uint8 font
Definition: orders.h:246
#define memset(x, y, z)
Definition: compat.h:39
TEXT2_ORDER text2
Definition: orders.h:287
uint32 bgcolour
Definition: orders.h:144
uint8 length
Definition: orders.h:263
uint8 colour_table
Definition: orders.h:155
uint8 fillmode
Definition: orders.h:221
#define in_uint16_be(s, v)
Definition: parse.h:75
RD_BOOL pstcache_save_bitmap(uint8 cache_id, uint16 cache_idx, uint8 *key, uint8 width, uint8 height, uint16 length, uint8 *data)
Definition: pstcache.c:82
uint32 fgcolour
Definition: orders.h:77
uint8 npoints
Definition: orders.h:178
sint16 bottom
Definition: orders.h:219
PEN pen
Definition: orders.h:105
sint16 y
Definition: orders.h:72
uint8 datasize
Definition: orders.h:195
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum map
Definition: glfuncs.h:262
#define in_uint16_le(s, v)
Definition: parse.h:55
uint8 opcode
Definition: orders.h:75
sint16 cy
Definition: orders.h:160