/[rdesktop]/sourceforge.net/trunk/rdesktop/xwin.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/xwin.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 753 by stargo, Mon Aug 23 11:13:50 2004 UTC revision 949 by astrand, Tue Aug 2 15:07:35 2005 UTC
# Line 1  Line 1 
1  /* -*- c-basic-offset: 8 -*-  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     User interface services - X Window System     User interface services - X Window System
4     Copyright (C) Matthew Chapman 1999-2002     Copyright (C) Matthew Chapman 1999-2005
5    
6     This program is free software; you can redistribute it and/or modify     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     it under the terms of the GNU General Public License as published by
# Line 30  Line 30 
30    
31  extern int g_width;  extern int g_width;
32  extern int g_height;  extern int g_height;
33    extern int g_xpos;
34    extern int g_ypos;
35    extern int g_pos;
36  extern BOOL g_sendmotion;  extern BOOL g_sendmotion;
37  extern BOOL g_fullscreen;  extern BOOL g_fullscreen;
38  extern BOOL g_grab_keyboard;  extern BOOL g_grab_keyboard;
# Line 117  PixelColour; Line 120  PixelColour;
120          XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \          XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \
121  }  }
122    
123    #define FILL_POLYGON(p,np)\
124    { \
125            XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \
126            if (g_ownbackstore) \
127                    XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \
128    }
129    
130    #define DRAW_ELLIPSE(x,y,cx,cy,m)\
131    { \
132            switch (m) \
133            { \
134                    case 0: /* Outline */ \
135                            XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
136                            if (g_ownbackstore) \
137                                    XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
138                            break; \
139                    case 1: /* Filled */ \
140                            XFillArc(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, \
141                                     cx, cy, 0, 360*64); \
142                            if (g_ownbackstore) \
143                                    XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y); \
144                            break; \
145            } \
146    }
147    
148  /* colour maps */  /* colour maps */
149  extern BOOL g_owncolmap;  extern BOOL g_owncolmap;
150  static Colormap g_xcolmap;  static Colormap g_xcolmap;
# Line 170  mwm_hide_decorations(void) Line 198  mwm_hide_decorations(void)
198                          (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);                          (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
199  }  }
200    
201  static PixelColour  #define SPLITCOLOUR15(colour, rv) \
202  split_colour15(uint32 colour)  { \
203  {          rv.red = ((colour >> 7) & 0xf8) | ((colour >> 12) & 0x7); \
204          PixelColour rv;          rv.green = ((colour >> 2) & 0xf8) | ((colour >> 8) & 0x7); \
205          rv.red = ((colour >> 7) & 0xf8) | ((colour >> 12) & 0x7);          rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \
         rv.green = ((colour >> 2) & 0xf8) | ((colour >> 8) & 0x7);  
         rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7);  
         return rv;  
 }  
   
 static PixelColour  
 split_colour16(uint32 colour)  
 {  
         PixelColour rv;  
         rv.red = ((colour >> 8) & 0xf8) | ((colour >> 13) & 0x7);  
         rv.green = ((colour >> 3) & 0xfc) | ((colour >> 9) & 0x3);  
         rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7);  
         return rv;  
 }  
   
 static PixelColour  
 split_colour24(uint32 colour)  
 {  
         PixelColour rv;  
         rv.blue = (colour & 0xff0000) >> 16;  
         rv.green = (colour & 0x00ff00) >> 8;  
         rv.red = (colour & 0x0000ff);  
         return rv;  
206  }  }
207    
208  static uint32  #define SPLITCOLOUR16(colour, rv) \
209  make_colour(PixelColour pc)  { \
210  {          rv.red = ((colour >> 8) & 0xf8) | ((colour >> 13) & 0x7); \
211          return (((pc.red >> g_red_shift_r) << g_red_shift_l)          rv.green = ((colour >> 3) & 0xfc) | ((colour >> 9) & 0x3); \
212                  | ((pc.green >> g_green_shift_r) << g_green_shift_l)          rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \
213                  | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l));  } \
214    
215    #define SPLITCOLOUR24(colour, rv) \
216    { \
217            rv.blue = (colour & 0xff0000) >> 16; \
218            rv.green = (colour & 0x00ff00) >> 8; \
219            rv.red = (colour & 0x0000ff); \
220  }  }
221    
222    #define MAKECOLOUR(pc) \
223            ((pc.red >> g_red_shift_r) << g_red_shift_l) \
224                    | ((pc.green >> g_green_shift_r) << g_green_shift_l) \
225                    | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l) \
226    
227  #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }  #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
228  #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | (x & 0xff00)); }  #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | (x & 0xff00)); }
229  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
230                          x = (x << 16) | (x >> 16); }                          x = (x << 16) | (x >> 16); }
231    
232    #define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; }
233    #define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
234    #define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
235    #define LOUT16(o, x) { *(o++) = x; *(o++) = x >> 8; }
236    #define LOUT24(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; }
237    #define LOUT32(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; *(o++) = x >> 24; }
238    
239  static uint32  static uint32
240  translate_colour(uint32 colour)  translate_colour(uint32 colour)
241  {  {
# Line 220  translate_colour(uint32 colour) Line 243  translate_colour(uint32 colour)
243          switch (g_server_bpp)          switch (g_server_bpp)
244          {          {
245                  case 15:                  case 15:
246                          pc = split_colour15(colour);                          SPLITCOLOUR15(colour, pc);
247                          break;                          break;
248                  case 16:                  case 16:
249                          pc = split_colour16(colour);                          SPLITCOLOUR16(colour, pc);
250                          break;                          break;
251                  case 24:                  case 24:
252                          pc = split_colour24(colour);                          SPLITCOLOUR24(colour, pc);
253                          break;                          break;
254          }          }
255          return make_colour(pc);          return MAKECOLOUR(pc);
256  }  }
257    
258  /* indent is confused by UNROLL8 */  /* indent is confused by UNROLL8 */
# Line 249  translate_colour(uint32 colour) Line 272  translate_colour(uint32 colour)
272          while (out < end) \          while (out < end) \
273                  { stm } \                  { stm } \
274  }  }
275    /* 3 byte output repeat */
276    #define REPEAT3(stm) \
277    { \
278            while (out <= end - 8 * 3) \
279                    UNROLL8(stm) \
280            while (out < end) \
281                    { stm } \
282    }
283  /* 4 byte output repeat */  /* 4 byte output repeat */
284  #define REPEAT4(stm) \  #define REPEAT4(stm) \
285  { \  { \
# Line 257  translate_colour(uint32 colour) Line 288  translate_colour(uint32 colour)
288          while (out < end) \          while (out < end) \
289                  { stm } \                  { stm } \
290  }  }
291    /* *INDENT-ON* */
292    
293  static void  static void
294  translate8to8(uint8 * data, uint8 * out, uint8 * end)  translate8to8(const uint8 * data, uint8 * out, uint8 * end)
295  {  {
296          while (out < end)          while (out < end)
297                  *(out++) = (uint8) g_colmap[*(data++)];                  *(out++) = (uint8) g_colmap[*(data++)];
298  }  }
299    
300  static void  static void
301  translate8to16(uint8 * data, uint8 * out, uint8 * end)  translate8to16(const uint8 * data, uint8 * out, uint8 * end)
302  {  {
303          uint16 value;          uint16 value;
304    
305          if (g_arch_match)          if (g_arch_match)
306          {          {
307                    /* *INDENT-OFF* */
308                  REPEAT2                  REPEAT2
309                  (                  (
310                          *((uint16 *) out) = g_colmap[*(data++)];                          *((uint16 *) out) = g_colmap[*(data++)];
311                          out += 2;                          out += 2;
312                  )                  )
313                    /* *INDENT-ON* */
314          }          }
315          else if (g_xserver_be)          else if (g_xserver_be)
316          {          {
317                  while (out < end)                  while (out < end)
318                  {                  {
319                          value = (uint16) g_colmap[*(data++)];                          value = (uint16) g_colmap[*(data++)];
320                          *(out++) = value >> 8;                          BOUT16(out, value);
                         *(out++) = value;  
321                  }                  }
322          }          }
323          else          else
# Line 292  translate8to16(uint8 * data, uint8 * out Line 325  translate8to16(uint8 * data, uint8 * out
325                  while (out < end)                  while (out < end)
326                  {                  {
327                          value = (uint16) g_colmap[*(data++)];                          value = (uint16) g_colmap[*(data++)];
328                          *(out++) = value;                          LOUT16(out, value);
                         *(out++) = value >> 8;  
329                  }                  }
330          }          }
331  }  }
332    
333  /* little endian - conversion happens when colourmap is built */  /* little endian - conversion happens when colourmap is built */
334  static void  static void
335  translate8to24(uint8 * data, uint8 * out, uint8 * end)  translate8to24(const uint8 * data, uint8 * out, uint8 * end)
336  {  {
337          uint32 value;          uint32 value;
338    
# Line 309  translate8to24(uint8 * data, uint8 * out Line 341  translate8to24(uint8 * data, uint8 * out
341                  while (out < end)                  while (out < end)
342                  {                  {
343                          value = g_colmap[*(data++)];                          value = g_colmap[*(data++)];
344                          *(out++) = value >> 16;                          BOUT24(out, value);
                         *(out++) = value >> 8;  
                         *(out++) = value;  
345                  }                  }
346          }          }
347          else          else
# Line 319  translate8to24(uint8 * data, uint8 * out Line 349  translate8to24(uint8 * data, uint8 * out
349                  while (out < end)                  while (out < end)
350                  {                  {
351                          value = g_colmap[*(data++)];                          value = g_colmap[*(data++)];
352                          *(out++) = value;                          LOUT24(out, value);
                         *(out++) = value >> 8;  
                         *(out++) = value >> 16;  
353                  }                  }
354          }          }
355  }  }
356    
357  static void  static void
358  translate8to32(uint8 * data, uint8 * out, uint8 * end)  translate8to32(const uint8 * data, uint8 * out, uint8 * end)
359  {  {
360          uint32 value;          uint32 value;
361    
362          if (g_arch_match)          if (g_arch_match)
363          {          {
364                    /* *INDENT-OFF* */
365                  REPEAT4                  REPEAT4
366                  (                  (
367                          *((uint32 *) out) = g_colmap[*(data++)];                          *((uint32 *) out) = g_colmap[*(data++)];
368                          out += 4;                          out += 4;
369                  )                  )
370                    /* *INDENT-ON* */
371          }          }
372          else if (g_xserver_be)          else if (g_xserver_be)
373          {          {
374                  while (out < end)                  while (out < end)
375                  {                  {
376                          value = g_colmap[*(data++)];                          value = g_colmap[*(data++)];
377                          *(out++) = value >> 24;                          BOUT32(out, value);
                         *(out++) = value >> 16;  
                         *(out++) = value >> 8;  
                         *(out++) = value;  
378                  }                  }
379          }          }
380          else          else
# Line 355  translate8to32(uint8 * data, uint8 * out Line 382  translate8to32(uint8 * data, uint8 * out
382                  while (out < end)                  while (out < end)
383                  {                  {
384                          value = g_colmap[*(data++)];                          value = g_colmap[*(data++)];
385                          *(out++) = value;                          LOUT32(out, value);
                         *(out++) = value >> 8;  
                         *(out++) = value >> 16;  
                         *(out++) = value >> 24;  
386                  }                  }
387          }          }
388  }  }
389    
 /* *INDENT-ON* */  
   
390  static void  static void
391  translate15to16(uint16 * data, uint8 * out, uint8 * end)  translate15to16(const uint16 * data, uint8 * out, uint8 * end)
392  {  {
393          uint16 pixel;          uint16 pixel;
394          uint16 value;          uint16 value;
395            PixelColour pc;
396    
397          while (out < end)          if (g_xserver_be)
398          {          {
399                  pixel = *(data++);                  while (out < end)
   
                 if (g_host_be)  
                 {  
                         BSWAP16(pixel);  
                 }  
   
                 value = make_colour(split_colour15(pixel));  
   
                 if (g_xserver_be)  
400                  {                  {
401                          *(out++) = value >> 8;                          pixel = *(data++);
402                          *(out++) = value;                          if (g_host_be)
403                            {
404                                    BSWAP16(pixel);
405                            }
406                            SPLITCOLOUR15(pixel, pc);
407                            value = MAKECOLOUR(pc);
408                            BOUT16(out, value);
409                  }                  }
410                  else          }
411            else
412            {
413                    while (out < end)
414                  {                  {
415                          *(out++) = value;                          pixel = *(data++);
416                          *(out++) = value >> 8;                          if (g_host_be)
417                            {
418                                    BSWAP16(pixel);
419                            }
420                            SPLITCOLOUR15(pixel, pc);
421                            value = MAKECOLOUR(pc);
422                            LOUT16(out, value);
423                  }                  }
424          }          }
425  }  }
426    
427  static void  static void
428  translate15to24(uint16 * data, uint8 * out, uint8 * end)  translate15to24(const uint16 * data, uint8 * out, uint8 * end)
429  {  {
430          uint32 value;          uint32 value;
431          uint16 pixel;          uint16 pixel;
432            PixelColour pc;
433    
434          while (out < end)          if (g_arch_match)
435          {          {
436                  pixel = *(data++);                  /* *INDENT-OFF* */
437                    REPEAT3
438                  if (g_host_be)                  (
439                  {                          pixel = *(data++);
440                          BSWAP16(pixel);                          SPLITCOLOUR15(pixel, pc);
441                  }                          *(out++) = pc.blue;
442                            *(out++) = pc.green;
443                  value = make_colour(split_colour15(pixel));                          *(out++) = pc.red;
444                  if (g_xserver_be)                  )
445                    /* *INDENT-ON* */
446            }
447            else if (g_xserver_be)
448            {
449                    while (out < end)
450                  {                  {
451                          *(out++) = value >> 16;                          pixel = *(data++);
452                          *(out++) = value >> 8;                          if (g_host_be)
453                          *(out++) = value;                          {
454                                    BSWAP16(pixel);
455                            }
456                            SPLITCOLOUR15(pixel, pc);
457                            value = MAKECOLOUR(pc);
458                            BOUT24(out, value);
459                  }                  }
460                  else          }
461            else
462            {
463                    while (out < end)
464                  {                  {
465                          *(out++) = value;                          pixel = *(data++);
466                          *(out++) = value >> 8;                          if (g_host_be)
467                          *(out++) = value >> 16;                          {
468                                    BSWAP16(pixel);
469                            }
470                            SPLITCOLOUR15(pixel, pc);
471                            value = MAKECOLOUR(pc);
472                            LOUT24(out, value);
473                  }                  }
474          }          }
475  }  }
476    
477  static void  static void
478  translate15to32(uint16 * data, uint8 * out, uint8 * end)  translate15to32(const uint16 * data, uint8 * out, uint8 * end)
479  {  {
480          uint16 pixel;          uint16 pixel;
481          uint32 value;          uint32 value;
482            PixelColour pc;
483    
484          while (out < end)          if (g_arch_match)
485          {          {
486                  pixel = *(data++);                  /* *INDENT-OFF* */
487                    REPEAT4
488                  if (g_host_be)                  (
489                  {                          pixel = *(data++);
490                          BSWAP16(pixel);                          SPLITCOLOUR15(pixel, pc);
491                  }                          *(out++) = pc.blue;
492                            *(out++) = pc.green;
493                  value = make_colour(split_colour15(pixel));                          *(out++) = pc.red;
494                            *(out++) = 0;
495                  if (g_xserver_be)                  )
496                    /* *INDENT-ON* */
497            }
498            else if (g_xserver_be)
499            {
500                    while (out < end)
501                  {                  {
502                          *(out++) = value >> 24;                          pixel = *(data++);
503                          *(out++) = value >> 16;                          if (g_host_be)
504                          *(out++) = value >> 8;                          {
505                          *(out++) = value;                                  BSWAP16(pixel);
506                            }
507                            SPLITCOLOUR15(pixel, pc);
508                            value = MAKECOLOUR(pc);
509                            BOUT32(out, value);
510                  }                  }
511                  else          }
512            else
513            {
514                    while (out < end)
515                  {                  {
516                          *(out++) = value;                          pixel = *(data++);
517                          *(out++) = value >> 8;                          if (g_host_be)
518                          *(out++) = value >> 16;                          {
519                          *(out++) = value >> 24;                                  BSWAP16(pixel);
520                            }
521                            SPLITCOLOUR15(pixel, pc);
522                            value = MAKECOLOUR(pc);
523                            LOUT32(out, value);
524                  }                  }
525          }          }
526  }  }
527    
528  static void  static void
529  translate16to16(uint16 * data, uint8 * out, uint8 * end)  translate16to16(const uint16 * data, uint8 * out, uint8 * end)
530  {  {
531          uint16 pixel;          uint16 pixel;
532          uint16 value;          uint16 value;
533            PixelColour pc;
534    
535          while (out < end)          if (g_xserver_be)
536          {          {
                 pixel = *(data++);  
   
537                  if (g_host_be)                  if (g_host_be)
538                  {                  {
539                          BSWAP16(pixel);                          while (out < end)
540                            {
541                                    pixel = *(data++);
542                                    BSWAP16(pixel);
543                                    SPLITCOLOUR16(pixel, pc);
544                                    value = MAKECOLOUR(pc);
545                                    BOUT16(out, value);
546                            }
547                    }
548                    else
549                    {
550                            while (out < end)
551                            {
552                                    pixel = *(data++);
553                                    SPLITCOLOUR16(pixel, pc);
554                                    value = MAKECOLOUR(pc);
555                                    BOUT16(out, value);
556                            }
557                  }                  }
558            }
559                  value = make_colour(split_colour16(pixel));          else
560            {
561                  if (g_xserver_be)                  if (g_host_be)
562                  {                  {
563                          *(out++) = value >> 8;                          while (out < end)
564                          *(out++) = value;                          {
565                                    pixel = *(data++);
566                                    BSWAP16(pixel);
567                                    SPLITCOLOUR16(pixel, pc);
568                                    value = MAKECOLOUR(pc);
569                                    LOUT16(out, value);
570                            }
571                  }                  }
572                  else                  else
573                  {                  {
574                          *(out++) = value;                          while (out < end)
575                          *(out++) = value >> 8;                          {
576                                    pixel = *(data++);
577                                    SPLITCOLOUR16(pixel, pc);
578                                    value = MAKECOLOUR(pc);
579                                    LOUT16(out, value);
580                            }
581                  }                  }
582          }          }
583  }  }
584    
585  static void  static void
586  translate16to24(uint16 * data, uint8 * out, uint8 * end)  translate16to24(const uint16 * data, uint8 * out, uint8 * end)
587  {  {
588          uint32 value;          uint32 value;
589          uint16 pixel;          uint16 pixel;
590            PixelColour pc;
591    
592          while (out < end)          if (g_arch_match)
593            {
594                    /* *INDENT-OFF* */
595                    REPEAT3
596                    (
597                            pixel = *(data++);
598                            SPLITCOLOUR16(pixel, pc);
599                            *(out++) = pc.blue;
600                            *(out++) = pc.green;
601                            *(out++) = pc.red;
602                    )
603                    /* *INDENT-ON* */
604            }
605            else if (g_xserver_be)
606          {          {
                 pixel = *(data++);  
   
607                  if (g_host_be)                  if (g_host_be)
608                  {                  {
609                          BSWAP16(pixel);                          while (out < end)
610                            {
611                                    pixel = *(data++);
612                                    BSWAP16(pixel);
613                                    SPLITCOLOUR16(pixel, pc);
614                                    value = MAKECOLOUR(pc);
615                                    BOUT24(out, value);
616                            }
617                  }                  }
618                    else
                 value = make_colour(split_colour16(pixel));  
   
                 if (g_xserver_be)  
619                  {                  {
620                          *(out++) = value >> 16;                          while (out < end)
621                          *(out++) = value >> 8;                          {
622                          *(out++) = value;                                  pixel = *(data++);
623                                    SPLITCOLOUR16(pixel, pc);
624                                    value = MAKECOLOUR(pc);
625                                    BOUT24(out, value);
626                            }
627                    }
628            }
629            else
630            {
631                    if (g_host_be)
632                    {
633                            while (out < end)
634                            {
635                                    pixel = *(data++);
636                                    BSWAP16(pixel);
637                                    SPLITCOLOUR16(pixel, pc);
638                                    value = MAKECOLOUR(pc);
639                                    LOUT24(out, value);
640                            }
641                  }                  }
642                  else                  else
643                  {                  {
644                          *(out++) = value;                          while (out < end)
645                          *(out++) = value >> 8;                          {
646                          *(out++) = value >> 16;                                  pixel = *(data++);
647                                    SPLITCOLOUR16(pixel, pc);
648                                    value = MAKECOLOUR(pc);
649                                    LOUT24(out, value);
650                            }
651                  }                  }
652          }          }
653  }  }
654    
655  static void  static void
656  translate16to32(uint16 * data, uint8 * out, uint8 * end)  translate16to32(const uint16 * data, uint8 * out, uint8 * end)
657  {  {
658          uint16 pixel;          uint16 pixel;
659          uint32 value;          uint32 value;
660            PixelColour pc;
661    
662          while (out < end)          if (g_arch_match)
663            {
664                    /* *INDENT-OFF* */
665                    REPEAT4
666                    (
667                            pixel = *(data++);
668                            SPLITCOLOUR16(pixel, pc);
669                            *(out++) = pc.blue;
670                            *(out++) = pc.green;
671                            *(out++) = pc.red;
672                            *(out++) = 0;
673                    )
674                    /* *INDENT-ON* */
675            }
676            else if (g_xserver_be)
677          {          {
                 pixel = *(data++);  
   
678                  if (g_host_be)                  if (g_host_be)
679                  {                  {
680                          BSWAP16(pixel);                          while (out < end)
681                            {
682                                    pixel = *(data++);
683                                    BSWAP16(pixel);
684                                    SPLITCOLOUR16(pixel, pc);
685                                    value = MAKECOLOUR(pc);
686                                    BOUT32(out, value);
687                            }
688                  }                  }
689                    else
                 value = make_colour(split_colour16(pixel));  
   
                 if (g_xserver_be)  
690                  {                  {
691                          *(out++) = value >> 24;                          while (out < end)
692                          *(out++) = value >> 16;                          {
693                          *(out++) = value >> 8;                                  pixel = *(data++);
694                          *(out++) = value;                                  SPLITCOLOUR16(pixel, pc);
695                                    value = MAKECOLOUR(pc);
696                                    BOUT32(out, value);
697                            }
698                    }
699            }
700            else
701            {
702                    if (g_host_be)
703                    {
704                            while (out < end)
705                            {
706                                    pixel = *(data++);
707                                    BSWAP16(pixel);
708                                    SPLITCOLOUR16(pixel, pc);
709                                    value = MAKECOLOUR(pc);
710                                    LOUT32(out, value);
711                            }
712                  }                  }
713                  else                  else
714                  {                  {
715                          *(out++) = value;                          while (out < end)
716                          *(out++) = value >> 8;                          {
717                          *(out++) = value >> 16;                                  pixel = *(data++);
718                          *(out++) = value >> 24;                                  SPLITCOLOUR16(pixel, pc);
719                                    value = MAKECOLOUR(pc);
720                                    LOUT32(out, value);
721                            }
722                  }                  }
723          }          }
724  }  }
725    
726  static void  static void
727  translate24to16(uint8 * data, uint8 * out, uint8 * end)  translate24to16(const uint8 * data, uint8 * out, uint8 * end)
728  {  {
729          uint32 pixel = 0;          uint32 pixel = 0;
730          uint16 value;          uint16 value;
731            PixelColour pc;
732    
733          while (out < end)          while (out < end)
734          {          {
735                  pixel = *(data++) << 16;                  pixel = *(data++) << 16;
736                  pixel |= *(data++) << 8;                  pixel |= *(data++) << 8;
737                  pixel |= *(data++);                  pixel |= *(data++);
738                    SPLITCOLOUR24(pixel, pc);
739                  value = (uint16) make_colour(split_colour24(pixel));                  value = MAKECOLOUR(pc);
   
740                  if (g_xserver_be)                  if (g_xserver_be)
741                  {                  {
742                          *(out++) = value >> 8;                          BOUT16(out, value);
                         *(out++) = value;  
743                  }                  }
744                  else                  else
745                  {                  {
746                          *(out++) = value;                          LOUT16(out, value);
                         *(out++) = value >> 8;  
747                  }                  }
748          }          }
749  }  }
750    
751  static void  static void
752  translate24to24(uint8 * data, uint8 * out, uint8 * end)  translate24to24(const uint8 * data, uint8 * out, uint8 * end)
753  {  {
754          uint32 pixel;          uint32 pixel;
755          uint32 value;          uint32 value;
756            PixelColour pc;
757    
758          while (out < end)          if (g_xserver_be)
759          {          {
760                  pixel = *(data++) << 16;                  while (out < end)
                 pixel |= *(data++) << 8;  
                 pixel |= *(data++);  
   
                 value = make_colour(split_colour24(pixel));  
   
                 if (g_xserver_be)  
761                  {                  {
762                          *(out++) = value >> 16;                          pixel = *(data++) << 16;
763                          *(out++) = value >> 8;                          pixel |= *(data++) << 8;
764                          *(out++) = value;                          pixel |= *(data++);
765                            SPLITCOLOUR24(pixel, pc);
766                            value = MAKECOLOUR(pc);
767                            BOUT24(out, value);
768                  }                  }
769                  else          }
770            else
771            {
772                    while (out < end)
773                  {                  {
774                          *(out++) = value;                          pixel = *(data++) << 16;
775                          *(out++) = value >> 8;                          pixel |= *(data++) << 8;
776                          *(out++) = value >> 16;                          pixel |= *(data++);
777                            SPLITCOLOUR24(pixel, pc);
778                            value = MAKECOLOUR(pc);
779                            LOUT24(out, value);
780                  }                  }
781          }          }
782  }  }
783    
784  static void  static void
785  translate24to32(uint8 * data, uint8 * out, uint8 * end)  translate24to32(const uint8 * data, uint8 * out, uint8 * end)
786  {  {
787          uint32 pixel;          uint32 pixel;
788          uint32 value;          uint32 value;
789            PixelColour pc;
790    
791          while (out < end)          if (g_arch_match)
792          {          {
793                  pixel = *(data++) << 16;                  /* *INDENT-OFF* */
794                  pixel |= *(data++) << 8;  #ifdef NEED_ALIGN
795                  pixel |= *(data++);                  REPEAT4
796                    (
797                  value = make_colour(split_colour24(pixel));                          *(out++) = *(data++);
798                            *(out++) = *(data++);
799                  if (g_xserver_be)                          *(out++) = *(data++);
800                            *(out++) = 0;
801                    )
802    #else
803                    REPEAT4
804                    (
805                            *((uint32 *) out) = *((uint32 *) data);
806                            out += 4;
807                            data += 3;
808                    )
809    #endif
810                    /* *INDENT-ON* */
811            }
812            else if (g_xserver_be)
813            {
814                    while (out < end)
815                  {                  {
816                          *(out++) = value >> 24;                          pixel = *(data++) << 16;
817                          *(out++) = value >> 16;                          pixel |= *(data++) << 8;
818                          *(out++) = value >> 8;                          pixel |= *(data++);
819                          *(out++) = value;                          SPLITCOLOUR24(pixel, pc);
820                            value = MAKECOLOUR(pc);
821                            BOUT32(out, value);
822                  }                  }
823                  else          }
824            else
825            {
826                    while (out < end)
827                  {                  {
828                          *(out++) = value;                          pixel = *(data++) << 16;
829                          *(out++) = value >> 8;                          pixel |= *(data++) << 8;
830                          *(out++) = value >> 16;                          pixel |= *(data++);
831                          *(out++) = value >> 24;                          SPLITCOLOUR24(pixel, pc);
832                            value = MAKECOLOUR(pc);
833                            LOUT32(out, value);
834                  }                  }
835          }          }
836  }  }
# Line 658  translate_image(int width, int height, u Line 851  translate_image(int width, int height, u
851                          return data;                          return data;
852                  if (g_depth == 16 && g_server_bpp == 16)                  if (g_depth == 16 && g_server_bpp == 16)
853                          return data;                          return data;
854                    if (g_depth == 24 && g_bpp == 24 && g_server_bpp == 24)
855                            return data;
856          }          }
857    
858          size = width * height * (g_bpp / 8);          size = width * height * (g_bpp / 8);
# Line 831  ui_init(void) Line 1026  ui_init(void)
1026                  calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l);                  calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l);
1027                  calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l);                  calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l);
1028    
1029                  /* if RGB video and averything is little endian */                  /* if RGB video and everything is little endian */
1030                  if (vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask)                  if ((vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask) &&
1031                          if (!g_xserver_be && !g_host_be)                      !g_xserver_be && !g_host_be)
1032                    {
1033                            if (g_depth <= 16 || (g_red_shift_l == 16 && g_green_shift_l == 8 &&
1034                                                  g_blue_shift_l == 0))
1035                            {
1036                                  g_arch_match = True;                                  g_arch_match = True;
1037                            }
1038                    }
1039    
1040                    if (g_arch_match)
1041                    {
1042                            DEBUG(("Architectures match, enabling little endian optimisations.\n"));
1043                    }
1044          }          }
1045    
1046          pfm = XListPixmapFormats(g_display, &i);          pfm = XListPixmapFormats(g_display, &i);
# Line 946  BOOL Line 1152  BOOL
1152  ui_create_window(void)  ui_create_window(void)
1153  {  {
1154          uint8 null_pointer_mask[1] = { 0x80 };          uint8 null_pointer_mask[1] = { 0x80 };
1155          uint8 null_pointer_data[4] = { 0x00, 0x00, 0x00, 0x00 };          uint8 null_pointer_data[24] = { 0x00 };
1156    
1157          XSetWindowAttributes attribs;          XSetWindowAttributes attribs;
1158          XClassHint *classhints;          XClassHint *classhints;
1159          XSizeHints *sizehints;          XSizeHints *sizehints;
# Line 957  ui_create_window(void) Line 1164  ui_create_window(void)
1164          wndwidth = g_fullscreen ? WidthOfScreen(g_screen) : g_width;          wndwidth = g_fullscreen ? WidthOfScreen(g_screen) : g_width;
1165          wndheight = g_fullscreen ? HeightOfScreen(g_screen) : g_height;          wndheight = g_fullscreen ? HeightOfScreen(g_screen) : g_height;
1166    
1167            /* Handle -x-y portion of geometry string */
1168            if (g_xpos < 0 || (g_xpos == 0 && (g_pos & 2)))
1169                    g_xpos = WidthOfScreen(g_screen) + g_xpos - g_width;
1170            if (g_ypos < 0 || (g_ypos == 0 && (g_pos & 4)))
1171                    g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;
1172    
1173          attribs.background_pixel = BlackPixelOfScreen(g_screen);          attribs.background_pixel = BlackPixelOfScreen(g_screen);
1174          attribs.border_pixel = WhitePixelOfScreen(g_screen);          attribs.border_pixel = WhitePixelOfScreen(g_screen);
1175          attribs.backing_store = g_ownbackstore ? NotUseful : Always;          attribs.backing_store = g_ownbackstore ? NotUseful : Always;
1176          attribs.override_redirect = g_fullscreen;          attribs.override_redirect = g_fullscreen;
1177          attribs.colormap = g_xcolmap;          attribs.colormap = g_xcolmap;
1178    
1179          g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), 0, 0, wndwidth, wndheight,          g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,
1180                                0, g_depth, InputOutput, g_visual,                                wndheight, 0, g_depth, InputOutput, g_visual,
1181                                CWBackPixel | CWBackingStore | CWOverrideRedirect |                                CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap |
1182                                CWColormap | CWBorderPixel, &attribs);                                CWBorderPixel, &attribs);
1183    
1184          if (g_gc == NULL)          if (g_gc == NULL)
1185                  g_gc = XCreateGC(g_display, g_wnd, 0, NULL);                  g_gc = XCreateGC(g_display, g_wnd, 0, NULL);
# Line 1000  ui_create_window(void) Line 1213  ui_create_window(void)
1213          if (sizehints)          if (sizehints)
1214          {          {
1215                  sizehints->flags = PMinSize | PMaxSize;                  sizehints->flags = PMinSize | PMaxSize;
1216                    if (g_pos)
1217                            sizehints->flags |= PPosition;
1218                  sizehints->min_width = sizehints->max_width = g_width;                  sizehints->min_width = sizehints->max_width = g_width;
1219                  sizehints->min_height = sizehints->max_height = g_height;                  sizehints->min_height = sizehints->max_height = g_height;
1220                  XSetWMNormalHints(g_display, g_wnd, sizehints);                  XSetWMNormalHints(g_display, g_wnd, sizehints);
# Line 1012  ui_create_window(void) Line 1227  ui_create_window(void)
1227          }          }
1228    
1229          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
1230                  VisibilityChangeMask | FocusChangeMask;                  VisibilityChangeMask | FocusChangeMask | StructureNotifyMask;
1231    
1232          if (g_sendmotion)          if (g_sendmotion)
1233                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
# Line 1126  xwin_toggle_fullscreen(void) Line 1341  xwin_toggle_fullscreen(void)
1341          }          }
1342  }  }
1343    
1344  /* Process all events in Xlib queue  /* Process events in Xlib queue
1345     Returns 0 after user quit, 1 otherwise */     Returns 0 after user quit, 1 otherwise */
1346  static int  static int
1347  xwin_process_events(void)  xwin_process_events(void)
# Line 1135  xwin_process_events(void) Line 1350  xwin_process_events(void)
1350          KeySym keysym;          KeySym keysym;
1351          uint16 button, flags;          uint16 button, flags;
1352          uint32 ev_time;          uint32 ev_time;
         key_translation tr;  
1353          char str[256];          char str[256];
1354          Status status;          Status status;
1355            int events = 0;
1356    
1357          while (XPending(g_display) > 0)          while ((XPending(g_display) > 0) && events++ < 20)
1358          {          {
1359                  XNextEvent(g_display, &xevent);                  XNextEvent(g_display, &xevent);
1360    
# Line 1187  xwin_process_events(void) Line 1402  xwin_process_events(void)
1402                                                        str, sizeof(str), &keysym, NULL);                                                        str, sizeof(str), &keysym, NULL);
1403                                  }                                  }
1404    
1405                                  DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym,                                  DEBUG_KBD(("KeyPress for keysym (0x%lx, %s)\n", keysym,
1406                                             get_ksname(keysym)));                                             get_ksname(keysym)));
1407    
1408                                  ev_time = time(NULL);                                  ev_time = time(NULL);
1409                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
1410                                          break;                                          break;
1411    
1412                                  tr = xkeymap_translate_key(keysym,                                  xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
1413                                                             xevent.xkey.keycode, xevent.xkey.state);                                                    ev_time, True);
   
                                 if (tr.scancode == 0)  
                                         break;  
   
                                 save_remote_modifiers(tr.scancode);  
                                 ensure_remote_modifiers(ev_time, tr);  
                                 rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);  
                                 restore_remote_modifiers(ev_time, tr.scancode);  
   
1414                                  break;                                  break;
1415    
1416                          case KeyRelease:                          case KeyRelease:
# Line 1212  xwin_process_events(void) Line 1418  xwin_process_events(void)
1418                                  XLookupString((XKeyEvent *) & xevent, str,                                  XLookupString((XKeyEvent *) & xevent, str,
1419                                                sizeof(str), &keysym, NULL);                                                sizeof(str), &keysym, NULL);
1420    
1421                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,                                  DEBUG_KBD(("\nKeyRelease for keysym (0x%lx, %s)\n", keysym,
1422                                             get_ksname(keysym)));                                             get_ksname(keysym)));
1423    
1424                                  ev_time = time(NULL);                                  ev_time = time(NULL);
1425                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
1426                                          break;                                          break;
1427    
1428                                  tr = xkeymap_translate_key(keysym,                                  xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
1429                                                             xevent.xkey.keycode, xevent.xkey.state);                                                    ev_time, False);
   
                                 if (tr.scancode == 0)  
                                         break;  
   
                                 rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);  
1430                                  break;                                  break;
1431    
1432                          case ButtonPress:                          case ButtonPress:
# Line 1383  xwin_process_events(void) Line 1584  xwin_process_events(void)
1584                          case PropertyNotify:                          case PropertyNotify:
1585                                  xclip_handle_PropertyNotify(&xevent.xproperty);                                  xclip_handle_PropertyNotify(&xevent.xproperty);
1586                                  break;                                  break;
1587                            case MapNotify:
1588                                    rdp_send_client_window_status(1);
1589                                    break;
1590                            case UnmapNotify:
1591                                    rdp_send_client_window_status(0);
1592                                    break;
1593                  }                  }
1594          }          }
1595          /* Keep going */          /* Keep going */
# Line 1434  ui_select(int rdp_socket) Line 1641  ui_select(int rdp_socket)
1641                                  error("select: %s\n", strerror(errno));                                  error("select: %s\n", strerror(errno));
1642    
1643                          case 0:                          case 0:
1644                                  /* TODO: if tv.tv_sec just times out                                  /* Abort serial read calls */
1645                                   * we will segfault.                                  if (s_timeout)
1646                                   * FIXME:                                          rdpdr_check_fds(&rfds, &wfds, (BOOL) True);
                                  */  
                                 //s_timeout = True;  
                                 //rdpdr_check_fds(&rfds, &wfds, (BOOL) True);  
1647                                  continue;                                  continue;
1648                  }                  }
1649    
1650                  rdpdr_check_fds(&rfds, &wfds, (BOOL) False);                  rdpdr_check_fds(&rfds, &wfds, (BOOL) False);
1651    
1652                    if (FD_ISSET(rdp_socket, &rfds))
1653                            return 1;
1654    
1655  #ifdef WITH_RDPSND  #ifdef WITH_RDPSND
1656                  if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))                  if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))
1657                          wave_out_play();                          wave_out_play();
1658  #endif  #endif
   
                 if (FD_ISSET(rdp_socket, &rfds))  
                         return 1;  
1659          }          }
1660  }  }
1661    
# Line 1988  ui_rect( Line 2192  ui_rect(
2192          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE(x, y, cx, cy);
2193  }  }
2194    
2195    void
2196    ui_polygon(uint8 opcode,
2197               /* mode */ uint8 fillmode,
2198               /* dest */ POINT * point, int npoints,
2199               /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
2200    {
2201            uint8 style, i, ipattern[8];
2202            Pixmap fill;
2203    
2204            SET_FUNCTION(opcode);
2205    
2206            switch (fillmode)
2207            {
2208                    case ALTERNATE:
2209                            XSetFillRule(g_display, g_gc, EvenOddRule);
2210                            break;
2211                    case WINDING:
2212                            XSetFillRule(g_display, g_gc, WindingRule);
2213                            break;
2214                    default:
2215                            unimpl("fill mode %d\n", fillmode);
2216            }
2217    
2218            if (brush)
2219                    style = brush->style;
2220            else
2221                    style = 0;
2222    
2223            switch (style)
2224            {
2225                    case 0: /* Solid */
2226                            SET_FOREGROUND(fgcolour);
2227                            FILL_POLYGON((XPoint *) point, npoints);
2228                            break;
2229    
2230                    case 2: /* Hatch */
2231                            fill = (Pixmap) ui_create_glyph(8, 8,
2232                                                            hatch_patterns + brush->pattern[0] * 8);
2233                            SET_FOREGROUND(fgcolour);
2234                            SET_BACKGROUND(bgcolour);
2235                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2236                            XSetStipple(g_display, g_gc, fill);
2237                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2238                            FILL_POLYGON((XPoint *) point, npoints);
2239                            XSetFillStyle(g_display, g_gc, FillSolid);
2240                            XSetTSOrigin(g_display, g_gc, 0, 0);
2241                            ui_destroy_glyph((HGLYPH) fill);
2242                            break;
2243    
2244                    case 3: /* Pattern */
2245                            for (i = 0; i != 8; i++)
2246                                    ipattern[7 - i] = brush->pattern[i];
2247                            fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
2248                            SET_FOREGROUND(bgcolour);
2249                            SET_BACKGROUND(fgcolour);
2250                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2251                            XSetStipple(g_display, g_gc, fill);
2252                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2253                            FILL_POLYGON((XPoint *) point, npoints);
2254                            XSetFillStyle(g_display, g_gc, FillSolid);
2255                            XSetTSOrigin(g_display, g_gc, 0, 0);
2256                            ui_destroy_glyph((HGLYPH) fill);
2257                            break;
2258    
2259                    default:
2260                            unimpl("brush %d\n", brush->style);
2261            }
2262    
2263            RESET_FUNCTION(opcode);
2264    }
2265    
2266    void
2267    ui_polyline(uint8 opcode,
2268                /* dest */ POINT * points, int npoints,
2269                /* pen */ PEN * pen)
2270    {
2271            /* TODO: set join style */
2272            SET_FUNCTION(opcode);
2273            SET_FOREGROUND(pen->colour);
2274            XDrawLines(g_display, g_wnd, g_gc, (XPoint *) points, npoints, CoordModePrevious);
2275            if (g_ownbackstore)
2276                    XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
2277                               CoordModePrevious);
2278            RESET_FUNCTION(opcode);
2279    }
2280    
2281    void
2282    ui_ellipse(uint8 opcode,
2283               /* mode */ uint8 fillmode,
2284               /* dest */ int x, int y, int cx, int cy,
2285               /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
2286    {
2287            uint8 style, i, ipattern[8];
2288            Pixmap fill;
2289    
2290            SET_FUNCTION(opcode);
2291    
2292            if (brush)
2293                    style = brush->style;
2294            else
2295                    style = 0;
2296    
2297            switch (style)
2298            {
2299                    case 0: /* Solid */
2300                            SET_FOREGROUND(fgcolour);
2301                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2302                            break;
2303    
2304                    case 2: /* Hatch */
2305                            fill = (Pixmap) ui_create_glyph(8, 8,
2306                                                            hatch_patterns + brush->pattern[0] * 8);
2307                            SET_FOREGROUND(fgcolour);
2308                            SET_BACKGROUND(bgcolour);
2309                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2310                            XSetStipple(g_display, g_gc, fill);
2311                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2312                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2313                            XSetFillStyle(g_display, g_gc, FillSolid);
2314                            XSetTSOrigin(g_display, g_gc, 0, 0);
2315                            ui_destroy_glyph((HGLYPH) fill);
2316                            break;
2317    
2318                    case 3: /* Pattern */
2319                            for (i = 0; i != 8; i++)
2320                                    ipattern[7 - i] = brush->pattern[i];
2321                            fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
2322                            SET_FOREGROUND(bgcolour);
2323                            SET_BACKGROUND(fgcolour);
2324                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2325                            XSetStipple(g_display, g_gc, fill);
2326                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2327                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2328                            XSetFillStyle(g_display, g_gc, FillSolid);
2329                            XSetTSOrigin(g_display, g_gc, 0, 0);
2330                            ui_destroy_glyph((HGLYPH) fill);
2331                            break;
2332    
2333                    default:
2334                            unimpl("brush %d\n", brush->style);
2335            }
2336    
2337            RESET_FUNCTION(opcode);
2338    }
2339    
2340  /* warning, this function only draws on wnd or backstore, not both */  /* warning, this function only draws on wnd or backstore, not both */
2341  void  void
2342  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
# Line 2043  ui_draw_glyph(int mixmode, Line 2392  ui_draw_glyph(int mixmode,
2392  }  }
2393    
2394  void  void
2395  ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y,  ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y,
2396               int clipx, int clipy, int clipcx, int clipcy,               int clipx, int clipy, int clipcx, int clipcy,
2397               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
2398               int fgcolour, uint8 * text, uint8 length)               int bgcolour, int fgcolour, uint8 * text, uint8 length)
2399  {  {
2400            /* TODO: use brush appropriately */
2401    
2402          FONTGLYPH *glyph;          FONTGLYPH *glyph;
2403          int i, j, xyoffset, x1, y1;          int i, j, xyoffset, x1, y1;
2404          DATABLOB *entry;          DATABLOB *entry;
Legend:
Removed from v.753  
changed lines
  Added in v.949
  ViewVC Help
Powered by ViewVC 1.1.26