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