/[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 28 by matty, Wed Jun 20 13:54:48 2001 UTC revision 84 by astrand, Tue Jul 30 07:30:12 2002 UTC
# Line 1  Line 1 
1  /*  /*
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-2000     Copyright (C) Matthew Chapman 1999-2001
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 21  Line 21 
21  #include <X11/Xlib.h>  #include <X11/Xlib.h>
22  #include <X11/Xutil.h>  #include <X11/Xutil.h>
23  #include <time.h>  #include <time.h>
24    #include <errno.h>
25    #define XK_MISCELLANY
26    #include <X11/keysymdef.h>
27  #include "rdesktop.h"  #include "rdesktop.h"
28    #include "scancodes.h"
29    
30  extern int width;  extern int width;
31  extern int height;  extern int height;
32  extern BOOL motion;  extern BOOL sendmotion;
 extern BOOL grab_keyboard;  
33  extern BOOL fullscreen;  extern BOOL fullscreen;
34  extern int private_colormap;  extern BOOL grab_keyboard;
35    
36  static int bpp;  Display *display = NULL;
37  static int depth;  static int x_socket;
 static Display *display;  
38  static Window wnd;  static Window wnd;
39  static GC gc;  static GC gc;
40  static Visual *visual;  static Visual *visual;
41  static uint32 *colmap;  static int depth;
42    static int bpp;
43    
44  #define Ctrans(col) ( private_colormap ? col : colmap[col])  /* endianness */
45    static BOOL host_be;
46    static BOOL xserver_be;
47    
48    /* software backing store */
49    static BOOL ownbackstore;
50    static Pixmap backstore;
51    
52    #define FILL_RECTANGLE(x,y,cx,cy)\
53    { \
54            XFillRectangle(display, wnd, gc, x, y, cx, cy); \
55            if (ownbackstore) \
56                    XFillRectangle(display, backstore, gc, x, y, cx, cy); \
57    }
58    
59    /* colour maps */
60    static BOOL owncolmap;
61    static Colormap xcolmap;
62    static uint32 white;
63    static uint32 *colmap;
64    static XIM IM = NULL;
65    static XIC IC = NULL;
66    
67  #define L_ENDIAN  /* Compose support */
68  int screen_msbfirst = 0;  BOOL enable_compose = False;
69    
70  static uint8 *translate(int width, int height, uint8 *data);  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )
71    #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));
72    #define SET_BACKGROUND(col)     XSetBackground(display, gc, TRANSLATE(col));
73    
74  static int rop2_map[] = {  static int rop2_map[] = {
75          GXclear,                /* 0 */          GXclear,                /* 0 */
# Line 64  static int rop2_map[] = { Line 90  static int rop2_map[] = {
90          GXset                   /* 1 */          GXset                   /* 1 */
91  };  };
92    
93    #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }
94    #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
95    
96  static void  static void
97  xwin_set_function(uint8 rop2)  translate8(uint8 * data, uint8 * out, uint8 * end)
98  {  {
99          static uint8 last_rop2 = ROP2_COPY;          while (out < end)
100                    *(out++) = (uint8) colmap[*(data++)];
101    }
102    
103          if (last_rop2 != rop2)  static void
104    translate16(uint8 * data, uint16 * out, uint16 * end)
105    {
106            while (out < end)
107                    *(out++) = (uint16) colmap[*(data++)];
108    }
109    
110    /* little endian - conversion happens when colourmap is built */
111    static void
112    translate24(uint8 * data, uint8 * out, uint8 * end)
113    {
114            uint32 value;
115    
116            while (out < end)
117          {          {
118                  XSetFunction(display, gc, rop2_map[rop2]);                  value = colmap[*(data++)];
119                  last_rop2 = rop2;                  *(out++) = value;
120                    *(out++) = value >> 8;
121                    *(out++) = value >> 16;
122          }          }
123  }  }
124    
125  static void  static void
126  xwin_grab_keyboard()  translate32(uint8 * data, uint32 * out, uint32 * end)
127    {
128            while (out < end)
129                    *(out++) = colmap[*(data++)];
130    }
131    
132    static uint8 *
133    translate_image(int width, int height, uint8 * data)
134    {
135            int size = width * height * bpp / 8;
136            uint8 *out = xmalloc(size);
137            uint8 *end = out + size;
138    
139            switch (bpp)
140            {
141                    case 8:
142                            translate8(data, out, end);
143                            break;
144    
145                    case 16:
146                            translate16(data, (uint16 *) out, (uint16 *) end);
147                            break;
148    
149                    case 24:
150                            translate24(data, out, end);
151                            break;
152    
153                    case 32:
154                            translate32(data, (uint32 *) out, (uint32 *) end);
155                            break;
156            }
157    
158            return out;
159    }
160    
161    #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
162    #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }
163    #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
164                            x = (x << 16) | (x >> 16); }
165    
166    static uint32
167    translate_colour(uint32 colour)
168    {
169            switch (bpp)
170            {
171                    case 16:
172                            if (host_be != xserver_be)
173                                    BSWAP16(colour);
174                            break;
175    
176                    case 24:
177                            if (xserver_be)
178                                    BSWAP24(colour);
179                            break;
180    
181                    case 32:
182                            if (host_be != xserver_be)
183                                    BSWAP32(colour);
184                            break;
185            }
186    
187            return colour;
188    }
189    
190    static unsigned long
191    init_inputmethod(void)
192  {  {
193          XGrabKeyboard(display, wnd, True, GrabModeAsync, GrabModeAsync,          unsigned long filtered_events = 0;
194                        CurrentTime);  
195            IM = XOpenIM(display, NULL, NULL, NULL);
196            if (IM == NULL)
197            {
198                    error("Failed to open input method\n");
199            }
200    
201            if (IM != NULL)
202            {
203                    /* Must be done after XCreateWindow */
204                    IC = XCreateIC(IM, XNInputStyle,
205                                   (XIMPreeditNothing | XIMStatusNothing),
206                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
207    
208                    if (IC == NULL)
209                    {
210                            error("Failed to create input context\n");
211                            XCloseIM(IM);
212                            IM = NULL;
213                    }
214            }
215    
216            /* For correct Multi_key/Compose processing, I guess.
217               It seems to work alright anyway, though. */
218            if (IC != NULL)
219            {
220                    if (XGetICValues(IC, XNFilterEvents, &filtered_events, NULL) != NULL)
221                    {
222                            error("Failed to obtain XNFilterEvents value from IC\n");
223                            filtered_events = 0;
224                    }
225            }
226            return filtered_events;
227  }  }
228    
229  static void  static void
230  xwin_ungrab_keyboard()  close_inputmethod(void)
231    {
232            if (IC != NULL)
233            {
234                    XDestroyIC(IC);
235                    if (IM != NULL)
236                    {
237                            XCloseIM(IM);
238                            IM = NULL;
239                    }
240            }
241    }
242    
243    BOOL
244    ui_init()
245  {  {
246          XUngrabKeyboard(display, CurrentTime);          Screen *screen;
247            display = XOpenDisplay(NULL);
248            if (display == NULL)
249            {
250                    error("Failed to open display\n");
251                    return False;
252            }
253            if (fullscreen)
254            {
255                    screen = DefaultScreenOfDisplay(display);
256                    width = WidthOfScreen(screen);
257                    height = HeightOfScreen(screen);
258            }
259            return True;
260  }  }
261    
262  BOOL  BOOL
# Line 97  ui_create_window(char *title) Line 267  ui_create_window(char *title)
267          XSizeHints *sizehints;          XSizeHints *sizehints;
268          unsigned long input_mask;          unsigned long input_mask;
269          XPixmapFormatValues *pfm;          XPixmapFormatValues *pfm;
270          int count;          Screen *screen;
271            uint16 test;
272            int i;
273    
274            x_socket = ConnectionNumber(display);
275            screen = DefaultScreenOfDisplay(display);
276            visual = DefaultVisualOfScreen(screen);
277            depth = DefaultDepthOfScreen(screen);
278    
279          display = XOpenDisplay(NULL);          pfm = XListPixmapFormats(display, &i);
         if (display == NULL)  
         {  
                 ERROR("Failed to open display\n");  
                 return False;  
         }  
   
         visual = DefaultVisual(display, DefaultScreen(display));  
         depth = DefaultDepth(display, DefaultScreen(display));  
         pfm = XListPixmapFormats(display, &count);  
280          if (pfm != NULL)          if (pfm != NULL)
281          {          {
282                  while (count--)                  /* Use maximum bpp for this depth - this is generally
283                       desirable, e.g. 24 bits->32 bits. */
284                    while (i--)
285                  {                  {
286                          if ((pfm + count)->depth == depth                          if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
                             && (pfm + count)->bits_per_pixel > bpp)  
287                          {                          {
288                                  bpp = (pfm + count)->bits_per_pixel;                                  bpp = pfm[i].bits_per_pixel;
289                          }                          }
290                  }                  }
291                  XFree(pfm);                  XFree(pfm);
# Line 124  ui_create_window(char *title) Line 293  ui_create_window(char *title)
293    
294          if (bpp < 8)          if (bpp < 8)
295          {          {
296                  ERROR("Less than 8 bpp not currently supported.\n");                  error("Less than 8 bpp not currently supported.\n");
297                  XCloseDisplay(display);                  XCloseDisplay(display);
298                  return False;                  return False;
299          }          }
300    
301          width &= ~3; /* make width nicely divisible */          if (depth <= 8)
302                    owncolmap = True;
303            else
304                    xcolmap = DefaultColormapOfScreen(screen);
305    
306          attribs.background_pixel = BlackPixel(display, DefaultScreen(display));          test = 1;
307          attribs.backing_store = Always;          host_be = !(BOOL) (*(uint8 *) (&test));
308            xserver_be = (ImageByteOrder(display) == MSBFirst);
309    
310            white = WhitePixelOfScreen(screen);
311            attribs.background_pixel = BlackPixelOfScreen(screen);
312            attribs.backing_store = DoesBackingStore(screen);
313    
314            if (attribs.backing_store == NotUseful)
315                    ownbackstore = True;
316    
317          if (fullscreen)          if (fullscreen)
318          {          {
319                  attribs.override_redirect = True;                  attribs.override_redirect = True;
320                  width = WidthOfScreen(DefaultScreenOfDisplay(display));                  width = WidthOfScreen(screen);
321                  height = HeightOfScreen(DefaultScreenOfDisplay(display));                  height = HeightOfScreen(screen);
                 XSetInputFocus(display, PointerRoot, RevertToPointerRoot,  
                                CurrentTime);  
322          }          }
323          else          else
324          {          {
325                  attribs.override_redirect = False;                  attribs.override_redirect = False;
326          }          }
327    
328          wnd = XCreateWindow(display, DefaultRootWindow(display),          width = (width + 3) & ~3;       /* make width a multiple of 32 bits */
329    
330            wnd = XCreateWindow(display, RootWindowOfScreen(screen),
331                              0, 0, width, height, 0, CopyFromParent,                              0, 0, width, height, 0, CopyFromParent,
332                              InputOutput, CopyFromParent,                              InputOutput, CopyFromParent,
333                              CWBackingStore | CWBackPixel | CWOverrideRedirect,                              CWBackingStore | CWBackPixel | CWOverrideRedirect, &attribs);
                             &attribs);  
334    
335          XStoreName(display, wnd, title);          XStoreName(display, wnd, title);
336    
337          classhints = XAllocClassHint();          classhints = XAllocClassHint();
338          if (classhints != NULL)          if (classhints != NULL)
   
339          {          {
340                  classhints->res_name = "rdesktop";                  classhints->res_name = classhints->res_class = "rdesktop";
                 classhints->res_class = "rdesktop";  
341                  XSetClassHint(display, wnd, classhints);                  XSetClassHint(display, wnd, classhints);
342                  XFree(classhints);                  XFree(classhints);
343          }          }
# Line 168  ui_create_window(char *title) Line 345  ui_create_window(char *title)
345          sizehints = XAllocSizeHints();          sizehints = XAllocSizeHints();
346          if (sizehints)          if (sizehints)
347          {          {
348                  sizehints->flags =                  sizehints->flags = PMinSize | PMaxSize;
349                          PPosition | PSize | PMinSize | PMaxSize | PBaseSize;                  sizehints->min_width = sizehints->max_width = width;
350                  sizehints->min_width = width;                  sizehints->min_height = sizehints->max_height = height;
                 sizehints->max_width = width;  
                 sizehints->min_height = height;  
                 sizehints->max_height = height;  
                 sizehints->base_width = width;  
                 sizehints->base_height = height;  
351                  XSetWMNormalHints(display, wnd, sizehints);                  XSetWMNormalHints(display, wnd, sizehints);
352                  XFree(sizehints);                  XFree(sizehints);
353          }          }
354    
355          input_mask = KeyPressMask | KeyReleaseMask;          xkeymap_init2();
356          input_mask |= ButtonPressMask | ButtonReleaseMask;  
357          if (motion)          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
                 input_mask |= PointerMotionMask;  
358          if (grab_keyboard)          if (grab_keyboard)
359                  input_mask |= EnterWindowMask | LeaveWindowMask;                  input_mask |= EnterWindowMask | LeaveWindowMask;
360            if (sendmotion)
361                    input_mask |= PointerMotionMask;
362    
363            if (ownbackstore)
364                    input_mask |= ExposureMask;
365    
366            if (enable_compose)
367                    input_mask |= init_inputmethod();
368    
369          XSelectInput(display, wnd, input_mask);          XSelectInput(display, wnd, input_mask);
370    
371          gc = XCreateGC(display, wnd, 0, NULL);          gc = XCreateGC(display, wnd, 0, NULL);
372    
373            if (ownbackstore)
374                    backstore = XCreatePixmap(display, wnd, width, height, depth);
375    
376          XMapWindow(display, wnd);          XMapWindow(display, wnd);
377    
378          return True;          return True;
379  }  }
380    
381  void  void
382  ui_destroy_window()  ui_destroy_window()
383  {  {
384            if (ownbackstore)
385                    XFreePixmap(display, backstore);
386    
387          XFreeGC(display, gc);          XFreeGC(display, gc);
388    
389            close_inputmethod();
390    
391          XDestroyWindow(display, wnd);          XDestroyWindow(display, wnd);
392          XCloseDisplay(display);          XCloseDisplay(display);
393          display = NULL;          display = NULL;
394  }  }
395    
396  static uint8  static void
397  xwin_translate_key(unsigned long key)  xwin_process_events()
398  {  {
399          DEBUG("KEY(code=0x%lx)\n", key);          XEvent xevent;
   
         if ((key > 8) && (key <= 0x60))  
                 return (key - 8);  
400    
401          switch (key)          KeySym keysym;
402          {          uint16 button, flags;
                 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;  
         }  
   
         return 0;  
 }  
   
 void  
 ui_process_events()  
 {  
         XEvent event;  
         uint8 scancode;  
         uint16 button;  
403          uint32 ev_time;          uint32 ev_time;
404            key_translation tr;
405            char *ksname = NULL;
406            char str[256];
407            Status status;
408    
409          if (display == NULL)          /* Refresh keyboard mapping if it has changed. This is important for
410                  return;             Xvnc, since it allocates keycodes dynamically */
411            if (XCheckTypedEvent(display, MappingNotify, &xevent))
412            {
413                    if (xevent.xmapping.request == MappingKeyboard
414                        || xevent.xmapping.request == MappingModifier)
415                            XRefreshKeyboardMapping(&xevent.xmapping);
416            }
417    
418          while (XCheckWindowEvent(display, wnd, ~0, &event))          while (XCheckMaskEvent(display, ~0, &xevent))
419          {          {
420                    if (enable_compose && (XFilterEvent(&xevent, None) == True))
421                    {
422                            DEBUG_KBD(("Filtering event\n"));
423                            continue;
424                    }
425    
426                  ev_time = time(NULL);                  ev_time = time(NULL);
427                    flags = 0;
428    
429                  switch (event.type)                  switch (xevent.type)
430                  {                  {
431                          case KeyPress:                          case KeyPress:
432                                  scancode = xwin_translate_key(event.xkey.keycode);                                  if (IC != NULL)
433                                  if (scancode == 0)                                          /* Multi_key compatible version */
434                                    {
435                                            XmbLookupString(IC,
436                                                            (XKeyPressedEvent *) &
437                                                            xevent, str, sizeof(str), &keysym, &status);
438                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
439                                            {
440                                                    error("XmbLookupString failed with status 0x%x\n",
441                                                          status);
442                                                    break;
443                                            }
444                                    }
445                                    else
446                                    {
447                                            /* Plain old XLookupString */
448                                            DEBUG_KBD(("No input context, using XLookupString\n"));
449                                            XLookupString((XKeyEvent *) & xevent,
450                                                          str, sizeof(str), &keysym, NULL);
451                                    }
452    
453                                    ksname = get_ksname(keysym);
454                                    DEBUG_KBD(("\nKeyPress for (keysym 0x%lx, %s)\n", keysym, ksname));
455    
456                                    if (inhibit_key(keysym))
457                                    {
458                                            DEBUG_KBD(("Inhibiting key\n"));
459                                          break;                                          break;
460                                    }
461    
462                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0,                                  tr = xkeymap_translate_key(keysym,
463                                                 scancode, 0);                                                             xevent.xkey.keycode, xevent.xkey.state);
                                 break;  
464    
465                          case KeyRelease:                                  ensure_remote_modifiers(ev_time, tr);
466                                  scancode = xwin_translate_key(event.xkey.keycode);  
467                                  if (scancode == 0)                                  if (tr.scancode == 0)
468                                          break;                                          break;
469    
470                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE,                                  rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
                                                KBD_FLAG_DOWN | KBD_FLAG_UP,  
                                                scancode, 0);  
471                                  break;                                  break;
472                            case KeyRelease:
473                                    XLookupString((XKeyEvent *) & xevent, str,
474                                                  sizeof(str), &keysym, NULL);
475    
476                          case ButtonPress:                                  ksname = get_ksname(keysym);
477                                  button = xwin_translate_mouse(event.xbutton.button);                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
478                                  if (button == 0)                                             ksname));
479    
480                                    if (inhibit_key(keysym))
481                                          break;                                          break;
482    
483                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  tr = xkeymap_translate_key(keysym,
484                                                 button | MOUSE_FLAG_DOWN,                                                             xevent.xkey.keycode, xevent.xkey.state);
485                                                 event.xbutton.x,  
486                                                 event.xbutton.y);                                  if (tr.scancode == 0)
487                                            break;
488    
489                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
490                                  break;                                  break;
491    
492                            case ButtonPress:
493                                    flags = MOUSE_FLAG_DOWN;
494                                    /* fall through */
495    
496                          case ButtonRelease:                          case ButtonRelease:
497                                  button = xwin_translate_mouse(event.xbutton.button);                                  button = xkeymap_translate_button(xevent.xbutton.button);
498                                  if (button == 0)                                  if (button == 0)
499                                          break;                                          break;
500    
501                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,
502                                                 button,                                                 flags | button, xevent.xbutton.x, xevent.xbutton.y);
                                                event.xbutton.x,  
                                                event.xbutton.y);  
503                                  break;                                  break;
504    
505                          case MotionNotify:                          case MotionNotify:
506                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,
507                                                 MOUSE_FLAG_MOVE,                                                 MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
                                                event.xmotion.x,  
                                                event.xmotion.y);  
508                                  break;                                  break;
509    
510                            case FocusIn:
511                                    /* fall through */
512                          case EnterNotify:                          case EnterNotify:
513                                  if (grab_keyboard)                                  if (grab_keyboard)
514                                          xwin_grab_keyboard();                                          XGrabKeyboard(display, wnd, True,
515                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
516                                  break;                                  break;
517    
518                            case FocusOut:
519                                    /* reset keys */
520                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE,
521                                                   KBD_FLAG_DOWN | KBD_FLAG_UP, SCANCODE_CHAR_LCTRL, 0);
522                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE,
523                                                   KBD_FLAG_DOWN | KBD_FLAG_UP, SCANCODE_CHAR_LALT, 0);
524                                    /* fall through */
525                          case LeaveNotify:                          case LeaveNotify:
526                                  if (grab_keyboard)                                  if (grab_keyboard)
527                                          xwin_ungrab_keyboard();                                          XUngrabKeyboard(display, CurrentTime);
528                                    break;
529    
530                            case Expose:
531                                    XCopyArea(display, backstore, wnd, gc,
532                                              xevent.xexpose.x, xevent.xexpose.y,
533                                              xevent.xexpose.width,
534                                              xevent.xexpose.height,
535                                              xevent.xexpose.x, xevent.xexpose.y);
536                                  break;                                  break;
537                  }                  }
538          }          }
539  }  }
540    
541  void  void
542    ui_select(int rdp_socket)
543    {
544            int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;
545            fd_set rfds;
546    
547            FD_ZERO(&rfds);
548    
549            while (True)
550            {
551                    FD_ZERO(&rfds);
552                    FD_SET(rdp_socket, &rfds);
553                    if (display != NULL)
554                    {
555                            FD_SET(x_socket, &rfds);
556                            XFlush(display);
557                    }
558    
559                    switch (select(n, &rfds, NULL, NULL, NULL))
560                    {
561                            case -1:
562                                    error("select: %s\n", strerror(errno));
563    
564                            case 0:
565                                    continue;
566                    }
567    
568                    if (FD_ISSET(x_socket, &rfds))
569                            xwin_process_events();
570    
571                    if (FD_ISSET(rdp_socket, &rfds))
572                            return;
573            }
574    }
575    
576    void
577  ui_move_pointer(int x, int y)  ui_move_pointer(int x, int y)
578  {  {
579          XWarpPointer(display, wnd, wnd, 0, 0, 0, 0, x, y);          XWarpPointer(display, wnd, wnd, 0, 0, 0, 0, x, y);
580  }  }
581    
582  HBITMAP  HBITMAP
583  ui_create_bitmap(int width, int height, uint8 *data)  ui_create_bitmap(int width, int height, uint8 * data)
584  {  {
585          XImage *image;          XImage *image;
586          Pixmap bitmap;          Pixmap bitmap;
587          uint8 *tdata;          uint8 *tdata;
588          tdata = (private_colormap ? data : translate(width, height, data));  
589            tdata = (owncolmap ? data : translate_image(width, height, data));
590          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
591          image =          image = XCreateImage(display, visual, depth, ZPixmap, 0,
592                  XCreateImage(display, visual,                               (char *) tdata, width, height, 8, 0);
                              depth, ZPixmap,  
                              0, tdata, width, height, BitmapPad(display), 0);  
593    
         xwin_set_function(ROP2_COPY);  
594          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
595    
596          XFree(image);          XFree(image);
597          if (!private_colormap)          if (!owncolmap)
598                  xfree(tdata);                  xfree(tdata);
599          return (HBITMAP) bitmap;          return (HBITMAP) bitmap;
600  }  }
601    
602  void  void
603  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)  
604  {  {
605          XImage *image;          XImage *image;
606          uint8 *tdata =          uint8 *tdata;
                 (private_colormap ? data : translate(width, height, data));  
         image =  
                 XCreateImage(display, visual, depth, ZPixmap, 0, tdata, width,  
                              height, BitmapPad(display), 0);  
   
         xwin_set_function(ROP2_COPY);  
607    
608          /* Window */          tdata = (owncolmap ? data : translate_image(width, height, data));
609          XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);          image = XCreateImage(display, visual, depth, ZPixmap, 0,
610          XFree(image);                               (char *) tdata, width, height, 8, 0);
         if (!private_colormap)  
                 xfree(tdata);  
 }  
611    
612  void          if (ownbackstore)
 ui_destroy_bitmap(HBITMAP bmp)  
 {  
         XFreePixmap(display, (Pixmap) bmp);  
 }  
   
 HCURSOR  
 ui_create_cursor(unsigned int x, unsigned int y, int width,  
                  int height, uint8 *mask, uint8 *data)  
 {  
         XImage *imagecursor;  
         XImage *imagemask;  
         Pixmap maskbitmap, cursorbitmap;  
         Cursor cursor;  
         XColor bg, fg;  
         GC lgc;  
         int i, x1, y1, scanlinelen;  
         uint8 *cdata, *cmask;  
         uint8 c;  
         cdata = (uint8 *) malloc(sizeof(uint8) * width * height);  
         if (!cdata)  
                 return NULL;  
         scanlinelen = (width + 7) >> 3;  
         cmask = (uint8 *) malloc(sizeof(uint8) * scanlinelen * height);  
         if (!cmask)  
613          {          {
614                  free(cdata);                  XPutImage(display, backstore, gc, image, 0, 0, x, y, cx, cy);
615                  return NULL;                  XCopyArea(display, backstore, wnd, gc, x, y, cx, cy, x, y);
         }  
         i = (height - 1) * scanlinelen;  
   
         if (!screen_msbfirst)  
         {  
                 while (i >= 0)  
                 {  
                         for (x1 = 0; x1 < scanlinelen; x1++)  
                         {  
                                 c = *(mask++);  
                                 cmask[i + x1] =  
                                         ((c & 0x1) << 7) | ((c & 0x2) << 5) |  
                                         ((c & 0x4) << 3) | ((c & 0x8) << 1) |  
                                         ((c & 0x10) >> 1) | ((c & 0x20) >> 3)  
                                         | ((c & 0x40) >> 5) | ((c & 0x80) >>  
                                                                7);  
                         }  
                         i -= scanlinelen;  
                 }  
616          }          }
617          else          else
618          {          {
619                  while (i >= 0)                  XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);
                 {  
                         for (x1 = 0; x1 < scanlinelen; x1++)  
                         {  
                                 cmask[i + x1] = *(mask++);  
                         }  
                         i -= scanlinelen;  
                 }  
620          }          }
621    
622            XFree(image);
623          fg.red = 0;          if (!owncolmap)
624          fg.blue = 0;                  xfree(tdata);
         fg.green = 0;  
         fg.flags = DoRed | DoBlue | DoGreen;  
         bg.red = 65535;  
         bg.blue = 65535;  
         bg.green = 65535;  
         bg.flags = DoRed | DoBlue | DoGreen;  
         maskbitmap = XCreatePixmap(display, wnd, width, height, 1);  
         cursorbitmap = XCreatePixmap(display, wnd, width, height, 1);  
         lgc = XCreateGC(display, maskbitmap, 0, NULL);  
         XSetFunction(display, lgc, GXcopy);  
         imagemask =  
                 XCreateImage(display, visual, 1, XYBitmap, 0, cmask, width,  
                              height, 8, 0);  
         imagecursor =  
                 XCreateImage(display, visual, 1, XYBitmap, 0, cdata, width,  
                              height, 8, 0);  
         for (y1 = height - 1; y1 >= 0; y1--)  
                 for (x1 = 0; x1 < width; x1++)  
                 {  
                         if (data[0] >= 0x80 || data[1] >= 0x80  
                             || data[2] >= 0x80)  
                                 if (XGetPixel(imagemask, x1, y1))  
   
                                 {  
                                         XPutPixel(imagecursor, x1, y1, 0);  
                                         XPutPixel(imagemask, x1, y1, 0);        /* mask is blank for text cursor! */  
                                 }  
   
                                 else  
                                         XPutPixel(imagecursor, x1, y1, 1);  
   
                         else  
                                 XPutPixel(imagecursor, x1, y1,  
                                           XGetPixel(imagemask, x1, y1));  
                         data += 3;  
                 }  
         XPutImage(display, maskbitmap, lgc, imagemask, 0, 0, 0, 0, width,  
                   height);  
         XPutImage(display, cursorbitmap, lgc, imagecursor, 0, 0, 0, 0, width,  
                   height); XFree(imagemask);  
         XFree(imagecursor);  
         free(cmask);  
         free(cdata);  
         XFreeGC(display, lgc);  
         cursor =  
                 XCreatePixmapCursor(display, cursorbitmap, maskbitmap, &fg,  
                                     &bg, x, y);  
         XFreePixmap(display, maskbitmap);  
         XFreePixmap(display, cursorbitmap);  
         return (HCURSOR) cursor;  
 }  
   
 void  
 ui_set_cursor(HCURSOR cursor)  
 {  
         XDefineCursor(display, wnd, (Cursor) cursor);  
625  }  }
626    
627  void  void
628  ui_destroy_cursor(HCURSOR cursor)  ui_destroy_bitmap(HBITMAP bmp)
629  {  {
630          XFreeCursor(display, (Cursor) cursor);          XFreePixmap(display, (Pixmap) bmp);
631  }  }
632    
633  HGLYPH  HGLYPH
634  ui_create_glyph(int width, int height, uint8 *data)  ui_create_glyph(int width, int height, uint8 * data)
635  {  {
636          XImage *image;          XImage *image;
637          Pixmap bitmap;          Pixmap bitmap;
# Line 538  ui_create_glyph(int width, int height, u Line 643  ui_create_glyph(int width, int height, u
643          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
644          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
645    
646          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
647                               data, width, height, 8, scanline);                               width, height, 8, scanline);
648          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
649          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
650          XInitImage(image);          XInitImage(image);
651    
         XSetFunction(display, gc, GXcopy);  
652          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
653    
654          XFree(image);          XFree(image);
655          XFreeGC(display, gc);          XFreeGC(display, gc);
   
656          return (HGLYPH) bitmap;          return (HGLYPH) bitmap;
657  }  }
658    
# Line 558  ui_destroy_glyph(HGLYPH glyph) Line 662  ui_destroy_glyph(HGLYPH glyph)
662          XFreePixmap(display, (Pixmap) glyph);          XFreePixmap(display, (Pixmap) glyph);
663  }  }
664    
665  HCOLOURMAP  HCURSOR
666  ui_create_colourmap(COLOURMAP *colours)  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
667                     uint8 * andmask, uint8 * xormask)
668  {  {
669          if (!private_colormap)          HGLYPH maskglyph, cursorglyph;
670            XColor bg, fg;
671            Cursor xcursor;
672            uint8 *cursor, *pcursor;
673            uint8 *mask, *pmask;
674            uint8 nextbit;
675            int scanline, offset;
676            int i, j;
677    
678            scanline = (width + 7) / 8;
679            offset = scanline * height;
680    
681            cursor = xmalloc(offset);
682            memset(cursor, 0, offset);
683    
684            mask = xmalloc(offset);
685            memset(mask, 0, offset);
686    
687            /* approximate AND and XOR masks with a monochrome X pointer */
688            for (i = 0; i < height; i++)
689          {          {
690                  COLOURENTRY *entry;                  offset -= scanline;
691                  int i, ncolours = colours->ncolours;                  pcursor = &cursor[offset];
692                  uint32 *nc = xmalloc(sizeof(*colmap) * ncolours);                  pmask = &mask[offset];
693                  for (i = 0; i < ncolours; i++)  
694                    for (j = 0; j < scanline; j++)
695                  {                  {
696                          XColor xc;                          for (nextbit = 0x80; nextbit != 0; nextbit >>= 1)
697                          entry = &colours->colours[i];                          {
698                          xc.red = entry->red << 8;                                  if (xormask[0] || xormask[1] || xormask[2])
699                          xc.green = entry->green << 8;                                  {
700                          xc.blue = entry->blue << 8;                                          *pcursor |= (~(*andmask) & nextbit);
701                          XAllocColor(display,                                          *pmask |= nextbit;
702                                      DefaultColormap(display,                                  }
703                                                      DefaultScreen(display)),                                  else
704                                      &xc);                                  {
705                          /* XXX Check return value */                                          *pcursor |= ((*andmask) & nextbit);
706                          nc[i] = xc.pixel;                                          *pmask |= (~(*andmask) & nextbit);
707                                    }
708    
709                                    xormask += 3;
710                            }
711    
712                            andmask++;
713                            pcursor++;
714                            pmask++;
715                  }                  }
                 return nc;  
716          }          }
717          else  
718            fg.red = fg.blue = fg.green = 0xffff;
719            bg.red = bg.blue = bg.green = 0x0000;
720            fg.flags = bg.flags = DoRed | DoBlue | DoGreen;
721    
722            cursorglyph = ui_create_glyph(width, height, cursor);
723            maskglyph = ui_create_glyph(width, height, mask);
724    
725            xcursor =
726                    XCreatePixmapCursor(display, (Pixmap) cursorglyph,
727                                        (Pixmap) maskglyph, &fg, &bg, x, y);
728    
729            ui_destroy_glyph(maskglyph);
730            ui_destroy_glyph(cursorglyph);
731            xfree(mask);
732            xfree(cursor);
733            return (HCURSOR) xcursor;
734    }
735    
736    void
737    ui_set_cursor(HCURSOR cursor)
738    {
739            XDefineCursor(display, wnd, (Cursor) cursor);
740    }
741    
742    void
743    ui_destroy_cursor(HCURSOR cursor)
744    {
745            XFreeCursor(display, (Cursor) cursor);
746    }
747    
748    #define MAKE_XCOLOR(xc,c) \
749                    (xc)->red   = ((c)->red   << 8) | (c)->red; \
750                    (xc)->green = ((c)->green << 8) | (c)->green; \
751                    (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \
752                    (xc)->flags = DoRed | DoGreen | DoBlue;
753    
754    HCOLOURMAP
755    ui_create_colourmap(COLOURMAP * colours)
756    {
757            COLOURENTRY *entry;
758            int i, ncolours = colours->ncolours;
759    
760            if (owncolmap)
761          {          {
                 COLOURENTRY *entry;  
762                  XColor *xcolours, *xentry;                  XColor *xcolours, *xentry;
763                  Colormap map;                  Colormap map;
764                  int i, ncolours = colours->ncolours;  
765                  xcolours = xmalloc(sizeof(XColor) * ncolours);                  xcolours = xmalloc(sizeof(XColor) * ncolours);
766                  for (i = 0; i < ncolours; i++)                  for (i = 0; i < ncolours; i++)
767                  {                  {
768                          entry = &colours->colours[i];                          entry = &colours->colours[i];
769                          xentry = &xcolours[i];                          xentry = &xcolours[i];
   
770                          xentry->pixel = i;                          xentry->pixel = i;
771                          xentry->red = entry->red << 8;                          MAKE_XCOLOR(xentry, entry);
                         xentry->blue = entry->blue << 8;  
                         xentry->green = entry->green << 8;  
                         xentry->flags = DoRed | DoBlue | DoGreen;  
772                  }                  }
773    
774                  map = XCreateColormap(display, wnd, visual, AllocAll);                  map = XCreateColormap(display, wnd, visual, AllocAll);
# Line 607  ui_create_colourmap(COLOURMAP *colours) Line 777  ui_create_colourmap(COLOURMAP *colours)
777                  xfree(xcolours);                  xfree(xcolours);
778                  return (HCOLOURMAP) map;                  return (HCOLOURMAP) map;
779          }          }
780            else
781            {
782                    uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
783                    XColor xentry;
784                    uint32 colour;
785    
786                    for (i = 0; i < ncolours; i++)
787                    {
788                            entry = &colours->colours[i];
789                            MAKE_XCOLOR(&xentry, entry);
790    
791                            if (XAllocColor(display, xcolmap, &xentry) != 0)
792                                    colour = xentry.pixel;
793                            else
794                                    colour = white;
795    
796                            /* byte swap here to make translate_image faster */
797                            map[i] = translate_colour(colour);
798                    }
799    
800                    return map;
801            }
802  }  }
803    
804  void  void
805  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
806  {  {
807          XFreeColormap(display, (Colormap) map);          if (owncolmap)
808                    XFreeColormap(display, (Colormap) map);
809            else
810                    xfree(map);
811  }  }
812    
813  void  void
814  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
815  {  {
816            if (owncolmap)
         /* XXX, change values of all pixels on the screen if the new colmap  
          * doesn't have the same values as the old one? */  
         if (!private_colormap)  
                 colmap = map;  
         else  
         {  
817                  XSetWindowColormap(display, wnd, (Colormap) map);                  XSetWindowColormap(display, wnd, (Colormap) map);
818                  if (fullscreen)          else
819                          XInstallColormap(display, (Colormap) map);                  colmap = map;
         }  
820  }  }
821    
822  void  void
# Line 665  void Line 853  void
853  ui_destblt(uint8 opcode,  ui_destblt(uint8 opcode,
854             /* dest */ int x, int y, int cx, int cy)             /* dest */ int x, int y, int cx, int cy)
855  {  {
856          xwin_set_function(opcode);          SET_FUNCTION(opcode);
857            FILL_RECTANGLE(x, y, cx, cy);
858          XFillRectangle(display, wnd, gc, x, y, cx, cy);          RESET_FUNCTION(opcode);
859  }  }
860    
861  void  void
862  ui_patblt(uint8 opcode,  ui_patblt(uint8 opcode,
863            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
864            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
865  {  {
         Display *dpy = display;  
866          Pixmap fill;          Pixmap fill;
867          uint8 i, ipattern[8];          uint8 i, ipattern[8];
868    
869          xwin_set_function(opcode);          SET_FUNCTION(opcode);
870    
871          switch (brush->style)          switch (brush->style)
872          {          {
873                  case 0: /* Solid */                  case 0: /* Solid */
874                          XSetForeground(dpy, gc, Ctrans(fgcolour));                          SET_FOREGROUND(fgcolour);
875                          XFillRectangle(dpy, wnd, gc, x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
876                          break;                          break;
877    
878                  case 3: /* Pattern */                  case 3: /* Pattern */
879                          for (i = 0; i != 8; i++)                          for (i = 0; i != 8; i++)
880                                  ipattern[i] = ~brush->pattern[i];                                  ipattern[7 - i] = brush->pattern[i];
881                          fill = (Pixmap) ui_create_glyph(8, 8, ipattern);                          fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
882    
883                          XSetForeground(dpy, gc, Ctrans(fgcolour));                          SET_FOREGROUND(bgcolour);
884                          XSetBackground(dpy, gc, Ctrans(bgcolour));                          SET_BACKGROUND(fgcolour);
885                          XSetFillStyle(dpy, gc, FillOpaqueStippled);                          XSetFillStyle(display, gc, FillOpaqueStippled);
886                          XSetStipple(dpy, gc, fill);                          XSetStipple(display, gc, fill);
887                            XSetTSOrigin(display, gc, brush->xorigin, brush->yorigin);
888    
889                          XFillRectangle(dpy, wnd, gc, x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
890    
891                          XSetFillStyle(dpy, gc, FillSolid);                          XSetFillStyle(display, gc, FillSolid);
892                            XSetTSOrigin(display, gc, 0, 0);
893                          ui_destroy_glyph((HGLYPH) fill);                          ui_destroy_glyph((HGLYPH) fill);
894                          break;                          break;
895    
896                  default:                  default:
897                          NOTIMP("brush %d\n", brush->style);                          unimpl("brush %d\n", brush->style);
898          }          }
899    
900            RESET_FUNCTION(opcode);
901  }  }
902    
903  void  void
# Line 714  ui_screenblt(uint8 opcode, Line 905  ui_screenblt(uint8 opcode,
905               /* dest */ int x, int y, int cx, int cy,               /* dest */ int x, int y, int cx, int cy,
906               /* src */ int srcx, int srcy)               /* src */ int srcx, int srcy)
907  {  {
908          xwin_set_function(opcode);          SET_FUNCTION(opcode);
   
909          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
910            if (ownbackstore)
911                    XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
912            RESET_FUNCTION(opcode);
913  }  }
914    
915  void  void
# Line 724  ui_memblt(uint8 opcode, Line 917  ui_memblt(uint8 opcode,
917            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
918            /* src */ HBITMAP src, int srcx, int srcy)            /* src */ HBITMAP src, int srcx, int srcy)
919  {  {
920          xwin_set_function(opcode);          SET_FUNCTION(opcode);
   
921          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
922            if (ownbackstore)
923                    XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
924            RESET_FUNCTION(opcode);
925  }  }
926    
927  void  void
928  ui_triblt(uint8 opcode,  ui_triblt(uint8 opcode,
929            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
930            /* src */ HBITMAP src, int srcx, int srcy,            /* src */ HBITMAP src, int srcx, int srcy,
931            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
932  {  {
933          /* This is potentially difficult to do in general. Until someone          /* This is potentially difficult to do in general. Until someone
934             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 742  ui_triblt(uint8 opcode, Line 937  ui_triblt(uint8 opcode,
937          {          {
938                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
939                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
940                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
941                          break;                          break;
942    
943                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
944                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
945                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
946                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
947                          break;                          break;
948    
949                  case 0xc0:                  case 0xc0:      /* PSa */
950                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
951                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
952                          break;                          break;
953    
954                  default:                  default:
955                          NOTIMP("triblt 0x%x\n", opcode);                          unimpl("triblt 0x%x\n", opcode);
956                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
957          }          }
958  }  }
# Line 769  ui_triblt(uint8 opcode, Line 960  ui_triblt(uint8 opcode,
960  void  void
961  ui_line(uint8 opcode,  ui_line(uint8 opcode,
962          /* dest */ int startx, int starty, int endx, int endy,          /* dest */ int startx, int starty, int endx, int endy,
963          /* pen */ PEN *pen)          /* pen */ PEN * pen)
964  {  {
965          xwin_set_function(opcode);          SET_FUNCTION(opcode);
966            SET_FOREGROUND(pen->colour);
         XSetForeground(display, gc, Ctrans(pen->colour));  
967          XDrawLine(display, wnd, gc, startx, starty, endx, endy);          XDrawLine(display, wnd, gc, startx, starty, endx, endy);
968            if (ownbackstore)
969                    XDrawLine(display, backstore, gc, startx, starty, endx, endy);
970            RESET_FUNCTION(opcode);
971  }  }
972    
973  void  void
# Line 782  ui_rect( Line 975  ui_rect(
975                 /* dest */ int x, int y, int cx, int cy,                 /* dest */ int x, int y, int cx, int cy,
976                 /* brush */ int colour)                 /* brush */ int colour)
977  {  {
978          xwin_set_function(ROP2_COPY);          SET_FOREGROUND(colour);
979            FILL_RECTANGLE(x, y, cx, cy);
         XSetForeground(display, gc, Ctrans(colour));  
         XFillRectangle(display, wnd, gc, x, y, cx, cy);  
980  }  }
981    
982  void  void
983  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
984                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
985                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
986                int fgcolour)                int bgcolour, int fgcolour)
987  {  {
988          Pixmap pixmap = (Pixmap) glyph;          SET_FOREGROUND(fgcolour);
989            SET_BACKGROUND(bgcolour);
         xwin_set_function(ROP2_COPY);  
   
   
         XSetForeground(display, gc, Ctrans(fgcolour));  
         switch (mixmode)  
         {  
                 case MIX_TRANSPARENT:  
                         XSetStipple(display, gc, pixmap);  
                         XSetFillStyle(display, gc, FillStippled);  
                         XSetTSOrigin(display, gc, x, y);  
                         XFillRectangle(display, wnd, gc, x, y, cx, cy);  
                         XSetFillStyle(display, gc, FillSolid);  
                         break;  
   
                 case MIX_OPAQUE:  
                         XSetBackground(display, gc, Ctrans(bgcolour));  
 /*      XCopyPlane (display, pixmap, back_pixmap, back_gc, srcx, srcy, cx, cy, x, y, 1); */  
                         XSetStipple(display, gc, pixmap);  
                         XSetFillStyle(display, gc, FillOpaqueStippled);  
                         XSetTSOrigin(display, gc, x, y);  
                         XFillRectangle(display, wnd, gc, x, y, cx, cy);  
                         XSetFillStyle(display, gc, FillSolid);  
                         break;  
990    
991                  default:          XSetFillStyle(display, gc,
992                          NOTIMP("mix %d\n", mixmode);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
993          }          XSetStipple(display, gc, (Pixmap) glyph);
994            XSetTSOrigin(display, gc, x, y);
995    
996            FILL_RECTANGLE(x, y, cx, cy);
997    
998            XSetFillStyle(display, gc, FillSolid);
999    }
1000    
1001    #define DO_GLYPH(ttext,idx) \
1002    {\
1003      glyph = cache_get_font (font, ttext[idx]);\
1004      if (!(flags & TEXT2_IMPLICIT_X))\
1005        {\
1006          xyoffset = ttext[++idx];\
1007          if ((xyoffset & 0x80))\
1008            {\
1009              if (flags & TEXT2_VERTICAL) \
1010                y += ttext[idx+1] | (ttext[idx+2] << 8);\
1011              else\
1012                x += ttext[idx+1] | (ttext[idx+2] << 8);\
1013              idx += 2;\
1014            }\
1015          else\
1016            {\
1017              if (flags & TEXT2_VERTICAL) \
1018                y += xyoffset;\
1019              else\
1020                x += xyoffset;\
1021            }\
1022        }\
1023      if (glyph != NULL)\
1024        {\
1025          ui_draw_glyph (mixmode, x + (short) glyph->offset,\
1026                         y + (short) glyph->baseline,\
1027                         glyph->width, glyph->height,\
1028                         glyph->pixmap, 0, 0, bgcolour, fgcolour);\
1029          if (flags & TEXT2_IMPLICIT_X)\
1030            x += glyph->width;\
1031        }\
1032  }  }
1033    
1034  void  void
1035  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,
1036               int clipx, int clipy, int clipcx, int clipcy,               int clipx, int clipy, int clipcx, int clipcy,
1037               int boxx, int boxy, int boxcx, int boxcy,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1038               int bgcolour, int fgcolour, uint8 *text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1039  {  {
1040          FONTGLYPH *glyph;          FONTGLYPH *glyph;
1041          int i, xyoffset;          int i, j, xyoffset;
1042            DATABLOB *entry;
1043    
1044          xwin_set_function(ROP2_COPY);          SET_FOREGROUND(bgcolour);
         XSetForeground(display, gc, Ctrans(bgcolour));  
1045    
1046          if (boxcx > 1)          if (boxcx > 1)
1047                  XFillRectangle(display, wnd, gc, boxx, boxy, boxcx, boxcy);          {
1048                    FILL_RECTANGLE(boxx, boxy, boxcx, boxcy);
1049            }
1050          else if (mixmode == MIX_OPAQUE)          else if (mixmode == MIX_OPAQUE)
1051                  XFillRectangle(display, wnd, gc, clipx, clipy, clipcx, clipcy);          {
1052                    FILL_RECTANGLE(clipx, clipy, clipcx, clipcy);
1053            }
1054    
1055          /* Paint text, character by character */          /* Paint text, character by character */
1056          for (i = 0; i < length; i++)          for (i = 0; i < length;)
1057          {          {
1058                  glyph = cache_get_font(font, text[i]);                  switch (text[i])
   
                 if (!(flags & TEXT2_IMPLICIT_X))  
   
1059                  {                  {
1060                          xyoffset = text[++i];                          case 0xff:
1061                          if ((xyoffset & 0x80))                                  if (i + 2 < length)
1062                          {                                          cache_put_text(text[i + 1], text, text[i + 2]);
                                 if (flags & 0x04)       /* vertical text */  
                                         y += text[++i] | (text[++i] << 8);  
                                 else  
                                         x += text[++i] | (text[++i] << 8);  
                         }  
                         else  
                         {  
                                 if (flags & 0x04)       /* vertical text */  
                                         y += xyoffset;  
1063                                  else                                  else
1064                                          x += xyoffset;                                  {
1065                          }                                          error("this shouldn't be happening\n");
1066                                            break;
1067                                    }
1068                                    /* this will move pointer from start to first character after FF command */
1069                                    length -= i + 3;
1070                                    text = &(text[i + 3]);
1071                                    i = 0;
1072                                    break;
1073    
1074                  }                          case 0xfe:
1075                  if (glyph != NULL)                                  entry = cache_get_text(text[i + 1]);
1076                  {                                  if (entry != NULL)
1077                          ui_draw_glyph(mixmode, x + (short) glyph->offset,                                  {
1078                                        y + (short) glyph->baseline,                                          if ((((uint8 *) (entry->data))[1] ==
1079                                        glyph->width, glyph->height,                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
1080                                        glyph->pixmap, 0, 0,                                          {
1081                                        bgcolour, fgcolour);                                                  if (flags & TEXT2_VERTICAL)
1082                                                            y += text[i + 2];
1083                                                    else
1084                                                            x += text[i + 2];
1085                                            }
1086                                            if (i + 2 < length)
1087                                                    i += 3;
1088                                            else
1089                                                    i += 2;
1090                                            length -= i;
1091                                            /* this will move pointer from start to first character after FE command */
1092                                            text = &(text[i]);
1093                                            i = 0;
1094                                            for (j = 0; j < entry->size; j++)
1095                                                    DO_GLYPH(((uint8 *) (entry->data)), j);
1096                                    }
1097                                    break;
1098    
1099                          if (flags & TEXT2_IMPLICIT_X)                          default:
1100                                  x += glyph->width;                                  DO_GLYPH(text, i);
1101                                    i++;
1102                                    break;
1103                  }                  }
1104          }          }
1105    
1106    
1107  }  }
1108    
1109  void  void
# Line 887  ui_desktop_save(uint32 offset, int x, in Line 1112  ui_desktop_save(uint32 offset, int x, in
1112          Pixmap pix;          Pixmap pix;
1113          XImage *image;          XImage *image;
1114    
1115          pix = XCreatePixmap(display, wnd, cx, cy, depth);          if (ownbackstore)
1116          xwin_set_function(ROP2_COPY);          {
1117                    image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
1118          XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);          }
1119          image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);          else
1120            {
1121                    pix = XCreatePixmap(display, wnd, cx, cy, depth);
1122                    XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
1123                    image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
1124                    XFreePixmap(display, pix);
1125            }
1126    
1127          offset *= bpp/8;          offset *= bpp / 8;
1128          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8, (uint8 *) image->data);
                           bpp/8, image->data);  
1129    
1130          XDestroyImage(image);          XDestroyImage(image);
         XFreePixmap(display, pix);  
1131  }  }
1132    
1133  void  void
# Line 907  ui_desktop_restore(uint32 offset, int x, Line 1136  ui_desktop_restore(uint32 offset, int x,
1136          XImage *image;          XImage *image;
1137          uint8 *data;          uint8 *data;
1138    
1139          offset *= bpp/8;          offset *= bpp / 8;
1140          data = cache_get_desktop(offset, cx, cy, bpp/8);          data = cache_get_desktop(offset, cx, cy, bpp / 8);
1141          if (data == NULL)          if (data == NULL)
1142                  return;                  return;
         image =  
                 XCreateImage(display, visual,  
                              depth, ZPixmap,  
                              0, data, cx, cy, BitmapPad(display),  
                              cx * bpp/8);  
         xwin_set_function(ROP2_COPY);  
         XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);  
         XFree(image);  
 }  
1143    
1144  /* unroll defines, used to make the loops a bit more readable... */          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1145  #define unroll8Expr(uexp) uexp uexp uexp uexp uexp uexp uexp uexp                               (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
 #define unroll8Lefts(uexp) case 7: uexp \  
         case 6: uexp \  
         case 5: uexp \  
         case 4: uexp \  
         case 3: uexp \  
         case 2: uexp \  
         case 1: uexp  
1146    
1147  static uint8 *          if (ownbackstore)
 translate(int width, int height, uint8 *data)  
 {  
         uint32 i;  
         uint32 size = width * height;  
         uint8 *d2 = xmalloc(size * bpp/8);  
         uint8 *d3 = d2;  
         uint32 pix;  
         i = (size & ~0x7);  
   
         /* XXX: where are the bits swapped??? */  
 #ifdef L_ENDIAN                 /* little-endian */  
         /* big-endian screen */  
         if (screen_msbfirst)  
1148          {          {
1149                  switch (bpp)                  XPutImage(display, backstore, gc, image, 0, 0, x, y, cx, cy);
1150                  {                  XCopyArea(display, backstore, wnd, gc, x, y, cx, cy, x, y);
                         case 32:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix >> 24;  
                                                     *d3++ = pix >> 16;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix;) i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      24;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix;)}  
                                 break;  
                         case 24:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix >> 16;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix;) i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix;)}  
                                 break;  
                         case 16:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix;) i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix;)}  
                                 break;  
                         case 8:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;)}  
                                 break;  
                 }  
1151          }          }
1152          else          else
         {                       /* little-endian screen */  
                 switch (bpp)  
                 {  
                         case 32:  
                                 while (i)  
                                 {  
                                         unroll8Expr(*((uint32 *) d3) =  
                                                     colmap[*data++];  
                                                     d3 += sizeof(uint32);  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(*  
                                                                      ((uint32  
                                                                        *) d3)  
 = colmap[*data++];  
 d3 += sizeof(uint32);  
                                         )}  
                                 break;  
                         case 24:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix >> 16;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;)}  
                                 break;  
                         case 16:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                         )}  
                                 break;  
                         case 8:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;)}  
                 }  
         }  
   
 #else /* bigendian-compiled */  
         if (screen_msbfirst)  
1153          {          {
1154                  /* big-endian screen */                  XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy);
                 switch (bpp)  
                 {  
                         case 32:  
                                 while (i)  
                                 {  
                                         unroll8Expr(*((uint32 *) d3) =  
                                                     colmap[*data++];  
                                                     d3 += sizeof(uint32);  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(*  
                                                                      ((uint32  
                                                                        *) d3)  
 = colmap[*data++];  
 d3 += sizeof(uint32);  
                                         )}  
                                 break;  
                         case 24:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix >> 16;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;)}  
                                 break;  
                         case 16:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                         )}  
                                 break;  
                         case 8:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;)}  
                 }  
         }  
         else  
         {  
                 /* little-endian screen */  
                 switch (bpp)  
                 {  
                         case 32:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix >> 16;  
                                                     *d3++ = pix >> 24;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      24;)}  
                                 break;  
                         case 24:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                     *d3++ = pix >> 16;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                                                      *d3++ =  
                                                                      pix >>  
                                                                      16;)}  
                                 break;  
                         case 16:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                     *d3++ = pix >> 8;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;  
                                                                      *d3++ =  
                                                                      pix >> 8;  
                                         )}  
                                 break;  
                         case 8:  
                                 while (i)  
                                 {  
                                         unroll8Expr(pix = colmap[*data++];  
                                                     *d3++ = pix;  
                                                 )i -= 8;  
                                 }  
                                 i = (size & 0x7);  
                                 if (i != 0)  
                                         switch (i)  
                                         {  
                                                         unroll8Lefts(pix =  
                                                                      colmap  
                                                                      [*data++];  
                                                                      *d3++ =  
                                                                      pix;)}  
                 }  
1155          }          }
 #endif  
1156    
1157          return d2;          XFree(image);
1158  }  }
Legend:
Removed from v.28  
changed lines
  Added in v.84
  ViewVC Help
Powered by ViewVC 1.1.26