moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 3078 insertions, 0 deletions

diff --git a/src/compositor/compositor-xrender.c b/src/compositor/compositor-xrender.c
new file mode 100644
index 00000000..e0938706
--- /dev/null
+++ b/src/compositor/compositor-xrender.c
@@ -0,0 +1,3078 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2007 Iain Holmes
+ * Based on xcompmgr - (c) 2003 Keith Packard
+ *          xfwm4    - (c) 2005-2007 Olivier Fourdan
+ *
+ * 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 the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE 500 /* for usleep() */
+
+#include <config.h>
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+
+#include <gdk/gdk.h>
+
+#include "display.h"
+#include "screen.h"
+#include "frame.h"
+#include "errors.h"
+#include "window.h"
+#include "compositor-private.h"
+#include "compositor-xrender.h"
+#include "xprops.h"
+#include <X11/Xatom.h>
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xcomposite.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xfixes.h>
+#include <X11/extensions/Xrender.h>
+
+#if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 2
+#define HAVE_NAME_WINDOW_PIXMAP 1
+#endif
+
+#if COMPOSITE_MAJOR > 0 || COMPOSITE_MINOR >= 3
+#define HAVE_COW 1
+#else
+/* Don't have a cow man...HAAHAAHAA */
+#endif
+
+#define USE_IDLE_REPAINT 1
+
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+static inline gboolean
+composite_at_least_version (MetaDisplay *display,
+                            int maj, int min)
+{
+  static int major = -1;
+  static int minor = -1;
+
+  if (major == -1)
+    meta_display_get_compositor_version (display, &major, &minor);
+
+  return (major > maj || (major == maj && minor >= min));
+}
+
+#define have_name_window_pixmap(display) \
+  composite_at_least_version (display, 0, 2)
+#define have_cow(display) \
+  composite_at_least_version (display, 0, 3)
+
+#endif
+
+typedef enum _MetaCompWindowType
+{
+  META_COMP_WINDOW_NORMAL,
+  META_COMP_WINDOW_DND,
+  META_COMP_WINDOW_DESKTOP,
+  META_COMP_WINDOW_DOCK,
+  META_COMP_WINDOW_MENU,
+  META_COMP_WINDOW_DROP_DOWN_MENU,
+  META_COMP_WINDOW_TOOLTIP,
+} MetaCompWindowType;
+
+typedef enum _MetaShadowType
+{
+  META_SHADOW_SMALL,
+  META_SHADOW_MEDIUM,
+  META_SHADOW_LARGE,
+  LAST_SHADOW_TYPE
+} MetaShadowType;
+
+typedef struct _MetaCompositorXRender
+{
+  MetaCompositor compositor;
+
+  MetaDisplay *display;
+
+  Atom atom_x_root_pixmap;
+  Atom atom_x_set_root;
+  Atom atom_net_wm_window_opacity;
+  Atom atom_net_wm_window_type_dnd;
+
+  Atom atom_net_wm_window_type;
+  Atom atom_net_wm_window_type_desktop;
+  Atom atom_net_wm_window_type_dock;
+  Atom atom_net_wm_window_type_menu;
+  Atom atom_net_wm_window_type_dialog;
+  Atom atom_net_wm_window_type_normal;
+  Atom atom_net_wm_window_type_utility;
+  Atom atom_net_wm_window_type_splash;
+  Atom atom_net_wm_window_type_toolbar;
+  Atom atom_net_wm_window_type_dropdown_menu;
+  Atom atom_net_wm_window_type_tooltip;
+
+#ifdef USE_IDLE_REPAINT
+  guint repaint_id;
+#endif
+  guint enabled : 1;
+  guint show_redraw : 1;
+  guint debug : 1;
+} MetaCompositorXRender;
+
+typedef struct _conv
+{
+  int size;
+  double *data;
+} conv;
+
+typedef struct _shadow
+{
+  conv *gaussian_map;
+  guchar *shadow_corner;
+  guchar *shadow_top;
+} shadow;
+
+typedef struct _MetaCompScreen
+{
+  MetaScreen *screen;
+  GList *windows;
+  GHashTable *windows_by_xid;
+
+  MetaWindow *focus_window;
+
+  Window output;
+
+  gboolean have_shadows;
+  shadow *shadows[LAST_SHADOW_TYPE];
+
+  Picture root_picture;
+  Picture root_buffer;
+  Picture black_picture;
+  Picture trans_black_picture;
+  Picture root_tile;
+  XserverRegion all_damage;
+
+  guint overlays;
+  gboolean compositor_active;
+  gboolean clip_changed;
+
+  GSList *dock_windows;
+} MetaCompScreen;
+
+typedef struct _MetaCompWindow
+{
+  MetaScreen *screen;
+  MetaWindow *window; /* May be NULL if this window isn't managed by Marco */
+  Window id;
+  XWindowAttributes attrs;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  Pixmap back_pixmap;
+
+  /* When the window is shaded back_pixmap will be replaced with the pixmap
+     for the shaded window. This is a copy of the original unshaded window
+     so that we can still see what the window looked like when it is needed
+     for the _get_window_pixmap function */
+  Pixmap shaded_back_pixmap;
+#endif
+
+  int mode;
+
+  gboolean damaged;
+  gboolean shaped;
+
+  MetaCompWindowType type;
+
+  Damage damage;
+  Picture picture;
+  Picture alpha_pict;
+
+  gboolean needs_shadow;
+  MetaShadowType shadow_type;
+  Picture shadow_pict;
+
+  XserverRegion border_size;
+  XserverRegion extents;
+
+  Picture shadow;
+  int shadow_dx;
+  int shadow_dy;
+  int shadow_width;
+  int shadow_height;
+
+  guint opacity;
+
+  XserverRegion border_clip;
+
+  gboolean updates_frozen;
+  gboolean update_pending;
+} MetaCompWindow;
+
+#define OPAQUE 0xffffffff
+
+#define WINDOW_SOLID 0
+#define WINDOW_ARGB 1
+
+#define SHADOW_SMALL_RADIUS 3.0
+#define SHADOW_MEDIUM_RADIUS 6.0
+#define SHADOW_LARGE_RADIUS 12.0
+
+#define SHADOW_SMALL_OFFSET_X (SHADOW_SMALL_RADIUS * -3 / 2)
+#define SHADOW_SMALL_OFFSET_Y (SHADOW_SMALL_RADIUS * -3 / 2)
+#define SHADOW_MEDIUM_OFFSET_X (SHADOW_MEDIUM_RADIUS * -3 / 2)
+#define SHADOW_MEDIUM_OFFSET_Y (SHADOW_MEDIUM_RADIUS * -5 / 4)
+#define SHADOW_LARGE_OFFSET_X -15
+#define SHADOW_LARGE_OFFSET_Y -15
+
+#define SHADOW_OPACITY 0.66
+
+#define TRANS_OPACITY 0.75
+
+#define DISPLAY_COMPOSITOR(display) ((MetaCompositorXRender *) meta_display_get_compositor (display))
+
+/* Gaussian stuff for creating the shadows */
+static double
+gaussian (double r,
+          double x,
+          double y)
+{
+  return ((1 / (sqrt (2 * G_PI * r))) *
+          exp ((- (x * x + y * y)) / (2 * r * r)));
+}
+
+static conv *
+make_gaussian_map (double r)
+{
+  conv *c;
+  int size, centre;
+  int x, y;
+  double t, g;
+
+  size = ((int) ceil ((r * 3)) + 1) & ~1;
+  centre = size / 2;
+  c = g_malloc (sizeof (conv) + size * size * sizeof (double));
+  c->size = size;
+  c->data = (double *) (c + 1);
+  t = 0.0;
+
+  for (y = 0; y < size; y++)
+    {
+      for (x = 0; x < size; x++)
+        {
+          g = gaussian (r, (double) (x - centre), (double) (y - centre));
+          t += g;
+          c->data[y * size + x] = g;
+        }
+    }
+
+  for (y = 0; y < size; y++)
+    {
+      for (x = 0; x < size; x++)
+        {
+          c->data[y * size + x] /= t;
+        }
+    }
+
+  return c;
+}
+
+static void
+dump_xserver_region (const char   *location,
+                     MetaDisplay  *display,
+                     XserverRegion region)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int nrects;
+  XRectangle *rects;
+  XRectangle bounds;
+
+  if (!compositor->debug)
+    return;
+
+  if (region)
+    {
+      rects = XFixesFetchRegionAndBounds (xdisplay, region, &nrects, &bounds);
+      if (nrects > 0)
+        {
+          int i;
+          fprintf (stderr, "%s (XSR): %d rects, bounds: %d,%d (%d,%d)\n",
+                   location, nrects, bounds.x, bounds.y, bounds.width, bounds.height);
+          for (i = 1; i < nrects; i++)
+            fprintf (stderr, "\t%d,%d (%d,%d)\n",
+                     rects[i].x, rects[i].y, rects[i].width, rects[i].height);
+        }
+      else
+        fprintf (stderr, "%s (XSR): empty\n", location);
+      XFree (rects);
+    }
+  else
+    fprintf (stderr, "%s (XSR): null\n", location);
+}
+
+/*
+* A picture will help
+*
+*      -center   0                width  width+center
+*  -center +-----+-------------------+-----+
+*          |     |                   |     |
+*          |     |                   |     |
+*        0 +-----+-------------------+-----+
+*          |     |                   |     |
+*          |     |                   |     |
+*          |     |                   |     |
+*   height +-----+-------------------+-----+
+*          |     |                   |     |
+* height+  |     |                   |     |
+*  center  +-----+-------------------+-----+
+*/
+static guchar
+sum_gaussian (conv          *map,
+              double         opacity,
+              int            x,
+              int            y,
+              int            width,
+              int            height)
+{
+  double *g_data, *g_line;
+  double v;
+  int fx, fy;
+  int fx_start, fx_end;
+  int fy_start, fy_end;
+  int g_size, centre;
+
+  g_line = map->data;
+  g_size = map->size;
+  centre = g_size / 2;
+  fx_start = centre - x;
+  if (fx_start < 0)
+    fx_start = 0;
+
+  fx_end = width + centre - x;
+  if (fx_end > g_size)
+    fx_end = g_size;
+
+  fy_start = centre - y;
+  if (fy_start < 0)
+    fy_start = 0;
+
+  fy_end = height + centre - y;
+  if (fy_end > g_size)
+    fy_end = g_size;
+
+  g_line = g_line + fy_start * g_size + fx_start;
+
+  v = 0.0;
+  for (fy = fy_start; fy < fy_end; fy++)
+    {
+      g_data = g_line;
+      g_line += g_size;
+
+      for (fx = fx_start; fx < fx_end; fx++)
+        v += *g_data++;
+    }
+
+  if (v > 1.0)
+    v = 1.0;
+
+  return ((guchar) (v * opacity * 255.0));
+}
+
+/* precompute shadow corners and sides to save time for large windows */
+static void
+presum_gaussian (shadow *shad)
+{
+  int centre;
+  int opacity, x, y;
+  int msize;
+  conv *map;
+
+  map = shad->gaussian_map;
+  msize = map->size;
+  centre = map->size / 2;
+
+  if (shad->shadow_corner)
+    g_free (shad->shadow_corner);
+  if (shad->shadow_top)
+    g_free (shad->shadow_top);
+
+  shad->shadow_corner = (guchar *)(g_malloc ((msize + 1) * (msize + 1) * 26));
+  shad->shadow_top = (guchar *) (g_malloc ((msize + 1) * 26));
+
+  for (x = 0; x <= msize; x++)
+    {
+
+      shad->shadow_top[25 * (msize + 1) + x] =
+        sum_gaussian (map, 1, x - centre, centre, msize * 2, msize * 2);
+      for (opacity = 0; opacity < 25; opacity++)
+        {
+          shad->shadow_top[opacity * (msize + 1) + x] =
+            shad->shadow_top[25 * (msize + 1) + x] * opacity / 25;
+        }
+
+      for (y = 0; y <= x; y++)
+        {
+          shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                              + y * (msize + 1)
+                              + x]
+            = sum_gaussian (map, 1, x - centre, y - centre,
+                            msize * 2, msize * 2);
+
+          shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                              + x * (msize + 1) + y] =
+            shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                                + y * (msize + 1) + x];
+
+          for (opacity = 0; opacity < 25; opacity++)
+            {
+              shad->shadow_corner[opacity * (msize + 1) * (msize + 1)
+                                  + y * (msize + 1) + x]
+                = shad->shadow_corner[opacity * (msize + 1) * (msize + 1)
+                                      + x * (msize + 1) + y]
+                = shad->shadow_corner[25 * (msize + 1) * (msize + 1)
+                                      + y * (msize + 1) + x] * opacity / 25;
+            }
+        }
+    }
+}
+
+static void
+generate_shadows (MetaCompScreen *info)
+{
+  double radii[LAST_SHADOW_TYPE] = {SHADOW_SMALL_RADIUS,
+                                    SHADOW_MEDIUM_RADIUS,
+                                    SHADOW_LARGE_RADIUS};
+  int i;
+
+  for (i = 0; i < LAST_SHADOW_TYPE; i++) {
+    shadow *shad = g_new0 (shadow, 1);
+
+    shad->gaussian_map = make_gaussian_map (radii[i]);
+    presum_gaussian (shad);
+
+    info->shadows[i] = shad;
+  }
+}
+
+static XImage *
+make_shadow (MetaDisplay   *display,
+             MetaScreen    *screen,
+             MetaShadowType shadow_type,
+             double         opacity,
+             int            width,
+             int            height)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XImage *ximage;
+  guchar *data;
+  shadow *shad;
+  int msize;
+  int ylimit, xlimit;
+  int swidth, sheight;
+  int centre;
+  int x, y;
+  guchar d;
+  int x_diff;
+  int opacity_int = (int)(opacity * 25);
+  int screen_number = meta_screen_get_screen_number (screen);
+
+  if (info==NULL)
+    {
+      return NULL;
+    }
+
+  shad = info->shadows[shadow_type];
+  msize = shad->gaussian_map->size;
+  swidth = width + msize;
+  sheight = height + msize;
+  centre = msize / 2;
+
+  data = g_malloc (swidth * sheight * sizeof (guchar));
+
+  ximage = XCreateImage (xdisplay, DefaultVisual (xdisplay, screen_number),
+                         8, ZPixmap, 0, (char *) data,
+                         swidth, sheight, 8, swidth * sizeof (guchar));
+  if (!ximage)
+    {
+      g_free (data);
+      return NULL;
+    }
+
+  /*
+   * Build the gaussian in sections
+   */
+
+  /*
+   * centre (fill the complete data array
+   */
+  if (msize > 0)
+    d = shad->shadow_top[opacity_int * (msize + 1) + msize];
+  else
+    d = sum_gaussian (shad->gaussian_map, opacity, centre,
+                      centre, width, height);
+  memset (data, d, sheight * swidth);
+
+  /*
+   * corners
+   */
+  ylimit = msize;
+  if (ylimit > sheight / 2)
+    ylimit = (sheight + 1) / 2;
+
+  xlimit = msize;
+  if (xlimit > swidth / 2)
+    xlimit = (swidth + 1) / 2;
+
+  for (y = 0; y < ylimit; y++)
+    {
+      for (x = 0; x < xlimit; x++)
+        {
+
+          if (xlimit == msize && ylimit == msize)
+            d = shad->shadow_corner[opacity_int * (msize + 1) * (msize + 1) + y * (msize + 1) + x];
+          else
+            d = sum_gaussian (shad->gaussian_map, opacity, x - centre,
+                              y - centre, width, height);
+
+          data[y * swidth + x] = d;
+          data[(sheight - y - 1) * swidth + x] = d;
+          data[(sheight - y - 1) * swidth + (swidth - x - 1)] = d;
+          data[y * swidth + (swidth - x - 1)] = d;
+        }
+    }
+
+  /* top/bottom */
+  x_diff = swidth - (msize * 2);
+  if (x_diff > 0 && ylimit > 0)
+    {
+      for (y = 0; y < ylimit; y++)
+        {
+          if (ylimit == msize)
+            d = shad->shadow_top[opacity_int * (msize + 1) + y];
+          else
+            d = sum_gaussian (shad->gaussian_map, opacity, centre,
+                              y - centre, width, height);
+
+          memset (&data[y * swidth + msize], d, x_diff);
+          memset (&data[(sheight - y - 1) * swidth + msize], d, x_diff);
+        }
+    }
+
+  /*
+   * sides
+   */
+  for (x = 0; x < xlimit; x++)
+    {
+      if (xlimit == msize)
+        d = shad->shadow_top[opacity_int * (msize + 1) + x];
+      else
+        d = sum_gaussian (shad->gaussian_map, opacity, x - centre,
+                          centre, width, height);
+
+      for (y = msize; y < sheight - msize; y++)
+        {
+          data[y * swidth + x] = d;
+          data[y * swidth + (swidth - x - 1)] = d;
+        }
+    }
+
+  return ximage;
+}
+
+static Picture
+shadow_picture (MetaDisplay   *display,
+                MetaScreen    *screen,
+                MetaShadowType shadow_type,
+                double         opacity,
+                Picture        alpha_pict,
+                int            width,
+                int            height,
+                int           *wp,
+                int           *hp)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XImage *shadow_image;
+  Pixmap shadow_pixmap;
+  Picture shadow_picture;
+  Window xroot = meta_screen_get_xroot (screen);
+  GC gc;
+
+  shadow_image = make_shadow (display, screen, shadow_type,
+                              opacity, width, height);
+  if (!shadow_image)
+    return None;
+
+  shadow_pixmap = XCreatePixmap (xdisplay, xroot,
+                                 shadow_image->width, shadow_image->height, 8);
+  if (!shadow_pixmap)
+    {
+      XDestroyImage (shadow_image);
+      return None;
+    }
+
+  shadow_picture = XRenderCreatePicture (xdisplay, shadow_pixmap,
+                                         XRenderFindStandardFormat (xdisplay,
+PictStandardA8),
+                                         0, 0);
+  if (!shadow_picture)
+    {
+      XDestroyImage (shadow_image);
+      XFreePixmap (xdisplay, shadow_pixmap);
+      return None;
+    }
+
+  gc = XCreateGC (xdisplay, shadow_pixmap, 0, 0);
+  if (!gc)
+    {
+      XDestroyImage (shadow_image);
+      XFreePixmap (xdisplay, shadow_pixmap);
+      XRenderFreePicture (xdisplay, shadow_picture);
+      return None;
+    }
+
+  XPutImage (xdisplay, shadow_pixmap, gc, shadow_image, 0, 0, 0, 0,
+             shadow_image->width, shadow_image->height);
+  *wp = shadow_image->width;
+  *hp = shadow_image->height;
+
+  XFreeGC (xdisplay, gc);
+  XDestroyImage (shadow_image);
+  XFreePixmap (xdisplay, shadow_pixmap);
+
+  return shadow_picture;
+}
+
+static MetaCompWindow *
+find_window_for_screen (MetaScreen *screen,
+                        Window      xwindow)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (info == NULL)
+    return NULL;
+
+  return g_hash_table_lookup (info->windows_by_xid, (gpointer) xwindow);
+}
+
+static MetaCompWindow *
+find_window_in_display (MetaDisplay *display,
+                        Window       xwindow)
+{
+  GSList *index;
+
+  for (index = meta_display_get_screens (display); index; index = index->next)
+    {
+      MetaCompWindow *cw = find_window_for_screen (index->data, xwindow);
+
+      if (cw != NULL)
+        return cw;
+    }
+
+  return NULL;
+}
+
+static MetaCompWindow *
+find_window_for_child_window_in_display (MetaDisplay *display,
+                                         Window       xwindow)
+{
+  Window ignored1, *ignored2;
+  Window parent;
+  guint ignored_children;
+
+  XQueryTree (meta_display_get_xdisplay (display), xwindow, &ignored1,
+              &parent, &ignored2, &ignored_children);
+
+  if (parent != None)
+    return find_window_in_display (display, parent);
+
+  return NULL;
+}
+
+static Picture
+solid_picture (MetaDisplay *display,
+               MetaScreen  *screen,
+               gboolean     argb,
+               double       a,
+               double       r,
+               double       g,
+               double       b)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Pixmap pixmap;
+  Picture picture;
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *render_format;
+  XRenderColor c;
+  Window xroot = meta_screen_get_xroot (screen);
+
+  render_format = XRenderFindStandardFormat (xdisplay,
+                                             argb ? PictStandardARGB32 : PictStandardA8);
+
+  pixmap = XCreatePixmap (xdisplay, xroot, 1, 1, argb ? 32 : 8);
+  g_return_val_if_fail (pixmap != None, None);
+
+  pa.repeat = TRUE;
+  picture = XRenderCreatePicture (xdisplay, pixmap, render_format,
+                                  CPRepeat, &pa);
+  if (picture == None)
+    {
+      XFreePixmap (xdisplay, pixmap);
+      g_warning ("(picture != None) failed");
+      return None;
+    }
+
+  c.alpha = a * 0xffff;
+  c.red = r * 0xffff;
+  c.green = g * 0xffff;
+  c.blue = b * 0xffff;
+
+  XRenderFillRectangle (xdisplay, PictOpSrc, picture, &c, 0, 0, 1, 1);
+  XFreePixmap (xdisplay, pixmap);
+
+  return picture;
+}
+
+static Picture
+root_tile (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Picture picture;
+  Pixmap pixmap;
+  gboolean fill = FALSE;
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *format;
+  int p;
+  Atom background_atoms[2];
+  Atom pixmap_atom;
+  int screen_number = meta_screen_get_screen_number (screen);
+  Window xroot = meta_screen_get_xroot (screen);
+
+  pixmap = None;
+  background_atoms[0] = DISPLAY_COMPOSITOR (display)->atom_x_root_pixmap;
+  background_atoms[1] = DISPLAY_COMPOSITOR (display)->atom_x_set_root;
+
+  pixmap_atom = XInternAtom (xdisplay, "PIXMAP", False);
+  for (p = 0; p < 2; p++)
+    {
+      Atom actual_type;
+      int actual_format;
+      gulong nitems, bytes_after;
+      guchar *prop;
+
+      if (XGetWindowProperty (xdisplay, xroot,
+                              background_atoms[p],
+                              0, 4, FALSE, AnyPropertyType,
+                              &actual_type, &actual_format,
+                              &nitems, &bytes_after, &prop) == Success)
+        {
+          if (actual_type == pixmap_atom &&
+              actual_format == 32 &&
+              nitems == 1)
+            {
+              memcpy (&pixmap, prop, 4);
+              XFree (prop);
+              fill = FALSE;
+              break;
+            }
+        }
+    }
+
+  if (!pixmap)
+    {
+      pixmap = XCreatePixmap (xdisplay, xroot, 1, 1,
+                              DefaultDepth (xdisplay, screen_number));
+      g_return_val_if_fail (pixmap != None, None);
+      fill = TRUE;
+    }
+
+  pa.repeat = TRUE;
+  format = XRenderFindVisualFormat (xdisplay, DefaultVisual (xdisplay,
+                                                             screen_number));
+  g_return_val_if_fail (format != NULL, None);
+
+  picture = XRenderCreatePicture (xdisplay, pixmap, format, CPRepeat, &pa);
+  if ((picture != None) && (fill))
+    {
+      XRenderColor c;
+
+      /* Background default to just plain ugly grey */
+      c.red = 0x8080;
+      c.green = 0x8080;
+      c.blue = 0x8080;
+      c.alpha = 0xffff;
+
+      XRenderFillRectangle (xdisplay, PictOpSrc, picture, &c, 0, 0, 1, 1);
+      XFreePixmap (xdisplay, pixmap);
+    }
+
+  return picture;
+}
+
+static Picture
+create_root_buffer (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Picture pict;
+  XRenderPictFormat *format;
+  Pixmap root_pixmap;
+  Visual *visual;
+  int depth, screen_width, screen_height, screen_number;
+
+  if (info == NULL)
+    {
+      return None;
+    }
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+  screen_number = meta_screen_get_screen_number (screen);
+  visual = DefaultVisual (xdisplay, screen_number);
+  depth = DefaultDepth (xdisplay, screen_number);
+
+  format = XRenderFindVisualFormat (xdisplay, visual);
+  g_return_val_if_fail (format != NULL, None);
+
+  root_pixmap = XCreatePixmap (xdisplay, info->output,
+                               screen_width, screen_height, depth);
+  g_return_val_if_fail (root_pixmap != None, None);
+
+  pict = XRenderCreatePicture (xdisplay, root_pixmap, format, 0, NULL);
+  XFreePixmap (xdisplay, root_pixmap);
+
+  return pict;
+}
+
+static void
+paint_root (MetaScreen *screen,
+            Picture     root_buffer)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  int width, height;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  g_return_if_fail (root_buffer != None);
+
+  if (info->root_tile == None)
+    {
+      info->root_tile = root_tile (screen);
+      g_return_if_fail (info->root_tile != None);
+    }
+
+  meta_screen_get_size (screen, &width, &height);
+  XRenderComposite (xdisplay, PictOpSrc, info->root_tile, None, root_buffer,
+                    0, 0, 0, 0, 0, 0, width, height);
+}
+
+static gboolean
+window_has_shadow (MetaCompWindow *cw)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (cw->screen);
+
+  if (info == NULL || info->have_shadows == FALSE)
+    return FALSE;
+
+  /* Always put a shadow around windows with a frame - This should override
+     the restriction about not putting a shadow around shaped windows
+     as the frame might be the reason the window is shaped */
+  if (cw->window)
+    {
+      if (meta_window_get_frame (cw->window)) {
+        meta_verbose ("Window has shadow because it has a frame\n");
+        return TRUE;
+      }
+    }
+
+  /* Never put a shadow around shaped windows */
+  if (cw->shaped) {
+    meta_verbose ("Window has no shadow as it is shaped\n");
+    return FALSE;
+  }
+
+  /* Don't put shadow around DND icon windows */
+  if (cw->type == META_COMP_WINDOW_DND ||
+      cw->type == META_COMP_WINDOW_DESKTOP) {
+    meta_verbose ("Window has no shadow as it is DND or Desktop\n");
+    return FALSE;
+  }
+
+  if (cw->mode != WINDOW_ARGB) {
+    meta_verbose ("Window has shadow as it is not ARGB\n");
+    return TRUE;
+  }
+
+  if (cw->type == META_COMP_WINDOW_MENU ||
+      cw->type == META_COMP_WINDOW_DROP_DOWN_MENU) {
+    meta_verbose ("Window has shadow as it is a menu\n");
+    return TRUE;
+  }
+
+  if (cw->type == META_COMP_WINDOW_TOOLTIP) {
+    meta_verbose ("Window has shadow as it is a tooltip\n");
+    return TRUE;
+  }
+
+  meta_verbose ("Window has no shadow as it fell through\n");
+  return FALSE;
+}
+
+double shadow_offsets_x[LAST_SHADOW_TYPE] = {SHADOW_SMALL_OFFSET_X,
+                                             SHADOW_MEDIUM_OFFSET_X,
+                                             SHADOW_LARGE_OFFSET_X};
+double shadow_offsets_y[LAST_SHADOW_TYPE] = {SHADOW_SMALL_OFFSET_Y,
+                                             SHADOW_MEDIUM_OFFSET_Y,
+                                             SHADOW_LARGE_OFFSET_Y};
+static XserverRegion
+win_extents (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRectangle r;
+
+  r.x = cw->attrs.x;
+  r.y = cw->attrs.y;
+  r.width = cw->attrs.width + cw->attrs.border_width * 2;
+  r.height = cw->attrs.height + cw->attrs.border_width * 2;
+
+  if (cw->needs_shadow)
+    {
+      XRectangle sr;
+
+      cw->shadow_dx = shadow_offsets_x [cw->shadow_type];
+      cw->shadow_dy = shadow_offsets_y [cw->shadow_type];
+
+      if (!cw->shadow)
+        {
+          double opacity = SHADOW_OPACITY;
+          if (cw->opacity != (guint) OPAQUE)
+            opacity = opacity * ((double) cw->opacity) / ((double) OPAQUE);
+
+          cw->shadow = shadow_picture (display, screen, cw->shadow_type,
+                                       opacity, cw->alpha_pict,
+                                       cw->attrs.width + cw->attrs.border_width * 2,
+                                       cw->attrs.height + cw->attrs.border_width * 2,
+                                       &cw->shadow_width, &cw->shadow_height);
+        }
+
+      sr.x = cw->attrs.x + cw->shadow_dx;
+      sr.y = cw->attrs.y + cw->shadow_dy;
+      sr.width = cw->shadow_width;
+      sr.height = cw->shadow_height;
+
+      if (sr.x < r.x)
+        {
+          r.width = (r.x + r.width) - sr.x;
+          r.x = sr.x;
+        }
+
+      if (sr.y < r.y)
+        {
+          r.height = (r.y + r.height) - sr.y;
+          r.y = sr.y;
+        }
+
+      if (sr.x + sr.width > r.x + r.width)
+        r.width = sr.x + sr.width - r.x;
+
+      if (sr.y + sr.height > r.y + r.height)
+        r.height = sr.y + sr.height - r.y;
+    }
+
+  return XFixesCreateRegion (xdisplay, &r, 1);
+}
+
+static XserverRegion
+border_size (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion border;
+
+  meta_error_trap_push (display);
+  border = XFixesCreateRegionFromWindow (xdisplay, cw->id,
+                                         WindowRegionBounding);
+  meta_error_trap_pop (display, FALSE);
+
+  g_return_val_if_fail (border != None, None);
+  XFixesTranslateRegion (xdisplay, border,
+                         cw->attrs.x + cw->attrs.border_width,
+                         cw->attrs.y + cw->attrs.border_width);
+  return border;
+}
+
+static XRenderPictFormat *
+get_window_format (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictFormat *format;
+  int screen_number = meta_screen_get_screen_number (screen);
+
+  format = XRenderFindVisualFormat (xdisplay, cw->attrs.visual);
+  if (!format)
+    format = XRenderFindVisualFormat (xdisplay,
+                                      DefaultVisual (xdisplay, screen_number));
+  return format;
+}
+
+static Picture
+get_window_picture (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *format;
+  Drawable draw;
+
+  draw = cw->id;
+
+  meta_error_trap_push (display);
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (display))
+    {
+      if (cw->back_pixmap == None)
+        cw->back_pixmap = XCompositeNameWindowPixmap (xdisplay, cw->id);
+
+      if (cw->back_pixmap != None)
+        draw = cw->back_pixmap;
+    }
+#endif
+
+  format = get_window_format (cw);
+  if (format)
+    {
+      Picture pict;
+
+      pa.subwindow_mode = IncludeInferiors;
+
+      pict = XRenderCreatePicture (xdisplay, draw, format, CPSubwindowMode, &pa);
+      meta_error_trap_pop (display, FALSE);
+
+      return pict;
+    }
+
+  meta_error_trap_pop (display, FALSE);
+  return None;
+}
+
+static void
+paint_dock_shadows (MetaScreen   *screen,
+                    Picture       root_buffer,
+                    XserverRegion region)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  GSList *d;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  for (d = info->dock_windows; d; d = d->next)
+    {
+      MetaCompWindow *cw = d->data;
+      XserverRegion shadow_clip;
+
+      if (cw->shadow)
+        {
+          shadow_clip = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesIntersectRegion (xdisplay, shadow_clip,
+                                 cw->border_clip, region);
+
+          XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0, shadow_clip);
+
+          XRenderComposite (xdisplay, PictOpOver, info->black_picture,
+                            cw->shadow, root_buffer,
+                            0, 0, 0, 0,
+                            cw->attrs.x + cw->shadow_dx,
+                            cw->attrs.y + cw->shadow_dy,
+                            cw->shadow_width, cw->shadow_height);
+          XFixesDestroyRegion (xdisplay, shadow_clip);
+        }
+    }
+}
+
+static void
+paint_windows (MetaScreen   *screen,
+               GList        *windows,
+               Picture       root_buffer,
+               XserverRegion region)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  GList *index, *last;
+  int screen_width, screen_height, screen_number;
+  Window xroot;
+  MetaCompWindow *cw;
+  XserverRegion paint_region, desktop_region;
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+  screen_number = meta_screen_get_screen_number (screen);
+  xroot = meta_screen_get_xroot (screen);
+
+  if (region == None)
+    {
+      XRectangle r;
+      r.x = 0;
+      r.y = 0;
+      r.width = screen_width;
+      r.height = screen_height;
+      paint_region = XFixesCreateRegion (xdisplay, &r, 1);
+    }
+  else
+    {
+      paint_region = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, paint_region, region);
+    }
+
+  desktop_region = None;
+
+  /*
+   * Painting from top to bottom, reducing the clipping area at
+   * each iteration. Only the opaque windows are painted 1st.
+   */
+  last = NULL;
+  for (index = windows; index; index = index->next)
+    {
+      /* Store the last window we dealt with */
+      last = index;
+
+      cw = (MetaCompWindow *) index->data;
+      if (!cw->damaged)
+        {
+          /* Not damaged */
+          continue;
+        }
+
+#if 0
+      if ((cw->attrs.x + cw->attrs.width < 1) ||
+          (cw->attrs.y + cw->attrs.height < 1) ||
+          (cw->attrs.x >= screen_width) || (cw->attrs.y >= screen_height))
+        {
+          /* Off screen */
+          continue;
+        }
+#endif
+
+      if (cw->picture == None)
+        cw->picture = get_window_picture (cw);
+
+      /* If the clip region of the screen has been changed
+         then we need to recreate the extents of the window */
+      if (info->clip_changed)
+        {
+          if (cw->border_size)
+            {
+              XFixesDestroyRegion (xdisplay, cw->border_size);
+              cw->border_size = None;
+            }
+
+#if 0
+          if (cw->extents)
+            {
+              XFixesDestroyRegion (xdisplay, cw->extents);
+              cw->extents = None;
+            }
+#endif
+        }
+
+      if (cw->border_size == None)
+        cw->border_size = border_size (cw);
+
+      if (cw->extents == None)
+        cw->extents = win_extents (cw);
+
+      if (cw->mode == WINDOW_SOLID)
+        {
+          int x, y, wid, hei;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+          if (have_name_window_pixmap (display))
+            {
+              x = cw->attrs.x;
+              y = cw->attrs.y;
+              wid = cw->attrs.width + cw->attrs.border_width * 2;
+              hei = cw->attrs.height + cw->attrs.border_width * 2;
+            }
+          else
+#endif
+            {
+              x = cw->attrs.x + cw->attrs.border_width;
+              y = cw->attrs.y + cw->attrs.border_width;
+              wid = cw->attrs.width;
+              hei = cw->attrs.height;
+            }
+
+          XFixesSetPictureClipRegion (xdisplay, root_buffer,
+                                      0, 0, paint_region);
+          XRenderComposite (xdisplay, PictOpSrc, cw->picture,
+                            None, root_buffer, 0, 0, 0, 0,
+                            x, y, wid, hei);
+
+          if (cw->type == META_COMP_WINDOW_DESKTOP)
+            {
+              desktop_region = XFixesCreateRegion (xdisplay, 0, 0);
+              XFixesCopyRegion (xdisplay, desktop_region, paint_region);
+            }
+
+          XFixesSubtractRegion (xdisplay, paint_region,
+                                paint_region, cw->border_size);
+        }
+
+      if (!cw->border_clip)
+        {
+          cw->border_clip = XFixesCreateRegion (xdisplay, 0, 0);
+          XFixesCopyRegion (xdisplay, cw->border_clip, paint_region);
+        }
+    }
+
+  XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0, paint_region);
+  paint_root (screen, root_buffer);
+
+  paint_dock_shadows (screen, root_buffer, desktop_region == None ?
+                      paint_region : desktop_region);
+  if (desktop_region != None)
+    XFixesDestroyRegion (xdisplay, desktop_region);
+
+  /*
+   * Painting from bottom to top, translucent windows and shadows are painted
+   */
+  for (index = last; index; index = index->prev)
+    {
+      cw = (MetaCompWindow *) index->data;
+
+      if (cw->picture)
+        {
+          if (cw->shadow && cw->type != META_COMP_WINDOW_DOCK)
+            {
+              XserverRegion shadow_clip;
+
+              shadow_clip = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesSubtractRegion (xdisplay, shadow_clip, cw->border_clip,
+                                    cw->border_size);
+              XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0,
+                                          shadow_clip);
+
+              XRenderComposite (xdisplay, PictOpOver, info->black_picture,
+                                cw->shadow, root_buffer,
+                                0, 0, 0, 0,
+                                cw->attrs.x + cw->shadow_dx,
+                                cw->attrs.y + cw->shadow_dy,
+                                cw->shadow_width, cw->shadow_height);
+              if (shadow_clip)
+                XFixesDestroyRegion (xdisplay, shadow_clip);
+            }
+
+          if ((cw->opacity != (guint) OPAQUE) && !(cw->alpha_pict))
+            {
+              cw->alpha_pict = solid_picture (display, screen, FALSE,
+                                              (double) cw->opacity / OPAQUE,
+                                              0, 0, 0);
+            }
+
+          XFixesIntersectRegion (xdisplay, cw->border_clip, cw->border_clip,
+                                 cw->border_size);
+          XFixesSetPictureClipRegion (xdisplay, root_buffer, 0, 0,
+                                      cw->border_clip);
+          if (cw->mode == WINDOW_ARGB)
+            {
+              int x, y, wid, hei;
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+              if (have_name_window_pixmap (display))
+                {
+                  x = cw->attrs.x;
+                  y = cw->attrs.y;
+                  wid = cw->attrs.width + cw->attrs.border_width * 2;
+                  hei = cw->attrs.height + cw->attrs.border_width * 2;
+                }
+              else
+#endif
+                {
+                  x = cw->attrs.x + cw->attrs.border_width;
+                  y = cw->attrs.y + cw->attrs.border_width;
+                  wid = cw->attrs.width;
+                  hei = cw->attrs.height;
+                }
+
+              XRenderComposite (xdisplay, PictOpOver, cw->picture,
+                                cw->alpha_pict, root_buffer, 0, 0, 0, 0,
+                                x, y, wid, hei);
+            }
+        }
+
+      if (cw->border_clip)
+        {
+          XFixesDestroyRegion (xdisplay, cw->border_clip);
+          cw->border_clip = None;
+        }
+    }
+
+  XFixesDestroyRegion (xdisplay, paint_region);
+}
+
+static void
+paint_all (MetaScreen   *screen,
+           XserverRegion region)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int screen_width, screen_height;
+
+  /* Set clipping to the given region */
+  XFixesSetPictureClipRegion (xdisplay, info->root_picture, 0, 0, region);
+
+  meta_screen_get_size (screen, &screen_width, &screen_height);
+
+  if (DISPLAY_COMPOSITOR (display)->show_redraw)
+    {
+      Picture overlay;
+
+      dump_xserver_region ("paint_all", display, region);
+
+      /* Make a random colour overlay */
+      overlay = solid_picture (display, screen, TRUE, 1, /* 0.3, alpha */
+                               ((double) (rand () % 100)) / 100.0,
+                               ((double) (rand () % 100)) / 100.0,
+                               ((double) (rand () % 100)) / 100.0);
+
+      XRenderComposite (xdisplay, PictOpOver, overlay, None, info->root_picture,
+                        0, 0, 0, 0, 0, 0, screen_width, screen_height);
+      XRenderFreePicture (xdisplay, overlay);
+      XFlush (xdisplay);
+      usleep (100 * 1000);
+    }
+
+  if (info->root_buffer == None)
+    info->root_buffer = create_root_buffer (screen);
+
+  paint_windows (screen, info->windows, info->root_buffer, region);
+
+  XFixesSetPictureClipRegion (xdisplay, info->root_buffer, 0, 0, region);
+  XRenderComposite (xdisplay, PictOpSrc, info->root_buffer, None,
+                    info->root_picture, 0, 0, 0, 0, 0, 0,
+                    screen_width, screen_height);
+}
+
+static void
+repair_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (info!=NULL && info->all_damage != None)
+    {
+      meta_error_trap_push (display);
+      paint_all (screen, info->all_damage);
+      XFixesDestroyRegion (xdisplay, info->all_damage);
+      info->all_damage = None;
+      info->clip_changed = FALSE;
+      meta_error_trap_pop (display, FALSE);
+    }
+}
+
+static void
+repair_display (MetaDisplay *display)
+{
+  GSList *screens = meta_display_get_screens (display);
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+
+#ifdef USE_IDLE_REPAINT
+  if (compositor->repaint_id > 0)
+    {
+      g_source_remove (compositor->repaint_id);
+      compositor->repaint_id = 0;
+    }
+#endif
+
+  for (; screens; screens = screens->next)
+    repair_screen ((MetaScreen *) screens->data);
+}
+
+#ifdef USE_IDLE_REPAINT
+static gboolean
+compositor_idle_cb (gpointer data)
+{
+  MetaCompositorXRender *compositor = (MetaCompositorXRender *) data;
+
+  compositor->repaint_id = 0;
+  repair_display (compositor->display);
+
+  return FALSE;
+}
+
+static void
+add_repair (MetaDisplay *display)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+
+  if (compositor->repaint_id > 0)
+    return;
+
+#if 1
+  compositor->repaint_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+                                            compositor_idle_cb, compositor,
+                                            NULL);
+#else
+  /* Limit it to 50fps */
+  compositor->repaint_id = g_timeout_add_full (G_PRIORITY_HIGH, 20,
+                                               compositor_idle_cb, compositor,
+                                               NULL);
+#endif
+}
+#endif
+
+static void
+add_damage (MetaScreen     *screen,
+            XserverRegion   damage)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  /*  dump_xserver_region ("add_damage", display, damage); */
+
+  if (info != NULL && info->all_damage)
+    {
+      XFixesUnionRegion (xdisplay, info->all_damage, info->all_damage, damage);
+      XFixesDestroyRegion (xdisplay, damage);
+    }
+  else
+    info->all_damage = damage;
+
+#ifdef USE_IDLE_REPAINT
+  add_repair (display);
+#endif
+}
+
+static void
+damage_screen (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+  int width, height;
+  XRectangle r;
+
+  r.x = 0;
+  r.y = 0;
+  meta_screen_get_size (screen, &width, &height);
+  r.width = width;
+  r.height = height;
+
+  region = XFixesCreateRegion (xdisplay, &r, 1);
+  dump_xserver_region ("damage_screen", display, region);
+  add_damage (screen, region);
+}
+
+static void
+repair_win (MetaCompWindow *cw)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion parts;
+
+  meta_error_trap_push (display);
+  if (!cw->damaged)
+    {
+      parts = win_extents (cw);
+      XDamageSubtract (xdisplay, cw->damage, None, None);
+    }
+  else
+    {
+      parts = XFixesCreateRegion (xdisplay, 0, 0);
+      XDamageSubtract (xdisplay, cw->damage, None, parts);
+      XFixesTranslateRegion (xdisplay, parts,
+                             cw->attrs.x + cw->attrs.border_width,
+                             cw->attrs.y + cw->attrs.border_width);
+    }
+
+  meta_error_trap_pop (display, FALSE);
+
+  dump_xserver_region ("repair_win", display, parts);
+  add_damage (screen, parts);
+  cw->damaged = TRUE;
+}
+
+static void
+free_win (MetaCompWindow *cw,
+          gboolean        destroy)
+{
+  MetaDisplay *display = meta_screen_get_display (cw->screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (cw->screen);
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (display))
+    {
+      /* See comment in map_win */
+      if (cw->back_pixmap && destroy)
+        {
+          XFreePixmap (xdisplay, cw->back_pixmap);
+          cw->back_pixmap = None;
+        }
+
+      if (cw->shaded_back_pixmap && destroy)
+        {
+          XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+          cw->shaded_back_pixmap = None;
+        }
+    }
+#endif
+
+  if (cw->picture)
+    {
+      XRenderFreePicture (xdisplay, cw->picture);
+      cw->picture = None;
+    }
+
+  if (cw->shadow)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow);
+      cw->shadow = None;
+    }
+
+  if (cw->alpha_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->alpha_pict);
+      cw->alpha_pict = None;
+    }
+
+  if (cw->shadow_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow_pict);
+      cw->shadow_pict = None;
+    }
+
+  if (cw->border_size)
+    {
+      XFixesDestroyRegion (xdisplay, cw->border_size);
+      cw->border_size = None;
+    }
+
+  if (cw->border_clip)
+    {
+      XFixesDestroyRegion (xdisplay, cw->border_clip);
+      cw->border_clip = None;
+    }
+
+  if (cw->extents)
+    {
+      XFixesDestroyRegion (xdisplay, cw->extents);
+      cw->extents = None;
+    }
+
+  if (destroy)
+    {
+      if (cw->damage != None) {
+        meta_error_trap_push (display);
+        XDamageDestroy (xdisplay, cw->damage);
+        meta_error_trap_pop (display, FALSE);
+
+        cw->damage = None;
+      }
+
+      /* The window may not have been added to the list in this case,
+         but we can check anyway */
+      if (info!=NULL && cw->type == META_COMP_WINDOW_DOCK)
+        info->dock_windows = g_slist_remove (info->dock_windows, cw);
+
+      g_free (cw);
+    }
+}
+
+static void
+map_win (MetaDisplay *display,
+         MetaScreen  *screen,
+         Window       id)
+{
+  MetaCompWindow *cw = find_window_for_screen (screen, id);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (cw == NULL)
+    return;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  /* The reason we deallocate this here and not in unmap
+     is so that we will still have a valid pixmap for
+     whenever the window is unmapped */
+  if (cw->back_pixmap)
+    {
+      XFreePixmap (xdisplay, cw->back_pixmap);
+      cw->back_pixmap = None;
+    }
+
+  if (cw->shaded_back_pixmap)
+    {
+      XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+      cw->shaded_back_pixmap = None;
+    }
+#endif
+
+  cw->attrs.map_state = IsViewable;
+  cw->damaged = FALSE;
+}
+
+static void
+unmap_win (MetaDisplay *display,
+           MetaScreen  *screen,
+           Window       id)
+{
+  MetaCompWindow *cw = find_window_for_screen (screen, id);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  if (cw == NULL || info == NULL)
+    {
+      return;
+    }
+
+  if (cw->window && cw->window == info->focus_window)
+    info->focus_window = NULL;
+
+  cw->attrs.map_state = IsUnmapped;
+  cw->damaged = FALSE;
+
+  if (cw->extents != None)
+    {
+      dump_xserver_region ("unmap_win", display, cw->extents);
+      add_damage (screen, cw->extents);
+      cw->extents = None;
+    }
+
+  free_win (cw, FALSE);
+  info->clip_changed = TRUE;
+}
+
+static void
+determine_mode (MetaDisplay    *display,
+                MetaScreen     *screen,
+                MetaCompWindow *cw)
+{
+  XRenderPictFormat *format;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  if (cw->alpha_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->alpha_pict);
+      cw->alpha_pict = None;
+    }
+
+  if (cw->shadow_pict)
+    {
+      XRenderFreePicture (xdisplay, cw->shadow_pict);
+      cw->shadow_pict = None;
+    }
+
+  if (cw->attrs.class == InputOnly)
+    format = NULL;
+  else
+    format = XRenderFindVisualFormat (xdisplay, cw->attrs.visual);
+
+  if ((format && format->type == PictTypeDirect && format->direct.alphaMask)
+      || cw->opacity != (guint) OPAQUE)
+    cw->mode = WINDOW_ARGB;
+  else
+    cw->mode = WINDOW_SOLID;
+
+  if (cw->extents)
+    {
+      XserverRegion damage;
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+
+      dump_xserver_region ("determine_mode", display, damage);
+      add_damage (screen, damage);
+    }
+}
+
+static gboolean
+is_shaped (MetaDisplay *display,
+           Window       xwindow)
+{
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  int xws, yws, xbs, ybs;
+  unsigned wws, hws, wbs, hbs;
+  int bounding_shaped, clip_shaped;
+
+  if (meta_display_has_shape (display))
+    {
+      XShapeQueryExtents (xdisplay, xwindow, &bounding_shaped,
+                          &xws, &yws, &wws, &hws, &clip_shaped,
+                          &xbs, &ybs, &wbs, &hbs);
+      return (bounding_shaped != 0);
+    }
+
+  return FALSE;
+}
+
+static void
+get_window_type (MetaDisplay    *display,
+                 MetaCompWindow *cw)
+{
+  MetaCompositorXRender *compositor = DISPLAY_COMPOSITOR (display);
+  int n_atoms;
+  Atom *atoms, type_atom;
+  int i;
+
+  type_atom = None;
+  n_atoms = 0;
+  atoms = NULL;
+
+  meta_prop_get_atom_list (display, cw->id,
+                           compositor->atom_net_wm_window_type,
+                           &atoms, &n_atoms);
+
+  for (i = 0; i < n_atoms; i++)
+    {
+      if (atoms[i] == compositor->atom_net_wm_window_type_dnd ||
+          atoms[i] == compositor->atom_net_wm_window_type_desktop ||
+          atoms[i] == compositor->atom_net_wm_window_type_dock ||
+          atoms[i] == compositor->atom_net_wm_window_type_toolbar ||
+          atoms[i] == compositor->atom_net_wm_window_type_menu ||
+          atoms[i] == compositor->atom_net_wm_window_type_dialog ||
+          atoms[i] == compositor->atom_net_wm_window_type_normal ||
+          atoms[i] == compositor->atom_net_wm_window_type_utility ||
+          atoms[i] == compositor->atom_net_wm_window_type_splash ||
+          atoms[i] == compositor->atom_net_wm_window_type_dropdown_menu ||
+          atoms[i] == compositor->atom_net_wm_window_type_tooltip)
+        {
+          type_atom = atoms[i];
+          break;
+        }
+    }
+
+  meta_XFree (atoms);
+
+  if (type_atom == compositor->atom_net_wm_window_type_dnd)
+    cw->type = META_COMP_WINDOW_DND;
+  else if (type_atom == compositor->atom_net_wm_window_type_desktop)
+    cw->type = META_COMP_WINDOW_DESKTOP;
+  else if (type_atom == compositor->atom_net_wm_window_type_dock)
+    cw->type = META_COMP_WINDOW_DOCK;
+  else if (type_atom == compositor->atom_net_wm_window_type_menu)
+    cw->type = META_COMP_WINDOW_MENU;
+  else if (type_atom == compositor->atom_net_wm_window_type_dropdown_menu)
+    cw->type = META_COMP_WINDOW_DROP_DOWN_MENU;
+  else if (type_atom == compositor->atom_net_wm_window_type_tooltip)
+    cw->type = META_COMP_WINDOW_TOOLTIP;
+  else
+    cw->type = META_COMP_WINDOW_NORMAL;
+
+/*   meta_verbose ("Window is %d\n", cw->type); */
+}
+
+/* Must be called with an error trap in place */
+static void
+add_win (MetaScreen *screen,
+         MetaWindow *window,
+         Window     xwindow)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  MetaCompWindow *cw;
+  gulong event_mask;
+
+  if (info == NULL)
+    return;
+
+  if (xwindow == info->output)
+    return;
+
+  cw = g_new0 (MetaCompWindow, 1);
+  cw->screen = screen;
+  cw->window = window;
+  cw->id = xwindow;
+
+  if (!XGetWindowAttributes (xdisplay, xwindow, &cw->attrs))
+    {
+      g_free (cw);
+      return;
+    }
+  get_window_type (display, cw);
+
+  /* If Marco has decided not to manage this window then the input events
+     won't have been set on the window */
+  event_mask = cw->attrs.your_event_mask | PropertyChangeMask;
+
+  XSelectInput (xdisplay, xwindow, event_mask);
+
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  cw->back_pixmap = None;
+  cw->shaded_back_pixmap = None;
+#endif
+
+  cw->damaged = FALSE;
+  cw->shaped = is_shaped (display, xwindow);
+
+  if (cw->attrs.class == InputOnly)
+    cw->damage = None;
+  else
+    cw->damage = XDamageCreate (xdisplay, xwindow, XDamageReportNonEmpty);
+
+  cw->alpha_pict = None;
+  cw->shadow_pict = None;
+  cw->border_size = None;
+  cw->extents = None;
+  cw->shadow = None;
+  cw->shadow_dx = 0;
+  cw->shadow_dy = 0;
+  cw->shadow_width = 0;
+  cw->shadow_height = 0;
+
+  if (window && meta_window_has_focus (window))
+    cw->shadow_type = META_SHADOW_LARGE;
+  else
+    cw->shadow_type = META_SHADOW_MEDIUM;
+
+  cw->opacity = OPAQUE;
+
+  cw->border_clip = None;
+
+  determine_mode (display, screen, cw);
+  cw->needs_shadow = window_has_shadow (cw);
+
+  /* Only add the window to the list of docks if it needs a shadow */
+  if (cw->type == META_COMP_WINDOW_DOCK && cw->needs_shadow)
+    {
+      meta_verbose ("Appending %p to dock windows\n", cw);
+      info->dock_windows = g_slist_append (info->dock_windows, cw);
+    }
+
+  /* Add this to the list at the top of the stack
+     before it is mapped so that map_win can find it again */
+  info->windows = g_list_prepend (info->windows, cw);
+  g_hash_table_insert (info->windows_by_xid, (gpointer) xwindow, cw);
+
+  if (cw->attrs.map_state == IsViewable)
+    map_win (display, screen, xwindow);
+}
+
+static void
+destroy_win (MetaDisplay *display,
+             Window       xwindow,
+             gboolean     gone)
+{
+  MetaScreen *screen;
+  MetaCompScreen *info;
+  MetaCompWindow *cw;
+
+  cw = find_window_in_display (display, xwindow);
+
+  if (cw == NULL)
+    return;
+
+  screen = cw->screen;
+
+  if (cw->extents != None)
+    {
+      dump_xserver_region ("destroy_win", display, cw->extents);
+      add_damage (screen, cw->extents);
+      cw->extents = None;
+    }
+
+  info = meta_screen_get_compositor_data (screen);
+  if (info != NULL)
+    {
+      info->windows = g_list_remove (info->windows, (gconstpointer) cw);
+      g_hash_table_remove (info->windows_by_xid, (gpointer) xwindow);
+    }
+
+  free_win (cw, TRUE);
+}
+
+static void
+restack_win (MetaCompWindow *cw,
+             Window          above)
+{
+  MetaScreen *screen;
+  MetaCompScreen *info;
+  Window previous_above;
+  GList *sibling, *next;
+
+  screen = cw->screen;
+  info = meta_screen_get_compositor_data (screen);
+
+  if (info == NULL)
+    {
+      return;
+    }
+
+  sibling = g_list_find (info->windows, (gconstpointer) cw);
+  next = g_list_next (sibling);
+  previous_above = None;
+
+  if (next)
+    {
+      MetaCompWindow *ncw = (MetaCompWindow *) next->data;
+      previous_above = ncw->id;
+    }
+
+  /* If above is set to None, the window whose state was changed is on
+   * the bottom of the stack with respect to sibling.
+   */
+  if (above == None)
+    {
+      /* Insert at bottom of window stack */
+      info->windows = g_list_delete_link (info->windows, sibling);
+      info->windows = g_list_append (info->windows, cw);
+    }
+  else if (previous_above != above)
+    {
+      GList *index;
+
+      for (index = info->windows; index; index = index->next) {
+        MetaCompWindow *cw2 = (MetaCompWindow *) index->data;
+        if (cw2->id == above)
+          break;
+      }
+
+      if (index != NULL)
+        {
+          info->windows = g_list_delete_link (info->windows, sibling);
+          info->windows = g_list_insert_before (info->windows, index, cw);
+        }
+    }
+}
+
+static void
+resize_win (MetaCompWindow *cw,
+            int             x,
+            int             y,
+            int             width,
+            int             height,
+            int             border_width,
+            gboolean        override_redirect)
+{
+  MetaScreen *screen = cw->screen;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  XserverRegion damage;
+  gboolean debug;
+
+  debug = DISPLAY_COMPOSITOR (display)->debug;
+
+  if (cw->extents)
+    {
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+    }
+  else
+    {
+      damage = None;
+      if (debug)
+        fprintf (stderr, "no extents to damage !\n");
+    }
+
+  /*  { // Damage whole screen each time ! ;-)
+    XRectangle r;
+
+    r.x = 0;
+    r.y = 0;
+    meta_screen_get_size (screen, &r.width, &r.height);
+    fprintf (stderr, "Damage whole screen %d,%d (%d %d)\n",
+             r.x, r.y, r.width, r.height);
+
+    damage = XFixesCreateRegion (xdisplay, &r, 1);
+    } */
+
+  cw->attrs.x = x;
+  cw->attrs.y = y;
+
+  if (cw->attrs.width != width || cw->attrs.height != height)
+    {
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+      if (have_name_window_pixmap (display))
+        {
+          if (cw->shaded_back_pixmap)
+            {
+              XFreePixmap (xdisplay, cw->shaded_back_pixmap);
+              cw->shaded_back_pixmap = None;
+            }
+
+          if (cw->back_pixmap)
+            {
+              /* If the window is shaded, we store the old backing pixmap
+                 so we can return a proper image of the window */
+              if (cw->window && meta_window_is_shaded (cw->window))
+                {
+                  cw->shaded_back_pixmap = cw->back_pixmap;
+                  cw->back_pixmap = None;
+                }
+              else
+                {
+                  XFreePixmap (xdisplay, cw->back_pixmap);
+                  cw->back_pixmap = None;
+                }
+            }
+        }
+#endif
+      if (cw->picture)
+        {
+          XRenderFreePicture (xdisplay, cw->picture);
+          cw->picture = None;
+        }
+
+      if (cw->shadow)
+        {
+          XRenderFreePicture (xdisplay, cw->shadow);
+          cw->shadow = None;
+        }
+    }
+
+  cw->attrs.width = width;
+  cw->attrs.height = height;
+  cw->attrs.border_width = border_width;
+  cw->attrs.override_redirect = override_redirect;
+
+  if (cw->extents)
+    XFixesDestroyRegion (xdisplay, cw->extents);
+
+  cw->extents = win_extents (cw);
+
+  if (damage)
+    {
+      if (debug)
+        fprintf (stderr, "Inexplicable intersection with new extents!\n");
+
+      XFixesUnionRegion (xdisplay, damage, damage, cw->extents);
+    }
+  else
+    {
+      damage = XFixesCreateRegion (xdisplay, NULL, 0);
+      XFixesCopyRegion (xdisplay, damage, cw->extents);
+    }
+
+  dump_xserver_region ("resize_win", display, damage);
+  add_damage (screen, damage);
+
+  if (info != NULL)
+    {
+      info->clip_changed = TRUE;
+    }
+}
+
+/* event processors must all be called with an error trap in place */
+static void
+process_circulate_notify (MetaCompositorXRender  *compositor,
+                          XCirculateEvent        *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+  MetaCompWindow *top;
+  MetaCompScreen *info;
+  MetaScreen *screen;
+  GList *first;
+  Window above;
+
+  if (!cw)
+    return;
+
+  screen = cw->screen;
+  info = meta_screen_get_compositor_data (screen);
+  first = info->windows;
+  top = (MetaCompWindow *) first->data;
+
+  if ((event->place == PlaceOnTop) && top)
+    above = top->id;
+  else
+    above = None;
+  restack_win (cw, above);
+
+  if (info != NULL)
+    {
+      info->clip_changed = TRUE;
+    }
+
+#ifdef USE_IDLE_REPAINT
+  add_repair (compositor->display);
+#endif
+}
+
+static void
+process_configure_notify (MetaCompositorXRender  *compositor,
+                          XConfigureEvent        *event)
+{
+  MetaDisplay *display = compositor->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompWindow *cw = find_window_in_display (display, event->window);
+
+  if (cw)
+    {
+#if 0
+      int x = -1, y = -1, width = -1, height = -1;
+      int ex = -1, ey = -1, ewidth = -1, eheight = -1;
+      MetaRectangle *rect;
+
+      if (cw->window) {
+        rect = meta_window_get_rect (cw->window);
+        x = rect->x;
+        y = rect->y;
+        width = rect->width;
+        height = rect->height;
+      }
+      fprintf (stderr, "configure notify xy (%d %d) -> (%d %d), wh (%d %d) -> (%d %d)\n",
+               x, y, event->x, event->y,
+               width, height, event->width, event->height);
+#endif
+
+      if (compositor->debug)
+        {
+          fprintf (stderr, "configure notify %d %d %d\n", cw->damaged,
+                   cw->shaped, cw->needs_shadow);
+          dump_xserver_region ("\textents", display, cw->extents);
+          fprintf (stderr, "\txy (%d %d), wh (%d %d)\n",
+                   event->x, event->y, event->width, event->height);
+        }
+
+      restack_win (cw, event->above);
+      resize_win (cw, event->x, event->y, event->width, event->height,
+                  event->border_width, event->override_redirect);
+    }
+  else
+    {
+      MetaScreen *screen;
+      MetaCompScreen *info;
+
+      /* Might be the root window? */
+      screen = meta_display_screen_for_root (display, event->window);
+      if (screen == NULL)
+        return;
+
+      info = meta_screen_get_compositor_data (screen);
+      if (info != NULL && info->root_buffer)
+        {
+          XRenderFreePicture (xdisplay, info->root_buffer);
+          info->root_buffer = None;
+        }
+
+      damage_screen (screen);
+    }
+}
+
+static void
+process_property_notify (MetaCompositorXRender *compositor,
+                         XPropertyEvent        *event)
+{
+  MetaDisplay *display = compositor->display;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaScreen *screen;
+  int p;
+  Atom background_atoms[2];
+
+  /* Check for the background property changing */
+  background_atoms[0] = compositor->atom_x_root_pixmap;
+  background_atoms[1] = compositor->atom_x_set_root;
+
+  for (p = 0; p < 2; p++)
+    {
+      if (event->atom == background_atoms[p])
+        {
+          screen = meta_display_screen_for_root (display, event->window);
+          if (screen)
+            {
+              MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+              Window xroot = meta_screen_get_xroot (screen);
+
+              if (info != NULL && info->root_tile)
+                {
+                  XClearArea (xdisplay, xroot, 0, 0, 0, 0, TRUE);
+                  XRenderFreePicture (xdisplay, info->root_tile);
+                  info->root_tile = None;
+
+                  /* Damage the whole screen as we may need to redraw the
+                     background ourselves */
+                  damage_screen (screen);
+#ifdef USE_IDLE_REPAINT
+                  add_repair (display);
+#endif
+
+                  return;
+                }
+            }
+        }
+    }
+
+  /* Check for the opacity changing */
+  if (event->atom == compositor->atom_net_wm_window_opacity)
+    {
+      MetaCompWindow *cw = find_window_in_display (display, event->window);
+      gulong value;
+
+      if (!cw)
+        {
+          /* Applications can set this for their toplevel windows, so
+           * this must be propagated to the window managed by the compositor
+           */
+          cw = find_window_for_child_window_in_display (display, event->window);
+        }
+
+      if (!cw)
+        return;
+
+      if (meta_prop_get_cardinal (display, event->window,
+                                  compositor->atom_net_wm_window_opacity,
+                                  &value) == FALSE)
+        value = OPAQUE;
+
+      cw->opacity = (guint)value;
+      determine_mode (display, cw->screen, cw);
+      cw->needs_shadow = window_has_shadow (cw);
+
+      if (cw->shadow)
+        {
+          XRenderFreePicture (xdisplay, cw->shadow);
+          cw->shadow = None;
+        }
+
+      if (cw->extents)
+        XFixesDestroyRegion (xdisplay, cw->extents);
+      cw->extents = win_extents (cw);
+
+      cw->damaged = TRUE;
+#ifdef USE_IDLE_REPAINT
+      add_repair (display);
+#endif
+
+      return;
+    }
+
+  if (event->atom == compositor->atom_net_wm_window_type) {
+    MetaCompWindow *cw = find_window_in_display (display, event->window);
+
+    if (!cw)
+      return;
+
+    get_window_type (display, cw);
+    cw->needs_shadow = window_has_shadow (cw);
+    return;
+  }
+}
+
+static void
+expose_area (MetaScreen *screen,
+             XRectangle *rects,
+             int         nrects)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+
+  region = XFixesCreateRegion (xdisplay, rects, nrects);
+
+  dump_xserver_region ("expose_area", display, region);
+  add_damage (screen, region);
+}
+
+static void
+process_expose (MetaCompositorXRender *compositor,
+                XExposeEvent          *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+  MetaScreen *screen = NULL;
+  XRectangle rect[1];
+  int origin_x = 0, origin_y = 0;
+
+  if (cw != NULL)
+    {
+      screen = cw->screen;
+      origin_x = cw->attrs.x; /* + cw->attrs.border_width; ? */
+      origin_y = cw->attrs.y; /* + cw->attrs.border_width; ? */
+    }
+  else
+    {
+      screen = meta_display_screen_for_root (compositor->display,
+                                             event->window);
+      if (screen == NULL)
+        return;
+    }
+
+  rect[0].x = event->x + origin_x;
+  rect[0].y = event->y + origin_y;
+  rect[0].width = event->width;
+  rect[0].height = event->height;
+
+  expose_area (screen, rect, 1);
+}
+
+static void
+process_unmap (MetaCompositorXRender *compositor,
+               XUnmapEvent           *event)
+{
+  MetaCompWindow *cw;
+
+  if (event->from_configure)
+    {
+      /* Ignore unmap caused by parent's resize */
+      return;
+    }
+
+
+  cw = find_window_in_display (compositor->display, event->window);
+  if (cw)
+    unmap_win (compositor->display, cw->screen, event->window);
+}
+
+static void
+process_map (MetaCompositorXRender *compositor,
+             XMapEvent             *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+
+  if (cw)
+    map_win (compositor->display, cw->screen, event->window);
+}
+
+static void
+process_reparent (MetaCompositorXRender *compositor,
+                  XReparentEvent        *event,
+                  MetaWindow            *window)
+{
+  MetaScreen *screen;
+
+  screen = meta_display_screen_for_root (compositor->display, event->parent);
+  if (screen != NULL)
+    add_win (screen, window, event->window);
+  else
+    destroy_win (compositor->display, event->window, FALSE);
+}
+
+static void
+process_create (MetaCompositorXRender *compositor,
+                XCreateWindowEvent    *event,
+                MetaWindow            *window)
+{
+  MetaScreen *screen;
+  /* We are only interested in top level windows, others will
+     be caught by normal marco functions */
+
+  screen = meta_display_screen_for_root (compositor->display, event->parent);
+  if (screen == NULL)
+    return;
+
+  if (!find_window_in_display (compositor->display, event->window))
+    add_win (screen, window, event->window);
+}
+
+static void
+process_destroy (MetaCompositorXRender *compositor,
+                 XDestroyWindowEvent   *event)
+{
+  destroy_win (compositor->display, event->window, FALSE);
+}
+
+static void
+process_damage (MetaCompositorXRender *compositor,
+                XDamageNotifyEvent    *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->drawable);
+  if (cw == NULL)
+    return;
+
+  repair_win (cw);
+
+#ifdef USE_IDLE_REPAINT
+  if (event->more == FALSE)
+    add_repair (compositor->display);
+#endif
+}
+
+static void
+process_shape (MetaCompositorXRender *compositor,
+               XShapeEvent           *event)
+{
+  MetaCompWindow *cw = find_window_in_display (compositor->display,
+                                               event->window);
+
+  if (cw == NULL)
+    return;
+
+  if (event->kind == ShapeBounding)
+    {
+      if (!event->shaped && cw->shaped)
+        cw->shaped = FALSE;
+
+      resize_win (cw, cw->attrs.x, cw->attrs.y,
+                  event->width + event->x, event->height + event->y,
+                  cw->attrs.border_width, cw->attrs.override_redirect);
+
+      if (event->shaped && !cw->shaped)
+        cw->shaped = TRUE;
+    }
+}
+
+static int
+timeout_debug (MetaCompositorXRender *compositor)
+{
+  compositor->show_redraw = (g_getenv ("MARCO_DEBUG_REDRAWS") != NULL);
+  compositor->debug = (g_getenv ("MARCO_DEBUG_COMPOSITOR") != NULL);
+
+  return FALSE;
+}
+
+static void
+xrender_add_window (MetaCompositor    *compositor,
+                    MetaWindow        *window,
+                    Window             xwindow,
+                    XWindowAttributes *attrs)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  MetaScreen *screen = meta_screen_for_x_screen (attrs->screen);
+
+  meta_error_trap_push (xrc->display);
+  add_win (screen, window, xwindow);
+  meta_error_trap_pop (xrc->display, FALSE);
+#endif
+}
+
+static void
+xrender_remove_window (MetaCompositor *compositor,
+                       Window          xwindow)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+show_overlay_window (MetaScreen *screen,
+                     Window      cow)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+#ifdef HAVE_COW
+  if (have_cow (display))
+    {
+      XserverRegion region;
+
+      region = XFixesCreateRegion (xdisplay, NULL, 0);
+
+      XFixesSetWindowShapeRegion (xdisplay, cow, ShapeBounding, 0, 0, 0);
+      XFixesSetWindowShapeRegion (xdisplay, cow, ShapeInput, 0, 0, region);
+
+      XFixesDestroyRegion (xdisplay, region);
+
+      damage_screen (screen);
+    }
+#endif
+}
+
+static void
+hide_overlay_window (MetaScreen *screen,
+                     Window      cow)
+{
+#ifdef HAVE_COW
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XserverRegion region;
+
+  region = XFixesCreateRegion (xdisplay, NULL, 0);
+  XFixesSetWindowShapeRegion (xdisplay, cow, ShapeBounding, 0, 0, region);
+  XFixesDestroyRegion (xdisplay, region);
+#endif
+}
+
+static Window
+get_output_window (MetaScreen *screen)
+{
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  Window output, xroot;
+
+  xroot = meta_screen_get_xroot (screen);
+
+#ifdef HAVE_COW
+  if (have_cow (display))
+    {
+      output = XCompositeGetOverlayWindow (xdisplay, xroot);
+      XSelectInput (xdisplay, output, ExposureMask);
+    }
+  else
+#endif
+    {
+      output = xroot;
+    }
+
+  return output;
+}
+
+static void
+xrender_manage_screen (MetaCompositor *compositor,
+                       MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompScreen *info;
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  XRenderPictureAttributes pa;
+  XRenderPictFormat *visual_format;
+  int screen_number = meta_screen_get_screen_number (screen);
+  Window xroot = meta_screen_get_xroot (screen);
+
+  /* Check if the screen is already managed */
+  if (meta_screen_get_compositor_data (screen))
+    return;
+
+  gdk_error_trap_push ();
+  XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
+  XSync (xdisplay, FALSE);
+
+  if (gdk_error_trap_pop ())
+    {
+      g_warning ("Another compositing manager is running on screen %i",
+                 screen_number);
+      return;
+    }
+
+  info = g_new0 (MetaCompScreen, 1);
+  info->screen = screen;
+
+  meta_screen_set_compositor_data (screen, info);
+
+  visual_format = XRenderFindVisualFormat (xdisplay, DefaultVisual (xdisplay,
+                                                                    screen_number));
+  if (!visual_format)
+    {
+      g_warning ("Cannot find visual format on screen %i", screen_number);
+      return;
+    }
+
+  info->output = get_output_window (screen);
+
+  pa.subwindow_mode = IncludeInferiors;
+  info->root_picture = XRenderCreatePicture (xdisplay, info->output,
+                                             visual_format,
+                                             CPSubwindowMode, &pa);
+  if (info->root_picture == None)
+    {
+      g_warning ("Cannot create root picture on screen %i", screen_number);
+      return;
+    }
+
+  info->root_buffer = None;
+  info->black_picture = solid_picture (display, screen, TRUE, 1, 0, 0, 0);
+
+  info->root_tile = None;
+  info->all_damage = None;
+
+  info->windows = NULL;
+  info->windows_by_xid = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+  info->focus_window = meta_display_get_focus_window (display);
+
+  info->compositor_active = TRUE;
+  info->overlays = 0;
+  info->clip_changed = TRUE;
+
+  info->have_shadows = (g_getenv("META_DEBUG_NO_SHADOW") == NULL);
+  if (info->have_shadows)
+    {
+      meta_verbose ("Enabling shadows\n");
+      generate_shadows (info);
+    }
+  else
+    meta_verbose ("Disabling shadows\n");
+
+  XClearArea (xdisplay, info->output, 0, 0, 0, 0, TRUE);
+
+  meta_screen_set_cm_selection (screen);
+
+  /* Now we're up and running we can show the output if needed */
+  show_overlay_window (screen, info->output);
+#endif
+}
+
+static void
+xrender_unmanage_screen (MetaCompositor *compositor,
+                         MetaScreen     *screen)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaDisplay *display = meta_screen_get_display (screen);
+  Display *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen *info;
+  Window xroot = meta_screen_get_xroot (screen);
+  GList *index;
+
+  info = meta_screen_get_compositor_data (screen);
+
+  /* This screen isn't managed */
+  if (info == NULL)
+    return;
+
+  hide_overlay_window (screen, info->output);
+
+  /* Destroy the windows */
+  for (index = info->windows; index; index = index->next)
+    {
+      MetaCompWindow *cw = (MetaCompWindow *) index->data;
+      free_win (cw, TRUE);
+    }
+  g_list_free (info->windows);
+  g_hash_table_destroy (info->windows_by_xid);
+
+  if (info->root_picture)
+    XRenderFreePicture (xdisplay, info->root_picture);
+
+  if (info->black_picture)
+    XRenderFreePicture (xdisplay, info->black_picture);
+
+  if (info->have_shadows)
+    {
+      int i;
+
+      for (i = 0; i < LAST_SHADOW_TYPE; i++)
+        g_free (info->shadows[i]->gaussian_map);
+    }
+
+  XCompositeUnredirectSubwindows (xdisplay, xroot,
+                                  CompositeRedirectManual);
+  meta_screen_unset_cm_selection (screen);
+
+#ifdef HAVE_COW
+  XCompositeReleaseOverlayWindow (xdisplay, info->output);
+#endif
+
+  g_free (info);
+
+  meta_screen_set_compositor_data (screen, NULL);
+#endif
+}
+
+static void
+xrender_set_updates (MetaCompositor *compositor,
+                     MetaWindow     *window,
+                     gboolean        updates)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+
+#endif
+}
+
+static void
+xrender_destroy (MetaCompositor *compositor)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  g_free (compositor);
+#endif
+}
+
+#if 0
+/* Taking these out because they're empty and never called, and the
+ * compiler complains -- tthurman
+ */
+
+static void
+xrender_begin_move (MetaCompositor *compositor,
+                    MetaWindow     *window,
+                    MetaRectangle  *initial,
+                    int             grab_x,
+                    int             grab_y)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_update_move (MetaCompositor *compositor,
+                     MetaWindow     *window,
+                     int             x,
+                     int             y)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_end_move (MetaCompositor *compositor,
+                  MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#endif
+}
+
+static void
+xrender_free_window (MetaCompositor *compositor,
+                     MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  /* FIXME: When an undecorated window is hidden this is called,
+     but the window does not get readded if it is subsequentally shown again
+     See http://bugzilla.gnome.org/show_bug.cgi?id=504876
+
+     I don't *think* theres any need for this call anyway, leaving it out
+     does not seem to cause any side effects so far, but I should check with
+     someone who understands more. */
+  /* destroy_win (compositor->display, window->xwindow, FALSE); */
+#endif
+}
+#endif /* 0 */
+
+static void
+xrender_process_event (MetaCompositor *compositor,
+                       XEvent         *event,
+                       MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  /*
+   * This trap is so that none of the compositor functions cause
+   * X errors. This is really a hack, but I'm afraid I don't understand
+   * enough about Marco/X to know how else you are supposed to do it
+   */
+  meta_error_trap_push (xrc->display);
+  switch (event->type)
+    {
+    case CirculateNotify:
+      process_circulate_notify (xrc, (XCirculateEvent *) event);
+      break;
+
+    case ConfigureNotify:
+      process_configure_notify (xrc, (XConfigureEvent *) event);
+      break;
+
+    case PropertyNotify:
+      process_property_notify (xrc, (XPropertyEvent *) event);
+      break;
+
+    case Expose:
+      process_expose (xrc, (XExposeEvent *) event);
+      break;
+
+    case UnmapNotify:
+      process_unmap (xrc, (XUnmapEvent *) event);
+      break;
+
+    case MapNotify:
+      process_map (xrc, (XMapEvent *) event);
+      break;
+
+    case ReparentNotify:
+      process_reparent (xrc, (XReparentEvent *) event, window);
+      break;
+
+    case CreateNotify:
+      process_create (xrc, (XCreateWindowEvent *) event, window);
+      break;
+
+    case DestroyNotify:
+      process_destroy (xrc, (XDestroyWindowEvent *) event);
+      break;
+
+    default:
+      if (event->type == meta_display_get_damage_event_base (xrc->display) + XDamageNotify)
+        process_damage (xrc, (XDamageNotifyEvent *) event);
+#ifdef HAVE_SHAPE
+      else if (event->type == meta_display_get_shape_event_base (xrc->display) + ShapeNotify)
+        process_shape (xrc, (XShapeEvent *) event);
+#endif /* HAVE_SHAPE */
+      else
+        {
+          meta_error_trap_pop (xrc->display, FALSE);
+          return;
+        }
+      break;
+    }
+
+  meta_error_trap_pop (xrc->display, FALSE);
+#ifndef USE_IDLE_REPAINT
+  repair_display (xrc->display);
+#endif
+
+  return;
+#endif
+}
+
+static Pixmap
+xrender_get_window_pixmap (MetaCompositor *compositor,
+                           MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompWindow *cw = NULL;
+  MetaScreen *screen = meta_window_get_screen (window);
+  MetaFrame *frame = meta_window_get_frame (window);
+
+  cw = find_window_for_screen (screen, frame ? meta_frame_get_xwindow (frame) :
+                               meta_window_get_xwindow (window));
+  if (cw == NULL)
+    return None;
+
+#ifdef HAVE_NAME_WINDOW_PIXMAP
+  if (have_name_window_pixmap (meta_window_get_display (window)))
+    {
+      if (meta_window_is_shaded (window))
+        return cw->shaded_back_pixmap;
+      else
+        return cw->back_pixmap;
+    }
+  else
+#endif
+    return None;
+#endif
+}
+
+static void
+xrender_set_active_window (MetaCompositor *compositor,
+                           MetaScreen     *screen,
+                           MetaWindow     *window)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+  MetaDisplay *display;
+  Display *xdisplay;
+  MetaCompWindow *old_focus = NULL, *new_focus = NULL;
+  MetaCompScreen *info = NULL;
+  MetaWindow *old_focus_win = NULL;
+
+  if (compositor == NULL)
+    return;
+
+  display = xrc->display;
+  xdisplay = meta_display_get_xdisplay (display);
+  info = meta_screen_get_compositor_data (screen);
+
+  if (info != NULL)
+    {
+      old_focus_win = info->focus_window;
+    }
+
+  if (old_focus_win)
+    {
+      MetaFrame *f = meta_window_get_frame (old_focus_win);
+
+      old_focus = find_window_for_screen (screen,
+                                          f ? meta_frame_get_xwindow (f) :
+                                          meta_window_get_xwindow (old_focus_win));
+    }
+
+  if (window)
+    {
+      MetaFrame *f = meta_window_get_frame (window);
+      new_focus = find_window_for_screen (screen,
+                                          f ? meta_frame_get_xwindow (f) :
+                                          meta_window_get_xwindow (window));
+    }
+
+  if (info != NULL)
+    {
+      info->focus_window = window;
+    }
+
+  if (old_focus)
+    {
+      XserverRegion damage;
+
+      /* Tear down old shadows */
+      old_focus->shadow_type = META_SHADOW_MEDIUM;
+      determine_mode (display, screen, old_focus);
+      old_focus->needs_shadow = window_has_shadow (old_focus);
+
+      if (old_focus->attrs.map_state == IsViewable)
+        {
+          if (old_focus->shadow)
+            {
+              XRenderFreePicture (xdisplay, old_focus->shadow);
+              old_focus->shadow = None;
+            }
+
+          if (old_focus->extents)
+            {
+              damage = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesCopyRegion (xdisplay, damage, old_focus->extents);
+              XFixesDestroyRegion (xdisplay, old_focus->extents);
+            }
+          else
+            damage = None;
+
+          /* Build new extents */
+          old_focus->extents = win_extents (old_focus);
+
+          if (damage)
+            XFixesUnionRegion (xdisplay, damage, damage, old_focus->extents);
+          else
+            {
+              damage = XFixesCreateRegion (xdisplay, NULL, 0);
+              XFixesCopyRegion (xdisplay, damage, old_focus->extents);
+            }
+
+          dump_xserver_region ("resize_win", display, damage);
+          add_damage (screen, damage);
+
+          if (info != NULL)
+            {
+              info->clip_changed = TRUE;
+            }
+        }
+    }
+
+  if (new_focus)
+    {
+      XserverRegion damage;
+
+      new_focus->shadow_type = META_SHADOW_LARGE;
+      determine_mode (display, screen, new_focus);
+      new_focus->needs_shadow = window_has_shadow (new_focus);
+
+      if (new_focus->shadow)
+        {
+          XRenderFreePicture (xdisplay, new_focus->shadow);
+          new_focus->shadow = None;
+        }
+
+      if (new_focus->extents)
+        {
+          damage = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesCopyRegion (xdisplay, damage, new_focus->extents);
+          XFixesDestroyRegion (xdisplay, new_focus->extents);
+        }
+      else
+        damage = None;
+
+      /* Build new extents */
+      new_focus->extents = win_extents (new_focus);
+
+      if (damage)
+        XFixesUnionRegion (xdisplay, damage, damage, new_focus->extents);
+      else
+        {
+          damage = XFixesCreateRegion (xdisplay, NULL, 0);
+          XFixesCopyRegion (xdisplay, damage, new_focus->extents);
+        }
+
+      dump_xserver_region ("resize_win", display, damage);
+      add_damage (screen, damage);
+
+      if (info != NULL)
+        {
+          info->clip_changed = TRUE;
+        }
+    }
+#ifdef USE_IDLE_REPAINT
+  add_repair (display);
+#endif
+#endif
+}
+
+static MetaCompositor comp_info = {
+  xrender_destroy,
+  xrender_manage_screen,
+  xrender_unmanage_screen,
+  xrender_add_window,
+  xrender_remove_window,
+  xrender_set_updates,
+  xrender_process_event,
+  xrender_get_window_pixmap,
+  xrender_set_active_window
+};
+
+MetaCompositor *
+meta_compositor_xrender_new (MetaDisplay *display)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  char *atom_names[] = {
+    "_XROOTPMAP_ID",
+    "_XSETROOT_ID",
+    "_NET_WM_WINDOW_OPACITY",
+    "_NET_WM_WINDOW_TYPE_DND",
+    "_NET_WM_WINDOW_TYPE",
+    "_NET_WM_WINDOW_TYPE_DESKTOP",
+    "_NET_WM_WINDOW_TYPE_DOCK",
+    "_NET_WM_WINDOW_TYPE_MENU",
+    "_NET_WM_WINDOW_TYPE_DIALOG",
+    "_NET_WM_WINDOW_TYPE_NORMAL",
+    "_NET_WM_WINDOW_TYPE_UTILITY",
+    "_NET_WM_WINDOW_TYPE_SPLASH",
+    "_NET_WM_WINDOW_TYPE_TOOLBAR",
+    "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
+    "_NET_WM_WINDOW_TYPE_TOOLTIP"
+  };
+  Atom atoms[G_N_ELEMENTS(atom_names)];
+  MetaCompositorXRender *xrc;
+  MetaCompositor *compositor;
+  Display *xdisplay = meta_display_get_xdisplay (display);
+
+  xrc = g_new (MetaCompositorXRender, 1);
+  xrc->compositor = comp_info;
+
+  compositor = (MetaCompositor *) xrc;
+
+  xrc->display = display;
+
+  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
+  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
+                False, atoms);
+
+  xrc->atom_x_root_pixmap = atoms[0];
+  xrc->atom_x_set_root = atoms[1];
+  xrc->atom_net_wm_window_opacity = atoms[2];
+  xrc->atom_net_wm_window_type_dnd = atoms[3];
+  xrc->atom_net_wm_window_type = atoms[4];
+  xrc->atom_net_wm_window_type_desktop = atoms[5];
+  xrc->atom_net_wm_window_type_dock = atoms[6];
+  xrc->atom_net_wm_window_type_menu = atoms[7];
+  xrc->atom_net_wm_window_type_dialog = atoms[8];
+  xrc->atom_net_wm_window_type_normal = atoms[9];
+  xrc->atom_net_wm_window_type_utility = atoms[10];
+  xrc->atom_net_wm_window_type_splash = atoms[11];
+  xrc->atom_net_wm_window_type_toolbar = atoms[12];
+  xrc->atom_net_wm_window_type_dropdown_menu = atoms[13];
+  xrc->atom_net_wm_window_type_tooltip = atoms[14];
+
+#ifdef USE_IDLE_REPAINT
+  meta_verbose ("Using idle repaint\n");
+  xrc->repaint_id = 0;
+#endif
+
+  xrc->enabled = TRUE;
+  g_timeout_add (2000, (GSourceFunc) timeout_debug, xrc);
+
+  return compositor;
+#else
+  return NULL;
+#endif
+}
+
+#endif /* HAVE_COMPOSITE_EXTENSIONS */
+