Bump version to 3.0.2

Update NEWS

NEWS

@@ -1,3 +1,45 @@
+3.0.2
+=====
+
+* Fix a crash when running without XKB support [Adam]
+  https://bugzilla.gnome.org/show_bug.cgi?id=647777
+* Fix smallish memory leaks [Colin]
+  https://bugzilla.gnome.org/show_bug.cgi?id=649500
+  https://bugzilla.gnome.org/show_bug.cgi?id=649504
+* Ignore mirrored monitors when listing monitors, fixing
+  drag-and-drop problems in GNOME Shell [Owen]
+  https://bugzilla.gnome.org/show_bug.cgi?id=649299
+* Don't allow side-by-side tiling of non-maximizable windows
+  like dialogs and utility windows [Dan]
+* Fix interaction of _NET_WM_WINDOW_OPACITY with window effects,
+  making it work again with GNOME Shell
+  https://bugzilla.gnome.org/show_bug.cgi?id=648613
+
+Contributors:
+ Adam Jackson, Colin Walters, Dan Winship
+
+Translations:
+ Abduxukur Abdurixit [ug]
+
+3.0.1
+=====
+
+* If WM_CLIENT_MACHINE isn't set, don't assume a window is remote;
+  fixes behavior of Fox toolkit applications under GNOME Shell.
+  https://bugzilla.gnome.org/show_bug.cgi?id=647662 [Colin]
+* Fix cases where windows could get stuck drawing as focused after
+  an attached modal dialog was closed. [Dan]
+  https://bugzilla.gnome.org/show_bug.cgi?id=647613
+* Fix a bug where a window that is too big to be tiled side-by-side
+  would behave strangely when using the gesture of dragging to
+  the top to maximize. [Florian]
+
+Contributors:
+ Florian Müllner, Colin Walters, Dan Winship
+
+Translations:
+ Amitakhya Phukan [as], Kristjan Schmidt [eo], Muhammet Kara [tr]
+
 3.0.0
 =====
 

configure.in

@@ -2,7 +2,7 @@ AC_PREREQ(2.50)
 
 m4_define([mutter_major_version], [3])
 m4_define([mutter_minor_version], [0])
-m4_define([mutter_micro_version], [0])
+m4_define([mutter_micro_version], [2])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])

po/LINGUAS

@@ -22,6 +22,7 @@ dz
 el
 en_CA
 en_GB
+eo
 es
 et
 eu

src/compositor/meta-window-actor.c

@@ -411,8 +411,6 @@ meta_window_actor_constructed (GObject *object)
   if (format && format->type == PictTypeDirect && format->direct.alphaMask)
     priv->argb32 = TRUE;
 
-  meta_window_actor_update_opacity (self);
-
   if (!priv->actor)
     {
       priv->actor = meta_shaped_texture_new ();
@@ -442,7 +440,7 @@ meta_window_actor_constructed (GObject *object)
       clutter_actor_raise_top (priv->actor);
     }
 
-
+  meta_window_actor_update_opacity (self);
   meta_window_actor_update_shape (self, priv->shaped);
 }
 
@@ -725,7 +723,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) / 255,
+                         (clutter_actor_get_paint_opacity (actor) * params.opacity * priv->opacity) / (255 * 255),
                          priv->shadow_clip);
     }
 
@@ -1690,7 +1688,7 @@ meta_window_actor_get_obscured_region (MetaWindowActor *self)
 {
   MetaWindowActorPrivate *priv = self->priv;
 
-  if (!priv->argb32 && priv->back_pixmap)
+  if (!priv->argb32 && priv->opacity == 0xff && priv->back_pixmap)
     {
       if (priv->shaped)
         return priv->shape_region;
@@ -2147,5 +2145,5 @@ meta_window_actor_update_opacity (MetaWindowActor *self)
     opacity = 255;
 
   self->priv->opacity = opacity;
-  clutter_actor_set_opacity (CLUTTER_ACTOR (self), opacity);
+  clutter_actor_set_opacity (self->priv->actor, opacity);
 }

src/compositor/region-utils.c

@@ -248,7 +248,6 @@ expand_region_inverse (cairo_region_t *region,
   MetaRegionBuilder builder;
   MetaRegionIterator iter;
   cairo_rectangle_int_t extents;
-  cairo_region_t *chunk;
 
   int last_x;
 
@@ -268,16 +267,11 @@ expand_region_inverse (cairo_region_t *region,
                      extents.x, extents.y + extents.height, extents.width, 1,
                      x_amount, y_amount, flip);
 
-  chunk = NULL;
-
   last_x = extents.x;
   for (meta_region_iterator_init (&iter, region);
        !meta_region_iterator_at_end (&iter);
        meta_region_iterator_next (&iter))
     {
-      if (chunk == NULL)
-        chunk = cairo_region_create ();
-
       if (iter.rectangle.x > last_x)
         add_expanded_rect (&builder,
                            last_x, iter.rectangle.y,

src/core/above-tab-keycode.c

@@ -76,6 +76,8 @@ compute_above_tab_keycode (Display *xdisplay)
   keyboard = XkbGetKeyboard (xdisplay,
                              XkbGBN_ClientSymbolsMask | XkbGBN_KeyNamesMask | XkbGBN_GeometryMask,
                              XkbUseCoreKbd);
+  if (!keyboard)
+    return best_keycode;
 
   geometry = keyboard->geom;
 

src/core/screen.c

@@ -349,6 +349,43 @@ set_wm_icon_size_hint (MetaScreen *screen)
 #undef N_VALS
 }
 
+/* The list of monitors reported by the windowing system might include
+ * mirrored monitors with identical bounds. Since mirrored monitors
+ * shouldn't be treated as separate monitors for most purposes, we
+ * filter them out here. (We ignore the possibility of partially
+ * overlapping monitors because they are rare and it's hard to come
+ * up with any sensible interpretation.)
+ */
+static void
+filter_mirrored_monitors (MetaScreen *screen)
+{
+  int i, j;
+
+  /* Currently always true and simplifies things */
+  g_assert (screen->primary_monitor_index == 0);
+
+  for (i = 1; i < screen->n_monitor_infos; i++)
+    {
+      /* In case we've filtered previous monitors */
+      screen->monitor_infos[i].number = i;
+
+      for (j = 0; j < i; j++)
+        {
+          if (meta_rectangle_equal (&screen->monitor_infos[i].rect,
+                                    &screen->monitor_infos[j].rect))
+            {
+              memmove (&screen->monitor_infos[i],
+                       &screen->monitor_infos[i + 1],
+                       (screen->n_monitor_infos - i - 1) * sizeof (MetaMonitorInfo));
+              screen->n_monitor_infos--;
+              i--;
+
+              continue;
+            }
+        }
+    }
+}
+
 static void
 reload_monitor_infos (MetaScreen *screen)
 {
@@ -538,6 +575,8 @@ reload_monitor_infos (MetaScreen *screen)
       screen->monitor_infos[0].rect = screen->rect;
     }
 
+  filter_mirrored_monitors (screen);
+
   g_assert (screen->n_monitor_infos > 0);
   g_assert (screen->monitor_infos != NULL);
 }

src/core/window.c

@@ -3450,13 +3450,25 @@ meta_window_tile (MetaWindow *window)
     }
 }
 
+static gboolean
+meta_window_can_tile_maximized (MetaWindow *window)
+{
+  if (!META_WINDOW_ALLOWS_RESIZE (window))
+    return FALSE;
+
+  if (!window->has_maximize_func)
+    return FALSE;
+
+  return TRUE;
+}
+
 static gboolean
 meta_window_can_tile_side_by_side (MetaWindow *window)
 {
   const MetaMonitorInfo *monitor;
   MetaRectangle tile_area;
 
-  if (!META_WINDOW_ALLOWS_RESIZE (window))
+  if (!meta_window_can_tile_maximized (window))
     return FALSE;
 
   monitor = meta_screen_get_current_monitor (window->screen);
@@ -3482,18 +3494,6 @@ meta_window_can_tile_side_by_side (MetaWindow *window)
          tile_area.height >= window->size_hints.min_height;
 }
 
-static gboolean
-meta_window_can_tile_maximized (MetaWindow *window)
-{
-  if (!META_WINDOW_ALLOWS_RESIZE (window))
-    return FALSE;
-
-  if (!window->has_maximize_func)
-    return FALSE;
-
-  return TRUE;
-}
-
 static void
 unmaximize_window_before_freeing (MetaWindow        *window)
 {
@@ -6390,7 +6390,7 @@ meta_window_propagate_focus_appearance (MetaWindow *window,
 
   child = window;
   parent = meta_window_get_transient_for (child);
-  while (child->type == META_WINDOW_MODAL_DIALOG && parent)
+  while (parent && (!focused || child->type == META_WINDOW_MODAL_DIALOG))
     {
       gboolean child_focus_state_changed;
 
@@ -6409,7 +6409,8 @@ meta_window_propagate_focus_appearance (MetaWindow *window,
           parent->attached_focus_window = NULL;
         }
 
-      if (child_focus_state_changed && !parent->has_focus)
+      if (child_focus_state_changed && !parent->has_focus &&
+          parent != window->display->expected_focus_window)
         {
           g_object_notify (G_OBJECT (parent), "appears-focused");
           if (parent->frame)
@@ -8202,50 +8203,42 @@ update_move (MetaWindow  *window,
   shake_threshold = meta_ui_get_drag_threshold (window->screen->ui) *
     DRAG_THRESHOLD_TO_SHAKE_THRESHOLD_FACTOR;
 
-  if (meta_prefs_get_edge_tiling ())
+  if (meta_prefs_get_edge_tiling () &&
+      !META_WINDOW_MAXIMIZED (window) &&
+      !META_WINDOW_TILED_SIDE_BY_SIDE (window))
     {
       const MetaMonitorInfo *monitor;
       MetaRectangle work_area;
 
       /* For side-by-side tiling we are interested in the inside vertical
-       * edges of the work area of the monitor where the pointer is located.
-       * Also see comment in meta_window_get_current_tile_area()
+       * edges of the work area of the monitor where the pointer is located,
+       * and in the outside top edge for maximized tiling.
+       * Also see comment in meta_window_get_current_tile_area().
+       *
+       * For maximized tiling we use the outside edge instead of the
+       * inside edge, because we don't want to force users to maximize
+       * windows they are placing near the top of their screens.
        */
       monitor = meta_screen_get_current_monitor (window->screen);
       meta_window_get_work_area_for_monitor (window,
                                              monitor->number,
                                              &work_area);
 
-      if (meta_window_can_tile_side_by_side (window))
-        {
-          /* check if cursor is near an edge of the work area */
-          if (x >= monitor->rect.x && x < (work_area.x + shake_threshold))
-            window->tile_mode = META_TILE_LEFT;
-          else if (x >= work_area.x + work_area.width - shake_threshold &&
-                   x < (monitor->rect.x + monitor->rect.width))
-            window->tile_mode = META_TILE_RIGHT;
-          else
-            window->tile_mode = META_TILE_NONE;
-        }
-
-      /* For maximized tiling we are interested in the outside top edge
-       * of the work area of the monitor where the pointer is located.
-       *
-       * We use the outside edge instead of the inside edge, because we
-       * don't want to force users to maximize windows they are placing
-       * near the top of their screens.
-       *
-       * If window->tile_mode is not NONE, that means that either we are
-       * on an edge and set it above, or we are currently tiled (in
-       * which case meta_window_can_tile_side_by_side() and
-       * meta_window_can_tile_maximized() return FALSE).
+      /* Check if the cursor is in a position which triggers tiling
+       * and set tile_mode accordingly.
        */
-      if (window->tile_mode == META_TILE_NONE && meta_window_can_tile_maximized (window))
-        {
-          /* check if cursor is on the top edge of the monitor*/
-          if (y >= monitor->rect.y && y <= work_area.y)
-              window->tile_mode = META_TILE_MAXIMIZED;
-        }
+      if (meta_window_can_tile_side_by_side (window) &&
+          x >= monitor->rect.x && x < (work_area.x + shake_threshold))
+        window->tile_mode = META_TILE_LEFT;
+      else if (meta_window_can_tile_side_by_side (window) &&
+               x >= work_area.x + work_area.width - shake_threshold &&
+               x < (monitor->rect.x + monitor->rect.width))
+        window->tile_mode = META_TILE_RIGHT;
+      else if (meta_window_can_tile_maximized (window) &&
+               y >= monitor->rect.y && y <= work_area.y)
+        window->tile_mode = META_TILE_MAXIMIZED;
+      else
+        window->tile_mode = META_TILE_NONE;
     }
 
   /* shake loose (unmaximize) maximized or tiled window if dragged beyond
@@ -10093,7 +10086,9 @@ meta_window_is_remote (MetaWindow *window)
 {
   g_return_val_if_fail (META_IS_WINDOW (window), FALSE);
 
-  return g_strcmp0 (window->wm_client_machine, window->display->hostname) != 0;
+  if (window->wm_client_machine != NULL)
+    return g_strcmp0 (window->wm_client_machine, window->display->hostname) != 0;
+  return FALSE;
 }
 
 /**

src/ui/theme.c

@@ -2639,11 +2639,13 @@ meta_theme_replace_constants (MetaTheme   *theme,
         {
           if (meta_theme_lookup_int_constant (theme, t->d.v.name, &ival))
             {
+              g_free (t->d.v.name);
               t->type = POS_TOKEN_INT;
               t->d.i.val = ival;
             }
           else if (meta_theme_lookup_float_constant (theme, t->d.v.name, &dval))
             {
+              g_free (t->d.v.name);
               t->type = POS_TOKEN_DOUBLE;
               t->d.d.val = dval;
             }