window-actor: Don't do any special initialization in _new

https://bugzilla.gnome.org/show_bug.cgi?id=678989

src/compositor/compositor.c

@@ -150,10 +150,28 @@ add_win (MetaWindow *window)
 {
   MetaScreen		*screen = meta_window_get_screen (window);
   MetaCompScreen        *info = meta_screen_get_compositor_data (screen);
+  MetaWindowActor       *actor;
+  ClutterActor          *window_group;
 
   g_return_if_fail (info != NULL);
 
-  meta_window_actor_new (window);
+  actor = meta_window_actor_new (window);
+
+  window->core_actor = actor;
+
+  if (window->layer == META_LAYER_OVERRIDE_REDIRECT)
+    window_group = info->top_window_group;
+  else
+    window_group = info->window_group;
+  clutter_actor_add_child (window_group, CLUTTER_ACTOR (actor));
+
+  clutter_actor_set_reactive (CLUTTER_ACTOR (actor), TRUE);
+  clutter_actor_hide (CLUTTER_ACTOR (actor));
+
+  /* Initial position in the stack is arbitrary; stacking will be synced
+   * before we first paint.
+   */
+  info->windows = g_list_append (info->windows, actor);
 
   sync_actor_stacking (info);
 }
@@ -163,16 +181,13 @@ process_damage (MetaCompositor     *compositor,
                 XDamageNotifyEvent *event,
                 MetaWindow         *window)
 {
-  MetaWindowActor *window_actor;
+  GSList *iter;
 
   if (window == NULL)
     return;
 
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (window_actor == NULL)
-    return;
-
-  meta_window_actor_process_damage (window_actor, event);
+  for (iter = window->actors; iter != NULL; iter = iter->next)
+    meta_window_actor_process_damage (META_WINDOW_ACTOR (iter->data), event);
 }
 
 static void
@@ -180,24 +195,12 @@ process_property_notify (MetaCompositor	*compositor,
                          XPropertyEvent *event,
                          MetaWindow     *window)
 {
-  MetaWindowActor *window_actor;
-
-  if (window == NULL)
-    return;
-
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (window_actor == NULL)
+  if (window == NULL || window->core_actor == NULL)
     return;
 
   /* Check for the opacity changing */
   if (event->atom == compositor->atom_net_wm_window_opacity)
-    {
-      meta_window_actor_update_opacity (window_actor);
-      DEBUG_TRACE ("process_property_notify: net_wm_window_opacity\n");
-      return;
-    }
-
-  DEBUG_TRACE ("process_property_notify: unknown\n");
+    meta_window_actor_update_opacity (window->core_actor);
 }
 
 static Window
@@ -789,27 +792,30 @@ void
 meta_compositor_remove_window (MetaCompositor *compositor,
                                MetaWindow     *window)
 {
-  MetaWindowActor         *window_actor     = NULL;
   MetaScreen *screen;
   MetaCompScreen *info;
+  GSList *iter;
 
   DEBUG_TRACE ("meta_compositor_remove_window\n");
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (!window_actor)
-    return;
 
   screen = meta_window_get_screen (window);
   info = meta_screen_get_compositor_data (screen);
 
-  if (window_actor == info->unredirected_window)
+  if (window->core_actor == info->unredirected_window)
     {
-      meta_window_actor_set_redirected (window_actor, TRUE);
-      meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
-                                 NULL);
+      meta_window_actor_set_redirected (info->unredirected_window, TRUE);
+      meta_shape_cow_for_window (meta_window_get_screen (window), NULL);
       info->unredirected_window = NULL;
     }
 
-  meta_window_actor_destroy (window_actor);
+  window->core_actor = NULL;
+
+  for (iter = window->actors; iter != NULL; iter = iter->next)
+    {
+      MetaWindowActor *actor = META_WINDOW_ACTOR (iter->data);
+      meta_window_actor_destroy (actor);
+      info->windows = g_list_remove (info->windows, (gconstpointer) actor);
+    }
 }
 
 void
@@ -869,12 +875,10 @@ void
 meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                       MetaWindow     *window)
 {
-  MetaWindowActor *window_actor;
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (!window_actor)
-    return;
+  GSList *iter;
 
-  meta_window_actor_update_shape (window_actor);
+  for (iter = window->actors; iter != NULL; iter = iter->next)
+    meta_window_actor_update_shape (META_WINDOW_ACTOR (iter->data));
 }
 
 /* Clutter makes the assumption that there is only one X window
@@ -1037,12 +1041,8 @@ meta_compositor_show_window (MetaCompositor *compositor,
 			     MetaWindow	    *window,
                              MetaCompEffect  effect)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_show_window\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_show (window_actor, effect);
+  if (window->core_actor != NULL)
+    meta_window_actor_show (window->core_actor, effect);
 }
 
 void
@@ -1050,12 +1050,8 @@ meta_compositor_hide_window (MetaCompositor *compositor,
                              MetaWindow     *window,
                              MetaCompEffect  effect)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_hide_window\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_hide (window_actor, effect);
+  if (window->core_actor != NULL)
+    meta_window_actor_hide (window->core_actor, effect);
 }
 
 void
@@ -1064,12 +1060,8 @@ meta_compositor_maximize_window (MetaCompositor    *compositor,
 				 MetaRectangle	   *old_rect,
 				 MetaRectangle	   *new_rect)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_maximize_window\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_maximize (window_actor, old_rect, new_rect);
+  if (window->core_actor != NULL)
+    meta_window_actor_maximize (window->core_actor, old_rect, new_rect);
 }
 
 void
@@ -1078,12 +1070,8 @@ meta_compositor_unmaximize_window (MetaCompositor    *compositor,
 				   MetaRectangle     *old_rect,
 				   MetaRectangle     *new_rect)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_unmaximize_window\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_unmaximize (window_actor, old_rect, new_rect);
+  if (window->core_actor != NULL)
+    meta_window_actor_unmaximize (window->core_actor, old_rect, new_rect);
 }
 
 void
@@ -1259,7 +1247,7 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
       while (stack)
         {
           stack_window = stack->data;
-          stack_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (stack_window));
+          stack_actor = stack_window->core_actor;
           if (!stack_actor)
             {
               meta_verbose ("Failed to find corresponding MetaWindowActor "
@@ -1308,24 +1296,16 @@ void
 meta_compositor_window_mapped (MetaCompositor *compositor,
                                MetaWindow     *window)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_mapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_mapped (window_actor);
+  if (window->core_actor != NULL)
+    meta_window_actor_mapped (window->core_actor);
 }
 
 void
 meta_compositor_window_unmapped (MetaCompositor *compositor,
                                  MetaWindow     *window)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  DEBUG_TRACE ("meta_compositor_window_unmapped\n");
-  if (!window_actor)
-    return;
-
-  meta_window_actor_unmapped (window_actor);
+  if (window->core_actor != NULL)
+    meta_window_actor_unmapped (window->core_actor);
 }
 
 void
@@ -1333,17 +1313,8 @@ meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
                                       gboolean did_placement)
 {
-  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  MetaScreen      *screen = meta_window_get_screen (window);
-  MetaCompScreen  *info = meta_screen_get_compositor_data (screen);
-
-  DEBUG_TRACE ("meta_compositor_sync_window_geometry\n");
-  g_return_if_fail (info);
-
-  if (!window_actor)
-    return;
-
-  meta_window_actor_sync_actor_geometry (window_actor, did_placement);
+  if (window->core_actor != NULL)
+    meta_window_actor_sync_actor_geometry (window->core_actor, did_placement);
 }
 
 void

src/compositor/meta-background-actor.c

@@ -119,26 +119,6 @@ meta_background_actor_get_preferred_height (ClutterActor *actor,
     *natural_height_p = height;
 }
 
-static gboolean
-meta_background_actor_get_paint_volume (ClutterActor       *actor,
-                                        ClutterPaintVolume *volume)
-{
-  ClutterContent *content;
-  gfloat width, height;
-
-  content = clutter_actor_get_content (actor);
-
-  if (!content)
-    return FALSE;
-
-  clutter_content_get_preferred_size (content, &width, &height);
-
-  clutter_paint_volume_set_width (volume, width);
-  clutter_paint_volume_set_height (volume, height);
-
-  return TRUE;
-}
-
 static void
 meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 {
@@ -151,7 +131,6 @@ meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 
   actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
   actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
-  actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
 }
 
 static void

src/compositor/meta-window-actor.c

@@ -34,19 +34,11 @@
 #include "monitor-private.h"
 #include "meta-cullable.h"
 
-enum {
-  POSITION_CHANGED,
-  SIZE_CHANGED,
-  LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL] = {0};
-
+static void meta_window_actor_queue_create_pixmap (MetaWindowActor *self);
 
 struct _MetaWindowActorPrivate
 {
   MetaWindow       *window;
-  Window            xwindow;
   MetaScreen       *screen;
 
   ClutterActor     *actor;
@@ -155,8 +147,6 @@ struct _FrameData
 enum
 {
   PROP_META_WINDOW = 1,
-  PROP_META_SCREEN,
-  PROP_X_WINDOW,
   PROP_NO_SHADOW,
   PROP_SHADOW_CLASS
 };
@@ -225,33 +215,12 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
                                "MetaWindow",
                                "The displayed MetaWindow",
                                META_TYPE_WINDOW,
-                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
 
   g_object_class_install_property (object_class,
                                    PROP_META_WINDOW,
                                    pspec);
 
-  pspec = g_param_spec_pointer ("meta-screen",
-				"MetaScreen",
-				"MetaScreen",
-				G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
-
-  g_object_class_install_property (object_class,
-                                   PROP_META_SCREEN,
-                                   pspec);
-
-  pspec = g_param_spec_ulong ("x-window",
-			      "Window",
-			      "Window",
-			      0,
-			      G_MAXULONG,
-			      0,
-			      G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
-
-  g_object_class_install_property (object_class,
-                                   PROP_X_WINDOW,
-                                   pspec);
-
   pspec = g_param_spec_boolean ("no-shadow",
                                 "No shadow",
                                 "Do not add shaddow to this window",
@@ -271,19 +240,6 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
   g_object_class_install_property (object_class,
                                    PROP_SHADOW_CLASS,
                                    pspec);
-
-  signals[POSITION_CHANGED] =
-    g_signal_new ("position-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
-  signals[SIZE_CHANGED] =
-    g_signal_new ("size-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
 }
 
 static void
@@ -296,6 +252,9 @@ meta_window_actor_init (MetaWindowActor *self)
 						   MetaWindowActorPrivate);
   priv->opacity = 0xff;
   priv->shadow_class = NULL;
+
+  priv->last_width = -1;
+  priv->last_height = -1;
 }
 
 static void
@@ -305,11 +264,9 @@ window_decorated_notify (MetaWindow *mw,
 {
   MetaWindowActor        *self     = META_WINDOW_ACTOR (data);
   MetaWindowActorPrivate *priv     = self->priv;
-  MetaFrame              *frame    = meta_window_get_frame (mw);
   MetaScreen             *screen   = priv->screen;
   MetaDisplay            *display  = meta_screen_get_display (screen);
   Display                *xdisplay = meta_display_get_xdisplay (display);
-  Window                  new_xwindow;
 
   /*
    * Basically, we have to reconstruct the the internals of this object
@@ -317,11 +274,6 @@ window_decorated_notify (MetaWindow *mw,
    */
   priv->redecorating = TRUE;
 
-  if (frame)
-    new_xwindow = meta_frame_get_xwindow (frame);
-  else
-    new_xwindow = meta_window_get_xwindow (mw);
-
   meta_window_actor_detach (self);
 
   /*
@@ -336,7 +288,7 @@ window_decorated_notify (MetaWindow *mw,
       priv->damage = None;
     }
 
-  priv->xwindow = new_xwindow;
+  priv->xwindow = meta_window_get_toplevel_xwindow (priv->window);
 
   /*
    * Recreate the contents.
@@ -357,13 +309,16 @@ meta_window_actor_constructed (GObject *object)
 {
   MetaWindowActor        *self     = META_WINDOW_ACTOR (object);
   MetaWindowActorPrivate *priv     = self->priv;
-  MetaScreen             *screen   = priv->screen;
-  MetaDisplay            *display  = meta_screen_get_display (screen);
-  Window                  xwindow  = priv->xwindow;
   MetaWindow             *window   = priv->window;
+  MetaScreen             *screen   = meta_window_get_screen (window);
+  MetaDisplay            *display  = meta_screen_get_display (screen);
   Display                *xdisplay = meta_display_get_xdisplay (display);
   XRenderPictFormat      *format;
+  Window                  xwindow;
 
+  xwindow = meta_window_get_toplevel_xwindow (window);
+
+  priv->screen = screen;
   priv->damage = XDamageCreate (xdisplay, xwindow,
                                 XDamageReportBoundingBox);
 
@@ -392,20 +347,28 @@ meta_window_actor_constructed (GObject *object)
       g_signal_connect_object (window, "notify::appears-focused",
                                G_CALLBACK (window_appears_focused_notify), self, 0);
     }
-  else
-    {
-      /*
-       * This is the case where existing window is gaining/loosing frame.
-       * Just ensure the actor is top most (i.e., above shadow).
-       */
-      clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self), priv->actor, NULL);
-    }
 
   meta_window_actor_update_opacity (self);
+  meta_window_actor_sync_actor_position (self);
+
+  priv->mapped = meta_window_toplevel_is_mapped (priv->window);
+  if (priv->mapped)
+    meta_window_actor_queue_create_pixmap (self);
+
+  meta_window_actor_set_updates_frozen (self,
+                                        meta_window_updates_are_frozen (priv->window));
+
+  /* If a window doesn't start off with updates frozen, we should
+   * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
+   */
+  if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
+    meta_window_actor_queue_frame_drawn (self, FALSE);
 
   /* Start off with an empty region to maintain the invariant that
      the shape region is always set */
   priv->shape_region = cairo_region_create ();
+
+  G_OBJECT_CLASS (meta_window_actor_parent_class)->constructed (object);
 }
 
 static void
@@ -416,7 +379,6 @@ meta_window_actor_dispose (GObject *object)
   MetaScreen             *screen;
   MetaDisplay            *display;
   Display                *xdisplay;
-  MetaCompScreen         *info;
 
   if (priv->disposed)
     return;
@@ -426,7 +388,6 @@ meta_window_actor_dispose (GObject *object)
   screen   = priv->screen;
   display  = meta_screen_get_display (screen);
   xdisplay = meta_display_get_xdisplay (display);
-  info     = meta_screen_get_compositor_data (screen);
 
   meta_window_actor_detach (self);
 
@@ -456,8 +417,6 @@ meta_window_actor_dispose (GObject *object)
       priv->damage = None;
     }
 
-  info->windows = g_list_remove (info->windows, (gconstpointer) self);
-
   g_clear_object (&priv->window);
 
   /*
@@ -491,17 +450,7 @@ meta_window_actor_set_property (GObject      *object,
   switch (prop_id)
     {
     case PROP_META_WINDOW:
-      {
-        if (priv->window)
-          g_object_unref (priv->window);
-        priv->window = g_value_dup_object (value);
-      }
-      break;
-    case PROP_META_SCREEN:
-      priv->screen = g_value_get_pointer (value);
-      break;
-    case PROP_X_WINDOW:
-      priv->xwindow = g_value_get_ulong (value);
+      priv->window = g_value_dup_object (value);
       break;
     case PROP_NO_SHADOW:
       {
@@ -547,12 +496,6 @@ meta_window_actor_get_property (GObject      *object,
     case PROP_META_WINDOW:
       g_value_set_object (value, priv->window);
       break;
-    case PROP_META_SCREEN:
-      g_value_set_pointer (value, priv->screen);
-      break;
-    case PROP_X_WINDOW:
-      g_value_set_ulong (value, priv->xwindow);
-      break;
     case PROP_NO_SHADOW:
       g_value_set_boolean (value, priv->no_shadow);
       break;
@@ -820,20 +763,6 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
   return FALSE;
 }
 
-/**
- * meta_window_actor_get_x_window: (skip)
- * @self: a #MetaWindowActor
- *
- */
-Window
-meta_window_actor_get_x_window (MetaWindowActor *self)
-{
-  if (!self)
-    return None;
-
-  return self->priv->xwindow;
-}
-
 /**
  * meta_window_actor_get_meta_window:
  * @self: a #MetaWindowActor
@@ -876,59 +805,6 @@ meta_window_actor_is_destroyed (MetaWindowActor *self)
   return self->priv->disposed;
 }
 
-gboolean
-meta_window_actor_is_override_redirect (MetaWindowActor *self)
-{
-  return meta_window_is_override_redirect (self->priv->window);
-}
-
-/**
- * meta_window_actor_get_workspace:
- * @self: #MetaWindowActor
- *
- * Returns the index of workspace on which this window is located; if the
- * window is sticky, or is not currently located on any workspace, returns -1.
- * This function is deprecated  and should not be used in newly written code;
- * meta_window_get_workspace() instead.
- *
- * Return value: (transfer none): index of workspace on which this window is
- * located.
- */
-gint
-meta_window_actor_get_workspace (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv;
-  MetaWorkspace          *workspace;
-
-  if (!self)
-    return -1;
-
-  priv = self->priv;
-
-  if (!priv->window || meta_window_is_on_all_workspaces (priv->window))
-    return -1;
-
-  workspace = meta_window_get_workspace (priv->window);
-
-  if (!workspace)
-    return -1;
-
-  return meta_workspace_index (workspace);
-}
-
-gboolean
-meta_window_actor_showing_on_its_workspace (MetaWindowActor *self)
-{
-  if (!self)
-    return FALSE;
-
-  /* If override redirect: */
-  if (!self->priv->window)
-    return TRUE;
-
-  return meta_window_showing_on_its_workspace (self->priv->window);
-}
-
 static void
 meta_window_actor_freeze (MetaWindowActor *self)
 {
@@ -1369,7 +1245,7 @@ meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
   MetaDisplay *display = meta_window_get_display (metaWindow);
 
   Display *xdisplay = meta_display_get_xdisplay (display);
-  Window  xwin = meta_window_actor_get_x_window (self);
+  Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);
 
   if (state)
     {
@@ -1392,7 +1268,6 @@ void
 meta_window_actor_destroy (MetaWindowActor *self)
 {
   MetaWindow	      *window;
-  MetaCompScreen      *info;
   MetaWindowActorPrivate *priv;
   MetaWindowType window_type;
 
@@ -1400,14 +1275,6 @@ meta_window_actor_destroy (MetaWindowActor *self)
 
   window = priv->window;
   window_type = meta_window_get_window_type (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) self);
 
   if (window_type == META_WINDOW_DROPDOWN_MENU ||
       window_type == META_WINDOW_POPUP_MENU ||
@@ -1470,8 +1337,6 @@ meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                               window_rect.x, window_rect.y);
   clutter_actor_set_size (CLUTTER_ACTOR (self),
                           window_rect.width, window_rect.height);
-
-  g_signal_emit (self, signals[POSITION_CHANGED], 0);
 }
 
 void
@@ -1619,68 +1484,9 @@ meta_window_actor_unmaximize (MetaWindowActor   *self,
 MetaWindowActor *
 meta_window_actor_new (MetaWindow *window)
 {
-  MetaScreen	 	 *screen = meta_window_get_screen (window);
-  MetaCompScreen         *info = meta_screen_get_compositor_data (screen);
-  MetaWindowActor        *self;
-  MetaWindowActorPrivate *priv;
-  MetaFrame		 *frame;
-  Window		  top_window;
-  ClutterActor           *window_group;
-
-  frame = meta_window_get_frame (window);
-  if (frame)
-    top_window = meta_frame_get_xwindow (frame);
-  else
-    top_window = meta_window_get_xwindow (window);
-
-  meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);
-
-  self = g_object_new (META_TYPE_WINDOW_ACTOR,
-                       "meta-window",         window,
-                       "x-window",            top_window,
-                       "meta-screen",         screen,
+  return g_object_new (META_TYPE_WINDOW_ACTOR,
+                       "meta-window", window,
                        NULL);
-
-  priv = self->priv;
-
-  priv->last_width = -1;
-  priv->last_height = -1;
-
-  priv->mapped = meta_window_toplevel_is_mapped (priv->window);
-  if (priv->mapped)
-    meta_window_actor_queue_create_pixmap (self);
-
-  meta_window_actor_set_updates_frozen (self,
-                                        meta_window_updates_are_frozen (priv->window));
-
-  /* If a window doesn't start off with updates frozen, we should
-   * we should send a _NET_WM_FRAME_DRAWN immediately after the first drawn.
-   */
-  if (priv->window->extended_sync_request_counter && !priv->updates_frozen)
-    meta_window_actor_queue_frame_drawn (self, FALSE);
-
-  meta_window_actor_sync_actor_geometry (self, priv->window->placed);
-
-  /* Hang our compositor window state off the MetaWindow for fast retrieval */
-  meta_window_set_compositor_private (window, G_OBJECT (self));
-
-  if (window->layer == META_LAYER_OVERRIDE_REDIRECT)
-    window_group = info->top_window_group;
-  else
-    window_group = info->window_group;
-
-  clutter_actor_add_child (window_group, CLUTTER_ACTOR (self));
-
-  clutter_actor_hide (CLUTTER_ACTOR (self));
-
-  clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
-
-  /* Initial position in the stack is arbitrary; stacking will be synced
-   * before we first paint.
-   */
-  info->windows = g_list_append (info->windows, self);
-
-  return self;
 }
 
 void
@@ -1906,8 +1712,8 @@ check_needs_pixmap (MetaWindowActor *self)
   MetaDisplay         *display  = meta_screen_get_display (screen);
   Display             *xdisplay = meta_display_get_xdisplay (display);
   MetaCompScreen      *info     = meta_screen_get_compositor_data (screen);
+  Window               xwindow  = meta_window_get_toplevel_xwindow (priv->window);
   MetaCompositor      *compositor;
-  Window               xwindow  = priv->xwindow;
 
   if (!priv->needs_pixmap)
     return;
@@ -1971,17 +1777,6 @@ check_needs_pixmap (MetaWindowActor *self)
        */
       if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture))))
         g_warning ("NOTE: Not using GLX TFP!\n");
-
-      /* ::size-changed is supposed to refer to meta_window_get_frame_rect().
-       * Emitting it here works pretty much OK because a new value of the
-       * *input* rect (which is the outer rect with the addition of invisible
-       * borders) forces a new pixmap and we get here. In the rare case where
-       * a change to the window size was exactly balanced by a change to the
-       * invisible borders, we would miss emitting the signal. We would also
-       * emit spurious signals when we get a new pixmap without a new size,
-       * but that should be mostly harmless.
-       */
-      g_signal_emit (self, signals[SIZE_CHANGED], 0);
     }
 
   priv->needs_pixmap = FALSE;

src/compositor/meta-window-group.c

@@ -199,11 +199,30 @@ meta_window_group_paint (ClutterActor *actor)
   meta_cullable_reset_culling (META_CULLABLE (window_group));
 }
 
+/* Adapted from clutter_actor_update_default_paint_volume() */
 static gboolean
-meta_window_group_get_paint_volume (ClutterActor       *actor,
+meta_window_group_get_paint_volume (ClutterActor       *self,
                                     ClutterPaintVolume *volume)
 {
-  return clutter_paint_volume_set_from_allocation (volume, actor);
+  ClutterActorIter iter;
+  ClutterActor *child;
+
+  clutter_actor_iter_init (&iter, self);
+  while (clutter_actor_iter_next (&iter, &child))
+    {
+      const ClutterPaintVolume *child_volume;
+
+      if (!CLUTTER_ACTOR_IS_MAPPED (child))
+        continue;
+
+      child_volume = clutter_actor_get_transformed_paint_volume (child, self);
+      if (child_volume == NULL)
+        return FALSE;
+
+      clutter_paint_volume_union (volume, child_volume);
+    }
+
+  return TRUE;
 }
 
 static void

src/compositor/plugins/default.c

@@ -412,7 +412,7 @@ switch_workspace (MetaPlugin *plugin,
       ClutterActor    *actor	    = CLUTTER_ACTOR (window_actor);
       gint             win_workspace;
 
-      win_workspace = meta_window_actor_get_workspace (window_actor);
+      win_workspace = meta_window_get_workspace (meta_window_actor_get_meta_window (window_actor));
 
       if (win_workspace == to || win_workspace == from)
         {

src/core/core.c

@@ -280,8 +280,7 @@ meta_core_lower_beneath_grab_window (Display *xdisplay,
     return;
 
   changes.stack_mode = Below;
-  changes.sibling = grab_window->frame ? grab_window->frame->xwindow
-                                       : grab_window->xwindow;
+  changes.sibling = meta_window_get_toplevel_xwindow (grab_window);
 
   meta_stack_tracker_record_lower_below (screen->stack_tracker,
                                          xwindow,
@@ -303,7 +302,7 @@ meta_core_user_focus (Display *xdisplay,
 {
   MetaWindow *window = get_window (xdisplay, frame_xwindow);
   
-  meta_window_focus_implicitly (window, timestamp);
+  meta_window_focus (window, timestamp);
 }
 
 void
@@ -482,7 +481,7 @@ meta_core_show_window_menu (Display *xdisplay,
   
   if (meta_prefs_get_raise_on_click ())
     meta_window_raise (window);
-  meta_window_focus_implicitly (window, timestamp);
+  meta_window_focus (window, timestamp);
 
   meta_window_show_menu (window, root_x, root_y, button, timestamp);
 }

src/core/display.c

@@ -117,6 +117,15 @@ typedef struct
   guint        ping_timeout_id;
 } MetaPingData;
 
+typedef struct
+{
+  MetaDisplay *display;
+  MetaWindow *window;
+  int pointer_x;
+  int pointer_y;
+} MetaFocusData;
+
+
 G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);
 
 /* Signals */
@@ -1552,6 +1561,21 @@ crossing_serial_is_ignored (MetaDisplay  *display,
   return FALSE;
 }
 
+static void
+reset_ignored_crossing_serials (MetaDisplay *display)
+{
+  int i;
+
+  i = 0;
+  while (i < N_IGNORED_CROSSING_SERIALS)
+    {
+      display->ignored_crossing_serials[i] = 0;
+      ++i;
+    }
+
+  display->ungrab_should_not_cause_focus_window = None;
+}
+
 static gboolean 
 window_raise_with_delay_callback (void *data)
 {
@@ -1592,6 +1616,110 @@ window_raise_with_delay_callback (void *data)
   return FALSE;
 }
 
+static void
+meta_display_mouse_mode_focus (MetaDisplay *display,
+                               MetaWindow  *window,
+                               guint32      timestamp)
+{
+  if (window->type != META_WINDOW_DESKTOP)
+    {
+      meta_topic (META_DEBUG_FOCUS,
+                  "Focusing %s at time %u.\n", window->desc, timestamp);
+
+      meta_window_focus (window, timestamp);
+
+      if (meta_prefs_get_auto_raise ())
+        meta_display_queue_autoraise_callback (display, window);
+      else
+        meta_topic (META_DEBUG_FOCUS, "Auto raise is disabled\n");
+    }
+  else
+    {
+      /* In mouse focus mode, we defocus when the mouse *enters*
+       * the DESKTOP window, instead of defocusing on LeaveNotify.
+       * This is because having the mouse enter override-redirect
+       * child windows unfortunately causes LeaveNotify events that
+       * we can't distinguish from the mouse actually leaving the
+       * toplevel window as we expect.  But, since we filter out
+       * EnterNotify events on override-redirect windows, this
+       * alternative mechanism works great.
+       */
+      if (meta_prefs_get_focus_mode() == G_DESKTOP_FOCUS_MODE_MOUSE &&
+          display->focus_window != NULL)
+        {
+          meta_topic (META_DEBUG_FOCUS,
+                      "Unsetting focus from %s due to mouse entering "
+                      "the DESKTOP window\n",
+                      display->focus_window->desc);
+          meta_display_focus_the_no_focus_window (display,
+                                                  window->screen,
+                                                  timestamp);
+        }
+    }
+}
+
+static gboolean
+window_focus_on_pointer_rest_callback (gpointer data)
+{
+  MetaFocusData *focus_data;
+  MetaDisplay *display;
+  MetaScreen *screen;
+  MetaWindow *window;
+  Window root, child;
+  double root_x, root_y, x, y;
+  guint32 timestamp;
+  XIButtonState buttons;
+  XIModifierState mods;
+  XIGroupState group;
+
+  focus_data = data;
+  display = focus_data->display;
+  screen = focus_data->window->screen;
+
+  if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)
+    goto out;
+
+  meta_error_trap_push (display);
+  XIQueryPointer (display->xdisplay,
+                  META_VIRTUAL_CORE_POINTER_ID,
+                  screen->xroot,
+                  &root, &child,
+                  &root_x, &root_y, &x, &y,
+                  &buttons, &mods, &group);
+  meta_error_trap_pop (display);
+  free (buttons.mask);
+
+  if (root_x != focus_data->pointer_x ||
+      root_y != focus_data->pointer_y)
+    {
+      focus_data->pointer_x = root_x;
+      focus_data->pointer_y = root_y;
+      return TRUE;
+    }
+
+  /* Explicitly check for the overlay window, as get_focus_window_at_point()
+   * may return windows that extend underneath the chrome (like
+   * override-redirect or DESKTOP windows)
+   */
+  if (child == meta_get_overlay_window (screen))
+    goto out;
+
+  window =
+    meta_stack_get_default_focus_window_at_point (screen->stack,
+                                                  screen->active_workspace,
+                                                  None, root_x, root_y);
+
+  if (window == NULL)
+    goto out;
+
+  timestamp = meta_display_get_current_time_roundtrip (display);
+  meta_display_mouse_mode_focus (display, window, timestamp);
+
+ out:
+  display->focus_timeout_id = 0;
+  return FALSE;
+}
+
 void
 meta_display_queue_autoraise_callback (MetaDisplay *display,
                                        MetaWindow  *window)
@@ -1612,6 +1740,37 @@ meta_display_queue_autoraise_callback (MetaDisplay *display,
   display->autoraise_window = window;
 }
 
+/* The interval, in milliseconds, we use in focus-follows-mouse
+ * mode to check whether the pointer has stopped moving after a
+ * crossing event.
+ */
+#define FOCUS_TIMEOUT_DELAY 25
+
+static void
+meta_display_queue_focus_callback (MetaDisplay *display,
+                                   MetaWindow  *window,
+                                   int          pointer_x,
+                                   int          pointer_y)
+{
+  MetaFocusData *focus_data;
+
+  focus_data = g_new (MetaFocusData, 1);
+  focus_data->display = display;
+  focus_data->window = window;
+  focus_data->pointer_x = pointer_x;
+  focus_data->pointer_y = pointer_y;
+
+  if (display->focus_timeout_id != 0)
+    g_source_remove (display->focus_timeout_id);
+
+  display->focus_timeout_id =
+    g_timeout_add_full (G_PRIORITY_DEFAULT,
+                        FOCUS_TIMEOUT_DELAY,
+                        window_focus_on_pointer_rest_callback,
+                        focus_data,
+                        g_free);
+}
+
 #if 0
 static void
 handle_net_restack_window (MetaDisplay* display,
@@ -2133,7 +2292,7 @@ event_callback (XEvent   *event,
       XIEnterEvent *enter_event = (XIEnterEvent *) input_event;
 
       if (window && !window->override_redirect &&
-          ((input_event->type == XI_KeyPress) || (input_event->type == XI_ButtonPress)))
+          ((input_event->evtype == XI_KeyPress) || (input_event->evtype == XI_ButtonPress)))
         {
           if (CurrentTime == display->current_time)
             {
@@ -2244,7 +2403,7 @@ event_callback (XEvent   *event,
                           meta_topic (META_DEBUG_FOCUS,
                                       "Focusing %s due to unmodified button %u press (display.c)\n",
                                       window->desc, device_event->detail);
-                          meta_window_focus_implicitly (window, device_event->time);
+                          meta_window_focus (window, device_event->time);
                         }
                       else
                         /* However, do allow terminals to lose focus due to new
@@ -2388,16 +2547,42 @@ event_callback (XEvent   *event,
            * avoid races.
            */
           if (window && !crossing_serial_is_ignored (display, event->xany.serial) &&
-              enter_event->mode != XINotifyGrab &&
+              enter_event->mode != XINotifyGrab && 
               enter_event->mode != XINotifyUngrab &&
               enter_event->detail != XINotifyInferior &&
               meta_display_focus_sentinel_clear (display))
             {
-              meta_window_handle_enter (window,
-                                        enter_event->time,
-                                        enter_event->root_x,
-                                        enter_event->root_y);
+              switch (meta_prefs_get_focus_mode ())
+                {
+                case G_DESKTOP_FOCUS_MODE_SLOPPY:
+                case G_DESKTOP_FOCUS_MODE_MOUSE:
+                  display->mouse_mode = TRUE;
+                  if (window->type != META_WINDOW_DOCK)
+                    {
+                      meta_topic (META_DEBUG_FOCUS,
+                                  "Queuing a focus change for %s due to "
+                                  "enter notify with serial %lu at time %lu, "
+                                  "and setting display->mouse_mode to TRUE.\n",
+                                  window->desc,
+                                  event->xany.serial,
+                                  enter_event->time);
 
+                      if (meta_prefs_get_focus_change_on_pointer_rest())
+                        meta_display_queue_focus_callback (display, window,
+                                                           enter_event->root_x,
+                                                           enter_event->root_y);
+                      else
+                        meta_display_mouse_mode_focus (display, window,
+                                                       enter_event->time);
+
+                      /* stop ignoring stuff */
+                      reset_ignored_crossing_serials (display);
+                    }
+                  break;
+                case G_DESKTOP_FOCUS_MODE_CLICK:
+                  break;
+                }
+          
               if (window->type == META_WINDOW_DOCK)
                 meta_window_raise (window);
             }
@@ -3823,7 +4008,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
    *   key grab on the RootWindow.
    */
   if (grab_window)
-    grab_xwindow = grab_window->frame ? grab_window->frame->xwindow : grab_window->xwindow;
+    grab_xwindow = meta_window_get_toplevel_xwindow (grab_window);
   else
     grab_xwindow = screen->xroot;
 

src/core/keybindings.c

@@ -1277,7 +1277,7 @@ meta_window_grab_keys (MetaWindow  *window)
     }
 
   meta_window_change_keygrabs (window,
-                               window->frame ? window->frame->xwindow : window->xwindow,
+                               meta_window_get_toplevel_xwindow (window),
                                TRUE);
 
   window->keys_grabbed = TRUE;
@@ -1578,9 +1578,9 @@ meta_window_grab_all_keys (MetaWindow  *window,
   meta_topic (META_DEBUG_FOCUS,
               "Focusing %s because we're grabbing all its keys\n",
               window->desc);
-  meta_window_focus_implicitly (window, timestamp);
+  meta_window_focus (window, timestamp);
 
-  grabwindow = window->frame ? window->frame->xwindow : window->xwindow;
+  grabwindow = meta_window_get_toplevel_xwindow (window);
 
   meta_topic (META_DEBUG_KEYBINDINGS,
               "Grabbing all keys on window %s\n", window->desc);

src/core/monitor-xrandr.c

@@ -453,8 +453,10 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
       XRRFreeCrtcInfo (crtc);
     }
 
+  meta_error_trap_push (meta_get_display ());
   primary_output = XRRGetOutputPrimary (manager_xrandr->xdisplay,
 					DefaultRootWindow (manager_xrandr->xdisplay));
+  meta_error_trap_pop (meta_get_display ());
 
   n_actual_outputs = 0;
   for (i = 0; i < (unsigned)resources->noutput; i++)
@@ -693,10 +695,11 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
 						 unsigned int         n_outputs)
 {
   MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
+  MetaDisplay *display = meta_get_display ();
   unsigned i;
   int width, height, width_mm, height_mm;
 
-  meta_display_grab (meta_get_display ());
+  meta_display_grab (display);
 
   /* First compute the new size of the screen (framebuffer) */
   width = 0; height = 0;
@@ -790,10 +793,10 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
    */
   width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
   height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
-  meta_error_trap_push (meta_get_display ());
+  meta_error_trap_push (display);
   XRRSetScreenSize (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
                     width, height, width_mm, height_mm);
-  meta_error_trap_pop (meta_get_display ());
+  meta_error_trap_pop (display);
 
   for (i = 0; i < n_crtcs; i++)
     {
@@ -850,7 +853,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
               goto next;
             }
 
-          meta_error_trap_push (meta_get_display ());
+          meta_error_trap_push (display);
           ok = XRRSetCrtcConfig (manager_xrandr->xdisplay,
                                  manager_xrandr->resources,
                                  (XID)crtc->crtc_id,
@@ -859,7 +862,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                                  (XID)mode->mode_id,
                                  wl_transform_to_xrandr (crtc_info->transform),
                                  outputs, n_outputs);
-          meta_error_trap_pop (meta_get_display ());
+          meta_error_trap_pop (display);
 
           if (ok != Success)
             {
@@ -900,9 +903,11 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
 
       if (output_info->is_primary)
         {
+          meta_error_trap_push (display);
           XRRSetOutputPrimary (manager_xrandr->xdisplay,
                                DefaultRootWindow (manager_xrandr->xdisplay),
                                (XID)output_info->output->output_id);
+          meta_error_trap_pop (display);
         }
 
       output_set_presentation_xrandr (manager_xrandr,
@@ -928,7 +933,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
       output->is_primary = FALSE;
     }
 
-  meta_display_ungrab (meta_get_display ());
+  meta_display_ungrab (display);
 }
 
 static void

src/core/screen.c

@@ -2984,7 +2984,7 @@ meta_screen_show_desktop (MetaScreen *screen,
       if (w->screen == screen  && 
           w->type == META_WINDOW_DESKTOP)
         {
-          meta_window_focus_explicitly (w, timestamp);
+          meta_window_focus (w, timestamp);
           break;
         }
       

src/core/window-private.h

@@ -36,6 +36,7 @@
 
 #include <config.h>
 #include <meta/compositor.h>
+#include <meta/meta-window-actor.h>
 #include <meta/window.h>
 #include "screen-private.h"
 #include <meta/util.h>
@@ -438,7 +439,10 @@ struct _MetaWindow
   /* maintained by group.c */
   MetaGroup *group;
 
-  GObject *compositor_private;
+  GSList *actors;
+
+  /* The core actor is the one in the window group. */
+  MetaWindowActor *core_actor;
 
   /* Focused window that is (directly or indirectly) attached to this one */
   MetaWindow *attached_focus_window;
@@ -696,12 +700,6 @@ void meta_window_set_shape_region         (MetaWindow     *window,
                                            cairo_region_t *region);
 void meta_window_update_shape_region_x11  (MetaWindow *window);
 
-void meta_window_handle_enter (MetaWindow  *window,
-                               guint32      timestamp,
-                               guint        root_x,
-                               guint        root_y);
-
-void meta_window_focus_implicitly (MetaWindow *window,
-                                   guint32     timestamp);
+Window meta_window_get_toplevel_xwindow (MetaWindow *window);
 
 #endif

src/core/window-props.c

@@ -316,6 +316,9 @@ reload_gtk_frame_extents (MetaWindow    *window,
     {
       window->has_custom_frame_extents = FALSE;
     }
+
+  if (!initial)
+    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
 }
 
 static void

src/core/window.c

@@ -49,7 +49,6 @@
 #include "constraints.h"
 #include "mutter-enum-types.h"
 #include "core.h"
-#include <meta/compositor-mutter.h>
 
 #include <X11/Xatom.h>
 #include <X11/Xlibint.h> /* For display->resource_mask */
@@ -195,6 +194,8 @@ enum
   FOCUS,
   RAISED,
   UNMANAGED,
+  SIZE_CHANGED,
+  POSITION_CHANGED,
 
   LAST_SIGNAL
 };
@@ -588,6 +589,22 @@ meta_window_class_init (MetaWindowClass *klass)
                   G_STRUCT_OFFSET (MetaWindowClass, unmanaged),
                   NULL, NULL, NULL,
                   G_TYPE_NONE, 0);
+
+  window_signals[POSITION_CHANGED] =
+    g_signal_new ("position-changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
+
+  window_signals[SIZE_CHANGED] =
+    g_signal_new ("size-changed",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL, NULL,
+                  G_TYPE_NONE, 0);
 }
 
 static void
@@ -1176,7 +1193,8 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   window->initial_workspace = 0; /* not used */
   window->initial_timestamp = 0; /* not used */
 
-  window->compositor_private = NULL;
+  window->core_actor = NULL;
+  window->actors = NULL;
 
   window->monitor = meta_screen_get_monitor_for_window (window->screen, window);
 
@@ -3183,7 +3201,7 @@ meta_window_show (MetaWindow *window)
 
           timestamp = meta_display_get_current_time_roundtrip (window->display);
 
-          meta_window_focus_explicitly (window, timestamp);
+          meta_window_focus (window, timestamp);
         }
       else
         {
@@ -3901,8 +3919,10 @@ meta_window_unmaximize_internal (MetaWindow        *window,
     {
       MetaRectangle target_rect;
       MetaRectangle work_area;
+      MetaRectangle old_rect;
 
       meta_window_get_work_area_for_monitor (window, window->monitor->number, &work_area);
+      meta_window_get_frame_rect (window, &old_rect);
 
       meta_topic (META_DEBUG_WINDOW_OPS,
                   "Unmaximizing %s%s\n",
@@ -3916,6 +3936,12 @@ meta_window_unmaximize_internal (MetaWindow        *window,
       window->maximized_vertically =
         window->maximized_vertically   && !unmaximize_vertically;
 
+      /* recalc_window_features() will eventually clear the cached frame
+       * extents, but we need the correct frame extents in the code below,
+       * so invalidate the old frame extents manually up front.
+       */
+      meta_window_frame_size_changed (window);
+
       /* Unmaximize to the saved_rect position in the direction(s)
        * being unmaximized.
        */
@@ -3960,9 +3986,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
 
       if (window->display->compositor)
         {
-          MetaRectangle old_rect, new_rect;
-
-	  meta_window_get_frame_rect (window, &old_rect);
+          MetaRectangle new_rect;
 
           meta_window_move_resize_internal (window,
                                             META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION,
@@ -4225,7 +4249,7 @@ meta_window_shade (MetaWindow  *window,
       meta_topic (META_DEBUG_FOCUS,
                   "Re-focusing window %s after shading it\n",
                   window->desc);
-      meta_window_focus_explicitly (window, timestamp);
+      meta_window_focus (window, timestamp);
 
       set_net_wm_state (window);
     }
@@ -4249,7 +4273,7 @@ meta_window_unshade (MetaWindow  *window,
       meta_topic (META_DEBUG_FOCUS,
                   "Focusing window %s after unshading it\n",
                   window->desc);
-      meta_window_focus_explicitly (window, timestamp);
+      meta_window_focus (window, timestamp);
 
       set_net_wm_state (window);
     }
@@ -4348,7 +4372,7 @@ window_activate (MetaWindow     *window,
   meta_topic (META_DEBUG_FOCUS,
               "Focusing window %s due to activation\n",
               window->desc);
-  meta_window_focus_explicitly (window, timestamp);
+  meta_window_focus (window, timestamp);
 
   meta_window_check_alive (window, timestamp);
 }
@@ -5278,6 +5302,12 @@ meta_window_move_resize_internal (MetaWindow          *window,
   else if (is_user_action)
     save_user_window_placement (window);
 
+  if (need_move_frame)
+    g_signal_emit (window, window_signals[POSITION_CHANGED], 0);
+
+  if (need_resize_client)
+    g_signal_emit (window, window_signals[SIZE_CHANGED], 0);
+
   if (need_move_frame || need_resize_frame ||
       need_move_client || need_resize_client ||
       did_placement)
@@ -5768,8 +5798,8 @@ meta_window_get_input_rect (const MetaWindow *window,
 /**
  * meta_window_client_rect_to_frame_rect:
  * @window: a #MetaWindow
- * @frame_rect: client rectangle in root coordinates
- * @client_rect: (out): location to store the computed corresponding frame bounds.
+ * @client_rect: client rectangle in root coordinates
+ * @frame_rect: (out): location to store the computed corresponding frame bounds.
  *
  * Converts a desired bounds of the client window - what is passed to meta_window_move_resize() -
  * into the corresponding bounds of the window frame (excluding invisible borders
@@ -5777,13 +5807,13 @@ meta_window_get_input_rect (const MetaWindow *window,
  */
 void
 meta_window_client_rect_to_frame_rect (MetaWindow    *window,
-                                       MetaRectangle *frame_rect,
-                                       MetaRectangle *client_rect)
+                                       MetaRectangle *client_rect,
+                                       MetaRectangle *frame_rect)
 {
-  if (!client_rect)
+  if (!frame_rect)
     return;
 
-  *client_rect = *frame_rect;
+  *frame_rect = *client_rect;
 
   /* The support for G_MAXINT here to mean infinity is a convenience for
    * constraints.c:get_size_limits() and not something that we provide
@@ -5794,24 +5824,24 @@ meta_window_client_rect_to_frame_rect (MetaWindow    *window,
       MetaFrameBorders borders;
       meta_frame_calc_borders (window->frame, &borders);
 
-      client_rect->x -= borders.visible.left;
-      client_rect->y -= borders.visible.top;
-      if (client_rect->width != G_MAXINT)
-        client_rect->width += borders.visible.left + borders.visible.right;
-      if (client_rect->height != G_MAXINT)
-        client_rect->height += borders.visible.top  + borders.visible.bottom;
+      frame_rect->x -= borders.visible.left;
+      frame_rect->y -= borders.visible.top;
+      if (frame_rect->width != G_MAXINT)
+        frame_rect->width += borders.visible.left + borders.visible.right;
+      if (frame_rect->height != G_MAXINT)
+        frame_rect->height += borders.visible.top  + borders.visible.bottom;
     }
   else
     {
       if (window->has_custom_frame_extents)
         {
           const GtkBorder *extents = &window->custom_frame_extents;
-          client_rect->x += extents->left;
-          client_rect->y += extents->top;
-          if (client_rect->width != G_MAXINT)
-            client_rect->width -= extents->left + extents->right;
-          if (client_rect->height != G_MAXINT)
-            client_rect->height -= extents->top + extents->bottom;
+          frame_rect->x += extents->left;
+          frame_rect->y += extents->top;
+          if (frame_rect->width != G_MAXINT)
+            frame_rect->width -= extents->left + extents->right;
+          if (frame_rect->height != G_MAXINT)
+            frame_rect->height -= extents->top + extents->bottom;
         }
     }
 }
@@ -5908,7 +5938,7 @@ meta_window_get_frame_rect (const MetaWindow *window,
  * area that we or the client adds to the window, or any area that the
  * client adds to draw a client-side shadow.
  *
- * Deprecated: 3.10: Use meta_window_get_frame_rect() instead.
+ * Deprecated: 3.12: Use meta_window_get_frame_rect() instead.
  */
 void
 meta_window_get_outer_rect (const MetaWindow *window,
@@ -5972,18 +6002,17 @@ get_modal_transient (MetaWindow *window)
 }
 
 /* XXX META_EFFECT_FOCUS */
-static void
-meta_window_focus_internal (MetaWindow  *window,
-                            guint32      timestamp,
-                            gboolean     explicit_focus)
+void
+meta_window_focus (MetaWindow  *window,
+                   guint32      timestamp)
 {
   MetaWindow *modal_transient;
 
   g_return_if_fail (!window->override_redirect);
 
   meta_topic (META_DEBUG_FOCUS,
-              "%s setting input focus to window %s, input: %d take_focus: %d\n",
-              explicit_focus ? "Explicitly" : "Implicitly", window->desc, window->input, window->take_focus);
+              "Setting input focus to window %s, input: %d take_focus: %d\n",
+              window->desc, window->input, window->take_focus);
 
   if (window->display->grab_window &&
       window->display->grab_window->all_keys_grabbed)
@@ -6018,16 +6047,15 @@ meta_window_focus_internal (MetaWindow  *window,
       return;
     }
 
-  /* For output-only or shaded windows, focus the frame if it was
-   * an explicit focus event. This seems to result in the client
-   * window getting key events though, so I don't know if it's
-   * icccm-compliant.
+  /* For output-only or shaded windows, focus the frame.
+   * This seems to result in the client window getting key events
+   * though, so I don't know if it's icccm-compliant.
    *
    * Still, we have to do this or keynav breaks for these windows.
    */
   if (window->frame &&
       (window->shaded ||
-       (explicit_focus && !window->input && !window->take_focus)))
+       !(window->input || window->take_focus)))
     {
       if (window->frame)
         {
@@ -6070,40 +6098,6 @@ meta_window_focus_internal (MetaWindow  *window,
 /*  meta_effect_run_focus(window, NULL, NULL); */
 }
 
-/**
- * meta_window_focus_explicitly:
- * @window: A #MetaWindow
- * @timestamp: The timestamp to focus the window with
- *
- * Explicitly grab the window's focus. This should be used in cases
- * where the user wants to focus the window with Alt-Tab, pagers,
- * or other means like that, as opposed to simply clicking on the
- * window or other focus-modes like focus-follows-mouse.
- */
-void
-meta_window_focus_explicitly (MetaWindow *window,
-                              guint32     timestamp)
-{
-  meta_window_focus_internal (window, timestamp, TRUE);
-}
-
-/**
- * meta_window_focus_implicitly:
- * @window: A #MetaWindow
- * @timestamp: The timestamp to focus the window with
- *
- * Implicitly focus the window. This should be done if the user
- * simply clicks on the window. Most of the time, this should be
- * handled by mutter internally, and you should never have to
- * call this.
- */
-void
-meta_window_focus_implicitly (MetaWindow *window,
-                              guint32     timestamp)
-{
-  meta_window_focus_internal (window, timestamp, FALSE);
-}
-
 static void
 meta_window_change_workspace_without_transients (MetaWindow    *window,
                                                  MetaWorkspace *workspace)
@@ -11071,24 +11065,15 @@ meta_window_get_gtk_menubar_object_path (MetaWindow *window)
  * meta_window_get_compositor_private:
  * @window: a #MetaWindow
  *
- * Gets the compositor's wrapper object for @window.
- *
- * Return value: (transfer none): the wrapper object.
- **/
+ * Return value: (transfer none):
+ */
 GObject *
 meta_window_get_compositor_private (MetaWindow *window)
 {
   if (!window)
     return NULL;
-  return window->compositor_private;
-}
 
-void
-meta_window_set_compositor_private (MetaWindow *window, GObject *priv)
-{
-  if (!window)
-    return;
-  window->compositor_private = priv;
+  return G_OBJECT (window->core_actor);
 }
 
 const char *
@@ -11470,184 +11455,8 @@ meta_window_can_close (MetaWindow *window)
   return window->has_close_func;
 }
 
-static void
-reset_ignored_crossing_serials (MetaDisplay *display)
+Window
+meta_window_get_toplevel_xwindow (MetaWindow *window)
 {
-  int i;
-
-  i = 0;
-  while (i < N_IGNORED_CROSSING_SERIALS)
-    {
-      display->ignored_crossing_serials[i] = 0;
-      ++i;
-    }
-
-  display->ungrab_should_not_cause_focus_window = None;
-}
-
-typedef struct
-{
-  MetaWindow *window;
-  int pointer_x;
-  int pointer_y;
-} MetaFocusData;
-
-static void
-mouse_mode_focus (MetaWindow  *window,
-                  guint32      timestamp)
-{
-  MetaDisplay *display = window->display;
-
-  if (window->type != META_WINDOW_DESKTOP)
-    {
-      meta_topic (META_DEBUG_FOCUS,
-                  "Focusing %s at time %u.\n", window->desc, timestamp);
-
-      meta_window_focus_implicitly (window, timestamp);
-
-      if (meta_prefs_get_auto_raise ())
-        meta_display_queue_autoraise_callback (display, window);
-      else
-        meta_topic (META_DEBUG_FOCUS, "Auto raise is disabled\n");
-    }
-  else
-    {
-      /* In mouse focus mode, we defocus when the mouse *enters*
-       * the DESKTOP window, instead of defocusing on LeaveNotify.
-       * This is because having the mouse enter override-redirect
-       * child windows unfortunately causes LeaveNotify events that
-       * we can't distinguish from the mouse actually leaving the
-       * toplevel window as we expect.  But, since we filter out
-       * EnterNotify events on override-redirect windows, this
-       * alternative mechanism works great.
-       */
-      if (meta_prefs_get_focus_mode() == G_DESKTOP_FOCUS_MODE_MOUSE &&
-          display->focus_window != NULL)
-        {
-          meta_topic (META_DEBUG_FOCUS,
-                      "Unsetting focus from %s due to mouse entering "
-                      "the DESKTOP window\n",
-                      display->focus_window->desc);
-          meta_display_focus_the_no_focus_window (display,
-                                                  window->screen,
-                                                  timestamp);
-        }
-    }
-}
-
-static gboolean
-window_focus_on_pointer_rest_callback (gpointer data)
-{
-  MetaFocusData *focus_data = data;
-  MetaWindow *window = focus_data->window;
-  MetaDisplay *display = window->display;
-  MetaScreen *screen = window->screen;
-  Window root, child;
-  double root_x, root_y, x, y;
-  guint32 timestamp;
-  XIButtonState buttons;
-  XIModifierState mods;
-  XIGroupState group;
-
-  if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)
-    goto out;
-
-  meta_error_trap_push (display);
-  XIQueryPointer (display->xdisplay,
-                  META_VIRTUAL_CORE_POINTER_ID,
-                  screen->xroot,
-                  &root, &child,
-                  &root_x, &root_y, &x, &y,
-                  &buttons, &mods, &group);
-  meta_error_trap_pop (display);
-  free (buttons.mask);
-
-  if (root_x != focus_data->pointer_x ||
-      root_y != focus_data->pointer_y)
-    {
-      focus_data->pointer_x = root_x;
-      focus_data->pointer_y = root_y;
-      return TRUE;
-    }
-
-  /* Explicitly check for the overlay window, as get_focus_window_at_point()
-   * may return windows that extend underneath the chrome (like
-   * override-redirect or DESKTOP windows)
-   */
-  if (child == meta_get_overlay_window (screen))
-    goto out;
-
-  window =
-    meta_stack_get_default_focus_window_at_point (screen->stack,
-                                                  screen->active_workspace,
-                                                  None, root_x, root_y);
-
-  if (window == NULL)
-    goto out;
-
-  timestamp = meta_display_get_current_time_roundtrip (display);
-  mouse_mode_focus (window, timestamp);
-
- out:
-  display->focus_timeout_id = 0;
-  return FALSE;
-}
-
-/* The interval, in milliseconds, we use in focus-follows-mouse
- * mode to check whether the pointer has stopped moving after a
- * crossing event.
- */
-#define FOCUS_TIMEOUT_DELAY 25
-
-static void
-queue_focus_callback (MetaDisplay *display,
-                      MetaWindow  *window,
-                      int          pointer_x,
-                      int          pointer_y)
-{
-  MetaFocusData *focus_data;
-
-  focus_data = g_new (MetaFocusData, 1);
-  focus_data->window = window;
-  focus_data->pointer_x = pointer_x;
-  focus_data->pointer_y = pointer_y;
-
-  if (display->focus_timeout_id != 0)
-    g_source_remove (display->focus_timeout_id);
-
-  display->focus_timeout_id =
-    g_timeout_add_full (G_PRIORITY_DEFAULT,
-                        FOCUS_TIMEOUT_DELAY,
-                        window_focus_on_pointer_rest_callback,
-                        focus_data,
-                        g_free);
-}
-
-void
-meta_window_handle_enter (MetaWindow  *window,
-                          guint32      timestamp,
-                          guint        root_x,
-                          guint        root_y)
-{
-  MetaDisplay *display = window->display;
-
-  switch (meta_prefs_get_focus_mode ())
-    {
-    case G_DESKTOP_FOCUS_MODE_SLOPPY:
-    case G_DESKTOP_FOCUS_MODE_MOUSE:
-      display->mouse_mode = TRUE;
-      if (window->type != META_WINDOW_DOCK)
-        {
-          if (meta_prefs_get_focus_change_on_pointer_rest())
-            queue_focus_callback (display, window, root_x, root_y);
-          else
-            mouse_mode_focus (window, timestamp);
-
-          /* stop ignoring stuff */
-          reset_ignored_crossing_serials (display);
-        }
-      break;
-    case G_DESKTOP_FOCUS_MODE_CLICK:
-      break;
-    }
+  return window->frame ? window->frame->xwindow : window->xwindow;
 }

src/core/workspace.c

@@ -1256,7 +1256,7 @@ meta_workspace_focus_default_window (MetaWorkspace *workspace,
             {
               meta_topic (META_DEBUG_FOCUS,
                           "Focusing mouse window %s\n", window->desc);
-              meta_window_focus_explicitly (window, timestamp);
+              meta_window_focus (window, timestamp);
             }
 
           if (workspace->screen->display->autoraise_window != window &&
@@ -1319,7 +1319,7 @@ focus_ancestor_or_top_window (MetaWorkspace *workspace,
                       "Focusing %s, ancestor of %s\n", 
                       ancestor->desc, not_this_one->desc);
       
-          meta_window_focus_explicitly (ancestor, timestamp);
+          meta_window_focus (ancestor, timestamp);
 
           /* Also raise the window if in click-to-focus */
           if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)
@@ -1338,7 +1338,7 @@ focus_ancestor_or_top_window (MetaWorkspace *workspace,
       meta_topic (META_DEBUG_FOCUS,
                   "Focusing workspace MRU window %s\n", window->desc);
       
-      meta_window_focus_explicitly (window, timestamp);
+      meta_window_focus (window, timestamp);
 
       /* Also raise the window if in click-to-focus */
       if (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK)

src/meta/meta-window-actor.h

@@ -60,11 +60,8 @@ struct _MetaWindowActor
 GType meta_window_actor_get_type (void);
 
 Window             meta_window_actor_get_x_window         (MetaWindowActor *self);
-gint               meta_window_actor_get_workspace        (MetaWindowActor *self);
 MetaWindow *       meta_window_actor_get_meta_window      (MetaWindowActor *self);
 ClutterActor *     meta_window_actor_get_texture          (MetaWindowActor *self);
-gboolean           meta_window_actor_is_override_redirect (MetaWindowActor *self);
-gboolean       meta_window_actor_showing_on_its_workspace (MetaWindowActor *self);
 gboolean       meta_window_actor_is_destroyed (MetaWindowActor *self);
 
 #endif /* META_WINDOW_ACTOR_H */

src/meta/prefs.h

@@ -248,7 +248,6 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
  * @META_KEYBINDING_ACTION_LOWER: FILLME 
  * @META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY: FILLME 
  * @META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY: FILLME 
- * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CORNER_SW: FILLME 
@@ -259,6 +258,7 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
  * @META_KEYBINDING_ACTION_MOVE_TO_SIDE_W: FILLME 
  * @META_KEYBINDING_ACTION_MOVE_TO_CENTER: FILLME 
  * @META_KEYBINDING_ACTION_OVERLAY_KEY: FILLME 
+ * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
  * @META_KEYBINDING_ACTION_LAST: FILLME 
  */
 /* XXX FIXME This should be x-macroed, but isn't yet because it would be
@@ -340,7 +340,6 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_RAISE,
   META_KEYBINDING_ACTION_LOWER,
   META_KEYBINDING_ACTION_MAXIMIZE_VERTICALLY,
-  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
   META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
   META_KEYBINDING_ACTION_MOVE_TO_CORNER_NW,
   META_KEYBINDING_ACTION_MOVE_TO_CORNER_NE,
@@ -353,6 +352,7 @@ typedef enum _MetaKeyBindingAction
   META_KEYBINDING_ACTION_MOVE_TO_CENTER,
   META_KEYBINDING_ACTION_OVERLAY_KEY,
   META_KEYBINDING_ACTION_ISO_NEXT_GROUP,
+  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
 
   META_KEYBINDING_ACTION_LAST
 } MetaKeyBindingAction;

src/meta/window.h

@@ -105,8 +105,8 @@ void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
 void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect) G_GNUC_DEPRECATED;
 
 void meta_window_client_rect_to_frame_rect (MetaWindow    *window,
-                                            MetaRectangle *frame_rect,
-                                            MetaRectangle *client_rect);
+                                            MetaRectangle *client_rect,
+                                            MetaRectangle *frame_rect);
 void meta_window_frame_rect_to_client_rect (MetaWindow    *window,
                                             MetaRectangle *frame_rect,
                                             MetaRectangle *client_rect);
@@ -154,7 +154,6 @@ void meta_window_change_workspace_by_index (MetaWindow *window,
 void meta_window_change_workspace          (MetaWindow  *window,
                                             MetaWorkspace *workspace);
 GObject *meta_window_get_compositor_private (MetaWindow *window);
-void meta_window_set_compositor_private (MetaWindow *window, GObject *priv);
 void meta_window_configure_notify (MetaWindow *window, XConfigureEvent *event);
 const char *meta_window_get_role (MetaWindow *window);
 MetaStackLayer meta_window_get_layer (MetaWindow *window);
@@ -227,7 +226,7 @@ void        meta_window_stick              (MetaWindow  *window);
 void        meta_window_unstick            (MetaWindow  *window);
 
 void        meta_window_kill               (MetaWindow  *window);
-void        meta_window_focus_explicitly   (MetaWindow  *window,
+void        meta_window_focus              (MetaWindow  *window,
                                             guint32      timestamp);
 
 void        meta_window_check_alive        (MetaWindow  *window,