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