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