/[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 64 by astrand, Thu Jul 18 16:38:31 2002 UTC revision 708 by jsorg71, Fri Jun 4 15:01:36 2004 UTC
# Line 1  Line 1 
1  /*  /* -*- 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-2001     Copyright (C) Matthew Chapman 1999-2002
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 20  Line 20 
20    
21  #include <X11/Xlib.h>  #include <X11/Xlib.h>
22  #include <X11/Xutil.h>  #include <X11/Xutil.h>
23  #include <X11/XKBlib.h>  #include <unistd.h>
24    #include <sys/time.h>
25  #include <time.h>  #include <time.h>
26  #include <errno.h>  #include <errno.h>
27    #include <strings.h>
28  #include "rdesktop.h"  #include "rdesktop.h"
29    #include "xproto.h"
30    
31  extern char keymapname[16];  extern int g_width;
32  extern int keylayout;  extern int g_height;
33  extern int width;  extern BOOL g_sendmotion;
34  extern int height;  extern BOOL g_fullscreen;
35  extern BOOL sendmotion;  extern BOOL g_grab_keyboard;
36  extern BOOL fullscreen;  extern BOOL g_hide_decorations;
37    extern char g_title[];
38  Display *display;  extern int g_server_bpp;
39  XkbDescPtr xkb;  extern int g_win_button_size;
40  static int x_socket;  
41  static Window wnd;  Display *g_display;
42  static GC gc;  Time g_last_gesturetime;
43  static Visual *visual;  static int g_x_socket;
44  static int depth;  static Screen *g_screen;
45  static int bpp;  Window g_wnd;
46    extern uint32 g_embed_wnd;
47    BOOL g_enable_compose = False;
48    BOOL g_Unobscured;              /* used for screenblt */
49    static GC g_gc = NULL;
50    static Visual *g_visual;
51    static int g_depth;
52    static int g_bpp;
53    static XIM g_IM;
54    static XIC g_IC;
55    static XModifierKeymap *g_mod_map;
56    static Cursor g_current_cursor;
57    static HCURSOR g_null_cursor = NULL;
58    static Atom g_protocol_atom, g_kill_atom;
59    static BOOL g_focused;
60    static BOOL g_mouse_in_wnd;
61    static BOOL g_arch_match = False;       /* set to True if RGB XServer and little endian */
62    
63  /* endianness */  /* endianness */
64  static BOOL host_be;  static BOOL g_host_be;
65  static BOOL xserver_be;  static BOOL g_xserver_be;
66    static int g_red_shift_r, g_blue_shift_r, g_green_shift_r;
67    static int g_red_shift_l, g_blue_shift_l, g_green_shift_l;
68    
69  /* software backing store */  /* software backing store */
70  static BOOL ownbackstore;  extern BOOL g_ownbackstore;
71  static Pixmap backstore;  static Pixmap g_backstore = 0;
72    
73    /* Moving in single app mode */
74    static BOOL g_moving_wnd;
75    static int g_move_x_offset = 0;
76    static int g_move_y_offset = 0;
77    
78    #ifdef WITH_RDPSND
79    extern int g_dsp_fd;
80    extern BOOL g_dsp_busy;
81    extern BOOL g_rdpsnd;
82    #endif
83    
84    /* MWM decorations */
85    #define MWM_HINTS_DECORATIONS   (1L << 1)
86    #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
87    typedef struct
88    {
89            uint32 flags;
90            uint32 functions;
91            uint32 decorations;
92            sint32 inputMode;
93            uint32 status;
94    }
95    PropMotifWmHints;
96    
97    typedef struct
98    {
99            uint32 red;
100            uint32 green;
101            uint32 blue;
102    }
103    PixelColour;
104    
 /* needed to keep track of the modifiers */  
 static unsigned int numlock_modifier_mask = 0;  
 static unsigned int key_down_state = 0;  
   
   
 #define DShift1Mask   (1<<0)  
 #define DLockMask     (1<<1)  
 #define DControl1Mask (1<<2)  
 #define DMod1Mask     (1<<3)  
 #define DMod2Mask     (1<<4)  
 #define DMod3Mask     (1<<5)  
 #define DMod4Mask     (1<<6)  
 #define DMod5Mask     (1<<7)  
 #define DShift2Mask   (1<<8)  
 #define DControl2Mask (1<<9)  
 #define DNumLockMask  (1<<10)  
105    
106  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
107  { \  { \
108          XFillRectangle(display, wnd, gc, x, y, cx, cy); \          XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \
109          if (ownbackstore) \          if (g_ownbackstore) \
110                  XFillRectangle(display, backstore, gc, x, y, cx, cy); \                  XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \
111    }
112    
113    #define FILL_RECTANGLE_BACKSTORE(x,y,cx,cy)\
114    { \
115            XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \
116  }  }
117    
118  /* colour maps */  /* colour maps */
119  static BOOL owncolmap;  extern BOOL g_owncolmap;
120  static Colormap xcolmap;  static Colormap g_xcolmap;
121  static uint32 white;  static uint32 *g_colmap = NULL;
122  static uint32 *colmap;  
123    #define TRANSLATE(col)          ( g_server_bpp != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )
124  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define SET_FOREGROUND(col)     XSetForeground(g_display, g_gc, TRANSLATE(col));
125  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));  #define SET_BACKGROUND(col)     XSetBackground(g_display, g_gc, TRANSLATE(col));
 #define SET_BACKGROUND(col)     XSetBackground(display, gc, TRANSLATE(col));  
126    
127  static int rop2_map[] = {  static int rop2_map[] = {
128          GXclear,                /* 0 */          GXclear,                /* 0 */
# Line 102  static int rop2_map[] = { Line 143  static int rop2_map[] = {
143          GXset                   /* 1 */          GXset                   /* 1 */
144  };  };
145    
146  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }
147  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }
148    
149    static void
150    mwm_hide_decorations(void)
151    {
152            PropMotifWmHints motif_hints;
153            Atom hintsatom;
154    
155            /* setup the property */
156            motif_hints.flags = MWM_HINTS_DECORATIONS;
157            motif_hints.decorations = 0;
158    
159            /* get the atom for the property */
160            hintsatom = XInternAtom(g_display, "_MOTIF_WM_HINTS", False);
161            if (!hintsatom)
162            {
163                    warning("Failed to get atom _MOTIF_WM_HINTS: probably your window manager does not support MWM hints\n");
164                    return;
165            }
166    
167            XChangeProperty(g_display, g_wnd, hintsatom, hintsatom, 32, PropModeReplace,
168                            (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
169    }
170    
171    static PixelColour
172    split_colour15(uint32 colour)
173    {
174            PixelColour rv;
175            rv.red = ((colour >> 7) & 0xf8) | ((colour >> 12) & 0x7);
176            rv.green = ((colour >> 2) & 0xf8) | ((colour >> 8) & 0x7);
177            rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7);
178            return rv;
179    }
180    
181    static PixelColour
182    split_colour16(uint32 colour)
183    {
184            PixelColour rv;
185            rv.red = ((colour >> 8) & 0xf8) | ((colour >> 13) & 0x7);
186            rv.green = ((colour >> 3) & 0xfc) | ((colour >> 9) & 0x3);
187            rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7);
188            return rv;
189    }
190    
191    static PixelColour
192    split_colour24(uint32 colour)
193    {
194            PixelColour rv;
195            rv.blue = (colour & 0xff0000) >> 16;
196            rv.green = (colour & 0x00ff00) >> 8;
197            rv.red = (colour & 0x0000ff);
198            return rv;
199    }
200    
201  void xwin_get_numlock_mask();  static uint32
202  void xwin_mod_update(uint32 state, uint32 ev_time);  make_colour(PixelColour pc)
203  void xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode);  {
204  void xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode);          return (((pc.red >> g_red_shift_r) << g_red_shift_l)
205                    | ((pc.green >> g_green_shift_r) << g_green_shift_l)
206                    | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l));
207    }
208    
209    #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
210    #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | (x & 0xff00)); }
211    #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
212                            x = (x << 16) | (x >> 16); }
213    
214    static uint32
215    translate_colour(uint32 colour)
216    {
217            PixelColour pc;
218            switch (g_server_bpp)
219            {
220                    case 15:
221                            pc = split_colour15(colour);
222                            break;
223                    case 16:
224                            pc = split_colour16(colour);
225                            break;
226                    case 24:
227                            pc = split_colour24(colour);
228                            break;
229            }
230            return make_colour(pc);
231    }
232    
233    #define UNROLL8(stm) { stm stm stm stm stm stm stm stm }
234    #define REPEAT(stm) \
235    { \
236            while (out <= end - 8 * 4) \
237                    UNROLL8(stm) \
238            while (out < end) \
239                    { stm } \
240    }
241    
242  static void  static void
243  translate8(uint8 * data, uint8 * out, uint8 * end)  translate8to8(uint8 * data, uint8 * out, uint8 * end)
244  {  {
245          while (out < end)          while (out < end)
246                  *(out++) = (uint8) colmap[*(data++)];                  *(out++) = (uint8) g_colmap[*(data++)];
247  }  }
248    
249  static void  static void
250  translate16(uint8 * data, uint16 * out, uint16 * end)  translate8to16(uint8 * data, uint8 * out, uint8 * end)
251    {
252            uint16 value;
253    
254            if (g_arch_match)
255                    REPEAT(*((uint16 *) out) = g_colmap[*(data++)];
256                           out += 2;)
257            else
258    if (g_xserver_be)
259  {  {
260          while (out < end)          while (out < end)
261                  *(out++) = (uint16) colmap[*(data++)];          {
262                    value = (uint16) g_colmap[*(data++)];
263                    *(out++) = value >> 8;
264                    *(out++) = value;
265            }
266    }
267    else
268    {
269            while (out < end)
270            {
271                    value = (uint16) g_colmap[*(data++)];
272                    *(out++) = value;
273                    *(out++) = value >> 8;
274            }
275    }
276  }  }
277    
278  /* little endian - conversion happens when colourmap is built */  /* little endian - conversion happens when colourmap is built */
279  static void  static void
280  translate24(uint8 * data, uint8 * out, uint8 * end)  translate8to24(uint8 * data, uint8 * out, uint8 * end)
281  {  {
282          uint32 value;          uint32 value;
283    
284            if (g_xserver_be)
285            {
286                    while (out < end)
287                    {
288                            value = g_colmap[*(data++)];
289                            *(out++) = value >> 16;
290                            *(out++) = value >> 8;
291                            *(out++) = value;
292                    }
293            }
294            else
295            {
296                    while (out < end)
297                    {
298                            value = g_colmap[*(data++)];
299                            *(out++) = value;
300                            *(out++) = value >> 8;
301                            *(out++) = value >> 16;
302                    }
303            }
304    }
305    
306    static void
307    translate8to32(uint8 * data, uint8 * out, uint8 * end)
308    {
309            uint32 value;
310    
311            if (g_arch_match)
312                    REPEAT(*((uint32 *) out) = g_colmap[*(data++)];
313                           out += 4;)
314            else
315    if (g_xserver_be)
316    {
317          while (out < end)          while (out < end)
318          {          {
319                  value = colmap[*(data++)];                  value = g_colmap[*(data++)];
320                    *(out++) = value >> 24;
321                    *(out++) = value >> 16;
322                    *(out++) = value >> 8;
323                    *(out++) = value;
324            }
325    }
326    else
327    {
328            while (out < end)
329            {
330                    value = g_colmap[*(data++)];
331                  *(out++) = value;                  *(out++) = value;
332                  *(out++) = value >> 8;                  *(out++) = value >> 8;
333                  *(out++) = value >> 16;                  *(out++) = value >> 16;
334                    *(out++) = value >> 24;
335          }          }
336  }  }
337    }
338    
339  static void  static void
340  translate32(uint8 * data, uint32 * out, uint32 * end)  translate15to16(uint16 * data, uint8 * out, uint8 * end)
341  {  {
342            uint16 pixel;
343            uint16 value;
344    
345          while (out < end)          while (out < end)
346                  *(out++) = colmap[*(data++)];          {
347                    pixel = *(data++);
348    
349                    if (g_host_be)
350                    {
351                            BSWAP16(pixel);
352                    }
353    
354                    value = make_colour(split_colour15(pixel));
355    
356                    if (g_xserver_be)
357                    {
358                            *(out++) = value >> 8;
359                            *(out++) = value;
360                    }
361                    else
362                    {
363                            *(out++) = value;
364                            *(out++) = value >> 8;
365                    }
366            }
367  }  }
368    
369  static uint8 *  static void
370  translate_image(int width, int height, uint8 * data)  translate15to24(uint16 * data, uint8 * out, uint8 * end)
371  {  {
372          int size = width * height * bpp / 8;          uint32 value;
373          uint8 *out = xmalloc(size);          uint16 pixel;
         uint8 *end = out + size;  
374    
375          switch (bpp)          while (out < end)
376          {          {
377                  case 8:                  pixel = *(data++);
                         translate8(data, out, end);  
                         break;  
378    
379                  case 16:                  if (g_host_be)
380                          translate16(data, (uint16 *) out, (uint16 *) end);                  {
381                          break;                          BSWAP16(pixel);
382                    }
383    
384                  case 24:                  value = make_colour(split_colour15(pixel));
385                          translate24(data, out, end);                  if (g_xserver_be)
386                          break;                  {
387                            *(out++) = value >> 16;
388                            *(out++) = value >> 8;
389                            *(out++) = value;
390                    }
391                    else
392                    {
393                            *(out++) = value;
394                            *(out++) = value >> 8;
395                            *(out++) = value >> 16;
396                    }
397            }
398    }
399    
400                  case 32:  static void
401                          translate32(data, (uint32 *) out, (uint32 *) end);  translate15to32(uint16 * data, uint8 * out, uint8 * end)
402                          break;  {
403            uint16 pixel;
404            uint32 value;
405    
406            while (out < end)
407            {
408                    pixel = *(data++);
409    
410                    if (g_host_be)
411                    {
412                            BSWAP16(pixel);
413                    }
414    
415                    value = make_colour(split_colour15(pixel));
416    
417                    if (g_xserver_be)
418                    {
419                            *(out++) = value >> 24;
420                            *(out++) = value >> 16;
421                            *(out++) = value >> 8;
422                            *(out++) = value;
423                    }
424                    else
425                    {
426                            *(out++) = value;
427                            *(out++) = value >> 8;
428                            *(out++) = value >> 16;
429                            *(out++) = value >> 24;
430                    }
431          }          }
432    }
433    
434          return out;  static void
435    translate16to16(uint16 * data, uint8 * out, uint8 * end)
436    {
437            uint16 pixel;
438            uint16 value;
439    
440            while (out < end)
441            {
442                    pixel = *(data++);
443    
444                    if (g_host_be)
445                    {
446                            BSWAP16(pixel);
447                    }
448    
449                    value = make_colour(split_colour16(pixel));
450    
451                    if (g_xserver_be)
452                    {
453                            *(out++) = value >> 8;
454                            *(out++) = value;
455                    }
456                    else
457                    {
458                            *(out++) = value;
459                            *(out++) = value >> 8;
460                    }
461            }
462  }  }
463    
464  #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }  static void
465  #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }  translate16to24(uint16 * data, uint8 * out, uint8 * end)
466  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \  {
467                          x = (x << 16) | (x >> 16); }          uint32 value;
468            uint16 pixel;
469    
470  static uint32          while (out < end)
471  translate_colour(uint32 colour)          {
472                    pixel = *(data++);
473    
474                    if (g_host_be)
475                    {
476                            BSWAP16(pixel);
477                    }
478    
479                    value = make_colour(split_colour16(pixel));
480    
481                    if (g_xserver_be)
482                    {
483                            *(out++) = value >> 16;
484                            *(out++) = value >> 8;
485                            *(out++) = value;
486                    }
487                    else
488                    {
489                            *(out++) = value;
490                            *(out++) = value >> 8;
491                            *(out++) = value >> 16;
492                    }
493            }
494    }
495    
496    static void
497    translate16to32(uint16 * data, uint8 * out, uint8 * end)
498  {  {
499          switch (bpp)          uint16 pixel;
500            uint32 value;
501    
502            while (out < end)
503          {          {
504                  case 16:                  pixel = *(data++);
                         if (host_be != xserver_be)  
                                 BSWAP16(colour);  
                         break;  
505    
506                  case 24:                  if (g_host_be)
507                          if (xserver_be)                  {
508                                  BSWAP24(colour);                          BSWAP16(pixel);
509                          break;                  }
510    
511                  case 32:                  value = make_colour(split_colour16(pixel));
512                          if (host_be != xserver_be)  
513                                  BSWAP32(colour);                  if (g_xserver_be)
514                          break;                  {
515                            *(out++) = value >> 24;
516                            *(out++) = value >> 16;
517                            *(out++) = value >> 8;
518                            *(out++) = value;
519                    }
520                    else
521                    {
522                            *(out++) = value;
523                            *(out++) = value >> 8;
524                            *(out++) = value >> 16;
525                            *(out++) = value >> 24;
526                    }
527          }          }
528    }
529    
530    static void
531    translate24to16(uint8 * data, uint8 * out, uint8 * end)
532    {
533            uint32 pixel = 0;
534            uint16 value;
535            while (out < end)
536            {
537                    pixel = *(data++) << 16;
538                    pixel |= *(data++) << 8;
539                    pixel |= *(data++);
540    
541                    value = (uint16) make_colour(split_colour24(pixel));
542    
543          return colour;                  if (g_xserver_be)
544                    {
545                            *(out++) = value >> 8;
546                            *(out++) = value;
547                    }
548                    else
549                    {
550                            *(out++) = value;
551                            *(out++) = value >> 8;
552                    }
553            }
554  }  }
555    
556  BOOL  static void
557  ui_create_window(char *title)  translate24to24(uint8 * data, uint8 * out, uint8 * end)
558  {  {
559          XSetWindowAttributes attribs;          uint32 pixel;
560          XClassHint *classhints;          uint32 value;
561          XSizeHints *sizehints;  
562          unsigned long input_mask;          while (out < end)
563          XPixmapFormatValues *pfm;          {
564          Screen *screen;                  pixel = *(data++) << 16;
565          uint16 test;                  pixel |= *(data++) << 8;
566          int i;                  pixel |= *(data++);
567    
568          int xkb_minor, xkb_major;                  value = make_colour(split_colour24(pixel));
         int xkb_event, xkb_error, xkb_reason;  
569    
570          /* compare compiletime libs with runtime libs. */                  if (g_xserver_be)
571          xkb_major = XkbMajorVersion;                  {
572          xkb_minor = XkbMinorVersion;                          *(out++) = value >> 16;
573          if (XkbLibraryVersion(&xkb_major, &xkb_minor) == False)                          *(out++) = value >> 8;
574                            *(out++) = value;
575                    }
576                    else
577                    {
578                            *(out++) = value;
579                            *(out++) = value >> 8;
580                            *(out++) = value >> 16;
581                    }
582            }
583    }
584    
585    static void
586    translate24to32(uint8 * data, uint8 * out, uint8 * end)
587    {
588            uint32 pixel;
589            uint32 value;
590    
591            while (out < end)
592          {          {
593                  error("please re-compile rdesktop\ncompile time version of xkb is not compatible with\nyour runtime version of the library\n");                  pixel = *(data++) << 16;
594                  return False;                  pixel |= *(data++) << 8;
595                    pixel |= *(data++);
596    
597                    value = make_colour(split_colour24(pixel));
598    
599                    if (g_xserver_be)
600                    {
601                            *(out++) = value >> 24;
602                            *(out++) = value >> 16;
603                            *(out++) = value >> 8;
604                            *(out++) = value;
605                    }
606                    else
607                    {
608                            *(out++) = value;
609                            *(out++) = value >> 8;
610                            *(out++) = value >> 16;
611                            *(out++) = value >> 24;
612                    }
613          }          }
614    }
615    
616    static uint8 *
617    translate_image(int width, int height, uint8 * data)
618    {
619            int size;
620            uint8 *out;
621            uint8 *end;
622    
623            /* if server and xserver bpp match, */
624            /* and arch(endian) matches, no need to translate */
625            /* just return data */
626            if (g_arch_match)
627            {
628                    if (g_depth == 15 && g_server_bpp == 15)
629                            return data;
630                    if (g_depth == 16 && g_server_bpp == 16)
631                            return data;
632            }
633    
634            size = width * height * (g_bpp / 8);
635            out = (uint8 *) xmalloc(size);
636            end = out + size;
637    
638          display =          switch (g_server_bpp)
                 XkbOpenDisplay(NULL, &xkb_event, &xkb_error, &xkb_major,  
                                &xkb_minor, &xkb_reason);  
         switch (xkb_reason)  
639          {          {
640                  case XkbOD_BadLibraryVersion:                  case 24:
641                          error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");                          switch (g_bpp)
642                          break;                          {
643                  case XkbOD_ConnectionRefused:                                  case 32:
644                          error("XkbOD_ConnectionRefused\n");                                          translate24to32(data, out, end);
645                                            break;
646                                    case 24:
647                                            translate24to24(data, out, end);
648                                            break;
649                                    case 16:
650                                            translate24to16(data, out, end);
651                                            break;
652                            }
653                          break;                          break;
654                  case XkbOD_BadServerVersion:                  case 16:
655                          error("XkbOD_BadServerVersion\n");                          switch (g_bpp)
656                            {
657                                    case 32:
658                                            translate16to32((uint16 *) data, out, end);
659                                            break;
660                                    case 24:
661                                            translate16to24((uint16 *) data, out, end);
662                                            break;
663                                    case 16:
664                                            translate16to16((uint16 *) data, out, end);
665                                            break;
666                            }
667                          break;                          break;
668                  case XkbOD_NonXkbServer:                  case 15:
669                          error("XkbOD_NonXkbServer: XKB extension not present in server\nupdate your X server.\n");                          switch (g_bpp)
670                            {
671                                    case 32:
672                                            translate15to32((uint16 *) data, out, end);
673                                            break;
674                                    case 24:
675                                            translate15to24((uint16 *) data, out, end);
676                                            break;
677                                    case 16:
678                                            translate15to16((uint16 *) data, out, end);
679                                            break;
680                            }
681                          break;                          break;
682                  case XkbOD_Success:                  case 8:
683                          DEBUG("XkbOD_Success: Connection established with display\n");                          switch (g_bpp)
684                            {
685                                    case 8:
686                                            translate8to8(data, out, end);
687                                            break;
688                                    case 16:
689                                            translate8to16(data, out, end);
690                                            break;
691                                    case 24:
692                                            translate8to24(data, out, end);
693                                            break;
694                                    case 32:
695                                            translate8to32(data, out, end);
696                                            break;
697                            }
698                          break;                          break;
699          }          }
700            return out;
701    }
702    
703    BOOL
704    get_key_state(unsigned int state, uint32 keysym)
705    {
706            int modifierpos, key, keysymMask = 0;
707            int offset;
708    
709            KeyCode keycode = XKeysymToKeycode(g_display, keysym);
710    
711            if (keycode == NoSymbol)
712                    return False;
713    
714          if (display == NULL)          for (modifierpos = 0; modifierpos < 8; modifierpos++)
715          {          {
716                  error("Failed to open display\n");                  offset = g_mod_map->max_keypermod * modifierpos;
717    
718                    for (key = 0; key < g_mod_map->max_keypermod; key++)
719                    {
720                            if (g_mod_map->modifiermap[offset + key] == keycode)
721                                    keysymMask |= 1 << modifierpos;
722                    }
723            }
724    
725            return (state & keysymMask) ? True : False;
726    }
727    
728    static void
729    calculate_shifts(uint32 mask, int *shift_r, int *shift_l)
730    {
731            *shift_l = ffs(mask) - 1;
732            mask >>= *shift_l;
733            *shift_r = 8 - ffs(mask & ~(mask >> 1));
734    }
735    
736    BOOL
737    ui_init(void)
738    {
739            XVisualInfo vi;
740            XPixmapFormatValues *pfm;
741            uint16 test;
742            int i, screen_num, nvisuals;
743            XVisualInfo *vmatches = NULL;
744            XVisualInfo template;
745            Bool TrueColorVisual = False;
746    
747            g_display = XOpenDisplay(NULL);
748            if (g_display == NULL)
749            {
750                    error("Failed to open display: %s\n", XDisplayName(NULL));
751                  return False;                  return False;
752          }          }
753    
754          x_socket = ConnectionNumber(display);          screen_num = DefaultScreen(g_display);
755          screen = DefaultScreenOfDisplay(display);          g_x_socket = ConnectionNumber(g_display);
756          visual = DefaultVisualOfScreen(screen);          g_screen = ScreenOfDisplay(g_display, screen_num);
757          depth = DefaultDepthOfScreen(screen);          g_depth = DefaultDepthOfScreen(g_screen);
758    
759            /* Search for best TrueColor depth */
760            template.class = TrueColor;
761            vmatches = XGetVisualInfo(g_display, VisualClassMask, &template, &nvisuals);
762    
763            nvisuals--;
764            while (nvisuals >= 0)
765            {
766                    if ((vmatches + nvisuals)->depth > g_depth)
767                    {
768                            g_depth = (vmatches + nvisuals)->depth;
769                    }
770                    nvisuals--;
771                    TrueColorVisual = True;
772            }
773    
774            test = 1;
775            g_host_be = !(BOOL) (*(uint8 *) (&test));
776            g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);
777    
778            if ((g_server_bpp == 8) && ((!TrueColorVisual) || (g_depth <= 8)))
779            {
780                    /* we use a colourmap, so the default visual should do */
781                    g_visual = DefaultVisualOfScreen(g_screen);
782                    g_depth = DefaultDepthOfScreen(g_screen);
783    
784          pfm = XListPixmapFormats(display, &i);                  /* Do not allocate colours on a TrueColor visual */
785                    if (g_visual->class == TrueColor)
786                    {
787                            g_owncolmap = False;
788                    }
789            }
790            else
791            {
792                    /* need a truecolour visual */
793                    if (!XMatchVisualInfo(g_display, screen_num, g_depth, TrueColor, &vi))
794                    {
795                            error("The display does not support true colour - high colour support unavailable.\n");
796                            return False;
797                    }
798    
799                    g_visual = vi.visual;
800                    g_owncolmap = False;
801                    calculate_shifts(vi.red_mask, &g_red_shift_r, &g_red_shift_l);
802                    calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l);
803                    calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l);
804    
805                    /* if RGB video and averything is little endian */
806                    if (vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask)
807                            if (!g_xserver_be && !g_host_be)
808                                    g_arch_match = True;
809            }
810    
811            pfm = XListPixmapFormats(g_display, &i);
812          if (pfm != NULL)          if (pfm != NULL)
813          {          {
814                  /* Use maximum bpp for this depth - this is generally                  /* Use maximum bpp for this depth - this is generally
815                     desirable, e.g. 24 bits->32 bits. */                     desirable, e.g. 24 bits->32 bits. */
816                  while (i--)                  while (i--)
817                  {                  {
818                          if ((pfm[i].depth == depth)                          if ((pfm[i].depth == g_depth) && (pfm[i].bits_per_pixel > g_bpp))
                             && (pfm[i].bits_per_pixel > bpp))  
819                          {                          {
820                                  bpp = pfm[i].bits_per_pixel;                                  g_bpp = pfm[i].bits_per_pixel;
821                          }                          }
822                  }                  }
823                  XFree(pfm);                  XFree(pfm);
824          }          }
825    
826          if (bpp < 8)          if (g_bpp < 8)
827          {          {
828                  error("Less than 8 bpp not currently supported.\n");                  error("Less than 8 bpp not currently supported.\n");
829                  XCloseDisplay(display);                  XCloseDisplay(g_display);
830                  return False;                  return False;
831          }          }
832    
833          if (depth <= 8)          if (!g_owncolmap)
834                  owncolmap = True;          {
835          else                  g_xcolmap =
836                  xcolmap = DefaultColormapOfScreen(screen);                          XCreateColormap(g_display, RootWindowOfScreen(g_screen), g_visual,
837                                            AllocNone);
838          test = 1;                  if (g_depth <= 8)
839          host_be = !(BOOL) (*(uint8 *) (&test));                          warning("Screen depth is 8 bits or lower: you may want to use -C for a private colourmap\n");
840          xserver_be = (ImageByteOrder(display) == MSBFirst);          }
   
         white = WhitePixelOfScreen(screen);  
         attribs.background_pixel = BlackPixelOfScreen(screen);  
         attribs.backing_store = DoesBackingStore(screen);  
841    
842          if (attribs.backing_store == NotUseful)          if ((!g_ownbackstore) && (DoesBackingStore(g_screen) != Always))
843                  ownbackstore = True;          {
844                    warning("External BackingStore not available, using internal\n");
845                    g_ownbackstore = True;
846            }
847    
848          if (fullscreen)          /*
849             * Determine desktop size
850             */
851            if (g_fullscreen)
852          {          {
853                  attribs.override_redirect = True;                  g_width = WidthOfScreen(g_screen);
854                  width = WidthOfScreen(screen);                  g_height = HeightOfScreen(g_screen);
                 height = HeightOfScreen(screen);  
855          }          }
856          else          else if (g_width < 0)
857            {
858                    /* Percent of screen */
859                    g_height = HeightOfScreen(g_screen) * (-g_width) / 100;
860                    g_width = WidthOfScreen(g_screen) * (-g_width) / 100;
861            }
862            else if (g_width == 0)
863          {          {
864                  attribs.override_redirect = False;                  /* Fetch geometry from _NET_WORKAREA */
865                    uint32 x, y, cx, cy;
866    
867                    if (get_current_workarea(&x, &y, &cx, &cy) == 0)
868                    {
869                            g_width = cx;
870                            g_height = cy;
871                    }
872                    else
873                    {
874                            warning("Failed to get workarea: probably your window manager does not support extended hints\n");
875                            g_width = 800;
876                            g_height = 600;
877                    }
878          }          }
879    
880          width = (width + 3) & ~3;       /* make width a multiple of 32 bits */          /* make sure width is a multiple of 4 */
881            g_width = (g_width + 3) & ~3;
882    
883            g_mod_map = XGetModifierMapping(g_display);
884    
885            xkeymap_init();
886    
887            if (g_enable_compose)
888                    g_IM = XOpenIM(g_display, NULL, NULL, NULL);
889    
890          wnd = XCreateWindow(display, RootWindowOfScreen(screen),          xclip_init();
                             0, 0, width, height, 0, CopyFromParent,  
                             InputOutput, CopyFromParent,  
                             CWBackingStore | CWBackPixel | CWOverrideRedirect,  
                             &attribs);  
891    
892          XStoreName(display, wnd, title);          DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_bpp, g_bpp, g_depth));
893    
894            return True;
895    }
896    
897    void
898    ui_deinit(void)
899    {
900            if (g_IM != NULL)
901                    XCloseIM(g_IM);
902    
903            if (g_null_cursor != NULL)
904                    ui_destroy_cursor(g_null_cursor);
905    
906            XFreeModifiermap(g_mod_map);
907    
908            if (g_ownbackstore)
909                    XFreePixmap(g_display, g_backstore);
910    
911            XFreeGC(g_display, g_gc);
912            XCloseDisplay(g_display);
913            g_display = NULL;
914    }
915    
916    BOOL
917    ui_create_window(void)
918    {
919            uint8 null_pointer_mask[1] = { 0x80 };
920            uint8 null_pointer_data[4] = { 0x00, 0x00, 0x00, 0x00 };
921            XSetWindowAttributes attribs;
922            XClassHint *classhints;
923            XSizeHints *sizehints;
924            int wndwidth, wndheight;
925            long input_mask, ic_input_mask;
926            XEvent xevent;
927    
928            wndwidth = g_fullscreen ? WidthOfScreen(g_screen) : g_width;
929            wndheight = g_fullscreen ? HeightOfScreen(g_screen) : g_height;
930    
931            attribs.background_pixel = BlackPixelOfScreen(g_screen);
932            attribs.border_pixel = WhitePixelOfScreen(g_screen);
933            attribs.backing_store = g_ownbackstore ? NotUseful : Always;
934            attribs.override_redirect = g_fullscreen;
935            attribs.colormap = g_xcolmap;
936    
937            g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), 0, 0, wndwidth, wndheight,
938                                  0, g_depth, InputOutput, g_visual,
939                                  CWBackPixel | CWBackingStore | CWOverrideRedirect |
940                                  CWColormap | CWBorderPixel, &attribs);
941    
942            if (g_gc == NULL)
943                    g_gc = XCreateGC(g_display, g_wnd, 0, NULL);
944    
945            if ((g_ownbackstore) && (g_backstore == 0))
946            {
947                    g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
948    
949                    /* clear to prevent rubbish being exposed at startup */
950                    XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
951                    XFillRectangle(g_display, g_backstore, g_gc, 0, 0, g_width, g_height);
952            }
953    
954            XStoreName(g_display, g_wnd, g_title);
955    
956            if (g_hide_decorations)
957                    mwm_hide_decorations();
958    
959          classhints = XAllocClassHint();          classhints = XAllocClassHint();
960          if (classhints != NULL)          if (classhints != NULL)
961          {          {
962                  classhints->res_name = classhints->res_class = "rdesktop";                  classhints->res_name = classhints->res_class = "rdesktop";
963                  XSetClassHint(display, wnd, classhints);                  XSetClassHint(g_display, g_wnd, classhints);
964                  XFree(classhints);                  XFree(classhints);
965          }          }
966    
# Line 334  ui_create_window(char *title) Line 968  ui_create_window(char *title)
968          if (sizehints)          if (sizehints)
969          {          {
970                  sizehints->flags = PMinSize | PMaxSize;                  sizehints->flags = PMinSize | PMaxSize;
971                  sizehints->min_width = sizehints->max_width = width;                  sizehints->min_width = sizehints->max_width = g_width;
972                  sizehints->min_height = sizehints->max_height = height;                  sizehints->min_height = sizehints->max_height = g_height;
973                  XSetWMNormalHints(display, wnd, sizehints);                  XSetWMNormalHints(g_display, g_wnd, sizehints);
974                  XFree(sizehints);                  XFree(sizehints);
975          }          }
976    
977          xkeymap_init();          if (g_embed_wnd)
978            {
979                    XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);
980            }
981    
982          input_mask = KeyPressMask | KeyReleaseMask |          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
983                  ButtonPressMask | ButtonReleaseMask |                  VisibilityChangeMask | FocusChangeMask;
                 EnterWindowMask | LeaveWindowMask;  
         if (sendmotion)  
                 input_mask |= PointerMotionMask;  
984    
985          if (ownbackstore)          if (g_sendmotion)
986                    input_mask |= PointerMotionMask;
987            if (g_ownbackstore)
988                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
989            if (g_fullscreen || g_grab_keyboard)
990                    input_mask |= EnterWindowMask;
991            if (g_grab_keyboard)
992                    input_mask |= LeaveWindowMask;
993    
994          XSelectInput(display, wnd, input_mask);          if (g_IM != NULL)
995          gc = XCreateGC(display, wnd, 0, NULL);          {
996                    g_IC = XCreateIC(g_IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
997                                     XNClientWindow, g_wnd, XNFocusWindow, g_wnd, NULL);
998    
999          if (ownbackstore)                  if ((g_IC != NULL)
1000                  backstore = XCreatePixmap(display, wnd, width, height, depth);                      && (XGetICValues(g_IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
1001                            input_mask |= ic_input_mask;
1002            }
1003    
1004          XMapWindow(display, wnd);          XSelectInput(g_display, g_wnd, input_mask);
1005            XMapWindow(g_display, g_wnd);
1006    
1007          /* TODO: error texts... make them friendly. */          /* wait for VisibilityNotify */
1008          xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);          do
         if ((int) xkb == BadAlloc || xkb == NULL)  
1009          {          {
1010                  error("XkbGetKeyboard failed.\n");                  XMaskEvent(g_display, VisibilityChangeMask, &xevent);
                 exit(0);  
1011          }          }
1012            while (xevent.type != VisibilityNotify);
1013            g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;
1014    
1015          /* TODO: error texts... make them friendly. */          g_focused = False;
1016          if (XkbSelectEvents          g_mouse_in_wnd = False;
1017              (display, xkb->device_spec, XkbAllEventsMask,  
1018               XkbAllEventsMask) == False)          /* handle the WM_DELETE_WINDOW protocol */
1019          {          g_protocol_atom = XInternAtom(g_display, "WM_PROTOCOLS", True);
1020                  error("XkbSelectEvents failed.\n");          g_kill_atom = XInternAtom(g_display, "WM_DELETE_WINDOW", True);
1021                  exit(0);          XSetWMProtocols(g_display, g_wnd, &g_kill_atom, 1);
         }  
1022    
1023          xwin_get_numlock_mask();          /* create invisible 1x1 cursor to be used as null cursor */
1024            if (g_null_cursor == NULL)
1025                    g_null_cursor = ui_create_cursor(0, 0, 1, 1, null_pointer_mask, null_pointer_data);
1026    
1027          return True;          return True;
1028  }  }
1029    
1030  void  void
1031  xwin_get_numlock_mask()  ui_resize_window()
1032  {  {
1033          KeyCode numlockcode;          XSizeHints *sizehints;
1034          KeyCode *keycode;          Pixmap bs;
         XModifierKeymap *modmap;  
         int i, j;  
1035    
1036          /* Find out if numlock is already defined as a modifier key, and if so where */          sizehints = XAllocSizeHints();
1037          numlockcode = XKeysymToKeycode(display, 0xFF7F);        /* XF_Num_Lock = 0xFF7F */          if (sizehints)
1038          if (numlockcode)          {
1039          {                  sizehints->flags = PMinSize | PMaxSize;
1040                  modmap = XGetModifierMapping(display);                  sizehints->min_width = sizehints->max_width = g_width;
1041                  if (modmap)                  sizehints->min_height = sizehints->max_height = g_height;
1042                  {                  XSetWMNormalHints(g_display, g_wnd, sizehints);
1043                          keycode = modmap->modifiermap;                  XFree(sizehints);
                         for (i = 0; i < 8; i++)  
                                 for (j = modmap->max_keypermod; j--;)  
                                 {  
                                         if (*keycode == numlockcode)  
                                         {  
                                                 numlock_modifier_mask =  
                                                         (1 << i);  
                                                 i = 8;  
                                                 break;  
                                         }  
                                         keycode++;  
                                 }  
                         if (!numlock_modifier_mask)  
                         {  
                                 modmap->modifiermap[7 *  
                                                     modmap->max_keypermod] =  
                                         numlockcode;  
                                 if (XSetModifierMapping(display, modmap) ==  
                                     MappingSuccess)  
                                         numlock_modifier_mask = (1 << 7);  
                                 else  
                                         printf("XSetModifierMapping failed!\n");  
                         }  
                         XFreeModifiermap(modmap);  
                 }  
1044          }          }
1045    
1046          if (!numlock_modifier_mask)          if (!(g_fullscreen || g_embed_wnd))
1047                  printf("WARNING: Failed to get a numlock modifier mapping.\n");          {
1048                    XResizeWindow(g_display, g_wnd, g_width, g_height);
1049            }
1050    
1051            /* create new backstore pixmap */
1052            if (g_backstore != 0)
1053            {
1054                    bs = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
1055                    XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
1056                    XFillRectangle(g_display, bs, g_gc, 0, 0, g_width, g_height);
1057                    XCopyArea(g_display, g_backstore, bs, g_gc, 0, 0, g_width, g_height, 0, 0);
1058                    XFreePixmap(g_display, g_backstore);
1059                    g_backstore = bs;
1060            }
1061    }
1062    
1063    void
1064    ui_destroy_window(void)
1065    {
1066            if (g_IC != NULL)
1067                    XDestroyIC(g_IC);
1068    
1069            XDestroyWindow(g_display, g_wnd);
1070  }  }
1071    
1072  void  void
1073  ui_destroy_window()  xwin_toggle_fullscreen(void)
1074  {  {
1075          if (xkb != NULL)          Pixmap contents = 0;
1076                  XkbFreeKeyboard(xkb, XkbAllControlsMask, True);  
1077            if (!g_ownbackstore)
1078            {
1079                    /* need to save contents of window */
1080                    contents = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
1081                    XCopyArea(g_display, g_wnd, contents, g_gc, 0, 0, g_width, g_height, 0, 0);
1082            }
1083    
1084            ui_destroy_window();
1085            g_fullscreen = !g_fullscreen;
1086            ui_create_window();
1087    
1088          if (ownbackstore)          XDefineCursor(g_display, g_wnd, g_current_cursor);
                 XFreePixmap(display, backstore);  
1089    
1090          XFreeGC(display, gc);          if (!g_ownbackstore)
1091          XDestroyWindow(display, wnd);          {
1092          XCloseDisplay(display);                  XCopyArea(g_display, contents, g_wnd, g_gc, 0, 0, g_width, g_height, 0, 0);
1093          display = NULL;                  XFreePixmap(g_display, contents);
1094            }
1095  }  }
1096    
1097  static void  /* Process all events in Xlib queue
1098  xwin_process_events()     Returns 0 after user quit, 1 otherwise */
1099    static int
1100    xwin_process_events(void)
1101  {  {
1102          XEvent xevent;          XEvent xevent;
   
1103          KeySym keysym;          KeySym keysym;
         uint8 scancode;  
1104          uint16 button, flags;          uint16 button, flags;
1105          uint32 ev_time;          uint32 ev_time;
1106          uint32 tmpmods;          key_translation tr;
1107            char str[256];
1108            Status status;
1109    
1110          while (XCheckMaskEvent(display, ~0, &xevent))          while (XPending(g_display) > 0)
1111          {          {
1112                  ev_time = time(NULL);                  XNextEvent(g_display, &xevent);
                 flags = 0;  
1113    
1114                  switch (xevent.type)                  if ((g_IC != NULL) && (XFilterEvent(&xevent, None) == True))
1115                  {                  {
1116                          case KeyRelease:                          DEBUG_KBD(("Filtering event\n"));
1117                                  flags = KBD_FLAG_DOWN | KBD_FLAG_UP;                          continue;
1118                                  /* fall through */                  }
                         case KeyPress:  
                                 if (XkbTranslateKeyCode  
                                     (xkb, xevent.xkey.keycode,  
                                      xevent.xkey.state, &tmpmods,  
                                      &keysym) == False)  
                                         break;  
                                 scancode =  
                                         xkeymap_translate_key(keysym,  
                                                               xevent.xkey.  
                                                               keycode,  
                                                               &flags);  
   
                                 if (scancode == 0)  
                                         break;  
   
                                 /* keep track of the modifiers -- needed for stickykeys... */  
                                 if (xevent.type == KeyPress)  
                                         xwin_mod_press(xevent.xkey.state,  
                                                        ev_time, scancode);  
   
                                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                                flags, scancode, 0);  
   
                                 if (xevent.type == KeyRelease)  
                                         xwin_mod_release(xevent.xkey.state,  
                                                          ev_time, scancode);  
   
                                 break;  
   
                         case ButtonPress:  
                                 flags = MOUSE_FLAG_DOWN;  
                                 /* fall through */  
   
                         case ButtonRelease:  
                                 button = xkeymap_translate_button(xevent.  
                                                                   xbutton.  
                                                                   button);  
                                 if (button == 0)  
                                         break;  
1119    
1120                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                  flags = 0;
                                                flags | button,  
                                                xevent.xbutton.x,  
                                                xevent.xbutton.y);  
                                 break;  
1121    
1122                          case MotionNotify:                  switch (xevent.type)
1123                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                  {
1124                                                 MOUSE_FLAG_MOVE,                          case VisibilityNotify:
1125                                                 xevent.xmotion.x,                                  g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;
                                                xevent.xmotion.y);  
1126                                  break;                                  break;
1127                            case ClientMessage:
1128                          case EnterNotify:                                  /* the window manager told us to quit */
1129                                  XGrabKeyboard(display, wnd, True,                                  if ((xevent.xclient.message_type == g_protocol_atom)
1130                                                GrabModeAsync, GrabModeAsync,                                      && ((Atom) xevent.xclient.data.l[0] == g_kill_atom))
1131                                                CurrentTime);                                          /* Quit */
1132                                            return 0;
                                 xwin_mod_update(xevent.xcrossing.state,  
                                                 ev_time);  
1133                                  break;                                  break;
1134    
1135                          case LeaveNotify:                          case KeyPress:
1136                                  XUngrabKeyboard(display, CurrentTime);                                  g_last_gesturetime = xevent.xkey.time;
1137                                  break;                                  if (g_IC != NULL)
1138                                            /* Multi_key compatible version */
1139                                    {
1140                                            XmbLookupString(g_IC,
1141                                                            &xevent.xkey, str, sizeof(str), &keysym,
1142                                                            &status);
1143                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
1144                                            {
1145                                                    error("XmbLookupString failed with status 0x%x\n",
1146                                                          status);
1147                                                    break;
1148                                            }
1149                                    }
1150                                    else
1151                                    {
1152                                            /* Plain old XLookupString */
1153                                            DEBUG_KBD(("\nNo input context, using XLookupString\n"));
1154                                            XLookupString((XKeyEvent *) & xevent,
1155                                                          str, sizeof(str), &keysym, NULL);
1156                                    }
1157    
1158                          case Expose:                                  DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym,
1159                                  XCopyArea(display, backstore, wnd, gc,                                             get_ksname(keysym)));
                                           xevent.xexpose.x, xevent.xexpose.y,  
                                           xevent.xexpose.width,  
                                           xevent.xexpose.height,  
                                           xevent.xexpose.x, xevent.xexpose.y);  
                                 break;  
                 }  
         }  
 }  
1160    
1161  void                                  ev_time = time(NULL);
1162  xwin_mod_update(uint32 state, uint32 ev_time)                                  if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
1163  {                                          break;
         xwin_mod_press(state, ev_time, 0);  
         xwin_mod_release(state, ev_time, 0);  
 }  
1164    
1165  void                                  tr = xkeymap_translate_key(keysym,
1166  xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode)                                                             xevent.xkey.keycode, xevent.xkey.state);
 {  
         switch (scancode)  
         {  
                 case 0x2a:  
                         key_down_state &= ~DShift1Mask;  
                         break;  
                 case 0x36:  
                         key_down_state &= ~DShift2Mask;  
                         break;  
                 case 0x1d:  
                         key_down_state &= ~DControl1Mask;  
                         break;  
                 case 0x9d:  
                         key_down_state &= ~DControl2Mask;  
                         break;  
                 case 0x38:  
                         key_down_state &= ~DMod1Mask;  
                         break;  
                 case 0xb8:  
                         key_down_state &= ~DMod2Mask;  
                         break;  
         }  
1167    
1168          if (!(numlock_modifier_mask & state)                                  if (tr.scancode == 0)
1169              && (key_down_state & DNumLockMask))                                          break;
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);  
                 key_down_state &= ~DNumLockMask;  
         }  
1170    
1171          if (!(LockMask & state) && (key_down_state & DLockMask))                                  save_remote_modifiers(tr.scancode);
1172          {                                  ensure_remote_modifiers(ev_time, tr);
1173                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);                                  rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
1174                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE,                                  restore_remote_modifiers(ev_time, tr.scancode);
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);  
                 key_down_state &= ~DLockMask;  
1175    
1176          }                                  break;
1177    
1178                            case KeyRelease:
1179                                    g_last_gesturetime = xevent.xkey.time;
1180                                    XLookupString((XKeyEvent *) & xevent, str,
1181                                                  sizeof(str), &keysym, NULL);
1182    
1183          if (!(ShiftMask & state) && (key_down_state & DShift1Mask))                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
1184          {                                             get_ksname(keysym)));
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x2a,  
                                0);  
                 key_down_state &= ~DShift1Mask;  
1185    
1186          }                                  ev_time = time(NULL);
1187                                    if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
1188                                            break;
1189    
1190          if (!(ControlMask & state) && (key_down_state & DControl1Mask))                                  tr = xkeymap_translate_key(keysym,
1191          {                                                             xevent.xkey.keycode, xevent.xkey.state);
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x1d,  
                                0);  
                 key_down_state &= ~DControl1Mask;  
1192    
1193          }                                  if (tr.scancode == 0)
1194                                            break;
1195    
1196          if (!(Mod1Mask & state) && (key_down_state & DMod1Mask))                                  rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
1197          {                                  break;
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x38,  
                                0);  
                 key_down_state &= ~DMod1Mask;  
1198    
1199          }                          case ButtonPress:
1200                                    flags = MOUSE_FLAG_DOWN;
1201                                    /* fall through */
1202    
1203          if (!(Mod2Mask & state) && (key_down_state & DMod2Mask))                          case ButtonRelease:
1204          {                                  g_last_gesturetime = xevent.xbutton.time;
1205                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0xb8,                                  button = xkeymap_translate_button(xevent.xbutton.button);
1206                                 0);                                  if (button == 0)
1207                  key_down_state &= ~DMod2Mask;                                          break;
         }  
 }  
1208    
1209                                    /* If win_button_size is nonzero, enable single app mode */
1210                                    if (xevent.xbutton.y < g_win_button_size)
1211                                    {
1212                                            /* Stop moving window when button is released, regardless of cursor position */
1213                                            if (g_moving_wnd && (xevent.type == ButtonRelease))
1214                                                    g_moving_wnd = False;
1215    
1216  void                                          /*  Check from right to left: */
 xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode)  
 {  
1217    
1218          switch (scancode)                                          if (xevent.xbutton.x >= g_width - g_win_button_size)
1219          {                                          {
1220                  case 0x2a:                                                  /* The close button, continue */
1221                          key_down_state |= DShift1Mask;                                                  ;
1222                          break;                                          }
1223                  case 0x36:                                          else if (xevent.xbutton.x >=
1224                          key_down_state |= DShift2Mask;                                                   g_width - g_win_button_size * 2)
1225                          break;                                          {
1226                  case 0x1d:                                                  /* The maximize/restore button. Do not send to
1227                          key_down_state |= DControl1Mask;                                                     server.  It might be a good idea to change the
1228                          break;                                                     cursor or give some other visible indication
1229                  case 0x9d:                                                     that rdesktop inhibited this click */
1230                          key_down_state |= DControl2Mask;                                                  break;
1231                          break;                                          }
1232                  case 0x3a:                                          else if (xevent.xbutton.x >=
1233                          key_down_state ^= DLockMask;                                                   g_width - g_win_button_size * 3)
1234                          break;                                          {
1235                  case 0x45:                                                  /* The minimize button. Iconify window. */
1236                          key_down_state ^= DNumLockMask;                                                  XIconifyWindow(g_display, g_wnd,
1237                          break;                                                                 DefaultScreen(g_display));
1238                  case 0x38:                                                  break;
1239                          key_down_state |= DMod1Mask;                                          }
1240                          break;                                          else if (xevent.xbutton.x <= g_win_button_size)
1241                  case 0xb8:                                          {
1242                          key_down_state |= DMod2Mask;                                                  /* The system menu. Ignore. */
1243                          break;                                                  break;
1244          }                                          }
1245                                            else
1246                                            {
1247                                                    /* The title bar. */
1248                                                    if ((xevent.type == ButtonPress) && !g_fullscreen
1249                                                        && g_hide_decorations)
1250                                                    {
1251                                                            g_moving_wnd = True;
1252                                                            g_move_x_offset = xevent.xbutton.x;
1253                                                            g_move_y_offset = xevent.xbutton.y;
1254                                                    }
1255                                                    break;
1256    
1257          if ((numlock_modifier_mask && state)                                          }
1258              && !(key_down_state & DNumLockMask))                                  }
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);  
                 key_down_state |= DNumLockMask;  
         }  
1259    
1260          if ((LockMask & state) && !(key_down_state & DLockMask))                                  rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
1261          {                                                 flags | button, xevent.xbutton.x, xevent.xbutton.y);
1262                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);                                  break;
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);  
                 key_down_state |= DLockMask;  
1263    
1264          }                          case MotionNotify:
1265                                    if (g_moving_wnd)
1266                                    {
1267                                            XMoveWindow(g_display, g_wnd,
1268                                                        xevent.xmotion.x_root - g_move_x_offset,
1269                                                        xevent.xmotion.y_root - g_move_y_offset);
1270                                            break;
1271                                    }
1272    
1273                                    if (g_fullscreen && !g_focused)
1274                                            XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
1275                                                           CurrentTime);
1276                                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
1277                                                   MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
1278                                    break;
1279    
1280          if ((ShiftMask & state)                          case FocusIn:
1281              && !((key_down_state & DShift1Mask)                                  if (xevent.xfocus.mode == NotifyGrab)
1282                   || (key_down_state & DShift2Mask)))                                          break;
1283          {                                  g_focused = True;
1284                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,                                  reset_modifier_keys();
1285                                 0x2a, 0);                                  if (g_grab_keyboard && g_mouse_in_wnd)
1286                  key_down_state |= DShift1Mask;                                          XGrabKeyboard(g_display, g_wnd, True,
1287                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
1288                                    break;
1289    
1290          }                          case FocusOut:
1291                                    if (xevent.xfocus.mode == NotifyUngrab)
1292                                            break;
1293                                    g_focused = False;
1294                                    if (xevent.xfocus.mode == NotifyWhileGrabbed)
1295                                            XUngrabKeyboard(g_display, CurrentTime);
1296                                    break;
1297    
1298          if ((ControlMask & state)                          case EnterNotify:
1299              && !((key_down_state & DControl1Mask)                                  /* we only register for this event when in fullscreen mode */
1300                   || (key_down_state & DControl2Mask)))                                  /* or grab_keyboard */
1301          {                                  g_mouse_in_wnd = True;
1302                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,                                  if (g_fullscreen)
1303                                 0x1d, 0);                                  {
1304                  key_down_state |= DControl1Mask;                                          XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
1305                                                           CurrentTime);
1306                                            break;
1307                                    }
1308                                    if (g_focused)
1309                                            XGrabKeyboard(g_display, g_wnd, True,
1310                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
1311                                    break;
1312    
1313          }                          case LeaveNotify:
1314                                    /* we only register for this event when grab_keyboard */
1315                                    g_mouse_in_wnd = False;
1316                                    XUngrabKeyboard(g_display, CurrentTime);
1317                                    break;
1318    
1319          if ((Mod1Mask & state) && !(key_down_state & DMod1Mask))                          case Expose:
1320          {                                  XCopyArea(g_display, g_backstore, g_wnd, g_gc,
1321                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,                                            xevent.xexpose.x, xevent.xexpose.y,
1322                                 0x38, 0);                                            xevent.xexpose.width,
1323                  key_down_state |= DMod1Mask;                                            xevent.xexpose.height,
1324                                              xevent.xexpose.x, xevent.xexpose.y);
1325                                    break;
1326    
1327          }                          case MappingNotify:
1328                                    /* Refresh keyboard mapping if it has changed. This is important for
1329                                       Xvnc, since it allocates keycodes dynamically */
1330                                    if (xevent.xmapping.request == MappingKeyboard
1331                                        || xevent.xmapping.request == MappingModifier)
1332                                            XRefreshKeyboardMapping(&xevent.xmapping);
1333    
1334          if ((Mod2Mask & state) && !(key_down_state & DMod2Mask))                                  if (xevent.xmapping.request == MappingModifier)
1335          {                                  {
1336                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,                                          XFreeModifiermap(g_mod_map);
1337                                 0xb8, 0);                                          g_mod_map = XGetModifierMapping(g_display);
1338                  key_down_state |= DMod2Mask;                                  }
1339                                    break;
1340    
1341                                    /* clipboard stuff */
1342                            case SelectionNotify:
1343                                    xclip_handle_SelectionNotify(&xevent.xselection);
1344                                    break;
1345                            case SelectionRequest:
1346                                    xclip_handle_SelectionRequest(&xevent.xselectionrequest);
1347                                    break;
1348                            case SelectionClear:
1349                                    xclip_handle_SelectionClear();
1350                                    break;
1351                            case PropertyNotify:
1352                                    xclip_handle_PropertyNotify(&xevent.xproperty);
1353                                    break;
1354                    }
1355          }          }
1356            /* Keep going */
1357            return 1;
1358  }  }
1359    
1360  void  /* Returns 0 after user quit, 1 otherwise */
1361    int
1362  ui_select(int rdp_socket)  ui_select(int rdp_socket)
1363  {  {
1364          int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;          int n;
1365          fd_set rfds;          fd_set rfds, wfds;
1366            struct timeval tv;
1367          FD_ZERO(&rfds);          BOOL s_timeout = False;
1368    
1369          while (True)          while (True)
1370          {          {
1371                    n = (rdp_socket > g_x_socket) ? rdp_socket : g_x_socket;
1372                    /* Process any events already waiting */
1373                    if (!xwin_process_events())
1374                            /* User quit */
1375                            return 0;
1376    
1377                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
1378                    FD_ZERO(&wfds);
1379                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
1380                  if (display != NULL)                  FD_SET(g_x_socket, &rfds);
1381    
1382    #ifdef WITH_RDPSND
1383                    /* FIXME: there should be an API for registering fds */
1384                    if (g_dsp_busy)
1385                  {                  {
1386                          FD_SET(x_socket, &rfds);                          FD_SET(g_dsp_fd, &wfds);
1387                          XFlush(display);                          n = (g_dsp_fd > n) ? g_dsp_fd : n;
1388                  }                  }
1389    #endif
1390                    /* default timeout */
1391                    tv.tv_sec = 60;
1392                    tv.tv_usec = 0;
1393    
1394                    /* add redirection handles */
1395                    rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);
1396    
1397                    n++;
1398    
1399                  switch (select(n, &rfds, NULL, NULL, NULL))                  switch (select(n, &rfds, &wfds, NULL, &tv))
1400                  {                  {
1401                          case -1:                          case -1:
1402                                  error("select: %s\n", strerror(errno));                                  error("select: %s\n", strerror(errno));
1403    
1404                          case 0:                          case 0:
1405                                    /* TODO: if tv.tv_sec just times out
1406                                     * we will segfault.
1407                                     * FIXME:
1408                                     */
1409                                    //s_timeout = True;
1410                                    //rdpdr_check_fds(&rfds, &wfds, (BOOL) True);
1411                                  continue;                                  continue;
1412                  }                  }
1413    
1414                  if (FD_ISSET(x_socket, &rfds))                  rdpdr_check_fds(&rfds, &wfds, (BOOL) False);
                         xwin_process_events();  
1415    
1416                  if (FD_ISSET(rdp_socket, &rfds))                  if (FD_ISSET(rdp_socket, &rfds))
1417                          return;                          return 1;
1418    
1419    #ifdef WITH_RDPSND
1420                    if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))
1421                            wave_out_play();
1422    #endif
1423          }          }
1424  }  }
1425    
1426  void  void
1427  ui_move_pointer(int x, int y)  ui_move_pointer(int x, int y)
1428  {  {
1429          XWarpPointer(display, wnd, wnd, 0, 0, 0, 0, x, y);          XWarpPointer(g_display, g_wnd, g_wnd, 0, 0, 0, 0, x, y);
1430  }  }
1431    
1432  HBITMAP  HBITMAP
# Line 761  ui_create_bitmap(int width, int height, Line 1435  ui_create_bitmap(int width, int height,
1435          XImage *image;          XImage *image;
1436          Pixmap bitmap;          Pixmap bitmap;
1437          uint8 *tdata;          uint8 *tdata;
1438            int bitmap_pad;
1439    
1440            if (g_server_bpp == 8)
1441            {
1442                    bitmap_pad = 8;
1443            }
1444            else
1445            {
1446                    bitmap_pad = g_bpp;
1447    
1448                    if (g_bpp == 24)
1449                            bitmap_pad = 32;
1450            }
1451    
1452          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (g_owncolmap ? data : translate_image(width, height, data));
1453          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(g_display, g_wnd, width, height, g_depth);
1454          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
1455                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, bitmap_pad, 0);
1456    
1457          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(g_display, bitmap, g_gc, image, 0, 0, 0, 0, width, height);
1458    
1459          XFree(image);          XFree(image);
1460          if (!owncolmap)          if (tdata != data)
1461                  xfree(tdata);                  xfree(tdata);
1462          return (HBITMAP) bitmap;          return (HBITMAP) bitmap;
1463  }  }
1464    
1465  void  void
1466  ui_paint_bitmap(int x, int y, int cx, int cy,  ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
                 int width, int height, uint8 * data)  
1467  {  {
1468          XImage *image;          XImage *image;
1469          uint8 *tdata;          uint8 *tdata;
1470            int bitmap_pad;
1471    
1472            if (g_server_bpp == 8)
1473            {
1474                    bitmap_pad = 8;
1475            }
1476            else
1477            {
1478                    bitmap_pad = g_bpp;
1479    
1480                    if (g_bpp == 24)
1481                            bitmap_pad = 32;
1482            }
1483    
1484          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (g_owncolmap ? data : translate_image(width, height, data));
1485          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
1486                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, bitmap_pad, 0);
1487    
1488          if (ownbackstore)          if (g_ownbackstore)
1489          {          {
1490                  XPutImage(display, backstore, gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
1491                  XCopyArea(display, backstore, wnd, gc, x, y, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
1492          }          }
1493          else          else
1494          {          {
1495                  XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
1496          }          }
1497    
1498          XFree(image);          XFree(image);
1499          if (!owncolmap)          if (tdata != data)
1500                  xfree(tdata);                  xfree(tdata);
1501  }  }
1502    
1503  void  void
1504  ui_destroy_bitmap(HBITMAP bmp)  ui_destroy_bitmap(HBITMAP bmp)
1505  {  {
1506          XFreePixmap(display, (Pixmap) bmp);          XFreePixmap(g_display, (Pixmap) bmp);
1507  }  }
1508    
1509  HGLYPH  HGLYPH
# Line 817  ui_create_glyph(int width, int height, u Line 1516  ui_create_glyph(int width, int height, u
1516    
1517          scanline = (width + 7) / 8;          scanline = (width + 7) / 8;
1518    
1519          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1);
1520          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(g_display, bitmap, 0, NULL);
1521    
1522          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data,
1523                               data, width, height, 8, scanline);                               width, height, 8, scanline);
1524          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
1525          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
1526          XInitImage(image);          XInitImage(image);
1527    
1528          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(g_display, bitmap, gc, image, 0, 0, 0, 0, width, height);
1529    
1530          XFree(image);          XFree(image);
1531          XFreeGC(display, gc);          XFreeGC(g_display, gc);
1532          return (HGLYPH) bitmap;          return (HGLYPH) bitmap;
1533  }  }
1534    
1535  void  void
1536  ui_destroy_glyph(HGLYPH glyph)  ui_destroy_glyph(HGLYPH glyph)
1537  {  {
1538          XFreePixmap(display, (Pixmap) glyph);          XFreePixmap(g_display, (Pixmap) glyph);
1539  }  }
1540    
1541  HCURSOR  HCURSOR
1542  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
1543                   int height, uint8 * andmask, uint8 * xormask)                   uint8 * andmask, uint8 * xormask)
1544  {  {
1545          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
1546          XColor bg, fg;          XColor bg, fg;
# Line 855  ui_create_cursor(unsigned int x, unsigne Line 1554  ui_create_cursor(unsigned int x, unsigne
1554          scanline = (width + 7) / 8;          scanline = (width + 7) / 8;
1555          offset = scanline * height;          offset = scanline * height;
1556    
1557          cursor = xmalloc(offset);          cursor = (uint8 *) xmalloc(offset);
1558          memset(cursor, 0, offset);          memset(cursor, 0, offset);
1559    
1560          mask = xmalloc(offset);          mask = (uint8 *) xmalloc(offset);
1561          memset(mask, 0, offset);          memset(mask, 0, offset);
1562    
1563          /* approximate AND and XOR masks with a monochrome X pointer */          /* approximate AND and XOR masks with a monochrome X pointer */
# Line 899  ui_create_cursor(unsigned int x, unsigne Line 1598  ui_create_cursor(unsigned int x, unsigne
1598          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
1599          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
1600    
1601          xcursor = XCreatePixmapCursor(display, (Pixmap) cursorglyph,          xcursor =
1602                                        (Pixmap) maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(g_display, (Pixmap) cursorglyph,
1603                                        (Pixmap) maskglyph, &fg, &bg, x, y);
1604    
1605          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
1606          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
# Line 912  ui_create_cursor(unsigned int x, unsigne Line 1612  ui_create_cursor(unsigned int x, unsigne
1612  void  void
1613  ui_set_cursor(HCURSOR cursor)  ui_set_cursor(HCURSOR cursor)
1614  {  {
1615          XDefineCursor(display, wnd, (Cursor) cursor);          g_current_cursor = (Cursor) cursor;
1616            XDefineCursor(g_display, g_wnd, g_current_cursor);
1617  }  }
1618    
1619  void  void
1620  ui_destroy_cursor(HCURSOR cursor)  ui_destroy_cursor(HCURSOR cursor)
1621  {  {
1622          XFreeCursor(display, (Cursor) cursor);          XFreeCursor(g_display, (Cursor) cursor);
1623    }
1624    
1625    void
1626    ui_set_null_cursor(void)
1627    {
1628            ui_set_cursor(g_null_cursor);
1629  }  }
1630    
1631  #define MAKE_XCOLOR(xc,c) \  #define MAKE_XCOLOR(xc,c) \
# Line 927  ui_destroy_cursor(HCURSOR cursor) Line 1634  ui_destroy_cursor(HCURSOR cursor)
1634                  (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \                  (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \
1635                  (xc)->flags = DoRed | DoGreen | DoBlue;                  (xc)->flags = DoRed | DoGreen | DoBlue;
1636    
1637    
1638  HCOLOURMAP  HCOLOURMAP
1639  ui_create_colourmap(COLOURMAP * colours)  ui_create_colourmap(COLOURMAP * colours)
1640  {  {
1641          COLOURENTRY *entry;          COLOURENTRY *entry;
1642          int i, ncolours = colours->ncolours;          int i, ncolours = colours->ncolours;
1643            if (!g_owncolmap)
1644            {
1645                    uint32 *map = (uint32 *) xmalloc(sizeof(*g_colmap) * ncolours);
1646                    XColor xentry;
1647                    XColor xc_cache[256];
1648                    uint32 colour;
1649                    int colLookup = 256;
1650                    for (i = 0; i < ncolours; i++)
1651                    {
1652                            entry = &colours->colours[i];
1653                            MAKE_XCOLOR(&xentry, entry);
1654    
1655                            if (XAllocColor(g_display, g_xcolmap, &xentry) == 0)
1656                            {
1657                                    /* Allocation failed, find closest match. */
1658                                    int j = 256;
1659                                    int nMinDist = 3 * 256 * 256;
1660                                    long nDist = nMinDist;
1661    
1662          if (owncolmap)                                  /* only get the colors once */
1663                                    while (colLookup--)
1664                                    {
1665                                            xc_cache[colLookup].pixel = colLookup;
1666                                            xc_cache[colLookup].red = xc_cache[colLookup].green =
1667                                                    xc_cache[colLookup].blue = 0;
1668                                            xc_cache[colLookup].flags = 0;
1669                                            XQueryColor(g_display,
1670                                                        DefaultColormap(g_display,
1671                                                                        DefaultScreen(g_display)),
1672                                                        &xc_cache[colLookup]);
1673                                    }
1674                                    colLookup = 0;
1675    
1676                                    /* approximate the pixel */
1677                                    while (j--)
1678                                    {
1679                                            if (xc_cache[j].flags)
1680                                            {
1681                                                    nDist = ((long) (xc_cache[j].red >> 8) -
1682                                                             (long) (xentry.red >> 8)) *
1683                                                            ((long) (xc_cache[j].red >> 8) -
1684                                                             (long) (xentry.red >> 8)) +
1685                                                            ((long) (xc_cache[j].green >> 8) -
1686                                                             (long) (xentry.green >> 8)) *
1687                                                            ((long) (xc_cache[j].green >> 8) -
1688                                                             (long) (xentry.green >> 8)) +
1689                                                            ((long) (xc_cache[j].blue >> 8) -
1690                                                             (long) (xentry.blue >> 8)) *
1691                                                            ((long) (xc_cache[j].blue >> 8) -
1692                                                             (long) (xentry.blue >> 8));
1693                                            }
1694                                            if (nDist < nMinDist)
1695                                            {
1696                                                    nMinDist = nDist;
1697                                                    xentry.pixel = j;
1698                                            }
1699                                    }
1700                            }
1701                            colour = xentry.pixel;
1702    
1703                            /* update our cache */
1704                            if (xentry.pixel < 256)
1705                            {
1706                                    xc_cache[xentry.pixel].red = xentry.red;
1707                                    xc_cache[xentry.pixel].green = xentry.green;
1708                                    xc_cache[xentry.pixel].blue = xentry.blue;
1709    
1710                            }
1711    
1712                            map[i] = colour;
1713                    }
1714                    return map;
1715            }
1716            else
1717          {          {
1718                  XColor *xcolours, *xentry;                  XColor *xcolours, *xentry;
1719                  Colormap map;                  Colormap map;
1720    
1721                  xcolours = xmalloc(sizeof(XColor) * ncolours);                  xcolours = (XColor *) xmalloc(sizeof(XColor) * ncolours);
1722                  for (i = 0; i < ncolours; i++)                  for (i = 0; i < ncolours; i++)
1723                  {                  {
1724                          entry = &colours->colours[i];                          entry = &colours->colours[i];
# Line 947  ui_create_colourmap(COLOURMAP * colours) Line 1727  ui_create_colourmap(COLOURMAP * colours)
1727                          MAKE_XCOLOR(xentry, entry);                          MAKE_XCOLOR(xentry, entry);
1728                  }                  }
1729    
1730                  map = XCreateColormap(display, wnd, visual, AllocAll);                  map = XCreateColormap(g_display, g_wnd, g_visual, AllocAll);
1731                  XStoreColors(display, map, xcolours, ncolours);                  XStoreColors(g_display, map, xcolours, ncolours);
1732    
1733                  xfree(xcolours);                  xfree(xcolours);
1734                  return (HCOLOURMAP) map;                  return (HCOLOURMAP) map;
1735          }          }
         else  
         {  
                 uint32 *map = xmalloc(sizeof(*colmap) * ncolours);  
                 XColor xentry;  
                 uint32 colour;  
   
                 for (i = 0; i < ncolours; i++)  
                 {  
                         entry = &colours->colours[i];  
                         MAKE_XCOLOR(&xentry, entry);  
   
                         if (XAllocColor(display, xcolmap, &xentry) != 0)  
                                 colour = xentry.pixel;  
                         else  
                                 colour = white;  
   
                         /* byte swap here to make translate_image faster */  
                         map[i] = translate_colour(colour);  
                 }  
   
                 return map;  
         }  
1736  }  }
1737    
1738  void  void
1739  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
1740  {  {
1741          if (owncolmap)          if (!g_owncolmap)
                 XFreeColormap(display, (Colormap) map);  
         else  
1742                  xfree(map);                  xfree(map);
1743            else
1744                    XFreeColormap(g_display, (Colormap) map);
1745  }  }
1746    
1747  void  void
1748  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
1749  {  {
1750          if (owncolmap)          if (!g_owncolmap)
1751                  XSetWindowColormap(display, wnd, (Colormap) map);          {
1752                    if (g_colmap)
1753                            xfree(g_colmap);
1754    
1755                    g_colmap = (uint32 *) map;
1756            }
1757          else          else
1758                  colmap = map;                  XSetWindowColormap(g_display, g_wnd, (Colormap) map);
1759  }  }
1760    
1761  void  void
# Line 1004  ui_set_clip(int x, int y, int cx, int cy Line 1767  ui_set_clip(int x, int y, int cx, int cy
1767          rect.y = y;          rect.y = y;
1768          rect.width = cx;          rect.width = cx;
1769          rect.height = cy;          rect.height = cy;
1770          XSetClipRectangles(display, gc, 0, 0, &rect, 1, YXBanded);          XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);
1771  }  }
1772    
1773  void  void
1774  ui_reset_clip()  ui_reset_clip(void)
1775  {  {
1776          XRectangle rect;          XRectangle rect;
1777    
1778          rect.x = 0;          rect.x = 0;
1779          rect.y = 0;          rect.y = 0;
1780          rect.width = width;          rect.width = g_width;
1781          rect.height = height;          rect.height = g_height;
1782          XSetClipRectangles(display, gc, 0, 0, &rect, 1, YXBanded);          XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);
1783  }  }
1784    
1785  void  void
1786  ui_bell()  ui_bell(void)
1787  {  {
1788          XBell(display, 0);          XBell(g_display, 0);
1789  }  }
1790    
1791  void  void
# Line 1034  ui_destblt(uint8 opcode, Line 1797  ui_destblt(uint8 opcode,
1797          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1798  }  }
1799    
1800    static uint8 hatch_patterns[] = {
1801            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, /* 0 - bsHorizontal */
1802            0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, /* 1 - bsVertical */
1803            0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, /* 2 - bsFDiagonal */
1804            0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, /* 3 - bsBDiagonal */
1805            0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08, /* 4 - bsCross */
1806            0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81  /* 5 - bsDiagCross */
1807    };
1808    
1809  void  void
1810  ui_patblt(uint8 opcode,  ui_patblt(uint8 opcode,
1811            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
# Line 1048  ui_patblt(uint8 opcode, Line 1820  ui_patblt(uint8 opcode,
1820          {          {
1821                  case 0: /* Solid */                  case 0: /* Solid */
1822                          SET_FOREGROUND(fgcolour);                          SET_FOREGROUND(fgcolour);
1823                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
1824                            break;
1825    
1826                    case 2: /* Hatch */
1827                            fill = (Pixmap) ui_create_glyph(8, 8,
1828                                                            hatch_patterns + brush->pattern[0] * 8);
1829                            SET_FOREGROUND(fgcolour);
1830                            SET_BACKGROUND(bgcolour);
1831                            XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
1832                            XSetStipple(g_display, g_gc, fill);
1833                            XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
1834                            FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
1835                            XSetFillStyle(g_display, g_gc, FillSolid);
1836                            XSetTSOrigin(g_display, g_gc, 0, 0);
1837                            ui_destroy_glyph((HGLYPH) fill);
1838                          break;                          break;
1839    
1840                  case 3: /* Pattern */                  case 3: /* Pattern */
1841                          for (i = 0; i != 8; i++)                          for (i = 0; i != 8; i++)
1842                                  ipattern[7 - i] = brush->pattern[i];                                  ipattern[7 - i] = brush->pattern[i];
1843                          fill = (Pixmap) ui_create_glyph(8, 8, ipattern);                          fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
   
1844                          SET_FOREGROUND(bgcolour);                          SET_FOREGROUND(bgcolour);
1845                          SET_BACKGROUND(fgcolour);                          SET_BACKGROUND(fgcolour);
1846                          XSetFillStyle(display, gc, FillOpaqueStippled);                          XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
1847                          XSetStipple(display, gc, fill);                          XSetStipple(g_display, g_gc, fill);
1848                          XSetTSOrigin(display, gc, brush->xorigin,                          XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
1849                                       brush->yorigin);                          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
1850                            XSetFillStyle(g_display, g_gc, FillSolid);
1851                          FILL_RECTANGLE(x, y, cx, cy);                          XSetTSOrigin(g_display, g_gc, 0, 0);
   
                         XSetFillStyle(display, gc, FillSolid);  
1852                          ui_destroy_glyph((HGLYPH) fill);                          ui_destroy_glyph((HGLYPH) fill);
1853                          break;                          break;
1854    
# Line 1074  ui_patblt(uint8 opcode, Line 1857  ui_patblt(uint8 opcode,
1857          }          }
1858    
1859          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1860    
1861            if (g_ownbackstore)
1862                    XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
1863  }  }
1864    
1865  void  void
# Line 1082  ui_screenblt(uint8 opcode, Line 1868  ui_screenblt(uint8 opcode,
1868               /* src */ int srcx, int srcy)               /* src */ int srcx, int srcy)
1869  {  {
1870          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1871          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          if (g_ownbackstore)
1872          if (ownbackstore)          {
1873                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  if (g_Unobscured)
1874                            cx, cy, x, y);                  {
1875                            XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
1876                            XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,
1877                                      y);
1878                    }
1879                    else
1880                    {
1881                            XCopyArea(g_display, g_backstore, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
1882                            XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,
1883                                      y);
1884                    }
1885            }
1886            else
1887            {
1888                    XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
1889            }
1890          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1891  }  }
1892    
# Line 1095  ui_memblt(uint8 opcode, Line 1896  ui_memblt(uint8 opcode,
1896            /* src */ HBITMAP src, int srcx, int srcy)            /* src */ HBITMAP src, int srcx, int srcy)
1897  {  {
1898          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1899          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
1900          if (ownbackstore)          if (g_ownbackstore)
1901                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy,                  XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
1902          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1903  }  }
1904    
# Line 1115  ui_triblt(uint8 opcode, Line 1915  ui_triblt(uint8 opcode,
1915          {          {
1916                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
1917                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
1918                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1919                          break;                          break;
1920    
1921                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
1922                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1923                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
1924                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1925                          break;                          break;
1926    
1927                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
1928                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
1929                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
1930                          break;                          break;
1931    
1932                  default:                  default:
# Line 1146  ui_line(uint8 opcode, Line 1942  ui_line(uint8 opcode,
1942  {  {
1943          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1944          SET_FOREGROUND(pen->colour);          SET_FOREGROUND(pen->colour);
1945          XDrawLine(display, wnd, gc, startx, starty, endx, endy);          XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);
1946          if (ownbackstore)          if (g_ownbackstore)
1947                  XDrawLine(display, backstore, gc, startx, starty, endx, endy);                  XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);
1948          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1949  }  }
1950    
# Line 1161  ui_rect( Line 1957  ui_rect(
1957          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE(x, y, cx, cy);
1958  }  }
1959    
1960    /* warning, this function only draws on wnd or backstore, not both */
1961  void  void
1962  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
1963                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
1964                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
1965                int fgcolour)                int bgcolour, int fgcolour)
1966  {  {
1967          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
1968          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
1969    
1970          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(g_display, g_gc,
1971                        ? FillStippled : FillOpaqueStippled);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
1972          XSetStipple(display, gc, (Pixmap) glyph);          XSetStipple(g_display, g_gc, (Pixmap) glyph);
1973          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(g_display, g_gc, x, y);
1974    
1975          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
1976    
1977          XSetFillStyle(display, gc, FillSolid);          XSetFillStyle(g_display, g_gc, FillSolid);
1978  }  }
1979    
1980  #define DO_GLYPH(ttext,idx) \  #define DO_GLYPH(ttext,idx) \
1981  {\  {\
1982    glyph = cache_get_font (font, ttext[idx]);\    glyph = cache_get_font (font, ttext[idx]);\
1983    if (!(flags & TEXT2_IMPLICIT_X))\    if (!(flags & TEXT2_IMPLICIT_X))\
1984      {\
1985        xyoffset = ttext[++idx];\
1986        if ((xyoffset & 0x80))\
1987      {\      {\
1988        xyoffset = ttext[++idx];\        if (flags & TEXT2_VERTICAL)\
1989        if ((xyoffset & 0x80))\          y += ttext[idx+1] | (ttext[idx+2] << 8);\
         {\  
           if (flags & TEXT2_VERTICAL) \  
             y += ttext[++idx] | (ttext[++idx] << 8);\  
           else\  
             x += ttext[++idx] | (ttext[++idx] << 8);\  
         }\  
1990        else\        else\
1991          {\          x += ttext[idx+1] | (ttext[idx+2] << 8);\
1992            if (flags & TEXT2_VERTICAL) \        idx += 2;\
             y += xyoffset;\  
           else\  
             x += xyoffset;\  
         }\  
1993      }\      }\
1994    if (glyph != NULL)\      else\
1995      {\      {\
1996        ui_draw_glyph (mixmode, x + (short) glyph->offset,\        if (flags & TEXT2_VERTICAL)\
1997                       y + (short) glyph->baseline,\          y += xyoffset;\
1998                       glyph->width, glyph->height,\        else\
1999                       glyph->pixmap, 0, 0, bgcolour, fgcolour);\          x += xyoffset;\
       if (flags & TEXT2_IMPLICIT_X)\  
         x += glyph->width;\  
2000      }\      }\
2001      }\
2002      if (glyph != NULL)\
2003      {\
2004        x1 = x + glyph->offset;\
2005        y1 = y + glyph->baseline;\
2006        XSetStipple(g_display, g_gc, (Pixmap) glyph->pixmap);\
2007        XSetTSOrigin(g_display, g_gc, x1, y1);\
2008        FILL_RECTANGLE_BACKSTORE(x1, y1, glyph->width, glyph->height);\
2009        if (flags & TEXT2_IMPLICIT_X)\
2010          x += glyph->width;\
2011      }\
2012  }  }
2013    
2014  void  void
2015  ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y,  ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y,
2016               int clipx, int clipy, int clipcx, int clipcy, int boxx,               int clipx, int clipy, int clipcx, int clipcy,
2017               int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
2018               int fgcolour, uint8 * text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
2019  {  {
2020          FONTGLYPH *glyph;          FONTGLYPH *glyph;
2021          int i, j, xyoffset;          int i, j, xyoffset, x1, y1;
2022          DATABLOB *entry;          DATABLOB *entry;
2023    
2024          SET_FOREGROUND(bgcolour);          SET_FOREGROUND(bgcolour);
2025    
2026            /* Sometimes, the boxcx value is something really large, like
2027               32691. This makes XCopyArea fail with Xvnc. The code below
2028               is a quick fix. */
2029            if (boxx + boxcx > g_width)
2030                    boxcx = g_width - boxx;
2031    
2032          if (boxcx > 1)          if (boxcx > 1)
2033          {          {
2034                  FILL_RECTANGLE(boxx, boxy, boxcx, boxcy);                  FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy);
2035          }          }
2036          else if (mixmode == MIX_OPAQUE)          else if (mixmode == MIX_OPAQUE)
2037          {          {
2038                  FILL_RECTANGLE(clipx, clipy, clipcx, clipcy);                  FILL_RECTANGLE_BACKSTORE(clipx, clipy, clipcx, clipcy);
2039          }          }
2040    
2041            SET_FOREGROUND(fgcolour);
2042            SET_BACKGROUND(bgcolour);
2043            XSetFillStyle(g_display, g_gc, FillStippled);
2044    
2045          /* Paint text, character by character */          /* Paint text, character by character */
2046          for (i = 0; i < length;)          for (i = 0; i < length;)
2047          {          {
# Line 1240  ui_draw_text(uint8 font, uint8 flags, in Line 2049  ui_draw_text(uint8 font, uint8 flags, in
2049                  {                  {
2050                          case 0xff:                          case 0xff:
2051                                  if (i + 2 < length)                                  if (i + 2 < length)
2052                                          cache_put_text(text[i + 1], text,                                          cache_put_text(text[i + 1], text, text[i + 2]);
                                                        text[i + 2]);  
2053                                  else                                  else
2054                                  {                                  {
2055                                          error("this shouldn't be happening\n");                                          error("this shouldn't be happening\n");
2056                                          break;                                          exit(1);
2057                                  }                                  }
2058                                  /* this will move pointer from start to first character after FF command */                                  /* this will move pointer from start to first character after FF command */
2059                                  length -= i + 3;                                  length -= i + 3;
# Line 1258  ui_draw_text(uint8 font, uint8 flags, in Line 2066  ui_draw_text(uint8 font, uint8 flags, in
2066                                  if (entry != NULL)                                  if (entry != NULL)
2067                                  {                                  {
2068                                          if ((((uint8 *) (entry->data))[1] ==                                          if ((((uint8 *) (entry->data))[1] ==
2069                                               0)                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
                                             && (!(flags & TEXT2_IMPLICIT_X)))  
2070                                          {                                          {
2071                                                  if (flags & TEXT2_VERTICAL)                                                  if (flags & TEXT2_VERTICAL)
2072                                                          y += text[i + 2];                                                          y += text[i + 2];
2073                                                  else                                                  else
2074                                                          x += text[i + 2];                                                          x += text[i + 2];
2075                                          }                                          }
                                         if (i + 2 < length)  
                                                 i += 3;  
                                         else  
                                                 i += 2;  
                                         length -= i;  
                                         /* this will move pointer from start to first character after FE command */  
                                         text = &(text[i]);  
                                         i = 0;  
2076                                          for (j = 0; j < entry->size; j++)                                          for (j = 0; j < entry->size; j++)
2077                                                  DO_GLYPH(((uint8 *) (entry->                                                  DO_GLYPH(((uint8 *) (entry->data)), j);
                                                                      data)),  
                                                          j);  
2078                                  }                                  }
2079                                    if (i + 2 < length)
2080                                            i += 3;
2081                                    else
2082                                            i += 2;
2083                                    length -= i;
2084                                    /* this will move pointer from start to first character after FE command */
2085                                    text = &(text[i]);
2086                                    i = 0;
2087                                  break;                                  break;
2088    
2089                          default:                          default:
# Line 1288  ui_draw_text(uint8 font, uint8 flags, in Line 2093  ui_draw_text(uint8 font, uint8 flags, in
2093                  }                  }
2094          }          }
2095    
2096            XSetFillStyle(g_display, g_gc, FillSolid);
2097    
2098            if (g_ownbackstore)
2099            {
2100                    if (boxcx > 1)
2101                            XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,
2102                                      boxy, boxcx, boxcy, boxx, boxy);
2103                    else
2104                            XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,
2105                                      clipy, clipcx, clipcy, clipx, clipy);
2106            }
2107  }  }
2108    
2109  void  void
# Line 1297  ui_desktop_save(uint32 offset, int x, in Line 2112  ui_desktop_save(uint32 offset, int x, in
2112          Pixmap pix;          Pixmap pix;
2113          XImage *image;          XImage *image;
2114    
2115          if (ownbackstore)          if (g_ownbackstore)
2116          {          {
2117                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,                  image = XGetImage(g_display, g_backstore, x, y, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
2118          }          }
2119          else          else
2120          {          {
2121                  pix = XCreatePixmap(display, wnd, cx, cy, depth);                  pix = XCreatePixmap(g_display, g_wnd, cx, cy, g_depth);
2122                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);                  XCopyArea(g_display, g_wnd, pix, g_gc, x, y, cx, cy, 0, 0);
2123                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,                  image = XGetImage(g_display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
2124                                    ZPixmap);                  XFreePixmap(g_display, pix);
                 XFreePixmap(display, pix);  
2125          }          }
2126    
2127          offset *= bpp / 8;          offset *= g_bpp / 8;
2128          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, g_bpp / 8, (uint8 *) image->data);
                           bpp / 8, (uint8 *) image->data);  
2129    
2130          XDestroyImage(image);          XDestroyImage(image);
2131  }  }
# Line 1324  ui_desktop_restore(uint32 offset, int x, Line 2136  ui_desktop_restore(uint32 offset, int x,
2136          XImage *image;          XImage *image;
2137          uint8 *data;          uint8 *data;
2138    
2139          offset *= bpp / 8;          offset *= g_bpp / 8;
2140          data = cache_get_desktop(offset, cx, cy, bpp / 8);          data = cache_get_desktop(offset, cx, cy, g_bpp / 8);
2141          if (data == NULL)          if (data == NULL)
2142                  return;                  return;
2143    
2144          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
2145                               0, data, cx, cy, BitmapPad(display),                               (char *) data, cx, cy, BitmapPad(g_display), cx * g_bpp / 8);
                              cx * bpp / 8);  
2146    
2147          if (ownbackstore)          if (g_ownbackstore)
2148          {          {
2149                  XPutImage(display, backstore, gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
2150                  XCopyArea(display, backstore, wnd, gc, x, y, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
2151          }          }
2152          else          else
2153          {          {
2154                  XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
2155          }          }
2156    
2157          XFree(image);          XFree(image);
Legend:
Removed from v.64  
changed lines
  Added in v.708
  ViewVC Help
Powered by ViewVC 1.1.26