compositor: Remove meta_compositor_window_[un]mapped

We no longer unmap the toplevel windows during normal operation. The
toplevel state is tied to the window's lifetime.

Call meta_compositor_add_window / meta_compositor_remove_window instead...

doc/reference/meta-sections.txt

@@ -96,8 +96,6 @@ meta_compositor_hide_window
 meta_compositor_switch_workspace
 meta_compositor_maximize_window
 meta_compositor_unmaximize_window
-meta_compositor_window_mapped
-meta_compositor_window_unmapped
 meta_compositor_sync_window_geometry
 meta_compositor_set_updates_frozen
 meta_compositor_queue_frame_drawn

src/compositor/compositor-private.h

@@ -17,8 +17,6 @@ struct _MetaCompositor
 {
   MetaDisplay    *display;
 
-  Atom            atom_x_root_pixmap;
-  Atom            atom_net_wm_window_opacity;
   guint           repaint_func_id;
 
   ClutterActor   *shadow_src;

src/compositor/compositor.c

@@ -42,15 +42,6 @@
  * the call, so it may be necessary to readjust the display based on the
  * old_rect to start the animation.
  *
- * meta_compositor_window_mapped() and meta_compositor_window_unmapped() are
- * notifications when the toplevel window (frame or client window) is mapped or
- * unmapped. That is, when the result of meta_window_toplevel_is_mapped()
- * changes. The main use of this is to drop resources when a window is unmapped.
- * A window will always be mapped before meta_compositor_show_window()
- * is called and will not be unmapped until after meta_compositor_hide_window()
- * is called. If the live_hidden_windows preference is set, windows will never
- * be unmapped.
- *
  * # Containers #
  *
  * There's two containers in the stage that are used to place window actors, here
@@ -150,28 +141,10 @@ 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);
 
-  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);
+  meta_window_actor_new (window);
 
   sync_actor_stacking (info);
 }
@@ -181,26 +154,16 @@ process_damage (MetaCompositor     *compositor,
                 XDamageNotifyEvent *event,
                 MetaWindow         *window)
 {
-  GSList *iter;
+  MetaWindowActor *window_actor;
 
   if (window == NULL)
     return;
 
-  for (iter = window->actors; iter != NULL; iter = iter->next)
-    meta_window_actor_process_damage (META_WINDOW_ACTOR (iter->data), event);
-}
-
-static void
-process_property_notify (MetaCompositor	*compositor,
-                         XPropertyEvent *event,
-                         MetaWindow     *window)
-{
-  if (window == NULL || window->core_actor == NULL)
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (window_actor == NULL)
     return;
 
-  /* Check for the opacity changing */
-  if (event->atom == compositor->atom_net_wm_window_opacity)
-    meta_window_actor_update_opacity (window->core_actor);
+  meta_window_actor_process_damage (window_actor, event);
 }
 
 static Window
@@ -792,30 +755,27 @@ 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->core_actor == info->unredirected_window)
+  if (window_actor == info->unredirected_window)
     {
-      meta_window_actor_set_redirected (info->unredirected_window, TRUE);
-      meta_shape_cow_for_window (meta_window_get_screen (window), NULL);
+      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);
       info->unredirected_window = NULL;
     }
 
-  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);
-    }
+  meta_window_actor_destroy (window_actor);
 }
 
 void
@@ -875,10 +835,24 @@ void
 meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                       MetaWindow     *window)
 {
-  GSList *iter;
+  MetaWindowActor *window_actor;
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (!window_actor)
+    return;
 
-  for (iter = window->actors; iter != NULL; iter = iter->next)
-    meta_window_actor_update_shape (META_WINDOW_ACTOR (iter->data));
+  meta_window_actor_update_shape (window_actor);
+}
+
+void
+meta_compositor_window_opacity_changed (MetaCompositor *compositor,
+                                        MetaWindow     *window)
+{
+  MetaWindowActor *window_actor;
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (!window_actor)
+    return;
+
+  meta_window_actor_update_opacity (window_actor);
 }
 
 /* Clutter makes the assumption that there is only one X window
@@ -987,28 +961,19 @@ meta_compositor_process_event (MetaCompositor *compositor,
 	}
     }
 
-  switch (event->type)
+  if (event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
     {
-    case PropertyNotify:
-      process_property_notify (compositor, (XPropertyEvent *) event, window);
-      break;
-
-    default:
-      if (event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
+      /* Core code doesn't handle damage events, so we need to extract the MetaWindow
+       * ourselves
+       */
+      if (window == NULL)
         {
-          /* Core code doesn't handle damage events, so we need to extract the MetaWindow
-           * ourselves
-           */
-          if (window == NULL)
-            {
-              Window xwin = ((XDamageNotifyEvent *) event)->drawable;
-              window = meta_display_lookup_x_window (compositor->display, xwin);
-            }
-
-	  DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
-          process_damage (compositor, (XDamageNotifyEvent *) event, window);
+          Window xwin = ((XDamageNotifyEvent *) event)->drawable;
+          window = meta_display_lookup_x_window (compositor->display, xwin);
         }
-      break;
+
+      DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
+      process_damage (compositor, (XDamageNotifyEvent *) event, window);
     }
 
   /* Clutter needs to know about MapNotify events otherwise it will
@@ -1041,8 +1006,12 @@ meta_compositor_show_window (MetaCompositor *compositor,
 			     MetaWindow	    *window,
                              MetaCompEffect  effect)
 {
-  if (window->core_actor != NULL)
-    meta_window_actor_show (window->core_actor, 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);
 }
 
 void
@@ -1050,8 +1019,12 @@ meta_compositor_hide_window (MetaCompositor *compositor,
                              MetaWindow     *window,
                              MetaCompEffect  effect)
 {
-  if (window->core_actor != NULL)
-    meta_window_actor_hide (window->core_actor, 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);
 }
 
 void
@@ -1060,8 +1033,12 @@ meta_compositor_maximize_window (MetaCompositor    *compositor,
 				 MetaRectangle	   *old_rect,
 				 MetaRectangle	   *new_rect)
 {
-  if (window->core_actor != NULL)
-    meta_window_actor_maximize (window->core_actor, old_rect, 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);
 }
 
 void
@@ -1070,8 +1047,12 @@ meta_compositor_unmaximize_window (MetaCompositor    *compositor,
 				   MetaRectangle     *old_rect,
 				   MetaRectangle     *new_rect)
 {
-  if (window->core_actor != NULL)
-    meta_window_actor_unmaximize (window->core_actor, old_rect, 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);
 }
 
 void
@@ -1247,7 +1228,7 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
       while (stack)
         {
           stack_window = stack->data;
-          stack_actor = stack_window->core_actor;
+          stack_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (stack_window));
           if (!stack_actor)
             {
               meta_verbose ("Failed to find corresponding MetaWindowActor "
@@ -1292,29 +1273,22 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
   sync_actor_stacking (info);
 }
 
-void
-meta_compositor_window_mapped (MetaCompositor *compositor,
-                               MetaWindow     *window)
-{
-  if (window->core_actor != NULL)
-    meta_window_actor_mapped (window->core_actor);
-}
-
-void
-meta_compositor_window_unmapped (MetaCompositor *compositor,
-                                 MetaWindow     *window)
-{
-  if (window->core_actor != NULL)
-    meta_window_actor_unmapped (window->core_actor);
-}
-
 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
                                       gboolean did_placement)
 {
-  if (window->core_actor != NULL)
-    meta_window_actor_sync_actor_geometry (window->core_actor, 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);
 }
 
 void
@@ -1479,13 +1453,7 @@ on_shadow_factory_changed (MetaShadowFactory *factory,
 MetaCompositor *
 meta_compositor_new (MetaDisplay *display)
 {
-  char *atom_names[] = {
-    "_XROOTPMAP_ID",
-    "_NET_WM_WINDOW_OPACITY",
-  };
-  Atom                   atoms[G_N_ELEMENTS(atom_names)];
   MetaCompositor        *compositor;
-  Display               *xdisplay = meta_display_get_xdisplay (display);
 
   if (!composite_at_least_version (display, 0, 3))
     return NULL;
@@ -1497,18 +1465,11 @@ meta_compositor_new (MetaDisplay *display)
   if (g_getenv("META_DISABLE_MIPMAPS"))
     compositor->no_mipmaps = TRUE;
 
-  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
-  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
-                False, atoms);
-
   g_signal_connect (meta_shadow_factory_get_default (),
                     "changed",
                     G_CALLBACK (on_shadow_factory_changed),
                     compositor);
 
-  compositor->atom_x_root_pixmap = atoms[0];
-  compositor->atom_net_wm_window_opacity = atoms[1];
-
   compositor->repaint_func_id = clutter_threads_add_repaint_func (meta_repaint_func,
                                                                   compositor,
                                                                   NULL);

src/compositor/meta-window-actor.c

@@ -34,7 +34,14 @@
 #include "monitor-private.h"
 #include "meta-cullable.h"
 
-static void meta_window_actor_queue_create_pixmap (MetaWindowActor *self);
+enum {
+  POSITION_CHANGED,
+  SIZE_CHANGED,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = {0};
+
 
 struct _MetaWindowActorPrivate
 {
@@ -61,8 +68,6 @@ struct _MetaWindowActorPrivate
 
   Damage            damage;
 
-  guint8            opacity;
-
   /* A region that matches the shape of the window, including frame bounds */
   cairo_region_t   *shape_region;
   /* If the window has an input shape, a region that matches the shape */
@@ -104,7 +109,6 @@ struct _MetaWindowActorPrivate
   GList            *frames;
 
   guint		    visible                : 1;
-  guint		    mapped                 : 1;
   guint		    argb32                 : 1;
   guint		    disposed               : 1;
   guint             redecorating           : 1;
@@ -240,6 +244,19 @@ 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
@@ -250,11 +267,7 @@ meta_window_actor_init (MetaWindowActor *self)
   priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 						   META_TYPE_WINDOW_ACTOR,
 						   MetaWindowActorPrivate);
-  priv->opacity = 0xff;
   priv->shadow_class = NULL;
-
-  priv->last_width = -1;
-  priv->last_height = -1;
 }
 
 static void
@@ -288,8 +301,6 @@ window_decorated_notify (MetaWindow *mw,
       priv->damage = None;
     }
 
-  priv->xwindow = meta_window_get_toplevel_xwindow (priv->window);
-
   /*
    * Recreate the contents.
    */
@@ -304,6 +315,15 @@ window_appears_focused_notify (MetaWindow *mw,
   clutter_actor_queue_redraw (CLUTTER_ACTOR (data));
 }
 
+static gboolean
+is_non_opaque (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+  MetaWindow *window = priv->window;
+
+  return priv->argb32 || (window->opacity != 0xFF);
+}
+
 static void
 meta_window_actor_constructed (GObject *object)
 {
@@ -341,34 +361,13 @@ meta_window_actor_constructed (GObject *object)
        * We will release it in dispose().
        */
       g_object_ref (priv->actor);
-
-      g_signal_connect_object (window, "notify::decorated",
-                               G_CALLBACK (window_decorated_notify), self, 0);
-      g_signal_connect_object (window, "notify::appears-focused",
-                               G_CALLBACK (window_appears_focused_notify), self, 0);
     }
 
   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
@@ -379,6 +378,7 @@ meta_window_actor_dispose (GObject *object)
   MetaScreen             *screen;
   MetaDisplay            *display;
   Display                *xdisplay;
+  MetaCompScreen         *info;
 
   if (priv->disposed)
     return;
@@ -388,6 +388,7 @@ 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);
 
@@ -417,6 +418,8 @@ meta_window_actor_dispose (GObject *object)
       priv->damage = None;
     }
 
+  info->windows = g_list_remove (info->windows, (gconstpointer) self);
+
   g_clear_object (&priv->window);
 
   /*
@@ -451,6 +454,11 @@ meta_window_actor_set_property (GObject      *object,
     {
     case PROP_META_WINDOW:
       priv->window = g_value_dup_object (value);
+
+      g_signal_connect_object (priv->window, "notify::decorated",
+                               G_CALLBACK (window_decorated_notify), self, 0);
+      g_signal_connect_object (priv->window, "notify::appears-focused",
+                               G_CALLBACK (window_appears_focused_notify), self, 0);
       break;
     case PROP_NO_SHADOW:
       {
@@ -593,7 +601,7 @@ clip_shadow_under_window (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
 
-  return (priv->argb32 || priv->opacity != 0xff) && priv->window->frame;
+  return is_non_opaque (self) && priv->window->frame;
 }
 
 static void
@@ -619,6 +627,7 @@ meta_window_actor_paint (ClutterActor *actor)
       MetaShadowParams params;
       cairo_rectangle_int_t shape_bounds;
       cairo_region_t *clip = priv->shadow_clip;
+      MetaWindow *window = priv->window;
 
       meta_window_actor_get_shape_bounds (self, &shape_bounds);
       meta_window_actor_get_shadow_params (self, appears_focused, &params);
@@ -642,7 +651,7 @@ meta_window_actor_paint (ClutterActor *actor)
                          params.y_offset + shape_bounds.y,
                          shape_bounds.width,
                          shape_bounds.height,
-                         (clutter_actor_get_paint_opacity (actor) * params.opacity * priv->opacity) / (255 * 255),
+                         (clutter_actor_get_paint_opacity (actor) * params.opacity * window->opacity) / (255 * 255),
                          clip,
                          clip_shadow_under_window (self)); /* clip_strictly - not just as an optimization */
 
@@ -729,10 +738,10 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
     return TRUE;
 
   /*
-   * Do not add shadows to ARGB windows; eventually we should generate a
-   * shadow from the input shape for such windows.
+   * Do not add shadows to non-opaque windows; eventually we should generate
+   * a shadow from the input shape for such windows.
    */
-  if (priv->argb32 || priv->opacity != 0xff)
+  if (is_non_opaque (self))
     return FALSE;
 
   /*
@@ -805,6 +814,59 @@ 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)
 {
@@ -877,7 +939,7 @@ meta_window_actor_damage_all (MetaWindowActor *self)
 
   texture = meta_shaped_texture_get_texture (META_SHAPED_TEXTURE (priv->actor));
 
-  if (!priv->mapped || priv->needs_pixmap)
+  if (priv->needs_pixmap)
     return;
 
   redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
@@ -966,7 +1028,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
         {
           queue_send_frame_messages_timeout (self);
         }
-      else if (priv->mapped && !priv->needs_pixmap)
+      else
         {
           const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
           clutter_actor_queue_redraw_with_clip (priv->actor, &clip);
@@ -998,9 +1060,6 @@ meta_window_actor_queue_create_pixmap (MetaWindowActor *self)
 
   priv->needs_pixmap = TRUE;
 
-  if (!priv->mapped)
-    return;
-
   if (is_frozen (self))
     return;
 
@@ -1214,7 +1273,7 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
   if (meta_window_requested_dont_bypass_compositor (metaWindow))
     return FALSE;
 
-  if (priv->opacity != 0xff)
+  if (metaWindow->opacity != 0xFF)
     return FALSE;
 
   if (metaWindow->shape_region != NULL)
@@ -1268,6 +1327,7 @@ void
 meta_window_actor_destroy (MetaWindowActor *self)
 {
   MetaWindow	      *window;
+  MetaCompScreen      *info;
   MetaWindowActorPrivate *priv;
   MetaWindowType window_type;
 
@@ -1275,6 +1335,14 @@ 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 ||
@@ -1337,6 +1405,8 @@ 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
@@ -1484,37 +1554,52 @@ meta_window_actor_unmaximize (MetaWindowActor   *self,
 MetaWindowActor *
 meta_window_actor_new (MetaWindow *window)
 {
-  return g_object_new (META_TYPE_WINDOW_ACTOR,
+  MetaScreen	 	 *screen = meta_window_get_screen (window);
+  MetaCompScreen         *info = meta_screen_get_compositor_data (screen);
+  MetaWindowActor        *self;
+  MetaWindowActorPrivate *priv;
+  ClutterActor           *window_group;
+
+  self = g_object_new (META_TYPE_WINDOW_ACTOR,
                        "meta-window", window,
                        NULL);
-}
 
-void
-meta_window_actor_mapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
+  priv = self->priv;
 
-  g_return_if_fail (!priv->mapped);
+  priv->last_width = -1;
+  priv->last_height = -1;
 
-  priv->mapped = TRUE;
+  meta_window_actor_set_updates_frozen (self,
+                                        meta_window_updates_are_frozen (priv->window));
 
-  meta_window_actor_queue_create_pixmap (self);
-}
+  /* 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);
 
-void
-meta_window_actor_unmapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
+  meta_window_actor_sync_actor_geometry (self, priv->window->placed);
 
-  g_return_if_fail (priv->mapped);
+  /* Hang our compositor window state off the MetaWindow for fast retrieval */
+  meta_window_set_compositor_private (window, G_OBJECT (self));
 
-  priv->mapped = FALSE;
+  if (window->layer == META_LAYER_OVERRIDE_REDIRECT)
+    window_group = info->top_window_group;
+  else
+    window_group = info->window_group;
 
-  if (meta_window_actor_effect_in_progress (self))
-    return;
+  clutter_actor_add_child (window_group, CLUTTER_ACTOR (self));
 
-  meta_window_actor_detach (self);
-  priv->needs_pixmap = FALSE;
+  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;
 }
 
 /**
@@ -1531,8 +1616,9 @@ static cairo_region_t *
 meta_window_actor_get_obscured_region (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
+  MetaWindow *window = priv->window;
 
-  if (priv->back_pixmap && priv->opacity == 0xff && !priv->window->shaded)
+  if (priv->back_pixmap && window->opacity != 0xFF && !priv->window->shaded)
     return priv->opaque_region;
   else
     return NULL;
@@ -1718,9 +1804,6 @@ check_needs_pixmap (MetaWindowActor *self)
   if (!priv->needs_pixmap)
     return;
 
-  if (!priv->mapped)
-    return;
-
   if (xwindow == meta_screen_get_xroot (screen) ||
       xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
     return;
@@ -1777,6 +1860,17 @@ 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;
@@ -1795,9 +1889,6 @@ check_needs_shadow (MetaWindowActor *self)
   gboolean should_have_shadow;
   gboolean appears_focused;
 
-  if (!priv->mapped)
-    return;
-
   /* Calling meta_window_actor_has_shadow() here at every pre-paint is cheap
    * and avoids the need to explicitly handle window type changes, which
    * we would do if tried to keep track of when we might be adding or removing
@@ -1901,7 +1992,7 @@ meta_window_actor_process_damage (MetaWindowActor    *self,
       return;
     }
 
-  if (!priv->mapped || priv->needs_pixmap)
+  if (priv->needs_pixmap)
     return;
 
   redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
@@ -2170,9 +2261,6 @@ check_needs_reshape (MetaWindowActor *self)
   MetaFrameBorders borders;
   cairo_rectangle_int_t client_area;
 
-  if (!priv->mapped)
-    return;
-
   if (!priv->needs_reshape)
     return;
 
@@ -2435,23 +2523,9 @@ void
 meta_window_actor_update_opacity (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
-  MetaDisplay *display = meta_screen_get_display (priv->screen);
-  MetaCompositor *compositor = meta_display_get_compositor (display);
-  Window xwin = meta_window_get_xwindow (priv->window);
-  gulong value;
-  guint8 opacity;
+  MetaWindow *window = priv->window;
 
-  if (meta_prop_get_cardinal (display, xwin,
-                              compositor->atom_net_wm_window_opacity,
-                              &value))
-    {
-      opacity = (guint8)((gfloat)value * 255.0 / ((gfloat)0xffffffff));
-    }
-  else
-    opacity = 255;
-
-  self->priv->opacity = opacity;
-  clutter_actor_set_opacity (self->priv->actor, opacity);
+  clutter_actor_set_opacity (self->priv->actor, window->opacity);
 }
 
 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_get_workspace (meta_window_actor_get_meta_window (window_actor));
+      win_workspace = meta_window_actor_get_workspace (window_actor);
 
       if (win_workspace == to || win_workspace == from)
         {

src/core/window-private.h

@@ -36,7 +36,6 @@
 
 #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>
@@ -356,6 +355,9 @@ struct _MetaWindow
   /* the input shape region for picking */
   cairo_region_t *input_region;
 
+  /* _NET_WM_WINDOW_OPACITY */
+  guint opacity;
+
   /* if TRUE, the we have the new form of sync request counter which
    * also handles application frames */
   guint extended_sync_request_counter : 1;
@@ -439,10 +441,7 @@ struct _MetaWindow
   /* maintained by group.c */
   MetaGroup *group;
 
-  GSList *actors;
-
-  /* The core actor is the one in the window group. */
-  MetaWindowActor *core_actor;
+  GObject *compositor_private;
 
   /* Focused window that is (directly or indirectly) attached to this one */
   MetaWindow *attached_focus_window;
@@ -699,6 +698,8 @@ void meta_window_update_input_region_x11  (MetaWindow *window);
 void meta_window_set_shape_region         (MetaWindow     *window,
                                            cairo_region_t *region);
 void meta_window_update_shape_region_x11  (MetaWindow *window);
+void meta_window_set_opacity              (MetaWindow *window,
+                                           guint       opacity);
 
 Window meta_window_get_toplevel_xwindow (MetaWindow *window);
 

src/core/window-props.c

@@ -1709,6 +1709,20 @@ reload_bypass_compositor (MetaWindow    *window,
   window->bypass_compositor = requested_value;
 }
 
+static void
+reload_window_opacity (MetaWindow    *window,
+                       MetaPropValue *value,
+                       gboolean       initial)
+
+{
+  int requested_value = 0xFF;
+
+  if (value->type != META_PROP_VALUE_INVALID)
+    requested_value = (int) value->v.cardinal;
+
+  meta_window_set_opacity (window, requested_value);
+}
+
 #define RELOAD_STRING(var_name, propname) \
   static void                                       \
   reload_ ## var_name (MetaWindow    *window,       \
@@ -1811,6 +1825,7 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
     { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
     { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
     { display->atom__NET_WM_BYPASS_COMPOSITOR, META_PROP_VALUE_CARDINAL,  reload_bypass_compositor, FALSE, FALSE },
+    { display->atom__NET_WM_WINDOW_OPACITY, META_PROP_VALUE_CARDINAL, reload_window_opacity,  TRUE, TRUE },
     { 0 },
   };
 

src/core/window.c

@@ -194,8 +194,6 @@ enum
   FOCUS,
   RAISED,
   UNMANAGED,
-  SIZE_CHANGED,
-  POSITION_CHANGED,
 
   LAST_SIGNAL
 };
@@ -589,22 +587,6 @@ 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
@@ -1193,8 +1175,7 @@ meta_window_new_with_attrs (MetaDisplay       *display,
   window->initial_workspace = 0; /* not used */
   window->initial_timestamp = 0; /* not used */
 
-  window->core_actor = NULL;
-  window->actors = NULL;
+  window->compositor_private = NULL;
 
   window->monitor = meta_screen_get_monitor_for_window (window->screen, window);
 
@@ -1220,6 +1201,8 @@ meta_window_new_with_attrs (MetaDisplay       *display,
    */
   window->stable_sequence = ++display->window_sequence_counter;
 
+  window->opacity = 0xFF;
+
   /* assign the window to its group, or create a new group if needed
    */
   window->group = NULL;
@@ -1464,9 +1447,6 @@ meta_window_new_with_attrs (MetaDisplay       *display,
       set_net_wm_state (window);
     }
 
-  if (screen->display->compositor)
-    meta_compositor_add_window (screen->display->compositor, window);
-
   /* Sync stack changes */
   meta_stack_thaw (window->screen->stack);
 
@@ -1689,8 +1669,6 @@ meta_window_unmanage (MetaWindow  *window,
       if (window->visible_to_compositor)
         meta_compositor_hide_window (window->display->compositor, window,
                                      META_COMP_EFFECT_DESTROY);
-
-      meta_compositor_remove_window (window->display->compositor, window);
     }
 
   if (window->display->window_with_menu == window)
@@ -3160,7 +3138,7 @@ meta_window_show (MetaWindow *window)
   if (toplevel_now_mapped != toplevel_was_mapped)
     {
       if (window->display->compositor)
-        meta_compositor_window_mapped (window->display->compositor, window);
+        meta_compositor_add_window (window->display->compositor, window);
     }
 
   if (!window->visible_to_compositor)
@@ -3309,13 +3287,7 @@ meta_window_hide (MetaWindow *window)
   if (toplevel_now_mapped != toplevel_was_mapped)
     {
       if (window->display->compositor)
-        {
-          /* As above, we may be *mapping* live hidden windows */
-          if (toplevel_now_mapped)
-            meta_compositor_window_mapped (window->display->compositor, window);
-          else
-            meta_compositor_window_unmapped (window->display->compositor, window);
-        }
+        meta_compositor_remove_window (window->display->compositor, window);
     }
 
   set_net_wm_state (window);
@@ -5302,12 +5274,6 @@ 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)
@@ -11065,15 +11031,24 @@ meta_window_get_gtk_menubar_object_path (MetaWindow *window)
  * meta_window_get_compositor_private:
  * @window: a #MetaWindow
  *
- * Return value: (transfer none):
- */
+ * Gets the compositor's wrapper object for @window.
+ *
+ * Return value: (transfer none): the wrapper object.
+ **/
 GObject *
 meta_window_get_compositor_private (MetaWindow *window)
 {
   if (!window)
     return NULL;
+  return window->compositor_private;
+}
 
-  return G_OBJECT (window->core_actor);
+void
+meta_window_set_compositor_private (MetaWindow *window, GObject *priv)
+{
+  if (!window)
+    return;
+  window->compositor_private = priv;
 }
 
 const char *
@@ -11460,3 +11435,13 @@ meta_window_get_toplevel_xwindow (MetaWindow *window)
 {
   return window->frame ? window->frame->xwindow : window->xwindow;
 }
+
+void
+meta_window_set_opacity (MetaWindow *window,
+                         guint       opacity)
+{
+  window->opacity = opacity;
+
+  if (window->display->compositor)
+    meta_compositor_window_opacity_changed (window->display->compositor, window);
+}

src/meta/atomnames.h

@@ -179,6 +179,7 @@ item(_NET_WM_BYPASS_COMPOSITOR)
 item(_NET_WM_OPAQUE_REGION)
 item(_NET_WM_FRAME_DRAWN)
 item(_NET_WM_FRAME_TIMINGS)
+item(_NET_WM_WINDOW_OPACITY)
 
 #if 0
 /* We apparently never use: */

src/meta/compositor.h

@@ -66,6 +66,8 @@ void meta_compositor_unmanage_screen (MetaCompositor *compositor,
 
 void meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                            MetaWindow     *window);
+void meta_compositor_window_opacity_changed (MetaCompositor *compositor,
+                                             MetaWindow     *window);
 
 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                         XEvent         *event,
@@ -75,11 +77,10 @@ gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor,
                                             MetaScreen     *screen,
                                             MetaKeyBinding *binding);
 
-void meta_compositor_add_window    (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-void meta_compositor_remove_window (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-
+void meta_compositor_add_window        (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
+void meta_compositor_remove_window     (MetaCompositor      *compositor,
+                                        MetaWindow          *window);
 void meta_compositor_show_window       (MetaCompositor      *compositor,
                                         MetaWindow          *window,
                                         MetaCompEffect       effect);
@@ -101,10 +102,6 @@ void meta_compositor_unmaximize_window (MetaCompositor      *compositor,
                                         MetaRectangle       *old_rect,
                                         MetaRectangle       *new_rect);
 
-void meta_compositor_window_mapped        (MetaCompositor *compositor,
-                                           MetaWindow     *window);
-void meta_compositor_window_unmapped      (MetaCompositor *compositor,
-                                           MetaWindow     *window);
 void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
                                            MetaWindow     *window,
                                            gboolean        did_placement);

src/meta/meta-window-actor.h

@@ -60,8 +60,11 @@ 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/window.h

@@ -154,6 +154,7 @@ 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);