/[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 988 by astrand, Thu Aug 25 20:27:45 2005 UTC revision 1246 by stargo, Tue Jul 11 17:22:24 2006 UTC
# Line 28  Line 28 
28  #include "rdesktop.h"  #include "rdesktop.h"
29  #include "xproto.h"  #include "xproto.h"
30    
31    /* We can't include Xproto.h because of conflicting defines for BOOL */
32    #define X_ConfigureWindow              12
33    
34  extern int g_width;  extern int g_width;
35  extern int g_height;  extern int g_height;
36  extern int g_xpos;  extern int g_xpos;
# Line 38  extern BOOL g_fullscreen; Line 41  extern BOOL g_fullscreen;
41  extern BOOL g_grab_keyboard;  extern BOOL g_grab_keyboard;
42  extern BOOL g_hide_decorations;  extern BOOL g_hide_decorations;
43  extern char g_title[];  extern char g_title[];
44  extern int g_server_bpp;  /* Color depth of the RDP session.
45       As of RDP 5.1, it may be 8, 15, 16 or 24. */
46    extern int g_server_depth;
47  extern int g_win_button_size;  extern int g_win_button_size;
48    
49  Display *g_display;  Display *g_display;
# Line 46  Time g_last_gesturetime; Line 51  Time g_last_gesturetime;
51  static int g_x_socket;  static int g_x_socket;
52  static Screen *g_screen;  static Screen *g_screen;
53  Window g_wnd;  Window g_wnd;
54    
55    /* SeamlessRDP support */
56    typedef struct _seamless_group
57    {
58            Window wnd;
59            unsigned long id;
60            unsigned int refcnt;
61    } seamless_group;
62    typedef struct _seamless_window
63    {
64            Window wnd;
65            unsigned long id;
66            unsigned long behind;
67            seamless_group *group;
68            int xoffset, yoffset;
69            int width, height;
70            int state;              /* normal/minimized/maximized. */
71            unsigned int desktop;
72            struct timeval *position_timer;
73    
74            BOOL outstanding_position;
75            unsigned int outpos_serial;
76            int outpos_xoffset, outpos_yoffset;
77            int outpos_width, outpos_height;
78    
79            struct _seamless_window *next;
80    } seamless_window;
81    static seamless_window *g_seamless_windows = NULL;
82    static unsigned long g_seamless_focused = 0;
83    static BOOL g_seamless_started = False; /* Server end is up and running */
84    static BOOL g_seamless_active = False;  /* We are currently in seamless mode */
85    static BOOL g_seamless_hidden = False;  /* Desktop is hidden on server */
86    extern BOOL g_seamless_rdp;
87    
88  extern uint32 g_embed_wnd;  extern uint32 g_embed_wnd;
89  BOOL g_enable_compose = False;  BOOL g_enable_compose = False;
90  BOOL g_Unobscured;              /* used for screenblt */  BOOL g_Unobscured;              /* used for screenblt */
91  static GC g_gc = NULL;  static GC g_gc = NULL;
92  static GC g_create_bitmap_gc = NULL;  static GC g_create_bitmap_gc = NULL;
93  static GC g_create_glyph_gc = NULL;  static GC g_create_glyph_gc = NULL;
94    static XRectangle g_clip_rectangle;
95  static Visual *g_visual;  static Visual *g_visual;
96    /* Color depth of the X11 visual of our window (e.g. 24 for True Color R8G8B visual).
97       This may be 32 for R8G8B8 visuals, and then the rest of the bits are undefined
98       as far as we're concerned. */
99  static int g_depth;  static int g_depth;
100    /* Bits-per-Pixel of the pixmaps we'll be using to draw on our window.
101       This may be larger than g_depth, in which case some of the bits would
102       be kept solely for alignment (e.g. 32bpp pixmaps on a 24bpp visual). */
103  static int g_bpp;  static int g_bpp;
104  static XIM g_IM;  static XIM g_IM;
105  static XIC g_IC;  static XIC g_IC;
# Line 61  static XModifierKeymap *g_mod_map; Line 107  static XModifierKeymap *g_mod_map;
107  static Cursor g_current_cursor;  static Cursor g_current_cursor;
108  static HCURSOR g_null_cursor = NULL;  static HCURSOR g_null_cursor = NULL;
109  static Atom g_protocol_atom, g_kill_atom;  static Atom g_protocol_atom, g_kill_atom;
110    extern Atom g_net_wm_state_atom;
111    extern Atom g_net_wm_desktop_atom;
112  static BOOL g_focused;  static BOOL g_focused;
113  static BOOL g_mouse_in_wnd;  static BOOL g_mouse_in_wnd;
114  static BOOL g_arch_match = False;       /* set to True if RGB XServer and little endian */  /* Indicates that:
115       1) visual has 15, 16 or 24 depth and the same color channel masks
116          as its RDP equivalent (implies X server is LE),
117       2) host is LE
118       This will trigger an optimization whose real value is questionable.
119    */
120    static BOOL g_compatible_arch;
121    /* Indicates whether RDP's bitmaps and our XImages have the same
122       binary format. If so, we can avoid an expensive translation.
123       Note that this can be true when g_compatible_arch is false,
124       e.g.:
125      
126         RDP(LE) <-> host(BE) <-> X-Server(LE)
127        
128       ('host' is the machine running rdesktop; the host simply memcpy's
129        so its endianess doesn't matter)
130     */
131    static BOOL g_no_translate_image = False;
132    
133  /* endianness */  /* endianness */
134  static BOOL g_host_be;  static BOOL g_host_be;
# Line 79  static Pixmap g_backstore = 0; Line 144  static Pixmap g_backstore = 0;
144  static BOOL g_moving_wnd;  static BOOL g_moving_wnd;
145  static int g_move_x_offset = 0;  static int g_move_x_offset = 0;
146  static int g_move_y_offset = 0;  static int g_move_y_offset = 0;
147    static BOOL g_using_full_workarea = False;
148    
149  #ifdef WITH_RDPSND  #ifdef WITH_RDPSND
150  extern int g_dsp_fd;  extern int g_dsp_fd;
# Line 91  extern BOOL g_rdpsnd; Line 157  extern BOOL g_rdpsnd;
157  #define PROP_MOTIF_WM_HINTS_ELEMENTS    5  #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
158  typedef struct  typedef struct
159  {  {
160          uint32 flags;          unsigned long flags;
161          uint32 functions;          unsigned long functions;
162          uint32 decorations;          unsigned long decorations;
163          sint32 inputMode;          long inputMode;
164          uint32 status;          unsigned long status;
165  }  }
166  PropMotifWmHints;  PropMotifWmHints;
167    
# Line 107  typedef struct Line 173  typedef struct
173  }  }
174  PixelColour;  PixelColour;
175    
176    #define ON_ALL_SEAMLESS_WINDOWS(func, args) \
177            do { \
178                    seamless_window *sw; \
179                    XRectangle rect; \
180                    if (!g_seamless_windows) break; \
181                    for (sw = g_seamless_windows; sw; sw = sw->next) { \
182                        rect.x = g_clip_rectangle.x - sw->xoffset; \
183                        rect.y = g_clip_rectangle.y - sw->yoffset; \
184                        rect.width = g_clip_rectangle.width; \
185                        rect.height = g_clip_rectangle.height; \
186                        XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded); \
187                        func args; \
188                    } \
189                    XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded); \
190            } while (0)
191    
192    static void
193    seamless_XFillPolygon(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
194    {
195            points[0].x -= xoffset;
196            points[0].y -= yoffset;
197            XFillPolygon(g_display, d, g_gc, points, npoints, Complex, CoordModePrevious);
198            points[0].x += xoffset;
199            points[0].y += yoffset;
200    }
201    
202    static void
203    seamless_XDrawLines(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
204    {
205            points[0].x -= xoffset;
206            points[0].y -= yoffset;
207            XDrawLines(g_display, d, g_gc, points, npoints, CoordModePrevious);
208            points[0].x += xoffset;
209            points[0].y += yoffset;
210    }
211    
212  #define FILL_RECTANGLE(x,y,cx,cy)\  #define FILL_RECTANGLE(x,y,cx,cy)\
213  { \  { \
214          XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \          XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \
215            ON_ALL_SEAMLESS_WINDOWS(XFillRectangle, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy)); \
216          if (g_ownbackstore) \          if (g_ownbackstore) \
217                  XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \                  XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \
218  }  }
# Line 125  PixelColour; Line 227  PixelColour;
227          XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \          XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \
228          if (g_ownbackstore) \          if (g_ownbackstore) \
229                  XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \                  XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \
230            ON_ALL_SEAMLESS_WINDOWS(seamless_XFillPolygon, (sw->wnd, p, np, sw->xoffset, sw->yoffset)); \
231  }  }
232    
233  #define DRAW_ELLIPSE(x,y,cx,cy,m)\  #define DRAW_ELLIPSE(x,y,cx,cy,m)\
# Line 133  PixelColour; Line 236  PixelColour;
236          { \          { \
237                  case 0: /* Outline */ \                  case 0: /* Outline */ \
238                          XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \                          XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
239                            ON_ALL_SEAMLESS_WINDOWS(XDrawArc, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy, 0, 360*64)); \
240                          if (g_ownbackstore) \                          if (g_ownbackstore) \
241                                  XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \                                  XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
242                          break; \                          break; \
243                  case 1: /* Filled */ \                  case 1: /* Filled */ \
244                          XFillArc(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, \                          XFillArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
245                                   cx, cy, 0, 360*64); \                          ON_ALL_SEAMLESS_WINDOWS(XCopyArea, (g_display, g_ownbackstore ? g_backstore : g_wnd, sw->wnd, g_gc, \
246                                                                x, y, cx, cy, x-sw->xoffset, y-sw->yoffset)); \
247                          if (g_ownbackstore) \                          if (g_ownbackstore) \
248                                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y); \                                  XFillArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
249                          break; \                          break; \
250          } \          } \
251  }  }
# Line 150  extern BOOL g_owncolmap; Line 255  extern BOOL g_owncolmap;
255  static Colormap g_xcolmap;  static Colormap g_xcolmap;
256  static uint32 *g_colmap = NULL;  static uint32 *g_colmap = NULL;
257    
258  #define TRANSLATE(col)          ( g_server_bpp != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )  #define TRANSLATE(col)          ( g_server_depth != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )
259  #define SET_FOREGROUND(col)     XSetForeground(g_display, g_gc, TRANSLATE(col));  #define SET_FOREGROUND(col)     XSetForeground(g_display, g_gc, TRANSLATE(col));
260  #define SET_BACKGROUND(col)     XSetBackground(g_display, g_gc, TRANSLATE(col));  #define SET_BACKGROUND(col)     XSetBackground(g_display, g_gc, TRANSLATE(col));
261    
# Line 176  static int rop2_map[] = { Line 281  static int rop2_map[] = {
281  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }
282  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }
283    
284    static seamless_window *
285    sw_get_window_by_id(unsigned long id)
286    {
287            seamless_window *sw;
288            for (sw = g_seamless_windows; sw; sw = sw->next)
289            {
290                    if (sw->id == id)
291                            return sw;
292            }
293            return NULL;
294    }
295    
296    
297    static seamless_window *
298    sw_get_window_by_wnd(Window wnd)
299    {
300            seamless_window *sw;
301            for (sw = g_seamless_windows; sw; sw = sw->next)
302            {
303                    if (sw->wnd == wnd)
304                            return sw;
305            }
306            return NULL;
307    }
308    
309    
310    static void
311    sw_remove_window(seamless_window * win)
312    {
313            seamless_window *sw, **prevnext = &g_seamless_windows;
314            for (sw = g_seamless_windows; sw; sw = sw->next)
315            {
316                    if (sw == win)
317                    {
318                            *prevnext = sw->next;
319                            sw->group->refcnt--;
320                            if (sw->group->refcnt == 0)
321                            {
322                                    XDestroyWindow(g_display, sw->group->wnd);
323                                    xfree(sw->group);
324                            }
325                            xfree(sw->position_timer);
326                            xfree(sw);
327                            return;
328                    }
329                    prevnext = &sw->next;
330            }
331            return;
332    }
333    
334    
335    /* Move all windows except wnd to new desktop */
336    static void
337    sw_all_to_desktop(Window wnd, unsigned int desktop)
338    {
339            seamless_window *sw;
340            for (sw = g_seamless_windows; sw; sw = sw->next)
341            {
342                    if (sw->wnd == wnd)
343                            continue;
344                    if (sw->desktop != desktop)
345                    {
346                            ewmh_move_to_desktop(sw->wnd, desktop);
347                            sw->desktop = desktop;
348                    }
349            }
350    }
351    
352    
353    /* Send our position */
354    static void
355    sw_update_position(seamless_window * sw)
356    {
357            XWindowAttributes wa;
358            int x, y;
359            Window child_return;
360            unsigned int serial;
361    
362            XGetWindowAttributes(g_display, sw->wnd, &wa);
363            XTranslateCoordinates(g_display, sw->wnd, wa.root,
364                                  -wa.border_width, -wa.border_width, &x, &y, &child_return);
365    
366            serial = seamless_send_position(sw->id, x, y, wa.width, wa.height, 0);
367    
368            sw->outstanding_position = True;
369            sw->outpos_serial = serial;
370    
371            sw->outpos_xoffset = x;
372            sw->outpos_yoffset = y;
373            sw->outpos_width = wa.width;
374            sw->outpos_height = wa.height;
375    }
376    
377    
378    /* Check if it's time to send our position */
379    static void
380    sw_check_timers()
381    {
382            seamless_window *sw;
383            struct timeval now;
384    
385            gettimeofday(&now, NULL);
386            for (sw = g_seamless_windows; sw; sw = sw->next)
387            {
388                    if (timerisset(sw->position_timer) && timercmp(sw->position_timer, &now, <))
389                    {
390                            timerclear(sw->position_timer);
391                            sw_update_position(sw);
392                    }
393            }
394    }
395    
396    
397    static void
398    sw_restack_window(seamless_window * sw, unsigned long behind)
399    {
400            seamless_window *sw_above;
401    
402            /* Remove window from stack */
403            for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
404            {
405                    if (sw_above->behind == sw->id)
406                            break;
407            }
408    
409            if (sw_above)
410                    sw_above->behind = sw->behind;
411    
412            /* And then add it at the new position */
413            for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
414            {
415                    if (sw_above->behind == behind)
416                            break;
417            }
418    
419            if (sw_above)
420                    sw_above->behind = sw->id;
421    
422            sw->behind = behind;
423    }
424    
425    
426    static void
427    sw_handle_restack(seamless_window * sw)
428    {
429            Status status;
430            Window root, parent, *children;
431            unsigned int nchildren, i;
432            seamless_window *sw_below;
433    
434            status = XQueryTree(g_display, RootWindowOfScreen(g_screen),
435                                &root, &parent, &children, &nchildren);
436            if (!status || !nchildren)
437                    return;
438    
439            sw_below = NULL;
440    
441            i = 0;
442            while (children[i] != sw->wnd)
443            {
444                    i++;
445                    if (i >= nchildren)
446                            goto end;
447            }
448    
449            for (i++; i < nchildren; i++)
450            {
451                    sw_below = sw_get_window_by_wnd(children[i]);
452                    if (sw_below)
453                            break;
454            }
455    
456            if (!sw_below && !sw->behind)
457                    goto end;
458            if (sw_below && (sw_below->id == sw->behind))
459                    goto end;
460    
461            if (sw_below)
462            {
463                    seamless_send_zchange(sw->id, sw_below->id, 0);
464                    sw_restack_window(sw, sw_below->id);
465            }
466            else
467            {
468                    seamless_send_zchange(sw->id, 0, 0);
469                    sw_restack_window(sw, 0);
470            }
471    
472          end:
473            XFree(children);
474    }
475    
476    
477    static seamless_group *
478    sw_find_group(unsigned long id, BOOL dont_create)
479    {
480            seamless_window *sw;
481            seamless_group *sg;
482            XSetWindowAttributes attribs;
483    
484            for (sw = g_seamless_windows; sw; sw = sw->next)
485            {
486                    if (sw->group->id == id)
487                            return sw->group;
488            }
489    
490            if (dont_create)
491                    return NULL;
492    
493            sg = xmalloc(sizeof(seamless_group));
494    
495            sg->wnd =
496                    XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0,
497                                  CopyFromParent, CopyFromParent, CopyFromParent, 0, &attribs);
498    
499            sg->id = id;
500            sg->refcnt = 0;
501    
502            return sg;
503    }
504    
505    
506  static void  static void
507  mwm_hide_decorations(void)  mwm_hide_decorations(Window wnd)
508  {  {
509          PropMotifWmHints motif_hints;          PropMotifWmHints motif_hints;
510          Atom hintsatom;          Atom hintsatom;
# Line 194  mwm_hide_decorations(void) Line 521  mwm_hide_decorations(void)
521                  return;                  return;
522          }          }
523    
524          XChangeProperty(g_display, g_wnd, hintsatom, hintsatom, 32, PropModeReplace,          XChangeProperty(g_display, wnd, hintsatom, hintsatom, 32, PropModeReplace,
525                          (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);                          (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
526    
527  }  }
528    
529  #define SPLITCOLOUR15(colour, rv) \  #define SPLITCOLOUR15(colour, rv) \
# Line 229  mwm_hide_decorations(void) Line 557  mwm_hide_decorations(void)
557  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
558                          x = (x << 16) | (x >> 16); }                          x = (x << 16) | (x >> 16); }
559    
560    /* The following macros output the same octet sequences
561       on both BE and LE hosts: */
562    
563  #define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; }  #define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; }
564  #define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }  #define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
565  #define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }  #define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
# Line 240  static uint32 Line 571  static uint32
571  translate_colour(uint32 colour)  translate_colour(uint32 colour)
572  {  {
573          PixelColour pc;          PixelColour pc;
574          switch (g_server_bpp)          switch (g_server_depth)
575          {          {
576                  case 15:                  case 15:
577                          SPLITCOLOUR15(colour, pc);                          SPLITCOLOUR15(colour, pc);
# Line 251  translate_colour(uint32 colour) Line 582  translate_colour(uint32 colour)
582                  case 24:                  case 24:
583                          SPLITCOLOUR24(colour, pc);                          SPLITCOLOUR24(colour, pc);
584                          break;                          break;
585                    default:
586                            /* Avoid warning */
587                            pc.red = 0;
588                            pc.green = 0;
589                            pc.blue = 0;
590                            break;
591          }          }
592          return MAKECOLOUR(pc);          return MAKECOLOUR(pc);
593  }  }
# Line 302  translate8to16(const uint8 * data, uint8 Line 639  translate8to16(const uint8 * data, uint8
639  {  {
640          uint16 value;          uint16 value;
641    
642          if (g_arch_match)          if (g_compatible_arch)
643          {          {
644                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
645                  REPEAT2                  REPEAT2
# Line 336  translate8to24(const uint8 * data, uint8 Line 673  translate8to24(const uint8 * data, uint8
673  {  {
674          uint32 value;          uint32 value;
675    
676          if (g_xserver_be)          if (g_compatible_arch)
677          {          {
678                  while (out < end)                  while (out < end)
679                  {                  {
# Line 359  translate8to32(const uint8 * data, uint8 Line 696  translate8to32(const uint8 * data, uint8
696  {  {
697          uint32 value;          uint32 value;
698    
699          if (g_arch_match)          if (g_compatible_arch)
700          {          {
701                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
702                  REPEAT4                  REPEAT4
# Line 431  translate15to24(const uint16 * data, uin Line 768  translate15to24(const uint16 * data, uin
768          uint16 pixel;          uint16 pixel;
769          PixelColour pc;          PixelColour pc;
770    
771          if (g_arch_match)          if (g_compatible_arch)
772          {          {
773                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
774                  REPEAT3                  REPEAT3
# Line 481  translate15to32(const uint16 * data, uin Line 818  translate15to32(const uint16 * data, uin
818          uint32 value;          uint32 value;
819          PixelColour pc;          PixelColour pc;
820    
821          if (g_arch_match)          if (g_compatible_arch)
822          {          {
823                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
824                  REPEAT4                  REPEAT4
# Line 589  translate16to24(const uint16 * data, uin Line 926  translate16to24(const uint16 * data, uin
926          uint16 pixel;          uint16 pixel;
927          PixelColour pc;          PixelColour pc;
928    
929          if (g_arch_match)          if (g_compatible_arch)
930          {          {
931                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
932                  REPEAT3                  REPEAT3
# Line 659  translate16to32(const uint16 * data, uin Line 996  translate16to32(const uint16 * data, uin
996          uint32 value;          uint32 value;
997          PixelColour pc;          PixelColour pc;
998    
999          if (g_arch_match)          if (g_compatible_arch)
1000          {          {
1001                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
1002                  REPEAT4                  REPEAT4
# Line 788  translate24to32(const uint8 * data, uint Line 1125  translate24to32(const uint8 * data, uint
1125          uint32 value;          uint32 value;
1126          PixelColour pc;          PixelColour pc;
1127    
1128          if (g_arch_match)          if (g_compatible_arch)
1129          {          {
1130                  /* *INDENT-OFF* */                  /* *INDENT-OFF* */
1131  #ifdef NEED_ALIGN  #ifdef NEED_ALIGN
# Line 802  translate24to32(const uint8 * data, uint Line 1139  translate24to32(const uint8 * data, uint
1139  #else  #else
1140                  REPEAT4                  REPEAT4
1141                  (                  (
1142                          *((uint32 *) out) = *((uint32 *) data);                   /* Only read 3 bytes. Reading 4 bytes means reading beyond buffer. */
1143                          out += 4;                   *((uint32 *) out) = *((uint16 *) data) + (*((uint8 *) data + 2) << 16);
1144                          data += 3;                   out += 4;
1145                     data += 3;
1146                  )                  )
1147  #endif  #endif
1148                  /* *INDENT-ON* */                  /* *INDENT-ON* */
# Line 842  translate_image(int width, int height, u Line 1180  translate_image(int width, int height, u
1180          uint8 *out;          uint8 *out;
1181          uint8 *end;          uint8 *end;
1182    
1183          /* if server and xserver bpp match, */          /*
1184          /* and arch(endian) matches, no need to translate */             If RDP depth and X Visual depths match,
1185          /* just return data */             and arch(endian) matches, no need to translate:
1186          if (g_arch_match)             just return data.
1187               Note: select_visual should've already ensured g_no_translate
1188               is only set for compatible depths, but the RDP depth might've
1189               changed during connection negotiations.
1190             */
1191            if (g_no_translate_image)
1192          {          {
1193                  if (g_depth == 15 && g_server_bpp == 15)                  if ((g_depth == 15 && g_server_depth == 15) ||
1194                          return data;                      (g_depth == 16 && g_server_depth == 16) ||
1195                  if (g_depth == 16 && g_server_bpp == 16)                      (g_depth == 24 && g_server_depth == 24))
                         return data;  
                 if (g_depth == 24 && g_bpp == 24 && g_server_bpp == 24)  
1196                          return data;                          return data;
1197          }          }
1198    
# Line 859  translate_image(int width, int height, u Line 1200  translate_image(int width, int height, u
1200          out = (uint8 *) xmalloc(size);          out = (uint8 *) xmalloc(size);
1201          end = out + size;          end = out + size;
1202    
1203          switch (g_server_bpp)          switch (g_server_depth)
1204          {          {
1205                  case 24:                  case 24:
1206                          switch (g_bpp)                          switch (g_bpp)
# Line 957  calculate_shifts(uint32 mask, int *shift Line 1298  calculate_shifts(uint32 mask, int *shift
1298          *shift_r = 8 - ffs(mask & ~(mask >> 1));          *shift_r = 8 - ffs(mask & ~(mask >> 1));
1299  }  }
1300    
1301  BOOL  /* Given a mask of a colour channel (e.g. XVisualInfo.red_mask),
1302  ui_init(void)     calculates the bits-per-pixel of this channel (a.k.a. colour weight).
1303     */
1304    static unsigned
1305    calculate_mask_weight(uint32 mask)
1306    {
1307            unsigned weight = 0;
1308            do
1309            {
1310                    weight += (mask & 1);
1311            }
1312            while (mask >>= 1);
1313            return weight;
1314    }
1315    
1316    static BOOL
1317    select_visual(int screen_num)
1318  {  {
         XVisualInfo vi;  
1319          XPixmapFormatValues *pfm;          XPixmapFormatValues *pfm;
1320          uint16 test;          int pixmap_formats_count, visuals_count;
         int i, screen_num, nvisuals;  
1321          XVisualInfo *vmatches = NULL;          XVisualInfo *vmatches = NULL;
1322          XVisualInfo template;          XVisualInfo template;
1323          Bool TrueColorVisual = False;          int i;
1324            unsigned red_weight, blue_weight, green_weight;
1325    
1326          g_display = XOpenDisplay(NULL);          red_weight = blue_weight = green_weight = 0;
1327          if (g_display == NULL)  
1328            if (g_server_depth == -1)
1329          {          {
1330                  error("Failed to open display: %s\n", XDisplayName(NULL));                  g_server_depth = DisplayPlanes(g_display, DefaultScreen(g_display));
                 return False;  
1331          }          }
1332    
1333          screen_num = DefaultScreen(g_display);          pfm = XListPixmapFormats(g_display, &pixmap_formats_count);
1334          g_x_socket = ConnectionNumber(g_display);          if (pfm == NULL)
1335          g_screen = ScreenOfDisplay(g_display, screen_num);          {
1336          g_depth = DefaultDepthOfScreen(g_screen);                  error("Unable to get list of pixmap formats from display.\n");
1337                    XCloseDisplay(g_display);
1338                    return False;
1339            }
1340    
1341          /* Search for best TrueColor depth */          /* Search for best TrueColor visual */
1342          template.class = TrueColor;          template.class = TrueColor;
1343          vmatches = XGetVisualInfo(g_display, VisualClassMask, &template, &nvisuals);          template.screen = screen_num;
1344            vmatches = XGetVisualInfo(g_display, VisualClassMask | VisualScreenMask, &template, &visuals_count);
1345            g_visual = NULL;
1346            g_no_translate_image = False;
1347            g_compatible_arch = False;
1348            if (vmatches != NULL)
1349            {
1350                    for (i = 0; i < visuals_count; ++i)
1351                    {
1352                            XVisualInfo *visual_info = &vmatches[i];
1353                            BOOL can_translate_to_bpp = False;
1354                            int j;
1355    
1356                            /* Try to find a no-translation visual that'll
1357                               allow us to use RDP bitmaps directly as ZPixmaps. */
1358                            if (!g_xserver_be && (((visual_info->depth == 15) &&
1359                                                   /* R5G5B5 */
1360                                                   (visual_info->red_mask == 0x7c00) &&
1361                                                   (visual_info->green_mask == 0x3e0) &&
1362                                                   (visual_info->blue_mask == 0x1f)) ||
1363                                                  ((visual_info->depth == 16) &&
1364                                                   /* R5G6B5 */
1365                                                   (visual_info->red_mask == 0xf800) &&
1366                                                   (visual_info->green_mask == 0x7e0) &&
1367                                                   (visual_info->blue_mask == 0x1f)) ||
1368                                                  ((visual_info->depth == 24) &&
1369                                                   /* R8G8B8 */
1370                                                   (visual_info->red_mask == 0xff0000) &&
1371                                                   (visual_info->green_mask == 0xff00) &&
1372                                                   (visual_info->blue_mask == 0xff))))
1373                            {
1374                                    g_visual = visual_info->visual;
1375                                    g_depth = visual_info->depth;
1376                                    g_compatible_arch = !g_host_be;
1377                                    g_no_translate_image = (visual_info->depth == g_server_depth);
1378                                    if (g_no_translate_image)
1379                                            /* We found the best visual */
1380                                            break;
1381                            }
1382                            else
1383                            {
1384                                    g_compatible_arch = False;
1385                            }
1386    
1387          nvisuals--;                          if (visual_info->depth > 24)
1388          while (nvisuals >= 0)                          {
1389          {                                  /* Avoid 32-bit visuals and likes like the plague.
1390                  if ((vmatches + nvisuals)->depth > g_depth)                                     They're either untested or proven to work bad
1391                  {                                     (e.g. nvidia's Composite 32-bit visual).
1392                          g_depth = (vmatches + nvisuals)->depth;                                     Most implementation offer a 24-bit visual anyway. */
1393                                    continue;
1394                            }
1395    
1396                            /* Only care for visuals, for whose BPPs (not depths!)
1397                               we have a translateXtoY function. */
1398                            for (j = 0; j < pixmap_formats_count; ++j)
1399                            {
1400                                    if (pfm[j].depth == visual_info->depth)
1401                                    {
1402                                            if ((pfm[j].bits_per_pixel == 16) ||
1403                                                (pfm[j].bits_per_pixel == 24) ||
1404                                                (pfm[j].bits_per_pixel == 32))
1405                                            {
1406                                                    can_translate_to_bpp = True;
1407                                            }
1408                                            break;
1409                                    }
1410                            }
1411    
1412                            /* Prefer formats which have the most colour depth.
1413                               We're being truly aristocratic here, minding each
1414                               weight on its own. */
1415                            if (can_translate_to_bpp)
1416                            {
1417                                    unsigned vis_red_weight =
1418                                            calculate_mask_weight(visual_info->red_mask);
1419                                    unsigned vis_green_weight =
1420                                            calculate_mask_weight(visual_info->green_mask);
1421                                    unsigned vis_blue_weight =
1422                                            calculate_mask_weight(visual_info->blue_mask);
1423                                    if ((vis_red_weight >= red_weight)
1424                                        && (vis_green_weight >= green_weight)
1425                                        && (vis_blue_weight >= blue_weight))
1426                                    {
1427                                            red_weight = vis_red_weight;
1428                                            green_weight = vis_green_weight;
1429                                            blue_weight = vis_blue_weight;
1430                                            g_visual = visual_info->visual;
1431                                            g_depth = visual_info->depth;
1432                                    }
1433                            }
1434                  }                  }
1435                  nvisuals--;                  XFree(vmatches);
                 TrueColorVisual = True;  
1436          }          }
1437    
1438          test = 1;          if (g_visual != NULL)
         g_host_be = !(BOOL) (*(uint8 *) (&test));  
         g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);  
   
         if ((g_server_bpp == 8) && ((!TrueColorVisual) || (g_depth <= 8)))  
1439          {          {
1440                  /* we use a colourmap, so the default visual should do */                  g_owncolmap = False;
1441                  g_visual = DefaultVisualOfScreen(g_screen);                  calculate_shifts(g_visual->red_mask, &g_red_shift_r, &g_red_shift_l);
1442                  g_depth = DefaultDepthOfScreen(g_screen);                  calculate_shifts(g_visual->green_mask, &g_green_shift_r, &g_green_shift_l);
1443                    calculate_shifts(g_visual->blue_mask, &g_blue_shift_r, &g_blue_shift_l);
                 /* Do not allocate colours on a TrueColor visual */  
                 if (g_visual->class == TrueColor)  
                 {  
                         g_owncolmap = False;  
                 }  
1444          }          }
1445          else          else
1446          {          {
1447                  /* need a truecolour visual */                  template.class = PseudoColor;
1448                  if (!XMatchVisualInfo(g_display, screen_num, g_depth, TrueColor, &vi))                  template.depth = 8;
1449                  {                  template.colormap_size = 256;
1450                          error("The display does not support true colour - high colour support unavailable.\n");                  vmatches =
1451                            XGetVisualInfo(g_display,
1452                                           VisualClassMask | VisualDepthMask | VisualColormapSizeMask,
1453                                           &template, &visuals_count);
1454                    if (vmatches == NULL)
1455                    {
1456                            error("No usable TrueColor or PseudoColor visuals on this display.\n");
1457                            XCloseDisplay(g_display);
1458                            XFree(pfm);
1459                          return False;                          return False;
1460                  }                  }
1461    
1462                  g_visual = vi.visual;                  /* we use a colourmap, so the default visual should do */
1463                  g_owncolmap = False;                  g_owncolmap = True;
1464                  calculate_shifts(vi.red_mask, &g_red_shift_r, &g_red_shift_l);                  g_visual = vmatches[0].visual;
1465                  calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l);                  g_depth = vmatches[0].depth;
1466                  calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l);          }
1467    
1468                  /* if RGB video and everything is little endian */          g_bpp = 0;
1469                  if ((vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask) &&          for (i = 0; i < pixmap_formats_count; ++i)
1470                      !g_xserver_be && !g_host_be)          {
1471                    XPixmapFormatValues *pf = &pfm[i];
1472                    if (pf->depth == g_depth)
1473                  {                  {
1474                          if (g_depth <= 16 || (g_red_shift_l == 16 && g_green_shift_l == 8 &&                          g_bpp = pf->bits_per_pixel;
1475                                                g_blue_shift_l == 0))  
1476                            if (g_no_translate_image)
1477                          {                          {
1478                                  g_arch_match = True;                                  switch (g_server_depth)
1479                                    {
1480                                            case 15:
1481                                            case 16:
1482                                                    if (g_bpp != 16)
1483                                                            g_no_translate_image = False;
1484                                                    break;
1485                                            case 24:
1486                                                    /* Yes, this will force image translation
1487                                                       on most modern servers which use 32 bits
1488                                                       for R8G8B8. */
1489                                                    if (g_bpp != 24)
1490                                                            g_no_translate_image = False;
1491                                                    break;
1492                                            default:
1493                                                    g_no_translate_image = False;
1494                                                    break;
1495                                    }
1496                          }                          }
                 }  
1497    
1498                  if (g_arch_match)                          /* Pixmap formats list is a depth-to-bpp mapping --
1499                  {                             there's just a single entry for every depth,
1500                          DEBUG(("Architectures match, enabling little endian optimisations.\n"));                             so we can safely break here */
1501                            break;
1502                  }                  }
1503          }          }
1504            XFree(pfm);
1505            pfm = NULL;
1506            return True;
1507    }
1508    
1509    static XErrorHandler g_old_error_handler;
1510    
1511          pfm = XListPixmapFormats(g_display, &i);  static int
1512          if (pfm != NULL)  error_handler(Display * dpy, XErrorEvent * eev)
1513    {
1514            if ((eev->error_code == BadMatch) && (eev->request_code == X_ConfigureWindow))
1515          {          {
1516                  /* Use maximum bpp for this depth - this is generally                  fprintf(stderr, "Got \"BadMatch\" when trying to restack windows.\n");
1517                     desirable, e.g. 24 bits->32 bits. */                  fprintf(stderr,
1518                  while (i--)                          "This is most likely caused by a broken window manager (commonly KWin).\n");
1519                  {                  return 0;
                         if ((pfm[i].depth == g_depth) && (pfm[i].bits_per_pixel > g_bpp))  
                         {  
                                 g_bpp = pfm[i].bits_per_pixel;  
                         }  
                 }  
                 XFree(pfm);  
1520          }          }
1521    
1522          if (g_bpp < 8)          return g_old_error_handler(dpy, eev);
1523    }
1524    
1525    BOOL
1526    ui_init(void)
1527    {
1528            int screen_num;
1529    
1530            g_display = XOpenDisplay(NULL);
1531            if (g_display == NULL)
1532          {          {
1533                  error("Less than 8 bpp not currently supported.\n");                  error("Failed to open display: %s\n", XDisplayName(NULL));
                 XCloseDisplay(g_display);  
1534                  return False;                  return False;
1535          }          }
1536    
1537            {
1538                    uint16 endianess_test = 1;
1539                    g_host_be = !(BOOL) (*(uint8 *) (&endianess_test));
1540            }
1541    
1542            g_old_error_handler = XSetErrorHandler(error_handler);
1543            g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);
1544            screen_num = DefaultScreen(g_display);
1545            g_x_socket = ConnectionNumber(g_display);
1546            g_screen = ScreenOfDisplay(g_display, screen_num);
1547            g_depth = DefaultDepthOfScreen(g_screen);
1548    
1549            if (!select_visual(screen_num))
1550                    return False;
1551    
1552            if (g_no_translate_image)
1553            {
1554                    DEBUG(("Performance optimization possible: avoiding image translation (colour depth conversion).\n"));
1555            }
1556    
1557            if (g_server_depth > g_bpp)
1558            {
1559                    warning("Remote desktop colour depth %d higher than display colour depth %d.\n",
1560                            g_server_depth, g_bpp);
1561            }
1562    
1563            DEBUG(("RDP depth: %d, display depth: %d, display bpp: %d, X server BE: %d, host BE: %d\n",
1564                   g_server_depth, g_depth, g_bpp, g_xserver_be, g_host_be));
1565    
1566          if (!g_owncolmap)          if (!g_owncolmap)
1567          {          {
1568                  g_xcolmap =                  g_xcolmap =
1569                          XCreateColormap(g_display, RootWindowOfScreen(g_screen), g_visual,                          XCreateColormap(g_display, RootWindowOfScreen(g_screen), g_visual,
1570                                          AllocNone);                                          AllocNone);
1571                  if (g_depth <= 8)                  if (g_depth <= 8)
1572                          warning("Screen depth is 8 bits or lower: you may want to use -C for a private colourmap\n");                          warning("Display colour depth is %d bit: you may want to use -C for a private colourmap.\n", g_depth);
1573          }          }
1574    
1575          if ((!g_ownbackstore) && (DoesBackingStore(g_screen) != Always))          if ((!g_ownbackstore) && (DoesBackingStore(g_screen) != Always))
1576          {          {
1577                  warning("External BackingStore not available, using internal\n");                  warning("External BackingStore not available. Using internal.\n");
1578                  g_ownbackstore = True;                  g_ownbackstore = True;
1579          }          }
1580    
# Line 1087  ui_init(void) Line 1585  ui_init(void)
1585          {          {
1586                  g_width = WidthOfScreen(g_screen);                  g_width = WidthOfScreen(g_screen);
1587                  g_height = HeightOfScreen(g_screen);                  g_height = HeightOfScreen(g_screen);
1588                    g_using_full_workarea = True;
1589          }          }
1590          else if (g_width < 0)          else if (g_width < 0)
1591          {          {
1592                  /* Percent of screen */                  /* Percent of screen */
1593                    if (-g_width >= 100)
1594                            g_using_full_workarea = True;
1595                  g_height = HeightOfScreen(g_screen) * (-g_width) / 100;                  g_height = HeightOfScreen(g_screen) * (-g_width) / 100;
1596                  g_width = WidthOfScreen(g_screen) * (-g_width) / 100;                  g_width = WidthOfScreen(g_screen) * (-g_width) / 100;
1597          }          }
# Line 1098  ui_init(void) Line 1599  ui_init(void)
1599          {          {
1600                  /* Fetch geometry from _NET_WORKAREA */                  /* Fetch geometry from _NET_WORKAREA */
1601                  uint32 x, y, cx, cy;                  uint32 x, y, cx, cy;
   
1602                  if (get_current_workarea(&x, &y, &cx, &cy) == 0)                  if (get_current_workarea(&x, &y, &cx, &cy) == 0)
1603                  {                  {
1604                          g_width = cx;                          g_width = cx;
1605                          g_height = cy;                          g_height = cy;
1606                            g_using_full_workarea = True;
1607                  }                  }
1608                  else                  else
1609                  {                  {
1610                          warning("Failed to get workarea: probably your window manager does not support extended hints\n");                          warning("Failed to get workarea: probably your window manager does not support extended hints\n");
1611                          g_width = 800;                          g_width = WidthOfScreen(g_screen);
1612                          g_height = 600;                          g_height = HeightOfScreen(g_screen);
1613                  }                  }
1614          }          }
1615    
# Line 1123  ui_init(void) Line 1624  ui_init(void)
1624                  g_IM = XOpenIM(g_display, NULL, NULL, NULL);                  g_IM = XOpenIM(g_display, NULL, NULL, NULL);
1625    
1626          xclip_init();          xclip_init();
1627            ewmh_init();
1628            if (g_seamless_rdp)
1629                    seamless_init();
1630    
1631          DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_bpp, g_bpp, g_depth));          DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_depth, g_bpp, g_depth));
1632    
1633          return True;          return True;
1634  }  }
# Line 1132  ui_init(void) Line 1636  ui_init(void)
1636  void  void
1637  ui_deinit(void)  ui_deinit(void)
1638  {  {
1639            while (g_seamless_windows)
1640            {
1641                    XDestroyWindow(g_display, g_seamless_windows->wnd);
1642                    sw_remove_window(g_seamless_windows);
1643            }
1644    
1645            xclip_deinit();
1646    
1647          if (g_IM != NULL)          if (g_IM != NULL)
1648                  XCloseIM(g_IM);                  XCloseIM(g_IM);
1649    
# Line 1148  ui_deinit(void) Line 1660  ui_deinit(void)
1660          g_display = NULL;          g_display = NULL;
1661  }  }
1662    
1663    
1664    static void
1665    get_window_attribs(XSetWindowAttributes * attribs)
1666    {
1667            attribs->background_pixel = BlackPixelOfScreen(g_screen);
1668            attribs->background_pixel = WhitePixelOfScreen(g_screen);
1669            attribs->border_pixel = WhitePixelOfScreen(g_screen);
1670            attribs->backing_store = g_ownbackstore ? NotUseful : Always;
1671            attribs->override_redirect = g_fullscreen;
1672            attribs->colormap = g_xcolmap;
1673    }
1674    
1675    static void
1676    get_input_mask(long *input_mask)
1677    {
1678            *input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
1679                    VisibilityChangeMask | FocusChangeMask | StructureNotifyMask;
1680    
1681            if (g_sendmotion)
1682                    *input_mask |= PointerMotionMask;
1683            if (g_ownbackstore)
1684                    *input_mask |= ExposureMask;
1685            if (g_fullscreen || g_grab_keyboard)
1686                    *input_mask |= EnterWindowMask;
1687            if (g_grab_keyboard)
1688                    *input_mask |= LeaveWindowMask;
1689    }
1690    
1691  BOOL  BOOL
1692  ui_create_window(void)  ui_create_window(void)
1693  {  {
# Line 1170  ui_create_window(void) Line 1710  ui_create_window(void)
1710          if (g_ypos < 0 || (g_ypos == 0 && (g_pos & 4)))          if (g_ypos < 0 || (g_ypos == 0 && (g_pos & 4)))
1711                  g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;                  g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;
1712    
1713          attribs.background_pixel = BlackPixelOfScreen(g_screen);          get_window_attribs(&attribs);
         attribs.border_pixel = WhitePixelOfScreen(g_screen);  
         attribs.backing_store = g_ownbackstore ? NotUseful : Always;  
         attribs.override_redirect = g_fullscreen;  
         attribs.colormap = g_xcolmap;  
1714    
1715          g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,          g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,
1716                                wndheight, 0, g_depth, InputOutput, g_visual,                                wndheight, 0, g_depth, InputOutput, g_visual,
# Line 1182  ui_create_window(void) Line 1718  ui_create_window(void)
1718                                CWBorderPixel, &attribs);                                CWBorderPixel, &attribs);
1719    
1720          if (g_gc == NULL)          if (g_gc == NULL)
1721            {
1722                  g_gc = XCreateGC(g_display, g_wnd, 0, NULL);                  g_gc = XCreateGC(g_display, g_wnd, 0, NULL);
1723                    ui_reset_clip();
1724            }
1725    
1726          if (g_create_bitmap_gc == NULL)          if (g_create_bitmap_gc == NULL)
1727                  g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);                  g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);
# Line 1199  ui_create_window(void) Line 1738  ui_create_window(void)
1738          XStoreName(g_display, g_wnd, g_title);          XStoreName(g_display, g_wnd, g_title);
1739    
1740          if (g_hide_decorations)          if (g_hide_decorations)
1741                  mwm_hide_decorations();                  mwm_hide_decorations(g_wnd);
1742    
1743          classhints = XAllocClassHint();          classhints = XAllocClassHint();
1744          if (classhints != NULL)          if (classhints != NULL)
# Line 1226  ui_create_window(void) Line 1765  ui_create_window(void)
1765                  XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);                  XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);
1766          }          }
1767    
1768          input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |          get_input_mask(&input_mask);
                 VisibilityChangeMask | FocusChangeMask | StructureNotifyMask;  
   
         if (g_sendmotion)  
                 input_mask |= PointerMotionMask;  
         if (g_ownbackstore)  
                 input_mask |= ExposureMask;  
         if (g_fullscreen || g_grab_keyboard)  
                 input_mask |= EnterWindowMask;  
         if (g_grab_keyboard)  
                 input_mask |= LeaveWindowMask;  
1769    
1770          if (g_IM != NULL)          if (g_IM != NULL)
1771          {          {
# Line 1321  xwin_toggle_fullscreen(void) Line 1850  xwin_toggle_fullscreen(void)
1850  {  {
1851          Pixmap contents = 0;          Pixmap contents = 0;
1852    
1853            if (g_seamless_active)
1854                    /* Turn off SeamlessRDP mode */
1855                    ui_seamless_toggle();
1856    
1857          if (!g_ownbackstore)          if (!g_ownbackstore)
1858          {          {
1859                  /* need to save contents of window */                  /* need to save contents of window */
# Line 1398  handle_button_event(XEvent xevent, BOOL Line 1931  handle_button_event(XEvent xevent, BOOL
1931                          /* The title bar. */                          /* The title bar. */
1932                          if (xevent.type == ButtonPress)                          if (xevent.type == ButtonPress)
1933                          {                          {
1934                                  if (!g_fullscreen && g_hide_decorations)                                  if (!g_fullscreen && g_hide_decorations && !g_using_full_workarea)
1935                                  {                                  {
1936                                          g_moving_wnd = True;                                          g_moving_wnd = True;
1937                                          g_move_x_offset = xevent.xbutton.x;                                          g_move_x_offset = xevent.xbutton.x;
# Line 1409  handle_button_event(XEvent xevent, BOOL Line 1942  handle_button_event(XEvent xevent, BOOL
1942                  }                  }
1943          }          }
1944    
1945          rdp_send_input(time(NULL), RDP_INPUT_MOUSE,          if (xevent.xmotion.window == g_wnd)
1946                         flags | button, xevent.xbutton.x, xevent.xbutton.y);          {
1947                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
1948                                   flags | button, xevent.xbutton.x, xevent.xbutton.y);
1949            }
1950            else
1951            {
1952                    /* SeamlessRDP */
1953                    rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
1954                                   flags | button, xevent.xbutton.x_root, xevent.xbutton.y_root);
1955            }
1956  }  }
1957    
1958    
1959  /* Process events in Xlib queue  /* Process events in Xlib queue
1960     Returns 0 after user quit, 1 otherwise */     Returns 0 after user quit, 1 otherwise */
1961  static int  static int
# Line 1424  xwin_process_events(void) Line 1967  xwin_process_events(void)
1967          char str[256];          char str[256];
1968          Status status;          Status status;
1969          int events = 0;          int events = 0;
1970            seamless_window *sw;
1971    
1972          while ((XPending(g_display) > 0) && events++ < 20)          while ((XPending(g_display) > 0) && events++ < 20)
1973          {          {
# Line 1438  xwin_process_events(void) Line 1982  xwin_process_events(void)
1982                  switch (xevent.type)                  switch (xevent.type)
1983                  {                  {
1984                          case VisibilityNotify:                          case VisibilityNotify:
1985                                  g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;                                  if (xevent.xvisibility.window == g_wnd)
1986                                            g_Unobscured =
1987                                                    xevent.xvisibility.state == VisibilityUnobscured;
1988    
1989                                  break;                                  break;
1990                          case ClientMessage:                          case ClientMessage:
1991                                  /* the window manager told us to quit */                                  /* the window manager told us to quit */
# Line 1518  xwin_process_events(void) Line 2065  xwin_process_events(void)
2065                                  if (g_fullscreen && !g_focused)                                  if (g_fullscreen && !g_focused)
2066                                          XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,                                          XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
2067                                                         CurrentTime);                                                         CurrentTime);
2068                                  rdp_send_input(time(NULL), RDP_INPUT_MOUSE,  
2069                                                 MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);                                  if (xevent.xmotion.window == g_wnd)
2070                                    {
2071                                            rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
2072                                                           xevent.xmotion.x, xevent.xmotion.y);
2073                                    }
2074                                    else
2075                                    {
2076                                            /* SeamlessRDP */
2077                                            rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
2078                                                           xevent.xmotion.x_root,
2079                                                           xevent.xmotion.y_root);
2080                                    }
2081                                  break;                                  break;
2082    
2083                          case FocusIn:                          case FocusIn:
# Line 1530  xwin_process_events(void) Line 2088  xwin_process_events(void)
2088                                  if (g_grab_keyboard && g_mouse_in_wnd)                                  if (g_grab_keyboard && g_mouse_in_wnd)
2089                                          XGrabKeyboard(g_display, g_wnd, True,                                          XGrabKeyboard(g_display, g_wnd, True,
2090                                                        GrabModeAsync, GrabModeAsync, CurrentTime);                                                        GrabModeAsync, GrabModeAsync, CurrentTime);
2091    
2092                                    sw = sw_get_window_by_wnd(xevent.xfocus.window);
2093                                    if (!sw)
2094                                            break;
2095    
2096                                    if (sw->id != g_seamless_focused)
2097                                    {
2098                                            seamless_send_focus(sw->id, 0);
2099                                            g_seamless_focused = sw->id;
2100                                    }
2101                                  break;                                  break;
2102    
2103                          case FocusOut:                          case FocusOut:
# Line 1562  xwin_process_events(void) Line 2130  xwin_process_events(void)
2130                                  break;                                  break;
2131    
2132                          case Expose:                          case Expose:
2133                                  XCopyArea(g_display, g_backstore, g_wnd, g_gc,                                  if (xevent.xexpose.window == g_wnd)
2134                                            xevent.xexpose.x, xevent.xexpose.y,                                  {
2135                                            xevent.xexpose.width,                                          XCopyArea(g_display, g_backstore, xevent.xexpose.window,
2136                                            xevent.xexpose.height,                                                    g_gc,
2137                                            xevent.xexpose.x, xevent.xexpose.y);                                                    xevent.xexpose.x, xevent.xexpose.y,
2138                                                      xevent.xexpose.width, xevent.xexpose.height,
2139                                                      xevent.xexpose.x, xevent.xexpose.y);
2140                                    }
2141                                    else
2142                                    {
2143                                            sw = sw_get_window_by_wnd(xevent.xexpose.window);
2144                                            if (!sw)
2145                                                    break;
2146                                            XCopyArea(g_display, g_backstore,
2147                                                      xevent.xexpose.window, g_gc,
2148                                                      xevent.xexpose.x + sw->xoffset,
2149                                                      xevent.xexpose.y + sw->yoffset,
2150                                                      xevent.xexpose.width,
2151                                                      xevent.xexpose.height, xevent.xexpose.x,
2152                                                      xevent.xexpose.y);
2153                                    }
2154    
2155                                  break;                                  break;
2156    
2157                          case MappingNotify:                          case MappingNotify:
# Line 1595  xwin_process_events(void) Line 2180  xwin_process_events(void)
2180                                  break;                                  break;
2181                          case PropertyNotify:                          case PropertyNotify:
2182                                  xclip_handle_PropertyNotify(&xevent.xproperty);                                  xclip_handle_PropertyNotify(&xevent.xproperty);
2183                                    if (xevent.xproperty.window == g_wnd)
2184                                            break;
2185                                    if (xevent.xproperty.window == DefaultRootWindow(g_display))
2186                                            break;
2187    
2188                                    /* seamless */
2189                                    sw = sw_get_window_by_wnd(xevent.xproperty.window);
2190                                    if (!sw)
2191                                            break;
2192    
2193                                    if ((xevent.xproperty.atom == g_net_wm_state_atom)
2194                                        && (xevent.xproperty.state == PropertyNewValue))
2195                                    {
2196                                            sw->state = ewmh_get_window_state(sw->wnd);
2197                                            seamless_send_state(sw->id, sw->state, 0);
2198                                    }
2199    
2200                                    if ((xevent.xproperty.atom == g_net_wm_desktop_atom)
2201                                        && (xevent.xproperty.state == PropertyNewValue))
2202                                    {
2203                                            sw->desktop = ewmh_get_window_desktop(sw->wnd);
2204                                            sw_all_to_desktop(sw->wnd, sw->desktop);
2205                                    }
2206    
2207                                  break;                                  break;
2208                          case MapNotify:                          case MapNotify:
2209                                  rdp_send_client_window_status(1);                                  if (!g_seamless_active)
2210                                            rdp_send_client_window_status(1);
2211                                  break;                                  break;
2212                          case UnmapNotify:                          case UnmapNotify:
2213                                  rdp_send_client_window_status(0);                                  if (!g_seamless_active)
2214                                            rdp_send_client_window_status(0);
2215                                    break;
2216                            case ConfigureNotify:
2217                                    if (!g_seamless_active)
2218                                            break;
2219    
2220                                    sw = sw_get_window_by_wnd(xevent.xconfigure.window);
2221                                    if (!sw)
2222                                            break;
2223    
2224                                    gettimeofday(sw->position_timer, NULL);
2225                                    if (sw->position_timer->tv_usec + SEAMLESSRDP_POSITION_TIMER >=
2226                                        1000000)
2227                                    {
2228                                            sw->position_timer->tv_usec +=
2229                                                    SEAMLESSRDP_POSITION_TIMER - 1000000;
2230                                            sw->position_timer->tv_sec += 1;
2231                                    }
2232                                    else
2233                                    {
2234                                            sw->position_timer->tv_usec += SEAMLESSRDP_POSITION_TIMER;
2235                                    }
2236    
2237                                    sw_handle_restack(sw);
2238                                  break;                                  break;
2239                  }                  }
2240          }          }
# Line 1625  ui_select(int rdp_socket) Line 2259  ui_select(int rdp_socket)
2259                          /* User quit */                          /* User quit */
2260                          return 0;                          return 0;
2261    
2262                    if (g_seamless_active)
2263                            sw_check_timers();
2264    
2265                  FD_ZERO(&rfds);                  FD_ZERO(&rfds);
2266                  FD_ZERO(&wfds);                  FD_ZERO(&wfds);
2267                  FD_SET(rdp_socket, &rfds);                  FD_SET(rdp_socket, &rfds);
# Line 1644  ui_select(int rdp_socket) Line 2281  ui_select(int rdp_socket)
2281    
2282                  /* add redirection handles */                  /* add redirection handles */
2283                  rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);                  rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);
2284                    seamless_select_timeout(&tv);
2285    
2286                  n++;                  n++;
2287    
# Line 1685  ui_create_bitmap(int width, int height, Line 2323  ui_create_bitmap(int width, int height,
2323          uint8 *tdata;          uint8 *tdata;
2324          int bitmap_pad;          int bitmap_pad;
2325    
2326          if (g_server_bpp == 8)          if (g_server_depth == 8)
2327          {          {
2328                  bitmap_pad = 8;                  bitmap_pad = 8;
2329          }          }
# Line 1717  ui_paint_bitmap(int x, int y, int cx, in Line 2355  ui_paint_bitmap(int x, int y, int cx, in
2355          uint8 *tdata;          uint8 *tdata;
2356          int bitmap_pad;          int bitmap_pad;
2357    
2358          if (g_server_bpp == 8)          if (g_server_depth == 8)
2359          {          {
2360                  bitmap_pad = 8;                  bitmap_pad = 8;
2361          }          }
# Line 1737  ui_paint_bitmap(int x, int y, int cx, in Line 2375  ui_paint_bitmap(int x, int y, int cx, in
2375          {          {
2376                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
2377                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
2378                    ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2379                                            (g_display, g_backstore, sw->wnd, g_gc, x, y, cx, cy,
2380                                             x - sw->xoffset, y - sw->yoffset));
2381          }          }
2382          else          else
2383          {          {
2384                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
2385                    ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2386                                            (g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
2387                                             x - sw->xoffset, y - sw->yoffset));
2388          }          }
2389    
2390          XFree(image);          XFree(image);
# Line 1861  ui_set_cursor(HCURSOR cursor) Line 2505  ui_set_cursor(HCURSOR cursor)
2505  {  {
2506          g_current_cursor = (Cursor) cursor;          g_current_cursor = (Cursor) cursor;
2507          XDefineCursor(g_display, g_wnd, g_current_cursor);          XDefineCursor(g_display, g_wnd, g_current_cursor);
2508            ON_ALL_SEAMLESS_WINDOWS(XDefineCursor, (g_display, sw->wnd, g_current_cursor));
2509  }  }
2510    
2511  void  void
# Line 2002  ui_set_colourmap(HCOLOURMAP map) Line 2647  ui_set_colourmap(HCOLOURMAP map)
2647                  g_colmap = (uint32 *) map;                  g_colmap = (uint32 *) map;
2648          }          }
2649          else          else
2650            {
2651                  XSetWindowColormap(g_display, g_wnd, (Colormap) map);                  XSetWindowColormap(g_display, g_wnd, (Colormap) map);
2652                    ON_ALL_SEAMLESS_WINDOWS(XSetWindowColormap, (g_display, sw->wnd, (Colormap) map));
2653            }
2654  }  }
2655    
2656  void  void
2657  ui_set_clip(int x, int y, int cx, int cy)  ui_set_clip(int x, int y, int cx, int cy)
2658  {  {
2659          XRectangle rect;          g_clip_rectangle.x = x;
2660            g_clip_rectangle.y = y;
2661          rect.x = x;          g_clip_rectangle.width = cx;
2662          rect.y = y;          g_clip_rectangle.height = cy;
2663          rect.width = cx;          XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded);
         rect.height = cy;  
         XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);  
2664  }  }
2665    
2666  void  void
2667  ui_reset_clip(void)  ui_reset_clip(void)
2668  {  {
2669          XRectangle rect;          g_clip_rectangle.x = 0;
2670            g_clip_rectangle.y = 0;
2671          rect.x = 0;          g_clip_rectangle.width = g_width;
2672          rect.y = 0;          g_clip_rectangle.height = g_height;
2673          rect.width = g_width;          XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded);
         rect.height = g_height;  
         XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);  
2674  }  }
2675    
2676  void  void
# Line 2107  ui_patblt(uint8 opcode, Line 2751  ui_patblt(uint8 opcode,
2751    
2752          if (g_ownbackstore)          if (g_ownbackstore)
2753                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
2754            ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2755                                    (g_display, g_ownbackstore ? g_backstore : g_wnd, sw->wnd, g_gc,
2756                                     x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
2757  }  }
2758    
2759  void  void
# Line 2117  ui_screenblt(uint8 opcode, Line 2764  ui_screenblt(uint8 opcode,
2764          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
2765          if (g_ownbackstore)          if (g_ownbackstore)
2766          {          {
2767                  if (g_Unobscured)                  XCopyArea(g_display, g_Unobscured ? g_wnd : g_backstore,
2768                  {                            g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
2769                          XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
                         XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,  
                                   y);  
                 }  
                 else  
                 {  
                         XCopyArea(g_display, g_backstore, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);  
                         XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,  
                                   y);  
                 }  
2770          }          }
2771          else          else
2772          {          {
2773                  XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);                  XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
2774          }          }
2775    
2776            ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2777                                    (g_display, g_ownbackstore ? g_backstore : g_wnd,
2778                                     sw->wnd, g_gc, x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
2779    
2780          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
2781  }  }
2782    
# Line 2144  ui_memblt(uint8 opcode, Line 2787  ui_memblt(uint8 opcode,
2787  {  {
2788          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
2789          XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);          XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
2790            ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2791                                    (g_display, (Pixmap) src, sw->wnd, g_gc,
2792                                     srcx, srcy, cx, cy, x - sw->xoffset, y - sw->yoffset));
2793          if (g_ownbackstore)          if (g_ownbackstore)
2794                  XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);                  XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
2795          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
# Line 2190  ui_line(uint8 opcode, Line 2836  ui_line(uint8 opcode,
2836          SET_FUNCTION(opcode);          SET_FUNCTION(opcode);
2837          SET_FOREGROUND(pen->colour);          SET_FOREGROUND(pen->colour);
2838          XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);          XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);
2839            ON_ALL_SEAMLESS_WINDOWS(XDrawLine, (g_display, sw->wnd, g_gc,
2840                                                startx - sw->xoffset, starty - sw->yoffset,
2841                                                endx - sw->xoffset, endy - sw->yoffset));
2842          if (g_ownbackstore)          if (g_ownbackstore)
2843                  XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);                  XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);
2844          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
# Line 2287  ui_polyline(uint8 opcode, Line 2936  ui_polyline(uint8 opcode,
2936          if (g_ownbackstore)          if (g_ownbackstore)
2937                  XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,                  XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
2938                             CoordModePrevious);                             CoordModePrevious);
2939    
2940            ON_ALL_SEAMLESS_WINDOWS(seamless_XDrawLines,
2941                                    (sw->wnd, (XPoint *) points, npoints, sw->xoffset, sw->yoffset));
2942    
2943          RESET_FUNCTION(opcode);          RESET_FUNCTION(opcode);
2944  }  }
2945    
# Line 2442  ui_draw_text(uint8 font, uint8 flags, ui Line 3095  ui_draw_text(uint8 font, uint8 flags, ui
3095                  switch (text[i])                  switch (text[i])
3096                  {                  {
3097                          case 0xff:                          case 0xff:
3098                                  if (i + 2 < length)                                  /* At least two bytes needs to follow */
3099                                          cache_put_text(text[i + 1], text, text[i + 2]);                                  if (i + 3 > length)
                                 else  
3100                                  {                                  {
3101                                          error("this shouldn't be happening\n");                                          warning("Skipping short 0xff command:");
3102                                          exit(1);                                          for (j = 0; j < length; j++)
3103                                                    fprintf(stderr, "%02x ", text[j]);
3104                                            fprintf(stderr, "\n");
3105                                            i = length = 0;
3106                                            break;
3107                                  }                                  }
3108                                    cache_put_text(text[i + 1], text, text[i + 2]);
3109                                    i += 3;
3110                                    length -= i;
3111                                  /* this will move pointer from start to first character after FF command */                                  /* this will move pointer from start to first character after FF command */
3112                                  length -= i + 3;                                  text = &(text[i]);
                                 text = &(text[i + 3]);  
3113                                  i = 0;                                  i = 0;
3114                                  break;                                  break;
3115    
3116                          case 0xfe:                          case 0xfe:
3117                                    /* At least one byte needs to follow */
3118                                    if (i + 2 > length)
3119                                    {
3120                                            warning("Skipping short 0xfe command:");
3121                                            for (j = 0; j < length; j++)
3122                                                    fprintf(stderr, "%02x ", text[j]);
3123                                            fprintf(stderr, "\n");
3124                                            i = length = 0;
3125                                            break;
3126                                    }
3127                                  entry = cache_get_text(text[i + 1]);                                  entry = cache_get_text(text[i + 1]);
3128                                  if (entry != NULL)                                  if (entry->data != NULL)
3129                                  {                                  {
3130                                          if ((((uint8 *) (entry->data))[1] ==                                          if ((((uint8 *) (entry->data))[1] == 0)
3131                                               0) && (!(flags & TEXT2_IMPLICIT_X)))                                              && (!(flags & TEXT2_IMPLICIT_X)) && (i + 2 < length))
3132                                          {                                          {
3133                                                  if (flags & TEXT2_VERTICAL)                                                  if (flags & TEXT2_VERTICAL)
3134                                                          y += text[i + 2];                                                          y += text[i + 2];
# Line 2492  ui_draw_text(uint8 font, uint8 flags, ui Line 3160  ui_draw_text(uint8 font, uint8 flags, ui
3160          if (g_ownbackstore)          if (g_ownbackstore)
3161          {          {
3162                  if (boxcx > 1)                  if (boxcx > 1)
3163                    {
3164                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,
3165                                    boxy, boxcx, boxcy, boxx, boxy);                                    boxy, boxcx, boxcy, boxx, boxy);
3166                            ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3167                                                    (g_display, g_backstore, sw->wnd, g_gc,
3168                                                     boxx, boxy,
3169                                                     boxcx, boxcy,
3170                                                     boxx - sw->xoffset, boxy - sw->yoffset));
3171                    }
3172                  else                  else
3173                    {
3174                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,
3175                                    clipy, clipcx, clipcy, clipx, clipy);                                    clipy, clipcx, clipcy, clipx, clipy);
3176                            ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3177                                                    (g_display, g_backstore, sw->wnd, g_gc,
3178                                                     clipx, clipy,
3179                                                     clipcx, clipcy, clipx - sw->xoffset,
3180                                                     clipy - sw->yoffset));
3181                    }
3182          }          }
3183  }  }
3184    
# Line 2542  ui_desktop_restore(uint32 offset, int x, Line 3224  ui_desktop_restore(uint32 offset, int x,
3224          {          {
3225                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
3226                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
3227                    ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3228                                            (g_display, g_backstore, sw->wnd, g_gc,
3229                                             x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
3230          }          }
3231          else          else
3232          {          {
3233                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
3234                    ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3235                                            (g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
3236                                             x - sw->xoffset, y - sw->yoffset));
3237          }          }
3238    
3239          XFree(image);          XFree(image);
# Line 2561  void Line 3249  void
3249  ui_end_update(void)  ui_end_update(void)
3250  {  {
3251  }  }
3252    
3253    
3254    void
3255    ui_seamless_begin(BOOL hidden)
3256    {
3257            if (!g_seamless_rdp)
3258                    return;
3259    
3260            if (g_seamless_started)
3261                    return;
3262    
3263            g_seamless_started = True;
3264            g_seamless_hidden = hidden;
3265    
3266            if (!hidden)
3267                    ui_seamless_toggle();
3268    }
3269    
3270    
3271    void
3272    ui_seamless_hide_desktop()
3273    {
3274            if (!g_seamless_rdp)
3275                    return;
3276    
3277            if (!g_seamless_started)
3278                    return;
3279    
3280            if (g_seamless_active)
3281                    ui_seamless_toggle();
3282    
3283            g_seamless_hidden = True;
3284    }
3285    
3286    
3287    void
3288    ui_seamless_unhide_desktop()
3289    {
3290            if (!g_seamless_rdp)
3291                    return;
3292    
3293            if (!g_seamless_started)
3294                    return;
3295    
3296            g_seamless_hidden = False;
3297    
3298            ui_seamless_toggle();
3299    }
3300    
3301    
3302    void
3303    ui_seamless_toggle()
3304    {
3305            if (!g_seamless_rdp)
3306                    return;
3307    
3308            if (!g_seamless_started)
3309                    return;
3310    
3311            if (g_seamless_hidden)
3312                    return;
3313    
3314            if (g_seamless_active)
3315            {
3316                    /* Deactivate */
3317                    while (g_seamless_windows)
3318                    {
3319                            XDestroyWindow(g_display, g_seamless_windows->wnd);
3320                            sw_remove_window(g_seamless_windows);
3321                    }
3322                    XMapWindow(g_display, g_wnd);
3323            }
3324            else
3325            {
3326                    /* Activate */
3327                    XUnmapWindow(g_display, g_wnd);
3328                    seamless_send_sync();
3329            }
3330    
3331            g_seamless_active = !g_seamless_active;
3332    }
3333    
3334    
3335    void
3336    ui_seamless_create_window(unsigned long id, unsigned long group, unsigned long parent,
3337                              unsigned long flags)
3338    {
3339            Window wnd;
3340            XSetWindowAttributes attribs;
3341            XClassHint *classhints;
3342            XSizeHints *sizehints;
3343            XWMHints *wmhints;
3344            long input_mask;
3345            seamless_window *sw, *sw_parent;
3346    
3347            if (!g_seamless_active)
3348                    return;
3349    
3350            /* Ignore CREATEs for existing windows */
3351            sw = sw_get_window_by_id(id);
3352            if (sw)
3353                    return;
3354    
3355            get_window_attribs(&attribs);
3356            wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0, g_depth,
3357                                InputOutput, g_visual,
3358                                CWBackPixel | CWBackingStore | CWColormap | CWBorderPixel, &attribs);
3359    
3360            XStoreName(g_display, wnd, "SeamlessRDP");
3361            ewmh_set_wm_name(wnd, "SeamlessRDP");
3362    
3363            mwm_hide_decorations(wnd);
3364    
3365            classhints = XAllocClassHint();
3366            if (classhints != NULL)
3367            {
3368                    classhints->res_name = "rdesktop";
3369                    classhints->res_class = "SeamlessRDP";
3370                    XSetClassHint(g_display, wnd, classhints);
3371                    XFree(classhints);
3372            }
3373    
3374            /* WM_NORMAL_HINTS */
3375            sizehints = XAllocSizeHints();
3376            if (sizehints != NULL)
3377            {
3378                    sizehints->flags = USPosition;
3379                    XSetWMNormalHints(g_display, wnd, sizehints);
3380                    XFree(sizehints);
3381            }
3382    
3383            /* Parent-less transient windows */
3384            if (parent == 0xFFFFFFFF)
3385            {
3386                    XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
3387                    /* Some buggy wm:s (kwin) do not handle the above, so fake it
3388                       using some other hints. */
3389                    ewmh_set_window_popup(wnd);
3390            }
3391            /* Normal transient windows */
3392            else if (parent != 0x00000000)
3393            {
3394                    sw_parent = sw_get_window_by_id(parent);
3395                    if (sw_parent)
3396                            XSetTransientForHint(g_display, wnd, sw_parent->wnd);
3397                    else
3398                            warning("ui_seamless_create_window: No parent window 0x%lx\n", parent);
3399            }
3400    
3401            if (flags & SEAMLESSRDP_CREATE_MODAL)
3402            {
3403                    /* We do this to support buggy wm:s (*cough* metacity *cough*)
3404                       somewhat at least */
3405                    if (parent == 0x00000000)
3406                            XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
3407                    ewmh_set_window_modal(wnd);
3408            }
3409    
3410            /* FIXME: Support for Input Context:s */
3411    
3412            get_input_mask(&input_mask);
3413            input_mask |= PropertyChangeMask;
3414    
3415            XSelectInput(g_display, wnd, input_mask);
3416    
3417            /* handle the WM_DELETE_WINDOW protocol. FIXME: When killing a
3418               seamless window, we could try to close the window on the
3419               serverside, instead of terminating rdesktop */
3420            XSetWMProtocols(g_display, wnd, &g_kill_atom, 1);
3421    
3422            sw = xmalloc(sizeof(seamless_window));
3423            sw->wnd = wnd;
3424            sw->id = id;
3425            sw->behind = 0;
3426            sw->group = sw_find_group(group, False);
3427            sw->group->refcnt++;
3428            sw->xoffset = 0;
3429            sw->yoffset = 0;
3430            sw->width = 0;
3431            sw->height = 0;
3432            sw->state = SEAMLESSRDP_NOTYETMAPPED;
3433            sw->desktop = 0;
3434            sw->position_timer = xmalloc(sizeof(struct timeval));
3435            timerclear(sw->position_timer);
3436    
3437            sw->outstanding_position = False;
3438            sw->outpos_serial = 0;
3439            sw->outpos_xoffset = sw->outpos_yoffset = 0;
3440            sw->outpos_width = sw->outpos_height = 0;
3441    
3442            sw->next = g_seamless_windows;
3443            g_seamless_windows = sw;
3444    
3445            /* WM_HINTS */
3446            wmhints = XAllocWMHints();
3447            if (wmhints)
3448            {
3449                    wmhints->flags = WindowGroupHint;
3450                    wmhints->window_group = sw->group->wnd;
3451                    XSetWMHints(g_display, sw->wnd, wmhints);
3452                    XFree(wmhints);
3453            }
3454    }
3455    
3456    
3457    void
3458    ui_seamless_destroy_window(unsigned long id, unsigned long flags)
3459    {
3460            seamless_window *sw;
3461    
3462            if (!g_seamless_active)
3463                    return;
3464    
3465            sw = sw_get_window_by_id(id);
3466            if (!sw)
3467            {
3468                    warning("ui_seamless_destroy_window: No information for window 0x%lx\n", id);
3469                    return;
3470            }
3471    
3472            XDestroyWindow(g_display, sw->wnd);
3473            sw_remove_window(sw);
3474    }
3475    
3476    
3477    void
3478    ui_seamless_destroy_group(unsigned long id, unsigned long flags)
3479    {
3480            seamless_window *sw, *sw_next;
3481    
3482            if (!g_seamless_active)
3483                    return;
3484    
3485            for (sw = g_seamless_windows; sw; sw = sw_next)
3486            {
3487                    sw_next = sw->next;
3488    
3489                    if (sw->group->id == id)
3490                    {
3491                            XDestroyWindow(g_display, sw->wnd);
3492                            sw_remove_window(sw);
3493                    }
3494            }
3495    }
3496    
3497    
3498    void
3499    ui_seamless_move_window(unsigned long id, int x, int y, int width, int height, unsigned long flags)
3500    {
3501            seamless_window *sw;
3502    
3503            if (!g_seamless_active)
3504                    return;
3505    
3506            sw = sw_get_window_by_id(id);
3507            if (!sw)
3508            {
3509                    warning("ui_seamless_move_window: No information for window 0x%lx\n", id);
3510                    return;
3511            }
3512    
3513            /* We ignore server updates until it has handled our request. */
3514            if (sw->outstanding_position)
3515                    return;
3516    
3517            if (!width || !height)
3518                    /* X11 windows must be at least 1x1 */
3519                    return;
3520    
3521            sw->xoffset = x;
3522            sw->yoffset = y;
3523            sw->width = width;
3524            sw->height = height;
3525    
3526            /* If we move the window in a maximized state, then KDE won't
3527               accept restoration */
3528            switch (sw->state)
3529            {
3530                    case SEAMLESSRDP_MINIMIZED:
3531                    case SEAMLESSRDP_MAXIMIZED:
3532                            return;
3533            }
3534    
3535            /* FIXME: Perhaps use ewmh_net_moveresize_window instead */
3536            XMoveResizeWindow(g_display, sw->wnd, sw->xoffset, sw->yoffset, sw->width, sw->height);
3537    }
3538    
3539    
3540    void
3541    ui_seamless_restack_window(unsigned long id, unsigned long behind, unsigned long flags)
3542    {
3543            seamless_window *sw;
3544    
3545            if (!g_seamless_active)
3546                    return;
3547    
3548            sw = sw_get_window_by_id(id);
3549            if (!sw)
3550            {
3551                    warning("ui_seamless_restack_window: No information for window 0x%lx\n", id);
3552                    return;
3553            }
3554    
3555            if (behind)
3556            {
3557                    seamless_window *sw_behind;
3558                    Window wnds[2];
3559    
3560                    sw_behind = sw_get_window_by_id(behind);
3561                    if (!sw_behind)
3562                    {
3563                            warning("ui_seamless_restack_window: No information for window 0x%lx\n",
3564                                    behind);
3565                            return;
3566                    }
3567    
3568                    wnds[1] = sw_behind->wnd;
3569                    wnds[0] = sw->wnd;
3570    
3571                    XRestackWindows(g_display, wnds, 2);
3572            }
3573            else
3574            {
3575                    XRaiseWindow(g_display, sw->wnd);
3576            }
3577    
3578            sw_restack_window(sw, behind);
3579    }
3580    
3581    
3582    void
3583    ui_seamless_settitle(unsigned long id, const char *title, unsigned long flags)
3584    {
3585            seamless_window *sw;
3586    
3587            if (!g_seamless_active)
3588                    return;
3589    
3590            sw = sw_get_window_by_id(id);
3591            if (!sw)
3592            {
3593                    warning("ui_seamless_settitle: No information for window 0x%lx\n", id);
3594                    return;
3595            }
3596    
3597            /* FIXME: Might want to convert the name for non-EWMH WMs */
3598            XStoreName(g_display, sw->wnd, title);
3599            ewmh_set_wm_name(sw->wnd, title);
3600    }
3601    
3602    
3603    void
3604    ui_seamless_setstate(unsigned long id, unsigned int state, unsigned long flags)
3605    {
3606            seamless_window *sw;
3607    
3608            if (!g_seamless_active)
3609                    return;
3610    
3611            sw = sw_get_window_by_id(id);
3612            if (!sw)
3613            {
3614                    warning("ui_seamless_setstate: No information for window 0x%lx\n", id);
3615                    return;
3616            }
3617    
3618            switch (state)
3619            {
3620                    case SEAMLESSRDP_NORMAL:
3621                    case SEAMLESSRDP_MAXIMIZED:
3622                            ewmh_change_state(sw->wnd, state);
3623                            XMapWindow(g_display, sw->wnd);
3624                            break;
3625                    case SEAMLESSRDP_MINIMIZED:
3626                            /* EWMH says: "if an Application asks to toggle _NET_WM_STATE_HIDDEN
3627                               the Window Manager should probably just ignore the request, since
3628                               _NET_WM_STATE_HIDDEN is a function of some other aspect of the window
3629                               such as minimization, rather than an independent state." Besides,
3630                               XIconifyWindow is easier. */
3631                            if (sw->state == SEAMLESSRDP_NOTYETMAPPED)
3632                            {
3633                                    XWMHints *hints;
3634                                    hints = XGetWMHints(g_display, sw->wnd);
3635                                    if (hints)
3636                                    {
3637                                            hints->flags |= StateHint;
3638                                            hints->initial_state = IconicState;
3639                                            XSetWMHints(g_display, sw->wnd, hints);
3640                                            XFree(hints);
3641                                    }
3642                                    XMapWindow(g_display, sw->wnd);
3643                            }
3644                            else
3645                                    XIconifyWindow(g_display, sw->wnd, DefaultScreen(g_display));
3646                            break;
3647                    default:
3648                            warning("SeamlessRDP: Invalid state %d\n", state);
3649                            break;
3650            }
3651    
3652            sw->state = state;
3653    }
3654    
3655    
3656    void
3657    ui_seamless_syncbegin(unsigned long flags)
3658    {
3659            if (!g_seamless_active)
3660                    return;
3661    
3662            /* Destroy all seamless windows */
3663            while (g_seamless_windows)
3664            {
3665                    XDestroyWindow(g_display, g_seamless_windows->wnd);
3666                    sw_remove_window(g_seamless_windows);
3667            }
3668    }
3669    
3670    
3671    void
3672    ui_seamless_ack(unsigned int serial)
3673    {
3674            seamless_window *sw;
3675            for (sw = g_seamless_windows; sw; sw = sw->next)
3676            {
3677                    if (sw->outstanding_position && (sw->outpos_serial == serial))
3678                    {
3679                            sw->xoffset = sw->outpos_xoffset;
3680                            sw->yoffset = sw->outpos_yoffset;
3681                            sw->width = sw->outpos_width;
3682                            sw->height = sw->outpos_height;
3683                            sw->outstanding_position = False;
3684    
3685                            /* Do a complete redraw of the window as part of the
3686                               completion of the move. This is to remove any
3687                               artifacts caused by our lack of synchronization. */
3688                            XCopyArea(g_display, g_backstore,
3689                                      sw->wnd, g_gc,
3690                                      sw->xoffset, sw->yoffset, sw->width, sw->height, 0, 0);
3691    
3692                            break;
3693                    }
3694            }
3695    }
Legend:
Removed from v.988  
changed lines
  Added in v.1246
  ViewVC Help
Powered by ViewVC 1.1.26