/[rdesktop]/sourceforge.net/trunk/rdesktop/xwin.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/xwin.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 64 by astrand, Thu Jul 18 16:38:31 2002 UTC revision 208 by matthewc, Fri Sep 27 01:04:34 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 Window System     User interface services - X Window System
4     Copyright (C) Matthew Chapman 1999-2001     Copyright (C) Matthew Chapman 1999-2002
5    
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 20  Line 20 
20    
21  #include <X11/Xlib.h>  #include <X11/Xlib.h>
22  #include <X11/Xutil.h>  #include <X11/Xutil.h>
 #include <X11/XKBlib.h>  
23  #include <time.h>  #include <time.h>
24  #include <errno.h>  #include <errno.h>
25  #include "rdesktop.h"  #include "rdesktop.h"
26    
 extern char keymapname[16];  
 extern int keylayout;  
27  extern int width;  extern int width;
28  extern int height;  extern int height;
29  extern BOOL sendmotion;  extern BOOL sendmotion;
30  extern BOOL fullscreen;  extern BOOL fullscreen;
31    extern BOOL grab_keyboard;
32    extern char title[];
33    BOOL enable_compose = False;
34    
35  Display *display;  Display *display;
 XkbDescPtr xkb;  
36  static int x_socket;  static int x_socket;
37    static Screen *screen;
38  static Window wnd;  static Window wnd;
39  static GC gc;  static GC gc;
40  static Visual *visual;  static Visual *visual;
41  static int depth;  static int depth;
42  static int bpp;  static int bpp;
43    static XIM IM;
44    static XIC IC;
45    static XModifierKeymap *mod_map;
46    static Cursor current_cursor;
47    
48  /* endianness */  /* endianness */
49  static BOOL host_be;  static BOOL host_be;
# Line 49  static BOOL xserver_be; Line 53  static BOOL xserver_be;
53  static BOOL ownbackstore;  static BOOL ownbackstore;
54  static Pixmap backstore;  static Pixmap backstore;
55    
 /* needed to keep track of the modifiers */  
 static unsigned int numlock_modifier_mask = 0;  
 static unsigned int key_down_state = 0;  
   
   
 #define DShift1Mask   (1<<0)  
 #define DLockMask     (1<<1)  
 #define DControl1Mask (1<<2)  
 #define DMod1Mask     (1<<3)  
 #define DMod2Mask     (1<<4)  
 #define DMod3Mask     (1<<5)  
 #define DMod4Mask     (1<<6)  
 #define DMod5Mask     (1<<7)  
 #define DShift2Mask   (1<<8)  
 #define DControl2Mask (1<<9)  
 #define DNumLockMask  (1<<10)  
   
56  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
57  { \  { \
58          XFillRectangle(display, wnd, gc, x, y, cx, cy); \          XFillRectangle(display, wnd, gc, x, y, cx, cy); \
# Line 74  static unsigned int key_down_state = 0; Line 61  static unsigned int key_down_state = 0;
61  }  }
62    
63  /* colour maps */  /* colour maps */
 static BOOL owncolmap;  
64  static Colormap xcolmap;  static Colormap xcolmap;
 static uint32 white;  
65  static uint32 *colmap;  static uint32 *colmap;
66    
67  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define SET_FOREGROUND(col)     XSetForeground(display, gc, translate_colour(colmap[col]));
68  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));  #define SET_BACKGROUND(col)     XSetBackground(display, gc, translate_colour(colmap[col]));
 #define SET_BACKGROUND(col)     XSetBackground(display, gc, TRANSLATE(col));  
69    
70  static int rop2_map[] = {  static int rop2_map[] = {
71          GXclear,                /* 0 */          GXclear,                /* 0 */
# Line 105  static int rop2_map[] = { Line 89  static int rop2_map[] = {
89  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }
90  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
91    
 void xwin_get_numlock_mask();  
 void xwin_mod_update(uint32 state, uint32 ev_time);  
 void xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode);  
 void xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode);  
   
92  static void  static void
93  translate8(uint8 * data, uint8 * out, uint8 * end)  translate8(uint8 * data, uint8 * out, uint8 * end)
94  {  {
# Line 205  translate_colour(uint32 colour) Line 184  translate_colour(uint32 colour)
184  }  }
185    
186  BOOL  BOOL
187  ui_create_window(char *title)  get_key_state(uint32 keysym, unsigned int state)
188  {  {
189          XSetWindowAttributes attribs;          int modifierpos, key, keysymMask = 0;
190          XClassHint *classhints;          int offset;
         XSizeHints *sizehints;  
         unsigned long input_mask;  
         XPixmapFormatValues *pfm;  
         Screen *screen;  
         uint16 test;  
         int i;  
191    
192          int xkb_minor, xkb_major;          KeyCode keycode = XKeysymToKeycode(display, keysym);
         int xkb_event, xkb_error, xkb_reason;  
193    
194          /* compare compiletime libs with runtime libs. */          if (keycode == NoSymbol)
         xkb_major = XkbMajorVersion;  
         xkb_minor = XkbMinorVersion;  
         if (XkbLibraryVersion(&xkb_major, &xkb_minor) == False)  
         {  
                 error("please re-compile rdesktop\ncompile time version of xkb is not compatible with\nyour runtime version of the library\n");  
195                  return False;                  return False;
         }  
196    
197            for (modifierpos = 0; modifierpos < 8; modifierpos++)
         display =  
                 XkbOpenDisplay(NULL, &xkb_event, &xkb_error, &xkb_major,  
                                &xkb_minor, &xkb_reason);  
         switch (xkb_reason)  
198          {          {
199                  case XkbOD_BadLibraryVersion:                  offset = mod_map->max_keypermod * modifierpos;
200                          error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");  
201                          break;                  for (key = 0; key < mod_map->max_keypermod; key++)
202                  case XkbOD_ConnectionRefused:                  {
203                          error("XkbOD_ConnectionRefused\n");                          if (mod_map->modifiermap[offset + key] == keycode)
204                          break;                                  keysymMask |= 1 << modifierpos;
205                  case XkbOD_BadServerVersion:                  }
                         error("XkbOD_BadServerVersion\n");  
                         break;  
                 case XkbOD_NonXkbServer:  
                         error("XkbOD_NonXkbServer: XKB extension not present in server\nupdate your X server.\n");  
                         break;  
                 case XkbOD_Success:  
                         DEBUG("XkbOD_Success: Connection established with display\n");  
                         break;  
206          }          }
207    
208            return (state & keysymMask) ? True : False;
209    }
210    
211    BOOL
212    ui_init(void)
213    {
214            XPixmapFormatValues *pfm;
215            uint16 test;
216            int i;
217    
218            display = XOpenDisplay(NULL);
219          if (display == NULL)          if (display == NULL)
220          {          {
221                  error("Failed to open display\n");                  error("Failed to open display\n");
# Line 269  ui_create_window(char *title) Line 234  ui_create_window(char *title)
234                     desirable, e.g. 24 bits->32 bits. */                     desirable, e.g. 24 bits->32 bits. */
235                  while (i--)                  while (i--)
236                  {                  {
237                          if ((pfm[i].depth == depth)                          if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
                             && (pfm[i].bits_per_pixel > bpp))  
238                          {                          {
239                                  bpp = pfm[i].bits_per_pixel;                                  bpp = pfm[i].bits_per_pixel;
240                          }                          }
# Line 285  ui_create_window(char *title) Line 249  ui_create_window(char *title)
249                  return False;                  return False;
250          }          }
251    
252          if (depth <= 8)          xcolmap = DefaultColormapOfScreen(screen);
253                  owncolmap = True;          gc = XCreateGC(display, RootWindowOfScreen(screen), 0, NULL);
254          else  
255                  xcolmap = DefaultColormapOfScreen(screen);          if (DoesBackingStore(screen) != Always)
256                    ownbackstore = True;
257    
258          test = 1;          test = 1;
259          host_be = !(BOOL) (*(uint8 *) (&test));          host_be = !(BOOL) (*(uint8 *) (&test));
260          xserver_be = (ImageByteOrder(display) == MSBFirst);          xserver_be = (ImageByteOrder(display) == MSBFirst);
261    
         white = WhitePixelOfScreen(screen);  
         attribs.background_pixel = BlackPixelOfScreen(screen);  
         attribs.backing_store = DoesBackingStore(screen);  
   
         if (attribs.backing_store == NotUseful)  
                 ownbackstore = True;  
   
262          if (fullscreen)          if (fullscreen)
263          {          {
                 attribs.override_redirect = True;  
264                  width = WidthOfScreen(screen);                  width = WidthOfScreen(screen);
265                  height = HeightOfScreen(screen);                  height = HeightOfScreen(screen);
266          }          }
267          else  
268            /* make sure width is a multiple of 4 */
269            width = (width + 3) & ~3;
270    
271            if (ownbackstore)
272          {          {
273                  attribs.override_redirect = False;                  backstore =
274                            XCreatePixmap(display, RootWindowOfScreen(screen), width, height, depth);
275    
276                    /* clear to prevent rubbish being exposed at startup */
277                    XSetForeground(display, gc, BlackPixelOfScreen(screen));
278                    XFillRectangle(display, backstore, gc, 0, 0, width, height);
279          }          }
280    
281          width = (width + 3) & ~3;       /* make width a multiple of 32 bits */          mod_map = XGetModifierMapping(display);
282    
283            if (enable_compose)
284                    IM = XOpenIM(display, NULL, NULL, NULL);
285    
286            xkeymap_init();
287            return True;
288    }
289    
290    void
291    ui_deinit(void)
292    {
293            if (IM != NULL)
294                    XCloseIM(IM);
295    
296          wnd = XCreateWindow(display, RootWindowOfScreen(screen),          XFreeModifiermap(mod_map);
297                              0, 0, width, height, 0, CopyFromParent,  
298                              InputOutput, CopyFromParent,          if (ownbackstore)
299                              CWBackingStore | CWBackPixel | CWOverrideRedirect,                  XFreePixmap(display, backstore);
300                              &attribs);  
301            XFreeGC(display, gc);
302            XCloseDisplay(display);
303            display = NULL;
304    }
305    
306    BOOL
307    ui_create_window(void)
308    {
309            XSetWindowAttributes attribs;
310            XClassHint *classhints;
311            XSizeHints *sizehints;
312            int wndwidth, wndheight;
313            long input_mask, ic_input_mask;
314            XEvent xevent;
315    
316            wndwidth = fullscreen ? WidthOfScreen(screen) : width;
317            wndheight = fullscreen ? HeightOfScreen(screen) : height;
318    
319            attribs.background_pixel = BlackPixelOfScreen(screen);
320            attribs.backing_store = ownbackstore ? NotUseful : Always;
321            attribs.override_redirect = fullscreen;
322    
323            wnd = XCreateWindow(display, RootWindowOfScreen(screen), 0, 0, wndwidth, wndheight,
324                                0, CopyFromParent, InputOutput, CopyFromParent,
325                                CWBackPixel | CWBackingStore | CWOverrideRedirect, &attribs);
326    
327          XStoreName(display, wnd, title);          XStoreName(display, wnd, title);
328    
# Line 340  ui_create_window(char *title) Line 344  ui_create_window(char *title)
344                  XFree(sizehints);                  XFree(sizehints);
345          }          }
346    
347          xkeymap_init();          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
348                    VisibilityChangeMask | FocusChangeMask;
349    
         input_mask = KeyPressMask | KeyReleaseMask |  
                 ButtonPressMask | ButtonReleaseMask |  
                 EnterWindowMask | LeaveWindowMask;  
350          if (sendmotion)          if (sendmotion)
351                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
   
352          if (ownbackstore)          if (ownbackstore)
353                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
354    
355          XSelectInput(display, wnd, input_mask);          if (IM != NULL)
356          gc = XCreateGC(display, wnd, 0, NULL);          {
357                    IC = XCreateIC(IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
358                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
359    
360          if (ownbackstore)                  if ((IC != NULL)
361                  backstore = XCreatePixmap(display, wnd, width, height, depth);                      && (XGetICValues(IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
362                            input_mask |= ic_input_mask;
363            }
364    
365            XSelectInput(display, wnd, input_mask);
366          XMapWindow(display, wnd);          XMapWindow(display, wnd);
367    
368          /* TODO: error texts... make them friendly. */          /* wait for VisibilityNotify */
369          xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);          do
         if ((int) xkb == BadAlloc || xkb == NULL)  
         {  
                 error("XkbGetKeyboard failed.\n");  
                 exit(0);  
         }  
   
         /* TODO: error texts... make them friendly. */  
         if (XkbSelectEvents  
             (display, xkb->device_spec, XkbAllEventsMask,  
              XkbAllEventsMask) == False)  
370          {          {
371                  error("XkbSelectEvents failed.\n");                  XMaskEvent(display, VisibilityChangeMask, &xevent);
                 exit(0);  
372          }          }
373            while (xevent.type != VisibilityNotify);
374    
375          xwin_get_numlock_mask();          if (fullscreen)
376                    XSetInputFocus(display, wnd, RevertToPointerRoot, CurrentTime);
377    
378          return True;          return True;
379  }  }
380    
381  void  void
382  xwin_get_numlock_mask()  ui_destroy_window(void)
383  {  {
384          KeyCode numlockcode;          if (IC != NULL)
385          KeyCode *keycode;                  XDestroyIC(IC);
         XModifierKeymap *modmap;  
         int i, j;  
   
         /* Find out if numlock is already defined as a modifier key, and if so where */  
         numlockcode = XKeysymToKeycode(display, 0xFF7F);        /* XF_Num_Lock = 0xFF7F */  
         if (numlockcode)  
         {  
                 modmap = XGetModifierMapping(display);  
                 if (modmap)  
                 {  
                         keycode = modmap->modifiermap;  
                         for (i = 0; i < 8; i++)  
                                 for (j = modmap->max_keypermod; j--;)  
                                 {  
                                         if (*keycode == numlockcode)  
                                         {  
                                                 numlock_modifier_mask =  
                                                         (1 << i);  
                                                 i = 8;  
                                                 break;  
                                         }  
                                         keycode++;  
                                 }  
                         if (!numlock_modifier_mask)  
                         {  
                                 modmap->modifiermap[7 *  
                                                     modmap->max_keypermod] =  
                                         numlockcode;  
                                 if (XSetModifierMapping(display, modmap) ==  
                                     MappingSuccess)  
                                         numlock_modifier_mask = (1 << 7);  
                                 else  
                                         printf("XSetModifierMapping failed!\n");  
                         }  
                         XFreeModifiermap(modmap);  
                 }  
         }  
   
         if (!numlock_modifier_mask)  
                 printf("WARNING: Failed to get a numlock modifier mapping.\n");  
386    
387            XDestroyWindow(display, wnd);
388  }  }
389    
390  void  void
391  ui_destroy_window()  xwin_toggle_fullscreen(void)
392  {  {
393          if (xkb != NULL)          Pixmap contents = 0;
                 XkbFreeKeyboard(xkb, XkbAllControlsMask, True);  
394    
395          if (ownbackstore)          if (!ownbackstore)
396                  XFreePixmap(display, backstore);          {
397                    /* need to save contents of window */
398                    contents = XCreatePixmap(display, wnd, width, height, depth);
399                    XCopyArea(display, wnd, contents, gc, 0, 0, width, height, 0, 0);
400            }
401    
402          XFreeGC(display, gc);          ui_destroy_window();
403          XDestroyWindow(display, wnd);          fullscreen = !fullscreen;
404          XCloseDisplay(display);          ui_create_window();
405          display = NULL;  
406            XDefineCursor(display, wnd, current_cursor);
407    
408            if (!ownbackstore)
409            {
410                    XCopyArea(display, contents, wnd, gc, 0, 0, width, height, 0, 0);
411                    XFreePixmap(display, contents);
412            }
413  }  }
414    
415    /* Process all events in Xlib queue */
416  static void  static void
417  xwin_process_events()  xwin_process_events(void)
418  {  {
419          XEvent xevent;          XEvent xevent;
   
420          KeySym keysym;          KeySym keysym;
         uint8 scancode;  
421          uint16 button, flags;          uint16 button, flags;
422          uint32 ev_time;          uint32 ev_time;
423          uint32 tmpmods;          key_translation tr;
424            char str[256];
425            Status status;
426            unsigned int state;
427            Window wdummy;
428            int dummy;
429    
430          while (XCheckMaskEvent(display, ~0, &xevent))          while (XPending(display) > 0)
431          {          {
432                  ev_time = time(NULL);                  XNextEvent(display, &xevent);
433    
434                    if ((IC != NULL) && (XFilterEvent(&xevent, None) == True))
435                    {
436                            DEBUG_KBD(("Filtering event\n"));
437                            continue;
438                    }
439    
440                  flags = 0;                  flags = 0;
441    
442                  switch (xevent.type)                  switch (xevent.type)
443                  {                  {
                         case KeyRelease:  
                                 flags = KBD_FLAG_DOWN | KBD_FLAG_UP;  
                                 /* fall through */  
444                          case KeyPress:                          case KeyPress:
445                                  if (XkbTranslateKeyCode                                  if (IC != NULL)
446                                      (xkb, xevent.xkey.keycode,                                          /* Multi_key compatible version */
447                                       xevent.xkey.state, &tmpmods,                                  {
448                                       &keysym) == False)                                          XmbLookupString(IC,
449                                                            (XKeyPressedEvent *) &
450                                                            xevent, str, sizeof(str), &keysym, &status);
451                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
452                                            {
453                                                    error("XmbLookupString failed with status 0x%x\n",
454                                                          status);
455                                                    break;
456                                            }
457                                    }
458                                    else
459                                    {
460                                            /* Plain old XLookupString */
461                                            DEBUG_KBD(("\nNo input context, using XLookupString\n"));
462                                            XLookupString((XKeyEvent *) & xevent,
463                                                          str, sizeof(str), &keysym, NULL);
464                                    }
465    
466                                    DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym)));
467    
468                                    ev_time = time(NULL);
469                                    if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
470                                          break;                                          break;
                                 scancode =  
                                         xkeymap_translate_key(keysym,  
                                                               xevent.xkey.  
                                                               keycode,  
                                                               &flags);  
471    
472                                  if (scancode == 0)                                  tr = xkeymap_translate_key(keysym,
473                                                               xevent.xkey.keycode, xevent.xkey.state);
474    
475                                    if (tr.scancode == 0)
476                                          break;                                          break;
477    
478                                  /* keep track of the modifiers -- needed for stickykeys... */                                  ensure_remote_modifiers(ev_time, tr);
                                 if (xevent.type == KeyPress)  
                                         xwin_mod_press(xevent.xkey.state,  
                                                        ev_time, scancode);  
   
                                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                                flags, scancode, 0);  
   
                                 if (xevent.type == KeyRelease)  
                                         xwin_mod_release(xevent.xkey.state,  
                                                          ev_time, scancode);  
479    
480                                    rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
481                                    break;
482    
483                            case KeyRelease:
484                                    XLookupString((XKeyEvent *) & xevent, str,
485                                                  sizeof(str), &keysym, NULL);
486    
487                                    DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
488                                               get_ksname(keysym)));
489    
490                                    ev_time = time(NULL);
491                                    if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
492                                            break;
493    
494                                    tr = xkeymap_translate_key(keysym,
495                                                               xevent.xkey.keycode, xevent.xkey.state);
496    
497                                    if (tr.scancode == 0)
498                                            break;
499    
500                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
501                                  break;                                  break;
502    
503                          case ButtonPress:                          case ButtonPress:
# Line 499  xwin_process_events() Line 505  xwin_process_events()
505                                  /* fall through */                                  /* fall through */
506    
507                          case ButtonRelease:                          case ButtonRelease:
508                                  button = xkeymap_translate_button(xevent.                                  button = xkeymap_translate_button(xevent.xbutton.button);
                                                                   xbutton.  
                                                                   button);  
509                                  if (button == 0)                                  if (button == 0)
510                                          break;                                          break;
511    
512                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
513                                                 flags | button,                                                 flags | button, xevent.xbutton.x, xevent.xbutton.y);
                                                xevent.xbutton.x,  
                                                xevent.xbutton.y);  
514                                  break;                                  break;
515    
516                          case MotionNotify:                          case MotionNotify:
517                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
518                                                 MOUSE_FLAG_MOVE,                                                 MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
                                                xevent.xmotion.x,  
                                                xevent.xmotion.y);  
519                                  break;                                  break;
520    
521                          case EnterNotify:                          case FocusIn:
522                                  XGrabKeyboard(display, wnd, True,                                  XQueryPointer(display, wnd, &wdummy, &wdummy, &dummy, &dummy, &dummy, &dummy, &state);
523                                                GrabModeAsync, GrabModeAsync,                                  reset_modifier_keys(state);
524                                                CurrentTime);                                  if (grab_keyboard)
525                                            XGrabKeyboard(display, wnd, True,
526                                  xwin_mod_update(xevent.xcrossing.state,                                                        GrabModeAsync, GrabModeAsync, CurrentTime);
                                                 ev_time);  
527                                  break;                                  break;
528    
529                          case LeaveNotify:                          case FocusOut:
530                                  XUngrabKeyboard(display, CurrentTime);                                  if (xevent.xfocus.mode == NotifyWhileGrabbed)
531                                            XUngrabKeyboard(display, CurrentTime);
532                                  break;                                  break;
533    
534                          case Expose:                          case Expose:
# Line 538  xwin_process_events() Line 538  xwin_process_events()
538                                            xevent.xexpose.height,                                            xevent.xexpose.height,
539                                            xevent.xexpose.x, xevent.xexpose.y);                                            xevent.xexpose.x, xevent.xexpose.y);
540                                  break;                                  break;
                 }  
         }  
 }  
   
 void  
 xwin_mod_update(uint32 state, uint32 ev_time)  
 {  
         xwin_mod_press(state, ev_time, 0);  
         xwin_mod_release(state, ev_time, 0);  
 }  
   
 void  
 xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode)  
 {  
         switch (scancode)  
         {  
                 case 0x2a:  
                         key_down_state &= ~DShift1Mask;  
                         break;  
                 case 0x36:  
                         key_down_state &= ~DShift2Mask;  
                         break;  
                 case 0x1d:  
                         key_down_state &= ~DControl1Mask;  
                         break;  
                 case 0x9d:  
                         key_down_state &= ~DControl2Mask;  
                         break;  
                 case 0x38:  
                         key_down_state &= ~DMod1Mask;  
                         break;  
                 case 0xb8:  
                         key_down_state &= ~DMod2Mask;  
                         break;  
         }  
   
         if (!(numlock_modifier_mask & state)  
             && (key_down_state & DNumLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);  
                 key_down_state &= ~DNumLockMask;  
         }  
   
         if (!(LockMask & state) && (key_down_state & DLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);  
                 key_down_state &= ~DLockMask;  
   
         }  
   
   
         if (!(ShiftMask & state) && (key_down_state & DShift1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x2a,  
                                0);  
                 key_down_state &= ~DShift1Mask;  
   
         }  
541    
542          if (!(ControlMask & state) && (key_down_state & DControl1Mask))                          case MappingNotify:
543          {                                  /* Refresh keyboard mapping if it has changed. This is important for
544                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x1d,                                     Xvnc, since it allocates keycodes dynamically */
545                                 0);                                  if (xevent.xmapping.request == MappingKeyboard
546                  key_down_state &= ~DControl1Mask;                                      || xevent.xmapping.request == MappingModifier)
547                                            XRefreshKeyboardMapping(&xevent.xmapping);
         }  
   
         if (!(Mod1Mask & state) && (key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x38,  
                                0);  
                 key_down_state &= ~DMod1Mask;  
   
         }  
   
         if (!(Mod2Mask & state) && (key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0xb8,  
                                0);  
                 key_down_state &= ~DMod2Mask;  
         }  
 }  
   
   
 void  
 xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode)  
 {  
548    
549          switch (scancode)                                  if (xevent.xmapping.request == MappingModifier)
550          {                                  {
551                  case 0x2a:                                          XFreeModifiermap(mod_map);
552                          key_down_state |= DShift1Mask;                                          mod_map = XGetModifierMapping(display);
553                          break;                                  }
554                  case 0x36:                                  break;
                         key_down_state |= DShift2Mask;  
                         break;  
                 case 0x1d:  
                         key_down_state |= DControl1Mask;  
                         break;  
                 case 0x9d:  
                         key_down_state |= DControl2Mask;  
                         break;  
                 case 0x3a:  
                         key_down_state ^= DLockMask;  
                         break;  
                 case 0x45:  
                         key_down_state ^= DNumLockMask;  
                         break;  
                 case 0x38:  
                         key_down_state |= DMod1Mask;  
                         break;  
                 case 0xb8:  
                         key_down_state |= DMod2Mask;  
                         break;  
         }  
   
         if ((numlock_modifier_mask && state)  
             && !(key_down_state & DNumLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);  
                 key_down_state |= DNumLockMask;  
         }  
   
         if ((LockMask & state) && !(key_down_state & DLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);  
                 key_down_state |= DLockMask;  
   
         }  
   
   
         if ((ShiftMask & state)  
             && !((key_down_state & DShift1Mask)  
                  || (key_down_state & DShift2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x2a, 0);  
                 key_down_state |= DShift1Mask;  
   
         }  
   
         if ((ControlMask & state)  
             && !((key_down_state & DControl1Mask)  
                  || (key_down_state & DControl2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x1d, 0);  
                 key_down_state |= DControl1Mask;  
   
         }  
   
         if ((Mod1Mask & state) && !(key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x38, 0);  
                 key_down_state |= DMod1Mask;  
   
         }  
   
         if ((Mod2Mask & state) && !(key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0xb8, 0);  
                 key_down_state |= DMod2Mask;  
555    
556                    }
557          }          }
558  }  }
559    
# Line 724  ui_select(int rdp_socket) Line 567  ui_select(int rdp_socket)
567    
568          while (True)          while (True)
569          {          {
570                    /* Process any events already waiting */
571                    xwin_process_events();
572    
573                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
574                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
575                  if (display != NULL)                  FD_SET(x_socket, &rfds);
                 {  
                         FD_SET(x_socket, &rfds);  
                         XFlush(display);  
                 }  
576    
577                  switch (select(n, &rfds, NULL, NULL, NULL))                  switch (select(n, &rfds, NULL, NULL, NULL))
578                  {                  {
# Line 741  ui_select(int rdp_socket) Line 583  ui_select(int rdp_socket)
583                                  continue;                                  continue;
584                  }                  }
585    
                 if (FD_ISSET(x_socket, &rfds))  
                         xwin_process_events();  
   
586                  if (FD_ISSET(rdp_socket, &rfds))                  if (FD_ISSET(rdp_socket, &rfds))
587                          return;                          return;
588          }          }
# Line 762  ui_create_bitmap(int width, int height, Line 601  ui_create_bitmap(int width, int height,
601          Pixmap bitmap;          Pixmap bitmap;
602          uint8 *tdata;          uint8 *tdata;
603    
604          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = translate_image(width, height, data);
605          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
606          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
607                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
608    
609          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
610    
611          XFree(image);          XFree(image);
612          if (!owncolmap)          xfree(tdata);
                 xfree(tdata);  
613          return (HBITMAP) bitmap;          return (HBITMAP) bitmap;
614  }  }
615    
616  void  void
617  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)  
618  {  {
619          XImage *image;          XImage *image;
620          uint8 *tdata;          uint8 *tdata;
621    
622          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = translate_image(width, height, data);
623          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
624                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
625    
626          if (ownbackstore)          if (ownbackstore)
627          {          {
# Line 797  ui_paint_bitmap(int x, int y, int cx, in Line 634  ui_paint_bitmap(int x, int y, int cx, in
634          }          }
635    
636          XFree(image);          XFree(image);
637          if (!owncolmap)          xfree(tdata);
                 xfree(tdata);  
638  }  }
639    
640  void  void
# Line 820  ui_create_glyph(int width, int height, u Line 656  ui_create_glyph(int width, int height, u
656          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
657          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
658    
659          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
660                               data, width, height, 8, scanline);                               width, height, 8, scanline);
661          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
662          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
663          XInitImage(image);          XInitImage(image);
# Line 840  ui_destroy_glyph(HGLYPH glyph) Line 676  ui_destroy_glyph(HGLYPH glyph)
676  }  }
677    
678  HCURSOR  HCURSOR
679  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
680                   int height, uint8 * andmask, uint8 * xormask)                   uint8 * andmask, uint8 * xormask)
681  {  {
682          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
683          XColor bg, fg;          XColor bg, fg;
# Line 899  ui_create_cursor(unsigned int x, unsigne Line 735  ui_create_cursor(unsigned int x, unsigne
735          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
736          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
737    
738          xcursor = XCreatePixmapCursor(display, (Pixmap) cursorglyph,          xcursor =
739                                        (Pixmap) maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(display, (Pixmap) cursorglyph,
740                                        (Pixmap) maskglyph, &fg, &bg, x, y);
741    
742          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
743          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
# Line 912  ui_create_cursor(unsigned int x, unsigne Line 749  ui_create_cursor(unsigned int x, unsigne
749  void  void
750  ui_set_cursor(HCURSOR cursor)  ui_set_cursor(HCURSOR cursor)
751  {  {
752          XDefineCursor(display, wnd, (Cursor) cursor);          current_cursor = (Cursor) cursor;
753            XDefineCursor(display, wnd, current_cursor);
754  }  }
755    
756  void  void
# Line 932  ui_create_colourmap(COLOURMAP * colours) Line 770  ui_create_colourmap(COLOURMAP * colours)
770  {  {
771          COLOURENTRY *entry;          COLOURENTRY *entry;
772          int i, ncolours = colours->ncolours;          int i, ncolours = colours->ncolours;
773            uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
774          if (owncolmap)          XColor xentry;
775            XColor xc_cache[256];
776            uint32 colour;
777            int colLookup = 256;
778            for (i = 0; i < ncolours; i++)
779          {          {
780                  XColor *xcolours, *xentry;                  entry = &colours->colours[i];
781                  Colormap map;                  MAKE_XCOLOR(&xentry, entry);
782    
783                  xcolours = xmalloc(sizeof(XColor) * ncolours);                  if (XAllocColor(display, xcolmap, &xentry) == 0)
                 for (i = 0; i < ncolours; i++)  
784                  {                  {
785                          entry = &colours->colours[i];                          /* Allocation failed, find closest match. */
786                          xentry = &xcolours[i];                          int j = 256;
787                          xentry->pixel = i;                          int nMinDist = 3 * 256 * 256;
788                          MAKE_XCOLOR(xentry, entry);                          long nDist = nMinDist;
                 }  
789    
790                  map = XCreateColormap(display, wnd, visual, AllocAll);                          /* only get the colors once */
791                  XStoreColors(display, map, xcolours, ncolours);                          while (colLookup--)
792                            {
793                                    xc_cache[colLookup].pixel = colLookup;
794                                    xc_cache[colLookup].red = xc_cache[colLookup].green =
795                                            xc_cache[colLookup].blue = 0;
796                                    xc_cache[colLookup].flags = 0;
797                                    XQueryColor(display,
798                                                DefaultColormap(display, DefaultScreen(display)),
799                                                &xc_cache[colLookup]);
800                            }
801                            colLookup = 0;
802    
803                  xfree(xcolours);                          /* approximate the pixel */
804                  return (HCOLOURMAP) map;                          while (j--)
805          }                          {
806          else                                  if (xc_cache[j].flags)
807          {                                  {
808                  uint32 *map = xmalloc(sizeof(*colmap) * ncolours);                                          nDist = ((long) (xc_cache[j].red >> 8) -
809                  XColor xentry;                                                   (long) (xentry.red >> 8)) *
810                  uint32 colour;                                                  ((long) (xc_cache[j].red >> 8) -
811                                                     (long) (xentry.red >> 8)) +
812                                                    ((long) (xc_cache[j].green >> 8) -
813                                                     (long) (xentry.green >> 8)) *
814                                                    ((long) (xc_cache[j].green >> 8) -
815                                                     (long) (xentry.green >> 8)) +
816                                                    ((long) (xc_cache[j].blue >> 8) -
817                                                     (long) (xentry.blue >> 8)) *
818                                                    ((long) (xc_cache[j].blue >> 8) -
819                                                     (long) (xentry.blue >> 8));
820                                    }
821                                    if (nDist < nMinDist)
822                                    {
823                                            nMinDist = nDist;
824                                            xentry.pixel = j;
825                                    }
826                            }
827                    }
828                    colour = xentry.pixel;
829    
830                  for (i = 0; i < ncolours; i++)                  /* update our cache */
831                    if (xentry.pixel < 256)
832                  {                  {
833                          entry = &colours->colours[i];                          xc_cache[xentry.pixel].red = xentry.red;
834                          MAKE_XCOLOR(&xentry, entry);                          xc_cache[xentry.pixel].green = xentry.green;
835                            xc_cache[xentry.pixel].blue = xentry.blue;
836    
                         if (XAllocColor(display, xcolmap, &xentry) != 0)  
                                 colour = xentry.pixel;  
                         else  
                                 colour = white;  
   
                         /* byte swap here to make translate_image faster */  
                         map[i] = translate_colour(colour);  
837                  }                  }
838    
839                  return map;  
840                    /* byte swap here to make translate_image faster */
841                    map[i] = translate_colour(colour);
842          }          }
843    
844            return map;
845  }  }
846    
847  void  void
848  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
849  {  {
850          if (owncolmap)          xfree(map);
                 XFreeColormap(display, (Colormap) map);  
         else  
                 xfree(map);  
851  }  }
852    
853  void  void
854  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
855  {  {
856          if (owncolmap)          colmap = map;
                 XSetWindowColormap(display, wnd, (Colormap) map);  
         else  
                 colmap = map;  
857  }  }
858    
859  void  void
# Line 1008  ui_set_clip(int x, int y, int cx, int cy Line 869  ui_set_clip(int x, int y, int cx, int cy
869  }  }
870    
871  void  void
872  ui_reset_clip()  ui_reset_clip(void)
873  {  {
874          XRectangle rect;          XRectangle rect;
875    
# Line 1020  ui_reset_clip() Line 881  ui_reset_clip()
881  }  }
882    
883  void  void
884  ui_bell()  ui_bell(void)
885  {  {
886          XBell(display, 0);          XBell(display, 0);
887  }  }
# Line 1060  ui_patblt(uint8 opcode, Line 921  ui_patblt(uint8 opcode,
921                          SET_BACKGROUND(fgcolour);                          SET_BACKGROUND(fgcolour);
922                          XSetFillStyle(display, gc, FillOpaqueStippled);                          XSetFillStyle(display, gc, FillOpaqueStippled);
923                          XSetStipple(display, gc, fill);                          XSetStipple(display, gc, fill);
924                          XSetTSOrigin(display, gc, brush->xorigin,                          XSetTSOrigin(display, gc, brush->xorigin, brush->yorigin);
                                      brush->yorigin);  
925    
926                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
927    
928                          XSetFillStyle(display, gc, FillSolid);                          XSetFillStyle(display, gc, FillSolid);
929                            XSetTSOrigin(display, gc, 0, 0);
930                          ui_destroy_glyph((HGLYPH) fill);                          ui_destroy_glyph((HGLYPH) fill);
931                          break;                          break;
932    
# Line 1084  ui_screenblt(uint8 opcode, Line 945  ui_screenblt(uint8 opcode,
945          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
946          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
947          if (ownbackstore)          if (ownbackstore)
948                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
949          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
950  }  }
951    
# Line 1097  ui_memblt(uint8 opcode, Line 957  ui_memblt(uint8 opcode,
957          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
958          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
959          if (ownbackstore)          if (ownbackstore)
960                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy,                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
961          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
962  }  }
963    
# Line 1115  ui_triblt(uint8 opcode, Line 974  ui_triblt(uint8 opcode,
974          {          {
975                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
976                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
977                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
978                          break;                          break;
979    
980                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
981                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
982                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
983                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
984                          break;                          break;
985    
986                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
987                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
988                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
989                          break;                          break;
990    
991                  default:                  default:
# Line 1164  ui_rect( Line 1019  ui_rect(
1019  void  void
1020  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
1021                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
1022                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
1023                int fgcolour)                int bgcolour, int fgcolour)
1024  {  {
1025          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
1026          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
1027    
1028          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(display, gc,
1029                        ? FillStippled : FillOpaqueStippled);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
1030          XSetStipple(display, gc, (Pixmap) glyph);          XSetStipple(display, gc, (Pixmap) glyph);
1031          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(display, gc, x, y);
1032    
# Line 1189  ui_draw_glyph(int mixmode, Line 1044  ui_draw_glyph(int mixmode,
1044        if ((xyoffset & 0x80))\        if ((xyoffset & 0x80))\
1045          {\          {\
1046            if (flags & TEXT2_VERTICAL) \            if (flags & TEXT2_VERTICAL) \
1047              y += ttext[++idx] | (ttext[++idx] << 8);\              y += ttext[idx+1] | (ttext[idx+2] << 8);\
1048            else\            else\
1049              x += ttext[++idx] | (ttext[++idx] << 8);\              x += ttext[idx+1] | (ttext[idx+2] << 8);\
1050              idx += 2;\
1051          }\          }\
1052        else\        else\
1053          {\          {\
# Line 1214  ui_draw_glyph(int mixmode, Line 1070  ui_draw_glyph(int mixmode,
1070    
1071  void  void
1072  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,
1073               int clipx, int clipy, int clipcx, int clipcy, int boxx,               int clipx, int clipy, int clipcx, int clipcy,
1074               int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1075               int fgcolour, uint8 * text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1076  {  {
1077          FONTGLYPH *glyph;          FONTGLYPH *glyph;
# Line 1240  ui_draw_text(uint8 font, uint8 flags, in Line 1096  ui_draw_text(uint8 font, uint8 flags, in
1096                  {                  {
1097                          case 0xff:                          case 0xff:
1098                                  if (i + 2 < length)                                  if (i + 2 < length)
1099                                          cache_put_text(text[i + 1], text,                                          cache_put_text(text[i + 1], text, text[i + 2]);
                                                        text[i + 2]);  
1100                                  else                                  else
1101                                  {                                  {
1102                                          error("this shouldn't be happening\n");                                          error("this shouldn't be happening\n");
# Line 1258  ui_draw_text(uint8 font, uint8 flags, in Line 1113  ui_draw_text(uint8 font, uint8 flags, in
1113                                  if (entry != NULL)                                  if (entry != NULL)
1114                                  {                                  {
1115                                          if ((((uint8 *) (entry->data))[1] ==                                          if ((((uint8 *) (entry->data))[1] ==
1116                                               0)                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
                                             && (!(flags & TEXT2_IMPLICIT_X)))  
1117                                          {                                          {
1118                                                  if (flags & TEXT2_VERTICAL)                                                  if (flags & TEXT2_VERTICAL)
1119                                                          y += text[i + 2];                                                          y += text[i + 2];
# Line 1275  ui_draw_text(uint8 font, uint8 flags, in Line 1129  ui_draw_text(uint8 font, uint8 flags, in
1129                                          text = &(text[i]);                                          text = &(text[i]);
1130                                          i = 0;                                          i = 0;
1131                                          for (j = 0; j < entry->size; j++)                                          for (j = 0; j < entry->size; j++)
1132                                                  DO_GLYPH(((uint8 *) (entry->                                                  DO_GLYPH(((uint8 *) (entry->data)), j);
                                                                      data)),  
                                                          j);  
1133                                  }                                  }
1134                                  break;                                  break;
1135    
# Line 1299  ui_desktop_save(uint32 offset, int x, in Line 1151  ui_desktop_save(uint32 offset, int x, in
1151    
1152          if (ownbackstore)          if (ownbackstore)
1153          {          {
1154                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1155          }          }
1156          else          else
1157          {          {
1158                  pix = XCreatePixmap(display, wnd, cx, cy, depth);                  pix = XCreatePixmap(display, wnd, cx, cy, depth);
1159                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
1160                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1161                  XFreePixmap(display, pix);                  XFreePixmap(display, pix);
1162          }          }
1163    
1164          offset *= bpp / 8;          offset *= bpp / 8;
1165          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8, (uint8 *) image->data);
                           bpp / 8, (uint8 *) image->data);  
1166    
1167          XDestroyImage(image);          XDestroyImage(image);
1168  }  }
# Line 1329  ui_desktop_restore(uint32 offset, int x, Line 1178  ui_desktop_restore(uint32 offset, int x,
1178          if (data == NULL)          if (data == NULL)
1179                  return;                  return;
1180    
1181          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1182                               0, data, cx, cy, BitmapPad(display),                               (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
                              cx * bpp / 8);  
1183    
1184          if (ownbackstore)          if (ownbackstore)
1185          {          {
Legend:
Removed from v.64  
changed lines
  Added in v.208
  ViewVC Help
Powered by ViewVC 1.1.26