/[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 713 by jsorg71, Wed Jun 16 03:08:55 2004 UTC revision 988 by astrand, Thu Aug 25 20:27:45 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 47  extern uint32 g_embed_wnd; Line 50  extern uint32 g_embed_wnd;
50  BOOL g_enable_compose = False;  BOOL g_enable_compose = False;
51  BOOL g_Unobscured;              /* used for screenblt */  BOOL g_Unobscured;              /* used for screenblt */
52  static GC g_gc = NULL;  static GC g_gc = NULL;
53    static GC g_create_bitmap_gc = NULL;
54    static GC g_create_glyph_gc = NULL;
55  static Visual *g_visual;  static Visual *g_visual;
56  static int g_depth;  static int g_depth;
57  static int g_bpp;  static int g_bpp;
# Line 115  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 168  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 218  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 247  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 255  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 290  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 307  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 317  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 353  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
                 value = make_colour(split_colour16(pixel));  
   
                 if (g_xserver_be)  
549                  {                  {
550                          *(out++) = value >> 8;                          while (out < end)
551                          *(out++) = value;                          {
552                                    pixel = *(data++);
553                                    SPLITCOLOUR16(pixel, pc);
554                                    value = MAKECOLOUR(pc);
555                                    BOUT16(out, value);
556                            }
557                    }
558            }
559            else
560            {
561                    if (g_host_be)
562                    {
563                            while (out < end)
564                            {
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 656  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 829  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 944  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 955  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);
1186    
1187            if (g_create_bitmap_gc == NULL)
1188                    g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);
1189    
1190          if ((g_ownbackstore) && (g_backstore == 0))          if ((g_ownbackstore) && (g_backstore == 0))
1191          {          {
1192                  g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);                  g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
# Line 995  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 1007  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 1121  xwin_toggle_fullscreen(void) Line 1341  xwin_toggle_fullscreen(void)
1341          }          }
1342  }  }
1343    
1344  /* Process all events in Xlib queue  static void
1345    handle_button_event(XEvent xevent, BOOL down)
1346    {
1347            uint16 button, flags = 0;
1348            g_last_gesturetime = xevent.xbutton.time;
1349            button = xkeymap_translate_button(xevent.xbutton.button);
1350            if (button == 0)
1351                    return;
1352    
1353            if (down)
1354                    flags = MOUSE_FLAG_DOWN;
1355    
1356            /* Stop moving window when button is released, regardless of cursor position */
1357            if (g_moving_wnd && (xevent.type == ButtonRelease))
1358                    g_moving_wnd = False;
1359    
1360            /* If win_button_size is nonzero, enable single app mode */
1361            if (xevent.xbutton.y < g_win_button_size)
1362            {
1363                    /*  Check from right to left: */
1364                    if (xevent.xbutton.x >= g_width - g_win_button_size)
1365                    {
1366                            /* The close button, continue */
1367                            ;
1368                    }
1369                    else if (xevent.xbutton.x >= g_width - g_win_button_size * 2)
1370                    {
1371                            /* The maximize/restore button. Do not send to
1372                               server.  It might be a good idea to change the
1373                               cursor or give some other visible indication
1374                               that rdesktop inhibited this click */
1375                            if (xevent.type == ButtonPress)
1376                                    return;
1377                    }
1378                    else if (xevent.xbutton.x >= g_width - g_win_button_size * 3)
1379                    {
1380                            /* The minimize button. Iconify window. */
1381                            if (xevent.type == ButtonRelease)
1382                            {
1383                                    /* Release the mouse button outside the minimize button, to prevent the
1384                                       actual minimazation to happen */
1385                                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE, button, 1, 1);
1386                                    XIconifyWindow(g_display, g_wnd, DefaultScreen(g_display));
1387                                    return;
1388                            }
1389                    }
1390                    else if (xevent.xbutton.x <= g_win_button_size)
1391                    {
1392                            /* The system menu. Ignore. */
1393                            if (xevent.type == ButtonPress)
1394                                    return;
1395                    }
1396                    else
1397                    {
1398                            /* The title bar. */
1399                            if (xevent.type == ButtonPress)
1400                            {
1401                                    if (!g_fullscreen && g_hide_decorations)
1402                                    {
1403                                            g_moving_wnd = True;
1404                                            g_move_x_offset = xevent.xbutton.x;
1405                                            g_move_y_offset = xevent.xbutton.y;
1406                                    }
1407                                    return;
1408                            }
1409                    }
1410            }
1411    
1412            rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
1413                           flags | button, xevent.xbutton.x, xevent.xbutton.y);
1414    }
1415    
1416    /* Process events in Xlib queue
1417     Returns 0 after user quit, 1 otherwise */     Returns 0 after user quit, 1 otherwise */
1418  static int  static int
1419  xwin_process_events(void)  xwin_process_events(void)
1420  {  {
1421          XEvent xevent;          XEvent xevent;
1422          KeySym keysym;          KeySym keysym;
         uint16 button, flags;  
1423          uint32 ev_time;          uint32 ev_time;
         key_translation tr;  
1424          char str[256];          char str[256];
1425          Status status;          Status status;
1426            int events = 0;
1427    
1428          while (XPending(g_display) > 0)          while ((XPending(g_display) > 0) && events++ < 20)
1429          {          {
1430                  XNextEvent(g_display, &xevent);                  XNextEvent(g_display, &xevent);
1431    
# Line 1144  xwin_process_events(void) Line 1435  xwin_process_events(void)
1435                          continue;                          continue;
1436                  }                  }
1437    
                 flags = 0;  
   
1438                  switch (xevent.type)                  switch (xevent.type)
1439                  {                  {
1440                          case VisibilityNotify:                          case VisibilityNotify:
# Line 1182  xwin_process_events(void) Line 1471  xwin_process_events(void)
1471                                                        str, sizeof(str), &keysym, NULL);                                                        str, sizeof(str), &keysym, NULL);
1472                                  }                                  }
1473    
1474                                  DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym,                                  DEBUG_KBD(("KeyPress for keysym (0x%lx, %s)\n", keysym,
1475                                             get_ksname(keysym)));                                             get_ksname(keysym)));
1476    
1477                                  ev_time = time(NULL);                                  ev_time = time(NULL);
1478                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
1479                                          break;                                          break;
1480    
1481                                  tr = xkeymap_translate_key(keysym,                                  xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
1482                                                             xevent.xkey.keycode, xevent.xkey.state);                                                    ev_time, True, 0);
   
                                 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);  
   
1483                                  break;                                  break;
1484    
1485                          case KeyRelease:                          case KeyRelease:
# Line 1207  xwin_process_events(void) Line 1487  xwin_process_events(void)
1487                                  XLookupString((XKeyEvent *) & xevent, str,                                  XLookupString((XKeyEvent *) & xevent, str,
1488                                                sizeof(str), &keysym, NULL);                                                sizeof(str), &keysym, NULL);
1489    
1490                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,                                  DEBUG_KBD(("\nKeyRelease for keysym (0x%lx, %s)\n", keysym,
1491                                             get_ksname(keysym)));                                             get_ksname(keysym)));
1492    
1493                                  ev_time = time(NULL);                                  ev_time = time(NULL);
1494                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
1495                                          break;                                          break;
1496    
1497                                  tr = xkeymap_translate_key(keysym,                                  xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
1498                                                             xevent.xkey.keycode, xevent.xkey.state);                                                    ev_time, False, 0);
   
                                 if (tr.scancode == 0)  
                                         break;  
   
                                 rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);  
1499                                  break;                                  break;
1500    
1501                          case ButtonPress:                          case ButtonPress:
1502                                  flags = MOUSE_FLAG_DOWN;                                  handle_button_event(xevent, True);
1503                                  /* fall through */                                  break;
1504    
1505                          case ButtonRelease:                          case ButtonRelease:
1506                                  g_last_gesturetime = xevent.xbutton.time;                                  handle_button_event(xevent, False);
                                 button = xkeymap_translate_button(xevent.xbutton.button);  
                                 if (button == 0)  
                                         break;  
   
                                 /* If win_button_size is nonzero, enable single app mode */  
                                 if (xevent.xbutton.y < g_win_button_size)  
                                 {  
                                         /* Stop moving window when button is released, regardless of cursor position */  
                                         if (g_moving_wnd && (xevent.type == ButtonRelease))  
                                                 g_moving_wnd = False;  
   
                                         /*  Check from right to left: */  
   
                                         if (xevent.xbutton.x >= g_width - g_win_button_size)  
                                         {  
                                                 /* The close button, continue */  
                                                 ;  
                                         }  
                                         else if (xevent.xbutton.x >=  
                                                  g_width - g_win_button_size * 2)  
                                         {  
                                                 /* The maximize/restore button. Do not send to  
                                                    server.  It might be a good idea to change the  
                                                    cursor or give some other visible indication  
                                                    that rdesktop inhibited this click */  
                                                 break;  
                                         }  
                                         else if (xevent.xbutton.x >=  
                                                  g_width - g_win_button_size * 3)  
                                         {  
                                                 /* The minimize button. Iconify window. */  
                                                 XIconifyWindow(g_display, g_wnd,  
                                                                DefaultScreen(g_display));  
                                                 break;  
                                         }  
                                         else if (xevent.xbutton.x <= g_win_button_size)  
                                         {  
                                                 /* The system menu. Ignore. */  
                                                 break;  
                                         }  
                                         else  
                                         {  
                                                 /* The title bar. */  
                                                 if ((xevent.type == ButtonPress) && !g_fullscreen  
                                                     && g_hide_decorations)  
                                                 {  
                                                         g_moving_wnd = True;  
                                                         g_move_x_offset = xevent.xbutton.x;  
                                                         g_move_y_offset = xevent.xbutton.y;  
                                                 }  
                                                 break;  
   
                                         }  
                                 }  
   
                                 rdp_send_input(time(NULL), RDP_INPUT_MOUSE,  
                                                flags | button, xevent.xbutton.x, xevent.xbutton.y);  
1507                                  break;                                  break;
1508    
1509                          case MotionNotify:                          case MotionNotify:
# Line 1378  xwin_process_events(void) Line 1596  xwin_process_events(void)
1596                          case PropertyNotify:                          case PropertyNotify:
1597                                  xclip_handle_PropertyNotify(&xevent.xproperty);                                  xclip_handle_PropertyNotify(&xevent.xproperty);
1598                                  break;                                  break;
1599                            case MapNotify:
1600                                    rdp_send_client_window_status(1);
1601                                    break;
1602                            case UnmapNotify:
1603                                    rdp_send_client_window_status(0);
1604                                    break;
1605                  }                  }
1606          }          }
1607          /* Keep going */          /* Keep going */
# Line 1429  ui_select(int rdp_socket) Line 1653  ui_select(int rdp_socket)
1653                                  error("select: %s\n", strerror(errno));                                  error("select: %s\n", strerror(errno));
1654    
1655                          case 0:                          case 0:
1656                                  /* TODO: if tv.tv_sec just times out                                  /* Abort serial read calls */
1657                                   * we will segfault.                                  if (s_timeout)
1658                                   * FIXME:                                          rdpdr_check_fds(&rfds, &wfds, (BOOL) True);
                                  */  
                                 //s_timeout = True;  
                                 //rdpdr_check_fds(&rfds, &wfds, (BOOL) True);  
1659                                  continue;                                  continue;
1660                  }                  }
1661    
# Line 1481  ui_create_bitmap(int width, int height, Line 1702  ui_create_bitmap(int width, int height,
1702          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
1703                               (char *) tdata, width, height, bitmap_pad, 0);                               (char *) tdata, width, height, bitmap_pad, 0);
1704    
1705          XPutImage(g_display, bitmap, g_gc, image, 0, 0, 0, 0, width, height);          XPutImage(g_display, bitmap, g_create_bitmap_gc, image, 0, 0, 0, 0, width, height);
1706    
1707          XFree(image);          XFree(image);
1708          if (tdata != data)          if (tdata != data)
# Line 1539  ui_create_glyph(int width, int height, u Line 1760  ui_create_glyph(int width, int height, u
1760          XImage *image;          XImage *image;
1761          Pixmap bitmap;          Pixmap bitmap;
1762          int scanline;          int scanline;
         GC gc;  
1763    
1764          scanline = (width + 7) / 8;          scanline = (width + 7) / 8;
1765    
1766          bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1);          bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1);
1767          gc = XCreateGC(g_display, bitmap, 0, NULL);          if (g_create_glyph_gc == 0)
1768                    g_create_glyph_gc = XCreateGC(g_display, bitmap, 0, NULL);
1769    
1770          image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data,          image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data,
1771                               width, height, 8, scanline);                               width, height, 8, scanline);
# Line 1552  ui_create_glyph(int width, int height, u Line 1773  ui_create_glyph(int width, int height, u
1773          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
1774          XInitImage(image);          XInitImage(image);
1775    
1776          XPutImage(g_display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(g_display, bitmap, g_create_glyph_gc, image, 0, 0, 0, 0, width, height);
1777    
1778          XFree(image);          XFree(image);
         XFreeGC(g_display, gc);  
1779          return (HGLYPH) bitmap;          return (HGLYPH) bitmap;
1780  }  }
1781    
# Line 1984  ui_rect( Line 2204  ui_rect(
2204          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE(x, y, cx, cy);
2205  }  }
2206    
2207    void
2208    ui_polygon(uint8 opcode,
2209               /* mode */ uint8 fillmode,
2210               /* dest */ POINT * point, int npoints,
2211               /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
2212    {
2213            uint8 style, i, ipattern[8];
2214            Pixmap fill;
2215    
2216            SET_FUNCTION(opcode);
2217    
2218            switch (fillmode)
2219            {
2220                    case ALTERNATE:
2221                            XSetFillRule(g_display, g_gc, EvenOddRule);
2222                            break;
2223                    case WINDING:
2224                            XSetFillRule(g_display, g_gc, WindingRule);
2225                            break;
2226                    default:
2227                            unimpl("fill mode %d\n", fillmode);
2228            }
2229    
2230            if (brush)
2231                    style = brush->style;
2232            else
2233                    style = 0;
2234    
2235            switch (style)
2236            {
2237                    case 0: /* Solid */
2238                            SET_FOREGROUND(fgcolour);
2239                            FILL_POLYGON((XPoint *) point, npoints);
2240                            break;
2241    
2242                    case 2: /* Hatch */
2243                            fill = (Pixmap) ui_create_glyph(8, 8,
2244                                                            hatch_patterns + brush->pattern[0] * 8);
2245                            SET_FOREGROUND(fgcolour);
2246                            SET_BACKGROUND(bgcolour);
2247                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2248                            XSetStipple(g_display, g_gc, fill);
2249                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2250                            FILL_POLYGON((XPoint *) point, npoints);
2251                            XSetFillStyle(g_display, g_gc, FillSolid);
2252                            XSetTSOrigin(g_display, g_gc, 0, 0);
2253                            ui_destroy_glyph((HGLYPH) fill);
2254                            break;
2255    
2256                    case 3: /* Pattern */
2257                            for (i = 0; i != 8; i++)
2258                                    ipattern[7 - i] = brush->pattern[i];
2259                            fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
2260                            SET_FOREGROUND(bgcolour);
2261                            SET_BACKGROUND(fgcolour);
2262                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2263                            XSetStipple(g_display, g_gc, fill);
2264                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2265                            FILL_POLYGON((XPoint *) point, npoints);
2266                            XSetFillStyle(g_display, g_gc, FillSolid);
2267                            XSetTSOrigin(g_display, g_gc, 0, 0);
2268                            ui_destroy_glyph((HGLYPH) fill);
2269                            break;
2270    
2271                    default:
2272                            unimpl("brush %d\n", brush->style);
2273            }
2274    
2275            RESET_FUNCTION(opcode);
2276    }
2277    
2278    void
2279    ui_polyline(uint8 opcode,
2280                /* dest */ POINT * points, int npoints,
2281                /* pen */ PEN * pen)
2282    {
2283            /* TODO: set join style */
2284            SET_FUNCTION(opcode);
2285            SET_FOREGROUND(pen->colour);
2286            XDrawLines(g_display, g_wnd, g_gc, (XPoint *) points, npoints, CoordModePrevious);
2287            if (g_ownbackstore)
2288                    XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
2289                               CoordModePrevious);
2290            RESET_FUNCTION(opcode);
2291    }
2292    
2293    void
2294    ui_ellipse(uint8 opcode,
2295               /* mode */ uint8 fillmode,
2296               /* dest */ int x, int y, int cx, int cy,
2297               /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
2298    {
2299            uint8 style, i, ipattern[8];
2300            Pixmap fill;
2301    
2302            SET_FUNCTION(opcode);
2303    
2304            if (brush)
2305                    style = brush->style;
2306            else
2307                    style = 0;
2308    
2309            switch (style)
2310            {
2311                    case 0: /* Solid */
2312                            SET_FOREGROUND(fgcolour);
2313                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2314                            break;
2315    
2316                    case 2: /* Hatch */
2317                            fill = (Pixmap) ui_create_glyph(8, 8,
2318                                                            hatch_patterns + brush->pattern[0] * 8);
2319                            SET_FOREGROUND(fgcolour);
2320                            SET_BACKGROUND(bgcolour);
2321                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2322                            XSetStipple(g_display, g_gc, fill);
2323                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2324                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2325                            XSetFillStyle(g_display, g_gc, FillSolid);
2326                            XSetTSOrigin(g_display, g_gc, 0, 0);
2327                            ui_destroy_glyph((HGLYPH) fill);
2328                            break;
2329    
2330                    case 3: /* Pattern */
2331                            for (i = 0; i != 8; i++)
2332                                    ipattern[7 - i] = brush->pattern[i];
2333                            fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
2334                            SET_FOREGROUND(bgcolour);
2335                            SET_BACKGROUND(fgcolour);
2336                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
2337                            XSetStipple(g_display, g_gc, fill);
2338                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
2339                            DRAW_ELLIPSE(x, y, cx, cy, fillmode);
2340                            XSetFillStyle(g_display, g_gc, FillSolid);
2341                            XSetTSOrigin(g_display, g_gc, 0, 0);
2342                            ui_destroy_glyph((HGLYPH) fill);
2343                            break;
2344    
2345                    default:
2346                            unimpl("brush %d\n", brush->style);
2347            }
2348    
2349            RESET_FUNCTION(opcode);
2350    }
2351    
2352  /* warning, this function only draws on wnd or backstore, not both */  /* warning, this function only draws on wnd or backstore, not both */
2353  void  void
2354  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
# Line 2039  ui_draw_glyph(int mixmode, Line 2404  ui_draw_glyph(int mixmode,
2404  }  }
2405    
2406  void  void
2407  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,
2408               int clipx, int clipy, int clipcx, int clipcy,               int clipx, int clipy, int clipcx, int clipcy,
2409               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
2410               int fgcolour, uint8 * text, uint8 length)               int bgcolour, int fgcolour, uint8 * text, uint8 length)
2411  {  {
2412            /* TODO: use brush appropriately */
2413    
2414          FONTGLYPH *glyph;          FONTGLYPH *glyph;
2415          int i, j, xyoffset, x1, y1;          int i, j, xyoffset, x1, y1;
2416          DATABLOB *entry;          DATABLOB *entry;
Legend:
Removed from v.713  
changed lines
  Added in v.988
  ViewVC Help
Powered by ViewVC 1.1.26