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
@@ -175,31 +166,6 @@ process_damage (MetaCompositor     *compositor,
   meta_window_actor_process_damage (window_actor, event);
 }
 
-static void
-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)
-    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");
-}
-
 static Window
 get_output_window (MetaScreen *screen)
 {
@@ -877,6 +843,18 @@ meta_compositor_window_shape_changed (MetaCompositor *compositor,
   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
  * per stage, which is a valid assumption to make for a generic
  * application toolkit. As such, it will ignore any events sent
@@ -983,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
@@ -1304,30 +1273,6 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
   sync_actor_stacking (info);
 }
 
-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);
-}
-
-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);
-}
-
 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
@@ -1508,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;
@@ -1526,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-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

@@ -46,7 +46,6 @@ static guint signals[LAST_SIGNAL] = {0};
 struct _MetaWindowActorPrivate
 {
   MetaWindow       *window;
-  Window            xwindow;
   MetaScreen       *screen;
 
   ClutterActor     *actor;
@@ -69,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 */
@@ -112,7 +109,6 @@ struct _MetaWindowActorPrivate
   GList            *frames;
 
   guint		    visible                : 1;
-  guint		    mapped                 : 1;
   guint		    argb32                 : 1;
   guint		    disposed               : 1;
   guint             redecorating           : 1;
@@ -155,8 +151,6 @@ struct _FrameData
 enum
 {
   PROP_META_WINDOW = 1,
-  PROP_META_SCREEN,
-  PROP_X_WINDOW,
   PROP_NO_SHADOW,
   PROP_SHADOW_CLASS
 };
@@ -225,33 +219,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",
@@ -294,7 +267,6 @@ 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;
 }
 
@@ -305,11 +277,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 +287,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,8 +301,6 @@ window_decorated_notify (MetaWindow *mw,
       priv->damage = None;
     }
 
-  priv->xwindow = new_xwindow;
-
   /*
    * Recreate the contents.
    */
@@ -352,18 +315,30 @@ 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)
 {
   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);
 
@@ -386,19 +361,6 @@ 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);
-    }
-  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);
@@ -491,17 +453,12 @@ 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);
+
+      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:
       {
@@ -547,12 +504,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;
@@ -650,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
@@ -676,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);
@@ -699,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 */
 
@@ -786,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;
 
   /*
@@ -820,20 +772,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
@@ -1001,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),
@@ -1090,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);
@@ -1122,9 +1060,6 @@ meta_window_actor_queue_create_pixmap (MetaWindowActor *self)
 
   priv->needs_pixmap = TRUE;
 
-  if (!priv->mapped)
-    return;
-
   if (is_frozen (self))
     return;
 
@@ -1338,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)
@@ -1369,7 +1304,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)
     {
@@ -1623,22 +1558,10 @@ meta_window_actor_new (MetaWindow *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,
+                       "meta-window", window,
                        NULL);
 
   priv = self->priv;
@@ -1646,10 +1569,6 @@ meta_window_actor_new (MetaWindow *window)
   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));
 
@@ -1683,34 +1602,6 @@ meta_window_actor_new (MetaWindow *window)
   return self;
 }
 
-void
-meta_window_actor_mapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  g_return_if_fail (!priv->mapped);
-
-  priv->mapped = TRUE;
-
-  meta_window_actor_queue_create_pixmap (self);
-}
-
-void
-meta_window_actor_unmapped (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-
-  g_return_if_fail (priv->mapped);
-
-  priv->mapped = FALSE;
-
-  if (meta_window_actor_effect_in_progress (self))
-    return;
-
-  meta_window_actor_detach (self);
-  priv->needs_pixmap = FALSE;
-}
-
 /**
  * meta_window_actor_get_obscured_region:
  * @self: a #MetaWindowActor
@@ -1725,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;
@@ -1906,15 +1798,12 @@ 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;
 
-  if (!priv->mapped)
-    return;
-
   if (xwindow == meta_screen_get_xroot (screen) ||
       xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
     return;
@@ -2000,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
@@ -2106,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),
@@ -2375,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;
 
@@ -2640,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/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/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,

src/core/display.c

@@ -2292,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)
             {
@@ -4008,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;
@@ -1580,7 +1580,7 @@ meta_window_grab_all_keys (MetaWindow  *window,
               window->desc);
   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/window-private.h

@@ -355,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;
@@ -695,5 +698,9 @@ 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);
 
 #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
@@ -1706,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,       \
@@ -1808,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

@@ -1201,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;
@@ -1445,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);
 
@@ -1670,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)
@@ -3141,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)
@@ -3290,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);
@@ -3900,8 +3891,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",
@@ -3915,6 +3908,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.
        */
@@ -3959,9 +3958,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,
@@ -5767,8 +5764,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
@@ -5776,13 +5773,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
@@ -5793,24 +5790,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;
         }
     }
 }
@@ -5907,7 +5904,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,
@@ -11432,3 +11429,19 @@ meta_window_can_close (MetaWindow *window)
 {
   return window->has_close_func;
 }
+
+Window
+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/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);