/[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 192 by matthewc, Tue Sep 24 07:59:14 2002 UTC
# 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 Cursor current_cursor;
46    
47  /* endianness */  /* endianness */
48  static BOOL host_be;  static BOOL host_be;
# Line 49  static BOOL xserver_be; Line 52  static BOOL xserver_be;
52  static BOOL ownbackstore;  static BOOL ownbackstore;
53  static Pixmap backstore;  static Pixmap backstore;
54    
 /* 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)  
   
55  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
56  { \  { \
57          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 60  static unsigned int key_down_state = 0;
60  }  }
61    
62  /* colour maps */  /* colour maps */
 static BOOL owncolmap;  
63  static Colormap xcolmap;  static Colormap xcolmap;
 static uint32 white;  
64  static uint32 *colmap;  static uint32 *colmap;
65    
66  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define SET_FOREGROUND(col)     XSetForeground(display, gc, translate_colour(colmap[col]));
67  #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));  
68    
69  static int rop2_map[] = {  static int rop2_map[] = {
70          GXclear,                /* 0 */          GXclear,                /* 0 */
# Line 105  static int rop2_map[] = { Line 88  static int rop2_map[] = {
88  #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]); }
89  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
90    
 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);  
   
91  static void  static void
92  translate8(uint8 * data, uint8 * out, uint8 * end)  translate8(uint8 * data, uint8 * out, uint8 * end)
93  {  {
# Line 205  translate_colour(uint32 colour) Line 183  translate_colour(uint32 colour)
183  }  }
184    
185  BOOL  BOOL
186  ui_create_window(char *title)  get_key_state(int keysym)
187  {  {
188          XSetWindowAttributes attribs;          int keysymMask = 0, modifierpos, key;
189          XClassHint *classhints;          Window wDummy1, wDummy2;
190          XSizeHints *sizehints;          int iDummy3, iDummy4, iDummy5, iDummy6;
191          unsigned long input_mask;          unsigned int current_state;
192          XPixmapFormatValues *pfm;          int offset;
         Screen *screen;  
         uint16 test;  
         int i;  
193    
194          int xkb_minor, xkb_major;          XModifierKeymap *map = XGetModifierMapping(display);
195          int xkb_event, xkb_error, xkb_reason;          KeyCode keycode = XKeysymToKeycode(display, keysym);
196    
197          /* 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");  
198                  return False;                  return False;
         }  
199    
200            for (modifierpos = 0; modifierpos < 8; modifierpos++)
         display =  
                 XkbOpenDisplay(NULL, &xkb_event, &xkb_error, &xkb_major,  
                                &xkb_minor, &xkb_reason);  
         switch (xkb_reason)  
201          {          {
202                  case XkbOD_BadLibraryVersion:                  offset = map->max_keypermod * modifierpos;
203                          error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");  
204                          break;                  for (key = 0; key < map->max_keypermod; key++)
205                  case XkbOD_ConnectionRefused:                  {
206                          error("XkbOD_ConnectionRefused\n");                          if (map->modifiermap[offset + key] == keycode)
207                          break;                                  keysymMask = 1 << modifierpos;
208                  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;  
209          }          }
210    
211            XQueryPointer(display, DefaultRootWindow(display), &wDummy1,
212                          &wDummy2, &iDummy3, &iDummy4, &iDummy5, &iDummy6, &current_state);
213    
214            XFreeModifiermap(map);
215    
216            return (current_state & keysymMask) ? True : False;
217    }
218    
219    BOOL
220    ui_init(void)
221    {
222            XPixmapFormatValues *pfm;
223            uint16 test;
224            int i;
225    
226            display = XOpenDisplay(NULL);
227          if (display == NULL)          if (display == NULL)
228          {          {
229                  error("Failed to open display\n");                  error("Failed to open display\n");
# Line 269  ui_create_window(char *title) Line 242  ui_create_window(char *title)
242                     desirable, e.g. 24 bits->32 bits. */                     desirable, e.g. 24 bits->32 bits. */
243                  while (i--)                  while (i--)
244                  {                  {
245                          if ((pfm[i].depth == depth)                          if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
                             && (pfm[i].bits_per_pixel > bpp))  
246                          {                          {
247                                  bpp = pfm[i].bits_per_pixel;                                  bpp = pfm[i].bits_per_pixel;
248                          }                          }
# Line 285  ui_create_window(char *title) Line 257  ui_create_window(char *title)
257                  return False;                  return False;
258          }          }
259    
260          if (depth <= 8)          xcolmap = DefaultColormapOfScreen(screen);
261                  owncolmap = True;          gc = XCreateGC(display, RootWindowOfScreen(screen), 0, NULL);
262          else  
263                  xcolmap = DefaultColormapOfScreen(screen);          if (DoesBackingStore(screen) != Always)
264                    ownbackstore = True;
265    
266          test = 1;          test = 1;
267          host_be = !(BOOL) (*(uint8 *) (&test));          host_be = !(BOOL) (*(uint8 *) (&test));
268          xserver_be = (ImageByteOrder(display) == MSBFirst);          xserver_be = (ImageByteOrder(display) == MSBFirst);
269    
         white = WhitePixelOfScreen(screen);  
         attribs.background_pixel = BlackPixelOfScreen(screen);  
         attribs.backing_store = DoesBackingStore(screen);  
   
         if (attribs.backing_store == NotUseful)  
                 ownbackstore = True;  
   
270          if (fullscreen)          if (fullscreen)
271          {          {
                 attribs.override_redirect = True;  
272                  width = WidthOfScreen(screen);                  width = WidthOfScreen(screen);
273                  height = HeightOfScreen(screen);                  height = HeightOfScreen(screen);
274          }          }
275          else  
276            /* make sure width is a multiple of 4 */
277            width = (width + 3) & ~3;
278    
279            if (ownbackstore)
280          {          {
281                  attribs.override_redirect = False;                  backstore = XCreatePixmap(display, RootWindowOfScreen(screen), width, height, depth);
282    
283                    /* clear to prevent rubbish being exposed at startup */
284                    XSetForeground(display, gc, BlackPixelOfScreen(screen));
285                    XFillRectangle(display, backstore, gc, 0, 0, width, height);
286          }          }
287    
288          width = (width + 3) & ~3;       /* make width a multiple of 32 bits */          if (enable_compose)
289                    IM = XOpenIM(display, NULL, NULL, NULL);
290    
291            xkeymap_init();
292            return True;
293    }
294    
295    void
296    ui_deinit(void)
297    {
298            if (IM != NULL)
299                    XCloseIM(IM);
300    
301          wnd = XCreateWindow(display, RootWindowOfScreen(screen),          if (ownbackstore)
302                              0, 0, width, height, 0, CopyFromParent,                  XFreePixmap(display, backstore);
303                              InputOutput, CopyFromParent,  
304                              CWBackingStore | CWBackPixel | CWOverrideRedirect,          XFreeGC(display, gc);
305                              &attribs);          XCloseDisplay(display);
306            display = NULL;
307    }
308    
309    BOOL
310    ui_create_window(void)
311    {
312            XSetWindowAttributes attribs;
313            XClassHint *classhints;
314            XSizeHints *sizehints;
315            int wndwidth, wndheight;
316            long input_mask, ic_input_mask;
317            XEvent xevent;
318    
319            wndwidth  = fullscreen ? WidthOfScreen(screen)  : width;
320            wndheight = fullscreen ? HeightOfScreen(screen) : height;
321    
322            attribs.background_pixel = BlackPixelOfScreen(screen);
323            attribs.backing_store = ownbackstore ? NotUseful : Always;
324            attribs.override_redirect = fullscreen;
325    
326            wnd = XCreateWindow(display, RootWindowOfScreen(screen), 0, 0, wndwidth, wndheight,
327                                0, CopyFromParent, InputOutput, CopyFromParent,
328                                CWBackPixel | CWBackingStore | CWOverrideRedirect, &attribs);
329    
330          XStoreName(display, wnd, title);          XStoreName(display, wnd, title);
331    
# Line 340  ui_create_window(char *title) Line 347  ui_create_window(char *title)
347                  XFree(sizehints);                  XFree(sizehints);
348          }          }
349    
350          xkeymap_init();          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
351                    StructureNotifyMask | FocusChangeMask;
352    
353          input_mask = KeyPressMask | KeyReleaseMask |          if (grab_keyboard)
354                  ButtonPressMask | ButtonReleaseMask |                  input_mask |= EnterWindowMask | LeaveWindowMask;
                 EnterWindowMask | LeaveWindowMask;  
355          if (sendmotion)          if (sendmotion)
356                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
   
357          if (ownbackstore)          if (ownbackstore)
358                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
359    
360          XSelectInput(display, wnd, input_mask);          if (IM != NULL)
361          gc = XCreateGC(display, wnd, 0, NULL);          {
362                    IC = XCreateIC(IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
363                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
364    
365          if (ownbackstore)                  if ((IC != NULL) && (XGetICValues(IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
366                  backstore = XCreatePixmap(display, wnd, width, height, depth);                          input_mask |= ic_input_mask;
367            }
368    
369            XSelectInput(display, wnd, input_mask);
370          XMapWindow(display, wnd);          XMapWindow(display, wnd);
371    
372          /* TODO: error texts... make them friendly. */          /* wait for MapNotify */
373          xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);          do {
374          if ((int) xkb == BadAlloc || xkb == NULL)                  XMaskEvent(display, StructureNotifyMask, &xevent);
375          {          } while (xevent.type != MapNotify);
                 error("XkbGetKeyboard failed.\n");  
                 exit(0);  
         }  
   
         /* TODO: error texts... make them friendly. */  
         if (XkbSelectEvents  
             (display, xkb->device_spec, XkbAllEventsMask,  
              XkbAllEventsMask) == False)  
         {  
                 error("XkbSelectEvents failed.\n");  
                 exit(0);  
         }  
376    
377          xwin_get_numlock_mask();          if (fullscreen)
378                    XSetInputFocus(display, wnd, RevertToPointerRoot, CurrentTime);
379    
380          return True;          return True;
381  }  }
382    
383  void  void
384  xwin_get_numlock_mask()  ui_destroy_window(void)
385  {  {
386          KeyCode numlockcode;          if (IC != NULL)
387          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");  
388    
389            XDestroyWindow(display, wnd);
390  }  }
391    
392  void  void
393  ui_destroy_window()  xwin_toggle_fullscreen(void)
394  {  {
395          if (xkb != NULL)          Pixmap contents = 0;
                 XkbFreeKeyboard(xkb, XkbAllControlsMask, True);  
396    
397          if (ownbackstore)          if (!ownbackstore)
398                  XFreePixmap(display, backstore);          {
399                    /* need to save contents of window */
400                    contents = XCreatePixmap(display, wnd, width, height, depth);
401                    XCopyArea(display, wnd, contents, gc, 0, 0, width, height, 0, 0);
402            }
403    
404          XFreeGC(display, gc);          ui_destroy_window();
405          XDestroyWindow(display, wnd);          fullscreen = !fullscreen;
406          XCloseDisplay(display);          ui_create_window();
407          display = NULL;  
408            XDefineCursor(display, wnd, current_cursor);
409    
410            if (!ownbackstore)
411            {
412                    XCopyArea(display, contents, wnd, gc, 0, 0, width, height, 0, 0);
413                    XFreePixmap(display, contents);
414            }
415  }  }
416    
417    /* Process all events in Xlib queue */
418  static void  static void
419  xwin_process_events()  xwin_process_events(void)
420  {  {
421          XEvent xevent;          XEvent xevent;
   
422          KeySym keysym;          KeySym keysym;
         uint8 scancode;  
423          uint16 button, flags;          uint16 button, flags;
424          uint32 ev_time;          uint32 ev_time;
425          uint32 tmpmods;          key_translation tr;
426            char *ksname = NULL;
427            char str[256];
428            Status status;
429    
430          while (XCheckMaskEvent(display, ~0, &xevent))          while (XPending(display) > 0)
431          {          {
432                    XNextEvent(display, &xevent);
433    
434                    if ((IC != NULL) && (XFilterEvent(&xevent, None) == True))
435                    {
436                            DEBUG_KBD(("Filtering event\n"));
437                            continue;
438                    }
439    
440                  ev_time = time(NULL);                  ev_time = time(NULL);
441                  flags = 0;                  flags = 0;
442    
443                  switch (xevent.type)                  switch (xevent.type)
444                  {                  {
                         case KeyRelease:  
                                 flags = KBD_FLAG_DOWN | KBD_FLAG_UP;  
                                 /* fall through */  
445                          case KeyPress:                          case KeyPress:
446                                  if (XkbTranslateKeyCode                                  if (IC != NULL)
447                                      (xkb, xevent.xkey.keycode,                                          /* Multi_key compatible version */
448                                       xevent.xkey.state, &tmpmods,                                  {
449                                       &keysym) == False)                                          XmbLookupString(IC,
450                                                            (XKeyPressedEvent *) &
451                                                            xevent, str, sizeof(str), &keysym, &status);
452                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
453                                            {
454                                                    error("XmbLookupString failed with status 0x%x\n",
455                                                          status);
456                                                    break;
457                                            }
458                                    }
459                                    else
460                                    {
461                                            /* Plain old XLookupString */
462                                            DEBUG_KBD(("\nNo input context, using XLookupString\n"));
463                                            XLookupString((XKeyEvent *) & xevent,
464                                                          str, sizeof(str), &keysym, NULL);
465                                    }
466    
467                                    ksname = get_ksname(keysym);
468                                    DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym, ksname));
469    
470                                    if (handle_special_keys(keysym, ev_time, True))
471                                          break;                                          break;
                                 scancode =  
                                         xkeymap_translate_key(keysym,  
                                                               xevent.xkey.  
                                                               keycode,  
                                                               &flags);  
472    
473                                  if (scancode == 0)                                  tr = xkeymap_translate_key(keysym,
474                                                               xevent.xkey.keycode, xevent.xkey.state);
475    
476                                    if (tr.scancode == 0)
477                                          break;                                          break;
478    
479                                  /* keep track of the modifiers -- needed for stickykeys... */                                  ensure_remote_modifiers(ev_time, tr);
480                                  if (xevent.type == KeyPress)  
481                                          xwin_mod_press(xevent.xkey.state,                                  rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
482                                                         ev_time, scancode);                                  break;
483                            case KeyRelease:
484                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE,                                  XLookupString((XKeyEvent *) & xevent, str,
485                                                 flags, scancode, 0);                                                sizeof(str), &keysym, NULL);
486    
487                                  if (xevent.type == KeyRelease)                                  ksname = get_ksname(keysym);
488                                          xwin_mod_release(xevent.xkey.state,                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
489                                                           ev_time, scancode);                                             ksname));
490    
491                                    if (handle_special_keys(keysym, 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(ev_time, 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(ev_time, 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 EnterNotify:
522                                  XGrabKeyboard(display, wnd, True,                                  if (grab_keyboard)
523                                                GrabModeAsync, GrabModeAsync,                                          XGrabKeyboard(display, wnd, True,
524                                                CurrentTime);                                                        GrabModeAsync, GrabModeAsync, CurrentTime);
   
                                 xwin_mod_update(xevent.xcrossing.state,  
                                                 ev_time);  
525                                  break;                                  break;
526    
527                          case LeaveNotify:                          case LeaveNotify:
528                                  XUngrabKeyboard(display, CurrentTime);                                  if (grab_keyboard)
529                                            XUngrabKeyboard(display, CurrentTime);
530                                    break;
531    
532                            case FocusIn:
533                                    reset_modifier_keys();
534                                  break;                                  break;
535    
536                          case Expose:                          case Expose:
# Line 538  xwin_process_events() Line 540  xwin_process_events()
540                                            xevent.xexpose.height,                                            xevent.xexpose.height,
541                                            xevent.xexpose.x, xevent.xexpose.y);                                            xevent.xexpose.x, xevent.xexpose.y);
542                                  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;  
   
         }  
   
         if (!(ControlMask & state) && (key_down_state & DControl1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x1d,  
                                0);  
                 key_down_state &= ~DControl1Mask;  
   
         }  
   
         if (!(Mod1Mask & state) && (key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x38,  
                                0);  
                 key_down_state &= ~DMod1Mask;  
   
         }  
   
         if (!(Mod2Mask & state) && (key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0xb8,  
                                0);  
                 key_down_state &= ~DMod2Mask;  
         }  
 }  
543    
544                            case MappingNotify:
545                                    /* Refresh keyboard mapping if it has changed. This is important for
546                                       Xvnc, since it allocates keycodes dynamically */
547                                    if (xevent.xmapping.request == MappingKeyboard
548                                        || xevent.xmapping.request == MappingModifier)
549                                            XRefreshKeyboardMapping(&xevent.xmapping);
550                                    break;
551    
552  void                  }
 xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode)  
 {  
   
         switch (scancode)  
         {  
                 case 0x2a:  
                         key_down_state |= DShift1Mask;  
                         break;  
                 case 0x36:  
                         key_down_state |= DShift2Mask;  
                         break;  
                 case 0x1d:  
                         key_down_state |= DControl1Mask;  
                         break;  
                 case 0x9d:  
                         key_down_state |= DControl2Mask;  
                         break;  
                 case 0x3a:  
                         key_down_state ^= DLockMask;  
                         break;  
                 case 0x45:  
                         key_down_state ^= DNumLockMask;  
                         break;  
                 case 0x38:  
                         key_down_state |= DMod1Mask;  
                         break;  
                 case 0xb8:  
                         key_down_state |= DMod2Mask;  
                         break;  
         }  
   
         if ((numlock_modifier_mask && state)  
             && !(key_down_state & DNumLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);  
                 key_down_state |= DNumLockMask;  
         }  
   
         if ((LockMask & state) && !(key_down_state & DLockMask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE,  
                                KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);  
                 key_down_state |= DLockMask;  
   
         }  
   
   
         if ((ShiftMask & state)  
             && !((key_down_state & DShift1Mask)  
                  || (key_down_state & DShift2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x2a, 0);  
                 key_down_state |= DShift1Mask;  
   
         }  
   
         if ((ControlMask & state)  
             && !((key_down_state & DControl1Mask)  
                  || (key_down_state & DControl2Mask)))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x1d, 0);  
                 key_down_state |= DControl1Mask;  
   
         }  
   
         if ((Mod1Mask & state) && !(key_down_state & DMod1Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0x38, 0);  
                 key_down_state |= DMod1Mask;  
   
         }  
   
         if ((Mod2Mask & state) && !(key_down_state & DMod2Mask))  
         {  
                 rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN,  
                                0xb8, 0);  
                 key_down_state |= DMod2Mask;  
   
553          }          }
554  }  }
555    
# Line 724  ui_select(int rdp_socket) Line 563  ui_select(int rdp_socket)
563    
564          while (True)          while (True)
565          {          {
566                    /* Process any events already waiting */
567                    xwin_process_events();
568    
569                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
570                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
571                  if (display != NULL)                  FD_SET(x_socket, &rfds);
                 {  
                         FD_SET(x_socket, &rfds);  
                         XFlush(display);  
                 }  
572    
573                  switch (select(n, &rfds, NULL, NULL, NULL))                  switch (select(n, &rfds, NULL, NULL, NULL))
574                  {                  {
# Line 741  ui_select(int rdp_socket) Line 579  ui_select(int rdp_socket)
579                                  continue;                                  continue;
580                  }                  }
581    
                 if (FD_ISSET(x_socket, &rfds))  
                         xwin_process_events();  
   
582                  if (FD_ISSET(rdp_socket, &rfds))                  if (FD_ISSET(rdp_socket, &rfds))
583                          return;                          return;
584          }          }
# Line 762  ui_create_bitmap(int width, int height, Line 597  ui_create_bitmap(int width, int height,
597          Pixmap bitmap;          Pixmap bitmap;
598          uint8 *tdata;          uint8 *tdata;
599    
600          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = translate_image(width, height, data);
601          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
602          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
603                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
604    
605          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
606    
607          XFree(image);          XFree(image);
608          if (!owncolmap)          xfree(tdata);
                 xfree(tdata);  
609          return (HBITMAP) bitmap;          return (HBITMAP) bitmap;
610  }  }
611    
612  void  void
613  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)  
614  {  {
615          XImage *image;          XImage *image;
616          uint8 *tdata;          uint8 *tdata;
617    
618          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = translate_image(width, height, data);
619          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
620                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
621    
622          if (ownbackstore)          if (ownbackstore)
623          {          {
# Line 797  ui_paint_bitmap(int x, int y, int cx, in Line 630  ui_paint_bitmap(int x, int y, int cx, in
630          }          }
631    
632          XFree(image);          XFree(image);
633          if (!owncolmap)          xfree(tdata);
                 xfree(tdata);  
634  }  }
635    
636  void  void
# Line 820  ui_create_glyph(int width, int height, u Line 652  ui_create_glyph(int width, int height, u
652          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
653          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
654    
655          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
656                               data, width, height, 8, scanline);                               width, height, 8, scanline);
657          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
658          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
659          XInitImage(image);          XInitImage(image);
# Line 840  ui_destroy_glyph(HGLYPH glyph) Line 672  ui_destroy_glyph(HGLYPH glyph)
672  }  }
673    
674  HCURSOR  HCURSOR
675  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
676                   int height, uint8 * andmask, uint8 * xormask)                   uint8 * andmask, uint8 * xormask)
677  {  {
678          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
679          XColor bg, fg;          XColor bg, fg;
# Line 899  ui_create_cursor(unsigned int x, unsigne Line 731  ui_create_cursor(unsigned int x, unsigne
731          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
732          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
733    
734          xcursor = XCreatePixmapCursor(display, (Pixmap) cursorglyph,          xcursor =
735                                        (Pixmap) maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(display, (Pixmap) cursorglyph,
736                                        (Pixmap) maskglyph, &fg, &bg, x, y);
737    
738          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
739          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
# Line 912  ui_create_cursor(unsigned int x, unsigne Line 745  ui_create_cursor(unsigned int x, unsigne
745  void  void
746  ui_set_cursor(HCURSOR cursor)  ui_set_cursor(HCURSOR cursor)
747  {  {
748          XDefineCursor(display, wnd, (Cursor) cursor);          current_cursor = (Cursor) cursor;
749            XDefineCursor(display, wnd, current_cursor);
750  }  }
751    
752  void  void
# Line 932  ui_create_colourmap(COLOURMAP * colours) Line 766  ui_create_colourmap(COLOURMAP * colours)
766  {  {
767          COLOURENTRY *entry;          COLOURENTRY *entry;
768          int i, ncolours = colours->ncolours;          int i, ncolours = colours->ncolours;
769            uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
770          if (owncolmap)          XColor xentry;
771            XColor xc_cache[256];
772            uint32 colour;
773            int colLookup = 256;
774            for (i = 0; i < ncolours; i++)
775          {          {
776                  XColor *xcolours, *xentry;                  entry = &colours->colours[i];
777                  Colormap map;                  MAKE_XCOLOR(&xentry, entry);
778    
779                  xcolours = xmalloc(sizeof(XColor) * ncolours);                  if (XAllocColor(display, xcolmap, &xentry) == 0)
                 for (i = 0; i < ncolours; i++)  
780                  {                  {
781                          entry = &colours->colours[i];                          /* Allocation failed, find closest match. */
782                          xentry = &xcolours[i];                          int j = 256;
783                          xentry->pixel = i;                          int nMinDist = 3 * 256 * 256;
784                          MAKE_XCOLOR(xentry, entry);                          long nDist = nMinDist;
785                  }  
786                            /* only get the colors once */
787                  map = XCreateColormap(display, wnd, visual, AllocAll);                          while( colLookup-- ){
788                  XStoreColors(display, map, xcolours, ncolours);                                  xc_cache[colLookup].pixel = colLookup;
789                                    xc_cache[colLookup].red = xc_cache[colLookup].green = xc_cache[colLookup].blue = 0;
790                  xfree(xcolours);                                  xc_cache[colLookup].flags = 0;
791                  return (HCOLOURMAP) map;                                  XQueryColor(display, DefaultColormap(display, DefaultScreen(display)), &xc_cache[colLookup]);
792          }                          }
793          else                          colLookup = 0;
         {  
                 uint32 *map = xmalloc(sizeof(*colmap) * ncolours);  
                 XColor xentry;  
                 uint32 colour;  
794    
795                  for (i = 0; i < ncolours; i++)                          /* approximate the pixel */
796                  {                          while( j-- ){
797                          entry = &colours->colours[i];                                  if( xc_cache[j].flags ){
798                          MAKE_XCOLOR(&xentry, entry);                                          nDist =
799                                            ((long) (xc_cache[j].red >> 8) - (long) (xentry.red >> 8)) *
800                                            ((long) (xc_cache[j].red >> 8) - (long) (xentry.red >> 8)) +
801                                            ((long) (xc_cache[j].green >> 8) - (long) (xentry.green >> 8)) *
802                                            ((long) (xc_cache[j].green >> 8) - (long) (xentry.green >> 8)) +
803                                            ((long) (xc_cache[j].blue >> 8) - (long) (xentry.blue >> 8)) *
804                                            ((long) (xc_cache[j].blue >> 8) - (long) (xentry.blue >> 8));
805                                    }
806                                    if( nDist < nMinDist ){
807                                            nMinDist = nDist;
808                                            xentry.pixel = j;
809                                    }
810                            }
811                    }
812                    colour = xentry.pixel;
813    
814                          if (XAllocColor(display, xcolmap, &xentry) != 0)                  /* update our cache */
815                                  colour = xentry.pixel;                  if( xentry.pixel < 256 ){
816                          else                          xc_cache[xentry.pixel].red = xentry.red;
817                                  colour = white;                          xc_cache[xentry.pixel].green = xentry.green;
818                            xc_cache[xentry.pixel].blue = xentry.blue;
819    
                         /* byte swap here to make translate_image faster */  
                         map[i] = translate_colour(colour);  
820                  }                  }
821    
822                  return map;  
823                    /* byte swap here to make translate_image faster */
824                    map[i] = translate_colour(colour);
825          }          }
826    
827            return map;
828  }  }
829    
830  void  void
831  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
832  {  {
833          if (owncolmap)          xfree(map);
                 XFreeColormap(display, (Colormap) map);  
         else  
                 xfree(map);  
834  }  }
835    
836  void  void
837  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
838  {  {
839          if (owncolmap)          colmap = map;
                 XSetWindowColormap(display, wnd, (Colormap) map);  
         else  
                 colmap = map;  
840  }  }
841    
842  void  void
# Line 1008  ui_set_clip(int x, int y, int cx, int cy Line 852  ui_set_clip(int x, int y, int cx, int cy
852  }  }
853    
854  void  void
855  ui_reset_clip()  ui_reset_clip(void)
856  {  {
857          XRectangle rect;          XRectangle rect;
858    
# Line 1020  ui_reset_clip() Line 864  ui_reset_clip()
864  }  }
865    
866  void  void
867  ui_bell()  ui_bell(void)
868  {  {
869          XBell(display, 0);          XBell(display, 0);
870  }  }
# Line 1060  ui_patblt(uint8 opcode, Line 904  ui_patblt(uint8 opcode,
904                          SET_BACKGROUND(fgcolour);                          SET_BACKGROUND(fgcolour);
905                          XSetFillStyle(display, gc, FillOpaqueStippled);                          XSetFillStyle(display, gc, FillOpaqueStippled);
906                          XSetStipple(display, gc, fill);                          XSetStipple(display, gc, fill);
907                          XSetTSOrigin(display, gc, brush->xorigin,                          XSetTSOrigin(display, gc, brush->xorigin, brush->yorigin);
                                      brush->yorigin);  
908    
909                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
910    
911                          XSetFillStyle(display, gc, FillSolid);                          XSetFillStyle(display, gc, FillSolid);
912                            XSetTSOrigin(display, gc, 0, 0);
913                          ui_destroy_glyph((HGLYPH) fill);                          ui_destroy_glyph((HGLYPH) fill);
914                          break;                          break;
915    
# Line 1084  ui_screenblt(uint8 opcode, Line 928  ui_screenblt(uint8 opcode,
928          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
929          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
930          if (ownbackstore)          if (ownbackstore)
931                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
932          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
933  }  }
934    
# Line 1097  ui_memblt(uint8 opcode, Line 940  ui_memblt(uint8 opcode,
940          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
941          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
942          if (ownbackstore)          if (ownbackstore)
943                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy,                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
944          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
945  }  }
946    
# Line 1115  ui_triblt(uint8 opcode, Line 957  ui_triblt(uint8 opcode,
957          {          {
958                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
959                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
960                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
961                          break;                          break;
962    
963                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
964                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
965                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
966                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
967                          break;                          break;
968    
969                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
970                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
971                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
972                          break;                          break;
973    
974                  default:                  default:
# Line 1164  ui_rect( Line 1002  ui_rect(
1002  void  void
1003  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
1004                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
1005                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
1006                int fgcolour)                int bgcolour, int fgcolour)
1007  {  {
1008          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
1009          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
1010    
1011          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(display, gc,
1012                        ? FillStippled : FillOpaqueStippled);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
1013          XSetStipple(display, gc, (Pixmap) glyph);          XSetStipple(display, gc, (Pixmap) glyph);
1014          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(display, gc, x, y);
1015    
# Line 1189  ui_draw_glyph(int mixmode, Line 1027  ui_draw_glyph(int mixmode,
1027        if ((xyoffset & 0x80))\        if ((xyoffset & 0x80))\
1028          {\          {\
1029            if (flags & TEXT2_VERTICAL) \            if (flags & TEXT2_VERTICAL) \
1030              y += ttext[++idx] | (ttext[++idx] << 8);\              y += ttext[idx+1] | (ttext[idx+2] << 8);\
1031            else\            else\
1032              x += ttext[++idx] | (ttext[++idx] << 8);\              x += ttext[idx+1] | (ttext[idx+2] << 8);\
1033              idx += 2;\
1034          }\          }\
1035        else\        else\
1036          {\          {\
# Line 1214  ui_draw_glyph(int mixmode, Line 1053  ui_draw_glyph(int mixmode,
1053    
1054  void  void
1055  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,
1056               int clipx, int clipy, int clipcx, int clipcy, int boxx,               int clipx, int clipy, int clipcx, int clipcy,
1057               int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1058               int fgcolour, uint8 * text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1059  {  {
1060          FONTGLYPH *glyph;          FONTGLYPH *glyph;
# Line 1240  ui_draw_text(uint8 font, uint8 flags, in Line 1079  ui_draw_text(uint8 font, uint8 flags, in
1079                  {                  {
1080                          case 0xff:                          case 0xff:
1081                                  if (i + 2 < length)                                  if (i + 2 < length)
1082                                          cache_put_text(text[i + 1], text,                                          cache_put_text(text[i + 1], text, text[i + 2]);
                                                        text[i + 2]);  
1083                                  else                                  else
1084                                  {                                  {
1085                                          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 1096  ui_draw_text(uint8 font, uint8 flags, in
1096                                  if (entry != NULL)                                  if (entry != NULL)
1097                                  {                                  {
1098                                          if ((((uint8 *) (entry->data))[1] ==                                          if ((((uint8 *) (entry->data))[1] ==
1099                                               0)                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
                                             && (!(flags & TEXT2_IMPLICIT_X)))  
1100                                          {                                          {
1101                                                  if (flags & TEXT2_VERTICAL)                                                  if (flags & TEXT2_VERTICAL)
1102                                                          y += text[i + 2];                                                          y += text[i + 2];
# Line 1275  ui_draw_text(uint8 font, uint8 flags, in Line 1112  ui_draw_text(uint8 font, uint8 flags, in
1112                                          text = &(text[i]);                                          text = &(text[i]);
1113                                          i = 0;                                          i = 0;
1114                                          for (j = 0; j < entry->size; j++)                                          for (j = 0; j < entry->size; j++)
1115                                                  DO_GLYPH(((uint8 *) (entry->                                                  DO_GLYPH(((uint8 *) (entry->data)), j);
                                                                      data)),  
                                                          j);  
1116                                  }                                  }
1117                                  break;                                  break;
1118    
# Line 1299  ui_desktop_save(uint32 offset, int x, in Line 1134  ui_desktop_save(uint32 offset, int x, in
1134    
1135          if (ownbackstore)          if (ownbackstore)
1136          {          {
1137                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1138          }          }
1139          else          else
1140          {          {
1141                  pix = XCreatePixmap(display, wnd, cx, cy, depth);                  pix = XCreatePixmap(display, wnd, cx, cy, depth);
1142                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
1143                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1144                  XFreePixmap(display, pix);                  XFreePixmap(display, pix);
1145          }          }
1146    
1147          offset *= bpp / 8;          offset *= bpp / 8;
1148          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);  
1149    
1150          XDestroyImage(image);          XDestroyImage(image);
1151  }  }
# Line 1329  ui_desktop_restore(uint32 offset, int x, Line 1161  ui_desktop_restore(uint32 offset, int x,
1161          if (data == NULL)          if (data == NULL)
1162                  return;                  return;
1163    
1164          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1165                               0, data, cx, cy, BitmapPad(display),                               (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
                              cx * bpp / 8);  
1166    
1167          if (ownbackstore)          if (ownbackstore)
1168          {          {
Legend:
Removed from v.64  
changed lines
  Added in v.192
  ViewVC Help
Powered by ViewVC 1.1.26