/[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 59 by jsorg71, Sun Jul 14 04:20:25 2002 UTC revision 435 by astrand, Wed Jul 9 09:18:20 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    
 extern char keymapname[16];  
 extern int keylayout;  
28  extern int width;  extern int width;
29  extern int height;  extern int height;
30  extern BOOL sendmotion;  extern BOOL sendmotion;
31  extern BOOL fullscreen;  extern BOOL fullscreen;
32    extern BOOL grab_keyboard;
33    extern BOOL hide_decorations;
34    extern char title[];
35    extern int server_bpp;
36    extern int win_button_size;
37    BOOL enable_compose = False;
38    BOOL focused;
39    BOOL mouse_in_wnd;
40    
41  Display *display;  Display *display;
42  XkbDescPtr xkb;  Time last_gesturetime;
43  static int x_socket;  static int x_socket;
44  static Window wnd;  static Screen *screen;
45    Window wnd;
46  static GC gc;  static GC gc;
47  static Visual *visual;  static Visual *visual;
48  static int depth;  static int depth;
49  static int bpp;  static int bpp;
50    static XIM IM;
51    static XIC IC;
52    static XModifierKeymap *mod_map;
53    static Cursor current_cursor;
54    static Atom protocol_atom, kill_atom;
55    
56  /* endianness */  /* endianness */
57  static BOOL host_be;  static BOOL host_be;
# Line 49  static BOOL xserver_be; Line 61  static BOOL xserver_be;
61  static BOOL ownbackstore;  static BOOL ownbackstore;
62  static Pixmap backstore;  static Pixmap backstore;
63    
64  /* needed to keep track of the modifiers */  /* Moving in single app mode */
65  static unsigned int numlock_modifier_mask = 0;  static BOOL moving_wnd;
66  static unsigned int key_down_state = 0;  static int move_x_offset = 0;
67    static int move_y_offset = 0;
68    
69  #define DShift1Mask   (1<<0)  /* MWM decorations */
70  #define DLockMask     (1<<1)  #define MWM_HINTS_DECORATIONS   (1L << 1)
71  #define DControl1Mask (1<<2)  #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
72  #define DMod1Mask     (1<<3)  typedef struct
73  #define DMod2Mask     (1<<4)  {
74  #define DMod3Mask     (1<<5)          uint32 flags;
75  #define DMod4Mask     (1<<6)          uint32 functions;
76  #define DMod5Mask     (1<<7)          uint32 decorations;
77  #define DShift2Mask   (1<<8)          sint32 inputMode;
78  #define DControl2Mask (1<<9)          uint32 status;
79  #define DNumLockMask  (1<<10)  }
80    PropMotifWmHints;
81    
82    typedef struct
83    {
84            uint32 red;
85            uint32 green;
86            uint32 blue;
87    }
88    PixelColour;
89    
90    
91  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
92  { \  { \
# Line 73  static unsigned int key_down_state = 0; Line 95  static unsigned int key_down_state = 0;
95                  XFillRectangle(display, backstore, gc, x, y, cx, cy); \                  XFillRectangle(display, backstore, gc, x, y, cx, cy); \
96  }  }
97    
98    #define FILL_RECTANGLE_BACKSTORE(x,y,cx,cy)\
99    { \
100            XFillRectangle(display, ownbackstore ? backstore : wnd, gc, x, y, cx, cy); \
101    }
102    
103  /* colour maps */  /* colour maps */
104  static BOOL owncolmap;  BOOL owncolmap = False;
105  static Colormap xcolmap;  static Colormap xcolmap;
 static uint32 white;  
106  static uint32 *colmap;  static uint32 *colmap;
107    
108  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define TRANSLATE(col)          ( server_bpp != 8 ? translate_colour(col) : owncolmap ? col : translate_colour(colmap[col]) )
109  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));
110  #define SET_BACKGROUND(col)     XSetBackground(display, gc, TRANSLATE(col));  #define SET_BACKGROUND(col)     XSetBackground(display, gc, TRANSLATE(col));
111    
# Line 105  static int rop2_map[] = { Line 131  static int rop2_map[] = {
131  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }
132  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
133    
134  void xwin_get_numlock_mask();  static void
135  void xwin_mod_update(uint32 state, uint32 ev_time );  mwm_hide_decorations(void)
136  void xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode);  {
137  void xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode);          PropMotifWmHints motif_hints;
138            Atom hintsatom;
139    
140            /* setup the property */
141            motif_hints.flags = MWM_HINTS_DECORATIONS;
142            motif_hints.decorations = 0;
143    
144            /* get the atom for the property */
145            hintsatom = XInternAtom(display, "_MOTIF_WM_HINTS", False);
146            if (!hintsatom)
147            {
148                    warning("Failed to get atom _MOTIF_WM_HINTS: probably your window manager does not support MWM hints\n");
149                    return;
150            }
151    
152            XChangeProperty(display, wnd, hintsatom, hintsatom, 32, PropModeReplace,
153                            (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
154    }
155    
156    static PixelColour
157    split_colour15(uint32 colour)
158    {
159            PixelColour rv;
160            rv.red = (colour & 0x7c00) >> 10;
161            rv.red = (rv.red * 0xff) / 0x1f;
162            rv.green = (colour & 0x03e0) >> 5;
163            rv.green = (rv.green * 0xff) / 0x1f;
164            rv.blue = (colour & 0x1f);
165            rv.blue = (rv.blue * 0xff) / 0x1f;
166            return rv;
167    }
168    
169    static PixelColour
170    split_colour16(uint32 colour)
171    {
172            PixelColour rv;
173            rv.red = (colour & 0xf800) >> 11;
174            rv.red = (rv.red * 0xff) / 0x1f;
175            rv.green = (colour & 0x07e0) >> 5;
176            rv.green = (rv.green * 0xff) / 0x3f;
177            rv.blue = (colour & 0x001f);
178            rv.blue = (rv.blue * 0xff) / 0x1f;
179            return rv;
180    }
181    
182    static PixelColour
183    split_colour24(uint32 colour)
184    {
185            PixelColour rv;
186            rv.blue = (colour & 0xff0000) >> 16;
187            rv.green = (colour & 0xff00) >> 8;
188            rv.red = (colour & 0xff);
189            return rv;
190    }
191    
192    static uint32
193    make_colour16(PixelColour pc)
194    {
195            pc.red = (pc.red * 0x1f) / 0xff;
196            pc.green = (pc.green * 0x3f) / 0xff;
197            pc.blue = (pc.blue * 0x1f) / 0xff;
198            return (pc.red << 11) | (pc.green << 5) | pc.blue;
199    }
200    
201    static uint32
202    make_colour24(PixelColour pc)
203    {
204            return (pc.red << 16) | (pc.green << 8) | pc.blue;
205    }
206    
207    static uint32
208    make_colour32(PixelColour pc)
209    {
210            return (pc.red << 16) | (pc.green << 8) | pc.blue;
211    }
212    
213    #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
214    #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }
215    #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
216                            x = (x << 16) | (x >> 16); }
217    
218    static uint32
219    translate_colour(uint32 colour)
220    {
221            switch (server_bpp)
222            {
223                    case 15:
224                            switch (bpp)
225                            {
226                                    case 16:
227                                            colour = make_colour16(split_colour15(colour));
228                                            break;
229                                    case 24:
230                                            colour = make_colour24(split_colour15(colour));
231                                            break;
232                                    case 32:
233                                            colour = make_colour32(split_colour15(colour));
234                                            break;
235                            }
236                            break;
237                    case 16:
238                            switch (bpp)
239                            {
240                                    case 16:
241                                            break;
242                                    case 24:
243                                            colour = make_colour24(split_colour16(colour));
244                                            break;
245                                    case 32:
246                                            colour = make_colour32(split_colour16(colour));
247                                            break;
248                            }
249                            break;
250                    case 24:
251                            switch (bpp)
252                            {
253                                    case 16:
254                                            colour = make_colour16(split_colour24(colour));
255                                            break;
256                                    case 24:
257                                            break;
258                                    case 32:
259                                            colour = make_colour32(split_colour24(colour));
260                                            break;
261                            }
262                            break;
263            }
264            switch (bpp)
265            {
266                    case 16:
267                            if (host_be != xserver_be)
268                                    BSWAP16(colour);
269                            break;
270    
271                    case 24:
272                            if (xserver_be)
273                                    BSWAP24(colour);
274                            break;
275    
276                    case 32:
277                            if (host_be != xserver_be)
278                                    BSWAP32(colour);
279                            break;
280            }
281    
282            return colour;
283    }
284    
285  static void  static void
286  translate8(uint8 *data, uint8 *out, uint8 *end)  translate8to8(uint8 * data, uint8 * out, uint8 * end)
287  {  {
288          while (out < end)          while (out < end)
289                  *(out++) = (uint8)colmap[*(data++)];                  *(out++) = (uint8) colmap[*(data++)];
290  }  }
291    
292  static void  static void
293  translate16(uint8 *data, uint16 *out, uint16 *end)  translate8to16(uint8 * data, uint16 * out, uint16 * end)
294  {  {
295          while (out < end)          while (out < end)
296                  *(out++) = (uint16)colmap[*(data++)];                  *(out++) = (uint16) colmap[*(data++)];
297  }  }
298    
299  /* little endian - conversion happens when colourmap is built */  /* little endian - conversion happens when colourmap is built */
300  static void  static void
301  translate24(uint8 *data, uint8 *out, uint8 *end)  translate8to24(uint8 * data, uint8 * out, uint8 * end)
302  {  {
303          uint32 value;          uint32 value;
304    
# Line 140  translate24(uint8 *data, uint8 *out, uin Line 312  translate24(uint8 *data, uint8 *out, uin
312  }  }
313    
314  static void  static void
315  translate32(uint8 *data, uint32 *out, uint32 *end)  translate8to32(uint8 * data, uint32 * out, uint32 * end)
316  {  {
317          while (out < end)          while (out < end)
318                  *(out++) = colmap[*(data++)];                  *(out++) = colmap[*(data++)];
319  }  }
320    
321  static uint8 *  /* todo the remaining translate function might need some big endian check ?? */
 translate_image(int width, int height, uint8 *data)  
 {  
         int size = width * height * bpp/8;  
         uint8 *out = xmalloc(size);  
         uint8 *end = out + size;  
   
         switch (bpp)  
         {  
                 case 8:  
                         translate8(data, out, end);  
                         break;  
322    
323                  case 16:  static void
324                          translate16(data, (uint16 *)out, (uint16 *)end);  translate15to16(uint16 * data, uint16 * out, uint16 * end)
325                          break;  {
326            while (out < end)
327                    *(out++) = (uint16) make_colour16(split_colour15(*(data++)));
328    }
329    
330                  case 24:  static void
331                          translate24(data, out, end);  translate15to24(uint16 * data, uint8 * out, uint8 * end)
332                          break;  {
333            uint32 value;
334    
335                  case 32:          while (out < end)
336                          translate32(data, (uint32 *)out, (uint32 *)end);          {
337                          break;                  value = make_colour24(split_colour15(*(data++)));
338                    *(out++) = value;
339                    *(out++) = value >> 8;
340                    *(out++) = value >> 16;
341          }          }
342    }
343    
344          return out;  static void
345    translate15to32(uint16 * data, uint32 * out, uint32 * end)
346    {
347            while (out < end)
348                    *(out++) = make_colour32(split_colour15(*(data++)));
349  }  }
350    
351  #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }  static void
352  #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }  translate16to16(uint16 * data, uint16 * out, uint16 * end)
353  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \  {
354                          x = (x << 16) | (x >> 16); }          while (out < end)
355                    *(out++) = (uint16) (*(data++));
356    }
357    
358  static uint32  
359  translate_colour(uint32 colour)  static void
360    translate16to24(uint16 * data, uint8 * out, uint8 * end)
361  {  {
362          switch (bpp)          uint32 value;
363    
364            while (out < end)
365          {          {
366                  case 16:                  value = make_colour24(split_colour16(*(data++)));
367                          if (host_be != xserver_be)                  *(out++) = value;
368                                  BSWAP16(colour);                  *(out++) = value >> 8;
369                          break;                  *(out++) = value >> 16;
370            }
371    }
372    
373                  case 24:  static void
374                          if (xserver_be)  translate16to32(uint16 * data, uint32 * out, uint32 * end)
375                                  BSWAP24(colour);  {
376                          break;          while (out < end)
377                    *(out++) = make_colour32(split_colour16(*(data++)));
378    }
379    
380                  case 32:  static void
381                          if (host_be != xserver_be)  translate24to16(uint8 * data, uint16 * out, uint16 * end)
382                                  BSWAP32(colour);  {
383                          break;          uint32 pixel = 0;
384            while (out < end)
385            {
386                    pixel = *(data++) << 16;
387                    pixel |= *(data++) << 8;
388                    pixel |= *(data++);
389                    *(out++) = (uint16) make_colour16(split_colour24(pixel));
390          }          }
391    }
392    
393          return colour;  static void
394    translate24to24(uint8 * data, uint8 * out, uint8 * end)
395    {
396            while (out < end)
397            {
398                    *(out++) = (*(data++));
399            }
400  }  }
401    
402  BOOL  static void
403  ui_create_window(char *title)  translate24to32(uint8 * data, uint32 * out, uint32 * end)
404  {  {
405          XSetWindowAttributes attribs;          uint32 pixel = 0;
406          XClassHint *classhints;          while (out < end)
         XSizeHints *sizehints;  
         unsigned long input_mask;  
         XPixmapFormatValues *pfm;  
         Screen *screen;  
         uint16 test;  
         int i;  
           
         int xkb_minor, xkb_major;  
         int xkb_event, xkb_error, xkb_reason;  
   
         /* compare compiletime libs with runtime libs. */  
         xkb_major = XkbMajorVersion;  
         xkb_minor = XkbMinorVersion;  
         if( XkbLibraryVersion( &xkb_major, &xkb_minor ) == False )  
407          {          {
408                  error("please re-compile rdesktop\ncompile time version of xkb is not compatible with\nyour runtime version of the library\n");                  pixel = *(data++);
409                  return False;                  pixel |= *(data++) << 8;
410                    pixel |= *(data++) << 16;
411                    *(out++) = pixel;
412          }          }
413    }
414    
415    static uint8 *
416    translate_image(int width, int height, uint8 * data)
417    {
418            int size = width * height * bpp / 8;
419            uint8 *out = (uint8 *) xmalloc(size);
420            uint8 *end = out + size;
421    
422          display = XkbOpenDisplay( NULL, &xkb_event, &xkb_error, &xkb_major, &xkb_minor, &xkb_reason );          switch (server_bpp)
         switch(xkb_reason)  
423          {          {
424                  case XkbOD_BadLibraryVersion:                  case 24:
425                          error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");                          switch (bpp)
426                          break;                          {
427                  case XkbOD_ConnectionRefused:                                  case 32:
428                          error("XkbOD_ConnectionRefused\n");                                          translate24to32(data, (uint32 *) out, (uint32 *) end);
429                                            break;
430                                    case 24:
431                                            translate24to24(data, out, end);
432                                            break;
433                                    case 16:
434                                            translate24to16(data, (uint16 *) out, (uint16 *) end);
435                                            break;
436                            }
437                          break;                          break;
438                  case XkbOD_BadServerVersion:                  case 16:
439                          error("XkbOD_BadServerVersion\n");                          switch (bpp)
440                            {
441                                    case 32:
442                                            translate16to32((uint16 *) data, (uint32 *) out,
443                                                            (uint32 *) end);
444                                            break;
445                                    case 24:
446                                            translate16to24((uint16 *) data, out, end);
447                                            break;
448                                    case 16:
449                                            translate16to16((uint16 *) data, (uint16 *) out,
450                                                            (uint16 *) end);
451                                            break;
452                            }
453                          break;                          break;
454                  case XkbOD_NonXkbServer:                  case 15:
455                          error("XkbOD_NonXkbServer: XKB extension not present in server\nupdate your X server.\n");                          switch (bpp)
456                            {
457                                    case 32:
458                                            translate15to32((uint16 *) data, (uint32 *) out,
459                                                            (uint32 *) end);
460                                            break;
461                                    case 24:
462                                            translate15to24((uint16 *) data, out, end);
463                                            break;
464                                    case 16:
465                                            translate15to16((uint16 *) data, (uint16 *) out,
466                                                            (uint16 *) end);
467                                            break;
468                            }
469                          break;                          break;
470                  case XkbOD_Success:                  case 8:
471                          DEBUG("XkbOD_Success: Connection established with display\n");                          switch (bpp)
472                            {
473                                    case 8:
474                                            translate8to8(data, out, end);
475                                            break;
476                                    case 16:
477                                            translate8to16(data, (uint16 *) out, (uint16 *) end);
478                                            break;
479                                    case 24:
480                                            translate8to24(data, out, end);
481                                            break;
482                                    case 32:
483                                            translate8to32(data, (uint32 *) out, (uint32 *) end);
484                                            break;
485                            }
486                          break;                          break;
487          }          }
488            return out;
489    }
490    
491    BOOL
492    get_key_state(unsigned int state, uint32 keysym)
493    {
494            int modifierpos, key, keysymMask = 0;
495            int offset;
496    
497            KeyCode keycode = XKeysymToKeycode(display, keysym);
498    
499            if (keycode == NoSymbol)
500                    return False;
501    
502            for (modifierpos = 0; modifierpos < 8; modifierpos++)
503            {
504                    offset = mod_map->max_keypermod * modifierpos;
505    
506                    for (key = 0; key < mod_map->max_keypermod; key++)
507                    {
508                            if (mod_map->modifiermap[offset + key] == keycode)
509                                    keysymMask |= 1 << modifierpos;
510                    }
511            }
512    
513            return (state & keysymMask) ? True : False;
514    }
515    
516    BOOL
517    ui_init(void)
518    {
519            XPixmapFormatValues *pfm;
520            uint16 test;
521            int i;
522    
523            display = XOpenDisplay(NULL);
524          if (display == NULL)          if (display == NULL)
525          {          {
526                  error("Failed to open display\n");                  error("Failed to open display: %s\n", XDisplayName(NULL));
527                  return False;                  return False;
528          }          }
529    
# Line 259  ui_create_window(char *title) Line 531  ui_create_window(char *title)
531          screen = DefaultScreenOfDisplay(display);          screen = DefaultScreenOfDisplay(display);
532          visual = DefaultVisualOfScreen(screen);          visual = DefaultVisualOfScreen(screen);
533          depth = DefaultDepthOfScreen(screen);          depth = DefaultDepthOfScreen(screen);
534            
535          pfm = XListPixmapFormats(display, &i);          pfm = XListPixmapFormats(display, &i);
536          if (pfm != NULL)          if (pfm != NULL)
537          {          {
# Line 267  ui_create_window(char *title) Line 539  ui_create_window(char *title)
539                     desirable, e.g. 24 bits->32 bits. */                     desirable, e.g. 24 bits->32 bits. */
540                  while (i--)                  while (i--)
541                  {                  {
542                          if ((pfm[i].depth == depth)                          if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
                             && (pfm[i].bits_per_pixel > bpp))  
543                          {                          {
544                                  bpp = pfm[i].bits_per_pixel;                                  bpp = pfm[i].bits_per_pixel;
545                          }                          }
# Line 283  ui_create_window(char *title) Line 554  ui_create_window(char *title)
554                  return False;                  return False;
555          }          }
556    
557          if (depth <= 8)          if (owncolmap != True)
558                  owncolmap = True;          {
         else  
559                  xcolmap = DefaultColormapOfScreen(screen);                  xcolmap = DefaultColormapOfScreen(screen);
560                    if (depth <= 8)
561                            warning("Screen depth is 8 bits or lower: you may want to use -C for a private colourmap\n");
562            }
563    
564            gc = XCreateGC(display, RootWindowOfScreen(screen), 0, NULL);
565    
566            if (DoesBackingStore(screen) != Always)
567                    ownbackstore = True;
568    
569          test = 1;          test = 1;
570          host_be = !(BOOL)(*(uint8 *)(&test));          host_be = !(BOOL) (*(uint8 *) (&test));
571          xserver_be = (ImageByteOrder(display) == MSBFirst);          xserver_be = (ImageByteOrder(display) == MSBFirst);
572    
573          white = WhitePixelOfScreen(screen);          if ((width == 0) || (height == 0))
574          attribs.background_pixel = BlackPixelOfScreen(screen);          {
575          attribs.backing_store = DoesBackingStore(screen);                  /* Fetch geometry from _NET_WORKAREA */
576                    uint32 x, y, cx, cy;
577    
578          if (attribs.backing_store == NotUseful)                  if (get_current_workarea(&x, &y, &cx, &cy) == 0)
579                  ownbackstore = True;                  {
580                            width = cx;
581                            height = cy;
582                    }
583                    else
584                    {
585                            warning("Failed to get workarea: probably your window manager does not support extended hints\n");
586                            width = 800;
587                            height = 600;
588                    }
589            }
590    
591          if (fullscreen)          if (fullscreen)
592          {          {
                 attribs.override_redirect = True;  
593                  width = WidthOfScreen(screen);                  width = WidthOfScreen(screen);
594                  height = HeightOfScreen(screen);                  height = HeightOfScreen(screen);
595          }          }
596          else  
597            /* make sure width is a multiple of 4 */
598            width = (width + 3) & ~3;
599    
600            if (ownbackstore)
601          {          {
602                  attribs.override_redirect = False;                  backstore =
603                            XCreatePixmap(display, RootWindowOfScreen(screen), width, height, depth);
604    
605                    /* clear to prevent rubbish being exposed at startup */
606                    XSetForeground(display, gc, BlackPixelOfScreen(screen));
607                    XFillRectangle(display, backstore, gc, 0, 0, width, height);
608          }          }
609    
610          width = (width + 3) & ~3; /* make width a multiple of 32 bits */          mod_map = XGetModifierMapping(display);
611    
612            if (enable_compose)
613                    IM = XOpenIM(display, NULL, NULL, NULL);
614    
615            xkeymap_init();
616            xclip_init();
617    
618            /* todo take this out when high colour is done */
619            printf("server bpp %d client bpp %d depth %d\n", server_bpp, bpp, depth);
620    
621            return True;
622    }
623    
624    void
625    ui_deinit(void)
626    {
627            if (IM != NULL)
628                    XCloseIM(IM);
629    
630            XFreeModifiermap(mod_map);
631    
632            if (ownbackstore)
633                    XFreePixmap(display, backstore);
634    
635            XFreeGC(display, gc);
636            XCloseDisplay(display);
637            display = NULL;
638    }
639    
640    BOOL
641    ui_create_window(void)
642    {
643            XSetWindowAttributes attribs;
644            XClassHint *classhints;
645            XSizeHints *sizehints;
646            int wndwidth, wndheight;
647            long input_mask, ic_input_mask;
648            XEvent xevent;
649    
650          wnd = XCreateWindow(display, RootWindowOfScreen(screen),          wndwidth = fullscreen ? WidthOfScreen(screen) : width;
651                              0, 0, width, height, 0, CopyFromParent,          wndheight = fullscreen ? HeightOfScreen(screen) : height;
652                              InputOutput, CopyFromParent,  
653                              CWBackingStore | CWBackPixel | CWOverrideRedirect,          attribs.background_pixel = BlackPixelOfScreen(screen);
654                              &attribs);          attribs.backing_store = ownbackstore ? NotUseful : Always;
655            attribs.override_redirect = fullscreen;
656    
657            wnd = XCreateWindow(display, RootWindowOfScreen(screen), 0, 0, wndwidth, wndheight,
658                                0, CopyFromParent, InputOutput, CopyFromParent,
659                                CWBackPixel | CWBackingStore | CWOverrideRedirect, &attribs);
660    
661          XStoreName(display, wnd, title);          XStoreName(display, wnd, title);
662    
663            if (hide_decorations)
664                    mwm_hide_decorations();
665    
666          classhints = XAllocClassHint();          classhints = XAllocClassHint();
667          if (classhints != NULL)          if (classhints != NULL)
668          {          {
# Line 338  ui_create_window(char *title) Line 681  ui_create_window(char *title)
681                  XFree(sizehints);                  XFree(sizehints);
682          }          }
683    
684          xkeymap_init();          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
685                    VisibilityChangeMask | FocusChangeMask;
686    
         input_mask = KeyPressMask | KeyReleaseMask |  
                          ButtonPressMask | ButtonReleaseMask |  
                          EnterWindowMask | LeaveWindowMask;  
687          if (sendmotion)          if (sendmotion)
688                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
   
689          if (ownbackstore)          if (ownbackstore)
690                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
691            if (fullscreen || grab_keyboard)
692                    input_mask |= EnterWindowMask;
693            if (grab_keyboard)
694                    input_mask |= LeaveWindowMask;
695    
696            if (IM != NULL)
697            {
698                    IC = XCreateIC(IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
699                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
700    
701                    if ((IC != NULL)
702                        && (XGetICValues(IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
703                            input_mask |= ic_input_mask;
704            }
705    
706          XSelectInput(display, wnd, input_mask);          XSelectInput(display, wnd, input_mask);
         gc = XCreateGC(display, wnd, 0, NULL);  
   
         if (ownbackstore)  
                 backstore = XCreatePixmap(display, wnd, width, height, depth);  
   
707          XMapWindow(display, wnd);          XMapWindow(display, wnd);
708    
709          /* TODO: error texts... make them friendly. */          /* wait for VisibilityNotify */
710          xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);          do
         if ((int)xkb == BadAlloc || xkb == NULL)  
         {  
                         error( "XkbGetKeyboard failed.\n");  
                         exit(0);  
         }  
   
         /* TODO: error texts... make them friendly. */  
         if( XkbSelectEvents(display, xkb->device_spec, XkbAllEventsMask, XkbAllEventsMask) == False )  
711          {          {
712                          error( "XkbSelectEvents failed.\n");                  XMaskEvent(display, VisibilityChangeMask, &xevent);
                         exit(0);  
713          }          }
714                    while (xevent.type != VisibilityNotify);
715          xwin_get_numlock_mask();  
716            focused = False;
717            mouse_in_wnd = False;
718    
719            /* handle the WM_DELETE_WINDOW protocol */
720            protocol_atom = XInternAtom(display, "WM_PROTOCOLS", True);
721            kill_atom = XInternAtom(display, "WM_DELETE_WINDOW", True);
722            XSetWMProtocols(display, wnd, &kill_atom, 1);
723    
724          return True;          return True;
725  }  }
726    
727  void  void
728  xwin_get_numlock_mask()  ui_destroy_window(void)
729  {  {
730          KeyCode numlockcode;          if (IC != NULL)
731          KeyCode* keycode;                  XDestroyIC(IC);
         XModifierKeymap *modmap;  
         int i,j;  
   
         /* Find out if numlock is already defined as a modifier key, and if so where */  
         numlockcode = XKeysymToKeycode(display, 0xFF7F);        /* XF_Num_Lock = 0xFF7F */  
         if (numlockcode) {  
                 modmap = XGetModifierMapping(display);  
                 if (modmap) {  
                         keycode = modmap->modifiermap;  
                         for (i = 0; i < 8; i++)  
                                 for (j = modmap->max_keypermod; j--;) {  
                                         if (*keycode == numlockcode) {  
                                                 numlock_modifier_mask = (1 << i);  
                                                 i = 8;  
                                                 break;  
                                         }  
                                         keycode++;  
                                 }  
                 if (!numlock_modifier_mask) {  
                                 modmap->modifiermap[7 * modmap->max_keypermod] = numlockcode;  
                                 if (XSetModifierMapping(display, modmap) == MappingSuccess)  
                                         numlock_modifier_mask = (1 << 7);  
                                 else  
                                         printf("XSetModifierMapping failed!\n");  
                         }  
                         XFreeModifiermap(modmap);  
                 }  
         }  
732    
733          if (!numlock_modifier_mask)          XDestroyWindow(display, wnd);
                 printf("WARNING: Failed to get a numlock modifier mapping.\n");  
                   
734  }  }
735    
736  void  void
737  ui_destroy_window()  xwin_toggle_fullscreen(void)
738  {  {
739          if( xkb != NULL )          Pixmap contents = 0;
                 XkbFreeKeyboard(xkb, XkbAllControlsMask, True);  
740    
741          if (ownbackstore)          if (!ownbackstore)
742                  XFreePixmap(display, backstore);          {
743                    /* need to save contents of window */
744                    contents = XCreatePixmap(display, wnd, width, height, depth);
745                    XCopyArea(display, wnd, contents, gc, 0, 0, width, height, 0, 0);
746            }
747    
748          XFreeGC(display, gc);          ui_destroy_window();
749          XDestroyWindow(display, wnd);          fullscreen = !fullscreen;
750          XCloseDisplay(display);          ui_create_window();
751          display = NULL;  
752            XDefineCursor(display, wnd, current_cursor);
753    
754            if (!ownbackstore)
755            {
756                    XCopyArea(display, contents, wnd, gc, 0, 0, width, height, 0, 0);
757                    XFreePixmap(display, contents);
758            }
759  }  }
760    
761  static void  /* Process all events in Xlib queue
762  xwin_process_events()     Returns 0 after user quit, 1 otherwise */
763    static int
764    xwin_process_events(void)
765  {  {
766          XEvent xevent;          XEvent xevent;
   
767          KeySym keysym;          KeySym keysym;
         uint8 scancode;  
768          uint16 button, flags;          uint16 button, flags;
769          uint32 ev_time;          uint32 ev_time;
770          uint32 tmpmods;          key_translation tr;
771            char str[256];
772            Status status;
773            unsigned int state;
774            Window wdummy;
775            int dummy;
776    
777          while (XCheckMaskEvent(display, ~0, &xevent))          while (XPending(display) > 0)
778          {          {
779                  ev_time = time(NULL);                  XNextEvent(display, &xevent);
780    
781                    if ((IC != NULL) && (XFilterEvent(&xevent, None) == True))
782                    {
783                            DEBUG_KBD(("Filtering event\n"));
784                            continue;
785                    }
786    
787                  flags = 0;                  flags = 0;
788    
789                  switch (xevent.type)                  switch (xevent.type)
790                  {                  {
791                          case KeyRelease:                          case ClientMessage:
792                                  flags = KBD_FLAG_DOWN | KBD_FLAG_UP;                                  /* the window manager told us to quit */
793                                  /* fall through */                                  if ((xevent.xclient.message_type == protocol_atom)
794                                        && ((Atom) xevent.xclient.data.l[0] == kill_atom))
795                                            /* Quit */
796                                            return 0;
797                                    break;
798    
799                          case KeyPress:                          case KeyPress:
800                                  if( XkbTranslateKeyCode(xkb, xevent.xkey.keycode, xevent.xkey.state, &tmpmods, &keysym) == False )                                  last_gesturetime = xevent.xkey.time;
801                                    if (IC != NULL)
802                                            /* Multi_key compatible version */
803                                    {
804                                            XmbLookupString(IC,
805                                                            &xevent.xkey, str, sizeof(str), &keysym,
806                                                            &status);
807                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
808                                            {
809                                                    error("XmbLookupString failed with status 0x%x\n",
810                                                          status);
811                                                    break;
812                                            }
813                                    }
814                                    else
815                                    {
816                                            /* Plain old XLookupString */
817                                            DEBUG_KBD(("\nNo input context, using XLookupString\n"));
818                                            XLookupString((XKeyEvent *) & xevent,
819                                                          str, sizeof(str), &keysym, NULL);
820                                    }
821    
822                                    DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym,
823                                               get_ksname(keysym)));
824    
825                                    ev_time = time(NULL);
826                                    if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
827                                          break;                                          break;
                                 scancode = xkeymap_translate_key(keysym, xevent.xkey.keycode, &flags);  
828    
829                                  if (scancode == 0 )                                  tr = xkeymap_translate_key(keysym,
830                                                               xevent.xkey.keycode, xevent.xkey.state);
831    
832                                    if (tr.scancode == 0)
833                                          break;                                          break;
834    
835                                  /* keep track of the modifiers -- needed for stickykeys... */                                  ensure_remote_modifiers(ev_time, tr);
836                                  if( xevent.type == KeyPress )  
837                                          xwin_mod_press( xevent.xkey.state, ev_time, scancode );                                  rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
838                                    break;
839    
840                            case KeyRelease:
841                                    last_gesturetime = xevent.xkey.time;
842                                    XLookupString((XKeyEvent *) & xevent, str,
843                                                  sizeof(str), &keysym, NULL);
844    
845                                    DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
846                                               get_ksname(keysym)));
847    
848                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, flags, scancode, 0);                                  ev_time = time(NULL);
849                                    if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
850                                            break;
851    
852                                    tr = xkeymap_translate_key(keysym,
853                                                               xevent.xkey.keycode, xevent.xkey.state);
854    
855                                  if( xevent.type == KeyRelease )                                  if (tr.scancode == 0)
856                                          xwin_mod_release( xevent.xkey.state, ev_time, scancode );                                          break;
857    
858                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
859                                  break;                                  break;
860    
861                          case ButtonPress:                          case ButtonPress:
# Line 476  xwin_process_events() Line 863  xwin_process_events()
863                                  /* fall through */                                  /* fall through */
864    
865                          case ButtonRelease:                          case ButtonRelease:
866                                    last_gesturetime = xevent.xbutton.time;
867                                  button = xkeymap_translate_button(xevent.xbutton.button);                                  button = xkeymap_translate_button(xevent.xbutton.button);
868                                  if (button == 0)                                  if (button == 0)
869                                          break;                                          break;
870    
871                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  /* If win_button_size is nonzero, enable single app mode */
872                                                 flags | button,                                  if (xevent.xbutton.y < win_button_size)
873                                                 xevent.xbutton.x,                                  {
874                                                 xevent.xbutton.y);                                          /* Stop moving window when button is released, regardless of cursor position */
875                                            if (moving_wnd && (xevent.type == ButtonRelease))
876                                                    moving_wnd = False;
877    
878                                            /*  Check from right to left: */
879    
880                                            if (xevent.xbutton.x >= width - win_button_size)
881                                            {
882                                                    /* The close button, continue */
883                                                    ;
884                                            }
885                                            else if (xevent.xbutton.x >= width - win_button_size * 2)
886                                            {
887                                                    /* The maximize/restore button. Do not send to
888                                                       server.  It might be a good idea to change the
889                                                       cursor or give some other visible indication
890                                                       that rdesktop inhibited this click */
891                                                    break;
892                                            }
893                                            else if (xevent.xbutton.x >= width - win_button_size * 3)
894                                            {
895                                                    /* The minimize button. Iconify window. */
896                                                    XIconifyWindow(display, wnd,
897                                                                   DefaultScreen(display));
898                                                    break;
899                                            }
900                                            else if (xevent.xbutton.x <= win_button_size)
901                                            {
902                                                    /* The system menu. Ignore. */
903                                                    break;
904                                            }
905                                            else
906                                            {
907                                                    /* The title bar. */
908                                                    if ((xevent.type == ButtonPress) && !fullscreen
909                                                        && hide_decorations)
910                                                    {
911                                                            moving_wnd = True;
912                                                            move_x_offset = xevent.xbutton.x;
913                                                            move_y_offset = xevent.xbutton.y;
914                                                    }
915                                                    break;
916    
917                                            }
918                                    }
919    
920                                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
921                                                   flags | button, xevent.xbutton.x, xevent.xbutton.y);
922                                  break;                                  break;
923    
924                          case MotionNotify:                          case MotionNotify:
925                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  if (moving_wnd)
926                                                 MOUSE_FLAG_MOVE,                                  {
927                                                 xevent.xmotion.x,                                          XMoveWindow(display, wnd,
928                                                 xevent.xmotion.y);                                                      xevent.xmotion.x_root - move_x_offset,
929                                                        xevent.xmotion.y_root - move_y_offset);
930                                            break;
931                                    }
932    
933                                    if (fullscreen && !focused)
934                                            XSetInputFocus(display, wnd, RevertToPointerRoot,
935                                                           CurrentTime);
936                                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
937                                                   MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
938                                  break;                                  break;
939    
940                          case EnterNotify:                          case FocusIn:
941                                  XGrabKeyboard(display, wnd, True, GrabModeAsync,                                  if (xevent.xfocus.mode == NotifyGrab)
942                                                GrabModeAsync, CurrentTime);                                          break;
943                                    focused = True;
944                                    XQueryPointer(display, wnd, &wdummy, &wdummy, &dummy, &dummy,
945                                                  &dummy, &dummy, &state);
946                                    reset_modifier_keys(state);
947                                    if (grab_keyboard && mouse_in_wnd)
948                                            XGrabKeyboard(display, wnd, True,
949                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
950                                    break;
951    
952                            case FocusOut:
953                                    if (xevent.xfocus.mode == NotifyUngrab)
954                                            break;
955                                    focused = False;
956                                    if (xevent.xfocus.mode == NotifyWhileGrabbed)
957                                            XUngrabKeyboard(display, CurrentTime);
958                                    break;
959    
960                                   xwin_mod_update( xevent.xcrossing.state, ev_time );                          case EnterNotify:
961                                    /* we only register for this event when in fullscreen mode */
962                                    /* or grab_keyboard */
963                                    mouse_in_wnd = True;
964                                    if (fullscreen)
965                                    {
966                                            XSetInputFocus(display, wnd, RevertToPointerRoot,
967                                                           CurrentTime);
968                                            break;
969                                    }
970                                    if (focused)
971                                            XGrabKeyboard(display, wnd, True,
972                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
973                                  break;                                  break;
974    
975                          case LeaveNotify:                          case LeaveNotify:
976                                    /* we only register for this event when grab_keyboard */
977                                    mouse_in_wnd = False;
978                                  XUngrabKeyboard(display, CurrentTime);                                  XUngrabKeyboard(display, CurrentTime);
979                                  break;                                  break;
980    
981                          case Expose:                          case Expose:
982                                  XCopyArea(display, backstore, wnd, gc,                                  XCopyArea(display, backstore, wnd, gc,
983                                            xevent.xexpose.x, xevent.xexpose.y,                                            xevent.xexpose.x, xevent.xexpose.y,
984                                            xevent.xexpose.width, xevent.xexpose.height,                                            xevent.xexpose.width,
985                                              xevent.xexpose.height,
986                                            xevent.xexpose.x, xevent.xexpose.y);                                            xevent.xexpose.x, xevent.xexpose.y);
987                                  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;  
   
         }  
988    
989                            case MappingNotify:
990                                    /* Refresh keyboard mapping if it has changed. This is important for
991                                       Xvnc, since it allocates keycodes dynamically */
992                                    if (xevent.xmapping.request == MappingKeyboard
993                                        || xevent.xmapping.request == MappingModifier)
994                                            XRefreshKeyboardMapping(&xevent.xmapping);
995    
996          if( !(ShiftMask & state) && (key_down_state & DShift1Mask))                                  if (xevent.xmapping.request == MappingModifier)
997          {                                  {
998                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x2a, 0);                                          XFreeModifiermap(mod_map);
999                  key_down_state &= ~DShift1Mask;                                          mod_map = XGetModifierMapping(display);
1000                                    }
1001          }                                  break;
   
         if( !(ControlMask & state) && (key_down_state & DControl1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x1d, 0);  
                 key_down_state &= ~DControl1Mask;  
   
         }  
   
         if( !(Mod1Mask & state) && (key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x38, 0);  
                 key_down_state &= ~DMod1Mask;  
   
         }  
   
         if( !(Mod2Mask & state) && (key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0xb8, 0);  
                 key_down_state &= ~DMod2Mask;  
         }  
 }  
   
   
 void  
 xwin_mod_press(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 0x3a:  
                 key_down_state ^= DLockMask;  
                 break;  
         case 0x45:  
                 key_down_state ^= DNumLockMask;  
                 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;  
   
         }  
   
   
         if( (ShiftMask & state) && !((key_down_state & DShift1Mask) || (key_down_state & DShift2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x2a, 0);  
                 key_down_state |= DShift1Mask;  
   
         }  
   
         if( (ControlMask & state) && !((key_down_state & DControl1Mask) || (key_down_state & DControl2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x1d, 0);  
                 key_down_state |= DControl1Mask;  
   
         }  
   
         if( (Mod1Mask & state) && !(key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x38, 0);  
                 key_down_state |= DMod1Mask;  
   
         }  
   
         if( (Mod2Mask & state) && !(key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0xb8, 0);  
                 key_down_state |= DMod2Mask;  
1002    
1003                                    /* clipboard stuff */
1004                            case SelectionNotify:
1005                                    xclip_handle_SelectionNotify(&xevent.xselection);
1006                                    break;
1007                            case SelectionRequest:
1008                                    xclip_handle_SelectionRequest(&xevent.xselectionrequest);
1009                                    break;
1010                            case SelectionClear:
1011                                    xclip_handle_SelectionClear();
1012                                    break;
1013                            case PropertyNotify:
1014                                    xclip_handle_PropertyNotify(&xevent.xproperty);
1015                                    break;
1016                    }
1017          }          }
1018            /* Keep going */
1019            return 1;
1020  }  }
1021    
1022  void  /* Returns 0 after user quit, 1 otherwise */
1023    int
1024  ui_select(int rdp_socket)  ui_select(int rdp_socket)
1025  {  {
1026          int n = (rdp_socket > x_socket) ? rdp_socket+1 : x_socket+1;          int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;
1027          fd_set rfds;          fd_set rfds;
1028    
1029          FD_ZERO(&rfds);          FD_ZERO(&rfds);
1030    
1031          while (True)          while (True)
1032          {          {
1033                    /* Process any events already waiting */
1034                    if (!xwin_process_events())
1035                            /* User quit */
1036                            return 0;
1037    
1038                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
1039                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
1040                  if (display != NULL)                  FD_SET(x_socket, &rfds);
                 {  
                         FD_SET(x_socket, &rfds);  
                         XFlush(display);  
                 }  
1041    
1042                  switch (select(n, &rfds, NULL, NULL, NULL))                  switch (select(n, &rfds, NULL, NULL, NULL))
1043                  {                  {
# Line 693  ui_select(int rdp_socket) Line 1048  ui_select(int rdp_socket)
1048                                  continue;                                  continue;
1049                  }                  }
1050    
                 if (FD_ISSET(x_socket, &rfds))  
                         xwin_process_events();  
   
1051                  if (FD_ISSET(rdp_socket, &rfds))                  if (FD_ISSET(rdp_socket, &rfds))
1052                          return;                          return 1;
1053          }          }
1054  }  }
1055    
# Line 708  ui_move_pointer(int x, int y) Line 1060  ui_move_pointer(int x, int y)
1060  }  }
1061    
1062  HBITMAP  HBITMAP
1063  ui_create_bitmap(int width, int height, uint8 *data)  ui_create_bitmap(int width, int height, uint8 * data)
1064  {  {
1065          XImage *image;          XImage *image;
1066          Pixmap bitmap;          Pixmap bitmap;
# Line 716  ui_create_bitmap(int width, int height, Line 1068  ui_create_bitmap(int width, int height,
1068    
1069          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
1070          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
1071          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1072                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, server_bpp == 8 ? 8 : bpp, 0);
1073    
1074          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
1075    
# Line 728  ui_create_bitmap(int width, int height, Line 1080  ui_create_bitmap(int width, int height,
1080  }  }
1081    
1082  void  void
1083  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)  
1084  {  {
1085          XImage *image;          XImage *image;
1086          uint8 *tdata;          uint8 *tdata;
   
1087          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
1088          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1089                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, server_bpp == 8 ? 8 : bpp, 0);
1090    
1091          if (ownbackstore)          if (ownbackstore)
1092          {          {
# Line 756  ui_paint_bitmap(int x, int y, int cx, in Line 1106  ui_paint_bitmap(int x, int y, int cx, in
1106  void  void
1107  ui_destroy_bitmap(HBITMAP bmp)  ui_destroy_bitmap(HBITMAP bmp)
1108  {  {
1109          XFreePixmap(display, (Pixmap)bmp);          XFreePixmap(display, (Pixmap) bmp);
1110  }  }
1111    
1112  HGLYPH  HGLYPH
1113  ui_create_glyph(int width, int height, uint8 *data)  ui_create_glyph(int width, int height, uint8 * data)
1114  {  {
1115          XImage *image;          XImage *image;
1116          Pixmap bitmap;          Pixmap bitmap;
# Line 772  ui_create_glyph(int width, int height, u Line 1122  ui_create_glyph(int width, int height, u
1122          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
1123          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
1124    
1125          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
1126                               data, width, height, 8, scanline);                               width, height, 8, scanline);
1127          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
1128          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
1129          XInitImage(image);          XInitImage(image);
# Line 782  ui_create_glyph(int width, int height, u Line 1132  ui_create_glyph(int width, int height, u
1132    
1133          XFree(image);          XFree(image);
1134          XFreeGC(display, gc);          XFreeGC(display, gc);
1135          return (HGLYPH)bitmap;          return (HGLYPH) bitmap;
1136  }  }
1137    
1138  void  void
1139  ui_destroy_glyph(HGLYPH glyph)  ui_destroy_glyph(HGLYPH glyph)
1140  {  {
1141          XFreePixmap(display, (Pixmap)glyph);          XFreePixmap(display, (Pixmap) glyph);
1142  }  }
1143    
1144  HCURSOR  HCURSOR
1145  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
1146                   int height, uint8 *andmask, uint8 *xormask)                   uint8 * andmask, uint8 * xormask)
1147  {  {
1148          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
1149          XColor bg, fg;          XColor bg, fg;
# Line 807  ui_create_cursor(unsigned int x, unsigne Line 1157  ui_create_cursor(unsigned int x, unsigne
1157          scanline = (width + 7) / 8;          scanline = (width + 7) / 8;
1158          offset = scanline * height;          offset = scanline * height;
1159    
1160          cursor = xmalloc(offset);          cursor = (uint8 *) xmalloc(offset);
1161          memset(cursor, 0, offset);          memset(cursor, 0, offset);
1162    
1163          mask = xmalloc(offset);          mask = (uint8 *) xmalloc(offset);
1164          memset(mask, 0, offset);          memset(mask, 0, offset);
1165    
1166          /* approximate AND and XOR masks with a monochrome X pointer */          /* approximate AND and XOR masks with a monochrome X pointer */
# Line 850  ui_create_cursor(unsigned int x, unsigne Line 1200  ui_create_cursor(unsigned int x, unsigne
1200    
1201          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
1202          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
1203            
1204          xcursor = XCreatePixmapCursor(display, (Pixmap)cursorglyph,          xcursor =
1205                                  (Pixmap)maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(display, (Pixmap) cursorglyph,
1206                                        (Pixmap) maskglyph, &fg, &bg, x, y);
1207    
1208          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
1209          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
1210          xfree(mask);          xfree(mask);
1211          xfree(cursor);          xfree(cursor);
1212          return (HCURSOR)xcursor;          return (HCURSOR) xcursor;
1213  }  }
1214    
1215  void  void
1216  ui_set_cursor(HCURSOR cursor)  ui_set_cursor(HCURSOR cursor)
1217  {  {
1218          XDefineCursor(display, wnd, (Cursor)cursor);          current_cursor = (Cursor) cursor;
1219            XDefineCursor(display, wnd, current_cursor);
1220  }  }
1221    
1222  void  void
1223  ui_destroy_cursor(HCURSOR cursor)  ui_destroy_cursor(HCURSOR cursor)
1224  {  {
1225          XFreeCursor(display, (Cursor)cursor);          XFreeCursor(display, (Cursor) cursor);
1226  }  }
1227    
1228  #define MAKE_XCOLOR(xc,c) \  #define MAKE_XCOLOR(xc,c) \
# Line 879  ui_destroy_cursor(HCURSOR cursor) Line 1231  ui_destroy_cursor(HCURSOR cursor)
1231                  (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \                  (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \
1232                  (xc)->flags = DoRed | DoGreen | DoBlue;                  (xc)->flags = DoRed | DoGreen | DoBlue;
1233    
1234    
1235  HCOLOURMAP  HCOLOURMAP
1236  ui_create_colourmap(COLOURMAP *colours)  ui_create_colourmap(COLOURMAP * colours)
1237  {  {
1238          COLOURENTRY *entry;          COLOURENTRY *entry;
1239          int i, ncolours = colours->ncolours;          int i, ncolours = colours->ncolours;
1240            if (!owncolmap)
1241            {
1242                    uint32 *map = (uint32 *) xmalloc(sizeof(*colmap) * ncolours);
1243                    XColor xentry;
1244                    XColor xc_cache[256];
1245                    uint32 colour;
1246                    int colLookup = 256;
1247                    for (i = 0; i < ncolours; i++)
1248                    {
1249                            entry = &colours->colours[i];
1250                            MAKE_XCOLOR(&xentry, entry);
1251    
1252                            if (XAllocColor(display, xcolmap, &xentry) == 0)
1253                            {
1254                                    /* Allocation failed, find closest match. */
1255                                    int j = 256;
1256                                    int nMinDist = 3 * 256 * 256;
1257                                    long nDist = nMinDist;
1258    
1259                                    /* only get the colors once */
1260                                    while (colLookup--)
1261                                    {
1262                                            xc_cache[colLookup].pixel = colLookup;
1263                                            xc_cache[colLookup].red = xc_cache[colLookup].green =
1264                                                    xc_cache[colLookup].blue = 0;
1265                                            xc_cache[colLookup].flags = 0;
1266                                            XQueryColor(display,
1267                                                        DefaultColormap(display,
1268                                                                        DefaultScreen(display)),
1269                                                        &xc_cache[colLookup]);
1270                                    }
1271                                    colLookup = 0;
1272    
1273                                    /* approximate the pixel */
1274                                    while (j--)
1275                                    {
1276                                            if (xc_cache[j].flags)
1277                                            {
1278                                                    nDist = ((long) (xc_cache[j].red >> 8) -
1279                                                             (long) (xentry.red >> 8)) *
1280                                                            ((long) (xc_cache[j].red >> 8) -
1281                                                             (long) (xentry.red >> 8)) +
1282                                                            ((long) (xc_cache[j].green >> 8) -
1283                                                             (long) (xentry.green >> 8)) *
1284                                                            ((long) (xc_cache[j].green >> 8) -
1285                                                             (long) (xentry.green >> 8)) +
1286                                                            ((long) (xc_cache[j].blue >> 8) -
1287                                                             (long) (xentry.blue >> 8)) *
1288                                                            ((long) (xc_cache[j].blue >> 8) -
1289                                                             (long) (xentry.blue >> 8));
1290                                            }
1291                                            if (nDist < nMinDist)
1292                                            {
1293                                                    nMinDist = nDist;
1294                                                    xentry.pixel = j;
1295                                            }
1296                                    }
1297                            }
1298                            colour = xentry.pixel;
1299    
1300                            /* update our cache */
1301                            if (xentry.pixel < 256)
1302                            {
1303                                    xc_cache[xentry.pixel].red = xentry.red;
1304                                    xc_cache[xentry.pixel].green = xentry.green;
1305                                    xc_cache[xentry.pixel].blue = xentry.blue;
1306    
1307          if (owncolmap)                          }
1308    
1309    
1310                            /* byte swap here to make translate_image faster */
1311                            map[i] = translate_colour(colour);
1312                    }
1313                    return map;
1314            }
1315            else
1316          {          {
1317                  XColor *xcolours, *xentry;                  XColor *xcolours, *xentry;
1318                  Colormap map;                  Colormap map;
1319    
1320                  xcolours = xmalloc(sizeof(XColor) * ncolours);                  xcolours = (XColor *) xmalloc(sizeof(XColor) * ncolours);
1321                  for (i = 0; i < ncolours; i++)                  for (i = 0; i < ncolours; i++)
1322                  {                  {
1323                          entry = &colours->colours[i];                          entry = &colours->colours[i];
# Line 903  ui_create_colourmap(COLOURMAP *colours) Line 1330  ui_create_colourmap(COLOURMAP *colours)
1330                  XStoreColors(display, map, xcolours, ncolours);                  XStoreColors(display, map, xcolours, ncolours);
1331    
1332                  xfree(xcolours);                  xfree(xcolours);
1333                  return (HCOLOURMAP)map;                  return (HCOLOURMAP) map;
         }  
         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;  
1334          }          }
1335  }  }
1336    
1337  void  void
1338  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
1339  {  {
1340          if (owncolmap)          if (!owncolmap)
                 XFreeColormap(display, (Colormap)map);  
         else  
1341                  xfree(map);                  xfree(map);
1342            else
1343                    XFreeColormap(display, (Colormap) map);
1344  }  }
1345    
1346  void  void
1347  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
1348  {  {
1349          if (owncolmap)          if (!owncolmap)
1350                  XSetWindowColormap(display, wnd, (Colormap)map);                  colmap = (uint32 *) map;
1351          else          else
1352                  colmap = map;                  XSetWindowColormap(display, wnd, (Colormap) map);
1353  }  }
1354    
1355  void  void
# Line 960  ui_set_clip(int x, int y, int cx, int cy Line 1365  ui_set_clip(int x, int y, int cx, int cy
1365  }  }
1366    
1367  void  void
1368  ui_reset_clip()  ui_reset_clip(void)
1369  {  {
1370          XRectangle rect;          XRectangle rect;
1371    
# Line 972  ui_reset_clip() Line 1377  ui_reset_clip()
1377  }  }
1378    
1379  void  void
1380  ui_bell()  ui_bell(void)
1381  {  {
1382          XBell(display, 0);          XBell(display, 0);
1383  }  }
# Line 986  ui_destblt(uint8 opcode, Line 1391  ui_destblt(uint8 opcode,
1391          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1392  }  }
1393    
1394    static uint8 hatch_patterns[] = {
1395            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, /* 0 - bsHorizontal */
1396            0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, /* 1 - bsVertical */
1397            0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, /* 2 - bsFDiagonal */
1398            0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, /* 3 - bsBDiagonal */
1399            0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08, /* 4 - bsCross */
1400            0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81  /* 5 - bsDiagCross */
1401    };
1402    
1403  void  void
1404  ui_patblt(uint8 opcode,  ui_patblt(uint8 opcode,
1405            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
1406            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
1407  {  {
1408          Pixmap fill;          Pixmap fill;
1409          uint8 i, ipattern[8];          uint8 i, ipattern[8];
# Line 1003  ui_patblt(uint8 opcode, Line 1417  ui_patblt(uint8 opcode,
1417                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
1418                          break;                          break;
1419    
1420                    case 2: /* Hatch */
1421                            fill = (Pixmap) ui_create_glyph(8, 8,
1422                                                            hatch_patterns + brush->pattern[0] * 8);
1423                            SET_FOREGROUND(bgcolour);
1424                            SET_BACKGROUND(fgcolour);
1425                            XSetFillStyle(display, gc, FillOpaqueStippled);
1426                            XSetStipple(display, gc, fill);
1427                            XSetTSOrigin(display, gc, brush->xorigin, brush->yorigin);
1428                            FILL_RECTANGLE(x, y, cx, cy);
1429                            XSetFillStyle(display, gc, FillSolid);
1430                            XSetTSOrigin(display, gc, 0, 0);
1431                            ui_destroy_glyph((HGLYPH) fill);
1432                            break;
1433    
1434                  case 3: /* Pattern */                  case 3: /* Pattern */
1435                          for (i = 0; i != 8; i++)                          for (i = 0; i != 8; i++)
1436                                  ipattern[7 - i] = brush->pattern[i];                                  ipattern[7 - i] = brush->pattern[i];
# Line 1017  ui_patblt(uint8 opcode, Line 1445  ui_patblt(uint8 opcode,
1445                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
1446    
1447                          XSetFillStyle(display, gc, FillSolid);                          XSetFillStyle(display, gc, FillSolid);
1448                          ui_destroy_glyph((HGLYPH)fill);                          XSetTSOrigin(display, gc, 0, 0);
1449                            ui_destroy_glyph((HGLYPH) fill);
1450                          break;                          break;
1451    
1452                  default:                  default:
# Line 1035  ui_screenblt(uint8 opcode, Line 1464  ui_screenblt(uint8 opcode,
1464          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1465          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
1466          if (ownbackstore)          if (ownbackstore)
1467                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
1468          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1469  }  }
1470    
# Line 1046  ui_memblt(uint8 opcode, Line 1474  ui_memblt(uint8 opcode,
1474            /* src */ HBITMAP src, int srcx, int srcy)            /* src */ HBITMAP src, int srcx, int srcy)
1475  {  {
1476          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1477          XCopyArea(display, (Pixmap)src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
1478          if (ownbackstore)          if (ownbackstore)
1479                  XCopyArea(display, (Pixmap)src, backstore, gc, srcx, srcy,                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
1480          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
1481  }  }
1482    
# Line 1057  void Line 1484  void
1484  ui_triblt(uint8 opcode,  ui_triblt(uint8 opcode,
1485            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
1486            /* src */ HBITMAP src, int srcx, int srcy,            /* src */ HBITMAP src, int srcx, int srcy,
1487            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
1488  {  {
1489          /* This is potentially difficult to do in general. Until someone          /* This is potentially difficult to do in general. Until someone
1490             comes up with a more efficient way of doing it I am using cases. */             comes up with a more efficient way of doing it I am using cases. */
# Line 1066  ui_triblt(uint8 opcode, Line 1493  ui_triblt(uint8 opcode,
1493          {          {
1494                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
1495                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
1496                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1497                          break;                          break;
1498    
1499                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
1500                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1501                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
1502                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
1503                          break;                          break;
1504    
1505                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
1506                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
1507                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
1508                          break;                          break;
1509    
1510                  default:                  default:
# Line 1093  ui_triblt(uint8 opcode, Line 1516  ui_triblt(uint8 opcode,
1516  void  void
1517  ui_line(uint8 opcode,  ui_line(uint8 opcode,
1518          /* dest */ int startx, int starty, int endx, int endy,          /* dest */ int startx, int starty, int endx, int endy,
1519          /* pen */ PEN *pen)          /* pen */ PEN * pen)
1520  {  {
1521          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
1522          SET_FOREGROUND(pen->colour);          SET_FOREGROUND(pen->colour);
# Line 1112  ui_rect( Line 1535  ui_rect(
1535          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE(x, y, cx, cy);
1536  }  }
1537    
1538    /* warning, this function only draws on wnd or backstore, not both */
1539  void  void
1540  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
1541                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
1542                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
1543                int fgcolour)                int bgcolour, int fgcolour)
1544  {  {
1545          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
1546          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
1547    
1548          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(display, gc,
1549                        ? FillStippled : FillOpaqueStippled);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
1550          XSetStipple(display, gc, (Pixmap)glyph);          XSetStipple(display, gc, (Pixmap) glyph);
1551          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(display, gc, x, y);
1552    
1553          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
1554    
1555          XSetFillStyle(display, gc, FillSolid);          XSetFillStyle(display, gc, FillSolid);
1556  }  }
# Line 1140  ui_draw_glyph(int mixmode, Line 1564  ui_draw_glyph(int mixmode,
1564        if ((xyoffset & 0x80))\        if ((xyoffset & 0x80))\
1565          {\          {\
1566            if (flags & TEXT2_VERTICAL) \            if (flags & TEXT2_VERTICAL) \
1567              y += ttext[++idx] | (ttext[++idx] << 8);\              y += ttext[idx+1] | (ttext[idx+2] << 8);\
1568            else\            else\
1569              x += ttext[++idx] | (ttext[++idx] << 8);\              x += ttext[idx+1] | (ttext[idx+2] << 8);\
1570              idx += 2;\
1571          }\          }\
1572        else\        else\
1573          {\          {\
# Line 1154  ui_draw_glyph(int mixmode, Line 1579  ui_draw_glyph(int mixmode,
1579      }\      }\
1580    if (glyph != NULL)\    if (glyph != NULL)\
1581      {\      {\
1582        ui_draw_glyph (mixmode, x + (short) glyph->offset,\        ui_draw_glyph (mixmode, x + glyph->offset,\
1583                       y + (short) glyph->baseline,\                       y + glyph->baseline,\
1584                       glyph->width, glyph->height,\                       glyph->width, glyph->height,\
1585                       glyph->pixmap, 0, 0, bgcolour, fgcolour);\                       glyph->pixmap, 0, 0, bgcolour, fgcolour);\
1586        if (flags & TEXT2_IMPLICIT_X)\        if (flags & TEXT2_IMPLICIT_X)\
# Line 1165  ui_draw_glyph(int mixmode, Line 1590  ui_draw_glyph(int mixmode,
1590    
1591  void  void
1592  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,
1593               int clipx, int clipy, int clipcx, int clipcy, int boxx,               int clipx, int clipy, int clipcx, int clipcy,
1594               int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1595               int fgcolour, uint8 * text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1596  {  {
1597          FONTGLYPH *glyph;          FONTGLYPH *glyph;
# Line 1177  ui_draw_text(uint8 font, uint8 flags, in Line 1602  ui_draw_text(uint8 font, uint8 flags, in
1602    
1603          if (boxcx > 1)          if (boxcx > 1)
1604          {          {
1605                  FILL_RECTANGLE(boxx, boxy, boxcx, boxcy);                  FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy);
1606          }          }
1607          else if (mixmode == MIX_OPAQUE)          else if (mixmode == MIX_OPAQUE)
1608          {          {
1609                  FILL_RECTANGLE(clipx, clipy, clipcx, clipcy);                  FILL_RECTANGLE_BACKSTORE(clipx, clipy, clipcx, clipcy);
1610          }          }
1611    
1612          /* Paint text, character by character */          /* Paint text, character by character */
1613          for (i = 0; i < length;) {          for (i = 0; i < length;)
1614                  switch (text[i]) {          {
1615                  case 0xff:                  switch (text[i])
1616                          if (i + 2 < length)                  {
1617                                  cache_put_text(text[i + 1], text, text[i + 2]);                          case 0xff:
1618                          else {                                  if (i + 2 < length)
1619                                  error("this shouldn't be happening\n");                                          cache_put_text(text[i + 1], text, text[i + 2]);
1620                                    else
1621                                    {
1622                                            error("this shouldn't be happening\n");
1623                                            exit(1);
1624                                    }
1625                                    /* this will move pointer from start to first character after FF command */
1626                                    length -= i + 3;
1627                                    text = &(text[i + 3]);
1628                                    i = 0;
1629                                  break;                                  break;
                         }  
                         /* this will move pointer from start to first character after FF command */  
                         length -= i + 3;  
                         text = &(text[i + 3]);  
                         i = 0;  
                         break;  
1630    
1631                  case 0xfe:                          case 0xfe:
1632                          entry = cache_get_text(text[i + 1]);                                  entry = cache_get_text(text[i + 1]);
1633                          if (entry != NULL) {                                  if (entry != NULL)
1634                                  if ((((uint8 *) (entry->data))[1] == 0)                                  {
1635                                      && (!(flags & TEXT2_IMPLICIT_X))) {                                          if ((((uint8 *) (entry->data))[1] ==
1636                                          if (flags & TEXT2_VERTICAL)                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
1637                                                  y += text[i + 2];                                          {
1638                                          else                                                  if (flags & TEXT2_VERTICAL)
1639                                                  x += text[i + 2];                                                          y += text[i + 2];
1640                                                    else
1641                                                            x += text[i + 2];
1642                                            }
1643                                            for (j = 0; j < entry->size; j++)
1644                                                    DO_GLYPH(((uint8 *) (entry->data)), j);
1645                                  }                                  }
1646                                  if (i + 2 < length)                                  if (i + 2 < length)
1647                                          i += 3;                                          i += 3;
1648                                  else                                  else
1649                                          i += 2;                                          i += 2;
1650                                  length -= i;                                  length -= i;
1651                                  /* this will move pointer from start to first character after FE command */                                  /* this will move pointer from start to first character after FE command */
1652                                  text = &(text[i]);                                  text = &(text[i]);
1653                                  i = 0;                                  i = 0;
1654                                  for (j = 0; j < entry->size; j++)                                  break;
                                         DO_GLYPH(((uint8 *) (entry->data)), j);  
                         }  
                         break;  
1655    
1656                  default:                          default:
1657                          DO_GLYPH(text, i);                                  DO_GLYPH(text, i);
1658                          i++;                                  i++;
1659                          break;                                  break;
1660                  }                  }
1661          }          }
1662            if (ownbackstore)
1663            {
1664                    if (boxcx > 1)
1665                            XCopyArea(display, backstore, wnd, gc, boxx,
1666                                      boxy, boxcx, boxcy, boxx, boxy);
1667                    else
1668                            XCopyArea(display, backstore, wnd, gc, clipx,
1669                                      clipy, clipcx, clipcy, clipx, clipy);
1670            }
1671  }  }
1672    
1673  void  void
# Line 1241  ui_desktop_save(uint32 offset, int x, in Line 1678  ui_desktop_save(uint32 offset, int x, in
1678    
1679          if (ownbackstore)          if (ownbackstore)
1680          {          {
1681                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1682          }          }
1683          else          else
1684          {          {
1685                  pix = XCreatePixmap(display, wnd, cx, cy, depth);                  pix = XCreatePixmap(display, wnd, cx, cy, depth);
1686                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
1687                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1688                  XFreePixmap(display, pix);                  XFreePixmap(display, pix);
1689          }          }
1690    
1691          offset *= bpp/8;          offset *= bpp / 8;
1692          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8, (uint8 *) image->data);
                           bpp/8, (uint8 *)image->data);  
1693    
1694          XDestroyImage(image);          XDestroyImage(image);
1695  }  }
# Line 1266  ui_desktop_restore(uint32 offset, int x, Line 1700  ui_desktop_restore(uint32 offset, int x,
1700          XImage *image;          XImage *image;
1701          uint8 *data;          uint8 *data;
1702    
1703          offset *= bpp/8;          offset *= bpp / 8;
1704          data = cache_get_desktop(offset, cx, cy, bpp/8);          data = cache_get_desktop(offset, cx, cy, bpp / 8);
1705          if (data == NULL)          if (data == NULL)
1706                  return;                  return;
1707    
1708          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1709                               0, data, cx, cy, BitmapPad(display),                               (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
                              cx * bpp/8);  
1710    
1711          if (ownbackstore)          if (ownbackstore)
1712          {          {
Legend:
Removed from v.59  
changed lines
  Added in v.435
  ViewVC Help
Powered by ViewVC 1.1.26