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