diff --git a/src/compositor/compositor-private.h b/src/compositor/compositor-private.h
index 566598e87..ffa938baf 100644
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -33,11 +33,9 @@ struct _MetaCompositor
   void (*unmanage_screen) (MetaCompositor *compositor,
                            MetaScreen     *screen);
   void (*add_window) (MetaCompositor    *compositor,
-                      MetaWindow        *window,
-                      Window             xwindow,
-                      XWindowAttributes *attrs);
+                      MetaWindow        *window);
   void (*remove_window) (MetaCompositor *compositor,
-                         Window          xwindow);
+                         MetaWindow     *window);
   void (*set_updates) (MetaCompositor *compositor,
                        MetaWindow     *window,
                        gboolean        update);
@@ -49,40 +47,34 @@ struct _MetaCompositor
   void (*set_active_window) (MetaCompositor *compositor,
                              MetaScreen     *screen,
                              MetaWindow     *window);
-  /* local additions */
-  void (*destroy_window) (MetaCompositor *compositor,
-                          MetaWindow     *window);
-
+  void (*map_window) (MetaCompositor *compositor,
+                      MetaWindow     *window);
+  void (*unmap_window) (MetaCompositor *compositor,
+			MetaWindow     *window);
   void (*minimize_window) (MetaCompositor *compositor,
-                           MetaWindow     *window);
-
+                           MetaWindow     *window,
+			   MetaRectangle  *window_rect,
+			   MetaRectangle  *icon_rect);
+  void (*unminimize_window) (MetaCompositor *compositor,
+			     MetaWindow     *window,
+			     MetaRectangle  *window_rect,
+			     MetaRectangle  *icon_rect);
   void (*maximize_window) (MetaCompositor    *compositor,
                            MetaWindow        *window,
-                           int                x,
-                           int                y,
-                           int                width,
-                           int                height);
-
+			   MetaRectangle     *window_rect);
   void (*unmaximize_window) (MetaCompositor    *compositor,
                              MetaWindow        *window,
-                             int                x,
-                             int                y,
-                             int                width,
-                             int                height);
-
+			     MetaRectangle     *window_rect);
   void (*update_workspace_geometry) (MetaCompositor *compositor,
                                      MetaWorkspace   *workspace);
-
   void (*switch_workspace) (MetaCompositor     *compositor,
                             MetaScreen         *screen,
                             MetaWorkspace      *from,
                             MetaWorkspace      *to,
                             MetaMotionDirection direction);
-
   void (*sync_stack) (MetaCompositor *compositor,
 		      MetaScreen     *screen,
 		      GList	     *stack);
-  
   void (*set_window_hidden) (MetaCompositor *compositor,
 			     MetaScreen	    *screen,
 			     MetaWindow	    *window,
diff --git a/src/compositor/compositor-xrender.c b/src/compositor/compositor-xrender.c
index 0a631a929..db3815274 100644
--- a/src/compositor/compositor-xrender.c
+++ b/src/compositor/compositor-xrender.c
@@ -911,7 +911,7 @@ window_has_shadow (MetaCompWindow *cw)
   }
 
   if (cw->type == META_COMP_WINDOW_MENU || 
-      cw->type == META_COMP_WINDOW_DROP_DOWN_MENU) {
+      cw->type == META_COMP_WINDOW_DROPDOWN_MENU) {
     meta_verbose ("Window has shadow as it is a menu\n");
     return TRUE;
   }
@@ -1776,7 +1776,7 @@ get_window_type (MetaDisplay    *display,
   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;
+    cw->type = META_COMP_WINDOW_DROPDOWN_MENU;
   else if (type_atom == compositor->atom_net_wm_window_type_tooltip)
     cw->type = META_COMP_WINDOW_TOOLTIP;
   else
diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
index 87692f4e1..18b759fe8 100644
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -57,23 +57,21 @@ meta_compositor_destroy (MetaCompositor *compositor)
 
 void
 meta_compositor_add_window (MetaCompositor    *compositor,
-                            MetaWindow        *window,
-                            Window             xwindow,
-                            XWindowAttributes *attrs)
+                            MetaWindow        *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   if (compositor && compositor->add_window)
-    compositor->add_window (compositor, window, xwindow, attrs);
+    compositor->add_window (compositor, window);
 #endif
 }
 
 void
 meta_compositor_remove_window (MetaCompositor *compositor,
-                               Window          xwindow)
+                               MetaWindow     *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   if (compositor && compositor->remove_window)
-    compositor->remove_window (compositor, xwindow);
+    compositor->remove_window (compositor, window);
 #endif
 }
 
@@ -165,57 +163,69 @@ void meta_compositor_end_move (MetaCompositor *compositor,
 {
 }
 
-void meta_compositor_free_window (MetaCompositor *compositor,
-                                  MetaWindow     *window)
+void
+meta_compositor_map_window (MetaCompositor *compositor,
+			    MetaWindow	   *window)
 {
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->map_window)
+    compositor->map_window (compositor, window);
+#endif
 }
 
 void
-meta_compositor_destroy_window (MetaCompositor *compositor,
-                                MetaWindow     *window)
+meta_compositor_unmap_window (MetaCompositor *compositor,
+			      MetaWindow     *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  if (compositor && compositor->destroy_window)
-    compositor->destroy_window (compositor, window);
+  if (compositor && compositor->unmap_window)
+    compositor->unmap_window (compositor, window);
 #endif
 }
 
 void
 meta_compositor_minimize_window (MetaCompositor *compositor,
-                                 MetaWindow     *window)
+                                 MetaWindow     *window,
+				 MetaRectangle	*window_rect,
+				 MetaRectangle	*icon_rect)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   if (compositor && compositor->minimize_window)
-    compositor->minimize_window (compositor, window);
+    compositor->minimize_window (compositor, window, window_rect, icon_rect);
+#endif
+}
+
+void
+meta_compositor_unminimize_window (MetaCompositor    *compositor,
+                                   MetaWindow        *window,
+				   MetaRectangle     *window_rect,
+				   MetaRectangle     *icon_rect)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  if (compositor && compositor->unminimize_window)
+    compositor->unminimize_window (compositor, window, window_rect, icon_rect);
 #endif
 }
 
 void
 meta_compositor_maximize_window (MetaCompositor    *compositor,
                                  MetaWindow        *window,
-                                 int                x,
-                                 int                y,
-                                 int                width,
-                                 int                height)
+				 MetaRectangle	   *window_rect)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   if (compositor && compositor->maximize_window)
-    compositor->maximize_window (compositor, window, x, y, width, height);
+    compositor->maximize_window (compositor, window, window_rect);
 #endif
 }
 
 void
 meta_compositor_unmaximize_window (MetaCompositor    *compositor,
                                    MetaWindow        *window,
-                                   int                x,
-                                   int                y,
-                                   int                width,
-                                   int                height)
-
+				   MetaRectangle     *window_rect)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   if (compositor && compositor->unmaximize_window)
-    compositor->unmaximize_window (compositor, window, x, y, width, height);
+    compositor->unmaximize_window (compositor, window, window_rect);
 #endif
 }
 
diff --git a/src/compositor/mutter/compositor-mutter.c b/src/compositor/mutter/compositor-mutter.c
index bcd7170f3..a018ef980 100644
--- a/src/compositor/mutter/compositor-mutter.c
+++ b/src/compositor/mutter/compositor-mutter.c
@@ -188,17 +188,19 @@ struct _MutterWindowPrivate
   gint              map_in_progress;
   gint              destroy_in_progress;
 
-  gboolean          needs_shadow           : 1;
-  gboolean          shaped                 : 1;
-  gboolean          destroy_pending        : 1;
-  gboolean          argb32                 : 1;
-  gboolean          disposed               : 1;
-  gboolean          is_minimized           : 1;
+  guint		    needs_shadow           : 1;
+  guint		    shaped                 : 1;
+  guint		    destroy_pending        : 1;
+  guint		    argb32                 : 1;
+  guint		    disposed               : 1;
+  guint		    is_minimized           : 1;
 
   /* Desktop switching flags */
-  gboolean          needs_map              : 1;
-  gboolean          needs_unmap            : 1;
-  gboolean          needs_repair           : 1;
+  guint		    needs_map              : 1;
+  guint		    needs_unmap            : 1;
+  guint		    needs_repair           : 1;
+
+  guint		    needs_destroy	   : 1;
 };
 
 enum
@@ -485,8 +487,9 @@ find_window_in_display (MetaDisplay *display, Window xwindow)
 
   if (window)
     {
-      if (window->compositor_private)
-	return window->compositor_private;
+      void *priv = meta_window_get_compositor_private (window);
+      if (priv)
+	return priv;
     }
 
   for (index = meta_display_get_screens (display);
@@ -520,91 +523,8 @@ find_window_for_child_window_in_display (MetaDisplay *display, Window xwindow)
 static void
 mutter_window_query_window_type (MutterWindow *self)
 {
-  MutterWindowPrivate *priv    = self->priv;
-  MetaScreen            *screen  = priv->screen;
-  MetaDisplay           *display = meta_screen_get_display (screen);
-  Window                 xwindow = priv->xwindow;
-  gint                   n_atoms;
-  Atom                  *atoms;
-  gint                   i;
-
-  if (priv->attrs.override_redirect)
-    {
-      priv->type = META_COMP_WINDOW_OVERRIDE;
-      return;
-    }
-
-  /*
-   * If the window is managed by the WM, get the type from the WM,
-   * otherwise do it the hard way.
-   */
-  if (priv->window && meta_window_get_type_atom (priv->window) != None)
-    {
-      priv->type = (MetaCompWindowType) meta_window_get_type (priv->window);
-      return;
-    }
-
-  n_atoms = 0;
-  atoms = NULL;
-
-  /*
-   * Assume normal
-   */
-  priv->type = META_COMP_WINDOW_NORMAL;
-
-  meta_prop_get_atom_list (display, xwindow,
-                           meta_display_get_atom (display,
-					       META_ATOM__NET_WM_WINDOW_TYPE),
-                           &atoms, &n_atoms);
-
-  for (i = 0; i < n_atoms; i++)
-    {
-      if (atoms[i] ==
-	  meta_display_get_atom (display,
-				 META_ATOM__NET_WM_WINDOW_TYPE_DND))
-	{
-	  priv->type = META_COMP_WINDOW_DND;
-	  break;
-	}
-      else if (atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_DESKTOP))
-	{
-	  priv->type = META_COMP_WINDOW_DESKTOP;
-	  break;
-	}
-      else if (atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_DOCK))
-	{
-	  priv->type = META_COMP_WINDOW_DOCK;
-	  break;
-	}
-      else if (atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_TOOLBAR) ||
-	       atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_MENU)    ||
-	       atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_DIALOG)  ||
-	       atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_NORMAL)  ||
-	       atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_UTILITY) ||
-	       atoms[i] ==
-	       meta_display_get_atom (display,
-				      META_ATOM__NET_WM_WINDOW_TYPE_SPLASH))
-        {
-	  priv->type = META_COMP_WINDOW_NORMAL;
-	  break;
-        }
-    }
-
-  meta_XFree (atoms);
+  MutterWindowPrivate *priv = self->priv;
+  priv->type = (MetaCompWindowType) meta_window_get_type (priv->window);
 }
 
 static gboolean
@@ -690,7 +610,7 @@ mutter_window_has_shadow (MutterWindow *self)
 
   if (priv->type == META_COMP_WINDOW_MENU
 #if 0
-      || priv->type == META_COMP_WINDOW_DROP_DOWN_MENU
+      || priv->type == META_COMP_WINDOW_DROPDOWN_MENU
 #endif
       )
     {
@@ -806,10 +726,12 @@ mutter_window_showing_on_its_workspace (MutterWindow *mcw)
 static void repair_win (MutterWindow *cw);
 static void map_win    (MutterWindow *cw);
 static void unmap_win  (MutterWindow *cw);
+static void sync_actor_stacking (GList *windows);
 
 static void
 mutter_finish_workspace_switch (MetaCompScreen *info)
 {
+#ifdef FIXME
   GList *last = g_list_last (info->windows);
   GList *l;
 
@@ -841,48 +763,12 @@ mutter_finish_workspace_switch (MetaCompScreen *info)
 	  l = l->prev;
 	}
     }
+#endif
 
-#if 0
   /*
    * Fix up stacking order in case the plugin messed it up.
    */
-  l = last;
-
-  while (l)
-    {
-      ClutterActor *a  = l->data;
-      MutterWindow *mw = l->data;
-      MetaWindow   *window = mw->priv->window;
-
-      /*
-       * If this window is not marked as hidden, we raise it.
-       * If it has no MetaWindow associated (i.e., override redirect), we
-       * raise it too. Everything else we push to the bottom.
-       */
-      if (!window || !meta_window_is_hidden (window))
-	{
-#if 0
-	  printf ("raising %p [0x%x] (%s) to top\n",
-		  a,
-		  (guint)mw->priv->xwindow,
-		  mw->priv->window ? mw->priv->window->desc : "unknown");
-#endif
-	  clutter_actor_raise_top (a);
-	}
-      else
-	{
-#if 0
-	  printf ("lowering %p [0x%x] (%s) to bottom\n",
-		  a,
-		  (guint)mw->priv->xwindow,
-		  mw->priv->window ? mw->priv->window->desc : "unknown");
-#endif
-	  clutter_actor_lower_bottom (a);
-	}
-
-      l = l->prev;
-    }
-#endif
+  sync_actor_stacking (info->windows);
 
 /*   printf ("... FINISHED DESKTOP SWITCH\n"); */
 
@@ -892,121 +778,158 @@ void
 mutter_window_effect_completed (MutterWindow *cw, gulong event)
 {
   MutterWindowPrivate *priv   = cw->priv;
-  MetaScreen            *screen = priv->screen;
-  MetaCompScreen        *info   = meta_screen_get_compositor_data (screen);
-  ClutterActor          *actor  = CLUTTER_ACTOR (cw);
+  MetaScreen          *screen = priv->screen;
+  MetaCompScreen      *info   = meta_screen_get_compositor_data (screen);
+  ClutterActor        *actor  = CLUTTER_ACTOR (cw);
+  
+  /* NB: Keep in mind that when effects get completed it possible
+   * that the corresponding MetaWindow may have be been destroyed.
+   * In this case priv->window will == NULL */
 
-    switch (event)
+  switch (event)
+  {
+  case MUTTER_PLUGIN_MINIMIZE:
     {
-    case MUTTER_PLUGIN_MINIMIZE:
+      ClutterActor *a = CLUTTER_ACTOR (cw);
+
+      priv->minimize_in_progress--;
+      if (priv->minimize_in_progress < 0)
+	{
+	  g_warning ("Error in minimize accounting.");
+	  priv->minimize_in_progress = 0;
+	}
+
+      if (!priv->minimize_in_progress)
+	{
+	  priv->is_minimized = TRUE;
+
+	  /*
+	   * We must ensure that the minimized actor is pushed down the stack
+	   * (the XConfigureEvent has 'above' semantics, i.e., when a window
+	   * is lowered, we get a bunch of 'raise' notifications, but might
+	   * not get any notification for the window that has been lowered.
+	   */
+	  clutter_actor_lower_bottom (a);
+
+	  /* Make sure that after the effect finishes, the actor is
+	   * made visible for sake of live previews.
+	   */
+	  clutter_actor_show (a);
+	}
+    }
+    break;
+  case MUTTER_PLUGIN_MAP:
+    /*
+     * Make sure that the actor is at the correct place in case
+     * the plugin fscked.
+     */
+    priv->map_in_progress--;
+
+    if (priv->map_in_progress < 0)
       {
-	ClutterActor *a = CLUTTER_ACTOR (cw);
+	g_warning ("Error in map accounting.");
+	priv->map_in_progress = 0;
+      }
 
-	priv->minimize_in_progress--;
-	if (priv->minimize_in_progress < 0)
+    if (!priv->map_in_progress && priv->window)
+      {
+	MetaRectangle rect;
+	meta_window_get_outer_rect (priv->window, &rect);
+	priv->is_minimized = FALSE;
+	clutter_actor_set_anchor_point (actor, 0, 0);
+	clutter_actor_set_position (actor, rect.x, rect.y);
+	clutter_actor_show_all (actor);
+      }
+    break;
+  case MUTTER_PLUGIN_DESTROY:
+    priv->destroy_in_progress--;
+
+    if (priv->destroy_in_progress < 0)
+      {
+	g_warning ("Error in destroy accounting.");
+	priv->destroy_in_progress = 0;
+      }
+
+    if (!priv->destroy_in_progress)
+      priv->needs_destroy = TRUE;
+    break;
+  case MUTTER_PLUGIN_UNMAXIMIZE:
+    priv->unmaximize_in_progress--;
+    if (priv->unmaximize_in_progress < 0)
+      {
+	g_warning ("Error in unmaximize accounting.");
+	priv->unmaximize_in_progress = 0;
+      }
+
+    if (!priv->unmaximize_in_progress && priv->window)
+      {
+	MetaRectangle rect;
+	meta_window_get_outer_rect (priv->window, &rect);
+	clutter_actor_set_position (actor, rect.x, rect.y);
+	mutter_window_detach (cw);
+	repair_win (cw);
+      }
+    break;
+  case MUTTER_PLUGIN_MAXIMIZE:
+    priv->maximize_in_progress--;
+    if (priv->maximize_in_progress < 0)
+      {
+	g_warning ("Error in maximize accounting.");
+	priv->maximize_in_progress = 0;
+      }
+
+    if (!priv->maximize_in_progress && priv->window)
+      {
+	MetaRectangle rect;
+	meta_window_get_outer_rect (priv->window, &rect);
+	clutter_actor_set_position (actor, rect.x, rect.y);
+	mutter_window_detach (cw);
+	repair_win (cw);
+      }
+    break;
+  case MUTTER_PLUGIN_SWITCH_WORKSPACE:
+    /* FIXME -- must redo stacking order */
+    info->switch_workspace_in_progress--;
+    if (info->switch_workspace_in_progress < 0)
+      {
+	g_warning ("Error in workspace_switch accounting!");
+	info->switch_workspace_in_progress = 0;
+      }
+
+    if (!info->switch_workspace_in_progress)
+      mutter_finish_workspace_switch (info);
+    break;
+  default:
+    break;
+  }
+  
+  switch (event)
+  {
+  case MUTTER_PLUGIN_MINIMIZE:
+  case MUTTER_PLUGIN_MAP:
+  case MUTTER_PLUGIN_DESTROY:
+  case MUTTER_PLUGIN_UNMAXIMIZE:
+  case MUTTER_PLUGIN_MAXIMIZE:
+    if (priv->needs_destroy)
+      {
+	if (priv->minimize_in_progress ||
+	    priv->maximize_in_progress ||
+	    priv->unmaximize_in_progress ||
+	    priv->map_in_progress ||
+	    priv->destroy_in_progress)
 	  {
-	    g_warning ("Error in minimize accounting.");
-	    priv->minimize_in_progress = 0;
+	    /* wait until last effect finished */
+	    break;
 	  }
-
-	if (!priv->minimize_in_progress)
+	else
 	  {
-	    priv->is_minimized = TRUE;
-
-	    /*
-	     * We must ensure that the minimized actor is pushed down the stack
-	     * (the XConfigureEvent has 'above' semantics, i.e., when a window
-	     * is lowered, we get a bunch of 'raise' notifications, but might
-	     * not get any notification for the window that has been lowered.
-	     */
-	    clutter_actor_lower_bottom (a);
-
-	    /* Make sure that after the effect finishes, the actor is
-	     * made visible for sake of live previews.
-	     */
-	    clutter_actor_show (a);
+	    clutter_actor_destroy (CLUTTER_ACTOR (cw));
+	    return;
 	  }
       }
-      break;
-    case MUTTER_PLUGIN_MAP:
-      /*
-       * Make sure that the actor is at the correct place in case
-       * the plugin fscked.
-       */
-      priv->map_in_progress--;
-
-      if (priv->map_in_progress < 0)
-	{
-	  g_warning ("Error in map accounting.");
-	  priv->map_in_progress = 0;
-	}
-
-      if (!priv->map_in_progress)
-	{
-	  priv->is_minimized = FALSE;
-	  clutter_actor_set_anchor_point (actor, 0, 0);
-	  clutter_actor_set_position (actor, priv->attrs.x, priv->attrs.y);
-	  clutter_actor_show_all (actor);
-	}
-      break;
-    case MUTTER_PLUGIN_DESTROY:
-      priv->destroy_in_progress--;
-
-      if (priv->destroy_in_progress < 0)
-	{
-	  g_warning ("Error in destroy accounting.");
-	  priv->destroy_in_progress = 0;
-	}
-
-      if (!priv->destroy_in_progress)
-	{
-	  clutter_actor_destroy (actor);
-	}
-      break;
-    case MUTTER_PLUGIN_UNMAXIMIZE:
-      priv->unmaximize_in_progress--;
-      if (priv->unmaximize_in_progress < 0)
-	{
-	  g_warning ("Error in unmaximize accounting.");
-	  priv->unmaximize_in_progress = 0;
-	}
-
-      if (!priv->unmaximize_in_progress)
-	{
-	  clutter_actor_set_position (actor, priv->attrs.x, priv->attrs.y);
-	  mutter_window_detach (cw);
-	  repair_win (cw);
-	}
-      break;
-    case MUTTER_PLUGIN_MAXIMIZE:
-      priv->maximize_in_progress--;
-      if (priv->maximize_in_progress < 0)
-	{
-	  g_warning ("Error in maximize accounting.");
-	  priv->maximize_in_progress = 0;
-	}
-
-      if (!priv->maximize_in_progress)
-	{
-	  clutter_actor_set_position (actor, priv->attrs.x, priv->attrs.y);
-	  mutter_window_detach (cw);
-	  repair_win (cw);
-	}
-      break;
-    case MUTTER_PLUGIN_SWITCH_WORKSPACE:
-      /* FIXME -- must redo stacking order */
-      info->switch_workspace_in_progress--;
-      if (info->switch_workspace_in_progress < 0)
-	{
-	  g_warning ("Error in workspace_switch accounting!");
-	  info->switch_workspace_in_progress = 0;
-	}
-
-      if (!info->switch_workspace_in_progress)
-	mutter_finish_workspace_switch (info);
-      break;
-    default: ;
-    }
+  default:
+    break;
+  }
 }
 
 
@@ -1038,38 +961,32 @@ mutter_window_detach (MutterWindow *self)
 }
 
 static void
-destroy_win (MutterWindow *cw, gboolean no_effect)
+destroy_win (MutterWindow *cw)
 {
   MetaWindow	      *window;
   MetaCompScreen      *info;
   MutterWindowPrivate *priv;
-  MetaScreen          *screen;
-
-  if (!cw)
-    return;
-
+  
   priv = cw->priv;
 
-  window = meta_display_lookup_x_window (priv->screen->display, priv->xwindow);
-  if (window)
-    window->compositor_private = NULL;
-
-  /* If not override redirect */
-  if (window)
-    window->compositor_private = NULL;
-
-  screen = priv->screen;
-  info   = meta_screen_get_compositor_data (screen);
-
+  window = priv->window;
+  meta_window_set_compositor_private (window, NULL);
 
   /*
    * We remove the window from internal lookup hashes and thus any other
    * unmap events etc fail
    */
+  info = meta_screen_get_compositor_data (priv->screen);
   info->windows = g_list_remove (info->windows, (gconstpointer) cw);
   g_hash_table_remove (info->windows_by_xid, (gpointer)priv->xwindow);
 
-  if (no_effect || priv->type == META_COMP_WINDOW_OVERRIDE)
+  if (priv->type == META_COMP_WINDOW_DROPDOWN_MENU ||
+      priv->type == META_COMP_WINDOW_POPUP_MENU ||
+      priv->type == META_COMP_WINDOW_TOOLTIP ||
+      priv->type == META_COMP_WINDOW_NOTIFICATION ||
+      priv->type == META_COMP_WINDOW_COMBO ||
+      priv->type == META_COMP_WINDOW_DND ||
+      priv->type == META_COMP_WINDOW_OVERRIDE_OTHER)
     {
       /*
        * No effects, just kill it.
@@ -1090,46 +1007,53 @@ destroy_win (MutterWindow *cw, gboolean no_effect)
 					   MUTTER_PLUGIN_DESTROY))
     {
       priv->destroy_in_progress--;
-      clutter_actor_destroy (CLUTTER_ACTOR (cw));
+      
+      if (priv->minimize_in_progress ||
+          priv->maximize_in_progress ||
+	  priv->unmaximize_in_progress ||
+	  priv->map_in_progress)
+	{
+	  priv->needs_destroy = TRUE;
+	}
+      else
+	clutter_actor_destroy (CLUTTER_ACTOR (cw));
     }
 }
 
 static void
-resize_win (MutterWindow *cw,
-            int           x,
-            int           y,
-            int           width,
-            int           height,
-            int           border_width,
-            gboolean      override_redirect)
+sync_actor_position (MutterWindow *cw)
 {
   MutterWindowPrivate *priv = cw->priv;
+  MetaRectangle window_rect;
 
-  if (priv->attrs.width != width || priv->attrs.height != height)
+  meta_window_get_outer_rect (priv->window, &window_rect);
+
+  if (priv->attrs.width != window_rect.width ||
+      priv->attrs.height != window_rect.height)
     mutter_window_detach (cw);
 
-  priv->attrs.width = width;
-  priv->attrs.height = height;
-  priv->attrs.x = x;
-  priv->attrs.y = y;
-  priv->attrs.border_width      = border_width;
-  priv->attrs.override_redirect = override_redirect;
+  /* XXX deprecated: please use meta_window_get_outer_rect instead */
+  priv->attrs.width = window_rect.width;
+  priv->attrs.height = window_rect.height;
+  priv->attrs.x = window_rect.x;
+  priv->attrs.y = window_rect.y;
 
   if (priv->maximize_in_progress   ||
       priv->unmaximize_in_progress ||
       priv->map_in_progress)
     return;
 
-  clutter_actor_set_position (CLUTTER_ACTOR (cw), x, y);
+  clutter_actor_set_position (CLUTTER_ACTOR (cw),
+			      window_rect.x, window_rect.y);
 }
 
 static void
 map_win (MutterWindow *cw)
 {
   MutterWindowPrivate *priv;
-  MetaCompScreen        *info;
-
-  if (cw == NULL)
+  MetaCompScreen      *info;
+  
+  if (!cw)
     return;
 
   priv = cw->priv;
@@ -1154,9 +1078,10 @@ map_win (MutterWindow *cw)
    */
   if (!info->switch_workspace_in_progress)
     {
+      MetaRectangle rect;
+      meta_window_get_outer_rect (priv->window, &rect);
       clutter_actor_set_anchor_point (CLUTTER_ACTOR (cw), 0, 0);
-      clutter_actor_set_position (CLUTTER_ACTOR (cw),
-				  cw->priv->attrs.x, cw->priv->attrs.y);
+      clutter_actor_set_position (CLUTTER_ACTOR (cw), rect.x, rect.y);
     }
 
   priv->map_in_progress++;
@@ -1180,9 +1105,9 @@ static void
 unmap_win (MutterWindow *cw)
 {
   MutterWindowPrivate *priv;
-  MetaCompScreen        *info;
-
-  if (cw == NULL)
+  MetaCompScreen      *info;
+  
+  if (!cw)
     return;
 
   priv = cw->priv;
@@ -1214,74 +1139,48 @@ unmap_win (MutterWindow *cw)
 
   if (!priv->minimize_in_progress &&
       (!meta_prefs_get_live_hidden_windows () ||
-       priv->type == META_COMP_WINDOW_OVERRIDE))
+       priv->type == META_COMP_WINDOW_DROPDOWN_MENU ||
+       priv->type == META_COMP_WINDOW_POPUP_MENU ||
+       priv->type == META_COMP_WINDOW_TOOLTIP ||
+       priv->type == META_COMP_WINDOW_NOTIFICATION ||
+       priv->type == META_COMP_WINDOW_COMBO ||
+       priv->type == META_COMP_WINDOW_DND ||
+       priv->type == META_COMP_WINDOW_OVERRIDE_OTHER))
     {
       clutter_actor_hide (CLUTTER_ACTOR (cw));
     }
 }
 
-
 static void
-add_win (MetaScreen *screen, MetaWindow *window, Window xwindow)
+add_win (MetaWindow *window)
 {
+  MetaScreen		*screen = meta_window_get_screen (window);
   MetaDisplay           *display = meta_screen_get_display (screen);
   MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
   MutterWindow          *cw;
   MutterWindowPrivate   *priv;
-  Display               *xdisplay = meta_display_get_xdisplay (display);
-  XWindowAttributes      attrs;
-  gulong                 events_needed;
+  MetaFrame		*frame;
+  Window		 top_window;
+  XWindowAttributes	 attrs;
+  
+  g_return_if_fail (info != NULL);
 
-  /* Note: this blacklist internal windows is copied from screen.c
-   * Ideally add_win shouldn't be driven by CreateNotify events and
-   * should instead be an event directly from metacity core. */
-  if (xwindow == screen->no_focus_window ||
-      xwindow == screen->flash_window ||
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-      xwindow == screen->wm_cm_selection_window ||
-      xwindow == screen->guard_window ||
-#endif
-      xwindow == screen->wm_sn_selection_window) {
-      meta_verbose ("Not managing our own windows\n");
-      return;
-    }
+  frame = meta_window_get_frame (window);
+  if (frame)
+    top_window = meta_frame_get_xwindow (frame);
+  else
+    top_window = meta_window_get_xwindow (window);
 
-  if (info == NULL)
+  meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);
+
+  /* FIXME: Remove the redundant data we store in cw->priv->attrs, and
+   * simply query metacity core for the data. */
+  if (!XGetWindowAttributes (display->xdisplay, top_window, &attrs))
     return;
 
-  if (xwindow == info->output)
-    return;
-
-  if (!XGetWindowAttributes (xdisplay, xwindow, &attrs))
-    return;
-
-  /*
-   * If Metacity has decided not to manage this window then the input events
-   * won't have been set on the window
-   */
-  events_needed = PropertyChangeMask | SubstructureNotifyMask;
-
-  /*
-   * Need ConfigureNotify for override windows.
-   */
-  if (!window)
-    events_needed |= StructureNotifyMask;
-
-  /*
-   * Check the event mask contains all we need.
-   */
-  if ((attrs.your_event_mask & events_needed) != events_needed)
-    {
-      gulong event_mask;
-      event_mask = attrs.your_event_mask | events_needed;
-      XSelectInput (xdisplay, xwindow, event_mask);
-    }
-
-  meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint) xwindow);
-
   cw = g_object_new (MUTTER_TYPE_COMP_WINDOW,
 		     "meta-window",         window,
-		     "x-window",            xwindow,
+		     "x-window",            top_window,
 		     "meta-screen",         screen,
 		     "x-window-attributes", &attrs,
 		     NULL);
@@ -1297,51 +1196,21 @@ add_win (MetaScreen *screen, MetaWindow *window, Window xwindow)
 
   if (priv->type == META_COMP_WINDOW_DOCK)
     {
-      meta_verbose ("Appending 0x%x to dock windows\n", (guint)xwindow);
+      meta_verbose ("Appending 0x%x to dock windows\n", (guint)top_window);
       info->dock_windows = g_slist_append (info->dock_windows, cw);
     }
 
-  meta_verbose ("added 0x%x (%p) type:", (guint)xwindow, cw);
-#if 0
+  meta_verbose ("added 0x%x (%p) type:", (guint)top_window, cw);
 
-  switch (cw->type)
-    {
-    case META_COMP_WINDOW_NORMAL:
-      printf("normal"); break;
-    case META_COMP_WINDOW_DND:
-      printf("dnd"); break;
-    case META_COMP_WINDOW_DESKTOP:
-      printf("desktop"); break;
-    case META_COMP_WINDOW_DOCK:
-      printf("dock"); break;
-    case META_COMP_WINDOW_MENU:
-      printf("menu"); break;
-    case META_COMP_WINDOW_DROP_DOWN_MENU:
-      printf("menu"); break;
-    case META_COMP_WINDOW_TOOLTIP:
-      printf("tooltip"); break;
-    default:
-      printf("unknown");
-      break;
-    }
-
-  if (window && meta_window_get_frame (window))
-    printf(" *HAS FRAME* ");
-
-  printf("\n");
-#endif
-
-  /* Hang our compositor window state off the MetaWindow for fast retrieval
-   * if we have one */
-  if (window)
-    window->compositor_private = cw;
+  /* Hang our compositor window state off the MetaWindow for fast retrieval */
+  meta_window_set_compositor_private (window, 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);
+  info->windows = g_list_append (info->windows, cw);
+  g_hash_table_insert (info->windows_by_xid, (gpointer) top_window, cw);
 
   if (priv->attrs.map_state == IsViewable)
     {
@@ -1349,19 +1218,21 @@ add_win (MetaScreen *screen, MetaWindow *window, Window xwindow)
       priv->attrs.map_state = IsUnmapped;
       map_win (cw);
     }
+
+  sync_actor_stacking (info->windows);
 }
 
 static void
 repair_win (MutterWindow *cw)
 {
   MutterWindowPrivate *priv     = cw->priv;
-  MetaScreen            *screen   = priv->screen;
-  MetaDisplay           *display  = meta_screen_get_display (screen);
-  Display               *xdisplay = meta_display_get_xdisplay (display);
-  MetaCompScreen        *info     = meta_screen_get_compositor_data (screen);
-  Mutter                *compositor;
-  Window                 xwindow  = priv->xwindow;
-  gboolean               full     = FALSE;
+  MetaScreen          *screen   = priv->screen;
+  MetaDisplay         *display  = meta_screen_get_display (screen);
+  Display             *xdisplay = meta_display_get_xdisplay (display);
+  MetaCompScreen      *info     = meta_screen_get_compositor_data (screen);
+  Mutter              *compositor;
+  Window               xwindow  = priv->xwindow;
+  gboolean             full     = FALSE;
 
   if (xwindow == meta_screen_get_xroot (screen) ||
       xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
@@ -1486,83 +1357,6 @@ repair_win (MutterWindow *cw)
   priv->needs_repair = FALSE;
 }
 
-
-static void
-process_create (Mutter *compositor,
-                XCreateWindowEvent    *event,
-                MetaWindow            *window)
-{
-  MetaScreen   *screen;
-  Window        xwindow = event->window;
-  MutterWindow *cw;
-
-  screen = meta_display_screen_for_root (compositor->display, event->parent);
-
-  if (screen == NULL)
-    return;
-
-  /*
-   * This is quite silly as we end up creating windows as then immediatly
-   * destroying them as they (likely) become framed and thus reparented.
-   */
-  cw = find_window_for_screen (screen, xwindow);
-
-  if (!cw && window)
-    {
-      xwindow = meta_window_get_xwindow (window);
-
-      cw = find_window_for_screen (screen, xwindow);
-    }
-
-  if (cw)
-    {
-      destroy_win (cw, TRUE);
-    }
-
-  add_win (screen, window, event->window);
-}
-
-static void
-process_reparent (Mutter *compositor,
-                  XReparentEvent        *event,
-                  MetaWindow            *window)
-{
-  MetaScreen   *screen;
-  MutterWindow *cw;
-  Window        xwindow = event->window;
-  gboolean      viewable = FALSE;
-
-  screen = meta_display_screen_for_root (compositor->display, event->parent);
-
-  if (!screen)
-    return;
-
-  if (window)
-    cw = window->compositor_private;
-  else
-    cw = find_window_for_screen (screen, xwindow);
-
-  if (cw)
-    {
-      viewable = (cw->priv->attrs.map_state == IsViewable);
-      destroy_win (cw, TRUE);
-    }
-
-  add_win (screen, window, event->window);
-}
-
-static void
-process_destroy (Mutter *compositor, XDestroyWindowEvent *event)
-{
-  MutterWindow *cw =
-    find_window_in_display (compositor->display, event->window);
-
-  if (!cw)
-    return;
-
-  destroy_win (cw, FALSE);
-}
-
 static void
 process_damage (Mutter *compositor,
                 XDamageNotifyEvent    *event)
@@ -1595,7 +1389,7 @@ process_damage (Mutter *compositor,
   if (XCheckTypedWindowEvent (dpy, drawable, DestroyNotify, &next))
     {
       priv->destroy_pending = TRUE;
-      destroy_win (cw, FALSE);
+      destroy_win (cw);
       return;
     }
 
@@ -1641,11 +1435,13 @@ process_shape (Mutter	    *compositor,
 {
   MutterWindow *cw = find_window_in_display (compositor->display,
                                              event->window);
-  MutterWindowPrivate *priv = cw->priv;
+  MutterWindowPrivate *priv;
 
   if (cw == NULL)
     return;
 
+  priv = cw->priv;
+
   if (event->kind == ShapeBounding)
     {
       priv->shaped = event->shaped;
@@ -1674,9 +1470,7 @@ process_configure_notify (Mutter  *compositor,
 
   if (cw)
     {
-      resize_win (cw,
-                  event->x, event->y, event->width, event->height,
-                  event->border_width, event->override_redirect);
+      sync_actor_position (cw);
     }
   else
     {
@@ -1698,7 +1492,7 @@ process_configure_notify (Mutter  *compositor,
 
 	      meta_screen_get_size (screen, &width, &height);
 	      clutter_actor_set_size (info->stage, width, height);
-
+	      
 	      meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
 			    meta_screen_get_screen_number (screen),
 			    width, height);
@@ -1710,60 +1504,6 @@ process_configure_notify (Mutter  *compositor,
     }
 }
 
-static void
-process_unmap (Mutter	    *compositor,
-               XUnmapEvent  *event)
-{
-  MutterWindow	*cw;
-  Window         xwin = event->window;
-  Display       *dpy = event->display;
-
-  if (event->from_configure)
-    {
-      /* Ignore unmap caused by parent's resize */
-      return;
-    }
-
-  cw = find_window_in_display (compositor->display, event->window);
-
-  if (cw)
-    {
-      XEvent next;
-      MutterWindowPrivate *priv = cw->priv;
-
-      if (priv->attrs.map_state == IsUnmapped || priv->destroy_pending)
-	return;
-
-      if (XCheckTypedWindowEvent (dpy, xwin, DestroyNotify, &next))
-	{
-	  priv->destroy_pending = TRUE;
-	  destroy_win (cw, FALSE);
-	  return;
-	}
-
-      unmap_win (cw);
-    }
-}
-
-static void
-process_map (Mutter     *compositor,
-             XMapEvent  *event,
-             MetaWindow *window)
-{
-  MutterWindow *cw;
-  Window        xwindow = event->window;
-
-  if (window)
-    cw = window->compositor_private;
-  else
-    cw = find_window_in_display (compositor->display, xwindow);
-
-  if (cw)
-    {
-      map_win (cw);
-    }
-}
-
 static void
 process_property_notify (Mutter		*compositor,
                          XPropertyEvent *event)
@@ -1912,7 +1652,7 @@ clutter_cmp_manage_screen (MetaCompositor *compositor,
   /* Check if the screen is already managed */
   if (meta_screen_get_compositor_data (screen))
     return;
-
+  
   meta_error_trap_push_with_return (display);
   XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
   XSync (xdisplay, FALSE);
@@ -1959,14 +1699,6 @@ clutter_cmp_manage_screen (MetaCompositor *compositor,
                 KeyPressMask | KeyReleaseMask);
 
   info->window_group = clutter_group_new ();
-#if 0
-  /*
-   * Fixed the property setting (g_object_set_property needs GValue,
-   * but setting this breaks everything, so it is disabled.
-   */
-  g_object_set (G_OBJECT (info->window_group),
-                "show-on-set-parent", FALSE, NULL);
-#endif
   info->overlay_group = clutter_group_new ();
   info->hidden_group = clutter_group_new ();
 
@@ -2003,27 +1735,32 @@ clutter_cmp_unmanage_screen (MetaCompositor *compositor,
 
 static void
 clutter_cmp_add_window (MetaCompositor    *compositor,
-                        MetaWindow        *window,
-                        Window             xwindow,
-                        XWindowAttributes *attrs)
+                        MetaWindow        *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  Mutter *xrc = (Mutter *) compositor;
-  MetaScreen            *screen = meta_screen_for_x_screen (attrs->screen);
+  MetaScreen *screen = meta_window_get_screen (window);
+  MetaDisplay *display = meta_screen_get_display (screen);
 
-  meta_error_trap_push (xrc->display);
+  meta_error_trap_push (display);
 
-  add_win (screen, window, xwindow);
-  meta_error_trap_pop (xrc->display, FALSE);
+  add_win (window);
+
+  meta_error_trap_pop (display, FALSE);
 #endif
 }
 
 static void
 clutter_cmp_remove_window (MetaCompositor *compositor,
-                           Window          xwindow)
+                           MetaWindow     *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
+  MutterWindow         *cw     = NULL;
+  
+  cw = meta_window_get_compositor_private (window);
+  if (!cw)
+    return;
 
+  destroy_win (cw);
 #endif
 }
 
@@ -2099,29 +1836,6 @@ clutter_cmp_process_event (MetaCompositor *compositor,
       process_property_notify (xrc, (XPropertyEvent *) event);
       break;
 
-    case Expose:
-      break;
-
-    case UnmapNotify:
-      process_unmap (xrc, (XUnmapEvent *) event);
-      break;
-
-    case MapNotify:
-      process_map (xrc, (XMapEvent *) event, window);
-      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)
         {
@@ -2131,12 +1845,6 @@ clutter_cmp_process_event (MetaCompositor *compositor,
       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;
     }
 
@@ -2167,43 +1875,42 @@ clutter_cmp_set_active_window (MetaCompositor *compositor,
 }
 
 static void
-clutter_cmp_destroy_window (MetaCompositor *compositor,
-                            MetaWindow     *window)
+clutter_cmp_map_window (MetaCompositor *compositor, MetaWindow *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  MutterWindow         *cw     = NULL;
-  MetaScreen           *screen = meta_window_get_screen (window);
-  MetaFrame            *f      = meta_window_get_frame (window);
-  Window                xwindow;
-
-  /* Chances are we actually get the window frame here */
-  xwindow = f ? meta_frame_get_xwindow (f) : meta_window_get_xwindow (window);
-
-  cw = find_window_for_screen (screen, xwindow);
-
+  MutterWindow *cw = meta_window_get_compositor_private (window);
   if (!cw)
     return;
-
-  destroy_win (cw, FALSE);
+  
+  map_win (cw);
 #endif
 }
 
 static void
-clutter_cmp_minimize_window (MetaCompositor *compositor, MetaWindow *window)
+clutter_cmp_unmap_window (MetaCompositor *compositor, MetaWindow *window)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  MutterWindow *cw;
-  MetaCompScreen *info;
-  MetaScreen     *screen;
-  MetaFrame      *f = meta_window_get_frame (window);
+  MutterWindow *cw = meta_window_get_compositor_private (window);
+  if (!cw)
+    return;
 
-  screen = meta_window_get_screen (window);
-  info = meta_screen_get_compositor_data (screen);
+  unmap_win (cw);
+#endif
+}
+
+static void
+clutter_cmp_minimize_window (MetaCompositor *compositor,
+			     MetaWindow	    *window,
+			     MetaRectangle  *window_rect,
+			     MetaRectangle  *icon_rect)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MutterWindow	 *cw = meta_window_get_compositor_private (window);
+  MetaScreen	 *screen = meta_window_get_screen (window);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info);
 
-  /* Chances are we actually get the window frame here */
-  cw = find_window_for_screen (screen,
-                               f ? meta_frame_get_xwindow (f) :
-                               meta_window_get_xwindow (window));
   if (!cw)
     return;
 
@@ -2215,8 +1922,8 @@ clutter_cmp_minimize_window (MetaCompositor *compositor, MetaWindow *window)
 
   if (!info->plugin_mgr ||
       !mutter_plugin_manager_event_simple (info->plugin_mgr,
-				cw,
-				MUTTER_PLUGIN_MINIMIZE))
+					   cw,
+					   MUTTER_PLUGIN_MINIMIZE))
     {
       cw->priv->is_minimized = TRUE;
       cw->priv->minimize_in_progress--;
@@ -2225,22 +1932,59 @@ clutter_cmp_minimize_window (MetaCompositor *compositor, MetaWindow *window)
 }
 
 static void
-clutter_cmp_maximize_window (MetaCompositor *compositor, MetaWindow *window,
-			     gint x, gint y, gint width, gint height)
+clutter_cmp_unminimize_window (MetaCompositor *compositor,
+			       MetaWindow     *window,
+			       MetaRectangle  *window_rect,
+			       MetaRectangle  *icon_rect)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  MutterWindow *cw;
-  MetaCompScreen *info;
-  MetaScreen     *screen;
-  MetaFrame      *f = meta_window_get_frame (window);
+#if 0
+  MutterWindow	 *cw = meta_window_get_compositor_private (window);
+  MetaScreen	 *screen = meta_window_get_screen (window);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
 
-  screen = meta_window_get_screen (window);
-  info = meta_screen_get_compositor_data (screen);
+  g_return_if_fail (info);
+
+  if (!cw)
+    return;
+
+  /*
+   * If there is a plugin manager, try to run an effect; if no effect is
+   * executed, hide the actor.
+   */
+  cw->priv->unminimize_in_progress++;
+
+  if (!info->plugin_mgr ||
+      !mutter_plugin_manager_event_simple (info->plugin_mgr,
+					   cw,
+					   MUTTER_PLUGIN_UNMINIMIZE))
+    {
+      cw->priv->is_minimized = TRUE;
+      cw->priv->minimize_in_progress--;
+    }
+#else
+  MutterWindow	 *cw = meta_window_get_compositor_private (window);
+  if (!cw)
+    return;
+
+  map_win (cw);
+#endif
+#endif
+}
+
+
+static void
+clutter_cmp_maximize_window (MetaCompositor *compositor,
+			     MetaWindow	    *window,
+			     MetaRectangle  *rect)
+{
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+  MutterWindow	 *cw = meta_window_get_compositor_private (window);
+  MetaScreen	 *screen = meta_window_get_screen (window);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+
+  g_return_if_fail (info);
 
-  /* Chances are we actually get the window frame here */
-  cw = find_window_for_screen (screen,
-                               f ? meta_frame_get_xwindow (f) :
-                               meta_window_get_xwindow (window));
   if (!cw)
     return;
 
@@ -2248,9 +1992,10 @@ clutter_cmp_maximize_window (MetaCompositor *compositor, MetaWindow *window,
 
   if (!info->plugin_mgr ||
       !mutter_plugin_manager_event_maximize (info->plugin_mgr,
-				cw,
-				MUTTER_PLUGIN_MAXIMIZE,
-				x, y, width, height))
+					     cw,
+					     MUTTER_PLUGIN_MAXIMIZE,
+					     rect->x, rect->y,
+					     rect->width, rect->height))
     {
       cw->priv->maximize_in_progress--;
     }
@@ -2258,22 +2003,17 @@ clutter_cmp_maximize_window (MetaCompositor *compositor, MetaWindow *window,
 }
 
 static void
-clutter_cmp_unmaximize_window (MetaCompositor *compositor, MetaWindow *window,
-			       gint x, gint y, gint width, gint height)
+clutter_cmp_unmaximize_window (MetaCompositor *compositor,
+			       MetaWindow     *window,
+			       MetaRectangle  *rect)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
-  MutterWindow *cw;
-  MetaCompScreen *info;
-  MetaScreen     *screen;
-  MetaFrame      *f = meta_window_get_frame (window);
+  MutterWindow	 *cw = meta_window_get_compositor_private (window);
+  MetaScreen	 *screen = meta_window_get_screen (window);
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
 
-  screen = meta_window_get_screen (window);
-  info = meta_screen_get_compositor_data (screen);
+  g_return_if_fail (info);
 
-  /* Chances are we actually get the window frame here */
-  cw = find_window_for_screen (screen,
-                               f ? meta_frame_get_xwindow (f) :
-                               meta_window_get_xwindow (window));
   if (!cw)
     return;
 
@@ -2281,9 +2021,10 @@ clutter_cmp_unmaximize_window (MetaCompositor *compositor, MetaWindow *window,
 
   if (!info->plugin_mgr ||
       !mutter_plugin_manager_event_maximize (info->plugin_mgr,
-				cw,
-				MUTTER_PLUGIN_UNMAXIMIZE,
-				x, y, width, height))
+					     cw,
+					     MUTTER_PLUGIN_UNMAXIMIZE,
+					     rect->x, rect->y,
+					     rect->width, rect->height))
     {
       cw->priv->unmaximize_in_progress--;
     }
@@ -2389,6 +2130,21 @@ clutter_cmp_switch_workspace (MetaCompositor *compositor,
 #endif
 }
 
+static void
+sync_actor_stacking (GList *windows)
+{
+  GList *tmp;
+  
+  /* NB: The first entry in the list is stacked the lowest */
+
+  for (tmp = g_list_last (windows); tmp != NULL; tmp = tmp->prev)
+    {
+      MutterWindow *cw = tmp->data;
+
+      clutter_actor_lower_bottom (CLUTTER_ACTOR (cw));
+    }
+}
+
 static void
 clutter_cmp_sync_stack (MetaCompositor *compositor,
 			MetaScreen     *screen,
@@ -2396,6 +2152,8 @@ clutter_cmp_sync_stack (MetaCompositor *compositor,
 {
   GList *tmp;
   MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  
+  /* NB: The first entry in stack, is stacked the highest */
 
   for (tmp = stack; tmp != NULL; tmp = tmp->next)
     {
@@ -2409,12 +2167,11 @@ clutter_cmp_sync_stack (MetaCompositor *compositor,
 	  continue;
 	}
 
-      clutter_actor_lower_bottom (CLUTTER_ACTOR (cw));
-
-      /* Also maintain the order of info->windows */
       info->windows = g_list_remove (info->windows, (gconstpointer)cw);
       info->windows = g_list_prepend (info->windows, cw);
     }
+
+  sync_actor_stacking (info->windows);
 }
 
 static void
@@ -2426,7 +2183,8 @@ clutter_cmp_set_window_hidden (MetaCompositor *compositor,
   MutterWindow *cw = window->compositor_private;
   MetaCompScreen *info = meta_screen_get_compositor_data (screen);
 
-  g_return_if_fail (cw);
+  if (!cw)
+    return;
 
   if (hidden)
     {
@@ -2454,8 +2212,10 @@ static MetaCompositor comp_info = {
   clutter_cmp_process_event,
   clutter_cmp_get_window_pixmap,
   clutter_cmp_set_active_window,
-  clutter_cmp_destroy_window,
+  clutter_cmp_map_window,
+  clutter_cmp_unmap_window,
   clutter_cmp_minimize_window,
+  clutter_cmp_unminimize_window,
   clutter_cmp_maximize_window,
   clutter_cmp_unmaximize_window,
   clutter_cmp_update_workspace_geometry,
diff --git a/src/core/core.c b/src/core/core.c
index 303ddcde7..852c686fd 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -145,6 +145,13 @@ meta_core_get (Display *xdisplay,
             case META_WINDOW_DOCK:
             case META_WINDOW_TOOLBAR:
             case META_WINDOW_SPLASHSCREEN:
+	    case META_WINDOW_DROPDOWN_MENU:
+	    case META_WINDOW_POPUP_MENU:
+	    case META_WINDOW_TOOLTIP:
+	    case META_WINDOW_NOTIFICATION:
+	    case META_WINDOW_COMBO:
+	    case META_WINDOW_DND:
+	    case META_WINDOW_OVERRIDE_OTHER:
               /* No frame */
               base_type = META_FRAME_TYPE_LAST;
               break;
diff --git a/src/core/display.c b/src/core/display.c
index 7d4310d8d..2de879e48 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -2020,7 +2020,8 @@ event_callback (XEvent   *event,
                               "Window %s withdrawn\n",
                               window->desc);
 
-                  meta_effect_run_close (window, NULL, NULL);
+		  if (!window->override_redirect)
+		    meta_effect_run_close (window, NULL, NULL);
 
                   /* Unmanage withdrawn window */		  
                   window->withdrawn = TRUE;
@@ -2045,6 +2046,15 @@ event_callback (XEvent   *event,
         }
       break;
     case MapNotify:
+      /* NB: override redirect windows wont cause a map request so we
+       * watch out for map notifies against any root windows too if a
+       * compositor is enabled: */
+      if (display->compositor && window == NULL
+	  && meta_display_screen_for_root (display, event->xmap.event))
+        {
+          window = meta_window_new (display, event->xmap.window,
+                                    FALSE);
+        }
       break;
     case MapRequest:
       if (window == NULL)
@@ -2073,29 +2083,32 @@ event_callback (XEvent   *event,
     case ReparentNotify:
       break;
     case ConfigureNotify:
-      /* Handle screen resize */
-      {
-	MetaScreen *screen;
+      if (window && window->override_redirect)
+	meta_window_configure_notify (window, &event->xconfigure);
+      else
+	/* Handle screen resize */
+	{
+	  MetaScreen *screen;
 
-        screen = meta_display_screen_for_root (display,
-                                               event->xconfigure.window);
+	  screen = meta_display_screen_for_root (display,
+						 event->xconfigure.window);
 
-	if (screen != NULL)
-          {
+	  if (screen != NULL)
+	    {
 #ifdef HAVE_RANDR
-            /* do the resize the official way */
-            XRRUpdateConfiguration (event);
+	      /* do the resize the official way */
+	      XRRUpdateConfiguration (event);
 #else
-            /* poke around in Xlib */
-            screen->xscreen->width   = event->xconfigure.width;
-            screen->xscreen->height  = event->xconfigure.height;
+	      /* poke around in Xlib */
+	      screen->xscreen->width   = event->xconfigure.width;
+	      screen->xscreen->height  = event->xconfigure.height;
 #endif
-            
-            meta_screen_resize (screen, 
-                                event->xconfigure.width,
-                                event->xconfigure.height);
-          }
-      }
+	      
+	      meta_screen_resize (screen, 
+				  event->xconfigure.width,
+				  event->xconfigure.height);
+	    }
+	}
       break;
     case ConfigureRequest:
       /* This comment and code is found in both twm and fvwm */
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index 20f5a20b8..e62750d5c 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -862,7 +862,8 @@ meta_window_grab_keys (MetaWindow  *window)
   if (window->all_keys_grabbed)
     return;
 
-  if (window->type == META_WINDOW_DOCK)
+  if (window->type == META_WINDOW_DOCK
+      || window->override_redirect)
     {
       if (window->keys_grabbed)
         ungrab_all_keys (window->display, window->xwindow);
diff --git a/src/core/place.c b/src/core/place.c
index 1e5e6c150..600f92a4c 100644
--- a/src/core/place.c
+++ b/src/core/place.c
@@ -394,6 +394,14 @@ rectangle_overlaps_some_window (MetaRectangle *rect,
         case META_WINDOW_DESKTOP:
         case META_WINDOW_DIALOG:
         case META_WINDOW_MODAL_DIALOG:
+	/* override redirect window types: */
+	case META_WINDOW_DROPDOWN_MENU:
+	case META_WINDOW_POPUP_MENU:
+	case META_WINDOW_TOOLTIP:
+	case META_WINDOW_NOTIFICATION:
+	case META_WINDOW_COMBO:
+	case META_WINDOW_DND:
+	case META_WINDOW_OVERRIDE_OTHER:
           break;
 
         case META_WINDOW_NORMAL:
@@ -680,6 +688,14 @@ meta_window_place (MetaWindow        *window,
     case META_WINDOW_TOOLBAR:
     case META_WINDOW_MENU:
     case META_WINDOW_UTILITY:
+    /* override redirect window types: */
+    case META_WINDOW_DROPDOWN_MENU:
+    case META_WINDOW_POPUP_MENU:
+    case META_WINDOW_TOOLTIP:
+    case META_WINDOW_NOTIFICATION:
+    case META_WINDOW_COMBO:
+    case META_WINDOW_DND:
+    case META_WINDOW_OVERRIDE_OTHER:
       goto done_no_constraints;
     }
   
@@ -713,6 +729,14 @@ meta_window_place (MetaWindow        *window,
         case META_WINDOW_TOOLBAR:
         case META_WINDOW_MENU:
         case META_WINDOW_UTILITY:
+	/* override redirect window types: */
+	case META_WINDOW_DROPDOWN_MENU:
+	case META_WINDOW_POPUP_MENU:
+	case META_WINDOW_TOOLTIP:
+	case META_WINDOW_NOTIFICATION:
+	case META_WINDOW_COMBO:
+	case META_WINDOW_DND:
+	case META_WINDOW_OVERRIDE_OTHER:
           if (window->size_hints.flags & PPosition)
             {
               meta_topic (META_DEBUG_PLACEMENT,
diff --git a/src/core/screen.c b/src/core/screen.c
index d02536cd8..d18e45217 100644
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -790,20 +790,6 @@ meta_screen_manage_all_windows (MetaScreen *screen)
 
       window = meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
                                            &info->attrs);
-      if (info->xwindow == screen->no_focus_window ||
-          info->xwindow == screen->flash_window ||
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-          info->xwindow == screen->wm_cm_selection_window ||
-	  info->xwindow == screen->guard_window ||
-#endif
-          info->xwindow == screen->wm_sn_selection_window) {
-        meta_verbose ("Not managing our own windows\n");
-        continue;
-      }
-
-      if (screen->display->compositor)
-        meta_compositor_add_window (screen->display->compositor, window,
-                                    info->xwindow, &info->attrs);
     }
   meta_stack_thaw (screen->stack);
 
@@ -818,38 +804,20 @@ meta_screen_composite_all_windows (MetaScreen *screen)
 {
 #ifdef HAVE_COMPOSITE_EXTENSIONS
   MetaDisplay *display;
-  GList *windows, *list;
+  GSList *windows, *tmp;
 
   display = screen->display;
   if (!display->compositor)
     return;
 
-  windows = list_windows (screen);
-
+  windows = meta_display_list_windows (display);
+  for (tmp = windows; tmp != NULL; tmp = tmp->next)
+    meta_compositor_add_window (display->compositor, tmp->data);
+  g_slist_free (windows);
+  
+  /* trigger a stack_sync_to_server: */
   meta_stack_freeze (screen->stack);
-
-  for (list = windows; list != NULL; list = list->next)
-    {
-      WindowInfo *info = list->data;
-
-      if (info->xwindow == screen->no_focus_window ||
-          info->xwindow == screen->flash_window ||
-          info->xwindow == screen->wm_sn_selection_window ||
-          info->xwindow == screen->wm_cm_selection_window) {
-        meta_verbose ("Not managing our own windows\n");
-        continue;
-      }
-
-      meta_compositor_add_window (display->compositor,
-                                  meta_display_lookup_x_window (display,
-                                                                info->xwindow),
-				  info->xwindow, &info->attrs);
-    }
-
   meta_stack_thaw (screen->stack);
-
-  g_list_foreach (windows, (GFunc)g_free, NULL);
-  g_list_free (windows);
 #endif
 }
 
diff --git a/src/core/session.c b/src/core/session.c
index 0107b99c9..beec196ee 100644
--- a/src/core/session.c
+++ b/src/core/session.c
@@ -698,6 +698,20 @@ window_type_to_string (MetaWindowType type)
       return "splashscreen";
     case META_WINDOW_UTILITY:
       return "utility";
+    case META_WINDOW_DROPDOWN_MENU:
+      return "dropdown_menu";
+    case META_WINDOW_POPUP_MENU:
+      return "popup_menu";
+    case META_WINDOW_TOOLTIP:
+      return "tooltip";
+    case META_WINDOW_NOTIFICATION:
+      return "notification";
+    case META_WINDOW_COMBO:
+      return "combo";
+    case META_WINDOW_DND:
+      return "dnd";
+    case META_WINDOW_OVERRIDE_OTHER:
+      return "override_redirect";
     }
 
   return "";
diff --git a/src/core/stack.c b/src/core/stack.c
index c7b55ab0c..0937b155b 100644
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -265,6 +265,14 @@ get_standalone_layer (MetaWindow *window)
         layer = META_LAYER_DOCK;
       break;
 
+    case META_WINDOW_DROPDOWN_MENU:
+    case META_WINDOW_POPUP_MENU:
+    case META_WINDOW_TOOLTIP:
+    case META_WINDOW_NOTIFICATION:
+    case META_WINDOW_COMBO:
+    case META_WINDOW_OVERRIDE_OTHER:
+      layer = META_LAYER_OVERRIDE_REDIRECT;
+      break;
     default:       
       meta_window_foreach_transient (window,
                                      is_focused_foreach,
@@ -1062,6 +1070,7 @@ stack_sync_to_server (MetaStack *stack)
   GArray *root_children_stacked;
   GList *tmp;
   GArray *all_hidden;
+  int n_override_redirect = 0;
   
   /* Bail out if frozen */
   if (stack->freeze_count > 0)
@@ -1100,7 +1109,10 @@ stack_sync_to_server (MetaStack *stack)
 		  w->layer, w->stack_position, w->desc);
 
       /* remember, stacked is in reverse order (bottom to top) */
-      g_array_prepend_val (stacked, w->xwindow);
+      if (w->override_redirect)
+	n_override_redirect++;
+      else
+	g_array_prepend_val (stacked, w->xwindow);
       
       if (w->frame)
 	top_level_window = w->frame->xwindow;
@@ -1124,7 +1136,7 @@ stack_sync_to_server (MetaStack *stack)
   meta_pop_no_msg_prefix ();
 
   /* All windows should be in some stacking order */
-  if (stacked->len != stack->windows->len)
+  if (stacked->len != stack->windows->len - n_override_redirect)
     meta_bug ("%u windows stacked, %u windows exist in stack\n",
               stacked->len, stack->windows->len);
   
diff --git a/src/core/stack.h b/src/core/stack.h
index f96938971..2737969e5 100644
--- a/src/core/stack.h
+++ b/src/core/stack.h
@@ -49,14 +49,15 @@
  */
 typedef enum
 {
-  META_LAYER_DESKTOP        = 0,
-  META_LAYER_BOTTOM         = 1,
-  META_LAYER_NORMAL         = 2,
-  META_LAYER_TOP            = 4, /* Same as DOCK; see EWMH and bug 330717 */
-  META_LAYER_DOCK           = 4,
-  META_LAYER_FULLSCREEN     = 5,
-  META_LAYER_FOCUSED_WINDOW = 6,
-  META_LAYER_LAST           = 7
+  META_LAYER_DESKTOP	       = 0,
+  META_LAYER_BOTTOM	       = 1,
+  META_LAYER_NORMAL	       = 2,
+  META_LAYER_TOP	       = 4, /* Same as DOCK; see EWMH and bug 330717 */
+  META_LAYER_DOCK	       = 4,
+  META_LAYER_FULLSCREEN	       = 5,
+  META_LAYER_FOCUSED_WINDOW    = 6,
+  META_LAYER_OVERRIDE_REDIRECT = 7,
+  META_LAYER_LAST	       = 8
 } MetaStackLayer;
 
 /**
diff --git a/src/core/window-private.h b/src/core/window-private.h
index 6fea6871e..c64cefff0 100644
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -110,6 +110,9 @@ struct _MetaWindow
   /* Initial timestamp property */
   guint32 initial_timestamp;  
   
+  /* Whether this is an override redirect window or not */
+  guint override_redirect : 1;
+
   /* Whether we're maximized */
   guint maximized_horizontally : 1;
   guint maximized_vertically : 1;
diff --git a/src/core/window.c b/src/core/window.c
index b2a1b1217..32978f189 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -53,6 +53,10 @@
 #include <X11/extensions/shape.h>
 #endif
 
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+#include <X11/extensions/Xcomposite.h>
+#endif
+
 static int destroying_windows_disallowed = 0;
 
 
@@ -253,6 +257,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   Atom initial_props[N_INITIAL_PROPS];
   int i;
   gboolean has_shape;
+  MetaScreen *screen;
 
   g_assert (attrs != NULL);
   g_assert (N_INITIAL_PROPS == (int) G_N_ELEMENTS (initial_props));
@@ -266,12 +271,43 @@ meta_window_new_with_attrs (MetaDisplay       *display,
       return NULL;
     }
 
-  if (attrs->override_redirect)
+  screen = NULL;
+  for (tmp = display->screens; tmp != NULL; tmp = tmp->next)
     {
-      meta_verbose ("Deciding not to manage override_redirect window 0x%lx\n", xwindow);
-      return NULL;
+      MetaScreen *scr = tmp->data;
+
+      if (scr->xroot == attrs->root)
+        {
+          screen = tmp->data;
+          break;
+        }
     }
   
+  g_assert (screen);
+  
+  /* A black list of override redirect windows that we don't need to manage: */
+  if (attrs->override_redirect &&
+      (xwindow == screen->no_focus_window ||
+       xwindow == screen->flash_window ||
+       xwindow == screen->wm_sn_selection_window ||
+       attrs->class == InputOnly ||
+       /* any windows created via meta_create_offscreen_window: */
+       (attrs->x == -100 && attrs->y == -100
+	&& attrs->width == 1 && attrs->height == 1) ||
+#ifdef HAVE_COMPOSITE_EXTENSIONS
+       xwindow == screen->wm_cm_selection_window ||
+       xwindow == screen->guard_window ||
+       (display->compositor &&
+        xwindow == XCompositeGetOverlayWindow (display->xdisplay,
+					       screen->xroot)
+       )
+#endif
+      )
+     ) {
+    meta_verbose ("Not managing our own windows\n");
+    return NULL;
+  }
+
   /* Grab server */
   meta_display_grab (display);
   meta_error_trap_push (display); /* Push a trap over all of window
@@ -330,6 +366,8 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   event_mask =
     PropertyChangeMask | EnterWindowMask | LeaveWindowMask |
     FocusChangeMask | ColormapChangeMask;
+  if (attrs->override_redirect)
+    event_mask |= StructureNotifyMask;
 
   XSelectInput (display->xdisplay, xwindow, event_mask);
 
@@ -384,8 +422,6 @@ meta_window_new_with_attrs (MetaDisplay       *display,
       return NULL;
     }
 
-  g_assert (!attrs->override_redirect);
-  
   window = g_new (MetaWindow, 1);
 
   window->constructing = TRUE;
@@ -408,25 +444,12 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   window->sync_request_time.tv_usec = 0;
 #endif
   
-  window->screen = NULL;
-  tmp = display->screens;
-  while (tmp != NULL)
-    {
-      MetaScreen *scr = tmp->data;
-
-      if (scr->xroot == attrs->root)
-        {
-          window->screen = tmp->data;
-          break;
-        }
-      
-      tmp = tmp->next;
-    }
-  
-  g_assert (window->screen);
+  window->screen = screen;
 
   window->desc = g_strdup_printf ("0x%lx", window->xwindow);
 
+  window->override_redirect = attrs->override_redirect;
+
   /* avoid tons of stack updates */
   meta_stack_freeze (window->screen->stack);
 
@@ -608,10 +631,12 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   
   meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS);
   
-  update_sm_hints (window); /* must come after transient_for */
+  if (!window->override_redirect)
+    update_sm_hints (window); /* must come after transient_for */
   update_role (window);
   update_net_wm_type (window);
-  meta_window_update_icon_now (window);
+  if (!window->override_redirect)
+    meta_window_update_icon_now (window);
 
   if (window->initially_iconic)
     {
@@ -672,14 +697,15 @@ meta_window_new_with_attrs (MetaDisplay       *display,
     meta_window_ensure_frame (window);
 
   meta_window_grab_keys (window);
-  if (window->type != META_WINDOW_DOCK)
+  if (window->type != META_WINDOW_DOCK && !window->override_redirect)
     {
       meta_display_grab_window_buttons (window->display, window->xwindow);
       meta_display_grab_focus_window_button (window->display, window);
     }
 
   if (window->type == META_WINDOW_DESKTOP ||
-      window->type == META_WINDOW_DOCK)
+      window->type == META_WINDOW_DOCK ||
+      window->override_redirect)
     {
       /* Change the default, but don't enforce this if the user
        * focuses the dock/desktop and unsticks it using key shortcuts.
@@ -759,7 +785,8 @@ meta_window_new_with_attrs (MetaDisplay       *display,
     }
   
   /* for the various on_all_workspaces = TRUE possible above */
-  meta_window_set_current_workspace_hint (window);
+  if (!window->override_redirect)
+    meta_window_set_current_workspace_hint (window);
   
   meta_window_update_struts (window);
 
@@ -800,11 +827,14 @@ meta_window_new_with_attrs (MetaDisplay       *display,
       }
   }
   
-  /* FIXME we have a tendency to set this then immediately
-   * change it again.
-   */
-  set_wm_state (window, window->iconic ? IconicState : NormalState);
-  set_net_wm_state (window);
+  if (!window->override_redirect)
+    {
+      /* FIXME we have a tendency to set this then immediately
+       * change it again.
+       */
+      set_wm_state (window, window->iconic ? IconicState : NormalState);
+      set_net_wm_state (window);
+    }
 
   /* Sync stack changes */
   meta_stack_thaw (window->screen->stack);
@@ -837,6 +867,9 @@ meta_window_new_with_attrs (MetaDisplay       *display,
  
   window->constructing = FALSE;
 
+  if (screen->display->compositor)
+    meta_compositor_add_window (screen->display->compositor, window);
+
   return window;
 }
 
@@ -988,7 +1021,7 @@ meta_window_free (MetaWindow  *window,
   meta_verbose ("Unmanaging 0x%lx\n", window->xwindow);
 
   if (window->display->compositor)
-    meta_compositor_destroy_window (window->display->compositor, window);
+    meta_compositor_remove_window (window->display->compositor, window);
   
   if (window->display->window_with_menu == window)
     {
@@ -1495,7 +1528,9 @@ implement_showing (MetaWindow *window,
           if (window->display->compositor)
             {
               meta_compositor_minimize_window (window->display->compositor,
-                                               window);
+                                               window,
+					       &window_rect,
+					       &icon_rect);
               finish_minimize (window);
             }
           else
@@ -2001,6 +2036,14 @@ window_state_on_map (MetaWindow *window,
     case META_WINDOW_DESKTOP:
     case META_WINDOW_SPLASHSCREEN:
     case META_WINDOW_MENU:
+    /* override redirect types: */
+    case META_WINDOW_DROPDOWN_MENU:
+    case META_WINDOW_POPUP_MENU:
+    case META_WINDOW_TOOLTIP:
+    case META_WINDOW_NOTIFICATION:
+    case META_WINDOW_COMBO:
+    case META_WINDOW_DND:
+    case META_WINDOW_OVERRIDE_OTHER:
       /* don't focus any of these; places_on_top may be irrelevant for some of
        * these (e.g. dock)--but you never know--the focus window might also be
        * of the same type in some weird situation...
@@ -2274,22 +2317,33 @@ meta_window_show (MetaWindow *window)
             }
         }
 
-      if (did_show && window->was_minimized)
+      if (did_show)
 	{
-	  MetaRectangle window_rect;
 	  MetaRectangle icon_rect;
-	  
-	  window->was_minimized = FALSE;
-	  
-	  if (meta_window_get_icon_geometry (window, &icon_rect))
+
+	  if (window->was_minimized
+	      && meta_window_get_icon_geometry (window, &icon_rect))
 	    {
+	      MetaRectangle window_rect;
+	      
 	      meta_window_get_outer_rect (window, &window_rect);
 	      
-	      meta_effect_run_unminimize (window,
-					  &window_rect,
-					  &icon_rect,
-					  NULL, NULL);
+	      if (window->display->compositor)
+		meta_compositor_unminimize_window (window->display->compositor,
+						   window,
+						   &window_rect,
+						   &icon_rect);
+	      else
+		meta_effect_run_unminimize (window,
+					    &window_rect,
+					    &icon_rect,
+					    NULL, NULL);
 	    }
+	  else
+	    meta_compositor_map_window (window->display->compositor,
+					window);
+
+	  window->was_minimized = FALSE;
 	}
       
       if (window->iconic)
@@ -2373,10 +2427,16 @@ meta_window_hide (MetaWindow *window)
 					 window->hidden);
       meta_stack_thaw (window->screen->stack);
 
+      meta_compositor_unmap_window (window->display->compositor,
+				    window);
+
       did_hide = TRUE;
     }
   else
     {
+      meta_compositor_unmap_window (window->display->compositor,
+				    window);
+
       if (window->frame && window->frame->mapped)
         {
           meta_topic (META_DEBUG_WINDOW_STATE, "Frame actually needs unmap\n");
@@ -2650,14 +2710,14 @@ meta_window_maximize (MetaWindow        *window,
 
       if (window->display->compositor)
         {
+	  MetaRectangle window_rect;
+
           meta_window_move_resize_now (window);
 
+	  meta_window_get_outer_rect (window, &window_rect);
           meta_compositor_maximize_window (window->display->compositor,
                                            window,
-                                           window->frame->rect.x,
-                                           window->frame->rect.y,
-                                           window->frame->rect.width,
-                                           window->frame->rect.height);
+					   &window_rect);
         }
       else
         {
@@ -2763,6 +2823,8 @@ meta_window_unmaximize (MetaWindow        *window,
 
       if (window->display->compositor)
         {
+	  MetaRectangle window_rect;
+
           meta_window_move_resize (window,
                                    FALSE,
                                    target_rect.x,
@@ -2771,12 +2833,11 @@ meta_window_unmaximize (MetaWindow        *window,
                                    target_rect.height);
           meta_window_move_resize_now (window);
 
+	  meta_window_get_outer_rect (window, &window_rect);
+
           meta_compositor_unmaximize_window (window->display->compositor,
-                                           window,
-                                           window->frame->rect.x,
-                                           window->frame->rect.y,
-                                           window->frame->rect.width,
-                                           window->frame->rect.height);
+					     window,
+					     &window_rect);
         }
       else
         {
@@ -3803,6 +3864,22 @@ idle_move_resize (gpointer data)
   return FALSE;
 }
 
+/* This is used to notify us of an unrequested configuration
+ * (only applicable to override redirect windows) */
+void
+meta_window_configure_notify (MetaWindow *window, XConfigureEvent *event)
+{
+  g_assert (window->override_redirect);
+  g_assert (window->frame == NULL);
+
+  window->rect.x = event->x;
+  window->rect.y = event->y;
+  window->rect.width = event->width;
+  window->rect.height = event->height;
+  if (!event->override_redirect && !event->send_event)
+    meta_warning ("Unhandled change of windows override redirect status\n");
+}
+
 void
 meta_window_get_position (MetaWindow  *window,
                           int         *x,
@@ -5847,10 +5924,18 @@ update_net_wm_type (MetaWindow *window)
           atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DOCK ||
           atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLBAR ||
           atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_MENU ||
-          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
-          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL ||
           atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY ||
-          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG ||
+          atoms[i] ==
+	    window->display->atom__NET_WM_WINDOW_TYPE_DROPDOWN_MENU ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_POPUP_MENU ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_TOOLTIP ||
+          atoms[i] ==
+	    window->display->atom__NET_WM_WINDOW_TYPE_NOTIFICATION ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_COMBO ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_DND ||
+          atoms[i] == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
         {
           window->type_atom = atoms[i];
           break;
@@ -6177,7 +6262,24 @@ recalc_window_type (MetaWindow *window)
 
   old_type = window->type;
   
-  if (window->type_atom != None)
+  if (window->override_redirect)
+    {
+      if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DROPDOWN_MENU)
+        window->type = META_WINDOW_DROPDOWN_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_POPUP_MENU)
+        window->type = META_WINDOW_POPUP_MENU;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_TOOLTIP)
+        window->type = META_WINDOW_TOOLTIP;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NOTIFICATION)
+        window->type = META_WINDOW_NOTIFICATION;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_COMBO)
+        window->type = META_WINDOW_COMBO;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DND)
+        window->type = META_WINDOW_DND;
+      else
+	window->type = META_WINDOW_OVERRIDE_OTHER;
+    }
+  else if (window->type_atom != None)
     {
       if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DESKTOP)
         window->type = META_WINDOW_DESKTOP;
@@ -6187,14 +6289,14 @@ recalc_window_type (MetaWindow *window)
         window->type = META_WINDOW_TOOLBAR;
       else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_MENU)
         window->type = META_WINDOW_MENU;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
-        window->type = META_WINDOW_DIALOG;
-      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
-        window->type = META_WINDOW_NORMAL;
       else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_UTILITY)
         window->type = META_WINDOW_UTILITY;
       else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_SPLASH)
         window->type = META_WINDOW_SPLASHSCREEN;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_DIALOG)
+        window->type = META_WINDOW_DIALOG;
+      else if (window->type_atom  == window->display->atom__NET_WM_WINDOW_TYPE_NORMAL)
+        window->type = META_WINDOW_NORMAL;
       else
         meta_bug ("Set a type atom for %s that wasn't handled in recalc_window_type\n",
                   window->desc);
@@ -6219,7 +6321,8 @@ recalc_window_type (MetaWindow *window)
     {
       recalc_window_features (window);
       
-      set_net_wm_state (window);
+      if (!window->override_redirect)
+	set_net_wm_state (window);
       
       /* Update frame */
       if (window->decorated)
@@ -6370,12 +6473,14 @@ recalc_window_features (MetaWindow *window)
     window->decorated = FALSE;
 
   if (window->type == META_WINDOW_DESKTOP ||
-      window->type == META_WINDOW_DOCK)
+      window->type == META_WINDOW_DOCK ||
+      window->override_redirect)
     window->always_sticky = TRUE;
   
   if (window->type == META_WINDOW_DESKTOP ||
       window->type == META_WINDOW_DOCK ||
-      window->type == META_WINDOW_SPLASHSCREEN)
+      window->type == META_WINDOW_SPLASHSCREEN ||
+      window->override_redirect)
     {
       window->decorated = FALSE;
       window->has_close_func = FALSE;
@@ -6463,6 +6568,13 @@ recalc_window_features (MetaWindow *window)
     case META_WINDOW_MENU:
     case META_WINDOW_UTILITY:
     case META_WINDOW_SPLASHSCREEN:
+    case META_WINDOW_DROPDOWN_MENU:
+    case META_WINDOW_POPUP_MENU:
+    case META_WINDOW_TOOLTIP:
+    case META_WINDOW_NOTIFICATION:
+    case META_WINDOW_COMBO:
+    case META_WINDOW_DND:
+    case META_WINDOW_OVERRIDE_OTHER:
       window->skip_taskbar = TRUE;
       window->skip_pager = TRUE;
       break;
@@ -8340,3 +8452,20 @@ meta_window_get_description (MetaWindow *window)
 
   return window->desc;
 }
+
+void *
+meta_window_get_compositor_private (MetaWindow *window)
+{
+  if (!window)
+    return NULL;
+  return window->compositor_private;
+}
+
+void
+meta_window_set_compositor_private (MetaWindow *window, void *priv)
+{
+  if (!window)
+    return;
+  window->compositor_private = priv;
+}
+
diff --git a/src/include/atomnames.h b/src/include/atomnames.h
index 9b7121684..6b1dd86c8 100644
--- a/src/include/atomnames.h
+++ b/src/include/atomnames.h
@@ -106,7 +106,15 @@ item(_NET_WM_WINDOW_TYPE_DESKTOP)
 item(_NET_WM_WINDOW_TYPE_DOCK)
 item(_NET_WM_WINDOW_TYPE_TOOLBAR)
 item(_NET_WM_WINDOW_TYPE_MENU)
+item(_NET_WM_WINDOW_TYPE_UTILITY)
+item(_NET_WM_WINDOW_TYPE_SPLASH)
 item(_NET_WM_WINDOW_TYPE_DIALOG)
+item(_NET_WM_WINDOW_TYPE_DROPDOWN_MENU)
+item(_NET_WM_WINDOW_TYPE_POPUP_MENU)
+item(_NET_WM_WINDOW_TYPE_TOOLTIP)
+item(_NET_WM_WINDOW_TYPE_NOTIFICATION)
+item(_NET_WM_WINDOW_TYPE_COMBO)
+item(_NET_WM_WINDOW_TYPE_DND)
 item(_NET_WM_WINDOW_TYPE_NORMAL)
 item(_NET_WM_STATE_MODAL)
 item(_NET_CLIENT_LIST)
@@ -120,9 +128,6 @@ item(_NET_WM_MOVERESIZE)
 item(_NET_ACTIVE_WINDOW)
 item(_NET_WM_STRUT)
 item(_NET_WM_STATE_HIDDEN)
-item(_NET_WM_WINDOW_TYPE_UTILITY)
-item(_NET_WM_WINDOW_TYPE_SPLASH)
-item(_NET_WM_WINDOW_TYPE_DND)
 item(_NET_WM_STATE_FULLSCREEN)
 item(_NET_WM_PING)
 item(_NET_WM_PID)
diff --git a/src/include/compositor.h b/src/include/compositor.h
index 15ac36cf1..66f0088c4 100644
--- a/src/include/compositor.h
+++ b/src/include/compositor.h
@@ -32,24 +32,27 @@
 
 typedef enum _MetaCompWindowType
 {
-  /*
-   * Types shared with MetaWindow
-   */
-  META_COMP_WINDOW_NORMAL  = META_WINDOW_NORMAL,
-  META_COMP_WINDOW_DESKTOP = META_WINDOW_DESKTOP,
-  META_COMP_WINDOW_DOCK    = META_WINDOW_DOCK,
-  META_COMP_WINDOW_MENU    = META_WINDOW_MENU,
+  META_COMP_WINDOW_NORMAL = META_WINDOW_NORMAL,
+  META_COMP_WINDOW_DESKTOP =  META_WINDOW_DESKTOP,
+  META_COMP_WINDOW_DOCK = META_WINDOW_DOCK,
+  META_COMP_WINDOW_DIALOG = META_WINDOW_DIALOG,
+  META_COMP_WINDOW_MODAL_DIALOG = META_WINDOW_MODAL_DIALOG,
+  META_COMP_WINDOW_TOOLBAR = META_WINDOW_TOOLBAR,
+  META_COMP_WINDOW_MENU = META_WINDOW_MENU,
+  META_COMP_WINDOW_UTILITY = META_WINDOW_UTILITY,
+  META_COMP_WINDOW_SPLASHSCREEN = META_WINDOW_SPLASHSCREEN,
+
+  /* override redirect window types, */
+  META_COMP_WINDOW_DROPDOWN_MENU = META_WINDOW_DROPDOWN_MENU,
+  META_COMP_WINDOW_POPUP_MENU = META_WINDOW_POPUP_MENU,
+  META_COMP_WINDOW_TOOLTIP = META_WINDOW_TOOLTIP,
+  META_COMP_WINDOW_NOTIFICATION = META_WINDOW_NOTIFICATION,
+  META_COMP_WINDOW_COMBO = META_WINDOW_COMBO,
+  META_COMP_WINDOW_DND = META_WINDOW_DND,
+  META_COMP_WINDOW_OVERRIDE_OTHER = META_WINDOW_OVERRIDE_OTHER
 
-  /*
-   * Extended types that WM does not care about, but we do.
-   */
-  META_COMP_WINDOW_TOOLTIP = 0xf000,
-  META_COMP_WINDOW_DROP_DOWN_MENU,
-  META_COMP_WINDOW_DND,
-  META_COMP_WINDOW_OVERRIDE,
 } MetaCompWindowType;
 
-
 #ifdef WITH_CLUTTER
 extern int meta_compositor_can_use_clutter__;
 #endif
@@ -62,11 +65,9 @@ void meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                       MetaScreen     *screen);
 
 void meta_compositor_add_window (MetaCompositor    *compositor,
-                                 MetaWindow        *window,
-                                 Window             xwindow,
-                                 XWindowAttributes *attrs);
+                                 MetaWindow        *window);
 void meta_compositor_remove_window (MetaCompositor *compositor,
-                                    Window          xwindow);
+                                    MetaWindow     *window);
 
 void meta_compositor_set_updates (MetaCompositor *compositor,
                                   MetaWindow     *window,
@@ -94,28 +95,34 @@ void meta_compositor_free_window (MetaCompositor *compositor,
                                   MetaWindow *window);
 
 void
-meta_compositor_destroy_window (MetaCompositor *compositor,
-                                MetaWindow     *window);
+meta_compositor_map_window (MetaCompositor *compositor,
+			    MetaWindow	   *window);
+
+void
+meta_compositor_unmap_window (MetaCompositor *compositor,
+			      MetaWindow     *window);
 
 void
 meta_compositor_minimize_window (MetaCompositor *compositor,
-                                 MetaWindow     *window);
+                                 MetaWindow     *window,
+				 MetaRectangle	*window_rect,
+				 MetaRectangle  *icon_rect);
+
+void
+meta_compositor_unminimize_window (MetaCompositor *compositor,
+				   MetaWindow     *window,
+				   MetaRectangle  *window_rect,
+				   MetaRectangle  *icon_rect);
 
 void
 meta_compositor_maximize_window (MetaCompositor    *compositor,
                                  MetaWindow        *window,
-                                 int                x,
-                                 int                y,
-                                 int                width,
-                                 int                height);
+				 MetaRectangle	   *window_rect);
 
 void
 meta_compositor_unmaximize_window (MetaCompositor    *compositor,
                                    MetaWindow        *window,
-                                   int                x,
-                                   int                y,
-                                   int                width,
-                                   int                height);
+				   MetaRectangle     *window_rect);
 
 void
 meta_compositor_update_workspace_geometry (MetaCompositor *compositor,
@@ -138,7 +145,6 @@ meta_compositor_set_window_hidden (MetaCompositor *compositor,
 				   MetaScreen	  *screen,
 				   MetaWindow	  *window,
 				   gboolean	   hidden);
-
 #endif
 
 
diff --git a/src/include/window.h b/src/include/window.h
index 5bd0b35ec..f2242cf73 100644
--- a/src/include/window.h
+++ b/src/include/window.h
@@ -39,6 +39,15 @@ typedef enum
   META_WINDOW_MENU,
   META_WINDOW_UTILITY,
   META_WINDOW_SPLASHSCREEN,
+
+  /* override redirect window types: */
+  META_WINDOW_DROPDOWN_MENU,
+  META_WINDOW_POPUP_MENU,
+  META_WINDOW_TOOLTIP,
+  META_WINDOW_NOTIFICATION,
+  META_WINDOW_COMBO,
+  META_WINDOW_DND,
+  META_WINDOW_OVERRIDE_OTHER
 } MetaWindowType;
 
 typedef enum
@@ -72,4 +81,7 @@ void meta_window_change_workspace_by_index (MetaWindow *window,
                                             gint        space_index,
                                             gboolean    append,
                                             guint32     timestamp);
+void *meta_window_get_compositor_private (MetaWindow *window);
+void meta_window_set_compositor_private (MetaWindow *window, void *priv);
+void meta_window_configure_notify (MetaWindow *window, XConfigureEvent *event);
 #endif