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

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

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

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