/[rdesktop]/sourceforge.net/branches/seamlessrdp-branch/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/branches/seamlessrdp-branch/rdesktop/xwin.c

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

revision 38 by matthewc, Thu Apr 4 12:04:33 2002 UTC revision 84 by astrand, Tue Jul 30 07:30:12 2002 UTC
# Line 2  Line 2 
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     User interface services - X Window System     User interface services - X Window System
4     Copyright (C) Matthew Chapman 1999-2001     Copyright (C) Matthew Chapman 1999-2001
5      
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.     (at your option) any later version.
10      
11     This program is distributed in the hope that it will be useful,     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.     GNU General Public License for more details.
15      
16     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
# Line 22  Line 22 
22  #include <X11/Xutil.h>  #include <X11/Xutil.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    #include "scancodes.h"
29    
 extern char keymapname[16];  
 extern int keylayout;  
30  extern int width;  extern int width;
31  extern int height;  extern int height;
32  extern BOOL sendmotion;  extern BOOL sendmotion;
33  extern BOOL fullscreen;  extern BOOL fullscreen;
34    extern BOOL grab_keyboard;
35    
36  static Display *display;  Display *display = NULL;
37  static int x_socket;  static int x_socket;
38  static Window wnd;  static Window wnd;
39  static GC gc;  static GC gc;
# Line 59  static BOOL owncolmap; Line 61  static BOOL owncolmap;
61  static Colormap xcolmap;  static Colormap xcolmap;
62  static uint32 white;  static uint32 white;
63  static uint32 *colmap;  static uint32 *colmap;
64    static XIM IM = NULL;
65    static XIC IC = NULL;
66    
67    /* Compose support */
68    BOOL enable_compose = False;
69    
70  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )  #define TRANSLATE(col)          ( owncolmap ? col : translate_colour(colmap[col]) )
71  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));  #define SET_FOREGROUND(col)     XSetForeground(display, gc, TRANSLATE(col));
# Line 87  static int rop2_map[] = { Line 94  static int rop2_map[] = {
94  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
95    
96  static void  static void
97  translate8(uint8 *data, uint8 *out, uint8 *end)  translate8(uint8 * data, uint8 * out, uint8 * end)
98  {  {
99          while (out < end)          while (out < end)
100                  *(out++) = (uint8)colmap[*(data++)];                  *(out++) = (uint8) colmap[*(data++)];
101  }  }
102    
103  static void  static void
104  translate16(uint8 *data, uint16 *out, uint16 *end)  translate16(uint8 * data, uint16 * out, uint16 * end)
105  {  {
106          while (out < end)          while (out < end)
107                  *(out++) = (uint16)colmap[*(data++)];                  *(out++) = (uint16) colmap[*(data++)];
108  }  }
109    
110  /* little endian - conversion happens when colourmap is built */  /* little endian - conversion happens when colourmap is built */
111  static void  static void
112  translate24(uint8 *data, uint8 *out, uint8 *end)  translate24(uint8 * data, uint8 * out, uint8 * end)
113  {  {
114          uint32 value;          uint32 value;
115    
# Line 116  translate24(uint8 *data, uint8 *out, uin Line 123  translate24(uint8 *data, uint8 *out, uin
123  }  }
124    
125  static void  static void
126  translate32(uint8 *data, uint32 *out, uint32 *end)  translate32(uint8 * data, uint32 * out, uint32 * end)
127  {  {
128          while (out < end)          while (out < end)
129                  *(out++) = colmap[*(data++)];                  *(out++) = colmap[*(data++)];
130  }  }
131    
132  static uint8 *  static uint8 *
133  translate_image(int width, int height, uint8 *data)  translate_image(int width, int height, uint8 * data)
134  {  {
135          int size = width * height * bpp/8;          int size = width * height * bpp / 8;
136          uint8 *out = xmalloc(size);          uint8 *out = xmalloc(size);
137          uint8 *end = out + size;          uint8 *end = out + size;
138    
# Line 136  translate_image(int width, int height, u Line 143  translate_image(int width, int height, u
143                          break;                          break;
144    
145                  case 16:                  case 16:
146                          translate16(data, (uint16 *)out, (uint16 *)end);                          translate16(data, (uint16 *) out, (uint16 *) end);
147                          break;                          break;
148    
149                  case 24:                  case 24:
# Line 144  translate_image(int width, int height, u Line 151  translate_image(int width, int height, u
151                          break;                          break;
152    
153                  case 32:                  case 32:
154                          translate32(data, (uint32 *)out, (uint32 *)end);                          translate32(data, (uint32 *) out, (uint32 *) end);
155                          break;                          break;
156          }          }
157    
# Line 180  translate_colour(uint32 colour) Line 187  translate_colour(uint32 colour)
187          return colour;          return colour;
188  }  }
189    
190    static unsigned long
191    init_inputmethod(void)
192    {
193            unsigned long filtered_events = 0;
194    
195            IM = XOpenIM(display, NULL, NULL, NULL);
196            if (IM == NULL)
197            {
198                    error("Failed to open input method\n");
199            }
200    
201            if (IM != NULL)
202            {
203                    /* Must be done after XCreateWindow */
204                    IC = XCreateIC(IM, XNInputStyle,
205                                   (XIMPreeditNothing | XIMStatusNothing),
206                                   XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
207    
208                    if (IC == NULL)
209                    {
210                            error("Failed to create input context\n");
211                            XCloseIM(IM);
212                            IM = NULL;
213                    }
214            }
215    
216            /* For correct Multi_key/Compose processing, I guess.
217               It seems to work alright anyway, though. */
218            if (IC != NULL)
219            {
220                    if (XGetICValues(IC, XNFilterEvents, &filtered_events, NULL) != NULL)
221                    {
222                            error("Failed to obtain XNFilterEvents value from IC\n");
223                            filtered_events = 0;
224                    }
225            }
226            return filtered_events;
227    }
228    
229    static void
230    close_inputmethod(void)
231    {
232            if (IC != NULL)
233            {
234                    XDestroyIC(IC);
235                    if (IM != NULL)
236                    {
237                            XCloseIM(IM);
238                            IM = NULL;
239                    }
240            }
241    }
242    
243    BOOL
244    ui_init()
245    {
246            Screen *screen;
247            display = XOpenDisplay(NULL);
248            if (display == NULL)
249            {
250                    error("Failed to open display\n");
251                    return False;
252            }
253            if (fullscreen)
254            {
255                    screen = DefaultScreenOfDisplay(display);
256                    width = WidthOfScreen(screen);
257                    height = HeightOfScreen(screen);
258            }
259            return True;
260    }
261    
262  BOOL  BOOL
263  ui_create_window(char *title)  ui_create_window(char *title)
264  {  {
# Line 192  ui_create_window(char *title) Line 271  ui_create_window(char *title)
271          uint16 test;          uint16 test;
272          int i;          int i;
273    
         display = XOpenDisplay(NULL);  
         if (display == NULL)  
         {  
                 error("Failed to open display\n");  
                 return False;  
         }  
   
274          x_socket = ConnectionNumber(display);          x_socket = ConnectionNumber(display);
275          screen = DefaultScreenOfDisplay(display);          screen = DefaultScreenOfDisplay(display);
276          visual = DefaultVisualOfScreen(screen);          visual = DefaultVisualOfScreen(screen);
# Line 211  ui_create_window(char *title) Line 283  ui_create_window(char *title)
283                     desirable, e.g. 24 bits->32 bits. */                     desirable, e.g. 24 bits->32 bits. */
284                  while (i--)                  while (i--)
285                  {                  {
286                          if ((pfm[i].depth == depth)                          if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
                             && (pfm[i].bits_per_pixel > bpp))  
287                          {                          {
288                                  bpp = pfm[i].bits_per_pixel;                                  bpp = pfm[i].bits_per_pixel;
289                          }                          }
# Line 233  ui_create_window(char *title) Line 304  ui_create_window(char *title)
304                  xcolmap = DefaultColormapOfScreen(screen);                  xcolmap = DefaultColormapOfScreen(screen);
305    
306          test = 1;          test = 1;
307          host_be = !(BOOL)(*(uint8 *)(&test));          host_be = !(BOOL) (*(uint8 *) (&test));
308          xserver_be = (ImageByteOrder(display) == MSBFirst);          xserver_be = (ImageByteOrder(display) == MSBFirst);
309    
310          white = WhitePixelOfScreen(screen);          white = WhitePixelOfScreen(screen);
# Line 254  ui_create_window(char *title) Line 325  ui_create_window(char *title)
325                  attribs.override_redirect = False;                  attribs.override_redirect = False;
326          }          }
327    
328          width = (width + 3) & ~3; /* make width a multiple of 32 bits */          width = (width + 3) & ~3;       /* make width a multiple of 32 bits */
329    
330          wnd = XCreateWindow(display, RootWindowOfScreen(screen),          wnd = XCreateWindow(display, RootWindowOfScreen(screen),
331                              0, 0, width, height, 0, CopyFromParent,                              0, 0, width, height, 0, CopyFromParent,
332                              InputOutput, CopyFromParent,                              InputOutput, CopyFromParent,
333                              CWBackingStore | CWBackPixel | CWOverrideRedirect,                              CWBackingStore | CWBackPixel | CWOverrideRedirect, &attribs);
                             &attribs);  
334    
335          XStoreName(display, wnd, title);          XStoreName(display, wnd, title);
336    
# Line 282  ui_create_window(char *title) Line 352  ui_create_window(char *title)
352                  XFree(sizehints);                  XFree(sizehints);
353          }          }
354    
355          xkeymap_init(display);          xkeymap_init2();
   
         input_mask = KeyPressMask | KeyReleaseMask  
                         | ButtonPressMask | ButtonReleaseMask  
                         | EnterWindowMask | LeaveWindowMask;  
356    
357            input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
358            if (grab_keyboard)
359                    input_mask |= EnterWindowMask | LeaveWindowMask;
360          if (sendmotion)          if (sendmotion)
361                  input_mask |= PointerMotionMask;                  input_mask |= PointerMotionMask;
362    
363          if (ownbackstore)          if (ownbackstore)
364                  input_mask |= ExposureMask;                  input_mask |= ExposureMask;
365    
366            if (enable_compose)
367                    input_mask |= init_inputmethod();
368    
369          XSelectInput(display, wnd, input_mask);          XSelectInput(display, wnd, input_mask);
370    
371          gc = XCreateGC(display, wnd, 0, NULL);          gc = XCreateGC(display, wnd, 0, NULL);
372    
373          if (ownbackstore)          if (ownbackstore)
374                  backstore = XCreatePixmap(display, wnd, width, height, depth);                  backstore = XCreatePixmap(display, wnd, width, height, depth);
375    
376          XMapWindow(display, wnd);          XMapWindow(display, wnd);
377    
378          return True;          return True;
379  }  }
380    
# Line 311  ui_destroy_window() Line 385  ui_destroy_window()
385                  XFreePixmap(display, backstore);                  XFreePixmap(display, backstore);
386    
387          XFreeGC(display, gc);          XFreeGC(display, gc);
388    
389            close_inputmethod();
390    
391          XDestroyWindow(display, wnd);          XDestroyWindow(display, wnd);
392          XCloseDisplay(display);          XCloseDisplay(display);
393          display = NULL;          display = NULL;
# Line 319  ui_destroy_window() Line 396  ui_destroy_window()
396  static void  static void
397  xwin_process_events()  xwin_process_events()
398  {  {
399          XEvent event;          XEvent xevent;
400    
401          KeySym keysym;          KeySym keysym;
402          uint8 scancode;          uint16 button, flags;
         uint16 button;  
403          uint32 ev_time;          uint32 ev_time;
404            key_translation tr;
405            char *ksname = NULL;
406            char str[256];
407            Status status;
408    
409          if (display == NULL)          /* Refresh keyboard mapping if it has changed. This is important for
410                  return;             Xvnc, since it allocates keycodes dynamically */
411            if (XCheckTypedEvent(display, MappingNotify, &xevent))
412            {
413                    if (xevent.xmapping.request == MappingKeyboard
414                        || xevent.xmapping.request == MappingModifier)
415                            XRefreshKeyboardMapping(&xevent.xmapping);
416            }
417    
418          while (XCheckWindowEvent(display, wnd, ~0, &event))          while (XCheckMaskEvent(display, ~0, &xevent))
419          {          {
420                    if (enable_compose && (XFilterEvent(&xevent, None) == True))
421                    {
422                            DEBUG_KBD(("Filtering event\n"));
423                            continue;
424                    }
425    
426                  ev_time = time(NULL);                  ev_time = time(NULL);
427                    flags = 0;
428    
429                  switch (event.type)                  switch (xevent.type)
430                  {                  {
431                          case KeyPress:                          case KeyPress:
432                                  keysym = XKeycodeToKeysym(display, event.xkey.keycode, 0);                                  if (IC != NULL)
433                                  scancode = xkeymap_translate_key(keysym, event.xkey.keycode);                                          /* Multi_key compatible version */
434                                  if (scancode == 0)                                  {
435                                            XmbLookupString(IC,
436                                                            (XKeyPressedEvent *) &
437                                                            xevent, str, sizeof(str), &keysym, &status);
438                                            if (!((status == XLookupKeySym) || (status == XLookupBoth)))
439                                            {
440                                                    error("XmbLookupString failed with status 0x%x\n",
441                                                          status);
442                                                    break;
443                                            }
444                                    }
445                                    else
446                                    {
447                                            /* Plain old XLookupString */
448                                            DEBUG_KBD(("No input context, using XLookupString\n"));
449                                            XLookupString((XKeyEvent *) & xevent,
450                                                          str, sizeof(str), &keysym, NULL);
451                                    }
452    
453                                    ksname = get_ksname(keysym);
454                                    DEBUG_KBD(("\nKeyPress for (keysym 0x%lx, %s)\n", keysym, ksname));
455    
456                                    if (inhibit_key(keysym))
457                                    {
458                                            DEBUG_KBD(("Inhibiting key\n"));
459                                          break;                                          break;
460                                    }
461    
462                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0,                                  tr = xkeymap_translate_key(keysym,
463                                                 scancode, 0);                                                             xevent.xkey.keycode, xevent.xkey.state);
                                 break;  
464    
465                          case KeyRelease:                                  ensure_remote_modifiers(ev_time, tr);
466                                  keysym = XKeycodeToKeysym(display, event.xkey.keycode, 0);  
467                                  scancode = xkeymap_translate_key(keysym, event.xkey.keycode);                                  if (tr.scancode == 0)
                                 if (scancode == 0)  
468                                          break;                                          break;
469    
470                                  rdp_send_input(ev_time, RDP_INPUT_SCANCODE,                                  rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
                                                KBD_FLAG_DOWN | KBD_FLAG_UP,  
                                                scancode, 0);  
471                                  break;                                  break;
472                            case KeyRelease:
473                                    XLookupString((XKeyEvent *) & xevent, str,
474                                                  sizeof(str), &keysym, NULL);
475    
476                          case ButtonPress:                                  ksname = get_ksname(keysym);
477                                  button = xkeymap_translate_button(event.xbutton.button);                                  DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
478                                  if (button == 0)                                             ksname));
479    
480                                    if (inhibit_key(keysym))
481                                          break;                                          break;
482    
483                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  tr = xkeymap_translate_key(keysym,
484                                                 button | MOUSE_FLAG_DOWN,                                                             xevent.xkey.keycode, xevent.xkey.state);
485                                                 event.xbutton.x,  
486                                                 event.xbutton.y);                                  if (tr.scancode == 0)
487                                            break;
488    
489                                    rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
490                                  break;                                  break;
491    
492                            case ButtonPress:
493                                    flags = MOUSE_FLAG_DOWN;
494                                    /* fall through */
495    
496                          case ButtonRelease:                          case ButtonRelease:
497                                  button = xkeymap_translate_button(event.xbutton.button);                                  button = xkeymap_translate_button(xevent.xbutton.button);
498                                  if (button == 0)                                  if (button == 0)
499                                          break;                                          break;
500    
501                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,
502                                                 button,                                                 flags | button, xevent.xbutton.x, xevent.xbutton.y);
                                                event.xbutton.x,  
                                                event.xbutton.y);  
503                                  break;                                  break;
504    
505                          case MotionNotify:                          case MotionNotify:
506                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,                                  rdp_send_input(ev_time, RDP_INPUT_MOUSE,
507                                                 MOUSE_FLAG_MOVE,                                                 MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
                                                event.xmotion.x,  
                                                event.xmotion.y);  
508                                  break;                                  break;
509    
510                            case FocusIn:
511                                    /* fall through */
512                          case EnterNotify:                          case EnterNotify:
513                                  XGrabKeyboard(display, wnd, True, GrabModeAsync,                                  if (grab_keyboard)
514                                                GrabModeAsync, CurrentTime);                                          XGrabKeyboard(display, wnd, True,
515                                                          GrabModeAsync, GrabModeAsync, CurrentTime);
516                                  break;                                  break;
517    
518                            case FocusOut:
519                                    /* reset keys */
520                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE,
521                                                   KBD_FLAG_DOWN | KBD_FLAG_UP, SCANCODE_CHAR_LCTRL, 0);
522                                    rdp_send_input(ev_time, RDP_INPUT_SCANCODE,
523                                                   KBD_FLAG_DOWN | KBD_FLAG_UP, SCANCODE_CHAR_LALT, 0);
524                                    /* fall through */
525                          case LeaveNotify:                          case LeaveNotify:
526                                  XUngrabKeyboard(display, CurrentTime);                                  if (grab_keyboard)
527                                            XUngrabKeyboard(display, CurrentTime);
528                                  break;                                  break;
529    
530                          case Expose:                          case Expose:
531                                  XCopyArea(display, backstore, wnd, gc,                                  XCopyArea(display, backstore, wnd, gc,
532                                            event.xexpose.x, event.xexpose.y,                                            xevent.xexpose.x, xevent.xexpose.y,
533                                            event.xexpose.width, event.xexpose.height,                                            xevent.xexpose.width,
534                                            event.xexpose.x, event.xexpose.y);                                            xevent.xexpose.height,
535                                              xevent.xexpose.x, xevent.xexpose.y);
536                                  break;                                  break;
537                  }                  }
538          }          }
# Line 406  xwin_process_events() Line 541  xwin_process_events()
541  void  void
542  ui_select(int rdp_socket)  ui_select(int rdp_socket)
543  {  {
544          int n = (rdp_socket > x_socket) ? rdp_socket+1 : x_socket+1;          int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;
545          fd_set rfds;          fd_set rfds;
546    
         XFlush(display);  
   
547          FD_ZERO(&rfds);          FD_ZERO(&rfds);
548    
549          while (True)          while (True)
550          {          {
551                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
552                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
553                  FD_SET(x_socket, &rfds);                  if (display != NULL)
554                    {
555                            FD_SET(x_socket, &rfds);
556                            XFlush(display);
557                    }
558    
559                  switch (select(n, &rfds, NULL, NULL, NULL))                  switch (select(n, &rfds, NULL, NULL, NULL))
560                  {                  {
# Line 443  ui_move_pointer(int x, int y) Line 580  ui_move_pointer(int x, int y)
580  }  }
581    
582  HBITMAP  HBITMAP
583  ui_create_bitmap(int width, int height, uint8 *data)  ui_create_bitmap(int width, int height, uint8 * data)
584  {  {
585          XImage *image;          XImage *image;
586          Pixmap bitmap;          Pixmap bitmap;
# Line 451  ui_create_bitmap(int width, int height, Line 588  ui_create_bitmap(int width, int height,
588    
589          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
590          bitmap = XCreatePixmap(display, wnd, width, height, depth);          bitmap = XCreatePixmap(display, wnd, width, height, depth);
591          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
592                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
593    
594          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);          XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
595    
# Line 463  ui_create_bitmap(int width, int height, Line 600  ui_create_bitmap(int width, int height,
600  }  }
601    
602  void  void
603  ui_paint_bitmap(int x, int y, int cx, int cy,  ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
                 int width, int height, uint8 *data)  
604  {  {
605          XImage *image;          XImage *image;
606          uint8 *tdata;          uint8 *tdata;
607    
608          tdata = (owncolmap ? data : translate_image(width, height, data));          tdata = (owncolmap ? data : translate_image(width, height, data));
609          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
610                               0, tdata, width, height, 8, 0);                               (char *) tdata, width, height, 8, 0);
611    
612          if (ownbackstore)          if (ownbackstore)
613          {          {
# Line 491  ui_paint_bitmap(int x, int y, int cx, in Line 627  ui_paint_bitmap(int x, int y, int cx, in
627  void  void
628  ui_destroy_bitmap(HBITMAP bmp)  ui_destroy_bitmap(HBITMAP bmp)
629  {  {
630          XFreePixmap(display, (Pixmap)bmp);          XFreePixmap(display, (Pixmap) bmp);
631  }  }
632    
633  HGLYPH  HGLYPH
634  ui_create_glyph(int width, int height, uint8 *data)  ui_create_glyph(int width, int height, uint8 * data)
635  {  {
636          XImage *image;          XImage *image;
637          Pixmap bitmap;          Pixmap bitmap;
# Line 507  ui_create_glyph(int width, int height, u Line 643  ui_create_glyph(int width, int height, u
643          bitmap = XCreatePixmap(display, wnd, width, height, 1);          bitmap = XCreatePixmap(display, wnd, width, height, 1);
644          gc = XCreateGC(display, bitmap, 0, NULL);          gc = XCreateGC(display, bitmap, 0, NULL);
645    
646          image = XCreateImage(display, visual, 1, ZPixmap, 0,          image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
647                               data, width, height, 8, scanline);                               width, height, 8, scanline);
648          image->byte_order = MSBFirst;          image->byte_order = MSBFirst;
649          image->bitmap_bit_order = MSBFirst;          image->bitmap_bit_order = MSBFirst;
650          XInitImage(image);          XInitImage(image);
# Line 517  ui_create_glyph(int width, int height, u Line 653  ui_create_glyph(int width, int height, u
653    
654          XFree(image);          XFree(image);
655          XFreeGC(display, gc);          XFreeGC(display, gc);
656          return (HGLYPH)bitmap;          return (HGLYPH) bitmap;
657  }  }
658    
659  void  void
660  ui_destroy_glyph(HGLYPH glyph)  ui_destroy_glyph(HGLYPH glyph)
661  {  {
662          XFreePixmap(display, (Pixmap)glyph);          XFreePixmap(display, (Pixmap) glyph);
663  }  }
664    
665  HCURSOR  HCURSOR
666  ui_create_cursor(unsigned int x, unsigned int y, int width,  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
667                   int height, uint8 *andmask, uint8 *xormask)                   uint8 * andmask, uint8 * xormask)
668  {  {
669          HGLYPH maskglyph, cursorglyph;          HGLYPH maskglyph, cursorglyph;
670          XColor bg, fg;          XColor bg, fg;
# Line 585  ui_create_cursor(unsigned int x, unsigne Line 721  ui_create_cursor(unsigned int x, unsigne
721    
722          cursorglyph = ui_create_glyph(width, height, cursor);          cursorglyph = ui_create_glyph(width, height, cursor);
723          maskglyph = ui_create_glyph(width, height, mask);          maskglyph = ui_create_glyph(width, height, mask);
724            
725          xcursor = XCreatePixmapCursor(display, (Pixmap)cursorglyph,          xcursor =
726                                  (Pixmap)maskglyph, &fg, &bg, x, y);                  XCreatePixmapCursor(display, (Pixmap) cursorglyph,
727                                        (Pixmap) maskglyph, &fg, &bg, x, y);
728    
729          ui_destroy_glyph(maskglyph);          ui_destroy_glyph(maskglyph);
730          ui_destroy_glyph(cursorglyph);          ui_destroy_glyph(cursorglyph);
731          xfree(mask);          xfree(mask);
732          xfree(cursor);          xfree(cursor);
733          return (HCURSOR)xcursor;          return (HCURSOR) xcursor;
734  }  }
735    
736  void  void
737  ui_set_cursor(HCURSOR cursor)  ui_set_cursor(HCURSOR cursor)
738  {  {
739          XDefineCursor(display, wnd, (Cursor)cursor);          XDefineCursor(display, wnd, (Cursor) cursor);
740  }  }
741    
742  void  void
743  ui_destroy_cursor(HCURSOR cursor)  ui_destroy_cursor(HCURSOR cursor)
744  {  {
745          XFreeCursor(display, (Cursor)cursor);          XFreeCursor(display, (Cursor) cursor);
746  }  }
747    
748  #define MAKE_XCOLOR(xc,c) \  #define MAKE_XCOLOR(xc,c) \
# Line 615  ui_destroy_cursor(HCURSOR cursor) Line 752  ui_destroy_cursor(HCURSOR cursor)
752                  (xc)->flags = DoRed | DoGreen | DoBlue;                  (xc)->flags = DoRed | DoGreen | DoBlue;
753    
754  HCOLOURMAP  HCOLOURMAP
755  ui_create_colourmap(COLOURMAP *colours)  ui_create_colourmap(COLOURMAP * colours)
756  {  {
757          COLOURENTRY *entry;          COLOURENTRY *entry;
758          int i, ncolours = colours->ncolours;          int i, ncolours = colours->ncolours;
# Line 638  ui_create_colourmap(COLOURMAP *colours) Line 775  ui_create_colourmap(COLOURMAP *colours)
775                  XStoreColors(display, map, xcolours, ncolours);                  XStoreColors(display, map, xcolours, ncolours);
776    
777                  xfree(xcolours);                  xfree(xcolours);
778                  return (HCOLOURMAP)map;                  return (HCOLOURMAP) map;
779          }          }
780          else          else
781          {          {
# Line 668  void Line 805  void
805  ui_destroy_colourmap(HCOLOURMAP map)  ui_destroy_colourmap(HCOLOURMAP map)
806  {  {
807          if (owncolmap)          if (owncolmap)
808                  XFreeColormap(display, (Colormap)map);                  XFreeColormap(display, (Colormap) map);
809          else          else
810                  xfree(map);                  xfree(map);
811  }  }
# Line 677  void Line 814  void
814  ui_set_colourmap(HCOLOURMAP map)  ui_set_colourmap(HCOLOURMAP map)
815  {  {
816          if (owncolmap)          if (owncolmap)
817                  XSetWindowColormap(display, wnd, (Colormap)map);                  XSetWindowColormap(display, wnd, (Colormap) map);
818          else          else
819                  colmap = map;                  colmap = map;
820  }  }
# Line 724  ui_destblt(uint8 opcode, Line 861  ui_destblt(uint8 opcode,
861  void  void
862  ui_patblt(uint8 opcode,  ui_patblt(uint8 opcode,
863            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
864            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
865  {  {
866          Pixmap fill;          Pixmap fill;
867            uint8 i, ipattern[8];
868    
869          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
870    
# Line 738  ui_patblt(uint8 opcode, Line 876  ui_patblt(uint8 opcode,
876                          break;                          break;
877    
878                  case 3: /* Pattern */                  case 3: /* Pattern */
879                          fill = (Pixmap)ui_create_glyph(8, 8, brush->pattern);                          for (i = 0; i != 8; i++)
880                                    ipattern[7 - i] = brush->pattern[i];
881                            fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
882    
883                          SET_FOREGROUND(bgcolour);                          SET_FOREGROUND(bgcolour);
884                          SET_BACKGROUND(fgcolour);                          SET_BACKGROUND(fgcolour);
# Line 749  ui_patblt(uint8 opcode, Line 889  ui_patblt(uint8 opcode,
889                          FILL_RECTANGLE(x, y, cx, cy);                          FILL_RECTANGLE(x, y, cx, cy);
890    
891                          XSetFillStyle(display, gc, FillSolid);                          XSetFillStyle(display, gc, FillSolid);
892                          ui_destroy_glyph((HGLYPH)fill);                          XSetTSOrigin(display, gc, 0, 0);
893                            ui_destroy_glyph((HGLYPH) fill);
894                          break;                          break;
895    
896                  default:                  default:
# Line 767  ui_screenblt(uint8 opcode, Line 908  ui_screenblt(uint8 opcode,
908          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
909          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
910          if (ownbackstore)          if (ownbackstore)
911                  XCopyArea(display, backstore, backstore, gc, srcx, srcy,                  XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
912          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
913  }  }
914    
# Line 778  ui_memblt(uint8 opcode, Line 918  ui_memblt(uint8 opcode,
918            /* src */ HBITMAP src, int srcx, int srcy)            /* src */ HBITMAP src, int srcx, int srcy)
919  {  {
920          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
921          XCopyArea(display, (Pixmap)src, wnd, gc, srcx, srcy, cx, cy, x, y);          XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
922          if (ownbackstore)          if (ownbackstore)
923                  XCopyArea(display, (Pixmap)src, backstore, gc, srcx, srcy,                  XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
                           cx, cy, x, y);  
924          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
925  }  }
926    
# Line 789  void Line 928  void
928  ui_triblt(uint8 opcode,  ui_triblt(uint8 opcode,
929            /* dest */ int x, int y, int cx, int cy,            /* dest */ int x, int y, int cx, int cy,
930            /* src */ HBITMAP src, int srcx, int srcy,            /* src */ HBITMAP src, int srcx, int srcy,
931            /* brush */ BRUSH *brush, int bgcolour, int fgcolour)            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
932  {  {
933          /* This is potentially difficult to do in general. Until someone          /* This is potentially difficult to do in general. Until someone
934             comes up with a more efficient way of doing it I am using cases. */             comes up with a more efficient way of doing it I am using cases. */
# Line 798  ui_triblt(uint8 opcode, Line 937  ui_triblt(uint8 opcode,
937          {          {
938                  case 0x69:      /* PDSxxn */                  case 0x69:      /* PDSxxn */
939                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
940                          ui_patblt(ROP2_NXOR, x, y, cx, cy,                          ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
941                          break;                          break;
942    
943                  case 0xb8:      /* PSDPxax */                  case 0xb8:      /* PSDPxax */
944                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
945                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
946                          ui_patblt(ROP2_XOR, x, y, cx, cy,                          ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   brush, bgcolour, fgcolour);  
947                          break;                          break;
948    
949                  case 0xc0:      /* PSa */                  case 0xc0:      /* PSa */
950                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);                          ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
951                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,                          ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                                   fgcolour);  
952                          break;                          break;
953    
954                  default:                  default:
# Line 825  ui_triblt(uint8 opcode, Line 960  ui_triblt(uint8 opcode,
960  void  void
961  ui_line(uint8 opcode,  ui_line(uint8 opcode,
962          /* dest */ int startx, int starty, int endx, int endy,          /* dest */ int startx, int starty, int endx, int endy,
963          /* pen */ PEN *pen)          /* pen */ PEN * pen)
964  {  {
965          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
966          SET_FOREGROUND(pen->colour);          SET_FOREGROUND(pen->colour);
# Line 847  ui_rect( Line 982  ui_rect(
982  void  void
983  ui_draw_glyph(int mixmode,  ui_draw_glyph(int mixmode,
984                /* dest */ int x, int y, int cx, int cy,                /* dest */ int x, int y, int cx, int cy,
985                /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,                /* src */ HGLYPH glyph, int srcx, int srcy,
986                int fgcolour)                int bgcolour, int fgcolour)
987  {  {
988          SET_FOREGROUND(fgcolour);          SET_FOREGROUND(fgcolour);
989          SET_BACKGROUND(bgcolour);          SET_BACKGROUND(bgcolour);
990    
991          XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)          XSetFillStyle(display, gc,
992                        ? FillStippled : FillOpaqueStippled);                        (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
993          XSetStipple(display, gc, (Pixmap)glyph);          XSetStipple(display, gc, (Pixmap) glyph);
994          XSetTSOrigin(display, gc, x, y);          XSetTSOrigin(display, gc, x, y);
995    
996          FILL_RECTANGLE(x, y, cx, cy);          FILL_RECTANGLE(x, y, cx, cy);
# Line 863  ui_draw_glyph(int mixmode, Line 998  ui_draw_glyph(int mixmode,
998          XSetFillStyle(display, gc, FillSolid);          XSetFillStyle(display, gc, FillSolid);
999  }  }
1000    
1001    #define DO_GLYPH(ttext,idx) \
1002    {\
1003      glyph = cache_get_font (font, ttext[idx]);\
1004      if (!(flags & TEXT2_IMPLICIT_X))\
1005        {\
1006          xyoffset = ttext[++idx];\
1007          if ((xyoffset & 0x80))\
1008            {\
1009              if (flags & TEXT2_VERTICAL) \
1010                y += ttext[idx+1] | (ttext[idx+2] << 8);\
1011              else\
1012                x += ttext[idx+1] | (ttext[idx+2] << 8);\
1013              idx += 2;\
1014            }\
1015          else\
1016            {\
1017              if (flags & TEXT2_VERTICAL) \
1018                y += xyoffset;\
1019              else\
1020                x += xyoffset;\
1021            }\
1022        }\
1023      if (glyph != NULL)\
1024        {\
1025          ui_draw_glyph (mixmode, x + (short) glyph->offset,\
1026                         y + (short) glyph->baseline,\
1027                         glyph->width, glyph->height,\
1028                         glyph->pixmap, 0, 0, bgcolour, fgcolour);\
1029          if (flags & TEXT2_IMPLICIT_X)\
1030            x += glyph->width;\
1031        }\
1032    }
1033    
1034  void  void
1035  ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y,  ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y,
1036               int clipx, int clipy, int clipcx, int clipcy,               int clipx, int clipy, int clipcx, int clipcy,
1037               int boxx, int boxy, int boxcx, int boxcy,               int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
1038               int bgcolour, int fgcolour, uint8 *text, uint8 length)               int fgcolour, uint8 * text, uint8 length)
1039  {  {
1040          FONTGLYPH *glyph;          FONTGLYPH *glyph;
1041          int i, offset;          int i, j, xyoffset;
1042            DATABLOB *entry;
1043    
1044          SET_FOREGROUND(bgcolour);          SET_FOREGROUND(bgcolour);
1045    
# Line 884  ui_draw_text(uint8 font, uint8 flags, in Line 1053  ui_draw_text(uint8 font, uint8 flags, in
1053          }          }
1054    
1055          /* Paint text, character by character */          /* Paint text, character by character */
1056          for (i = 0; i < length; i++)          for (i = 0; i < length;)
1057          {          {
1058                  glyph = cache_get_font(font, text[i]);                  switch (text[i])
   
                 if (!(flags & TEXT2_IMPLICIT_X))  
1059                  {                  {
1060                          offset = text[++i];                          case 0xff:
1061                          if (offset & 0x80)                                  if (i + 2 < length)
1062                                  offset = ((offset & 0x7f) << 8) | text[++i];                                          cache_put_text(text[i + 1], text, text[i + 2]);
1063                                    else
1064                          if (flags & TEXT2_VERTICAL)                                  {
1065                                  y += offset;                                          error("this shouldn't be happening\n");
1066                          else                                          break;
1067                                  x += offset;                                  }
1068                  }                                  /* this will move pointer from start to first character after FF command */
1069                                    length -= i + 3;
1070                                    text = &(text[i + 3]);
1071                                    i = 0;
1072                                    break;
1073    
1074                  if (glyph != NULL)                          case 0xfe:
1075                  {                                  entry = cache_get_text(text[i + 1]);
1076                          ui_draw_glyph(mixmode, x + (short) glyph->offset,                                  if (entry != NULL)
1077                                        y + (short) glyph->baseline,                                  {
1078                                        glyph->width, glyph->height,                                          if ((((uint8 *) (entry->data))[1] ==
1079                                        glyph->pixmap, 0, 0,                                               0) && (!(flags & TEXT2_IMPLICIT_X)))
1080                                        bgcolour, fgcolour);                                          {
1081                                                    if (flags & TEXT2_VERTICAL)
1082                                                            y += text[i + 2];
1083                                                    else
1084                                                            x += text[i + 2];
1085                                            }
1086                                            if (i + 2 < length)
1087                                                    i += 3;
1088                                            else
1089                                                    i += 2;
1090                                            length -= i;
1091                                            /* this will move pointer from start to first character after FE command */
1092                                            text = &(text[i]);
1093                                            i = 0;
1094                                            for (j = 0; j < entry->size; j++)
1095                                                    DO_GLYPH(((uint8 *) (entry->data)), j);
1096                                    }
1097                                    break;
1098    
1099                          if (flags & TEXT2_IMPLICIT_X)                          default:
1100                                  x += glyph->width;                                  DO_GLYPH(text, i);
1101                                    i++;
1102                                    break;
1103                  }                  }
1104          }          }
1105    
1106    
1107  }  }
1108    
1109  void  void
# Line 922  ui_desktop_save(uint32 offset, int x, in Line 1114  ui_desktop_save(uint32 offset, int x, in
1114    
1115          if (ownbackstore)          if (ownbackstore)
1116          {          {
1117                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,                  image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1118          }          }
1119          else          else
1120          {          {
1121                  pix = XCreatePixmap(display, wnd, cx, cy, depth);                  pix = XCreatePixmap(display, wnd, cx, cy, depth);
1122                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);                  XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
1123                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,                  image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
                                   ZPixmap);  
1124                  XFreePixmap(display, pix);                  XFreePixmap(display, pix);
1125          }          }
1126    
1127          offset *= bpp/8;          offset *= bpp / 8;
1128          cache_put_desktop(offset, cx, cy, image->bytes_per_line,          cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8, (uint8 *) image->data);
                           bpp/8, (uint8 *)image->data);  
1129    
1130          XDestroyImage(image);          XDestroyImage(image);
1131  }  }
# Line 947  ui_desktop_restore(uint32 offset, int x, Line 1136  ui_desktop_restore(uint32 offset, int x,
1136          XImage *image;          XImage *image;
1137          uint8 *data;          uint8 *data;
1138    
1139          offset *= bpp/8;          offset *= bpp / 8;
1140          data = cache_get_desktop(offset, cx, cy, bpp/8);          data = cache_get_desktop(offset, cx, cy, bpp / 8);
1141          if (data == NULL)          if (data == NULL)
1142                  return;                  return;
1143    
1144          image = XCreateImage(display, visual, depth, ZPixmap,          image = XCreateImage(display, visual, depth, ZPixmap, 0,
1145                               0, data, cx, cy, BitmapPad(display),                               (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
                              cx * bpp/8);  
1146    
1147          if (ownbackstore)          if (ownbackstore)
1148          {          {
Legend:
Removed from v.38  
changed lines
  Added in v.84
  ViewVC Help
Powered by ViewVC 1.1.26