/[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!

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

Parent Directory | Revision Log | View Patch Patch

-revision 1042 by astrand,
Tue Jan 24 12:40:24 2006 UTC
+revision 1463 by astrand,
Fri Mar 28 11:36:15 2008 UTC
 Line 1
  /* -*- c-basic-offset: 8 -*-
     rdesktop: A Remote Desktop Protocol client.
     User interface services - X Window System
-    Copyright (C) Matthew Chapman 1999-2005
+    Copyright (C) Matthew Chapman 1999-2007
+    Copyright 2007 Pierre Ossman <ossman@cendio.se> for Cendio AB
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
-Line 20
+Line 21
  #include <X11/Xlib.h>
  #include <X11/Xutil.h>
+ #include <X11/Xproto.h>
  #include <unistd.h>
  #include <sys/time.h>
  #include <time.h>
-Line 33 
 extern int g_height;
+Line 35 
 extern int g_height;
  extern int g_xpos;
  extern int g_ypos;
  extern int g_pos;
- extern BOOL g_sendmotion;
+ extern RD_BOOL g_sendmotion;
- extern BOOL g_fullscreen;
+ extern RD_BOOL g_fullscreen;
- extern BOOL g_grab_keyboard;
+ extern RD_BOOL g_grab_keyboard;
- extern BOOL g_hide_decorations;
+ extern RD_BOOL g_hide_decorations;
  extern char g_title[];
  /* Color depth of the RDP session.
     As of RDP 5.1, it may be 8, 15, 16 or 24. */
-Line 48 
 Time g_last_gesturetime;
+Line 50 
 Time g_last_gesturetime;
  static int g_x_socket;
  static Screen *g_screen;
  Window g_wnd;
+ /* SeamlessRDP support */
+ typedef struct _seamless_group
+ {
+         Window wnd;
+         unsigned long id;
+         unsigned int refcnt;
+ } seamless_group;
+ typedef struct _seamless_window
+ {
+         Window wnd;
+         unsigned long id;
+         unsigned long behind;
+         seamless_group *group;
+         int xoffset, yoffset;
+         int width, height;
+         int state;              /* normal/minimized/maximized. */
+         unsigned int desktop;
+         struct timeval *position_timer;
+         RD_BOOL outstanding_position;
+         unsigned int outpos_serial;
+         int outpos_xoffset, outpos_yoffset;
+         int outpos_width, outpos_height;
+         unsigned int icon_size;
+         unsigned int icon_offset;
+         char icon_buffer[32 * 32 * 4];
+         struct _seamless_window *next;
+ } seamless_window;
+ static seamless_window *g_seamless_windows = NULL;
+ static unsigned long g_seamless_focused = 0;
+ static RD_BOOL g_seamless_started = False;      /* Server end is up and running */
+ static RD_BOOL g_seamless_active = False;       /* We are currently in seamless mode */
+ static RD_BOOL g_seamless_hidden = False;       /* Desktop is hidden on server */
+ static RD_BOOL g_seamless_broken_restack = False;       /* WM does not properly restack */
+ extern RD_BOOL g_seamless_rdp;
  extern uint32 g_embed_wnd;
- BOOL g_enable_compose = False;
+ RD_BOOL g_enable_compose = False;
- BOOL g_Unobscured;              /* used for screenblt */
+ RD_BOOL g_Unobscured;           /* used for screenblt */
  static GC g_gc = NULL;
  static GC g_create_bitmap_gc = NULL;
  static GC g_create_glyph_gc = NULL;
+ static XRectangle g_clip_rectangle;
  static Visual *g_visual;
  /* Color depth of the X11 visual of our window (e.g. 24 for True Color R8G8B visual).
     This may be 32 for R8G8B8 visuals, and then the rest of the bits are undefined
-Line 66 
 static int g_bpp;
+Line 108 
 static int g_bpp;
  static XIM g_IM;
  static XIC g_IC;
  static XModifierKeymap *g_mod_map;
+ /* Maps logical (xmodmap -pp) pointing device buttons (0-based) back
+    to physical (1-based) indices. */
+ static unsigned char g_pointer_log_to_phys_map[16];
  static Cursor g_current_cursor;
- static HCURSOR g_null_cursor = NULL;
+ static RD_HCURSOR g_null_cursor = NULL;
  static Atom g_protocol_atom, g_kill_atom;
- static BOOL g_focused;
+ extern Atom g_net_wm_state_atom;
- static BOOL g_mouse_in_wnd;
+ extern Atom g_net_wm_desktop_atom;
- /* Indicates the visual is has 15, 16 or 24 depth
+ static RD_BOOL g_focused;
-    and the same color channel masks as its RDP equivalent. */
+ static RD_BOOL g_mouse_in_wnd;
- static BOOL g_compatible_depth;
+ /* Indicates that:
+) visual has 15, 16 or 24 depth and the same color channel masks
+       as its RDP equivalent (implies X server is LE),
+) host is LE
+    This will trigger an optimization whose real value is questionable.
+ */
+ static RD_BOOL g_compatible_arch;
  /* Indicates whether RDP's bitmaps and our XImages have the same
     binary format. If so, we can avoid an expensive translation.
-    If this is True, so is g_compatible_depth. */
+    Note that this can be true when g_compatible_arch is false,
- static BOOL g_no_translate_image = False;
+    e.g.:
+      RDP(LE) <-> host(BE) <-> X-Server(LE)
+    ('host' is the machine running rdesktop; the host simply memcpy's
+     so its endianess doesn't matter)
+  */
+ static RD_BOOL g_no_translate_image = False;
  /* endianness */
- static BOOL g_host_be;
+ static RD_BOOL g_host_be;
- static BOOL g_xserver_be;
+ static RD_BOOL g_xserver_be;
  static int g_red_shift_r, g_blue_shift_r, g_green_shift_r;
  static int g_red_shift_l, g_blue_shift_l, g_green_shift_l;
  /* software backing store */
- extern BOOL g_ownbackstore;
+ extern RD_BOOL g_ownbackstore;
  static Pixmap g_backstore = 0;
  /* Moving in single app mode */
- static BOOL g_moving_wnd;
+ static RD_BOOL g_moving_wnd;
  static int g_move_x_offset = 0;
  static int g_move_y_offset = 0;
- static BOOL g_using_full_workarea = False;
+ static RD_BOOL g_using_full_workarea = False;
  #ifdef WITH_RDPSND
- extern int g_dsp_fd;
+ extern RD_BOOL g_rdpsnd;
- extern BOOL g_dsp_busy;
- extern BOOL g_rdpsnd;
  #endif
  /* MWM decorations */
-Line 122 
 typedef struct
+Line 178 
 typedef struct
  }
  PixelColour;
+ #define ON_ALL_SEAMLESS_WINDOWS(func, args) \
+         do { \
+                 seamless_window *sw; \
+                 XRectangle rect; \
+                 if (!g_seamless_windows) break; \
+                 for (sw = g_seamless_windows; sw; sw = sw->next) { \
+                     rect.x = g_clip_rectangle.x - sw->xoffset; \
+                     rect.y = g_clip_rectangle.y - sw->yoffset; \
+                     rect.width = g_clip_rectangle.width; \
+                     rect.height = g_clip_rectangle.height; \
+                     XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded); \
+                     func args; \
+                 } \
+                 XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded); \
+         } while (0)
+ static void
+ seamless_XFillPolygon(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
+ {
+         points[0].x -= xoffset;
+         points[0].y -= yoffset;
+         XFillPolygon(g_display, d, g_gc, points, npoints, Complex, CoordModePrevious);
+         points[0].x += xoffset;
+         points[0].y += yoffset;
+ }
+ static void
+ seamless_XDrawLines(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
+ {
+         points[0].x -= xoffset;
+         points[0].y -= yoffset;
+         XDrawLines(g_display, d, g_gc, points, npoints, CoordModePrevious);
+         points[0].x += xoffset;
+         points[0].y += yoffset;
+ }
  #define FILL_RECTANGLE(x,y,cx,cy)\
  { \
          XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \
+         ON_ALL_SEAMLESS_WINDOWS(XFillRectangle, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy)); \
          if (g_ownbackstore) \
                  XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \
  }
-Line 140 
 PixelColour;
+Line 232 
 PixelColour;
          XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \
          if (g_ownbackstore) \
                  XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \
+         ON_ALL_SEAMLESS_WINDOWS(seamless_XFillPolygon, (sw->wnd, p, np, sw->xoffset, sw->yoffset)); \
  }
  #define DRAW_ELLIPSE(x,y,cx,cy,m)\
-Line 148 
 PixelColour;
+Line 241 
 PixelColour;
          { \
                  case 0: /* Outline */ \
                          XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
+                         ON_ALL_SEAMLESS_WINDOWS(XDrawArc, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy, 0, 360*64)); \
                          if (g_ownbackstore) \
                                  XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
                          break; \
                  case 1: /* Filled */ \
                          XFillArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
+                         ON_ALL_SEAMLESS_WINDOWS(XFillArc, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy, 0, 360*64)); \
                          if (g_ownbackstore) \
                                  XFillArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
                          break; \
-Line 160 
 PixelColour;
+Line 255 
 PixelColour;
  }
  /* colour maps */
- extern BOOL g_owncolmap;
+ extern RD_BOOL g_owncolmap;
  static Colormap g_xcolmap;
  static uint32 *g_colmap = NULL;
-Line 190 
 static int rop2_map[] = {
+Line 285 
 static int rop2_map[] = {
  #define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }
  #define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }
+ static seamless_window *
+ sw_get_window_by_id(unsigned long id)
+ {
+         seamless_window *sw;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw->id == id)
+                         return sw;
+         }
+         return NULL;
+ }
+ static seamless_window *
+ sw_get_window_by_wnd(Window wnd)
+ {
+         seamless_window *sw;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw->wnd == wnd)
+                         return sw;
+         }
+         return NULL;
+ }
+ static void
+ sw_remove_window(seamless_window * win)
+ {
+         seamless_window *sw, **prevnext = &g_seamless_windows;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw == win)
+                 {
+                         *prevnext = sw->next;
+                         sw->group->refcnt--;
+                         if (sw->group->refcnt == 0)
+                         {
+                                 XDestroyWindow(g_display, sw->group->wnd);
+                                 xfree(sw->group);
+                         }
+                         xfree(sw->position_timer);
+                         xfree(sw);
+                         return;
+                 }
+                 prevnext = &sw->next;
+         }
+         return;
+ }
+ /* Move all windows except wnd to new desktop */
+ static void
+ sw_all_to_desktop(Window wnd, unsigned int desktop)
+ {
+         seamless_window *sw;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw->wnd == wnd)
+                         continue;
+                 if (sw->desktop != desktop)
+                 {
+                         ewmh_move_to_desktop(sw->wnd, desktop);
+                         sw->desktop = desktop;
+                 }
+         }
+ }
+ /* Send our position */
+ static void
+ sw_update_position(seamless_window * sw)
+ {
+         XWindowAttributes wa;
+         int x, y;
+         Window child_return;
+         unsigned int serial;
+         XGetWindowAttributes(g_display, sw->wnd, &wa);
+         XTranslateCoordinates(g_display, sw->wnd, wa.root,
+                               -wa.border_width, -wa.border_width, &x, &y, &child_return);
+         serial = seamless_send_position(sw->id, x, y, wa.width, wa.height, 0);
+         sw->outstanding_position = True;
+         sw->outpos_serial = serial;
+         sw->outpos_xoffset = x;
+         sw->outpos_yoffset = y;
+         sw->outpos_width = wa.width;
+         sw->outpos_height = wa.height;
+ }
+ /* Check if it's time to send our position */
  static void
- mwm_hide_decorations(void)
+ sw_check_timers()
+ {
+         seamless_window *sw;
+         struct timeval now;
+         gettimeofday(&now, NULL);
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (timerisset(sw->position_timer) && timercmp(sw->position_timer, &now, <))
+                 {
+                         timerclear(sw->position_timer);
+                         sw_update_position(sw);
+                 }
+         }
+ }
+ static void
+ sw_restack_window(seamless_window * sw, unsigned long behind)
+ {
+         seamless_window *sw_above;
+         /* Remove window from stack */
+         for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
+         {
+                 if (sw_above->behind == sw->id)
+                         break;
+         }
+         if (sw_above)
+                 sw_above->behind = sw->behind;
+         /* And then add it at the new position */
+         for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
+         {
+                 if (sw_above->behind == behind)
+                         break;
+         }
+         if (sw_above)
+                 sw_above->behind = sw->id;
+         sw->behind = behind;
+ }
+ static void
+ sw_handle_restack(seamless_window * sw)
+ {
+         Status status;
+         Window root, parent, *children;
+         unsigned int nchildren, i;
+         seamless_window *sw_below;
+         status = XQueryTree(g_display, RootWindowOfScreen(g_screen),
+                             &root, &parent, &children, &nchildren);
+         if (!status || !nchildren)
+                 return;
+         sw_below = NULL;
+         i = 0;
+         while (children[i] != sw->wnd)
+         {
+                 i++;
+                 if (i >= nchildren)
+                         goto end;
+         }
+         for (i++; i < nchildren; i++)
+         {
+                 sw_below = sw_get_window_by_wnd(children[i]);
+                 if (sw_below)
+                         break;
+         }
+         if (!sw_below && !sw->behind)
+                 goto end;
+         if (sw_below && (sw_below->id == sw->behind))
+                 goto end;
+         if (sw_below)
+         {
+                 seamless_send_zchange(sw->id, sw_below->id, 0);
+                 sw_restack_window(sw, sw_below->id);
+         }
+         else
+         {
+                 seamless_send_zchange(sw->id, 0, 0);
+                 sw_restack_window(sw, 0);
+         }
+       end:
+         XFree(children);
+ }
+ static seamless_group *
+ sw_find_group(unsigned long id, RD_BOOL dont_create)
+ {
+         seamless_window *sw;
+         seamless_group *sg;
+         XSetWindowAttributes attribs;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw->group->id == id)
+                         return sw->group;
+         }
+         if (dont_create)
+                 return NULL;
+         sg = xmalloc(sizeof(seamless_group));
+         sg->wnd =
+                 XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0,
+                               CopyFromParent, CopyFromParent, CopyFromParent, 0, &attribs);
+         sg->id = id;
+         sg->refcnt = 0;
+         return sg;
+ }
+ static void
+ mwm_hide_decorations(Window wnd)
  {
          PropMotifWmHints motif_hints;
          Atom hintsatom;
-Line 208 
 mwm_hide_decorations(void)
+Line 525 
 mwm_hide_decorations(void)
                  return;
          }
-         XChangeProperty(g_display, g_wnd, hintsatom, hintsatom, 32, PropModeReplace,
+         XChangeProperty(g_display, wnd, hintsatom, hintsatom, 32, PropModeReplace,
                          (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
+ }
+ typedef struct _sw_configurenotify_context
+ {
+         Window window;
+         unsigned long serial;
+ } sw_configurenotify_context;
+ /* Predicate procedure for sw_wait_configurenotify */
+ static Bool
+ sw_configurenotify_p(Display * display, XEvent * xevent, XPointer arg)
+ {
+         sw_configurenotify_context *context = (sw_configurenotify_context *) arg;
+         if (xevent->xany.type == ConfigureNotify
+             && xevent->xconfigure.window == context->window
+             && xevent->xany.serial >= context->serial)
+                 return True;
+         return False;
+ }
+ /* Wait for a ConfigureNotify, with a equal or larger serial, on the
+    specified window. The event will be removed from the queue. We
+    could use XMaskEvent(StructureNotifyMask), but we would then risk
+    throwing away crucial events like DestroyNotify.
+    After a ConfigureWindow, according to ICCCM section 4.1.5, we
+    should recieve a ConfigureNotify, either a real or synthetic
+    one. This indicates that the configure has been "completed".
+    However, some WMs such as several versions of Metacity fails to
+    send synthetic events. See bug
+    http://bugzilla.gnome.org/show_bug.cgi?id=322840. We need to use a
+    timeout to avoid a hang. Tk uses the same approach. */
+ static void
+ sw_wait_configurenotify(Window wnd, unsigned long serial)
+ {
+         XEvent xevent;
+         sw_configurenotify_context context;
+         struct timeval now;
+         struct timeval nextsecond;
+         RD_BOOL got = False;
+         context.window = wnd;
+         context.serial = serial;
+         gettimeofday(&nextsecond, NULL);
+         nextsecond.tv_sec += 1;
+         do
+         {
+                 if (XCheckIfEvent(g_display, &xevent, sw_configurenotify_p, (XPointer) & context))
+                 {
+                         got = True;
+                         break;
+                 }
+                 usleep(100000);
+                 gettimeofday(&now, NULL);
+         }
+         while (timercmp(&now, &nextsecond, <));
+         if (!got)
+         {
+                 warning("Broken Window Manager: Timeout while waiting for ConfigureNotify\n");
+         }
+ }
+ /* Get the toplevel window, in case of reparenting */
+ static Window
+ sw_get_toplevel(Window wnd)
+ {
+         Window root, parent;
+         Window *child_list;
+         unsigned int num_children;
+         while (1)
+         {
+                 XQueryTree(g_display, wnd, &root, &parent, &child_list, &num_children);
+                 if (root == parent)
+                 {
+                         break;
+                 }
+                 else if (!parent)
+                 {
+                         warning("Internal error: sw_get_toplevel called with root window\n");
+                 }
+                 wnd = parent;
+         }
+         return wnd;
+ }
+ /* Check if wnd is already behind a window wrt stacking order */
+ static RD_BOOL
+ sw_window_is_behind(Window wnd, Window behind)
+ {
+         Window dummy1, dummy2;
+         Window *child_list;
+         unsigned int num_children;
+         unsigned int i;
+         RD_BOOL found_behind = False;
+         RD_BOOL found_wnd = False;
+         wnd = sw_get_toplevel(wnd);
+         behind = sw_get_toplevel(behind);
+         XQueryTree(g_display, RootWindowOfScreen(g_screen), &dummy1, &dummy2, &child_list,
+                    &num_children);
+         for (i = num_children - 1; i >= 0; i--)
+         {
+                 if (child_list[i] == behind)
+                 {
+                         found_behind = True;
+                 }
+                 else if (child_list[i] == wnd)
+                 {
+                         found_wnd = True;
+                         break;
+                 }
+         }
+         if (child_list)
+                 XFree(child_list);
+         if (!found_wnd)
+         {
+                 warning("sw_window_is_behind: Unable to find window 0x%lx\n", wnd);
+                 if (!found_behind)
+                 {
+                         warning("sw_window_is_behind: Unable to find behind window 0x%lx\n",
+                                 behind);
+                 }
+         }
+         return found_behind;
+ }
+ /* Test if the window manager correctly handles window restacking. In
+    particular, we are testing if it's possible to place a window
+    between two other windows. Many WMs such as Metacity can only stack
+    windows on the top or bottom. The window creation should mostly
+    match ui_seamless_create_window. */
+ static void
+ seamless_restack_test()
+ {
+         /* The goal is to have the middle window between top and
+            bottom.  The middle window is initially at the top,
+            though. */
+         Window wnds[3];         /* top, middle and bottom */
+         int i;
+         XEvent xevent;
+         XWindowChanges values;
+         unsigned long restack_serial;
+         for (i = 0; i < 3; i++)
+         {
+                 char name[64];
+                 wnds[i] =
+                         XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen), 0, 0, 20, 20,
+, 0, 0);
+                 snprintf(name, sizeof(name), "SeamlessRDP restack test - window %d", i);
+                 XStoreName(g_display, wnds[i], name);
+                 ewmh_set_wm_name(wnds[i], name);
+                 /* Hide decorations. Often this means that no
+                    reparenting will be done, which makes the restack
+                    easier. Besides, we want to mimic our other
+                    seamless windows as much as possible. We must still
+                    handle the case with reparenting, though. */
+                 mwm_hide_decorations(wnds[i]);
+                 /* Prevent windows from appearing in task bar */
+                 XSetTransientForHint(g_display, wnds[i], RootWindowOfScreen(g_screen));
+                 ewmh_set_window_popup(wnds[i]);
+                 /* We need to catch MapNotify/ConfigureNotify */
+                 XSelectInput(g_display, wnds[i], StructureNotifyMask);
+         }
+         /* Map Windows. Currently, we assume that XMapRaised places
+            the window on the top of the stack. Should be fairly safe;
+            the window is configured before it's mapped. */
+         XMapRaised(g_display, wnds[2]); /* bottom */
+         do
+         {
+                 XWindowEvent(g_display, wnds[2], StructureNotifyMask, &xevent);
+         }
+         while (xevent.type != MapNotify);
+         XMapRaised(g_display, wnds[0]); /* top */
+         do
+         {
+                 XWindowEvent(g_display, wnds[0], StructureNotifyMask, &xevent);
+         }
+         while (xevent.type != MapNotify);
+         XMapRaised(g_display, wnds[1]); /* middle */
+         do
+         {
+                 XWindowEvent(g_display, wnds[1], StructureNotifyMask, &xevent);
+         }
+         while (xevent.type != MapNotify);
+         /* The stacking order should now be 1 - 0 - 2 */
+         if (!sw_window_is_behind(wnds[0], wnds[1]) || !sw_window_is_behind(wnds[2], wnds[1]))
+         {
+                 /* Ok, technically a WM is allowed to stack windows arbitrarily, but... */
+                 warning("Broken Window Manager: Unable to test window restacking\n");
+                 g_seamless_broken_restack = True;
+                 for (i = 0; i < 3; i++)
+                         XDestroyWindow(g_display, wnds[i]);
+                 return;
+         }
+         /* Restack, using XReconfigureWMWindow, which should correctly
+            handle reparented windows as well as nonreparenting WMs. */
+         values.stack_mode = Below;
+         values.sibling = wnds[0];
+         restack_serial = XNextRequest(g_display);
+         XReconfigureWMWindow(g_display, wnds[1], DefaultScreen(g_display), CWStackMode | CWSibling,
+                              &values);
+         sw_wait_configurenotify(wnds[1], restack_serial);
+         /* Now verify that middle is behind top but not behind
+            bottom */
+         if (!sw_window_is_behind(wnds[1], wnds[0]))
+         {
+                 warning("Broken Window Manager: doesn't handle restack (restack request was ignored)\n");
+                 g_seamless_broken_restack = True;
+         }
+         else if (sw_window_is_behind(wnds[1], wnds[2]))
+         {
+                 warning("Broken Window Manager: doesn't handle restack (window was moved to bottom)\n");
+                 g_seamless_broken_restack = True;
+         }
+         /* Destroy windows */
+         for (i = 0; i < 3; i++)
+                 XDestroyWindow(g_display, wnds[i]);
  }
  #define SPLITCOLOUR15(colour, rv) \
-Line 243 
 mwm_hide_decorations(void)
+Line 802 
 mwm_hide_decorations(void)
  #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
                          x = (x << 16) | (x >> 16); }
+ /* The following macros output the same octet sequences
+    on both BE and LE hosts: */
  #define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; }
  #define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
  #define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
-Line 263 
 translate_colour(uint32 colour)
+Line 825 
 translate_colour(uint32 colour)
                          SPLITCOLOUR16(colour, pc);
                          break;
                  case 24:
+                 case 32:
                          SPLITCOLOUR24(colour, pc);
                          break;
                  default:
-Line 322 
 translate8to16(const uint8 * data, uint8
+Line 885 
 translate8to16(const uint8 * data, uint8
  {
          uint16 value;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT2
-Line 356 
 translate8to24(const uint8 * data, uint8
+Line 919 
 translate8to24(const uint8 * data, uint8
  {
          uint32 value;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  while (out < end)
                  {
-Line 379 
 translate8to32(const uint8 * data, uint8
+Line 942 
 translate8to32(const uint8 * data, uint8
  {
          uint32 value;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT4
-Line 451 
 translate15to24(const uint16 * data, uin
+Line 1014 
 translate15to24(const uint16 * data, uin
          uint16 pixel;
          PixelColour pc;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT3
-Line 501 
 translate15to32(const uint16 * data, uin
+Line 1064 
 translate15to32(const uint16 * data, uin
          uint32 value;
          PixelColour pc;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT4
-Line 609 
 translate16to24(const uint16 * data, uin
+Line 1172 
 translate16to24(const uint16 * data, uin
          uint16 pixel;
          PixelColour pc;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT3
-Line 679 
 translate16to32(const uint16 * data, uin
+Line 1242 
 translate16to32(const uint16 * data, uin
          uint32 value;
          PixelColour pc;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
                  REPEAT4
-Line 808 
 translate24to32(const uint8 * data, uint
+Line 1371 
 translate24to32(const uint8 * data, uint
          uint32 value;
          PixelColour pc;
-         if (g_compatible_depth)
+         if (g_compatible_arch)
          {
                  /* *INDENT-OFF* */
  #ifdef NEED_ALIGN
-Line 871 
 translate_image(int width, int height, u
+Line 1434 
 translate_image(int width, int height, u
             is only set for compatible depths, but the RDP depth might've
             changed during connection negotiations.
           */
+         /* todo */
+         if (g_server_depth == 32 && g_depth == 24)
+         {
+                 return data;
+         }
          if (g_no_translate_image)
          {
                  if ((g_depth == 15 && g_server_depth == 15) ||
-Line 948 
 translate_image(int width, int height, u
+Line 1518 
 translate_image(int width, int height, u
          return out;
  }
- BOOL
+ static void
+ xwin_refresh_pointer_map(void)
+ {
+         unsigned char phys_to_log_map[sizeof(g_pointer_log_to_phys_map)];
+         int i, pointer_buttons;
+         pointer_buttons = XGetPointerMapping(g_display, phys_to_log_map, sizeof(phys_to_log_map));
+         for (i = 0; i < pointer_buttons; ++i)
+         {
+                 /* This might produce multiple logical buttons mapping
+                    to a single physical one, but hey, that's
+                    life... */
+                 g_pointer_log_to_phys_map[phys_to_log_map[i] - 1] = i + 1;
+         }
+ }
+ RD_BOOL
  get_key_state(unsigned int state, uint32 keysym)
  {
          int modifierpos, key, keysymMask = 0;
-Line 996 
 calculate_mask_weight(uint32 mask)
+Line 1582 
 calculate_mask_weight(uint32 mask)
          return weight;
  }
- static BOOL
+ static RD_BOOL
- select_visual()
+ select_visual(int screen_num)
  {
          XPixmapFormatValues *pfm;
          int pixmap_formats_count, visuals_count;
-Line 1008 
 select_visual()
+Line 1594 
 select_visual()
          red_weight = blue_weight = green_weight = 0;
+         if (g_server_depth == -1)
+         {
+                 g_server_depth = DisplayPlanes(g_display, DefaultScreen(g_display));
+         }
          pfm = XListPixmapFormats(g_display, &pixmap_formats_count);
          if (pfm == NULL)
          {
-Line 1018 
 select_visual()
+Line 1609 
 select_visual()
          /* Search for best TrueColor visual */
          template.class = TrueColor;
-         vmatches = XGetVisualInfo(g_display, VisualClassMask, &template, &visuals_count);
+         template.screen = screen_num;
+         vmatches =
+                 XGetVisualInfo(g_display, VisualClassMask | VisualScreenMask, &template,
+                                &visuals_count);
          g_visual = NULL;
          g_no_translate_image = False;
-         g_compatible_depth = False;
+         g_compatible_arch = False;
          if (vmatches != NULL)
          {
                  for (i = 0; i < visuals_count; ++i)
                  {
                          XVisualInfo *visual_info = &vmatches[i];
+                         RD_BOOL can_translate_to_bpp = False;
+                         int j;
                          /* Try to find a no-translation visual that'll
                             allow us to use RDP bitmaps directly as ZPixmaps. */
-Line 1048 
 select_visual()
+Line 1644 
 select_visual()
                          {
                                  g_visual = visual_info->visual;
                                  g_depth = visual_info->depth;
-                                 g_compatible_depth = True;
+                                 g_compatible_arch = !g_host_be;
                                  g_no_translate_image = (visual_info->depth == g_server_depth);
                                  if (g_no_translate_image)
                                          /* We found the best visual */
-Line 1056 
 select_visual()
+Line 1652 
 select_visual()
                          }
                          else
                          {
-                                 g_compatible_depth = False;
+                                 g_compatible_arch = False;
                          }
                          if (visual_info->depth > 24)
-Line 1070 
 select_visual()
+Line 1666 
 select_visual()
                          /* Only care for visuals, for whose BPPs (not depths!)
                             we have a translateXtoY function. */
-                         BOOL can_translate_to_bpp = False;
-                         int j;
                          for (j = 0; j < pixmap_formats_count; ++j)
                          {
                                  if (pfm[j].depth == visual_info->depth)
-Line 1183 
 select_visual()
+Line 1777 
 select_visual()
          return True;
  }
- BOOL
+ static XErrorHandler g_old_error_handler;
+ static RD_BOOL g_error_expected = False;
+ /* Check if the X11 window corresponding to a seamless window with
+    specified id exists. */
+ RD_BOOL
+ sw_window_exists(unsigned long id)
+ {
+         seamless_window *sw;
+         char *name;
+         Status sts = 0;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+                 return False;
+         g_error_expected = True;
+         sts = XFetchName(g_display, sw->wnd, &name);
+         g_error_expected = False;
+         if (sts)
+         {
+                 XFree(name);
+         }
+         return sts;
+ }
+ static int
+ error_handler(Display * dpy, XErrorEvent * eev)
+ {
+         if (g_error_expected)
+                 return 0;
+         return g_old_error_handler(dpy, eev);
+ }
+ RD_BOOL
  ui_init(void)
  {
          int screen_num;
-Line 1197 
 ui_init(void)
+Line 1827 
 ui_init(void)
          {
                  uint16 endianess_test = 1;
-                 g_host_be = !(BOOL) (*(uint8 *) (&endianess_test));
+                 g_host_be = !(RD_BOOL) (*(uint8 *) (&endianess_test));
          }
+         g_old_error_handler = XSetErrorHandler(error_handler);
          g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);
          screen_num = DefaultScreen(g_display);
          g_x_socket = ConnectionNumber(g_display);
          g_screen = ScreenOfDisplay(g_display, screen_num);
          g_depth = DefaultDepthOfScreen(g_screen);
-         if (!select_visual())
+         if (!select_visual(screen_num))
                  return False;
          if (g_no_translate_image)
-Line 1245 
 ui_init(void)
+Line 1876 
 ui_init(void)
          {
                  g_width = WidthOfScreen(g_screen);
                  g_height = HeightOfScreen(g_screen);
+                 g_using_full_workarea = True;
          }
          else if (g_width < 0)
          {
-Line 1258 
 ui_init(void)
+Line 1890 
 ui_init(void)
          {
                  /* Fetch geometry from _NET_WORKAREA */
                  uint32 x, y, cx, cy;
-                 g_using_full_workarea = True;
                  if (get_current_workarea(&x, &y, &cx, &cy) == 0)
                  {
                          g_width = cx;
                          g_height = cy;
+                         g_using_full_workarea = True;
                  }
                  else
                  {
                          warning("Failed to get workarea: probably your window manager does not support extended hints\n");
-                         g_width = 800;
+                         g_width = WidthOfScreen(g_screen);
-                         g_height = 600;
+                         g_height = HeightOfScreen(g_screen);
                  }
          }
-Line 1277 
 ui_init(void)
+Line 1908 
 ui_init(void)
          g_width = (g_width + 3) & ~3;
          g_mod_map = XGetModifierMapping(g_display);
+         xwin_refresh_pointer_map();
          xkeymap_init();
-Line 1284 
 ui_init(void)
+Line 1916 
 ui_init(void)
                  g_IM = XOpenIM(g_display, NULL, NULL, NULL);
          xclip_init();
+         ewmh_init();
+         if (g_seamless_rdp)
+         {
+                 seamless_init();
+         }
          DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_depth, g_bpp, g_depth));
-Line 1293 
 ui_init(void)
+Line 1930 
 ui_init(void)
  void
  ui_deinit(void)
  {
+         while (g_seamless_windows)
+         {
+                 XDestroyWindow(g_display, g_seamless_windows->wnd);
+                 sw_remove_window(g_seamless_windows);
+         }
+         xclip_deinit();
          if (g_IM != NULL)
                  XCloseIM(g_IM);
-Line 1309 
 ui_deinit(void)
+Line 1954 
 ui_deinit(void)
          g_display = NULL;
  }
- BOOL
+ static void
+ get_window_attribs(XSetWindowAttributes * attribs)
+ {
+         attribs->background_pixel = BlackPixelOfScreen(g_screen);
+         attribs->background_pixel = WhitePixelOfScreen(g_screen);
+         attribs->border_pixel = WhitePixelOfScreen(g_screen);
+         attribs->backing_store = g_ownbackstore ? NotUseful : Always;
+         attribs->override_redirect = g_fullscreen;
+         attribs->colormap = g_xcolmap;
+ }
+ static void
+ get_input_mask(long *input_mask)
+ {
+         *input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
+                 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;
+ }
+ RD_BOOL
  ui_create_window(void)
  {
          uint8 null_pointer_mask[1] = { 0x80 };
-Line 1331 
 ui_create_window(void)
+Line 2004 
 ui_create_window(void)
          if (g_ypos < 0 || (g_ypos == 0 && (g_pos & 4)))
                  g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;
-         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;
          g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,
                                wndheight, 0, g_depth, InputOutput, g_visual,
-Line 1343 
 ui_create_window(void)
+Line 2012 
 ui_create_window(void)
                                CWBorderPixel, &attribs);
          if (g_gc == NULL)
+         {
                  g_gc = XCreateGC(g_display, g_wnd, 0, NULL);
+                 ui_reset_clip();
+         }
          if (g_create_bitmap_gc == NULL)
                  g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);
-Line 1358 
 ui_create_window(void)
+Line 2030 
 ui_create_window(void)
          }
          XStoreName(g_display, g_wnd, g_title);
+         ewmh_set_wm_name(g_wnd, g_title);
          if (g_hide_decorations)
-                 mwm_hide_decorations();
+                 mwm_hide_decorations(g_wnd);
          classhints = XAllocClassHint();
          if (classhints != NULL)
-Line 1387 
 ui_create_window(void)
+Line 2060 
 ui_create_window(void)
                  XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);
          }
-         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;
          if (g_IM != NULL)
          {
-Line 1432 
 ui_create_window(void)
+Line 2095 
 ui_create_window(void)
          if (g_null_cursor == NULL)
                  g_null_cursor = ui_create_cursor(0, 0, 1, 1, null_pointer_mask, null_pointer_data);
+         if (g_seamless_rdp)
+         {
+                 seamless_restack_test();
+         }
          return True;
  }
-Line 1482 
 xwin_toggle_fullscreen(void)
+Line 2150 
 xwin_toggle_fullscreen(void)
  {
          Pixmap contents = 0;
+         if (g_seamless_active)
+                 /* Turn off SeamlessRDP mode */
+                 ui_seamless_toggle();
          if (!g_ownbackstore)
          {
                  /* need to save contents of window */
-Line 1503 
 xwin_toggle_fullscreen(void)
+Line 2175 
 xwin_toggle_fullscreen(void)
  }
  static void
- handle_button_event(XEvent xevent, BOOL down)
+ handle_button_event(XEvent xevent, RD_BOOL down)
  {
          uint16 button, flags = 0;
          g_last_gesturetime = xevent.xbutton.time;
+         /* Reverse the pointer button mapping, e.g. in the case of
+            "left-handed mouse mode"; the RDP session expects to
+            receive physical buttons (true in mstsc as well) and
+            logical button behavior depends on the remote desktop's own
+            mouse settings */
+         xevent.xbutton.button = g_pointer_log_to_phys_map[xevent.xbutton.button - 1];
          button = xkeymap_translate_button(xevent.xbutton.button);
          if (button == 0)
                  return;
-Line 1570 
 handle_button_event(XEvent xevent, BOOL
+Line 2248 
 handle_button_event(XEvent xevent, BOOL
                  }
          }
-         rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
+         if (xevent.xmotion.window == g_wnd)
-                        flags | button, xevent.xbutton.x, xevent.xbutton.y);
+         {
+                 rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
+                                flags | button, xevent.xbutton.x, xevent.xbutton.y);
+         }
+         else
+         {
+                 /* SeamlessRDP */
+                 rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
+                                flags | button, xevent.xbutton.x_root, xevent.xbutton.y_root);
+         }
  }
  /* Process events in Xlib queue
     Returns 0 after user quit, 1 otherwise */
  static int
-Line 1585 
 xwin_process_events(void)
+Line 2273 
 xwin_process_events(void)
          char str[256];
          Status status;
          int events = 0;
+         seamless_window *sw;
          while ((XPending(g_display) > 0) && events++ < 20)
          {
-Line 1599 
 xwin_process_events(void)
+Line 2288 
 xwin_process_events(void)
                  switch (xevent.type)
                  {
                          case VisibilityNotify:
-                                 g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;
+                                 if (xevent.xvisibility.window == g_wnd)
+                                         g_Unobscured =
+                                                 xevent.xvisibility.state == VisibilityUnobscured;
                                  break;
                          case ClientMessage:
                                  /* the window manager told us to quit */
                                  if ((xevent.xclient.message_type == g_protocol_atom)
                                      && ((Atom) xevent.xclient.data.l[0] == g_kill_atom))
-                                         /* Quit */
+                                 {
-                                         return 0;
+                                         /* When killing a seamless window, close the window on the
+                                            serverside instead of terminating rdesktop */
+                                         sw = sw_get_window_by_wnd(xevent.xclient.window);
+                                         if (!sw)
+                                                 /* Otherwise, quit */
+                                                 return 0;
+                                         /* send seamless destroy process message */
+                                         seamless_send_destroy(sw->id);
+                                 }
                                  break;
                          case KeyPress:
-Line 1679 
 xwin_process_events(void)
+Line 2379 
 xwin_process_events(void)
                                  if (g_fullscreen && !g_focused)
                                          XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
                                                         CurrentTime);
-                                 rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
-                                                MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
+                                 if (xevent.xmotion.window == g_wnd)
+                                 {
+                                         rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
+                                                        xevent.xmotion.x, xevent.xmotion.y);
+                                 }
+                                 else
+                                 {
+                                         /* SeamlessRDP */
+                                         rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
+                                                        xevent.xmotion.x_root,
+                                                        xevent.xmotion.y_root);
+                                 }
                                  break;
                          case FocusIn:
-Line 1691 
 xwin_process_events(void)
+Line 2402 
 xwin_process_events(void)
                                  if (g_grab_keyboard && g_mouse_in_wnd)
                                          XGrabKeyboard(g_display, g_wnd, True,
                                                        GrabModeAsync, GrabModeAsync, CurrentTime);
+                                 sw = sw_get_window_by_wnd(xevent.xfocus.window);
+                                 if (!sw)
+                                         break;
+                                 /* Menu windows are real X11 windows,
+                                    with focus. When such a window is
+                                    destroyed, focus is reverted to the
+                                    main application window, which
+                                    would cause us to send FOCUS. This
+                                    breaks window switching in, say,
+                                    Seamonkey. We shouldn't need to
+                                    send FOCUS: Windows should also
+                                    revert focus to some other window
+                                    when the menu window is
+                                    destroyed. So, we only send FOCUS
+                                    if the previous focus window still
+                                    exists. */
+                                 if (sw->id != g_seamless_focused)
+                                 {
+                                         if (sw_window_exists(g_seamless_focused))
+                                                 seamless_send_focus(sw->id, 0);
+                                         g_seamless_focused = sw->id;
+                                 }
                                  break;
                          case FocusOut:
-Line 1723 
 xwin_process_events(void)
+Line 2459 
 xwin_process_events(void)
                                  break;
                          case Expose:
-                                 XCopyArea(g_display, g_backstore, g_wnd, g_gc,
+                                 if (xevent.xexpose.window == g_wnd)
-                                           xevent.xexpose.x, xevent.xexpose.y,
+                                 {
-                                           xevent.xexpose.width,
+                                         XCopyArea(g_display, g_backstore, xevent.xexpose.window,
-                                           xevent.xexpose.height,
+                                                   g_gc,
-                                           xevent.xexpose.x, xevent.xexpose.y);
+                                                   xevent.xexpose.x, xevent.xexpose.y,
+                                                   xevent.xexpose.width, xevent.xexpose.height,
+                                                   xevent.xexpose.x, xevent.xexpose.y);
+                                 }
+                                 else
+                                 {
+                                         sw = sw_get_window_by_wnd(xevent.xexpose.window);
+                                         if (!sw)
+                                                 break;
+                                         XCopyArea(g_display, g_backstore,
+                                                   xevent.xexpose.window, g_gc,
+                                                   xevent.xexpose.x + sw->xoffset,
+                                                   xevent.xexpose.y + sw->yoffset,
+                                                   xevent.xexpose.width,
+                                                   xevent.xexpose.height, xevent.xexpose.x,
+                                                   xevent.xexpose.y);
+                                 }
                                  break;
                          case MappingNotify:
-Line 1742 
 xwin_process_events(void)
+Line 2495 
 xwin_process_events(void)
                                          XFreeModifiermap(g_mod_map);
                                          g_mod_map = XGetModifierMapping(g_display);
                                  }
+                                 if (xevent.xmapping.request == MappingPointer)
+                                 {
+                                         xwin_refresh_pointer_map();
+                                 }
                                  break;
                                  /* clipboard stuff */
-Line 1756 
 xwin_process_events(void)
+Line 2515 
 xwin_process_events(void)
                                  break;
                          case PropertyNotify:
                                  xclip_handle_PropertyNotify(&xevent.xproperty);
+                                 if (xevent.xproperty.window == g_wnd)
+                                         break;
+                                 if (xevent.xproperty.window == DefaultRootWindow(g_display))
+                                         break;
+                                 /* seamless */
+                                 sw = sw_get_window_by_wnd(xevent.xproperty.window);
+                                 if (!sw)
+                                         break;
+                                 if ((xevent.xproperty.atom == g_net_wm_state_atom)
+                                     && (xevent.xproperty.state == PropertyNewValue))
+                                 {
+                                         sw->state = ewmh_get_window_state(sw->wnd);
+                                         seamless_send_state(sw->id, sw->state, 0);
+                                 }
+                                 if ((xevent.xproperty.atom == g_net_wm_desktop_atom)
+                                     && (xevent.xproperty.state == PropertyNewValue))
+                                 {
+                                         sw->desktop = ewmh_get_window_desktop(sw->wnd);
+                                         sw_all_to_desktop(sw->wnd, sw->desktop);
+                                 }
                                  break;
                          case MapNotify:
-                                 rdp_send_client_window_status(1);
+                                 if (!g_seamless_active)
+                                         rdp_send_client_window_status(1);
                                  break;
                          case UnmapNotify:
-                                 rdp_send_client_window_status(0);
+                                 if (!g_seamless_active)
+                                         rdp_send_client_window_status(0);
+                                 break;
+                         case ConfigureNotify:
+                                 if (!g_seamless_active)
+                                         break;
+                                 sw = sw_get_window_by_wnd(xevent.xconfigure.window);
+                                 if (!sw)
+                                         break;
+                                 gettimeofday(sw->position_timer, NULL);
+                                 if (sw->position_timer->tv_usec + SEAMLESSRDP_POSITION_TIMER >=
+                                     1000000)
+                                 {
+                                         sw->position_timer->tv_usec +=
+                                                 SEAMLESSRDP_POSITION_TIMER - 1000000;
+                                         sw->position_timer->tv_sec += 1;
+                                 }
+                                 else
+                                 {
+                                         sw->position_timer->tv_usec += SEAMLESSRDP_POSITION_TIMER;
+                                 }
+                                 sw_handle_restack(sw);
                                  break;
                  }
          }
-Line 1776 
 ui_select(int rdp_socket)
+Line 2584 
 ui_select(int rdp_socket)
          int n;
          fd_set rfds, wfds;
          struct timeval tv;
-         BOOL s_timeout = False;
+         RD_BOOL s_timeout = False;
          while (True)
          {
-Line 1786 
 ui_select(int rdp_socket)
+Line 2594 
 ui_select(int rdp_socket)
                          /* User quit */
                          return 0;
+                 if (g_seamless_active)
+                         sw_check_timers();
                  FD_ZERO(&rfds);
                  FD_ZERO(&wfds);
                  FD_SET(rdp_socket, &rfds);
                  FD_SET(g_x_socket, &rfds);
- #ifdef WITH_RDPSND
-                 /* FIXME: there should be an API for registering fds */
-                 if (g_dsp_busy)
-                 {
-                         FD_SET(g_dsp_fd, &wfds);
-                         n = (g_dsp_fd > n) ? g_dsp_fd : n;
-                 }
- #endif
                  /* default timeout */
                  tv.tv_sec = 60;
                  tv.tv_usec = 0;
+ #ifdef WITH_RDPSND
+                 rdpsnd_add_fds(&n, &rfds, &wfds, &tv);
+ #endif
                  /* add redirection handles */
                  rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);
+                 seamless_select_timeout(&tv);
                  n++;
-Line 1814 
 ui_select(int rdp_socket)
+Line 2622 
 ui_select(int rdp_socket)
                                  error("select: %s\n", strerror(errno));
                          case 0:
+ #ifdef WITH_RDPSND
+                                 rdpsnd_check_fds(&rfds, &wfds);
+ #endif
                                  /* Abort serial read calls */
                                  if (s_timeout)
-                                         rdpdr_check_fds(&rfds, &wfds, (BOOL) True);
+                                         rdpdr_check_fds(&rfds, &wfds, (RD_BOOL) True);
                                  continue;
                  }
-                 rdpdr_check_fds(&rfds, &wfds, (BOOL) False);
+ #ifdef WITH_RDPSND
+                 rdpsnd_check_fds(&rfds, &wfds);
+ #endif
+                 rdpdr_check_fds(&rfds, &wfds, (RD_BOOL) False);
                  if (FD_ISSET(rdp_socket, &rfds))
                          return 1;
- #ifdef WITH_RDPSND
-                 if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))
-                         wave_out_play();
- #endif
          }
  }
-Line 1838 
 ui_move_pointer(int x, int y)
+Line 2650 
 ui_move_pointer(int x, int y)
          XWarpPointer(g_display, g_wnd, g_wnd, 0, 0, 0, 0, x, y);
  }
- HBITMAP
+ RD_HBITMAP
  ui_create_bitmap(int width, int height, uint8 * data)
  {
          XImage *image;
-Line 1868 
 ui_create_bitmap(int width, int height,
+Line 2680 
 ui_create_bitmap(int width, int height,
          XFree(image);
          if (tdata != data)
                  xfree(tdata);
-         return (HBITMAP) bitmap;
+         return (RD_HBITMAP) bitmap;
  }
  void
-Line 1898 
 ui_paint_bitmap(int x, int y, int cx, in
+Line 2710 
 ui_paint_bitmap(int x, int y, int cx, in
          {
                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
+                 ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                         (g_display, g_backstore, sw->wnd, g_gc, x, y, cx, cy,
+                                          x - sw->xoffset, y - sw->yoffset));
          }
          else
          {
                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
+                 ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                         (g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
+                                          x - sw->xoffset, y - sw->yoffset));
          }
          XFree(image);
-Line 1910 
 ui_paint_bitmap(int x, int y, int cx, in
+Line 2728 
 ui_paint_bitmap(int x, int y, int cx, in
  }
  void
- ui_destroy_bitmap(HBITMAP bmp)
+ ui_destroy_bitmap(RD_HBITMAP bmp)
  {
          XFreePixmap(g_display, (Pixmap) bmp);
  }
- HGLYPH
+ RD_HGLYPH
  ui_create_glyph(int width, int height, uint8 * data)
  {
          XImage *image;
-Line 1937 
 ui_create_glyph(int width, int height, u
+Line 2755 
 ui_create_glyph(int width, int height, u
          XPutImage(g_display, bitmap, g_create_glyph_gc, image, 0, 0, 0, 0, width, height);
          XFree(image);
-         return (HGLYPH) bitmap;
+         return (RD_HGLYPH) bitmap;
  }
  void
- ui_destroy_glyph(HGLYPH glyph)
+ ui_destroy_glyph(RD_HGLYPH glyph)
  {
          XFreePixmap(g_display, (Pixmap) glyph);
  }
- HCURSOR
+ RD_HCURSOR
  ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
                   uint8 * andmask, uint8 * xormask)
  {
-         HGLYPH maskglyph, cursorglyph;
+         RD_HGLYPH maskglyph, cursorglyph;
          XColor bg, fg;
          Cursor xcursor;
          uint8 *cursor, *pcursor;
-Line 2014 
 ui_create_cursor(unsigned int x, unsigne
+Line 2832 
 ui_create_cursor(unsigned int x, unsigne
          ui_destroy_glyph(cursorglyph);
          xfree(mask);
          xfree(cursor);
-         return (HCURSOR) xcursor;
+         return (RD_HCURSOR) xcursor;
  }
  void
- ui_set_cursor(HCURSOR cursor)
+ ui_set_cursor(RD_HCURSOR cursor)
  {
          g_current_cursor = (Cursor) cursor;
          XDefineCursor(g_display, g_wnd, g_current_cursor);
+         ON_ALL_SEAMLESS_WINDOWS(XDefineCursor, (g_display, sw->wnd, g_current_cursor));
  }
  void
- ui_destroy_cursor(HCURSOR cursor)
+ ui_destroy_cursor(RD_HCURSOR cursor)
  {
          XFreeCursor(g_display, (Cursor) cursor);
  }
-Line 2043 
 ui_set_null_cursor(void)
+Line 2862 
 ui_set_null_cursor(void)
                  (xc)->flags = DoRed | DoGreen | DoBlue;
- HCOLOURMAP
+ RD_HCOLOURMAP
  ui_create_colourmap(COLOURMAP * colours)
  {
          COLOURENTRY *entry;
-Line 2139 
 ui_create_colourmap(COLOURMAP * colours)
+Line 2958 
 ui_create_colourmap(COLOURMAP * colours)
                  XStoreColors(g_display, map, xcolours, ncolours);
                  xfree(xcolours);
-                 return (HCOLOURMAP) map;
+                 return (RD_HCOLOURMAP) map;
          }
  }
  void
- ui_destroy_colourmap(HCOLOURMAP map)
+ ui_destroy_colourmap(RD_HCOLOURMAP map)
  {
          if (!g_owncolmap)
                  xfree(map);
-Line 2153 
 ui_destroy_colourmap(HCOLOURMAP map)
+Line 2972 
 ui_destroy_colourmap(HCOLOURMAP map)
  }
  void
- ui_set_colourmap(HCOLOURMAP map)
+ ui_set_colourmap(RD_HCOLOURMAP map)
  {
          if (!g_owncolmap)
          {
-Line 2163 
 ui_set_colourmap(HCOLOURMAP map)
+Line 2982 
 ui_set_colourmap(HCOLOURMAP map)
                  g_colmap = (uint32 *) map;
          }
          else
+         {
                  XSetWindowColormap(g_display, g_wnd, (Colormap) map);
+                 ON_ALL_SEAMLESS_WINDOWS(XSetWindowColormap, (g_display, sw->wnd, (Colormap) map));
+         }
  }
  void
  ui_set_clip(int x, int y, int cx, int cy)
  {
-         XRectangle rect;
+         g_clip_rectangle.x = x;
+         g_clip_rectangle.y = y;
-         rect.x = x;
+         g_clip_rectangle.width = cx;
-         rect.y = y;
+         g_clip_rectangle.height = cy;
-         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);
  }
  void
  ui_reset_clip(void)
  {
-         XRectangle rect;
+         g_clip_rectangle.x = 0;
+         g_clip_rectangle.y = 0;
-         rect.x = 0;
+         g_clip_rectangle.width = g_width;
-         rect.y = 0;
+         g_clip_rectangle.height = g_height;
-         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);
  }
  void
-Line 2242 
 ui_patblt(uint8 opcode,
+Line 3060 
 ui_patblt(uint8 opcode,
                          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  case 3: /* Pattern */
-Line 2257 
 ui_patblt(uint8 opcode,
+Line 3075 
 ui_patblt(uint8 opcode,
                          FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  default:
-Line 2268 
 ui_patblt(uint8 opcode,
+Line 3086 
 ui_patblt(uint8 opcode,
          if (g_ownbackstore)
                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
+         ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                 (g_display, g_ownbackstore ? g_backstore : g_wnd, sw->wnd, g_gc,
+                                  x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
  }
  void
-Line 2278 
 ui_screenblt(uint8 opcode,
+Line 3099 
 ui_screenblt(uint8 opcode,
          SET_FUNCTION(opcode);
          if (g_ownbackstore)
          {
-                 if (g_Unobscured)
+                 XCopyArea(g_display, g_Unobscured ? g_wnd : g_backstore,
-                 {
+                           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);
+                 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);
-                 }
          }
          else
          {
                  XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
          }
+         ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                 (g_display, g_ownbackstore ? g_backstore : g_wnd,
+                                  sw->wnd, g_gc, x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
          RESET_FUNCTION(opcode);
  }
  void
  ui_memblt(uint8 opcode,
            /* dest */ int x, int y, int cx, int cy,
-           /* src */ HBITMAP src, int srcx, int srcy)
+           /* src */ RD_HBITMAP src, int srcx, int srcy)
  {
          SET_FUNCTION(opcode);
          XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
+         ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                 (g_display, (Pixmap) src, sw->wnd, g_gc,
+                                  srcx, srcy, cx, cy, x - sw->xoffset, y - sw->yoffset));
          if (g_ownbackstore)
                  XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
          RESET_FUNCTION(opcode);
-Line 2313 
 ui_memblt(uint8 opcode,
+Line 3133 
 ui_memblt(uint8 opcode,
  void
  ui_triblt(uint8 opcode,
            /* dest */ int x, int y, int cx, int cy,
-           /* src */ HBITMAP src, int srcx, int srcy,
+           /* src */ RD_HBITMAP src, int srcx, int srcy,
            /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
  {
          /* This is potentially difficult to do in general. Until someone
-Line 2351 
 ui_line(uint8 opcode,
+Line 3171 
 ui_line(uint8 opcode,
          SET_FUNCTION(opcode);
          SET_FOREGROUND(pen->colour);
          XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);
+         ON_ALL_SEAMLESS_WINDOWS(XDrawLine, (g_display, sw->wnd, g_gc,
+                                             startx - sw->xoffset, starty - sw->yoffset,
+                                             endx - sw->xoffset, endy - sw->yoffset));
          if (g_ownbackstore)
                  XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);
          RESET_FUNCTION(opcode);
-Line 2368 
 ui_rect(
+Line 3191 
 ui_rect(
  void
  ui_polygon(uint8 opcode,
             /* mode */ uint8 fillmode,
-            /* dest */ POINT * point, int npoints,
+            /* dest */ RD_POINT * point, int npoints,
             /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
  {
          uint8 style, i, ipattern[8];
-Line 2411 
 ui_polygon(uint8 opcode,
+Line 3234 
 ui_polygon(uint8 opcode,
                          FILL_POLYGON((XPoint *) point, npoints);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  case 3: /* Pattern */
-Line 2426 
 ui_polygon(uint8 opcode,
+Line 3249 
 ui_polygon(uint8 opcode,
                          FILL_POLYGON((XPoint *) point, npoints);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  default:
-Line 2438 
 ui_polygon(uint8 opcode,
+Line 3261 
 ui_polygon(uint8 opcode,
  void
  ui_polyline(uint8 opcode,
-             /* dest */ POINT * points, int npoints,
+             /* dest */ RD_POINT * points, int npoints,
              /* pen */ PEN * pen)
  {
          /* TODO: set join style */
-Line 2448 
 ui_polyline(uint8 opcode,
+Line 3271 
 ui_polyline(uint8 opcode,
          if (g_ownbackstore)
                  XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
                             CoordModePrevious);
+         ON_ALL_SEAMLESS_WINDOWS(seamless_XDrawLines,
+                                 (sw->wnd, (XPoint *) points, npoints, sw->xoffset, sw->yoffset));
          RESET_FUNCTION(opcode);
  }
-Line 2485 
 ui_ellipse(uint8 opcode,
+Line 3312 
 ui_ellipse(uint8 opcode,
                          DRAW_ELLIPSE(x, y, cx, cy, fillmode);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  case 3: /* Pattern */
-Line 2500 
 ui_ellipse(uint8 opcode,
+Line 3327 
 ui_ellipse(uint8 opcode,
                          DRAW_ELLIPSE(x, y, cx, cy, fillmode);
                          XSetFillStyle(g_display, g_gc, FillSolid);
                          XSetTSOrigin(g_display, g_gc, 0, 0);
-                         ui_destroy_glyph((HGLYPH) fill);
+                         ui_destroy_glyph((RD_HGLYPH) fill);
                          break;
                  default:
-Line 2514 
 ui_ellipse(uint8 opcode,
+Line 3341 
 ui_ellipse(uint8 opcode,
  void
  ui_draw_glyph(int mixmode,
                /* dest */ int x, int y, int cx, int cy,
-               /* src */ HGLYPH glyph, int srcx, int srcy,
+               /* src */ RD_HGLYPH glyph, int srcx, int srcy,
                int bgcolour, int fgcolour)
  {
          SET_FOREGROUND(fgcolour);
-Line 2668 
 ui_draw_text(uint8 font, uint8 flags, ui
+Line 3495 
 ui_draw_text(uint8 font, uint8 flags, ui
          if (g_ownbackstore)
          {
                  if (boxcx > 1)
+                 {
                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,
                                    boxy, boxcx, boxcy, boxx, boxy);
+                         ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                                 (g_display, g_backstore, sw->wnd, g_gc,
+                                                  boxx, boxy,
+                                                  boxcx, boxcy,
+                                                  boxx - sw->xoffset, boxy - sw->yoffset));
+                 }
                  else
+                 {
                          XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,
                                    clipy, clipcx, clipcy, clipx, clipy);
+                         ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                                 (g_display, g_backstore, sw->wnd, g_gc,
+                                                  clipx, clipy,
+                                                  clipcx, clipcy, clipx - sw->xoffset,
+                                                  clipy - sw->yoffset));
+                 }
          }
  }
-Line 2685 
 ui_desktop_save(uint32 offset, int x, in
+Line 3526 
 ui_desktop_save(uint32 offset, int x, in
          if (g_ownbackstore)
          {
                  image = XGetImage(g_display, g_backstore, x, y, cx, cy, AllPlanes, ZPixmap);
+                 exit_if_null(image);
          }
          else
          {
                  pix = XCreatePixmap(g_display, g_wnd, cx, cy, g_depth);
                  XCopyArea(g_display, g_wnd, pix, g_gc, x, y, cx, cy, 0, 0);
                  image = XGetImage(g_display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
+                 exit_if_null(image);
                  XFreePixmap(g_display, pix);
          }
-Line 2712 
 ui_desktop_restore(uint32 offset, int x,
+Line 3555 
 ui_desktop_restore(uint32 offset, int x,
                  return;
          image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
-                              (char *) data, cx, cy, BitmapPad(g_display), cx * g_bpp / 8);
+                              (char *) data, cx, cy, g_bpp, 0);
          if (g_ownbackstore)
          {
                  XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
                  XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
+                 ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                         (g_display, g_backstore, sw->wnd, g_gc,
+                                          x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
          }
          else
          {
                  XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
+                 ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
+                                         (g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
+                                          x - sw->xoffset, y - sw->yoffset));
          }
          XFree(image);
-Line 2737 
 void
+Line 3586 
 void
  ui_end_update(void)
  {
  }
+ void
+ ui_seamless_begin(RD_BOOL hidden)
+ {
+         if (!g_seamless_rdp)
+                 return;
+         if (g_seamless_started)
+                 return;
+         g_seamless_started = True;
+         g_seamless_hidden = hidden;
+         if (!hidden)
+                 ui_seamless_toggle();
+ }
+ void
+ ui_seamless_hide_desktop()
+ {
+         if (!g_seamless_rdp)
+                 return;
+         if (!g_seamless_started)
+                 return;
+         if (g_seamless_active)
+                 ui_seamless_toggle();
+         g_seamless_hidden = True;
+ }
+ void
+ ui_seamless_unhide_desktop()
+ {
+         if (!g_seamless_rdp)
+                 return;
+         if (!g_seamless_started)
+                 return;
+         g_seamless_hidden = False;
+         ui_seamless_toggle();
+ }
+ void
+ ui_seamless_toggle()
+ {
+         if (!g_seamless_rdp)
+                 return;
+         if (!g_seamless_started)
+                 return;
+         if (g_seamless_hidden)
+                 return;
+         if (g_seamless_active)
+         {
+                 /* Deactivate */
+                 while (g_seamless_windows)
+                 {
+                         XDestroyWindow(g_display, g_seamless_windows->wnd);
+                         sw_remove_window(g_seamless_windows);
+                 }
+                 XMapWindow(g_display, g_wnd);
+         }
+         else
+         {
+                 /* Activate */
+                 XUnmapWindow(g_display, g_wnd);
+                 seamless_send_sync();
+         }
+         g_seamless_active = !g_seamless_active;
+ }
+ void
+ ui_seamless_create_window(unsigned long id, unsigned long group, unsigned long parent,
+                           unsigned long flags)
+ {
+         Window wnd;
+         XSetWindowAttributes attribs;
+         XClassHint *classhints;
+         XSizeHints *sizehints;
+         XWMHints *wmhints;
+         long input_mask;
+         seamless_window *sw, *sw_parent;
+         if (!g_seamless_active)
+                 return;
+         /* Ignore CREATEs for existing windows */
+         sw = sw_get_window_by_id(id);
+         if (sw)
+                 return;
+         get_window_attribs(&attribs);
+         wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0, g_depth,
+                             InputOutput, g_visual,
+                             CWBackPixel | CWBackingStore | CWColormap | CWBorderPixel, &attribs);
+         XStoreName(g_display, wnd, "SeamlessRDP");
+         ewmh_set_wm_name(wnd, "SeamlessRDP");
+         mwm_hide_decorations(wnd);
+         classhints = XAllocClassHint();
+         if (classhints != NULL)
+         {
+                 classhints->res_name = "rdesktop";
+                 classhints->res_class = "SeamlessRDP";
+                 XSetClassHint(g_display, wnd, classhints);
+                 XFree(classhints);
+         }
+         /* WM_NORMAL_HINTS */
+         sizehints = XAllocSizeHints();
+         if (sizehints != NULL)
+         {
+                 sizehints->flags = USPosition;
+                 XSetWMNormalHints(g_display, wnd, sizehints);
+                 XFree(sizehints);
+         }
+         /* Parent-less transient windows */
+         if (parent == 0xFFFFFFFF)
+         {
+                 XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
+                 /* Some buggy wm:s (kwin) do not handle the above, so fake it
+                    using some other hints. */
+                 ewmh_set_window_popup(wnd);
+         }
+         /* Normal transient windows */
+         else if (parent != 0x00000000)
+         {
+                 sw_parent = sw_get_window_by_id(parent);
+                 if (sw_parent)
+                         XSetTransientForHint(g_display, wnd, sw_parent->wnd);
+                 else
+                         warning("ui_seamless_create_window: No parent window 0x%lx\n", parent);
+         }
+         if (flags & SEAMLESSRDP_CREATE_MODAL)
+         {
+                 /* We do this to support buggy wm:s (*cough* metacity *cough*)
+                    somewhat at least */
+                 if (parent == 0x00000000)
+                         XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
+                 ewmh_set_window_modal(wnd);
+         }
+         if (flags & SEAMLESSRDP_CREATE_TOPMOST)
+         {
+                 /* Make window always-on-top */
+                 ewmh_set_window_above(wnd);
+         }
+         /* FIXME: Support for Input Context:s */
+         get_input_mask(&input_mask);
+         input_mask |= PropertyChangeMask;
+         XSelectInput(g_display, wnd, input_mask);
+         /* handle the WM_DELETE_WINDOW protocol. */
+         XSetWMProtocols(g_display, wnd, &g_kill_atom, 1);
+         sw = xmalloc(sizeof(seamless_window));
+         memset(sw, 0, sizeof(seamless_window));
+         sw->wnd = wnd;
+         sw->id = id;
+         sw->group = sw_find_group(group, False);
+         sw->group->refcnt++;
+         sw->state = SEAMLESSRDP_NOTYETMAPPED;
+         sw->desktop = 0;
+         sw->position_timer = xmalloc(sizeof(struct timeval));
+         timerclear(sw->position_timer);
+         sw->outstanding_position = False;
+         sw->outpos_serial = 0;
+         sw->outpos_xoffset = sw->outpos_yoffset = 0;
+         sw->outpos_width = sw->outpos_height = 0;
+         sw->next = g_seamless_windows;
+         g_seamless_windows = sw;
+         /* WM_HINTS */
+         wmhints = XAllocWMHints();
+         if (wmhints)
+         {
+                 wmhints->flags = WindowGroupHint;
+                 wmhints->window_group = sw->group->wnd;
+                 XSetWMHints(g_display, sw->wnd, wmhints);
+                 XFree(wmhints);
+         }
+ }
+ void
+ ui_seamless_destroy_window(unsigned long id, unsigned long flags)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_destroy_window: No information for window 0x%lx\n", id);
+                 return;
+         }
+         XDestroyWindow(g_display, sw->wnd);
+         sw_remove_window(sw);
+ }
+ void
+ ui_seamless_destroy_group(unsigned long id, unsigned long flags)
+ {
+         seamless_window *sw, *sw_next;
+         if (!g_seamless_active)
+                 return;
+         for (sw = g_seamless_windows; sw; sw = sw_next)
+         {
+                 sw_next = sw->next;
+                 if (sw->group->id == id)
+                 {
+                         XDestroyWindow(g_display, sw->wnd);
+                         sw_remove_window(sw);
+                 }
+         }
+ }
+ void
+ ui_seamless_seticon(unsigned long id, const char *format, int width, int height, int chunk,
+                     const char *data, int chunk_len)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_seticon: No information for window 0x%lx\n", id);
+                 return;
+         }
+         if (chunk == 0)
+         {
+                 if (sw->icon_size)
+                         warning("ui_seamless_seticon: New icon started before previous completed\n");
+                 if (strcmp(format, "RGBA") != 0)
+                 {
+                         warning("ui_seamless_seticon: Uknown icon format \"%s\"\n", format);
+                         return;
+                 }
+                 sw->icon_size = width * height * 4;
+                 if (sw->icon_size > 32 * 32 * 4)
+                 {
+                         warning("ui_seamless_seticon: Icon too large (%d bytes)\n", sw->icon_size);
+                         sw->icon_size = 0;
+                         return;
+                 }
+                 sw->icon_offset = 0;
+         }
+         else
+         {
+                 if (!sw->icon_size)
+                         return;
+         }
+         if (chunk_len > (sw->icon_size - sw->icon_offset))
+         {
+                 warning("ui_seamless_seticon: Too large chunk received (%d bytes > %d bytes)\n",
+                         chunk_len, sw->icon_size - sw->icon_offset);
+                 sw->icon_size = 0;
+                 return;
+         }
+         memcpy(sw->icon_buffer + sw->icon_offset, data, chunk_len);
+         sw->icon_offset += chunk_len;
+         if (sw->icon_offset == sw->icon_size)
+         {
+                 ewmh_set_icon(sw->wnd, width, height, sw->icon_buffer);
+                 sw->icon_size = 0;
+         }
+ }
+ void
+ ui_seamless_delicon(unsigned long id, const char *format, int width, int height)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_seticon: No information for window 0x%lx\n", id);
+                 return;
+         }
+         if (strcmp(format, "RGBA") != 0)
+         {
+                 warning("ui_seamless_seticon: Uknown icon format \"%s\"\n", format);
+                 return;
+         }
+         ewmh_del_icon(sw->wnd, width, height);
+ }
+ void
+ ui_seamless_move_window(unsigned long id, int x, int y, int width, int height, unsigned long flags)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_move_window: No information for window 0x%lx\n", id);
+                 return;
+         }
+         /* We ignore server updates until it has handled our request. */
+         if (sw->outstanding_position)
+                 return;
+         if (!width || !height)
+                 /* X11 windows must be at least 1x1 */
+                 return;
+         sw->xoffset = x;
+         sw->yoffset = y;
+         sw->width = width;
+         sw->height = height;
+         /* If we move the window in a maximized state, then KDE won't
+            accept restoration */
+         switch (sw->state)
+         {
+                 case SEAMLESSRDP_MINIMIZED:
+                 case SEAMLESSRDP_MAXIMIZED:
+                         return;
+         }
+         /* FIXME: Perhaps use ewmh_net_moveresize_window instead */
+         XMoveResizeWindow(g_display, sw->wnd, sw->xoffset, sw->yoffset, sw->width, sw->height);
+ }
+ void
+ ui_seamless_restack_window(unsigned long id, unsigned long behind, unsigned long flags)
+ {
+         seamless_window *sw;
+         XWindowChanges values;
+         unsigned long restack_serial;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_restack_window: No information for window 0x%lx\n", id);
+                 return;
+         }
+         if (behind)
+         {
+                 seamless_window *sw_behind;
+                 sw_behind = sw_get_window_by_id(behind);
+                 if (!sw_behind)
+                 {
+                         warning("ui_seamless_restack_window: No information for behind window 0x%lx\n", behind);
+                         return;
+                 }
+                 if (!g_seamless_broken_restack)
+                 {
+                         values.stack_mode = Below;
+                         values.sibling = sw_behind->wnd;
+                         restack_serial = XNextRequest(g_display);
+                         XReconfigureWMWindow(g_display, sw->wnd, DefaultScreen(g_display),
+                                              CWStackMode | CWSibling, &values);
+                         sw_wait_configurenotify(sw->wnd, restack_serial);
+                 }
+         }
+         else
+         {
+                 values.stack_mode = Above;
+                 restack_serial = XNextRequest(g_display);
+                 XReconfigureWMWindow(g_display, sw->wnd, DefaultScreen(g_display), CWStackMode,
+                                      &values);
+                 sw_wait_configurenotify(sw->wnd, restack_serial);
+         }
+         sw_restack_window(sw, behind);
+         if (flags & SEAMLESSRDP_CREATE_TOPMOST)
+         {
+                 /* Make window always-on-top */
+                 ewmh_set_window_above(sw->wnd);
+         }
+ }
+ void
+ ui_seamless_settitle(unsigned long id, const char *title, unsigned long flags)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_settitle: No information for window 0x%lx\n", id);
+                 return;
+         }
+         /* FIXME: Might want to convert the name for non-EWMH WMs */
+         XStoreName(g_display, sw->wnd, title);
+         ewmh_set_wm_name(sw->wnd, title);
+ }
+ void
+ ui_seamless_setstate(unsigned long id, unsigned int state, unsigned long flags)
+ {
+         seamless_window *sw;
+         if (!g_seamless_active)
+                 return;
+         sw = sw_get_window_by_id(id);
+         if (!sw)
+         {
+                 warning("ui_seamless_setstate: No information for window 0x%lx\n", id);
+                 return;
+         }
+         switch (state)
+         {
+                 case SEAMLESSRDP_NORMAL:
+                 case SEAMLESSRDP_MAXIMIZED:
+                         ewmh_change_state(sw->wnd, state);
+                         XMapWindow(g_display, sw->wnd);
+                         break;
+                 case SEAMLESSRDP_MINIMIZED:
+                         /* EWMH says: "if an Application asks to toggle _NET_WM_STATE_HIDDEN
+                            the Window Manager should probably just ignore the request, since
+                            _NET_WM_STATE_HIDDEN is a function of some other aspect of the window
+                            such as minimization, rather than an independent state." Besides,
+                            XIconifyWindow is easier. */
+                         if (sw->state == SEAMLESSRDP_NOTYETMAPPED)
+                         {
+                                 XWMHints *hints;
+                                 hints = XGetWMHints(g_display, sw->wnd);
+                                 if (hints)
+                                 {
+                                         hints->flags |= StateHint;
+                                         hints->initial_state = IconicState;
+                                         XSetWMHints(g_display, sw->wnd, hints);
+                                         XFree(hints);
+                                 }
+                                 XMapWindow(g_display, sw->wnd);
+                         }
+                         else
+                                 XIconifyWindow(g_display, sw->wnd, DefaultScreen(g_display));
+                         break;
+                 default:
+                         warning("SeamlessRDP: Invalid state %d\n", state);
+                         break;
+         }
+         sw->state = state;
+ }
+ void
+ ui_seamless_syncbegin(unsigned long flags)
+ {
+         if (!g_seamless_active)
+                 return;
+         /* Destroy all seamless windows */
+         while (g_seamless_windows)
+         {
+                 XDestroyWindow(g_display, g_seamless_windows->wnd);
+                 sw_remove_window(g_seamless_windows);
+         }
+ }
+ void
+ ui_seamless_ack(unsigned int serial)
+ {
+         seamless_window *sw;
+         for (sw = g_seamless_windows; sw; sw = sw->next)
+         {
+                 if (sw->outstanding_position && (sw->outpos_serial == serial))
+                 {
+                         sw->xoffset = sw->outpos_xoffset;
+                         sw->yoffset = sw->outpos_yoffset;
+                         sw->width = sw->outpos_width;
+                         sw->height = sw->outpos_height;
+                         sw->outstanding_position = False;
+                         /* Do a complete redraw of the window as part of the
+                            completion of the move. This is to remove any
+                            artifacts caused by our lack of synchronization. */
+                         XCopyArea(g_display, g_backstore,
+                                   sw->wnd, g_gc,
+                                   sw->xoffset, sw->yoffset, sw->width, sw->height, 0, 0);
+                         break;
+                 }
+         }
+ }

 Legend:



Removed from v.1042
 


changed lines


 
Added in v.1463
 Legend:



Removed from v.1042
 


changed lines


 
Added in v.1463
-Removed from v.1042
+Added in v.1463

	ViewVC Help
Powered by ViewVC 1.1.26