/[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 70 by astrand, Sat Jul 27 23:09:32 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    #define XK_MISCELLANY
26    #include <X11/keysymdef.h>
27  #include "rdesktop.h"  #include "rdesktop.h"
28    
 extern char keymapname[16];  
 extern int keylayout;  
29  extern int width;  extern int width;
30  extern int height;  extern int height;
31  extern BOOL sendmotion;  extern BOOL sendmotion;
32  extern BOOL fullscreen;  extern BOOL fullscreen;
33    
34  Display *display;  Display *display = NULL;
 XkbDescPtr xkb;  
35  static int x_socket;  static int x_socket;
36  static Window wnd;  static Window wnd;
37  static GC gc;  static GC gc;
# Line 49  static BOOL xserver_be; Line 47  static BOOL xserver_be;
47  static BOOL ownbackstore;  static BOOL ownbackstore;
48  static Pixmap backstore;  static Pixmap backstore;
49    
 /* 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)  
   
50  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
51  { \  { \
52          XFillRectangle(display, wnd, gc, x, y, cx, cy); \          XFillRectangle(display, wnd, gc, x, y, cx, cy); \
# Line 78  static BOOL owncolmap; Line 59  static BOOL owncolmap;
59  static Colormap xcolmap;  static Colormap xcolmap;
60  static uint32 white;  static uint32 white;
61  static uint32 *colmap;  static uint32 *colmap;
62    static XIM IM = NULL;
63    static XIC IC = NULL;
64    
65    /* Compose support */
66    BOOL enable_compose = False;
67    
68  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )
69  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));
# Line 105  static int rop2_map[] = { Line 91  static int rop2_map[] = {
91  #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]); }
92  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
93    
 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);  
   
94  static void  static void
95  translate8(uint8 * data, uint8 * out, uint8 * end)  translate8(uint8 * data, uint8 * out, uint8 * end)
96  {  {
# Line 204  translate_colour(uint32 colour) Line 185  translate_colour(uint32 colour)
185          return colour;          return colour;
186  }  }
187    
188    static unsigned long
189    init_inputmethod(void)
190    {
191            unsigned long filtered_events = 0;
192    
193            IM = XOpenIM(display, NULL, NULL, NULL);
194            if (IM == NULL)
195            {
196                    error("Failed to open input method\n");
197            }
198    
199            if (IM != NULL)
200            {
201                    /* Must be done after XCreateWindow */
202                    IC = XCreateIC(IM, XNInputStyle,
203                                   (XIMPreeditNothing | XIMStatusNothing),
204                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
205    
206                    if (IC == NULL)
207                    {
208                            error("Failed to create input context\n");
209                            XCloseIM(IM);
210                            IM = NULL;
211                    }
212            }
213    
214            /* For correct Multi_key/Compose processing, I guess.
215               It seems to work alright anyway, though. */
216            if (IC != NULL)
217            {
218                    if (XGetICValues(IC, XNFilterEvents, &filtered_events, NULL)
219                        != NULL)
220                    {
221                            error("Failed to obtain XNFilterEvents value from IC\n");
222                            filtered_events = 0;
223                    }
224            }
225            return filtered_events;
226    }
227    
228    static void
229    close_inputmethod(void)
230    {
231            if (IC != NULL)
232            {
233                    XDestroyIC(IC);
234                    if (IM != NULL)
235                    {
236                            XCloseIM(IM);
237                            IM = NULL;
238                    }
239            }
240    }
241    
242    
243  BOOL  BOOL
244  ui_create_window(char *title)  ui_create_window(char *title)
245  {  {
# Line 216  ui_create_window(char *title) Line 252  ui_create_window(char *title)
252          uint16 test;          uint16 test;
253          int i;          int i;
254    
255          int xkb_minor, xkb_major;          display = XOpenDisplay(NULL);
         int xkb_event, xkb_error, xkb_reason;  
   
         /* compare compiletime libs with runtime libs. */  
         xkb_major = XkbMajorVersion;  
         xkb_minor = XkbMinorVersion;  
         if (XkbLibraryVersion(&xkb_major, &xkb_minor) == False)  
         {  
                 error("please re-compile rdesktop\ncompile time version of xkb is not compatible with\nyour runtime version of the library\n");  
                 return False;  
         }  
   
   
         display =  
                 XkbOpenDisplay(NULL, &xkb_event, &xkb_error, &xkb_major,  
                                &xkb_minor, &xkb_reason);  
         switch (xkb_reason)  
         {  
                 case XkbOD_BadLibraryVersion:  
                         error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");  
                         break;  
                 case XkbOD_ConnectionRefused:  
                         error("XkbOD_ConnectionRefused\n");  
                         break;  
                 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;  
         }  
256    
257          if (display == NULL)          if (display == NULL)
258          {          {
# Line 340  ui_create_window(char *title) Line 343  ui_create_window(char *title)
343                  XFree(sizehints);                  XFree(sizehints);
344          }          }
345    
346          xkeymap_init();          xkeymap_init2();
347    
348          input_mask = KeyPressMask | KeyReleaseMask |          input_mask =
349                  ButtonPressMask | ButtonReleaseMask |                  KeyPressMask | KeyReleaseMask | ButtonPressMask |
350                  EnterWindowMask | LeaveWindowMask;                  ButtonReleaseMask | EnterWindowMask | LeaveWindowMask;
351          if (sendmotion)          if (sendmotion)
352                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
353    
354          if (ownbackstore)          if (ownbackstore)
355                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
356    
357            if (enable_compose)
358                    input_mask |= init_inputmethod();
359    
360          XSelectInput(display, wnd, input_mask);          XSelectInput(display, wnd, input_mask);
361    
362          gc = XCreateGC(display, wnd, 0, NULL);          gc = XCreateGC(display, wnd, 0, NULL);
363    
364          if (ownbackstore)          if (ownbackstore)
# Line 359  ui_create_window(char *title) Line 366  ui_create_window(char *title)
366    
367          XMapWindow(display, wnd);          XMapWindow(display, wnd);
368    
         /* TODO: error texts... make them friendly. */  
         xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);  
         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)  
         {  
                 error("XkbSelectEvents failed.\n");  
                 exit(0);  
         }  
   
         xwin_get_numlock_mask();  
   
369          return True;          return True;
370  }  }
371    
372  void  void
 xwin_get_numlock_mask()  
 {  
         KeyCode numlockcode;  
         KeyCode *keycode;  
         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");  
   
 }  
   
 void  
373  ui_destroy_window()  ui_destroy_window()
374  {  {
         if (xkb != NULL)  
                 XkbFreeKeyboard(xkb, XkbAllControlsMask, True);  
   
375          if (ownbackstore)          if (ownbackstore)
376                  XFreePixmap(display, backstore);                  XFreePixmap(display, backstore);
377    
378          XFreeGC(display, gc);          XFreeGC(display, gc);
379    
380            close_inputmethod();
381    
382          XDestroyWindow(display, wnd);          XDestroyWindow(display, wnd);
383          XCloseDisplay(display);          XCloseDisplay(display);
384          display = NULL;          display = NULL;
# Line 450  xwin_process_events() Line 390  xwin_process_events()
390          XEvent xevent;          XEvent xevent;
391    
392          KeySym keysym;          KeySym keysym;
         uint8 scancode;  
393          uint16 button, flags;          uint16 button, flags;
394          uint32 ev_time;          uint32 ev_time;
395          uint32 tmpmods;          key_translation tr;
396            char *ksname = NULL;
397            char str[256];
398            Status status;
399    
400            /* Refresh keyboard mapping if it has changed. This is important for
401               Xvnc, since it allocates keycodes dynamically */
402            if (XCheckTypedEvent(display, MappingNotify, &xevent))
403            {
404                    if (xevent.xmapping.request == MappingKeyboard
405                        || xevent.xmapping.request == MappingModifier)
406                            XRefreshKeyboardMapping(&xevent.xmapping);
407            }
408    
409          while (XCheckMaskEvent(display, ~0, &xevent))          while (XCheckMaskEvent(display, ~0, &xevent))
410          {          {
411                    if (enable_compose && (XFilterEvent(&xevent, None) == True))
412                    {
413                            DEBUG_KBD("Filtering event\n");
414                            continue;
415                    }
416    
417                  ev_time = time(NULL);                  ev_time = time(NULL);
418                  flags = 0;                  flags = 0;
419    
420                  switch (xevent.type)                  switch (xevent.type)
421                  {                  {
                         case KeyRelease:  
                                 flags = KBD_FLAG_DOWN | KBD_FLAG_UP;  
                                 /* fall through */  
422                          case KeyPress:                          case KeyPress:
423                                  if (XkbTranslateKeyCode                                  if (IC != NULL)
424                                      (xkb, xevent.xkey.keycode,                                          /* Multi_key compatible version */
425                                       xevent.xkey.state, &tmpmods,                                  {
426                                       &keysym) == False)                                          XmbLookupString(IC,
427                                                            (XKeyPressedEvent *) &
428                                                            xevent, str,
429                                                            sizeof(str), &keysym,
430                                                            &status);
431                                            if (!
432                                                ((status == XLookupKeySym)
433                                                 || (status == XLookupBoth)))
434                                            {
435                                                    error("XmbLookupString failed with status 0x%x\n", status);
436                                                    break;
437                                            }
438                                    }
439                                    else
440                                    {
441                                            /* Plain old XLookupString */
442                                            DEBUG_KBD
443                                                    ("No input context, using XLookupString\n");
444                                            XLookupString((XKeyEvent *) & xevent,
445                                                          str, sizeof(str),
446                                                          &keysym, NULL);
447                                    }
448    
449                                    ksname = get_ksname(keysym);
450                                    DEBUG_KBD
451                                            ("\nKeyPress for (keysym 0x%lx, %s)\n",
452                                             keysym, ksname);
453    
454                                    if (inhibit_key(keysym))
455                                    {
456                                            DEBUG_KBD("Inhibiting key\n");
457                                            break;
458                                    }
459    
460                                    tr = xkeymap_translate_key(keysym,
461                                                               xevent.xkey.
462                                                               keycode,
463                                                               xevent.xkey.state);
464    
465                                    ensure_remote_modifiers(ev_time, tr);
466    
467                                    if (tr.scancode == 0)
468                                          break;                                          break;
                                 scancode =  
                                         xkeymap_translate_key(keysym,  
                                                               xevent.xkey.  
                                                               keycode,  
                                                               &flags);  
469    
470                                  if (scancode == 0)                                  rdp_send_scancode(ev_time, RDP_KEYPRESS,
471                                                      tr.scancode);
472                                    break;
473                            case KeyRelease:
474                                    XLookupString((XKeyEvent *) & xevent, str,
475                                                  sizeof(str), &keysym, NULL);
476    
477                                    ksname = get_ksname(keysym);
478                                    DEBUG_KBD
479                                            ("\nKeyRelease for (keysym 0x%lx, %s)\n",
480                                             keysym, ksname);
481    
482                                    if (inhibit_key(keysym))
483                                          break;                                          break;
484    
485                                  /* keep track of the modifiers -- needed for stickykeys... */                                  tr = xkeymap_translate_key(keysym,
486                                  if (xevent.type == KeyPress)                                                             xevent.xkey.
487                                          xwin_mod_press(xevent.xkey.state,                                                             keycode,
488                                                         ev_time, scancode);                                                             xevent.xkey.state);
489    
490                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE,                                  if (tr.scancode == 0)
491                                                 flags, scancode, 0);                                          break;
   
                                 if (xevent.type == KeyRelease)  
                                         xwin_mod_release(xevent.xkey.state,  
                                                          ev_time, scancode);  
492    
493                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE,
494                                                      tr.scancode);
495                                  break;                                  break;
496    
497                          case ButtonPress:                          case ButtonPress:
# Line 522  xwin_process_events() Line 522  xwin_process_events()
522                                  XGrabKeyboard(display, wnd, True,                                  XGrabKeyboard(display, wnd, True,
523                                                GrabModeAsync, GrabModeAsync,                                                GrabModeAsync, GrabModeAsync,
524                                                CurrentTime);                                                CurrentTime);
   
                                 xwin_mod_update(xevent.xcrossing.state,  
                                                 ev_time);  
525                                  break;                                  break;
526    
527                          case LeaveNotify:                          case LeaveNotify:
# Line 543  xwin_process_events() Line 540  xwin_process_events()
540  }  }
541    
542  void  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;  
         }  
 }  
   
   
 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;  
   
         }  
 }  
   
 void  
543  ui_select(int rdp_socket)  ui_select(int rdp_socket)
544  {  {
545          int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;          int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;
# Line 764  ui_create_bitmap(int width, int height, Line 589  ui_create_bitmap(int width, int height,
589    
590          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
591          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
592          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0, tdata, width,
593                               0, tdata, width, height, 8, 0);                               height, 8, 0);
594    
595          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
596    
# Line 776  ui_create_bitmap(int width, int height, Line 601  ui_create_bitmap(int width, int height,
601  }  }
602    
603  void  void
604  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,
605                  int width, int height, uint8 * data)                  uint8 * data)
606  {  {
607          XImage *image;          XImage *image;
608          uint8 *tdata;          uint8 *tdata;
609    
610          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
611          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0, tdata, width,
612                               0, tdata, width, height, 8, 0);                               height, 8, 0);
613    
614          if (ownbackstore)          if (ownbackstore)
615          {          {
# Line 820  ui_create_glyph(int width, int height, u Line 645  ui_create_glyph(int width, int height, u
645          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
646          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
647    
648          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, data, width,
649                               data, width, height, 8, scanline);                               height, 8, scanline);
650          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
651          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
652          XInitImage(image);          XInitImage(image);
# Line 840  ui_destroy_glyph(HGLYPH glyph) Line 665  ui_destroy_glyph(HGLYPH glyph)
665  }  }
666    
667  HCURSOR  HCURSOR
668  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
669                   int height, uint8 * andmask, uint8 * xormask)                   uint8 * andmask, uint8 * xormask)
670  {  {
671          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
672          XColor bg, fg;          XColor bg, fg;
# Line 899  ui_create_cursor(unsigned int x, unsigne Line 724  ui_create_cursor(unsigned int x, unsigne
724          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
725          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
726    
727          xcursor = XCreatePixmapCursor(display, (Pixmap) cursorglyph,          xcursor =
728                                        (Pixmap) maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(display, (Pixmap) cursorglyph,
729                                        (Pixmap) maskglyph, &fg, &bg, x, y);
730    
731          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
732          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
# Line 1084  ui_screenblt(uint8 opcode, Line 910  ui_screenblt(uint8 opcode,
910          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
911          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
912          if (ownbackstore)          if (ownbackstore)
913                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx,
914                            cx, cy, x, y);                            cy, x, y);
915          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
916  }  }
917    
# Line 1115  ui_triblt(uint8 opcode, Line 941  ui_triblt(uint8 opcode,
941          {          {
942                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
943                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
944                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour,
945                                    brush, bgcolour, fgcolour);                                    fgcolour);
946                          break;                          break;
947    
948                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
949                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour,
950                                    brush, bgcolour, fgcolour);                                    fgcolour);
951                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
952                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour,
953                                    brush, bgcolour, fgcolour);                                    fgcolour);
954                          break;                          break;
955    
956                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
# Line 1164  ui_rect( Line 990  ui_rect(
990  void  void
991  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
992                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
993                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
994                int fgcolour)                int bgcolour, int fgcolour)
995  {  {
996          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
997          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
998    
999          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(display, gc,
1000                        ? FillStippled : FillOpaqueStippled);                        (mixmode ==
1001                           MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
1002          XSetStipple(display, gc, (Pixmap) glyph);          XSetStipple(display, gc, (Pixmap) glyph);
1003          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(display, gc, x, y);
1004    
# Line 1214  ui_draw_glyph(int mixmode, Line 1041  ui_draw_glyph(int mixmode,
1041    
1042  void  void
1043  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,
1044               int clipx, int clipy, int clipcx, int clipcy, int boxx,               int clipx, int clipy, int clipcx, int clipcy,
1045               int boxy, int boxcx, int boxcy, int bgcolour,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1046               int fgcolour, uint8 * text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1047  {  {
1048          FONTGLYPH *glyph;          FONTGLYPH *glyph;
# Line 1312  ui_desktop_save(uint32 offset, int x, in Line 1139  ui_desktop_save(uint32 offset, int x, in
1139          }          }
1140    
1141          offset *= bpp / 8;          offset *= bpp / 8;
1142          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8,
1143                            bpp / 8, (uint8 *) image->data);                            (uint8 *) image->data);
1144    
1145          XDestroyImage(image);          XDestroyImage(image);
1146  }  }
# Line 1329  ui_desktop_restore(uint32 offset, int x, Line 1156  ui_desktop_restore(uint32 offset, int x,
1156          if (data == NULL)          if (data == NULL)
1157                  return;                  return;
1158    
1159          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0, data, cx, cy,
1160                               0, data, cx, cy, BitmapPad(display),                               BitmapPad(display), cx * bpp / 8);
                              cx * bpp / 8);  
1161    
1162          if (ownbackstore)          if (ownbackstore)
1163          {          {
Legend:
Removed from v.64  
changed lines
  Added in v.70
  ViewVC Help
Powered by ViewVC 1.1.26