MetaWindowActor: Fix crashes when mapping and unmapping windows

The assumptions made when getting the size of the window for the paint volume turned out not to be accurate in all cases - get_paint_volume() could be called on windows without computed bounds. https://bugzilla.gnome.org/show_bug.cgi?id=592382
Omit shadows for fullscreen and maximized windows
2010-11-13 11:44:47 -05:00 · 2010-11-13 11:44:47 -05:00 · 2010-11-13 11:44:47 -05:00 · 2010-11-13 11:44:47 -05:00 · 2010-11-13 11:44:47 -05:00 · 2010-11-13 11:44:46 -05:00
46 changed files with 2042 additions and 6158 deletions
--- a/configure.in
+++ b/configure.in
@@ -2,7 +2,7 @@ AC_PREREQ(2.50)

 m4_define([mutter_major_version], [2])
 m4_define([mutter_minor_version], [91])
-m4_define([mutter_micro_version], [4])
+m4_define([mutter_micro_version], [2])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -61,6 +61,72 @@ AC_CHECK_SIZEOF(__int64)
 ## byte order
 AC_C_BIGENDIAN

+#### Warnings
+
+# Stay command-line compatible with the gnome-common configure option. Here
+# minimum/yes/maximum are the same, however.
+AC_ARG_ENABLE(compile_warnings,
+  AS_HELP_STRING([--enable-compile-warnings=@<:@no/minimum/yes/maximum/error@:>@],[Turn on compiler warnings]),,
+  enable_compile_warnings=error)
+
+changequote(,)dnl
+if test "$enable_compile_warnings" != no ; then
+  if test "x$GCC" = "xyes"; then
+    case " $CFLAGS " in
+    *[\ \	]-Wall[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wall" ;;
+    esac
+
+#   case " $CFLAGS " in
+#   *[\ \	]-Wshadow[\ \	]*) ;;
+#   *) CFLAGS="$CFLAGS -Wshadow" ;;
+#   esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wchar-subscripts[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wmissing-declarations[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wmissing-prototypes[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wmissing-prototypes" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wnested-externs[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wnested-externs" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wpointer-arith[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wcast-align[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wcast-align" ;;
+    esac
+
+    case " $CFLAGS " in
+    *[\ \	]-Wsign-compare[\ \	]*) ;;
+    *) CFLAGS="$CFLAGS -Wsign-compare" ;;
+    esac
+
+    if test "$enable_compile_warnings" = error; then
+      case " $CFLAGS " in
+      *[\ \	]-Werror[\ \	]*) ;;
+      *) CFLAGS="$CFLAGS -Werror" ;;
+      esac
+    fi
+  fi
+fi
+changequote([,])dnl
+
 GTK_MIN_VERSION=2.90.7
 CANBERRA_GTK=libcanberra-gtk3
 CANBERRA_GTK_VERSION=0.26
@@ -452,72 +518,6 @@ AM_PATH_PYTHON([2.5])
 # Use gnome-doc-utils:
 GNOME_DOC_INIT([0.8.0])

-#### Warnings (last since -Werror can disturb other tests)
-
-# Stay command-line compatible with the gnome-common configure option. Here
-# minimum/yes/maximum are the same, however.
-AC_ARG_ENABLE(compile_warnings,
-  AS_HELP_STRING([--enable-compile-warnings=@<:@no/minimum/yes/maximum/error@:>@],[Turn on compiler warnings]),,
-  enable_compile_warnings=error)
-
-changequote(,)dnl
-if test "$enable_compile_warnings" != no ; then
-  if test "x$GCC" = "xyes"; then
-    case " $CFLAGS " in
-    *[\ \	]-Wall[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wall" ;;
-    esac
-
-#   case " $CFLAGS " in
-#   *[\ \	]-Wshadow[\ \	]*) ;;
-#   *) CFLAGS="$CFLAGS -Wshadow" ;;
-#   esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wchar-subscripts[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wchar-subscripts" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wmissing-declarations[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wmissing-declarations" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wmissing-prototypes[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wmissing-prototypes" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wnested-externs[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wnested-externs" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wpointer-arith[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wpointer-arith" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wcast-align[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wcast-align" ;;
-    esac
-
-    case " $CFLAGS " in
-    *[\ \	]-Wsign-compare[\ \	]*) ;;
-    *) CFLAGS="$CFLAGS -Wsign-compare" ;;
-    esac
-
-    if test "$enable_compile_warnings" = error; then
-      case " $CFLAGS " in
-      *[\ \	]-Werror[\ \	]*) ;;
-      *) CFLAGS="$CFLAGS -Werror" ;;
-      esac
-    fi
-  fi
-fi
-changequote([,])dnl
-
 AC_CONFIG_FILES([
 Makefile
 doc/Makefile
@@ -574,7 +574,7 @@ if expr $MUTTER_MINOR_VERSION % 2 > /dev/null ; then
   stable_version=`expr $MUTTER_MINOR_VERSION - 1`
   echo "This is the UNSTABLE branch of mutter"
   echo -n "Use 2.$stable_version.x for stable "
-   echo    "(gnome-2-$stable_version branch in git)"
+   echo    "(gnome-2-$stable_version branch in Subversion)"
 else
   echo "This is the stable branch of mutter"
 fi
--- a/doc/theme-format.txt
+++ b/doc/theme-format.txt
@@ -22,14 +22,6 @@ This document has separate sections for each format version. You may
 want to read the document in reverse order, since the base features
 are discussed under version 1.

-New Features in Theme Format Version 3.2
-========================================
-
-A new window type 'attached' is added for modal dialogs which are
-attached to their parent window. (When the attach_modal_dialogs preference
-is turned on.) If no style is defined for the 'attached' window type,
-the 'border' window type will be used instead.
-
 New Features in Theme Format Version 3.1
 ========================================

--- a/po/LINGUAS
+++ b/po/LINGUAS
@@ -82,7 +82,6 @@ te
 th
 tk
 tr
-ug 
 uk
 vi
 wa
--- a/po/ar.po
+++ b/po/ar.po
--- a/po/es.po
+++ b/po/es.po
--- a/po/gl.po
+++ b/po/gl.po
--- a/po/he.po
+++ b/po/he.po
--- a/po/nb.po
+++ b/po/nb.po
--- a/po/sl.po
+++ b/po/sl.po
--- a/po/ug.po
+++ b/po/ug.po
--- a/po/vi.po
+++ b/po/vi.po
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -21,12 +21,8 @@ mutter_SOURCES= 				\
 	core/boxes.c				\
 	core/boxes-private.h			\
 	include/boxes.h				\
-	compositor/cogl-utils.c			\
-	compositor/cogl-utils.h			\
 	compositor/compositor.c			\
 	compositor/compositor-private.h		\
-	compositor/meta-background-actor.c	\
-	compositor/meta-background-actor.h	\
 	compositor/meta-module.c		\
 	compositor/meta-module.h		\
 	compositor/meta-plugin.c		\
--- a/src/compositor/cogl-utils.c
+++ b/src/compositor/cogl-utils.c
@@ -1,104 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * Utilities for use with Cogl
- *
- * Copyright 2010 Red Hat, Inc.
- * Copyright 2010 Intel Corporation
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#include "cogl-utils.h"
-
-/**
- * meta_create_color_texture_4ub:
- * @red:
- * @green:
- * @blue:
- * @alpha:
- *
- * Creates a texture that is a single pixel with the specified
- * unpremultiplied color components.
- *
- * Return value: (transfer full): a newly created Cogl texture
- */
-CoglHandle
-meta_create_color_texture_4ub (guint8 red,
-                               guint8 green,
-                               guint8 blue,
-                               guint8 alpha)
-{
-  CoglColor color;
-  guint8 pixel[4];
-
-  cogl_color_set_from_4ub (&color, red, green, blue, alpha);
-  cogl_color_premultiply (&color);
-
-  pixel[0] = cogl_color_get_red_byte (&color);
-  pixel[1] = cogl_color_get_green_byte (&color);
-  pixel[2] = cogl_color_get_blue_byte (&color);
-  pixel[3] = cogl_color_get_alpha_byte (&color);
-
-  return cogl_texture_new_from_data (1, 1,
-                                     COGL_TEXTURE_NONE,
-                                     COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                                     COGL_PIXEL_FORMAT_ANY,
-                                     4, pixel);
-}
-
-
-/* Based on gnome-shell/src/st/st-private.c:_st_create_texture_material.c */
-
-/**
- * meta_create_texture_material:
- * @src_texture: (allow-none): texture to use initially for the layer
- *
- * Creates a material with a single layer. Using a common template
- * allows sharing a shader for different uses in Mutter. To share the same
- * shader with all other materials that are just texture plus opacity
- * would require Cogl fixes.
- * (See http://bugzilla.clutter-project.org/show_bug.cgi?id=2425)
- *
- * Return value: (transfer full): a newly created Cogl material
- */
-CoglHandle
-meta_create_texture_material (CoglHandle src_texture)
-{
-  static CoglHandle texture_material_template = COGL_INVALID_HANDLE;
-  CoglHandle material;
-
-  /* We use a material that has a dummy texture as a base for all
-     texture materials. The idea is that only the Cogl texture object
-     would be different in the children so it is likely that Cogl will
-     be able to share GL programs between all the textures. */
-  if (G_UNLIKELY (texture_material_template == COGL_INVALID_HANDLE))
-    {
-      CoglHandle dummy_texture;
-
-      dummy_texture = meta_create_color_texture_4ub (0xff, 0xff, 0xff, 0xff);
-
-      texture_material_template = cogl_material_new ();
-      cogl_material_set_layer (texture_material_template, 0, dummy_texture);
-      cogl_handle_unref (dummy_texture);
-    }
-
-  material = cogl_material_copy (texture_material_template);
-
-  if (src_texture != COGL_INVALID_HANDLE)
-    cogl_material_set_layer (material, 0, src_texture);
-
-  return material;
-}
--- a/src/compositor/cogl-utils.h
+++ b/src/compositor/cogl-utils.h
@@ -1,34 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * Utilities for use with Cogl
- *
- * Copyright 2010 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#ifndef __META_COGL_UTILS_H__
-#define __META_COGL_UTILS_H__
-
-#include <cogl/cogl.h>
-
-CoglHandle meta_create_color_texture_4ub (guint8     red,
-                                          guint8     green,
-                                          guint8     blue,
-                                          guint8     alpha);
-CoglHandle meta_create_texture_material  (CoglHandle src_texture);
-
-#endif /* __META_COGL_UTILS_H__ */
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -35,7 +35,6 @@ struct _MetaCompScreen
  MetaScreen            *screen;

  ClutterActor          *stage, *window_group, *overlay_group;
-  ClutterActor          *background_actor;
  ClutterActor		*hidden_group;
  GList                 *windows;
  GHashTable            *windows_by_xid;
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -14,7 +14,6 @@
 #include "meta-shadow-factory.h"
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-background-actor.h"
 #include "../core/window-private.h" /* to check window->hidden */
 #include "../core/display-private.h" /* for meta_display_lookup_x_window() */
 #include <X11/extensions/shape.h>
@@ -35,7 +34,7 @@ composite_at_least_version (MetaDisplay *display, int maj, int min)
  return (major > maj || (major == maj && minor >= min));
 }

-static void sync_actor_stacking (MetaCompScreen *info);
+static void sync_actor_stacking (GList *windows);

 static void
 meta_finish_workspace_switch (MetaCompScreen *info)
@@ -49,7 +48,7 @@ meta_finish_workspace_switch (MetaCompScreen *info)
  /*
   * Fix up stacking order in case the plugin messed it up.
   */
-  sync_actor_stacking (info);
+  sync_actor_stacking (info->windows);

 /*   printf ("... FINISHED DESKTOP SWITCH\n"); */

@@ -88,7 +87,7 @@ add_win (MetaWindow *window)

  meta_window_actor_new (window);

-  sync_actor_stacking (info);
+  sync_actor_stacking (info->windows);
 }

 static void
@@ -137,22 +136,6 @@ process_property_notify (MetaCompositor	*compositor,
 {
  MetaWindowActor *window_actor;

-  if (event->atom == compositor->atom_x_root_pixmap)
-    {
-      GSList *l;
-
-      for (l = meta_display_get_screens (compositor->display); l; l = l->next)
-        {
-	  MetaScreen  *screen = l->data;
-          if (event->window == meta_screen_get_xroot (screen))
-            {
-              MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-              meta_background_actor_update (META_BACKGROUND_ACTOR (info->background_actor));
-              return;
-            }
-        }
-    }
-
  if (window == NULL)
    return;

@@ -253,27 +236,6 @@ meta_get_window_group_for_screen (MetaScreen *screen)
  return info->window_group;
 }

-/**
- * meta_get_background_actor_for_screen:
- * @screen: a #MetaScreen
- *
- * Gets the actor that draws the root window background under the windows.
- * The root window background automatically tracks the image or color set
- * by the environment.
- *
- * Returns: (transfer none): The background actor corresponding to @screen
- */
-ClutterActor *
-meta_get_background_actor_for_screen (MetaScreen *screen)
-{
-  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-
-  if (!info)
-    return NULL;
-
-  return info->background_actor;
-}
-
 /**
 * meta_get_window_actors:
 * @screen: a #MetaScreen
@@ -532,14 +494,9 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  XSelectInput (xdisplay, xwin, event_mask);

  info->window_group = meta_window_group_new (screen);
-  info->background_actor = meta_background_actor_new (screen);
  info->overlay_group = clutter_group_new ();
  info->hidden_group = clutter_group_new ();

-  clutter_container_add (CLUTTER_CONTAINER (info->window_group),
-                         info->background_actor,
-                         NULL);
-
  clutter_container_add (CLUTTER_CONTAINER (info->stage),
                         info->window_group,
                         info->overlay_group,
@@ -870,73 +827,18 @@ meta_compositor_switch_workspace (MetaCompositor     *compositor,
 }

 static void
-sync_actor_stacking (MetaCompScreen *info)
+sync_actor_stacking (GList *windows)
 {
-  GList *children;
  GList *tmp;
-  GList *old;
-  gboolean reordered;

-  /* NB: The first entries in the lists are stacked the lowest */
+  /* NB: The first entry in the list is stacked the lowest */

-  /* Restacking will trigger full screen redraws, so it's worth a
-   * little effort to make sure we actually need to restack before
-   * we go ahead and do it */
-
-  children = clutter_container_get_children (CLUTTER_CONTAINER (info->window_group));
-  reordered = FALSE;
-
-  old = children;
-
-  /* We allow for actors in the window group other than the actors we
-   * know about, but it's up to a plugin to try and keep them stacked correctly
-   * (we really need extra API to make that reliable.)
-   */
-
-  /* Of the actors we know, the bottom actor should be the background actor */
-
-  while (old && old->data != info->background_actor && !META_IS_WINDOW_ACTOR (old->data))
-    old = old->next;
-  if (old == NULL || old->data != info->background_actor)
-    {
-      reordered = TRUE;
-      goto done_with_check;
-    }
-
-  /* Then the window actors should follow in sequence */
-
-  old = old->next;
-  for (tmp = info->windows; tmp != NULL; tmp = tmp->next)
-    {
-      while (old && !META_IS_WINDOW_ACTOR (old->data))
-        old = old->next;
-
-      /* old == NULL: someone reparented a window out of the window group,
-       * order undefined, always restack */
-      if (old == NULL || old->data != tmp->data)
-        {
-          reordered = TRUE;
-          goto done_with_check;
-        }
-
-      old = old->next;
-    }
-
- done_with_check:
-
-  g_list_free (children);
-
-  if (!reordered)
-    return;
-
-  for (tmp = g_list_last (info->windows); tmp != NULL; tmp = tmp->prev)
+  for (tmp = g_list_last (windows); tmp != NULL; tmp = tmp->prev)
    {
      MetaWindowActor *window_actor = tmp->data;

      clutter_actor_lower_bottom (CLUTTER_ACTOR (window_actor));
    }
-
-  clutter_actor_lower_bottom (info->background_actor);
 }

 void
@@ -1025,7 +927,7 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
      old_stack = g_list_remove (old_stack, actor);
    }

-  sync_actor_stacking (info);
+  sync_actor_stacking (info->windows);
 }

 void
@@ -1082,8 +984,6 @@ meta_compositor_sync_screen_size (MetaCompositor  *compositor,

  clutter_actor_set_size (info->stage, width, height);

-  meta_background_actor_screen_size_changed (META_BACKGROUND_ACTOR (info->background_actor));
-
  meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
 		meta_screen_get_screen_number (screen),
 		width, height);
--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@@ -1,414 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * meta-background-actor.c: Actor for painting the root window background
- *
- * Copyright 2009 Sander Dijkhuis
- * Copyright 2010 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * Portions adapted from gnome-shell/src/shell-global.c
- */
-
-#include <config.h>
-
-#define COGL_ENABLE_EXPERIMENTAL_API
-#include <cogl/cogl-texture-pixmap-x11.h>
-
-#include <X11/Xatom.h>
-
-#include "cogl-utils.h"
-#include "compositor-private.h"
-#include "errors.h"
-#include "meta-background-actor.h"
-
-struct _MetaBackgroundActorClass
-{
-  ClutterActorClass parent_class;
-};
-
-struct _MetaBackgroundActor
-{
-  ClutterActor parent;
-
-  CoglHandle material;
-  MetaScreen *screen;
-  cairo_region_t *visible_region;
-  float texture_width;
-  float texture_height;
-
-  guint have_pixmap : 1;
-};
-
-G_DEFINE_TYPE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR);
-
-static void
-update_wrap_mode (MetaBackgroundActor *self)
-{
-  int width, height;
-  CoglMaterialWrapMode wrap_mode;
-
-  meta_screen_get_size (self->screen, &width, &height);
-
-  /* We turn off repeating when we have a full-screen pixmap to keep from
-   * getting artifacts from one side of the image sneaking into the other
-   * side of the image via bilinear filtering.
-   */
-  if (width == self->texture_width && height == self->texture_height)
-    wrap_mode = COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE;
-  else
-    wrap_mode = COGL_MATERIAL_WRAP_MODE_REPEAT;
-
-  cogl_material_set_layer_wrap_mode (self->material, 0, wrap_mode);
-}
-
-static void
-set_texture (MetaBackgroundActor *self,
-             CoglHandle           texture)
-{
-  MetaDisplay *display;
-
-  display = meta_screen_get_display (self->screen);
-
-  /* This may trigger destruction of an old texture pixmap, which, if
-   * the underlying X pixmap is already gone has the tendency to trigger
-   * X errors inside DRI. For safety, trap errors */
-  meta_error_trap_push (display);
-  cogl_material_set_layer (self->material, 0, texture);
-  meta_error_trap_pop (display);
-
-  self->texture_width = cogl_texture_get_width (texture);
-  self->texture_height = cogl_texture_get_height (texture);
-
-  update_wrap_mode (self);
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
-}
-
-/* Sets our material to paint with a 1x1 texture of the stage's background
- * color; doing this when we have no pixmap allows the application to turn
- * off painting the stage. There might be a performance benefit to
- * painting in this case with a solid color, but the normal solid color
- * case is a 1x1 root pixmap, so we'd have to reverse-engineer that to
- * actually pick up the (small?) performance win. This is just a fallback.
- */
-static void
-set_texture_to_stage_color (MetaBackgroundActor *self)
-{
-  ClutterActor *stage = meta_get_stage_for_screen (self->screen);
-  ClutterColor color;
-  CoglHandle texture;
-
-  clutter_stage_get_color (CLUTTER_STAGE (stage), &color);
-  texture = meta_create_color_texture_4ub (color.red, color.green,
-                                           color.blue, 0xff);
-  set_texture (self, texture);
-  cogl_handle_unref (texture);
-}
-
-static void
-on_notify_stage_color (GObject             *stage,
-                       GParamSpec          *pspec,
-                       MetaBackgroundActor *self)
-{
-  if (!self->have_pixmap)
-    set_texture_to_stage_color (self);
-}
-
-static void
-meta_background_actor_dispose (GObject *object)
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
-
-  meta_background_actor_set_visible_region (self, NULL);
-
-  if (self->material != COGL_INVALID_HANDLE)
-    {
-      cogl_handle_unref (self->material);
-      self->material = COGL_INVALID_HANDLE;
-    }
-
-  if (self->screen != NULL)
-    {
-      ClutterActor *stage = meta_get_stage_for_screen (self->screen);
-      g_signal_handlers_disconnect_by_func (stage,
-                                            (gpointer) on_notify_stage_color,
-                                            self);
-      self->screen = NULL;
-    }
-}
-
-static void
-meta_background_actor_get_preferred_width (ClutterActor *actor,
-                                           gfloat        for_height,
-                                           gfloat       *min_width_p,
-                                           gfloat       *natural_width_p)
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
-  int width, height;
-
-  meta_screen_get_size (self->screen, &width, &height);
-
-  if (min_width_p)
-    *min_width_p = width;
-  if (natural_width_p)
-    *natural_width_p = height;
-}
-
-static void
-meta_background_actor_get_preferred_height (ClutterActor *actor,
-                                            gfloat        for_width,
-                                            gfloat       *min_height_p,
-                                            gfloat       *natural_height_p)
-
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
-  int width, height;
-
-  meta_screen_get_size (self->screen, &width, &height);
-
-  if (min_height_p)
-    *min_height_p = height;
-  if (natural_height_p)
-    *natural_height_p = height;
-}
-
-static void
-meta_background_actor_paint (ClutterActor *actor)
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
-  int width, height;
-
-  meta_screen_get_size (self->screen, &width, &height);
-
-  cogl_set_source (self->material);
-
-  if (self->visible_region)
-    {
-      int n_rectangles = cairo_region_num_rectangles (self->visible_region);
-      int i;
-
-      for (i = 0; i < n_rectangles; i++)
-        {
-          cairo_rectangle_int_t rect;
-          cairo_region_get_rectangle (self->visible_region, i, &rect);
-
-          cogl_rectangle_with_texture_coords (rect.x, rect.y,
-                                              rect.x + rect.width, rect.y + rect.height,
-                                              rect.x / self->texture_width,
-                                              rect.y / self->texture_height,
-                                              (rect.x + rect.width) / self->texture_width,
-                                              (rect.y + rect.height) / self->texture_height);
-        }
-    }
-  else
-    {
-      cogl_rectangle_with_texture_coords (0.0f, 0.0f,
-                                          width, height,
-                                          0.0f, 0.0f,
-                                          width / self->texture_width,
-                                          height / self->texture_height);
-    }
-}
-
-#if CLUTTER_CHECK_VERSION(1, 5, 2)
-static gboolean
-meta_background_actor_get_paint_volume (ClutterActor       *actor,
-                                        ClutterPaintVolume *volume)
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
-  int width, height;
-
-  meta_screen_get_size (self->screen, &width, &height);
-
-  clutter_paint_volume_set_width (volume, width);
-  clutter_paint_volume_set_height (volume, height);
-
-  return TRUE;
-}
-#endif
-
-static void
-meta_background_actor_class_init (MetaBackgroundActorClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
-
-  object_class->dispose = meta_background_actor_dispose;
-
-  actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
-  actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
-  actor_class->paint = meta_background_actor_paint;
-#if CLUTTER_CHECK_VERSION(1, 5, 2)
-  actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
-#endif
-}
-
-static void
-meta_background_actor_init (MetaBackgroundActor *background_actor)
-{
-}
-
-/**
- * @screen: the #MetaScreen
- * meta_background_actor_new:
- *
- * Creates a new actor to draw the background for the given screen.
- *
- * Return value: (transfer none): the newly created background actor
- */
-ClutterActor *
-meta_background_actor_new (MetaScreen *screen)
-{
-  MetaBackgroundActor *self;
-  ClutterActor *stage;
-
-  g_return_val_if_fail (META_IS_SCREEN (screen), NULL);
-
-  self = g_object_new (META_TYPE_BACKGROUND_ACTOR, NULL);
-
-  self->screen = screen;
-
-  self->material = meta_create_texture_material (NULL);
-  cogl_material_set_layer_wrap_mode (self->material, 0,
-                                     COGL_MATERIAL_WRAP_MODE_REPEAT);
-
-  stage = meta_get_stage_for_screen (self->screen);
-  g_signal_connect (stage, "notify::color",
-                    G_CALLBACK (on_notify_stage_color), self);
-
-  meta_background_actor_update (self);
-
-  return CLUTTER_ACTOR (self);
-}
-
-/**
- * meta_background_actor_update:
- * @self: a #MetaBackgroundActor
- *
- * Refetches the _XROOTPMAP_ID property for the root window and updates
- * the contents of the background actor based on that. There's no attempt
- * to optimize out pixmap values that don't change (since a root pixmap
- * could be replaced by with another pixmap with the same ID under some
- * circumstances), so this should only be called when we actually receive
- * a PropertyNotify event for the property.
- */
-void
-meta_background_actor_update (MetaBackgroundActor *self)
-{
-  MetaDisplay *display;
-  MetaCompositor *compositor;
-  Atom type;
-  int format;
-  gulong nitems;
-  gulong bytes_after;
-  guchar *data;
-  Pixmap root_pixmap_id;
-
-  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
-
-  display = meta_screen_get_display (self->screen);
-  compositor = meta_display_get_compositor (display);
-
-  root_pixmap_id = None;
-  if (!XGetWindowProperty (meta_display_get_xdisplay (display),
-                           meta_screen_get_xroot  (self->screen),
-                           compositor->atom_x_root_pixmap,
-                           0, LONG_MAX,
-                           False,
-                           AnyPropertyType,
-                           &type, &format, &nitems, &bytes_after, &data) &&
-      type != None)
-  {
-     /* Got a property. */
-     if (type == XA_PIXMAP && format == 32 && nitems == 1)
-       {
-         /* Was what we expected. */
-         root_pixmap_id = *(Pixmap *)data;
-       }
-
-     XFree(data);
-  }
-
-  if (root_pixmap_id != None)
-    {
-      CoglHandle texture;
-
-      meta_error_trap_push (display);
-      texture = cogl_texture_pixmap_x11_new (root_pixmap_id, FALSE);
-      meta_error_trap_pop (display);
-
-      if (texture != COGL_INVALID_HANDLE)
-        {
-          set_texture (self, texture);
-          cogl_handle_unref (texture);
-
-          self->have_pixmap = True;
-          return;
-        }
-    }
-
-  self->have_pixmap = False;
-  set_texture_to_stage_color (self);
-}
-
-/**
- * meta_background_actor_set_visible_region:
- * @self: a #MetaBackgroundActor
- * @visible_region: (allow-none): the area of the actor (in allocate-relative
- *   coordinates) that is visible.
- *
- * Sets the area of the background that is unobscured by overlapping windows.
- * This is used to optimize and only paint the visible portions.
- */
-void
-meta_background_actor_set_visible_region (MetaBackgroundActor *self,
-                                          cairo_region_t      *visible_region)
-{
-  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
-
-  if (self->visible_region)
-    {
-      cairo_region_destroy (self->visible_region);
-      self->visible_region = NULL;
-    }
-
-  if (visible_region)
-    {
-      cairo_rectangle_int_t screen_rect = { 0 };
-      meta_screen_get_size (self->screen, &screen_rect.width, &screen_rect.height);
-
-      /* Doing the intersection here is probably unnecessary - MetaWindowGroup
-       * should never compute a visible area that's larger than the root screen!
-       * but it's not that expensive and adds some extra robustness.
-       */
-      self->visible_region = cairo_region_create_rectangle (&screen_rect);
-      cairo_region_intersect (self->visible_region, visible_region);
-    }
-}
-
-/**
- * meta_background_actor_screen_size_changed:
- * @self: a #MetaBackgroundActor
- *
- * Called by the compositor when the size of the #MetaScreen changes
- */
-void
-meta_background_actor_screen_size_changed (MetaBackgroundActor *self)
-{
-  update_wrap_mode (self);
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
-}
--- a/src/compositor/meta-background-actor.h
+++ b/src/compositor/meta-background-actor.h
@@ -1,58 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * meta-background-actor.h: Actor for painting the root window background
- *
- * Copyright 2010 Red Hat, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- */
-
-#ifndef META_BACKGROUND_ACTOR_H
-#define META_BACKGROUND_ACTOR_H
-
-#include <clutter/clutter.h>
-
-#include "screen.h"
-
-/**
- * MetaBackgroundActor:
- *
- * This class handles tracking and painting the root window background.
- * By integrating with #MetaWindowGroup we can avoid painting parts of
- * the background that are obscured by other windows.
- */
-
-#define META_TYPE_BACKGROUND_ACTOR            (meta_background_actor_get_type ())
-#define META_BACKGROUND_ACTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActor))
-#define META_BACKGROUND_ACTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActorClass))
-#define META_IS_BACKGROUND_ACTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_BACKGROUND_ACTOR))
-#define META_IS_BACKGROUND_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_BACKGROUND_ACTOR))
-#define META_BACKGROUND_ACTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_BACKGROUND_ACTOR, MetaBackgroundActorClass))
-
-typedef struct _MetaBackgroundActor        MetaBackgroundActor;
-typedef struct _MetaBackgroundActorClass   MetaBackgroundActorClass;
-typedef struct _MetaBackgroundActorPrivate MetaBackgroundActorPrivate;
-
-GType meta_background_actor_get_type (void);
-
-ClutterActor *meta_background_actor_new (MetaScreen *screen);
-
-void meta_background_actor_update              (MetaBackgroundActor *actor);
-void meta_background_actor_set_visible_region  (MetaBackgroundActor *self,
-                                                cairo_region_t      *visible_region);
-void meta_background_actor_screen_size_changed (MetaBackgroundActor *self);
-
-#endif /* META_BACKGROUND_ACTOR_H */
--- a/src/compositor/meta-plugin.c
+++ b/src/compositor/meta-plugin.c
@@ -351,14 +351,6 @@ meta_plugin_get_window_group (MetaPlugin *plugin)
  return meta_get_window_group_for_screen (priv->screen);
 }

-ClutterActor *
-meta_plugin_get_background_actor (MetaPlugin *plugin)
-{
-  MetaPluginPrivate *priv = META_PLUGIN (plugin)->priv;
-
-  return meta_get_background_actor_for_screen (priv->screen);
-}
-
 /**
 * _meta_plugin_effect_started:
 * @plugin: the plugin
--- a/src/compositor/meta-shadow-factory-private.h
+++ b/src/compositor/meta-shadow-factory-private.h
@@ -55,8 +55,6 @@ void        meta_shadow_get_bounds  (MetaShadow            *shadow,
                                     int                    window_height,
                                     cairo_rectangle_int_t *bounds);

-MetaShadowFactory *meta_shadow_factory_new (void);
-
 MetaShadow *meta_shadow_factory_get_shadow (MetaShadowFactory *factory,
                                            MetaWindowShape   *shape,
                                            int                width,
--- a/src/compositor/meta-shadow-factory.c
+++ b/src/compositor/meta-shadow-factory.c
@@ -5,6 +5,7 @@
 * Create and cache shadow textures for abritrary window shapes
 *
 * Copyright 2010 Red Hat, Inc.
+ * Copyright 2010 Intel Corporation
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
@@ -25,7 +26,6 @@
 #include <math.h>
 #include <string.h>

-#include "cogl-utils.h"
 #include "meta-shadow-factory-private.h"
 #include "region-utils.h"

@@ -641,6 +641,49 @@ flip_buffer (guchar *buffer,
 #undef BLOCK_SIZE
 }

+/* Creates a material with a single layer. Using a common template
+ * allows sharing a shader between all shadows. To share the same
+ * shader with all other materials that are just texture plus
+ * opacity would require cogl fixes. Based on
+ * gnome-shell/src/st/_st_create_texture_material.c
+ */
+static CoglHandle
+create_texture_material (CoglHandle src_texture)
+{
+  static CoglHandle texture_material_template = COGL_INVALID_HANDLE;
+  CoglHandle material;
+
+  g_return_val_if_fail (src_texture != COGL_INVALID_HANDLE,
+                        COGL_INVALID_HANDLE);
+
+  /* We use a material that has a dummy texture as a base for all
+     texture materials. The idea is that only the Cogl texture object
+     would be different in the children so it is likely that Cogl will
+     be able to share GL programs between all the textures. */
+  if (G_UNLIKELY (texture_material_template == COGL_INVALID_HANDLE))
+    {
+      static const guint8 white_pixel[] = { 0xff, 0xff, 0xff, 0xff };
+      CoglHandle dummy_texture;
+
+      dummy_texture =
+        cogl_texture_new_from_data (1, 1,
+                                    COGL_TEXTURE_NONE,
+                                    COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+                                    COGL_PIXEL_FORMAT_ANY,
+                                    4, white_pixel);
+
+      texture_material_template = cogl_material_new ();
+      cogl_material_set_layer (texture_material_template, 0, dummy_texture);
+      cogl_handle_unref (dummy_texture);
+    }
+
+  material = cogl_material_copy (texture_material_template);
+
+  cogl_material_set_layer (material, 0, src_texture);
+
+  return material;
+}
+
 static void
 make_shadow (MetaShadow     *shadow,
             cairo_region_t *region)
@@ -732,7 +775,7 @@ make_shadow (MetaShadow     *shadow,

  /* We offset the passed in pixels to crop off the extra area we allocated at the top
   * in the case of top_fade >= 0. We also account for padding at the left for symmetry
-   * though that doesn't currently occur.
+   * though that doesn't currnetly occur.
   */
  shadow->texture = cogl_texture_new_from_data (shadow->outer_border_left + extents.width + shadow->outer_border_right,
                                                shadow->outer_border_top + extents.height + shadow->outer_border_bottom,
@@ -748,7 +791,7 @@ make_shadow (MetaShadow     *shadow,
  cairo_region_destroy (column_convolve_region);
  g_free (buffer);

-  shadow->material = meta_create_texture_material (shadow->texture);
+  shadow->material = create_texture_material (shadow->texture);
 }

 static MetaShadowParams *
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -39,7 +39,7 @@ struct _MetaWindowActorPrivate
   * these will be the same. 2) when the shadow potentially changes we
   * don't immediately unreference the old shadow, we just flag it as
   * dirty and recompute it when we next need it (recompute_focused_shadow,
-   * recompute_unfocused_shadow.) Because of our extraction of
+   * recompute_unfocused_shadow.)  Because of the our extraction of
   * size-invariant window shape, we'll often find that the new shadow
   * is the same as the old shadow.
   */
@@ -641,7 +641,6 @@ meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
    bounds->x = bounds->y = bounds->width = bounds->height = 0;
 }

-#if CLUTTER_CHECK_VERSION(1, 5, 2)
 static void
 meta_window_actor_get_shadow_bounds (MetaWindowActor       *self,
                                     gboolean               appears_focused,
@@ -662,7 +661,6 @@ meta_window_actor_get_shadow_bounds (MetaWindowActor       *self,
                          shape_bounds.height,
                          bounds);
 }
-#endif

 static void
 meta_window_actor_paint (ClutterActor *actor)
@@ -1823,8 +1821,8 @@ check_needs_pixmap (MetaWindowActor *self)
       * do it here.
       * See: http://bugzilla.clutter-project.org/show_bug.cgi?id=2236
       */
-      if (G_UNLIKELY (!clutter_glx_texture_pixmap_using_extension (
-                                  CLUTTER_GLX_TEXTURE_PIXMAP (priv->actor))))
+      if (!clutter_glx_texture_pixmap_using_extension (
+                                  CLUTTER_GLX_TEXTURE_PIXMAP (priv->actor)))
        g_warning ("NOTE: Not using GLX TFP!\n");

      g_object_get (priv->actor,
@@ -1889,26 +1887,24 @@ check_needs_shadow (MetaWindowActor *self)

  if (*shadow_location == NULL && should_have_shadow)
    {
+      MetaShadowFactory *factory = meta_shadow_factory_get_default ();
+      const char *shadow_class = meta_window_actor_get_shadow_class (self);
+      cairo_rectangle_int_t shape_bounds;
+
      if (priv->shadow_shape == NULL)
        {
-          if (priv->shaped && priv->shape_region)
+          if (priv->shaped)
            priv->shadow_shape = meta_window_shape_new (priv->shape_region);
-          else if (priv->bounding_region)
+          else
            priv->shadow_shape = meta_window_shape_new (priv->bounding_region);
        }

-      if (priv->shadow_shape != NULL)
-        {
-          MetaShadowFactory *factory = meta_shadow_factory_get_default ();
-          const char *shadow_class = meta_window_actor_get_shadow_class (self);
-          cairo_rectangle_int_t shape_bounds;
+      meta_window_actor_get_shape_bounds (self, &shape_bounds);

-          meta_window_actor_get_shape_bounds (self, &shape_bounds);
-          *shadow_location = meta_shadow_factory_get_shadow (factory,
-                                                             priv->shadow_shape,
-                                                             shape_bounds.width, shape_bounds.height,
-                                                             shadow_class, appears_focused);
-        }
+      *shadow_location = meta_shadow_factory_get_shadow (factory,
+                                                         priv->shadow_shape,
+                                                         shape_bounds.width, shape_bounds.height,
+                                                         shadow_class, appears_focused);
    }

  if (old_shadow != NULL)
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@@ -5,11 +5,8 @@
 #define _ISOC99_SOURCE /* for roundf */
 #include <math.h>

-#include <gdk/gdk.h> /* for gdk_rectangle_intersect() */
-
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-background-actor.h"

 struct _MetaWindowGroupClass
 {
@@ -105,9 +102,7 @@ meta_window_group_paint (ClutterActor *actor)
 {
  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
  cairo_region_t *visible_region;
-  GLboolean scissor_test;
  cairo_rectangle_int_t screen_rect = { 0 };
-  cairo_rectangle_int_t scissor_rect;
  GList *children, *l;

  /* We walk the list from top to bottom (opposite of painting order),
@@ -123,67 +118,35 @@ meta_window_group_paint (ClutterActor *actor)
   * optimization, however.)
   */
  meta_screen_get_size (window_group->screen, &screen_rect.width, &screen_rect.height);
-
-  /* When doing a partial stage paint, Clutter will set the GL scissor
-   * box to the clip rectangle for the partial repaint. We combine the screen
-   * rectangle with the scissor box to get the region we need to
-   * paint. (Strangely, the scissor box sometimes seems to be bigger
-   * than the stage ... Clutter should probably be clampimg)
-   */
-  glGetBooleanv (GL_SCISSOR_TEST, &scissor_test);
-
-  if (scissor_test)
-    {
-      GLint scissor_box[4];
-      glGetIntegerv (GL_SCISSOR_BOX, scissor_box);
-
-      scissor_rect.x = scissor_box[0];
-      scissor_rect.y = screen_rect.height - (scissor_box[1] + scissor_box[3]);
-      scissor_rect.width = scissor_box[2];
-      scissor_rect.height = scissor_box[3];
-
-      gdk_rectangle_intersect (&scissor_rect, &screen_rect, &scissor_rect);
-    }
-  else
-    {
-      scissor_rect = screen_rect;
-    }
-
-  visible_region = cairo_region_create_rectangle (&scissor_rect);
+  visible_region = cairo_region_create_rectangle (&screen_rect);

  for (l = children; l; l = l->next)
    {
-      if (!CLUTTER_ACTOR_IS_VISIBLE (l->data))
+      MetaWindowActor *window_actor;
+      gboolean x, y;
+
+      if (!META_IS_WINDOW_ACTOR (l->data) || !CLUTTER_ACTOR_IS_VISIBLE (l->data))
        continue;

-      if (META_IS_WINDOW_ACTOR (l->data))
+      window_actor = l->data;
+
+      if (!actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
+        continue;
+
+      /* Temporarily move to the coordinate system of the actor */
+      cairo_region_translate (visible_region, - x, - y);
+
+      meta_window_actor_set_visible_region (window_actor, visible_region);
+
+      if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
        {
-          MetaWindowActor *window_actor = l->data;
-          gboolean x, y;
-
-          if (!actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
-            continue;
-
-          /* Temporarily move to the coordinate system of the actor */
-          cairo_region_translate (visible_region, - x, - y);
-
-          meta_window_actor_set_visible_region (window_actor, visible_region);
-
-          if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
-            {
-              cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
-              if (obscured_region)
-                cairo_region_subtract (visible_region, obscured_region);
-            }
-
-          meta_window_actor_set_visible_region_beneath (window_actor, visible_region);
-          cairo_region_translate (visible_region, x, y);
-        }
-      else if (META_IS_BACKGROUND_ACTOR (l->data))
-        {
-          MetaBackgroundActor *background_actor = l->data;
-          meta_background_actor_set_visible_region (background_actor, visible_region);
+          cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
+          if (obscured_region)
+            cairo_region_subtract (visible_region, obscured_region);
        }
+
+      meta_window_actor_set_visible_region_beneath (window_actor, visible_region);
+      cairo_region_translate (visible_region, x, y);
    }

  cairo_region_destroy (visible_region);
@@ -195,17 +158,13 @@ meta_window_group_paint (ClutterActor *actor)
   */
  for (l = children; l; l = l->next)
    {
-      if (META_IS_WINDOW_ACTOR (l->data))
-        {
-          MetaWindowActor *window_actor = l->data;
-          window_actor = l->data;
-          meta_window_actor_reset_visible_regions (window_actor);
-        }
-      else if (META_IS_BACKGROUND_ACTOR (l->data))
-        {
-          MetaBackgroundActor *background_actor = l->data;
-          meta_background_actor_set_visible_region (background_actor, NULL);
-        }
+      MetaWindowActor *window_actor;
+
+      if (!META_IS_WINDOW_ACTOR (l->data))
+        continue;
+
+      window_actor = l->data;
+      meta_window_actor_reset_visible_regions (window_actor);
    }

  g_list_free (children);
--- a/src/compositor/meta-window-shape.c
+++ b/src/compositor/meta-window-shape.c
@@ -141,9 +141,8 @@ meta_window_shape_new (cairo_region_t *region)

 #if 0
      g_print ("%d: +%d+%dx%dx%d => +%d+%dx%dx%d\n",
-               iter.i, iter.rectangle.x, iter.rectangle.y, iter.rectangle.width, iter.rectangle.height,
-               shape->rectangles[iter.i].x, shape->rectangles[iter.i].y,
-               hape->rectangles[iter.i].width, shape->rectangles[iter.i].height);
+               i, iter.rectangle.x, iter.rectangle.y, iter.rectangle.width, iter.rectangle.height,
+               shape->rectangles[i].x, shape->rectangles[i].y, shape->rectangles[i].width, shape->rectangles[i].height);
 #endif

      hash = hash * 31 + x1 * 17 + x2 * 27 + y1 * 37 + y2 * 43;
--- a/src/compositor/meta-window-shape.h
+++ b/src/compositor/meta-window-shape.h
@@ -32,8 +32,8 @@
 * MetaWindowShape:
 * #MetaWindowShape represents a 9-sliced region with borders on all sides that
 * are unscaled, and a constant central region that is scaled. For example,
- * the regions representing two windows that are rounded rectangles,
- * with the same corner radius but different sizes, have the
+ * if you the regions representing two windows that around rounded rectangles,
+ * with the same corner regions, but different sizes, they have the
 * same MetaWindowShape.
 *
 * #MetaWindowShape is designed to be used as part of a hash table key, so has
--- a/src/compositor/region-utils.c
+++ b/src/compositor/region-utils.c
@@ -47,9 +47,7 @@

 typedef struct
 {
-  /* To merge regions in binary tree order, we need to keep track of
-   * the regions that we've already merged together at different
-   * levels of the tree. We fill in an array in the pattern:
+  /* To merge regions in a binary tree, we need to keep track of The way these are filled is in the pattern:
   *
   * |a  |
   * |b  |a  |
@@ -180,7 +178,7 @@ meta_region_iterator_next (MetaRegionIterator *iter)
  iter->rectangle = iter->next_rectangle;
  iter->line_start = iter->line_end;

-  if (iter->i + 1 < iter->n_rectangles)
+  if (iter->i < iter->n_rectangles)
    {
      cairo_region_get_rectangle (iter->region, iter->i + 1, &iter->next_rectangle);
      iter->line_end = iter->next_rectangle.y != iter->rectangle.y;
@@ -203,12 +201,12 @@ add_expanded_rect (MetaRegionBuilder  *builder,
 {
  if (flip)
    meta_region_builder_add_rectangle (builder,
-                                       y - y_amount, x - x_amount,
-                                       height + 2 * y_amount, width + 2 * x_amount);
+                                         y - y_amount, x - x_amount,
+                                         height + 2 * y_amount, width + 2 * x_amount);
  else
    meta_region_builder_add_rectangle (builder,
-                                       x - x_amount, y - y_amount,
-                                       width + 2 * x_amount, height + 2 * y_amount);
+                                         x - x_amount, y - y_amount,
+                                         width + 2 * x_amount, height + 2 * y_amount);
 }

 static cairo_region_t *
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -796,7 +796,7 @@ constrain_maximization (MetaWindow         *window,

  /* Determine whether constraint applies; exit if it doesn't */
  if ((!window->maximized_horizontally && !window->maximized_vertically) ||
-      META_WINDOW_TILED_SIDE_BY_SIDE (window))
+      META_WINDOW_TILED (window))
    return TRUE;

  /* Calculate target_size = maximized size of (window + frame) */
@@ -880,7 +880,7 @@ constrain_tiling (MetaWindow         *window,
    return TRUE;

  /* Determine whether constraint applies; exit if it doesn't */
-  if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
+  if (!META_WINDOW_TILED (window))
    return TRUE;

  /* Calculate target_size - as the tile previews need this as well, we
@@ -968,8 +968,7 @@ constrain_size_increments (MetaWindow         *window,

  /* Determine whether constraint applies; exit if it doesn't */
  if (META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
-      META_WINDOW_TILED_SIDE_BY_SIDE (window) ||
-      info->action_type == ACTION_MOVE)
+      META_WINDOW_TILED (window) || info->action_type == ACTION_MOVE)
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is */
@@ -1100,8 +1099,7 @@ constrain_aspect_ratio (MetaWindow         *window,
  constraints_are_inconsistent = minr > maxr;
  if (constraints_are_inconsistent ||
      META_WINDOW_MAXIMIZED (window) || window->fullscreen || 
-      META_WINDOW_TILED_SIDE_BY_SIDE (window) ||
-      info->action_type == ACTION_MOVE)
+      META_WINDOW_TILED (window) || info->action_type == ACTION_MOVE)
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is.  We
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -2642,10 +2642,6 @@ event_callback (XEvent   *event,
                  meta_bell_notify (display, xkb_ev);
                }
 	      break;
-            case XkbNewKeyboardNotify:
-            case XkbMapNotify:
-              meta_display_process_mapping_event (display, event);
-              break;
 	    }
 	}
 #endif
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -233,8 +233,9 @@ reload_keycodes (MetaDisplay *display)
 {
  meta_topic (META_DEBUG_KEYBINDINGS,
              "Reloading keycodes for binding tables\n");
-
-  if (display->overlay_key_combo.keysym != 0)
+  
+  if (display->overlay_key_combo.keysym 
+      && display->overlay_key_combo.keycode == 0)
    {
      display->overlay_key_combo.keycode = XKeysymToKeycode (
          display->xdisplay, display->overlay_key_combo.keysym);
@@ -247,11 +248,9 @@ reload_keycodes (MetaDisplay *display)
      i = 0;
      while (i < display->n_key_bindings)
        {
-          if (display->key_bindings[i].keysym != 0)
-            {
+          if (display->key_bindings[i].keycode == 0)
              display->key_bindings[i].keycode = XKeysymToKeycode (
                      display->xdisplay, display->key_bindings[i].keysym);
-            }
          
          ++i;
        }
@@ -531,51 +530,26 @@ void
 meta_display_process_mapping_event (MetaDisplay *display,
                                    XEvent      *event)
 { 
-  gboolean keymap_changed = FALSE;
-  gboolean modmap_changed = FALSE;
-
-#ifdef HAVE_XKB
-  if (event->type == display->xkb_base_event_type)
-    {
-      meta_topic (META_DEBUG_KEYBINDINGS,
-                  "XKB mapping changed, will redo keybindings\n");
-
-      keymap_changed = TRUE;
-      modmap_changed = TRUE;
-    }
-  else
-#endif
  if (event->xmapping.request == MappingModifier)
    {
      meta_topic (META_DEBUG_KEYBINDINGS,
                  "Received MappingModifier event, will reload modmap and redo keybindings\n");

-      modmap_changed = TRUE;
+      reload_modmap (display);
+
+      reload_modifiers (display);
+      
+      regrab_key_bindings (display);
    }
  else if (event->xmapping.request == MappingKeyboard)
    {
      meta_topic (META_DEBUG_KEYBINDINGS,
                  "Received MappingKeyboard event, will reload keycodes and redo keybindings\n");

-      keymap_changed = TRUE;
-    }
-
-  /* Now to do the work itself */
-
-  if (keymap_changed || modmap_changed)
-    {
-      if (keymap_changed)
-        reload_keymap (display);
-
-      /* Deciphering the modmap depends on the loaded keysyms to find out
-       * what modifiers is Super and so forth, so we need to reload it
-       * even when only the keymap changes */
+      reload_keymap (display);
      reload_modmap (display);
-
-      if (keymap_changed)
-        reload_keycodes (display);
-
-      reload_modifiers (display);
+      
+      reload_keycodes (display);

      regrab_key_bindings (display);
    }
@@ -643,14 +617,6 @@ meta_display_init_keys (MetaDisplay *display)
  /* Keys are actually grabbed in meta_screen_grab_keys() */
  
  meta_prefs_add_listener (bindings_changed_callback, display);
-
-#ifdef HAVE_XKB
-  /* meta_display_init_keys() should have already called XkbQueryExtension() */
-  if (display->xkb_base_event_type != -1)
-    XkbSelectEvents (display->xdisplay, XkbUseCoreKbd,
-                     XkbNewKeyboardNotifyMask | XkbMapNotifyMask,
-                     XkbNewKeyboardNotifyMask | XkbMapNotifyMask);
-#endif
 }

 void
--- a/src/core/prefs.c
+++ b/src/core/prefs.c
@@ -104,7 +104,7 @@ static char *cursor_theme = NULL;
 static int   cursor_size = 24;
 static gboolean compositing_manager = FALSE;
 static gboolean resize_with_right_button = FALSE;
-static gboolean edge_tiling = FALSE;
+static gboolean side_by_side_tiling = FALSE;
 static gboolean force_fullscreen = TRUE;

 static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_FULLSCREEN_FLASH;
@@ -423,9 +423,9 @@ static MetaBoolPreference preferences_bool[] =
      &resize_with_right_button,
      FALSE,
    },
-    { "/apps/metacity/general/edge_tiling",
-      META_PREF_EDGE_TILING,
-      &edge_tiling,
+    { "/apps/metacity/general/side_by_side_tiling",
+      META_PREF_SIDE_BY_SIDE_TILING,
+      &side_by_side_tiling,
      FALSE,
    },
    { "/apps/mutter/general/live_hidden_windows",
@@ -2010,8 +2010,8 @@ meta_preference_to_string (MetaPreference pref)
    case META_PREF_RESIZE_WITH_RIGHT_BUTTON:
      return "RESIZE_WITH_RIGHT_BUTTON";

-    case META_PREF_EDGE_TILING:
-      return "EDGE_TILING";
+    case META_PREF_SIDE_BY_SIDE_TILING:
+      return "SIDE_BY_SIDE_TILING";

    case META_PREF_FORCE_FULLSCREEN:
      return "FORCE_FULLSCREEN";
@@ -2926,9 +2926,9 @@ meta_prefs_get_gnome_animations ()
 }

 gboolean
-meta_prefs_get_edge_tiling ()
+meta_prefs_get_side_by_side_tiling ()
 {
-  return edge_tiling;
+  return side_by_side_tiling;
 }

 MetaKeyBindingAction
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -1758,7 +1758,6 @@ meta_screen_tile_preview_update_timeout (gpointer data)
  MetaScreen *screen = data;
  MetaWindow *window = screen->display->grab_window;
  gboolean composited = screen->display->compositor != NULL;
-  gboolean needs_preview = FALSE;

  screen->tile_preview_timeout_id = 0;

@@ -1776,28 +1775,9 @@ meta_screen_tile_preview_update_timeout (gpointer data)
                                     create_serial);
    }

-  if (window)
-    {
-      switch (window->tile_mode)
-        {
-          case META_TILE_LEFT:
-          case META_TILE_RIGHT:
-              if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
-                needs_preview = TRUE;
-              break;
-
-          case META_TILE_MAXIMIZED:
-              if (!META_WINDOW_MAXIMIZED (window))
-                needs_preview = TRUE;
-              break;
-
-          default:
-              needs_preview = FALSE;
-              break;
-        }
-    }
-
-  if (needs_preview)
+  if (window
+      && !META_WINDOW_TILED (window)
+      && window->tile_mode != META_TILE_NONE)
    {
      MetaRectangle tile_rect;

--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
@@ -54,8 +54,8 @@
 *
 * When we receive a new event: a) we compare the serial in the event to
 * the serial of the queued requests and remove any that are now
- * no longer pending b) if necessary, drop the predicted stacking
- * order to recompute it at the next opportunity.
+ * no longer pending b) drop the predicted stacking order to recompute
+ * it at the next opportunity.
 *
 * Possible optimizations:
 *  Keep the stacks as an array + reverse-mapping hash table to avoid
@@ -505,8 +505,6 @@ static void
 stack_tracker_event_received (MetaStackTracker *tracker,
 			      MetaStackOp      *op)
 {
-  gboolean need_sync = FALSE;
-
  meta_stack_op_dump (op, "Stack op event received: ", "\n");

  if (op->any.serial < tracker->server_serial)
@@ -514,8 +512,7 @@ stack_tracker_event_received (MetaStackTracker *tracker,

  tracker->server_serial = op->any.serial;

-  if (meta_stack_op_apply (op, tracker->server_stack))
-    need_sync = TRUE;
+  meta_stack_op_apply (op, tracker->server_stack);

  while (tracker->queued_requests->head)
    {
@@ -525,21 +522,17 @@ stack_tracker_event_received (MetaStackTracker *tracker,

      g_queue_pop_head (tracker->queued_requests);
      meta_stack_op_free (queued_op);
-      need_sync = TRUE;
    }

-  if (need_sync)
+  if (tracker->predicted_stack)
    {
-      if (tracker->predicted_stack)
-        {
-          g_array_free (tracker->predicted_stack, TRUE);
-          tracker->predicted_stack = NULL;
-        }
-
-      meta_stack_tracker_queue_sync_stack (tracker);
+      g_array_free (tracker->predicted_stack, TRUE);
+      tracker->predicted_stack = NULL;
    }

  meta_stack_tracker_dump (tracker);
+
+  meta_stack_tracker_queue_sync_stack (tracker);
 }

 void
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -64,8 +64,7 @@ typedef enum {
 typedef enum {
  META_TILE_NONE,
  META_TILE_LEFT,
-  META_TILE_RIGHT,
-  META_TILE_MAXIMIZED
+  META_TILE_RIGHT
 } MetaTileMode;

 struct _MetaWindow
@@ -410,11 +409,11 @@ struct _MetaWindowClass
                                        (w)->maximized_vertically)
 #define META_WINDOW_MAXIMIZED_VERTICALLY(w)    ((w)->maximized_vertically)
 #define META_WINDOW_MAXIMIZED_HORIZONTALLY(w)  ((w)->maximized_horizontally)
-#define META_WINDOW_TILED_SIDE_BY_SIDE(w)      ((w)->maximized_vertically && \
-                                                !(w)->maximized_horizontally && \
-                                                 (w)->tile_mode != META_TILE_NONE)
+#define META_WINDOW_TILED(w)           ((w)->maximized_vertically && \
+                                        !(w)->maximized_horizontally && \
+                                        (w)->tile_mode != META_TILE_NONE)
 #define META_WINDOW_ALLOWS_MOVE(w)     ((w)->has_move_func && !(w)->fullscreen)
-#define META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS(w)   ((w)->has_resize_func && !META_WINDOW_MAXIMIZED (w) && !META_WINDOW_TILED_SIDE_BY_SIDE(w) && !(w)->fullscreen && !(w)->shaded)
+#define META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS(w)   ((w)->has_resize_func && !META_WINDOW_MAXIMIZED (w) && !META_WINDOW_TILED(w) && !(w)->fullscreen && !(w)->shaded)
 #define META_WINDOW_ALLOWS_RESIZE(w)   (META_WINDOW_ALLOWS_RESIZE_EXCEPT_HINTS (w) &&                \
                                        (((w)->size_hints.min_width < (w)->size_hints.max_width) ||  \
                                         ((w)->size_hints.min_height < (w)->size_hints.max_height)))
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -2972,7 +2972,7 @@ ensure_size_hints_satisfied (MetaRectangle    *rect,
 static void
 meta_window_save_rect (MetaWindow *window)
 {
-  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED_SIDE_BY_SIDE (window) || window->fullscreen))
+  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED (window) || window->fullscreen))
    {
      /* save size/pos as appropriate args for move_resize */
      if (!window->maximized_horizontally)
@@ -3014,7 +3014,7 @@ force_save_user_window_placement (MetaWindow *window)
 static void
 save_user_window_placement (MetaWindow *window)
 {
-  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED_SIDE_BY_SIDE (window) || window->fullscreen))
+  if (!(META_WINDOW_MAXIMIZED (window) || META_WINDOW_TILED (window) || window->fullscreen))
    {
      MetaRectangle user_rect;

@@ -3187,18 +3187,11 @@ meta_window_is_fullscreen (MetaWindow *window)
 static void
 meta_window_tile (MetaWindow *window)
 {
-  MetaMaximizeFlags directions;
-
  /* Don't do anything if no tiling is requested */
  if (window->tile_mode == META_TILE_NONE)
    return;

-  if (window->tile_mode == META_TILE_MAXIMIZED)
-    directions = META_MAXIMIZE_VERTICAL | META_MAXIMIZE_HORIZONTAL;
-  else
-    directions = META_MAXIMIZE_VERTICAL;
-
-  meta_window_maximize_internal (window, directions, NULL);
+  meta_window_maximize_internal (window, META_MAXIMIZE_VERTICAL, NULL);
  meta_screen_tile_preview_update (window->screen, FALSE);

  if (window->display->compositor)
@@ -3225,7 +3218,7 @@ meta_window_tile (MetaWindow *window)
 }

 static gboolean
-meta_window_can_tile_side_by_side (MetaWindow *window)
+meta_window_can_tile (MetaWindow *window)
 {
  const MetaMonitorInfo *monitor;
  MetaRectangle tile_area;
@@ -3256,18 +3249,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)
 {
@@ -3335,13 +3316,6 @@ meta_window_unmaximize_internal (MetaWindow        *window,
      window->maximized_vertically =
        window->maximized_vertically   && !unmaximize_vertically;

-      /* Reset the tile mode for maximized tiled windows for consistency
-       * with "normal" maximized windows, but keep other tile modes,
-       * as side-by-side tiled windows may snap back.
-       */
-      if (window->tile_mode == META_TILE_MAXIMIZED)
-        window->tile_mode = META_TILE_NONE;
-
      /* Unmaximize to the saved_rect position in the direction(s)
       * being unmaximized.
       */
@@ -3425,8 +3399,7 @@ meta_window_unmaximize (MetaWindow        *window,
                        MetaMaximizeFlags  directions)
 {
  /* Restore tiling if necessary */
-  if (window->tile_mode == META_TILE_LEFT ||
-      window->tile_mode == META_TILE_RIGHT)
+  if (window->tile_mode != META_TILE_NONE)
    {
      window->maximized_horizontally = FALSE;
      meta_window_tile (window);
@@ -4718,13 +4691,6 @@ meta_window_get_geometry (MetaWindow  *window,
    window->size_hints.height_inc;
 }

-/**
- * meta_window_get_outer_rect:
- * @window: a #MetaWindow
- * @rect: (out): pointer to an allocated #MetaRectangle
- *
- * Gets the rectangle that bounds @window and, if decorated, its decorations.
- */
 void
 meta_window_get_outer_rect (const MetaWindow *window,
                            MetaRectangle    *rect)
@@ -7826,13 +7792,14 @@ 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_side_by_side_tiling () &&
+      meta_window_can_tile (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.
+      /* For tiling we are interested in the work area of the monitor where
+       * the pointer is located.
       * Also see comment in meta_window_get_current_tile_area()
       */
      monitor = meta_screen_get_current_monitor (window->screen);
@@ -7840,38 +7807,17 @@ update_move (MetaWindow  *window,
                                             monitor->number,
                                             &work_area);

-      if (meta_window_can_tile_side_by_side (window))
+      if (y >= monitor->rect.y &&
+          y < (monitor->rect.y + monitor->rect.height))
        {
-          if (y >= monitor->rect.y &&
-              y < (monitor->rect.y + monitor->rect.height))
-            {
-              /* 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 (meta_window_can_tile_maximized (window))
-        {
-          if (x >= monitor->rect.x &&
-              x < (monitor->rect.x + monitor->rect.width))
-            {
-              /* 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;
-            }
+          /* 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;
        }
    }

@@ -7881,15 +7827,12 @@ update_move (MetaWindow  *window,
   */

  if ((META_WINDOW_MAXIMIZED (window) && ABS (dy) >= shake_threshold) ||
-      (META_WINDOW_TILED_SIDE_BY_SIDE (window) && (MAX (ABS (dx), ABS (dy)) >= shake_threshold)))
+      (META_WINDOW_TILED (window) && (MAX (ABS (dx), ABS (dy)) >= shake_threshold)))
    {
      double prop;

-      /* Shake loose, so that the window snaps back to maximized
-       * when dragged near the top; do not snap back if tiling
-       * is enabled, as top edge tiling can be used in that case
-       */
-      window->shaken_loose = !meta_prefs_get_edge_tiling ();
+      /* Shake loose */
+      window->shaken_loose = !META_WINDOW_TILED (window);
      window->tile_mode = META_TILE_NONE;

      /* move the unmaximized window to the cursor */
@@ -7922,13 +7865,12 @@ update_move (MetaWindow  *window,
   * loose or it is still maximized (then move straight)
   */
  else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) &&
-           window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT)
+           window->tile_mode == META_TILE_NONE)
    {
      const MetaMonitorInfo *wmonitor;
      MetaRectangle work_area;
      int monitor;

-      window->tile_mode = META_TILE_NONE;
      wmonitor = meta_screen_get_monitor_for_window (window->screen, window);

      for (monitor = 0; monitor < window->screen->n_monitor_infos; monitor++)
@@ -7987,7 +7929,7 @@ update_move (MetaWindow  *window,
  meta_window_get_client_root_coords (window, &old);

  /* Don't allow movement in the maximized directions or while tiled */
-  if (window->maximized_horizontally || META_WINDOW_TILED_SIDE_BY_SIDE (window))
+  if (window->maximized_horizontally || META_WINDOW_TILED (window))
    new_x = old.x;
  if (window->maximized_vertically)
    new_y = old.y;
@@ -8423,23 +8365,6 @@ check_use_this_motion_notify (MetaWindow *window,
    }
 }

-static void
-update_tile_mode (MetaWindow *window)
-{
-  switch (window->tile_mode)
-    {
-      case META_TILE_LEFT:
-      case META_TILE_RIGHT:
-          if (!META_WINDOW_TILED_SIDE_BY_SIDE (window))
-              window->tile_mode = META_TILE_NONE;
-          break;
-      case META_TILE_MAXIMIZED:
-          if (!META_WINDOW_MAXIMIZED (window))
-              window->tile_mode = META_TILE_NONE;
-          break;
-    }
-}
-
 void
 meta_window_handle_mouse_grab_op_event (MetaWindow *window,
                                        XEvent     *event)
@@ -8532,7 +8457,9 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window,
               * would break the ability to snap back to the tiled
               * state, so we wait until mouse release.
               */
-              update_tile_mode (window);
+              if (!window->maximized_vertically &&
+                  window->tile_mode != META_TILE_NONE)
+                window->tile_mode = META_TILE_NONE;
            }
        }

--- a/src/core/workspace.c
+++ b/src/core/workspace.c
@@ -618,20 +618,10 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,
   meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
                                      new_space, &layout2);

-   if (meta_ui_get_direction() == META_UI_DIRECTION_RTL)
-     {
-       if (layout1.current_col > layout2.current_col)
-         direction = META_MOTION_RIGHT;
-       else if (layout1.current_col < layout2.current_col)
-         direction = META_MOTION_LEFT;
-     }
-   else
-    {
-       if (layout1.current_col < layout2.current_col)
-         direction = META_MOTION_RIGHT;
-       else if (layout1.current_col > layout2.current_col)
-         direction = META_MOTION_LEFT;
-    }
+   if (layout1.current_col < layout2.current_col)
+     direction = META_MOTION_RIGHT;
+   if (layout1.current_col > layout2.current_col)
+     direction = META_MOTION_LEFT;

   if (layout1.current_row < layout2.current_row)
     {
--- a/src/include/compositor-mutter.h
+++ b/src/include/compositor-mutter.h
@@ -39,6 +39,4 @@ Window        meta_get_overlay_window           (MetaScreen *screen);
 GList        *meta_get_window_actors            (MetaScreen *screen);
 ClutterActor *meta_get_window_group_for_screen  (MetaScreen *screen);

-ClutterActor *meta_get_background_actor_for_screen (MetaScreen *screen);
-
 #endif
--- a/src/include/meta-plugin.h
+++ b/src/include/meta-plugin.h
@@ -249,9 +249,6 @@ meta_plugin_get_overlay_group (MetaPlugin *plugin);
 ClutterActor *
 meta_plugin_get_window_group (MetaPlugin *plugin);

-ClutterActor *
-meta_plugin_get_background_actor (MetaPlugin *plugin);
-
 ClutterActor *
 meta_plugin_get_stage (MetaPlugin *plugin);

--- a/src/include/meta-shadow-factory.h
+++ b/src/include/meta-shadow-factory.h
@@ -72,6 +72,8 @@ MetaShadowFactory *meta_shadow_factory_get_default (void);

 GType meta_shadow_factory_get_type (void);

+MetaShadowFactory *meta_shadow_factory_new        (void);
+
 void meta_shadow_factory_set_params (MetaShadowFactory *factory,
                                     const char        *class_name,
                                     gboolean           focused,
--- a/src/include/prefs.h
+++ b/src/include/prefs.h
@@ -60,7 +60,7 @@ typedef enum
  META_PREF_CURSOR_SIZE,
  META_PREF_COMPOSITING_MANAGER,
  META_PREF_RESIZE_WITH_RIGHT_BUTTON,
-  META_PREF_EDGE_TILING,
+  META_PREF_SIDE_BY_SIDE_TILING,
  META_PREF_FORCE_FULLSCREEN,
  META_PREF_CLUTTER_PLUGINS,
  META_PREF_LIVE_HIDDEN_WINDOWS,
@@ -99,7 +99,7 @@ gboolean                    meta_prefs_get_auto_raise         (void);
 int                         meta_prefs_get_auto_raise_delay   (void);
 gboolean                    meta_prefs_get_gnome_accessibility (void);
 gboolean                    meta_prefs_get_gnome_animations   (void);
-gboolean                    meta_prefs_get_edge_tiling        (void);
+gboolean                    meta_prefs_get_side_by_side_tiling (void);

 const char*                 meta_prefs_get_command            (int i);

--- a/src/tools/mutter-window-demo.c
+++ b/src/tools/mutter-window-demo.c
@@ -51,7 +51,7 @@ set_gdk_window_struts (GdkWindow *window,
  vals[11] = 800;

  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
-                   GDK_WINDOW_XID (window),
+                   GDK_WINDOW_XWINDOW (window),
                   XInternAtom (GDK_WINDOW_XDISPLAY (window),
                                "_NET_WM_STRUT_PARTIAL", False),
                   XA_CARDINAL, 32, PropModeReplace,
@@ -125,7 +125,7 @@ set_gdk_window_type (GdkWindow  *window,
                          type, False);
  
  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
-                   GDK_WINDOW_XID (window),
+                   GDK_WINDOW_XWINDOW (window),
                   XInternAtom (GDK_WINDOW_XDISPLAY (window), "_NET_WM_WINDOW_TYPE", False),
                   XA_ATOM, 32, PropModeReplace,
                   (guchar *)atoms, 
--- a/src/ui/menu.c
+++ b/src/ui/menu.c
@@ -401,10 +401,10 @@ meta_window_menu_new   (MetaFrames         *frames,
                      n_workspaces, active_workspace);

                  window = gtk_widget_get_window (GTK_WIDGET (frames));
-                  display = GDK_WINDOW_XDISPLAY (window);
+                  display = gdk_x11_drawable_get_xdisplay (window);

                  screen = gdk_window_get_screen (window);
-                  xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
+                  xroot = GDK_DRAWABLE_XID (gdk_screen_get_root_window (screen));

                  submenu = gtk_menu_new ();

--- a/src/ui/testgradient.c
+++ b/src/ui/testgradient.c
@@ -23,17 +23,19 @@
 #include "gradient.h"
 #include <gtk/gtk.h>

-typedef void (* RenderGradientFunc) (cairo_t     *cr,
+typedef void (* RenderGradientFunc) (GdkDrawable *drawable,
+                                     cairo_t     *cr,
                                     int          width,
                                     int          height);

 static void
-draw_checkerboard (cairo_t *cr,
-                   int      width,
-                   int      height)
+draw_checkerboard (GdkDrawable *drawable,
+                   int          width,
+                   int          height)
 {
  gint i, j, xcount, ycount;
  GdkColor color1, color2;
+  cairo_t *cr;
  
 #define CHECK_SIZE 10
 #define SPACING 2  
@@ -46,6 +48,8 @@ draw_checkerboard (cairo_t *cr,
  color2.green = 50000;
  color2.blue = 50000;

+  cr = gdk_cairo_create (drawable);
+
  xcount = 0;
  i = SPACING;
  while (i < width)
@@ -73,10 +77,13 @@ draw_checkerboard (cairo_t *cr,
      i += CHECK_SIZE + SPACING;
      ++xcount;
    }
+  
+  cairo_destroy (cr);
 }

 static void
-render_simple (cairo_t     *cr,
+render_simple (GdkDrawable *drawable,
+               cairo_t     *cr,
               int width, int height,
               MetaGradientType type,
               gboolean    with_alpha)
@@ -108,7 +115,7 @@ render_simple (cairo_t     *cr,
                               alphas, G_N_ELEMENTS (alphas),
                               META_GRADIENT_HORIZONTAL);
      
-      draw_checkerboard (cr , width, height);
+      draw_checkerboard (drawable, width, height);
    }
    
  gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
@@ -119,35 +126,40 @@ render_simple (cairo_t     *cr,
 }

 static void
-render_vertical_func (cairo_t *cr,
+render_vertical_func (GdkDrawable *drawable,
+                      cairo_t *cr,
                      int width, int height)
 {
-  render_simple (cr, width, height, META_GRADIENT_VERTICAL, FALSE);
+  render_simple (drawable, cr, width, height, META_GRADIENT_VERTICAL, FALSE);
 }

 static void
-render_horizontal_func (cairo_t *cr,
+render_horizontal_func (GdkDrawable *drawable,
+                        cairo_t *cr,
                        int width, int height)
 {
-  render_simple (cr, width, height, META_GRADIENT_HORIZONTAL, FALSE);
+  render_simple (drawable, cr, width, height, META_GRADIENT_HORIZONTAL, FALSE);
 }

 static void
-render_diagonal_func (cairo_t *cr,
+render_diagonal_func (GdkDrawable *drawable,
+                      cairo_t *cr,
                      int width, int height)
 {
-  render_simple (cr, width, height, META_GRADIENT_DIAGONAL, FALSE);
+  render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, FALSE);
 }

 static void
-render_diagonal_alpha_func (cairo_t *cr,
+render_diagonal_alpha_func (GdkDrawable *drawable,
+                            cairo_t *cr,
                            int width, int height)
 {
-  render_simple (cr, width, height, META_GRADIENT_DIAGONAL, TRUE);
+  render_simple (drawable, cr, width, height, META_GRADIENT_DIAGONAL, TRUE);
 }

 static void
-render_multi (cairo_t     *cr,
+render_multi (GdkDrawable *drawable,
+              cairo_t     *cr,
              int width, int height,
              MetaGradientType type)
 {
@@ -174,28 +186,32 @@ render_multi (cairo_t     *cr,
 }

 static void
-render_vertical_multi_func (cairo_t *cr,
+render_vertical_multi_func (GdkDrawable *drawable,
+                            cairo_t *cr,
                            int width, int height)
 {
-  render_multi (cr, width, height, META_GRADIENT_VERTICAL);
+  render_multi (drawable, cr, width, height, META_GRADIENT_VERTICAL);
 }

 static void
-render_horizontal_multi_func (cairo_t *cr,
+render_horizontal_multi_func (GdkDrawable *drawable,
+                              cairo_t *cr,
                              int width, int height)
 {
-  render_multi (cr, width, height, META_GRADIENT_HORIZONTAL);
+  render_multi (drawable, cr, width, height, META_GRADIENT_HORIZONTAL);
 }

 static void
-render_diagonal_multi_func (cairo_t *cr,
+render_diagonal_multi_func (GdkDrawable *drawable,
+                            cairo_t *cr,
                            int width, int height)
 {
-  render_multi (cr, width, height, META_GRADIENT_DIAGONAL);
+  render_multi (drawable, cr, width, height, META_GRADIENT_DIAGONAL);
 }

 static void
-render_interwoven_func (cairo_t *cr,
+render_interwoven_func (GdkDrawable *drawable,
+                        cairo_t     *cr,
                        int width, int height)
 {
  GdkPixbuf *pixbuf;
@@ -219,22 +235,31 @@ render_interwoven_func (cairo_t *cr,
 }

 static gboolean
-draw_callback (GtkWidget *widget,
-               cairo_t   *cr,
-               gpointer   data)
+expose_callback (GtkWidget *widget,
+                 GdkEventExpose *event,
+                 gpointer data)
 {
  RenderGradientFunc func = data;
+  GdkWindow *window;
+  GtkAllocation allocation;
  GtkStyle *style;
+  cairo_t *cr;

  style = gtk_widget_get_style (widget);
+  gtk_widget_get_allocation (widget, &allocation);

+  window = gtk_widget_get_window (widget);
+  cr = gdk_cairo_create (window);
  gdk_cairo_set_source_color (cr, &style->fg[gtk_widget_get_state (widget)]);

-  (* func) (cr,
-            gtk_widget_get_allocated_width (widget),
-            gtk_widget_get_allocated_height (widget));
+  (* func) (gtk_widget_get_window (widget),
+            cr,
+            allocation.width,
+            allocation.height);

-  return FALSE;
+  cairo_destroy (cr);
+
+  return TRUE;
 }

 static GtkWidget*
@@ -255,8 +280,8 @@ create_gradient_window (const char *title,
  gtk_window_set_default_size (GTK_WINDOW (window), 175, 175);
  
  g_signal_connect (G_OBJECT (drawing_area),
-                    "draw",
-                    G_CALLBACK (draw_callback),
+                    "expose_event",
+                    G_CALLBACK (expose_callback),
                    func);

  gtk_container_add (GTK_CONTAINER (window), drawing_area);
--- a/src/ui/theme-viewer.c
+++ b/src/ui/theme-viewer.c
@@ -234,7 +234,7 @@ dialog_contents (void)
  
  vbox = gtk_vbox_new (FALSE, 0);

-  action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
+  action_area = gtk_hbutton_box_new ();

  gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),
                             GTK_BUTTONBOX_END);  
--- a/src/ui/theme.c
+++ b/src/ui/theme.c
@@ -6089,20 +6089,16 @@ meta_gradient_type_to_string (MetaGradientType type)
 GtkStateType
 meta_gtk_state_from_string (const char *str)
 {
-  if (g_ascii_strcasecmp ("normal", str) == 0)
+  if (strcmp ("normal", str) == 0 || strcmp ("NORMAL", str) == 0)
    return GTK_STATE_NORMAL;
-  else if (g_ascii_strcasecmp ("prelight", str) == 0)
+  else if (strcmp ("prelight", str) == 0 || strcmp ("PRELIGHT", str) == 0)
    return GTK_STATE_PRELIGHT;
-  else if (g_ascii_strcasecmp ("active", str) == 0)
+  else if (strcmp ("active", str) == 0 || strcmp ("ACTIVE", str) == 0)
    return GTK_STATE_ACTIVE;
-  else if (g_ascii_strcasecmp ("selected", str) == 0)
+  else if (strcmp ("selected", str) == 0 || strcmp ("SELECTED", str) == 0)
    return GTK_STATE_SELECTED;
-  else if (g_ascii_strcasecmp ("insensitive", str) == 0)
+  else if (strcmp ("insensitive", str) == 0 || strcmp ("INSENSITIVE", str) == 0)
    return GTK_STATE_INSENSITIVE;
-  else if (g_ascii_strcasecmp ("inconsistent", str) == 0)
-    return GTK_STATE_INCONSISTENT;
-  else if (g_ascii_strcasecmp ("focused", str) == 0)
-    return GTK_STATE_FOCUSED;
  else
    return -1; /* hack */
 }
@@ -6122,10 +6118,6 @@ meta_gtk_state_to_string (GtkStateType state)
      return "SELECTED";
    case GTK_STATE_INSENSITIVE:
      return "INSENSITIVE";
-    case GTK_STATE_INCONSISTENT:
-      return "INCONSISTENT";
-    case GTK_STATE_FOCUSED:
-      return "FOCUSED";
    }

  return "<unknown>";
--- a/src/ui/tile-preview.c
+++ b/src/ui/tile-preview.c
@@ -195,7 +195,7 @@ meta_tile_preview_show (MetaTilePreview *preview,
  gtk_widget_show (preview->preview_window);
  window = gtk_widget_get_window (preview->preview_window);
  meta_core_lower_beneath_focus_window (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
-                                        GDK_WINDOW_XID (window),
+                                        GDK_WINDOW_XWINDOW (window),
                                        gtk_get_current_event_time ());

  old_rect.x = old_rect.y = 0;
@@ -254,5 +254,5 @@ meta_tile_preview_get_xwindow (MetaTilePreview *preview,
  if (create_serial)
    *create_serial = preview->create_serial;

-  return GDK_WINDOW_XID (window);
+  return GDK_WINDOW_XWINDOW (window);
 }
--- a/src/ui/ui.c
+++ b/src/ui/ui.c
@@ -60,16 +60,6 @@ struct _MetaUI
 void
 meta_ui_init (int *argc, char ***argv)
 {
-  /* As of 2.91.7, Gdk uses XI2 by default, which conflicts with the
-   * direct X calls we use - in particular, events caused by calls to
-   * XGrabPointer/XGrabKeyboard are no longer understood by GDK, while
-   * GDK will no longer generate the core XEvents we process.
-   * So at least for now, enforce the previous behavior.
-   */
-#if GTK_CHECK_VERSION(2, 91, 7)
-  gdk_disable_multidevice ();
-#endif
-
  if (!gtk_init_check (argc, argv))
    meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL));

@@ -101,7 +91,6 @@ static gboolean
 maybe_redirect_mouse_event (XEvent *xevent)
 {
  GdkDisplay *gdisplay;
-  GdkDeviceManager *gmanager;
  MetaUI *ui;
  GdkEvent *gevent;
  GdkWindow *gdk_window;
@@ -129,7 +118,7 @@ maybe_redirect_mouse_event (XEvent *xevent)
  if (!ui)
    return FALSE;

-  gdk_window = gdk_x11_window_lookup_for_display (gdisplay, window);
+  gdk_window = gdk_window_lookup_for_display (gdisplay, window);
  if (gdk_window == NULL)
    return FALSE;

@@ -207,8 +196,7 @@ maybe_redirect_mouse_event (XEvent *xevent)
    }

  /* If we've gotten here, we've created the gdk_event and should send it on */
-  gmanager = gdk_display_get_device_manager (gdisplay);
-  gdk_event_set_device (gevent, gdk_device_manager_get_client_pointer (gmanager));
+  gdk_event_set_device (gevent, gdk_display_get_core_pointer (gdisplay));
  gtk_main_do_event (gevent);
  gdk_event_free (gevent);

@@ -411,10 +399,8 @@ meta_ui_map_frame   (MetaUI *ui,
                     Window  xwindow)
 {
  GdkWindow *window;
-  GdkDisplay *display;

-  display = gdk_x11_lookup_xdisplay (ui->xdisplay);
-  window = gdk_x11_window_lookup_for_display (display, xwindow);
+  window = gdk_xid_table_lookup (xwindow);

  if (window)
    gdk_window_show_unraised (window);
@@ -425,10 +411,8 @@ meta_ui_unmap_frame (MetaUI *ui,
                     Window  xwindow)
 {
  GdkWindow *window;
-  GdkDisplay *display;

-  display = gdk_x11_lookup_xdisplay (ui->xdisplay);
-  window = gdk_x11_window_lookup_for_display (display, xwindow);
+  window = gdk_xid_table_lookup (xwindow);

  if (window)
    gdk_window_hide (window);
@@ -657,10 +641,8 @@ meta_ui_window_should_not_cause_focus (Display *xdisplay,
                                       Window   xwindow)
 {
  GdkWindow *window;
-  GdkDisplay *display;

-  display = gdk_x11_lookup_xdisplay (xdisplay);
-  window = gdk_x11_window_lookup_for_display (display, xwindow);
+  window = gdk_xid_table_lookup (xwindow);

  /* we shouldn't cause focus if we're an override redirect
   * toplevel which is not foreign
@@ -675,20 +657,17 @@ char*
 meta_text_property_to_utf8 (Display             *xdisplay,
                            const XTextProperty *prop)
 {
-  GdkDisplay *display;
  char **list;
  int count;
  char *retval;
  
  list = NULL;

-  display = gdk_x11_lookup_xdisplay (xdisplay);
-  count = gdk_text_property_to_utf8_list_for_display (display,
-                                                      gdk_x11_xatom_to_atom (prop->encoding),
-                                                      prop->format,
-                                                      prop->value,
-                                                      prop->nitems,
-                                                      &list);
+  count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),
+                                          prop->format,
+                                          prop->value,
+                                          prop->nitems,
+                                          &list);

  if (count == 0)
    retval = NULL;
@@ -913,11 +892,9 @@ gboolean
 meta_ui_window_is_widget (MetaUI *ui,
                          Window  xwindow)
 {
-  GdkDisplay *display;
  GdkWindow *window;

-  display = gdk_x11_lookup_xdisplay (ui->xdisplay);
-  window = gdk_x11_window_lookup_for_display (display, xwindow);
+  window = gdk_xid_table_lookup (xwindow);

  if (window)
    {
Author	SHA1	Message	Date
Owen W. Taylor	0a4cfde4e2	MetaWindowActor: Fix crashes when mapping and unmapping windows The assumptions made when getting the size of the window for the paint volume turned out not to be accurate in all cases - get_paint_volume() could be called on windows without computed bounds. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:47 -05:00
Owen W. Taylor	c853d197e3	Omit shadows for fullscreen and maximized windows Fullscreen and maximized windows never have visible shadows - the only case where we would ever see them is if they bleed onto an adjacent monitor and that looks bad. It's small performance win to avoid computing them, and this also avoids painting the top shadow for all maximized windows in GNOME Shell - since the top panel isn't a X window, it doesn't factor into the computation of what parts of windows are visible and maximized windows are computed as having a top shadow. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:47 -05:00
Owen W. Taylor	bf7ae3e4d3	Add meta_window_get_maximized() and meta_window_is_fullscreen() These functions duplicate existing properties; they are added for convenience and to avoid the GObject property code on some performance critical painting paths. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:47 -05:00
Owen W. Taylor	2b21f1d48c	Implement more accurate clipping of obscured shadows Instead of making optimizing obscured shadows an all-or-none operation, pass the clip region to meta_shadow_paint() and only paint the 9-slices that are at least partially visible. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:47 -05:00
Owen W. Taylor	4c91e05b86	Report a correct paint volume for shadowed windows Since we paint shadows directly now rather than using a child actor in the ClutterGroup, we need to implement get_paint_volume() for Clutter 1.5. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:47 -05:00
Owen W. Taylor	bc91c328f3	Use a template material for shadows To avoid unnecessary shader recompilation, use a root template material for all shadows. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:46 -05:00
Owen W. Taylor	5bbbac65d6	Make window shadows globally configurable Instead of setting shadow parameters on individual windows, add the idea of a "shadow class". Windows have default shadow classes based on their frame and window type, which can be overriden by setting the shadow-class property. Each shadow class has separably configurable parameters for the focused and unfocused state. New shadow classes can be defined with arbitrary names. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:46 -05:00
Owen W. Taylor	a0a0fc14d7	Export meta_frame_type_to_string() Frame types will form the bases of shadow classes, which are strings, so export the to-string function so that we can do the conversion uniformly. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:46 -05:00
Owen W. Taylor	cc9efe1289	Add meta_window_get_frame_type() Add a public function to get the frame type for a window; the code is refactored from existing code in core.c. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:46 -05:00
Owen W. Taylor	8825ded1ca	Export meta_window_appears_focused() Move meta_window_appears_focused() into the public window.h so we can use it to change the shadow type. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:46 -05:00
Owen W. Taylor	b823ef0007	Make MetaShadowFactory public The basic MetaShadowFactory type is moved to a public header, while the functions to fetch and paint shadows are kept private. The public object will be used for configuration of shadows by plugins. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:45 -05:00
Owen W. Taylor	a846434bcf	MetaShadowFactory: convert to a GObject https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:45 -05:00
Owen W. Taylor	825fc2c0c8	MetaShadowFactory: Add the ability to top-fade a shadow For attached modal dialogs, we want the shadow to fade out at the top as if the window was glued to the parent at the top. Add a shadow-top-fade property to MetaWindowActor and the corresponding parameter to meta_shadow_factory_get_shadow(). The internal implementation of MetaShadow is adjusted to work in terms of an "inner border" and "outer border" instead of doing the calculations in terms of an aggregate border and the spread of the shadow. The old way of doing things gets clumsy when the top_fade distance is added in as well. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-13 11:44:45 -05:00
Owen W. Taylor	4fbe547f16	Add frame type for attached modal dialogs Add a new frame type META_FRAME_TYPE_ATTACHED which is used for attached modal dialogs. The theme format version is bumped to 3.2, and attached windows can have borders defined in a metacity-theme-3.xml as: <window version=">= 3.2" type="attached" style_set="[name]"/> If no style is defined for "attached", drawing will fall back to the "border" type. https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-11 18:47:38 -05:00
Owen W. Taylor	fc2ba0afbe	Make shadows pretty and configurable The current shadow code just uses a single fixed texture (the Gaussian blur of a rectangle with a fixed blur radius) for drawing all window shadows. This patch adds the ability * Implement efficient blurring of arbitrary regions by approximating a Gaussian blur with multiple box blurs. * Detect when multiple windows can use the same shadow texture by converting their shape into a size-invariant MetaWindowShape. * Add properties shadow-radius, shadow-x-offset, shadow-y-offset, shadow-opacity to allow the shadow for a window to be configured. * Add meta_window_actor_paint() and draw the shadow directly from there rather than using a child actor. * Remove TidyTextureFrame, which is no longer used https://bugzilla.gnome.org/show_bug.cgi?id=592382	2010-11-10 14:42:54 -05:00