Bump version to 2.29.0

The change to reduce GConf trips by using
gconf_client_all_entries() broke the fallback to builtin values
because update_binding() was no longer called for bindings not
found in GConf. Fix this by keeping track of the bindings we
find from GConf in a hash table, then looping through and setting
all the bindings at the end.

This also improves efficiency by avoiding a linear scan for each
binding in GConf.

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

.gitignore

@@ -13,17 +13,22 @@ config.sub
 configure
 depcomp
 install-sh
+intltool-extract.in
+intltool-merge.in
 libtool
 ltmain.sh
 missing
 .deps
-src/metacity-wm.desktop
+src/mutter-wm.desktop
+src/mutter.desktop
 *.o
 *.a
 *.lo
 *.la
 .libs
 *.swp
+*.gir
+*.typelib
 tidy-enum-types.[ch]
 tidy-marshal.[ch]
 stamp-tidy-enum-types.h
@@ -38,19 +43,18 @@ POTFILES
 50-metacity-desktop-key.xml
 50-metacity-key.xml
 inlinepixbufs.h
-libmetacity-private.pc
-metacity
-metacity-dialog
-metacity-theme-viewer
-metacity.desktop
-metacity.schemas
+libmutter-private.pc
+mutter
+mutter-theme-viewer
+mutter.desktop
+mutter.schemas
 testasyncgetprop
 testboxes
 testgradient
-metacity-grayscale
-metacity-mag
-metacity-message
-metacity-window-demo
+mutter-grayscale
+mutter-mag
+mutter-message
+mutter-window-demo
 focus-window
 test-gravity
 test-resizing
@@ -58,3 +62,8 @@ test-size-hints
 wm-tester
 INSTALL
 mkinstalldirs
+src/mutter-enum-types.[ch]
+src/stamp-mutter-enum-types.h
+src/mutter-marshal.[ch]
+src/stamp-mutter-marshal.h
+src/mutter-plugins.pc

README

@@ -20,7 +20,7 @@ libstartup-notification at
 http://www.freedesktop.org/software/startup-notification/ or on the
 GNOME ftp site. You also need GConf 1.2 (unless building a funky
 extra-small embedded metacity with --disable-gconf, see below).
-You need Clutter 0.9.3. You need gobject-introspection 0.6.3.
+You need Clutter 1.0. You need gobject-introspection 0.6.3.
 
 REPORTING BUGS AND SUBMITTING PATCHES
 ===

configure.in

@@ -1,9 +1,7 @@
 AC_PREREQ(2.50)
 
 m4_define([mutter_major_version], [2])
-m4_define([mutter_minor_version], [27])
-# Fibonacci sequence for micro version numbering:
-# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987
+m4_define([mutter_minor_version], [29])
 m4_define([mutter_micro_version], [0])
 
 m4_define([mutter_version],
@@ -17,7 +15,8 @@ AC_INIT([mutter], [mutter_version],
 AC_CONFIG_SRCDIR(src/core/display.c)
 AC_CONFIG_HEADERS(config.h)
 
-AM_INIT_AUTOMAKE
+AM_INIT_AUTOMAKE([dist-bzip2 no-dist-gzip])
+m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])],)
 AM_MAINTAINER_MODE
 
 MUTTER_MAJOR_VERSION=mutter_major_version
@@ -46,6 +45,9 @@ AC_HEADER_STDC
 AC_LIBTOOL_WIN32_DLL
 AM_PROG_LIBTOOL
 
+# Sets GLIB_GENMARSHAL and GLIB_MKENUMS
+AM_PATH_GLIB_2_0()
+
 #### Integer sizes
 
 AC_CHECK_SIZEOF(char)
@@ -153,31 +155,21 @@ AC_ARG_ENABLE(startup-notification,
                  [disable mutter's startup notification support, for embedded/size-sensitive custom non-GNOME builds]),,
   enable_startup_notification=auto)
 
-AC_ARG_ENABLE(compositor,
-  AC_HELP_STRING([--disable-compositor],
-                 [disable mutter's compositing manager]),,
-  enable_compositor=auto)
-
-AC_ARG_ENABLE(clutter,
-  AC_HELP_STRING([--without-clutter],
-                 [disable the use of clutter for compositing]),,
-  with_clutter=auto)
-
-AC_ARG_ENABLE(introspection,
+AC_ARG_WITH(introspection,
   AC_HELP_STRING([--without-introspection],
                  [disable the use of GObject introspection]),,
   with_introspection=auto)
 
+AC_ARG_WITH(libcanberra,
+  AC_HELP_STRING([--without-libcanberra],
+                 [disable the use of libcanberra for playing sounds]),,
+  with_libcanberra=auto)
+
 AC_ARG_ENABLE(xsync,
   AC_HELP_STRING([--disable-xsync],
                  [disable mutter's use of the XSync extension]),,
   enable_xsync=auto)
 
-AC_ARG_ENABLE(render,
-  AC_HELP_STRING([--disable-render],
-                 [disable mutter's use of the RENDER extension]),,
-  enable_render=auto)
-
 AC_ARG_ENABLE(shape,
   AC_HELP_STRING([--disable-shape],
                  [disable mutter's use of the shaped window extension]),,
@@ -191,16 +183,10 @@ AM_GLIB_GNU_GETTEXT
 ## here we get the flags we'll actually use
 # GOptionEntry requires	glib-2.6.0
 PKG_CHECK_MODULES(ALL, glib-2.0 >= 2.6.0)
-# gtk_window_set_icon_name requires gtk2+-2.60
+# gtk_window_set_icon_name requires gtk2+-2.6.0
 PKG_CHECK_MODULES(MUTTER_MESSAGE, gtk+-2.0 >= 2.6.0)
 PKG_CHECK_MODULES(MUTTER_WINDOW_DEMO, gtk+-2.0 >= 2.6.0)
 
-if $PKG_CONFIG --atleast-version 1.2.0 pangoxft; then
-   echo "pangoxft found"
-else
-   AC_MSG_ERROR("Pango 1.2.0 or greater based on Xft2 is required")
-fi
-
 # Unconditionally use this dir to avoid a circular dep with gnomecc
 GNOME_KEYBINDINGS_KEYSDIR="${datadir}/gnome-control-center/keybindings"
 AC_SUBST(GNOME_KEYBINDINGS_KEYSDIR)
@@ -231,43 +217,28 @@ else
   echo "Building without libstartup-notification"
 fi
 
-## init this, it gets set either in the compositor check below
-## or the render-specific check later
-have_xrender=no
+have_libcanberra=no
+AC_MSG_CHECKING([libcanberra-gtk])
+if test x$with_libcanberra = xno ; then
+  AC_MSG_RESULT([disabled])
+else
+  if $PKG_CONFIG --exists libcanberra-gtk; then
+    have_libcanberra=yes
+    AC_MSG_RESULT(yes)
+    MUTTER_PC_MODULES="$MUTTER_PC_MODULES libcanberra-gtk"
+    AC_DEFINE([HAVE_LIBCANBERRA], 1, [Building with libcanberra for playing sounds])
+  else
+    AC_MSG_RESULT(no)
+    if test x$with_libcanberra = xyes ; then
+      AC_MSG_ERROR([libcanberra forced and libcanberra-gtk was not found])
+    fi
+  fi
+fi
 
 XCOMPOSITE_VERSION=0.2
-if test x$enable_compositor = xyes; then
-   have_xcomposite=yes
-elif test x$enable_compositor = xauto; then
-   echo "Building compositing manager by default now."
-   have_xcomposite=yes
-else
-   have_xcomposite=no
-fi
 
-if test x$with_clutter = xyes; then
-   have_xcomposite=yes
-   have_clutter=yes
-elif test x$with_clutter = xauto; then
-   echo "Building clutter compositing manager by default now."
-   have_xcomposite=yes
-   have_clutter=yes
-else
-   have_clutter=no
-fi
-
-AM_CONDITIONAL(WITH_CLUTTER, test "$have_clutter" = "yes")
-
-if test x$have_xcomposite = xyes; then
-   AC_MSG_CHECKING([Xcomposite >= $XCOMPOSITE_VERSION])
-   if $PKG_CONFIG --atleast-version $XCOMPOSITE_VERSION xcomposite; then
-      AC_MSG_RESULT([yes])
-   else
-      AC_MSG_ERROR([no. Use --disable-compositor to disable.])
-   fi
-fi
-
-if test x$have_xcomposite = xyes; then
+AC_MSG_CHECKING([Xcomposite >= $XCOMPOSITE_VERSION])
+if $PKG_CONFIG --atleast-version $XCOMPOSITE_VERSION xcomposite; then
   MUTTER_PC_MODULES="$MUTTER_PC_MODULES xcomposite >= $XCOMPOSITE_VERSION xfixes xrender xdamage"
   AC_DEFINE(HAVE_COMPOSITE_EXTENSIONS, 1, [Building with compositing manager support])
   echo "Building with compositing manager"
@@ -275,42 +246,13 @@ if test x$have_xcomposite = xyes; then
   ## force on render also
   have_xrender=yes
 else
-  echo "Building without compositing manager"
+  AC_MSG_ERROR([no. Mutter requires the Xcomposite extension to build.])
 fi
 
-## if no compositor, still possibly enable render
-if test x$have_xcomposite = xno; then
-  XRENDER_VERSION=0.0
-  AC_MSG_CHECKING([xrender >= $XRENDER_VERSION])
-  if $PKG_CONFIG --atleast-version $XRENDER_VERSION xrender; then
-     have_xrender=yes
-  else
-     have_xrender=no
-  fi
-  AC_MSG_RESULT($have_xrender)
-
-  if test x$enable_render = xyes; then
-     have_xrender=yes
-     echo "Render support forced on"
-  elif test x$enable_render = xauto; then
-     true
-  else
-     have_xrender=no
-  fi
-
-  if test x$have_xrender = xyes; then
-     echo "Building with Render"
-     MUTTER_PC_MODULES="$MUTTER_PC_MODULES xrender >= $XRENDER_VERSION"
-  fi
-fi ## have_composite
-
-if test x$have_xrender = xyes; then
-  AC_DEFINE(HAVE_RENDER, , [Building with Render extension support])
-fi
-
-CLUTTER_PACKAGE=clutter-0.9
+CLUTTER_VERSION=1.0.0
+CLUTTER_PACKAGE=clutter-1.0
 AC_SUBST(CLUTTER_PACKAGE)
-if test x$have_clutter = xyes; then
+if $PKG_CONFIG --atleast-version $CLUTTER_VERSION $CLUTTER_PACKAGE ; then
   MUTTER_PC_MODULES="$MUTTER_PC_MODULES $CLUTTER_PACKAGE "
   PKG_CHECK_MODULES(CLUTTER, $CLUTTER_PACKAGE)
   AC_DEFINE(WITH_CLUTTER, , [Building with Clutter compositor])
@@ -327,6 +269,8 @@ if test x$have_clutter = xyes; then
     AC_DEFINE(HAVE_GLX_TEXTURE_PIXMAP, ,
               [Is ClutterGLXTexturePixmap available?])
   fi
+else
+  AC_MSG_ERROR([no. Mutter requires Clutter version $CLUTTER_VERSION.])
 fi
 
 if test x$with_introspection != xno; then
@@ -493,7 +437,7 @@ fi
 
 MUTTER_LIBS="$MUTTER_LIBS $XSYNC_LIBS $RANDR_LIBS $SHAPE_LIBS $X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS -lm"
 MUTTER_MESSAGE_LIBS="$MUTTER_MESSAGE_LIBS $X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
-MUTTER_WINDOW_DEMO_LIBS="$MUTTER_WINDOW_DEMO_LIBS $X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
+MUTTER_WINDOW_DEMO_LIBS="$MUTTER_WINDOW_DEMO_LIBS $X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS -lm"
 MUTTER_PROPS_LIBS="$MUTTER_PROPS_LIBS $X_LIBS $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
 
 found_sm=no
@@ -578,7 +522,7 @@ src/wm-tester/Makefile
 src/libmutter-private.pc
 src/mutter-plugins.pc
 src/tools/Makefile
-src/compositor/mutter/plugins/Makefile
+src/compositor/plugins/Makefile
 po/Makefile.in
 ])
 
@@ -611,20 +555,18 @@ mutter-$VERSION:
 	XFree86 Xinerama:         ${use_xfree_xinerama}
 	Solaris Xinerama:         ${use_solaris_xinerama}
 	Startup notification:     ${have_startup_notification}
-	Compositing manager:      ${have_xcomposite}
+	libcanberra:              ${have_libcanberra}
 	Introspection:            ${have_introspection}
 	Session management:       ${found_sm}
 	Shape extension:          ${found_shape}
-	Resize-and-rotate:        ${found_randr}
 	Xsync:                    ${found_xsync}
-	Render:                   ${have_xrender}
 	Xcursor:                  ${have_xcursor}
-	Clutter:                  ${have_clutter}
 "
 
+
 MUTTER_MINOR_VERSION=mutter_minor_version
-if test $(( $(echo $MUTTER_MINOR_VERSION) %2)) == "1"; then
-   stable_version=$(( ($MUTTER_MINOR_VERSION / 2) * 2))
+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 Subversion)"

po/LINGUAS

@@ -10,6 +10,7 @@ be@latin
 bg
 bn
 bn_IN
+br
 bs
 ca
 ca@valencia
@@ -56,6 +57,7 @@ mn
 mr
 ms
 nb
+nds
 ne
 nl
 nn

po/POTFILES.in

@@ -1,5 +1,6 @@
 # List of source files containing translatable strings.
 # Please keep this file sorted alphabetically.
+src/core/bell.c
 src/core/core.c
 src/core/delete.c
 src/core/display.c

src/Makefile.am

@@ -1,29 +1,48 @@
+# Flag build for parallelism; see https://savannah.gnu.org/patch/?6905
+.AUTOPARALLEL:
+
 lib_LTLIBRARIES = libmutter-private.la
 
-SUBDIRS=wm-tester tools
-
-if WITH_CLUTTER
-SUBDIRS += compositor/mutter/plugins
-endif
+SUBDIRS=wm-tester tools compositor/plugins
 
 INCLUDES=@MUTTER_CFLAGS@ -I $(srcdir)/include -I$(srcdir)/compositor -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PKGLIBDIR=\"$(pkglibdir)\" -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
 
+mutter_built_sources = \
+	mutter-marshal.h \
+	mutter-marshal.c \
+	mutter-enum-types.h \
+	mutter-enum-types.c
+
 mutter_SOURCES= 				\
 	core/async-getprop.c			\
 	core/async-getprop.h			\
-	core/alttabhandler.c			\
-	include/alttabhandler.h			\
-	core/alttabhandlerdefault.c		\
-	include/alttabhandlerdefault.h		\
 	core/bell.c				\
 	core/bell.h				\
 	core/boxes.c				\
 	include/boxes.h				\
 	compositor/compositor.c			\
 	compositor/compositor-private.h		\
-	compositor/compositor-xrender.c		\
-	compositor/compositor-xrender.h		\
+	compositor/mutter-module.c		\
+	compositor/mutter-module.h		\
+	compositor/mutter-plugin.c		\
+	compositor/mutter-plugin-manager.c	\
+	compositor/mutter-plugin-manager.h	\
+	compositor/mutter-shaped-texture.c	\
+	compositor/mutter-texture-tower.c	\
+	compositor/mutter-texture-tower.h	\
+	compositor/mutter-window.c		\
+	compositor/mutter-window-private.h	\
+	compositor/mutter-window-group.c	\
+	compositor/mutter-window-group.h	\
+	compositor/shadow.c			\
+	compositor/shadow.h			\
+	compositor/mutter-shaped-texture.h	\
+	compositor/tidy/tidy-texture-frame.c	\
+	compositor/tidy/tidy-texture-frame.h	\
 	include/compositor.h			\
+	include/mutter-plugin.h			\
+	include/mutter-window.h			\
+	include/compositor-mutter.h 		\
 	core/constraints.c			\
 	core/constraints.h			\
 	core/core.c				\
@@ -35,8 +54,6 @@ mutter_SOURCES= 				\
 	ui/draw-workspace.h			\
 	core/edge-resistance.c			\
 	core/edge-resistance.h			\
-	core/effects.c				\
-	core/effects.h				\
 	core/errors.c				\
 	include/errors.h			\
 	core/eventqueue.c			\
@@ -56,7 +73,6 @@ mutter_SOURCES= 				\
 	core/keybindings.c			\
 	core/keybindings-private.h		\
 	core/main.c				\
-	include/main.h				\
 	core/mutter-Xatomtype.h		\
 	core/place.c				\
 	core/place.h				\
@@ -70,6 +86,8 @@ mutter_SOURCES= 				\
 	core/session.h				\
 	core/stack.c				\
 	core/stack.h				\
+	core/stack-tracker.c			\
+	core/stack-tracker.h			\
 	core/util.c				\
 	include/util.h				\
 	core/window-props.c			\
@@ -104,23 +122,8 @@ mutter_SOURCES= 				\
 	ui/themewidget.c			\
 	ui/themewidget.h			\
 	ui/ui.c					\
-	include/all-keybindings.h
-
-if WITH_CLUTTER
-mutter_SOURCES += 					\
-	compositor/mutter/compositor-mutter.c		\
-	compositor/mutter/mutter-shaped-texture.c	\
-	compositor/mutter/mutter-shaped-texture.h	\
-	compositor/mutter/mutter-plugin-manager.c	\
-	compositor/mutter/mutter-plugin-manager.h	\
-	compositor/mutter/tidy/tidy-texture-frame.c	\
-	compositor/mutter/tidy/tidy-texture-frame.h	\
-	compositor/mutter/mutter-module.c		\
-	compositor/mutter/mutter-module.h		\
-	compositor/mutter/mutter-plugin.c		\
-	include/mutter-plugin.h				\
-	include/compositor-mutter.h
-endif
+	include/all-keybindings.h               \
+	$(mutter_built_sources)
 
 # by setting libmutter_private_la_CFLAGS, the files shared with
 # mutter proper will be compiled with different names.
@@ -145,13 +148,14 @@ libmutter_private_la_LIBADD  = @MUTTER_LIBS@
 
 libmutterincludedir = $(includedir)/mutter/mutter-private
 
+# Headers installed for plugins; introspected information will
+# be extracted into Mutter-<version>.gir
 libmutterinclude_base_headers =		\
-	include/alttabhandler.h			\
 	include/boxes.h				\
 	ui/gradient.h				\
+	include/main.h				\
 	include/util.h				\
 	include/common.h			\
-	ui/preview-widget.h			\
 	ui/theme-parser.h			\
 	ui/theme.h				\
 	include/prefs.h				\
@@ -160,14 +164,19 @@ libmutterinclude_base_headers =		\
 	include/compositor.h			\
 	include/compositor-mutter.h		\
 	include/types.h				\
+	include/errors.h			\
 	include/screen.h			\
 	include/display.h			\
 	include/group.h				\
 	include/keybindings.h			\
-	include/mutter-plugin.h
+	include/mutter-plugin.h			\
+	include/mutter-window.h
 
 # Excluded from scanning for introspection but installed
+# preview-widget.h: only part of libmutter-private
+# atomnames.h: macros cause problems for scanning process
 libmutterinclude_extra_headers =		\
+	ui/preview-widget.h			\
 	include/atomnames.h
 
 libmutterinclude_HEADERS =			\
@@ -194,28 +203,31 @@ typelib_DATA = Meta-$(api_version).typelib
 # We need to strip out the attribute that would point back to libmutter-introspect
 # so that libgirepository looks for symbols in the executable instead
 Meta-$(api_version).gir: $(G_IR_SCANNER) mutter $(libmutterinclude_HEADERS) $(mutter_SOURCES)
+	$(AM_V_GEN) pwd=`pwd` ;				\
+        cd $(srcdir) &&					\
 	$(G_IR_SCANNER)					\
 		--namespace=Meta			\
 		--nsversion=$(api_version)		\
 		--include=GObject-2.0			\
 		--include=Gdk-2.0			\
 		--include=Gtk-2.0			\
-		--include=Clutter-0.9			\
-		--pkg=clutter-0.9			\
+		--include=Clutter-1.0			\
+		--pkg=clutter-1.0			\
 		--pkg=gtk+-2.0				\
+		--include=xlib-2.0			\
 		--include=xfixes-4.0			\
-		--program=./mutter			\
-		$(filter %.c,$(mutter_SOURCES))	\
+		--program=$$pwd/mutter			\
+		$(filter %.c,$(mutter_SOURCES))		\
 		$(libmutterinclude_base_headers)	\
 		$(INCLUDES)				\
-		-o $@
+		-o $$pwd/$@
 
 Meta-$(api_version).typelib: $(G_IR_COMPILER) Meta-$(api_version).gir
-	LD_LIBRARY_PATH=$${LD_LIBRARY_PATH:+$$LD_LIBRARY_PATH:}. $(G_IR_COMPILER) Meta-$(api_version).gir -o $@
+	$(AM_V_GEN) LD_LIBRARY_PATH=$${LD_LIBRARY_PATH:+$$LD_LIBRARY_PATH:}. $(G_IR_COMPILER) Meta-$(api_version).gir -o $@
 endif
 
 EFENCE=
-mutter_LDADD=@MUTTER_LIBS@ libmutter-private.la $(EFENCE)
+mutter_LDADD=@MUTTER_LIBS@ $(EFENCE)
 mutter_LDFLAGS=-export-dynamic
 
 mutter_theme_viewer_LDADD= @MUTTER_LIBS@ libmutter-private.la
@@ -226,9 +238,9 @@ testasyncgetprop_SOURCES=core/async-getprop.h core/async-getprop.c core/testasyn
 
 noinst_PROGRAMS=testboxes testgradient testasyncgetprop
 
-testboxes_LDADD= @MUTTER_LIBS@ libmutter-private.la
-testgradient_LDADD= @MUTTER_LIBS@ libmutter-private.la
-testasyncgetprop_LDADD= @MUTTER_LIBS@ libmutter-private.la
+testboxes_LDADD= @MUTTER_LIBS@
+testgradient_LDADD= @MUTTER_LIBS@
+testasyncgetprop_LDADD= @MUTTER_LIBS@
 
 @INTLTOOL_DESKTOP_RULE@
 
@@ -263,7 +275,14 @@ VARIABLES=stock_maximize_data $(srcdir)/stock_maximize.png \
           stock_delete_data $(srcdir)/stock_delete.png
 
 BUILT_SOURCES = inlinepixbufs.h
-CLEANFILES = inlinepixbufs.h mutter.desktop mutter-wm.desktop mutter.schemas
+CLEANFILES =					\
+	inlinepixbufs.h				\
+	mutter.desktop				\
+	mutter-wm.desktop			\
+	mutter.schemas				\
+	$(mutter_built_sources)			\
+	$(typelib_DATA)				\
+	$(gir_DATA)
 
 inlinepixbufs.h: $(IMAGES)
 	$(GDK_PIXBUF_CSOURCE) --raw --build-list $(VARIABLES) >$(srcdir)/inlinepixbufs.h
@@ -274,10 +293,55 @@ pkgconfig_DATA = libmutter-private.pc mutter-plugins.pc
 
 EXTRA_DIST=$(desktopfiles_files) 	\
 	$(wmproperties_files)		\
-	$(IMAGES) $(schema_DATA) 	\
+	$(IMAGES) 			\
 	$(desktopfiles_in_files)	\
 	$(wmproperties_in_files)	\
 	$(schema_in_files)		\
 	libmutter-private.pc.in	\
-	mutter-plugins.pc.in
+	mutter-plugins.pc.in  \
+	mutter-enum-types.h.in \
+	mutter-enum-types.c.in \
+	mutter-marshal.list
 
+BUILT_SOURCES += $(mutter_built_sources)
+MUTTER_STAMP_FILES = stamp-mutter-marshal.h stamp-mutter-enum-types.h
+CLEANFILES += $(MUTTER_STAMP_FILES)
+
+mutter-marshal.h: stamp-mutter-marshal.h
+	@true
+stamp-mutter-marshal.h: Makefile mutter-marshal.list
+	$(AM_V_GEN) $(GLIB_GENMARSHAL) \
+		--prefix=_mutter_marshal \
+		--header \
+	$(srcdir)/mutter-marshal.list > xgen-tmh && \
+	(cmp -s xgen-tmh mutter-marshal.h || cp -f xgen-tmh mutter-marshal.h) && \
+	rm -f xgen-tmh && \
+	echo timestamp > $(@F)
+
+mutter-marshal.c: Makefile mutter-marshal.list
+	 $(AM_V_GEN) (echo "#include \"mutter-marshal.h\"" ; \
+	 $(GLIB_GENMARSHAL) \
+		--prefix=_mutter_marshal \
+		--body \
+	 $(srcdir)/mutter-marshal.list ) > xgen-tmc && \
+	cp -f xgen-tmc mutter-marshal.c && \
+	rm -f xgen-tmc
+
+mutter-enum-types.h: stamp-mutter-enum-types.h Makefile
+	@true
+stamp-mutter-enum-types.h: $(libmutterinclude_base_headers) mutter-enum-types.h.in
+	$(AM_V_GEN) ( cd $(srcdir) && \
+	  $(GLIB_MKENUMS) \
+	    --template $(srcdir)/mutter-enum-types.h.in \
+	  $(libmutterinclude_base_headers) ) >> xgen-teth && \
+	(cmp -s xgen-teth mutter-enum-types.h || cp xgen-teth mutter-enum-types.h) && \
+	rm -f xgen-teth && \
+	echo timestamp > $(@F)
+
+mutter-enum-types.c: stamp-mutter-enum-types.h mutter-enum-types.c.in
+	  $(AM_V_GEN) ( cd $(srcdir) && \
+	  $(GLIB_MKENUMS) \
+	    --template $(srcdir)/mutter-enum-types.c.in \
+	  $(libmutterinclude_base_headers) ) >> xgen-tetc && \
+	cp xgen-tetc mutter-enum-types.c && \
+	rm -f xgen-tetc

src/compositor/compositor-private.h

@@ -1,90 +1,68 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 
-/*
- * Copyright (C) 2008 Iain Holmes
- *
- * 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_COMPOSITOR_PRIVATE_H
 #define META_COMPOSITOR_PRIVATE_H
 
+#include <X11/extensions/Xfixes.h>
+
 #include "compositor.h"
+#include "display.h"
+#include "mutter-plugin-manager.h"
+#include <clutter/clutter.h>
+
+typedef struct _MetaCompScreen MetaCompScreen;
 
 struct _MetaCompositor
 {
-  void (* destroy) (MetaCompositor *compositor);
+  MetaDisplay    *display;
 
-  void (*manage_screen) (MetaCompositor *compositor,
-                         MetaScreen     *screen);
-  void (*unmanage_screen) (MetaCompositor *compositor,
-                           MetaScreen     *screen);
-  void (*add_window) (MetaCompositor    *compositor,
-                      MetaWindow        *window);
-  void (*remove_window) (MetaCompositor *compositor,
-                         MetaWindow     *window);
-  void (*set_updates) (MetaCompositor *compositor,
-                       MetaWindow     *window,
-                       gboolean        update);
-  gboolean (*process_event) (MetaCompositor *compositor,
-                             XEvent         *event,
-                             MetaWindow     *window);
-  Pixmap (*get_window_pixmap) (MetaCompositor *compositor,
-                               MetaWindow     *window);
-  void (*set_active_window) (MetaCompositor *compositor,
-                             MetaScreen     *screen,
-                             MetaWindow     *window);
-  void (*map_window) (MetaCompositor *compositor,
-                      MetaWindow     *window);
-  void (*unmap_window) (MetaCompositor *compositor,
-			MetaWindow     *window);
-  void (*minimize_window) (MetaCompositor *compositor,
-                           MetaWindow     *window,
-			   MetaRectangle  *window_rect,
-			   MetaRectangle  *icon_rect);
-  void (*unminimize_window) (MetaCompositor *compositor,
-			     MetaWindow     *window,
-			     MetaRectangle  *window_rect,
-			     MetaRectangle  *icon_rect);
-  void (*maximize_window) (MetaCompositor    *compositor,
-                           MetaWindow        *window,
-			   MetaRectangle     *window_rect);
-  void (*unmaximize_window) (MetaCompositor    *compositor,
-                             MetaWindow        *window,
-			     MetaRectangle     *window_rect);
-  void (*update_workspace_geometry) (MetaCompositor *compositor,
-                                     MetaWorkspace   *workspace);
-  void (*switch_workspace) (MetaCompositor     *compositor,
-                            MetaScreen         *screen,
-                            MetaWorkspace      *from,
-                            MetaWorkspace      *to,
-                            MetaMotionDirection direction);
-  void (*sync_stack) (MetaCompositor *compositor,
-		      MetaScreen     *screen,
-		      GList	     *stack);
-  void (*set_window_hidden) (MetaCompositor *compositor,
-			     MetaScreen	    *screen,
-			     MetaWindow	    *window,
-			     gboolean	     hidden);
-  void (*sync_window_geometry) (MetaCompositor	*compositor,
-				MetaWindow	*window);
-  void (*sync_screen_size) (MetaCompositor *compositor,
-			    MetaScreen	   *screen,
-			    guint	    width,
-			    guint	    height);
+  Atom            atom_x_root_pixmap;
+  Atom            atom_x_set_root;
+  Atom            atom_net_wm_window_opacity;
+  guint           repaint_func_id;
+
+  ClutterActor   *shadow_src;
+
+  MutterPlugin   *modal_plugin;
+
+  gboolean        show_redraw : 1;
+  gboolean        debug       : 1;
+  gboolean        no_mipmaps  : 1;
 };
 
-#endif
+struct _MetaCompScreen
+{
+  MetaScreen            *screen;
+
+  ClutterActor          *stage, *window_group, *overlay_group;
+  ClutterActor		*hidden_group;
+  GList                 *windows;
+  GHashTable            *windows_by_xid;
+  Window                 output;
+
+  /* Before we create the output window */
+  XserverRegion     pending_input_region;
+
+  gint                   switch_workspace_in_progress;
+
+  MutterPluginManager *plugin_mgr;
+};
+
+void mutter_switch_workspace_completed (MetaScreen    *screen);
+void mutter_set_stage_input_region     (MetaScreen    *screen,
+                                        XserverRegion  region);
+void mutter_empty_stage_input_region   (MetaScreen    *screen);
+
+gboolean mutter_begin_modal_for_plugin (MetaScreen       *screen,
+                                        MutterPlugin     *plugin,
+                                        Window            grab_window,
+                                        Cursor            cursor,
+                                        MetaModalOptions  options,
+                                        guint32           timestamp);
+void     mutter_end_modal_for_plugin   (MetaScreen       *screen,
+                                        MutterPlugin     *plugin,
+                                        guint32           timestamp);
+
+void mutter_check_end_modal (MetaScreen *screen);
+
+#endif /* META_COMPOSITOR_PRIVATE_H */

src/compositor/compositor-xrender.h

@@ -1,31 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* 
- * Copyright (C) 2007 Iain Holmes
- * Based on xcompmgr - (c) 2003 Keith Packard
- *          xfwm4    - (c) 2005-2007 Olivier Fourdan
- * 
- * 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_COMPOSITOR_XRENDER_H_
-#define META_COMPOSITOR_XRENDER_H_
-
-#include "types.h"
-
-MetaCompositor *meta_compositor_xrender_new (MetaDisplay *display);
-
-#endif

src/compositor/mutter-plugin-manager.c

@@ -22,14 +22,18 @@
  */
 
 #include "config.h"
+#include "compositor-private.h"
 #include "mutter-plugin-manager.h"
 #include "prefs.h"
 #include "errors.h"
 #include "workspace.h"
 #include "mutter-module.h"
+#include "../core/window-private.h"
 
 #include <string.h>
 
+#include <clutter/x11/clutter-x11.h>
+
 /*
  * There is only one instace of each module per the process.
  */
@@ -337,6 +341,10 @@ mutter_plugin_manager_reload (MutterPluginManager *plugin_mgr)
    * plugins to unload? We are probably not going to have large numbers of
    * plugins loaded at the same time, so it might not be worth it.
    */
+
+  /* Prevent stale grabs on unloaded plugins */
+  mutter_check_end_modal (plugin_mgr->screen);
+
   mutter_plugin_manager_unload (plugin_mgr);
   return mutter_plugin_manager_load (plugin_mgr);
 }
@@ -399,6 +407,10 @@ mutter_plugin_manager_event_simple (MutterPluginManager *plugin_mgr,
 {
   GList *l = plugin_mgr->plugins;
   gboolean retval = FALSE;
+  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
+
+  if (display->display_opening)
+    return FALSE;
 
   while (l)
     {
@@ -474,6 +486,10 @@ mutter_plugin_manager_event_maximize (MutterPluginManager *plugin_mgr,
 {
   GList *l = plugin_mgr->plugins;
   gboolean retval = FALSE;
+  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
+
+  if (display->display_opening)
+    return FALSE;
 
   while (l)
     {
@@ -543,6 +559,10 @@ mutter_plugin_manager_switch_workspace (MutterPluginManager *plugin_mgr,
 {
   GList *l = plugin_mgr->plugins;
   gboolean retval = FALSE;
+  MetaDisplay *display  = meta_screen_get_display (plugin_mgr->screen);
+
+  if (display->display_opening)
+    return FALSE;
 
   while (l)
     {
@@ -585,12 +605,31 @@ mutter_plugin_manager_xevent_filter (MutterPluginManager *plugin_mgr,
                                      XEvent              *xev)
 {
   GList *l;
+  gboolean have_plugin_xevent_func;
 
   if (!plugin_mgr)
     return FALSE;
 
   l = plugin_mgr->plugins;
 
+  /* We need to make sure that clutter gets certain events, like
+   * ConfigureNotify on the stage window. If there is a plugin that
+   * provides an xevent_filter function, then it's the responsibility
+   * of that plugin to pass events to Clutter. Otherwise, we send the
+   * event directly to Clutter ourselves.
+   *
+   * What happens if there are two plugins with xevent_filter functions
+   * is undefined; in general, multiple competing plugins are something
+   * we don't support well or care much about.
+   *
+   * FIXME: Really, we should just always handle sending the event to
+   *  clutter if a plugin doesn't report the event as handled by
+   *  returning TRUE, but it doesn't seem worth breaking compatibility
+   *  of the plugin interface right now to achieve this; the way it is
+   *  now works fine in practice.
+   */
+  have_plugin_xevent_func = FALSE;
+
   while (l)
     {
       MutterPlugin      *plugin = l->data;
@@ -598,6 +637,7 @@ mutter_plugin_manager_xevent_filter (MutterPluginManager *plugin_mgr,
 
       if (klass->xevent_filter)
         {
+          have_plugin_xevent_func = TRUE;
           if (klass->xevent_filter (plugin, xev) == TRUE)
             return TRUE;
         }
@@ -605,5 +645,8 @@ mutter_plugin_manager_xevent_filter (MutterPluginManager *plugin_mgr,
       l = l->next;
     }
 
+  if (!have_plugin_xevent_func)
+    return clutter_x11_handle_event (xev) != CLUTTER_X11_FILTER_CONTINUE;
+
   return FALSE;
 }

src/compositor/mutter-plugin.c

@@ -31,6 +31,9 @@
 #include <X11/extensions/shape.h>
 #include <clutter/x11/clutter-x11.h>
 
+#include "compositor-private.h"
+#include "mutter-window-private.h"
+
 G_DEFINE_ABSTRACT_TYPE (MutterPlugin, mutter_plugin, G_TYPE_OBJECT);
 
 #define MUTTER_PLUGIN_GET_PRIVATE(obj) \
@@ -389,7 +392,17 @@ mutter_plugin_effect_completed (MutterPlugin *plugin,
                  name ? name : "unknown");
     }
 
-  mutter_window_effect_completed (actor, event);
+  if (event == MUTTER_PLUGIN_SWITCH_WORKSPACE)
+    {
+      /* The window is just used to identify the screen */
+      MetaWindow *window = mutter_window_get_meta_window (actor);
+      MetaScreen *screen = meta_window_get_screen (window);
+      mutter_switch_workspace_completed (screen);
+    }
+    else
+    {
+      mutter_window_effect_completed (actor, event);
+    }
 }
 
 void
@@ -446,6 +459,18 @@ mutter_plugin_set_stage_input_region (MutterPlugin *plugin,
   mutter_set_stage_input_region (screen, region);
 }
 
+/**
+ * mutter_plugin_get_windows:
+ * @plugin: A #MutterPlugin
+ *
+ * This function returns all of the #MutterWindow objects referenced by Mutter, including
+ * override-redirect windows.  The returned list is a snapshot of Mutter's current
+ * stacking order, with the topmost window last.
+ *
+ * The 'restacked' signal of #MetaScreen signals when this value has changed.
+ *
+ * Returns: (transfer none) (element-type MutterWindow): Windows in stacking order, topmost last
+ */
 GList *
 mutter_plugin_get_windows (MutterPlugin *plugin)
 {
@@ -454,6 +479,64 @@ mutter_plugin_get_windows (MutterPlugin *plugin)
   return mutter_get_windows (priv->screen);
 }
 
+/**
+ * mutter_plugin_begin_modal:
+ * @plugin: a #MutterPlugin
+ * @grab_window: the X window to grab the keyboard and mouse on
+ * @cursor: the cursor to use for the pointer grab, or None,
+ *          to use the normal cursor for the grab window and
+ *          its descendants.
+ * @options: flags that modify the behavior of the modal grab
+ * @timestamp: the timestamp used for establishing grabs
+ *
+ * This function is used to grab the keyboard and mouse for the exclusive
+ * use of the plugin. Correct operation requires that both the keyboard
+ * and mouse are grabbed, or thing will break. (In particular, other
+ * passive X grabs in Mutter can trigger but not be handled by the normal
+ * keybinding handling code.) However, the plugin can establish the keyboard
+ * and/or mouse grabs ahead of time and pass in the
+ * %META_MODAL_POINTER_ALREADY_GRABBED and/or %META_MODAL_KEYBOARD_ALREADY_GRABBED
+ * options. This facility is provided for two reasons: first to allow using
+ * this function to establish modality after a passive grab, and second to
+ * allow using obscure features of XGrabPointer() and XGrabKeyboard() without
+ * having to add them to this API.
+ *
+ * Return value: whether we successfully grabbed the keyboard and
+ *  mouse and made the plugin modal.
+ */
+gboolean
+mutter_plugin_begin_modal (MutterPlugin      *plugin,
+                           Window             grab_window,
+                           Cursor             cursor,
+                           MetaModalOptions   options,
+                           guint32            timestamp)
+{
+  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+
+  return mutter_begin_modal_for_plugin (priv->screen, plugin,
+                                        grab_window, cursor, options, timestamp);
+}
+
+/**
+ * mutter_plugin_end_modal
+ * @plugin: a #MutterPlugin
+ * @timestamp: the time used for releasing grabs
+ *
+ * Ends the modal operation begun with meta_plugin_begin_modal(). This
+ * ungrabs both the mouse and keyboard even when
+ * %META_MODAL_POINTER_ALREADY_GRABBED or
+ * %META_MODAL_KEYBOARD_ALREADY_GRABBED were provided as options
+ * when beginnning the modal operation.
+ */
+void
+mutter_plugin_end_modal (MutterPlugin *plugin,
+                         guint32       timestamp)
+{
+  MutterPluginPrivate *priv = MUTTER_PLUGIN (plugin)->priv;
+
+  mutter_end_modal_for_plugin (priv->screen, plugin, timestamp);
+}
+
 Display *
 mutter_plugin_get_xdisplay (MutterPlugin *plugin)
 {

src/compositor/mutter-shaped-texture.c

@@ -26,19 +26,27 @@
 #include <config.h>
 
 #include "mutter-shaped-texture.h"
+#include "mutter-texture-tower.h"
 
 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
 #include <string.h>
 
-
 static void mutter_shaped_texture_dispose (GObject *object);
 static void mutter_shaped_texture_finalize (GObject *object);
+static void mutter_shaped_texture_notify (GObject *object,
+					  GParamSpec *pspec);
 
 static void mutter_shaped_texture_paint (ClutterActor *actor);
 static void mutter_shaped_texture_pick (ClutterActor *actor,
 					const ClutterColor *color);
 
+static void mutter_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
+                                               int                      x,
+                                               int                      y,
+                                               int                      width,
+                                               int                      height);
+
 static void mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex);
 
 #ifdef HAVE_GLX_TEXTURE_PIXMAP
@@ -55,12 +63,16 @@ G_DEFINE_TYPE (MutterShapedTexture, mutter_shaped_texture,
 
 struct _MutterShapedTexturePrivate
 {
+  MutterTextureTower *paint_tower;
   CoglHandle mask_texture;
   CoglHandle material;
+  CoglHandle material_unshaped;
 #if 1 /* see workaround comment in mutter_shaped_texture_paint */
   CoglHandle material_workaround;
 #endif
 
+  GdkRegion *clip_region;
+
   guint mask_width, mask_height;
 
   GArray *rectangles;
@@ -71,13 +83,17 @@ mutter_shaped_texture_class_init (MutterShapedTextureClass *klass)
 {
   GObjectClass *gobject_class = (GObjectClass *) klass;
   ClutterActorClass *actor_class = (ClutterActorClass *) klass;
+  ClutterX11TexturePixmapClass *x11_texture_class = (ClutterX11TexturePixmapClass *) klass;
 
   gobject_class->dispose = mutter_shaped_texture_dispose;
   gobject_class->finalize = mutter_shaped_texture_finalize;
+  gobject_class->notify = mutter_shaped_texture_notify;
 
   actor_class->paint = mutter_shaped_texture_paint;
   actor_class->pick = mutter_shaped_texture_pick;
 
+  x11_texture_class->update_area = mutter_shaped_texture_update_area;
+
   g_type_class_add_private (klass, sizeof (MutterShapedTexturePrivate));
 }
 
@@ -90,6 +106,7 @@ mutter_shaped_texture_init (MutterShapedTexture *self)
 
   priv->rectangles = g_array_new (FALSE, FALSE, sizeof (XRectangle));
 
+  priv->paint_tower = mutter_texture_tower_new ();
   priv->mask_texture = COGL_INVALID_HANDLE;
 }
 
@@ -99,6 +116,10 @@ mutter_shaped_texture_dispose (GObject *object)
   MutterShapedTexture *self = (MutterShapedTexture *) object;
   MutterShapedTexturePrivate *priv = self->priv;
 
+  if (priv->paint_tower)
+    mutter_texture_tower_free (priv->paint_tower);
+  priv->paint_tower = NULL;
+
   mutter_shaped_texture_dirty_mask (self);
 
   if (priv->material != COGL_INVALID_HANDLE)
@@ -106,6 +127,11 @@ mutter_shaped_texture_dispose (GObject *object)
       cogl_material_unref (priv->material);
       priv->material = COGL_INVALID_HANDLE;
     }
+  if (priv->material_unshaped != COGL_INVALID_HANDLE)
+    {
+      cogl_material_unref (priv->material_unshaped);
+      priv->material_unshaped = COGL_INVALID_HANDLE;
+    }
 #if 1 /* see comment in mutter_shaped_texture_paint */
   if (priv->material_workaround != COGL_INVALID_HANDLE)
     {
@@ -114,6 +140,8 @@ mutter_shaped_texture_dispose (GObject *object)
     }
 #endif
 
+  mutter_shaped_texture_set_clip_region (self, NULL);
+
   G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->dispose (object);
 }
 
@@ -128,6 +156,28 @@ mutter_shaped_texture_finalize (GObject *object)
   G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->finalize (object);
 }
 
+static void
+mutter_shaped_texture_notify (GObject    *object,
+			      GParamSpec *pspec)
+{
+  if (G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->notify)
+    G_OBJECT_CLASS (mutter_shaped_texture_parent_class)->notify (object, pspec);
+
+  /* It seems like we could just do this out of update_area(), but unfortunately,
+   * clutter_glx_texture_pixmap() doesn't call through the vtable on the
+   * initial update_area, so we need to look for changes to the texture
+   * explicitly.
+   */
+  if (strcmp (pspec->name, "cogl-texture") == 0)
+    {
+      MutterShapedTexture *stex = (MutterShapedTexture *) object;
+      MutterShapedTexturePrivate *priv = stex->priv;
+
+      mutter_texture_tower_set_base_texture (priv->paint_tower,
+					     clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex)));
+    }
+}
+
 static void
 mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex)
 {
@@ -141,7 +191,7 @@ mutter_shaped_texture_dirty_mask (MutterShapedTexture *stex)
       cogl_texture_get_gl_texture (priv->mask_texture,
                                    &mask_gl_tex, &mask_gl_target);
 
-      if (mask_gl_target == CGL_TEXTURE_RECTANGLE_ARB)
+      if (mask_gl_target == GL_TEXTURE_RECTANGLE_ARB)
         glDeleteTextures (1, &mask_gl_tex);
 
       cogl_texture_unref (priv->mask_texture);
@@ -204,23 +254,23 @@ mutter_shaped_texture_ensure_mask (MutterShapedTexture *stex)
 
       cogl_texture_get_gl_texture (paint_tex, NULL, &paint_gl_target);
 
-      if (paint_gl_target == CGL_TEXTURE_RECTANGLE_ARB)
+      if (paint_gl_target == GL_TEXTURE_RECTANGLE_ARB)
         {
           GLuint tex;
 
           glGenTextures (1, &tex);
-          glBindTexture (CGL_TEXTURE_RECTANGLE_ARB, tex);
+          glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
           glPixelStorei (GL_UNPACK_ROW_LENGTH, tex_width);
           glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
           glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
           glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
-          glTexImage2D (CGL_TEXTURE_RECTANGLE_ARB, 0,
+          glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
                         GL_ALPHA, tex_width, tex_height,
                         0, GL_ALPHA, GL_UNSIGNED_BYTE, mask_data);
 
           priv->mask_texture
             = cogl_texture_new_from_foreign (tex,
-                                             CGL_TEXTURE_RECTANGLE_ARB,
+                                             GL_TEXTURE_RECTANGLE_ARB,
                                              tex_width, tex_height,
                                              0, 0,
                                              COGL_PIXEL_FORMAT_A_8);
@@ -253,72 +303,99 @@ mutter_shaped_texture_paint (ClutterActor *actor)
   guint depth;
 #endif
 
+  if (priv->clip_region && gdk_region_empty (priv->clip_region))
+    return;
+
   if (!CLUTTER_ACTOR_IS_REALIZED (CLUTTER_ACTOR (stex)))
     clutter_actor_realize (CLUTTER_ACTOR (stex));
 
-  paint_tex = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex));
-
-  tex_width = cogl_texture_get_width (paint_tex);
-  tex_height = cogl_texture_get_height (paint_tex);
-
-  if (tex_width == 0 || tex_width == 0) /* no contents yet */
-    return;
-
-  /* If there are no rectangles fallback to the regular paint
-     method */
-  if (priv->rectangles->len < 1)
-    {
-      CLUTTER_ACTOR_CLASS (mutter_shaped_texture_parent_class)
-        ->paint (actor);
-      return;
-    }
+  /* If mipmaps are supported, then the texture filter quality will
+   * still be HIGH here. In that case we just want to use the base
+   * texture. If mipmaps are not support then
+   * on_glx_texture_pixmap_pre_paint() will have reset the texture
+   * filter quality to MEDIUM, and we should use the MutterTextureTower
+   * mipmap emulation.
+   *
+   * http://bugzilla.openedhand.com/show_bug.cgi?id=1877 is an RFE
+   * for a better way of handling this.
+   *
+   * While it would be nice to have direct access to the 'can_mipmap'
+   * boolean in ClutterGLXTexturePixmap, since since MutterTextureTower
+   * creates the scaled down images on demand there is no substantial
+   * overhead from doing the work to create and update the tower and
+   * not using it, other than the memory allocated for the MutterTextureTower
+   * structure itself.
+   */
+  if (clutter_texture_get_filter_quality (CLUTTER_TEXTURE (stex)) == CLUTTER_TEXTURE_QUALITY_HIGH)
+    paint_tex = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (stex));
+  else
+    paint_tex = mutter_texture_tower_get_paint_texture (priv->paint_tower);
 
   if (paint_tex == COGL_INVALID_HANDLE)
     return;
 
-  mutter_shaped_texture_ensure_mask (stex);
+  tex_width = cogl_texture_get_width (paint_tex);
+  tex_height = cogl_texture_get_height (paint_tex);
 
-  if (priv->material == COGL_INVALID_HANDLE)
+  if (tex_width == 0 || tex_height == 0) /* no contents yet */
+    return;
+
+  if (priv->rectangles->len < 1)
     {
-      priv->material = cogl_material_new ();
+      /* If there are no rectangles use a single-layer texture */
 
-      cogl_material_set_layer_combine (priv->material, 1,
-				       "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
-				       NULL);
+      if (priv->material_unshaped == COGL_INVALID_HANDLE)
+	priv->material_unshaped = cogl_material_new ();
+
+      material = priv->material_unshaped;
     }
-  material = priv->material;
-
-#if 1
-  /* This was added as a workaround. It seems that with the intel
-   * drivers when multi-texturing using an RGB TFP texture, the
-   * texture is actually setup internally as an RGBA texture, where
-   * the alpha channel is mostly 0.0 so you only see a shimmer of the
-   * window. This workaround forcibly defines the alpha channel as
-   * 1.0. Maybe there is some clutter/cogl state that is interacting
-   * with this that is being overlooked, but for now this seems to
-   * work. */
-  g_object_get (stex, "pixmap-depth", &depth, NULL);
-  if (depth == 24)
+  else
     {
-      if (priv->material_workaround == COGL_INVALID_HANDLE)
-        {
-          material = priv->material_workaround = cogl_material_new ();
+      mutter_shaped_texture_ensure_mask (stex);
 
-	  cogl_material_set_layer_combine (material, 0,
-					   "RGB = MODULATE (TEXTURE, PREVIOUS)"
-					   "A = REPLACE (PREVIOUS)",
-					   NULL);
-	  cogl_material_set_layer_combine (material, 1,
+      if (priv->material == COGL_INVALID_HANDLE)
+	{
+	  priv->material = cogl_material_new ();
+
+	  cogl_material_set_layer_combine (priv->material, 1,
 					   "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
 					   NULL);
-        }
+	}
+      material = priv->material;
 
-      material = priv->material_workaround;
-    }
+#if 1
+      /* This was added as a workaround. It seems that with the intel
+       * drivers when multi-texturing using an RGB TFP texture, the
+       * texture is actually setup internally as an RGBA texture, where
+       * the alpha channel is mostly 0.0 so you only see a shimmer of the
+       * window. This workaround forcibly defines the alpha channel as
+       * 1.0. Maybe there is some clutter/cogl state that is interacting
+       * with this that is being overlooked, but for now this seems to
+       * work. */
+      g_object_get (stex, "pixmap-depth", &depth, NULL);
+      if (depth == 24)
+	{
+	  if (priv->material_workaround == COGL_INVALID_HANDLE)
+	    {
+	      material = priv->material_workaround = cogl_material_new ();
+
+	      cogl_material_set_layer_combine (material, 0,
+					       "RGB = MODULATE (TEXTURE, PREVIOUS)"
+					       "A = REPLACE (PREVIOUS)",
+					       NULL);
+	      cogl_material_set_layer_combine (material, 1,
+					       "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
+					       NULL);
+	    }
+
+	  material = priv->material_workaround;
+	}
 #endif
 
+      cogl_material_set_layer (material, 1, priv->mask_texture);
+    }
+
   cogl_material_set_layer (material, 0, paint_tex);
-  cogl_material_set_layer (material, 1, priv->mask_texture);
 
   {
     CoglColor color;
@@ -330,9 +407,61 @@ mutter_shaped_texture_paint (ClutterActor *actor)
   cogl_set_source (material);
 
   clutter_actor_get_allocation_box (actor, &alloc);
+
+  if (priv->clip_region)
+    {
+      GdkRectangle *rects;
+      int n_rects;
+      int i;
+
+      /* Limit to how many separate rectangles we'll draw; beyond this just
+       * fall back and draw the whole thing */
+#     define MAX_RECTS 16
+
+      /* Would be nice to be able to check the number of rects first */
+      gdk_region_get_rectangles (priv->clip_region, &rects, &n_rects);
+      if (n_rects > MAX_RECTS)
+	{
+	  g_free (rects);
+	  /* Fall through to following code */
+	}
+      else
+	{
+	  float coords[8];
+          float x1, y1, x2, y2;
+
+	  for (i = 0; i < n_rects; i++)
+	    {
+	      GdkRectangle *rect = &rects[i];
+
+	      x1 = rect->x;
+	      y1 = rect->y;
+	      x2 = rect->x + rect->width;
+	      y2 = rect->y + rect->height;
+
+              coords[0] = rect->x / (alloc.x2 - alloc.x1);
+	      coords[1] = rect->y / (alloc.y2 - alloc.y1);
+	      coords[2] = (rect->x + rect->width) / (alloc.x2 - alloc.x1);
+	      coords[3] = (rect->y + rect->height) / (alloc.y2 - alloc.y1);
+
+              coords[4] = coords[0];
+              coords[5] = coords[1];
+              coords[6] = coords[2];
+              coords[7] = coords[3];
+
+              cogl_rectangle_with_multitexture_coords (x1, y1, x2, y2,
+                                                       &coords[0], 8);
+            }
+
+	  g_free (rects);
+
+	  return;
+	}
+    }
+
   cogl_rectangle (0, 0,
-                  alloc.x2 - alloc.x1,
-                  alloc.y2 - alloc.y1);
+		  alloc.x2 - alloc.x1,
+		  alloc.y2 - alloc.y1);
 }
 
 static void
@@ -360,8 +489,8 @@ mutter_shaped_texture_pick (ClutterActor *actor,
       tex_width = cogl_texture_get_width (paint_tex);
       tex_height = cogl_texture_get_height (paint_tex);
 
-      if (tex_width == 0 || tex_width == 0) /* no contents yet */
-	return;
+      if (tex_width == 0 || tex_height == 0) /* no contents yet */
+        return;
 
       mutter_shaped_texture_ensure_mask (stex);
 
@@ -379,6 +508,22 @@ mutter_shaped_texture_pick (ClutterActor *actor,
     }
 }
 
+static void
+mutter_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
+                                   int                      x,
+                                   int                      y,
+                                   int                      width,
+                                   int                      height)
+{
+  MutterShapedTexture *stex = (MutterShapedTexture *) texture;
+  MutterShapedTexturePrivate *priv = stex->priv;
+
+  CLUTTER_X11_TEXTURE_PIXMAP_CLASS (mutter_shaped_texture_parent_class)->update_area (texture,
+                                                                                      x, y, width, height);
+
+  mutter_texture_tower_update_area (priv->paint_tower, x, y, width, height);
+}
+
 ClutterActor *
 mutter_shaped_texture_new (void)
 {
@@ -426,3 +571,37 @@ mutter_shaped_texture_add_rectangles (MutterShapedTexture *stex,
   mutter_shaped_texture_dirty_mask (stex);
   clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }
+
+/**
+ * mutter_shaped_texture_set_clip_region:
+ * @frame: a #TidyTextureframe
+ * @clip_region: (transfer full): the region of the texture that
+ *   is visible and should be painted. OWNERSHIP IS ASSUMED BY
+ *   THE FUNCTION (for efficiency to avoid a copy.)
+ *
+ * Provides a hint to the texture about what areas of the texture
+ * are not completely obscured and thus need to be painted. This
+ * is an optimization and is not supposed to have any effect on
+ * the output.
+ *
+ * Typically a parent container will set the clip region before
+ * painting its children, and then unset it afterwards.
+ */
+void
+mutter_shaped_texture_set_clip_region (MutterShapedTexture *stex,
+				       GdkRegion           *clip_region)
+{
+  MutterShapedTexturePrivate *priv;
+
+  g_return_if_fail (MUTTER_IS_SHAPED_TEXTURE (stex));
+
+  priv = stex->priv;
+
+  if (priv->clip_region)
+    {
+      gdk_region_destroy (priv->clip_region);
+      priv->clip_region = NULL;
+    }
+
+  priv->clip_region = clip_region;
+}

src/compositor/mutter-shaped-texture.h

@@ -31,6 +31,8 @@
 #include <clutter/glx/clutter-glx.h>
 #endif /* HAVE_GLX_TEXTURE_PIXMAP */
 
+#include <gdk/gdkregion.h>
+
 G_BEGIN_DECLS
 
 #define MUTTER_TYPE_SHAPED_TEXTURE			    \
@@ -90,6 +92,10 @@ void mutter_shaped_texture_add_rectangles (MutterShapedTexture *stex,
 					   size_t num_rects,
 					   const XRectangle *rects);
 
+/* Assumes ownership of clip_region */
+void mutter_shaped_texture_set_clip_region (MutterShapedTexture *stex,
+					    GdkRegion           *clip_region);
+
 G_END_DECLS
 
 #endif /* __MUTTER_SHAPED_TEXTURE_H__ */

src/compositor/mutter-texture-tower.c

@@ -0,0 +1,837 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MutterTextureTower
+ *
+ * Mipmap emulation by creation of scaled down images
+ *
+ * Copyright (C) 2009 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.
+ */
+
+#include <math.h>
+#include <string.h>
+
+#include "mutter-texture-tower.h"
+
+#ifndef M_LOG2E
+#define M_LOG2E 1.4426950408889634074
+#endif
+
+#if !CLUTTER_CHECK_VERSION(1,1,3)
+static PFNGLACTIVETEXTUREARBPROC activeTexture;
+static PFNGLGENFRAMEBUFFERSPROC genFramebuffers;
+static PFNGLDELETEFRAMEBUFFERSPROC deleteFramebuffers;
+static PFNGLBINDFRAMEBUFFERPROC bindFramebuffer;
+static PFNGLFRAMEBUFFERTEXTURE2DPROC framebufferTexture2D;
+#endif
+
+
+#define MAX_TEXTURE_LEVELS 12
+
+/* If the texture format in memory doesn't match this, then Mesa
+ * will do the conversion, so things will still work, but it might
+ * be slow depending on how efficient Mesa is. These should be the
+ * native formats unless the display is 16bpp. If conversions
+ * here are a bottleneck, investigate whether we are converting when
+ * storing window data *into* the texture before adding extra code
+ * to handle multiple texture formats.
+ */
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+#define TEXTURE_FORMAT COGL_PIXEL_FORMAT_BGRA_8888_PRE
+#else
+#define TEXTURE_FORMAT COGL_PIXEL_FORMAT_ARGB_8888_PRE
+#endif
+
+typedef struct
+{
+  guint16 x1;
+  guint16 y1;
+  guint16 x2;
+  guint16 y2;
+} Box;
+
+struct _MutterTextureTower
+{
+  int n_levels;
+  CoglHandle textures[MAX_TEXTURE_LEVELS];
+#if CLUTTER_CHECK_VERSION(1,1,3)
+  CoglHandle fbos[MAX_TEXTURE_LEVELS];
+#else
+  GLuint fbos[MAX_TEXTURE_LEVELS];
+#endif
+  Box invalid[MAX_TEXTURE_LEVELS];
+};
+
+/**
+ * mutter_texture_tower_new:
+ *
+ * Creates a new texture tower. The base texture has to be set with
+ * mutter_texture_tower_set_base_texture() before use.
+ *
+ * Return value: the new texture tower. Free with mutter_texture_tower_free()
+ */
+MutterTextureTower *
+mutter_texture_tower_new (void)
+{
+  MutterTextureTower *tower;
+
+  tower = g_slice_new0 (MutterTextureTower);
+
+  return tower;
+}
+
+/**
+ * mutter_texture_tower_free:
+ * @tower: a #MutterTextureTower
+ *
+ * Frees a texture tower created with mutter_texture_tower_new().
+ */
+void
+mutter_texture_tower_free (MutterTextureTower *tower)
+{
+  g_return_if_fail (tower != NULL);
+
+  mutter_texture_tower_set_base_texture (tower, COGL_INVALID_HANDLE);
+
+  g_slice_free (MutterTextureTower, tower);
+}
+
+static gboolean
+texture_is_rectangle (CoglHandle texture)
+{
+  GLuint gl_tex;
+  GLenum gl_target;
+
+  cogl_texture_get_gl_texture (texture, &gl_tex, &gl_target);
+  return gl_target == GL_TEXTURE_RECTANGLE_ARB;
+}
+
+static void
+free_texture (CoglHandle texture)
+{
+  GLuint gl_tex;
+  GLenum gl_target;
+
+  cogl_texture_get_gl_texture (texture, &gl_tex, &gl_target);
+
+  if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
+    glDeleteTextures (1, &gl_tex);
+
+  cogl_texture_unref (texture);
+}
+
+/**
+ * mutter_texture_tower_update_area:
+ * @tower: a MutterTextureTower
+ * @texture: the new texture used as a base for scaled down versions
+ *
+ * Sets the base texture that is the scaled texture that the
+ * scaled textures of the tower are derived from. The texture itself
+ * will be used as level 0 of the tower and will be referenced until
+ * unset or until the tower is freed.
+ */
+void
+mutter_texture_tower_set_base_texture (MutterTextureTower *tower,
+                                       CoglHandle          texture)
+{
+  int i;
+
+  g_return_if_fail (tower != NULL);
+
+  if (texture == tower->textures[0])
+    return;
+
+  if (tower->textures[0] != COGL_INVALID_HANDLE)
+    {
+      for (i = 1; i < tower->n_levels; i++)
+        {
+          if (tower->textures[i] != COGL_INVALID_HANDLE)
+            {
+              free_texture (tower->textures[i]);
+              tower->textures[i] = COGL_INVALID_HANDLE;
+            }
+
+#if CLUTTER_CHECK_VERSION(1,1,3)
+          if (tower->fbos[i] != COGL_INVALID_HANDLE)
+            {
+              cogl_handle_unref (tower->fbos[i]);
+              tower->fbos[i] = COGL_INVALID_HANDLE;
+            }
+#else
+          if (tower->fbos[i] != 0)
+            {
+              (*deleteFramebuffers) (1, &tower->fbos[i]);
+              tower->fbos[i] = 0;
+            }
+#endif
+        }
+
+      cogl_texture_unref (tower->textures[0]);
+    }
+
+  tower->textures[0] = texture;
+
+  if (tower->textures[0] != COGL_INVALID_HANDLE)
+    {
+      int width, height;
+
+      cogl_texture_ref (tower->textures[0]);
+
+      width = cogl_texture_get_width (tower->textures[0]);
+      height = cogl_texture_get_height (tower->textures[0]);
+
+      tower->n_levels = 1 + MAX ((int)(M_LOG2E * log (width)), (int)(M_LOG2E * log (height)));
+      tower->n_levels = MIN(tower->n_levels, MAX_TEXTURE_LEVELS);
+
+      mutter_texture_tower_update_area (tower, 0, 0, width, height);
+    }
+  else
+    {
+      tower->n_levels = 0;
+    }
+}
+
+/**
+ * mutter_texture_tower_update_area:
+ * @tower: a MutterTextureTower
+ * @x: X coordinate of upper left of rectangle that changed
+ * @y: Y coordinate of upper left of rectangle that changed
+ * @width: width of rectangle that changed
+ * @height: height rectangle that changed
+ *
+ * Mark a region of the base texture as having changed; the next
+ * time a scaled down version of the base texture is retrieved,
+ * the appropriate area of the scaled down texture will be updated.
+ */
+void
+mutter_texture_tower_update_area (MutterTextureTower *tower,
+                                  int                 x,
+                                  int                 y,
+                                  int                 width,
+                                  int                 height)
+{
+  int texture_width, texture_height;
+  Box invalid;
+  int i;
+
+  g_return_if_fail (tower != NULL);
+
+  texture_width = cogl_texture_get_width (tower->textures[0]);
+  texture_height = cogl_texture_get_height (tower->textures[0]);
+
+  invalid.x1 = x;
+  invalid.y1 = y;
+  invalid.x2 = x + width;
+  invalid.y2 = y + height;
+
+  for (i = 1; i < tower->n_levels; i++)
+    {
+      texture_width = MAX (1, texture_width / 2);
+      texture_height = MAX (1, texture_height / 2);
+
+      invalid.x1 = invalid.x1 / 2;
+      invalid.y1 = invalid.y1 / 2;
+      invalid.x2 = MIN (texture_width, (invalid.x2 + 1) / 2);
+      invalid.y2 = MIN (texture_height, (invalid.y2 + 1) / 2);
+
+      if (tower->invalid[i].x1 == tower->invalid[i].x2 ||
+          tower->invalid[i].y1 == tower->invalid[i].y2)
+        {
+          tower->invalid[i] = invalid;
+        }
+      else
+        {
+          tower->invalid[i].x1 = MIN (tower->invalid[i].x1, invalid.x1);
+          tower->invalid[i].y1 = MIN (tower->invalid[i].y1, invalid.y1);
+          tower->invalid[i].x2 = MAX (tower->invalid[i].x2, invalid.x2);
+          tower->invalid[i].y2 = MAX (tower->invalid[i].y2, invalid.y2);
+        }
+    }
+}
+
+/* It generally looks worse if we scale up a window texture by even a
+ * small amount than if we scale it down using bilinear filtering, so
+ * we always pick the *larger* adjacent level. */
+#define LOD_BIAS (-0.49)
+
+/* This determines the appropriate level of detail to use when drawing the
+ * texture, in a way that corresponds to what the GL specification does
+ * when mip-mapping. This is probably fancier and slower than what we need,
+ * but we do the computation only once each time we paint a window, and
+ * its easier to just use the equations from the specification than to
+ * come up with something simpler.
+ *
+ * If window is being painted at an angle from the viewer, then we have to
+ * pick a point in the texture; we use the middle of the texture (which is
+ * why the width/height are passed in.) This is not the normal case for
+ * Mutter.
+ */
+static int
+get_paint_level (int width, int height)
+{
+  CoglMatrix projection, modelview, pm;
+  float v[4];
+  double viewport_width, viewport_height;
+  double u0, v0;
+  double xc, yc, wc;
+  double dxdu_, dxdv_, dydu_, dydv_;
+  double det_, det_sq;
+  double rho_sq;
+  double lambda;
+
+  /* See
+   * http://www.opengl.org/registry/doc/glspec32.core.20090803.pdf
+   * Section 3.8.9, p. 1.6.2. Here we have
+   *
+   *  u(x,y) = x_o;
+   *  v(x,y) = y_o;
+   *
+   * Since we are mapping 1:1 from object coordinates into pixel
+   * texture coordinates, the clip coordinates are:
+   *
+   *  (x_c)                               (x_o)        (u)
+   *  (y_c) = (M_projection)(M_modelview) (y_o) = (PM) (v)
+   *  (z_c)                               (z_o)        (0)
+   *  (w_c)                               (w_o)        (1)
+   */
+
+  cogl_get_projection_matrix (&projection);
+  cogl_get_modelview_matrix (&modelview);
+
+  cogl_matrix_multiply (&pm, &projection, &modelview);
+
+  cogl_get_viewport (v);
+  viewport_width = v[2];
+  viewport_height = v[3];
+
+  u0 = width / 2.;
+  v0 = height / 2.;
+
+  xc = pm.xx * u0 + pm.xy * v0 + pm.xw;
+  yc = pm.yx * u0 + pm.yy * v0 + pm.yw;
+  wc = pm.wx * u0 + pm.wy * v0 + pm.ww;
+
+  /* We'll simplify the equations below for a bit of micro-optimization.
+   * The commented out code is the unsimplified version.
+
+  // Partial derivates of window coordinates:
+  //
+  //  x_w = 0.5 * viewport_width * x_c / w_c + viewport_center_x
+  //  y_w = 0.5 * viewport_height * y_c / w_c + viewport_center_y
+  //
+  // with respect to u, v, using
+  // d(a/b)/dx = da/dx * (1/b) - a * db/dx / (b^2)
+
+  dxdu = 0.5 * viewport_width * (pm.xx - pm.wx * (xc/wc)) / wc;
+  dxdv = 0.5 * viewport_width * (pm.xy - pm.wy * (xc/wc)) / wc;
+  dydu = 0.5 * viewport_height * (pm.yx - pm.wx * (yc/wc)) / wc;
+  dydv = 0.5 * viewport_height * (pm.yy - pm.wy * (yc/wc)) / wc;
+
+  // Compute the inverse partials as the matrix inverse
+  det = dxdu * dydv - dxdv * dydu;
+
+  dudx =   dydv / det;
+  dudy = - dxdv / det;
+  dvdx = - dydu / det;
+  dvdy =   dvdu / det;
+
+  // Scale factor; maximum of the distance in texels for a change of 1 pixel
+  // in the X direction or 1 pixel in the Y direction
+  rho = MAX (sqrt (dudx * dudx + dvdx * dvdx), sqrt(dudy * dudy + dvdy * dvdy));
+
+  // Level of detail
+  lambda = log2 (rho) + LOD_BIAS;
+  */
+
+  /* dxdu * wc, etc */
+  dxdu_ = 0.5 * viewport_width * (pm.xx - pm.wx * (xc/wc));
+  dxdv_ = 0.5 * viewport_width * (pm.xy - pm.wy * (xc/wc));
+  dydu_ = 0.5 * viewport_height * (pm.yx - pm.wx * (yc/wc));
+  dydv_ = 0.5 * viewport_height * (pm.yy - pm.wy * (yc/wc));
+
+  /* det * wc^2 */
+  det_ = dxdu_ * dydv_ - dxdv_ * dydu_;
+  det_sq = det_ * det_;
+  if (det_sq == 0.0)
+    return -1;
+
+  /* (rho * det * wc)^2 */
+  rho_sq = MAX (dydv_ * dydv_ + dydu_ * dydu_, dxdv_ * dxdv_ + dxdu_ * dxdu_);
+  lambda = 0.5 * M_LOG2E * log (rho_sq * wc * wc / det_sq) + LOD_BIAS;
+
+#if 0
+  g_print ("%g %g %g\n", 0.5 * viewport_width * pm.xx / pm.ww, 0.5 * viewport_height * pm.yy / pm.ww, lambda);
+#endif
+
+  if (lambda <= 0.)
+    return 0;
+  else
+    return (int)(0.5 + lambda);
+}
+
+static gboolean
+is_power_of_two (int x)
+{
+  return (x & (x - 1)) == 0;
+}
+
+static void
+texture_tower_create_texture (MutterTextureTower *tower,
+                              int                 level,
+                              int                 width,
+                              int                 height)
+{
+  if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
+      texture_is_rectangle (tower->textures[level - 1]))
+    {
+      GLuint tex = 0;
+
+      glGenTextures (1, &tex);
+      glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
+      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
+                    GL_RGBA, width,height,
+#if TEXTURE_FORMAT == COGL_PIXEL_FORMAT_BGRA_8888_PRE
+                    0, GL_BGRA, GL_UNSIGNED_BYTE,
+#else /* assume big endian */
+                    0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
+#endif
+                    NULL);
+
+      tower->textures[level] = cogl_texture_new_from_foreign (tex, GL_TEXTURE_RECTANGLE_ARB,
+                                                              width, height,
+                                                              0, 0,
+                                                              TEXTURE_FORMAT);
+    }
+  else
+    {
+      tower->textures[level] = cogl_texture_new_with_size (width, height,
+                                                           COGL_TEXTURE_NO_AUTO_MIPMAP,
+                                                           TEXTURE_FORMAT);
+    }
+
+  tower->invalid[level].x1 = 0;
+  tower->invalid[level].y1 = 0;
+  tower->invalid[level].x2 = width;
+  tower->invalid[level].y2 = height;
+}
+
+/* The COGL fbo (render-to-texture) support is pretty hard to use in
+ * Clutter 1.0; there's no way to save and restore the old projection
+ * matrix and viewport without ugly workarounds that require explicit
+ * access to the ClutterStage.  In Clutter 1.2, the save/restore is
+ * automatic. For now, until we depend on Clutter 1.2, we use GL
+ * directly for render-to-texture. The main downside (other than
+ * a lot of verbosity) is that we have to save the state, reset anything
+ * that we think COGL might have left in a way we don't want it, then
+ * restore the old state.
+ */
+#if CLUTTER_CHECK_VERSION(1,1,3)
+static gboolean
+texture_tower_revalidate_fbo (MutterTextureTower *tower,
+                              int                 level)
+{
+  CoglHandle source_texture = tower->textures[level - 1];
+  int source_texture_width = cogl_texture_get_width (source_texture);
+  int source_texture_height = cogl_texture_get_height (source_texture);
+  CoglHandle dest_texture = tower->textures[level];
+  int dest_texture_width = cogl_texture_get_width (dest_texture);
+  int dest_texture_height = cogl_texture_get_height (dest_texture);
+  Box *invalid = &tower->invalid[level];
+  CoglMatrix modelview;
+
+  if (tower->fbos[level] == COGL_INVALID_HANDLE)
+    tower->fbos[level] = cogl_offscreen_new_to_texture (dest_texture);
+
+  if (tower->fbos[level] == COGL_INVALID_HANDLE)
+    return FALSE;
+
+  cogl_push_framebuffer (tower->fbos[level]);
+
+  cogl_ortho (0, dest_texture_width, dest_texture_height, 0, -1., 1.);
+
+  cogl_matrix_init_identity (&modelview);
+  cogl_set_modelview_matrix (&modelview);
+
+  cogl_set_source_texture (tower->textures[level - 1]);
+  cogl_rectangle_with_texture_coords (invalid->x1, invalid->y1,
+                                      invalid->x2, invalid->y2,
+                                      (2. * invalid->x1) / source_texture_width,
+                                      (2. * invalid->y1) / source_texture_height,
+                                      (2. * invalid->x2) / source_texture_width,
+                                      (2. * invalid->y2) / source_texture_height);
+
+  cogl_pop_framebuffer ();
+
+  return TRUE;
+}
+#else
+static void
+initialize_gl_functions (void)
+{
+  static gboolean initialized = FALSE;
+
+  if (!initialized)
+    {
+      initialized = TRUE;
+
+      activeTexture = (PFNGLACTIVETEXTUREARBPROC) cogl_get_proc_address ("glActiveTextureARB");
+      genFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) cogl_get_proc_address ("glGenFramebuffersEXT");
+      deleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) cogl_get_proc_address ("glDeleteFramebuffersEXT");
+      bindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) cogl_get_proc_address ("glBindFramebufferEXT");
+      framebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) cogl_get_proc_address ("glFramebufferTexture2D");
+    }
+}
+
+static gboolean
+texture_tower_revalidate_fbo (MutterTextureTower *tower,
+                              int                 level)
+{
+  CoglHandle source_texture = tower->textures[level - 1];
+  int source_texture_width = cogl_texture_get_width (source_texture);
+  int source_texture_height = cogl_texture_get_height (source_texture);
+  CoglHandle dest_texture = tower->textures[level];
+  int dest_texture_width = cogl_texture_get_width (dest_texture);
+  int dest_texture_height = cogl_texture_get_height (dest_texture);
+  ClutterActorBox source_box;
+  Box *dest_box;
+
+  GLuint source_gl_tex;
+  GLenum source_gl_target;
+
+  if (!cogl_features_available (COGL_FEATURE_OFFSCREEN))
+    return FALSE;
+
+  initialize_gl_functions ();
+
+  /* Create the frame-buffer object that renders to the texture, if
+   * it doesn't exist; just bind it for rendering if it does */
+  if (tower->fbos[level] == 0)
+    {
+      GLuint dest_gl_tex;
+      GLenum dest_gl_target;
+
+      cogl_texture_get_gl_texture (dest_texture, &dest_gl_tex, &dest_gl_target);
+
+      (*genFramebuffers) (1, &tower->fbos[level]);
+      (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, tower->fbos[level]);
+      (*framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                               dest_gl_target, dest_gl_tex, 0);
+    }
+  else
+    {
+      (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, tower->fbos[level]);
+    }
+
+  /* Save the old state (other than the transformation matrices) */
+  glPushAttrib (GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT | GL_VIEWPORT_BIT);
+
+  /* And set up the state we need */
+  glDisable (GL_BLEND);
+  glDisable (GL_SCISSOR_TEST);
+  glDisable (GL_STENCIL_TEST);
+
+  glDisable (GL_CLIP_PLANE3);
+  glDisable (GL_CLIP_PLANE2);
+  glDisable (GL_CLIP_PLANE1);
+  glDisable (GL_CLIP_PLANE0);
+
+  cogl_texture_get_gl_texture (source_texture, &source_gl_tex, &source_gl_target);
+
+  (*activeTexture) (GL_TEXTURE0_ARB);
+  if (source_gl_target == GL_TEXTURE_2D)
+    glDisable (GL_TEXTURE_RECTANGLE_ARB);
+  else
+    glDisable (GL_TEXTURE_2D);
+  glEnable (source_gl_target);
+  glBindTexture (source_gl_target, source_gl_tex);
+  glTexParameteri (source_gl_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri (source_gl_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
+  glTexParameteri (source_gl_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+  /* In theory, we should loop over all the texture units supported
+   * by the GL implementation, but here we just assume that no more
+   * than three are used by Mutter and all GL implementations we care
+   * about will support at least 3.
+   */
+  (*activeTexture) (GL_TEXTURE1_ARB);
+  glDisable (GL_TEXTURE_2D);
+  glDisable (GL_TEXTURE_RECTANGLE_ARB);
+  (*activeTexture) (GL_TEXTURE2_ARB);
+  glDisable (GL_TEXTURE_2D);
+  glDisable (GL_TEXTURE_RECTANGLE_ARB);
+
+  glViewport (0, 0, dest_texture_width, dest_texture_height);
+
+  /* Save the transformation matrices and set up new ones that map
+   * coordinates directly onto the destination texture */
+  glMatrixMode (GL_MODELVIEW);
+  glPushMatrix ();
+  glLoadIdentity ();
+
+  glMatrixMode (GL_PROJECTION);
+  glPushMatrix();
+  glLoadIdentity ();
+  glOrtho (0, dest_texture_width, 0, dest_texture_height, -1., 1.);
+
+  /* Draw */
+
+  dest_box = &tower->invalid[level];
+  if (texture_is_rectangle (source_texture))
+    {
+      source_box.x1 = 2 * dest_box->x1;
+      source_box.y1 = 2 * dest_box->y1;
+      source_box.x2 = 2 * dest_box->x2;
+      source_box.y2 = 2 * dest_box->y2;
+    }
+  else
+    {
+      source_box.x1 = (2. * dest_box->x1) / source_texture_width;
+      source_box.y1 = (2. * dest_box->y1) / source_texture_height;
+      source_box.x2 = (2. * dest_box->x2) / source_texture_width;
+      source_box.y2 = (2. * dest_box->y2) / source_texture_height;
+    }
+
+  glColor3f (0., 1., 1.);
+
+  glBegin (GL_QUADS);
+  glTexCoord2f (source_box.x1, source_box.y1);
+  glVertex2f (dest_box->x1, dest_box->y1);
+  glTexCoord2f (source_box.x2, source_box.y1);
+  glVertex2f (dest_box->x2, dest_box->y1);
+  glTexCoord2f (source_box.x2, source_box.y2);
+  glVertex2f (dest_box->x2, dest_box->y2);
+  glTexCoord2f (source_box.x1, source_box.y2);
+  glVertex2f (dest_box->x1, dest_box->y2);
+  glEnd ();
+
+  /* And restore everything back the way we found it */
+
+  glMatrixMode (GL_PROJECTION);
+  glPopMatrix ();
+  glMatrixMode (GL_MODELVIEW);
+  glPopMatrix ();
+
+  glPopAttrib ();
+
+  (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
+
+  return TRUE;
+}
+#endif
+
+static void
+fill_copy (guchar       *buf,
+           const guchar *source,
+           int           width)
+{
+  memcpy (buf, source, width * 4);
+}
+
+static void
+fill_scale_down (guchar       *buf,
+                 const guchar *source,
+                 int           width)
+{
+  while (width > 1)
+    {
+      buf[0] = (source[0] + source[4]) / 2;
+      buf[1] = (source[1] + source[5]) / 2;
+      buf[2] = (source[2] + source[6]) / 2;
+      buf[3] = (source[3] + source[7]) / 2;
+
+      buf += 4;
+      source += 8;
+      width -= 2;
+    }
+
+  if (width > 0)
+    {
+      buf[0] = source[0] / 2;
+      buf[1] = source[1] / 2;
+      buf[2] = source[2] / 2;
+      buf[3] = source[3] / 2;
+    }
+}
+
+static void
+texture_tower_revalidate_client (MutterTextureTower *tower,
+                                 int                 level)
+{
+  CoglHandle source_texture = tower->textures[level - 1];
+  int source_texture_width = cogl_texture_get_width (source_texture);
+  int source_texture_height = cogl_texture_get_height (source_texture);
+  guint source_rowstride;
+  guchar *source_data;
+  CoglHandle dest_texture = tower->textures[level];
+  int dest_texture_width = cogl_texture_get_width (dest_texture);
+  int dest_texture_height = cogl_texture_get_height (dest_texture);
+  int dest_x = tower->invalid[level].x1;
+  int dest_y = tower->invalid[level].y1;
+  int dest_width = tower->invalid[level].x2 - tower->invalid[level].x1;
+  int dest_height = tower->invalid[level].y2 - tower->invalid[level].y1;
+  guchar *dest_data;
+  guchar *source_tmp1 = NULL, *source_tmp2 = NULL;
+  int i, j;
+
+  source_rowstride = source_texture_width * 4;
+
+  source_data = g_malloc (source_texture_height * source_rowstride);
+  cogl_texture_get_data (source_texture, TEXTURE_FORMAT, source_rowstride,
+                         source_data);
+
+  dest_data = g_malloc (dest_height * dest_width * 4);
+
+  if (dest_texture_height < source_texture_height)
+    {
+      source_tmp1 = g_malloc (dest_width * 4);
+      source_tmp2 = g_malloc (dest_width * 4);
+    }
+
+  for (i = 0; i < dest_height; i++)
+    {
+      guchar *dest_row = dest_data + i * dest_width * 4;
+      if (dest_texture_height < source_texture_height)
+        {
+          guchar *source1, *source2;
+          guchar *dest;
+
+          if (dest_texture_width < source_texture_width)
+            {
+              fill_scale_down (source_tmp1,
+                               source_data + ((i + dest_y) * 2) * source_rowstride + dest_x * 2 * 4,
+                               dest_width * 2);
+              fill_scale_down (source_tmp2,
+                               source_data + ((i + dest_y) * 2 + 1) * source_rowstride + dest_x * 2 * 4,
+                               dest_width * 2);
+            }
+          else
+            {
+              fill_copy (source_tmp1,
+                         source_data + ((i + dest_y) * 2) * source_rowstride + dest_x * 4,
+                         dest_width);
+              fill_copy (source_tmp2,
+                         source_data + ((i + dest_y) * 2 + 1) * source_rowstride + dest_x * 4,
+                         dest_width);
+            }
+
+          source1 = source_tmp1;
+          source2 = source_tmp2;
+
+          dest = dest_row;
+          for (j = 0; j < dest_width * 4; j++)
+            *(dest++) = (*(source1++) + *(source2++)) / 2;
+        }
+      else
+        {
+          if (dest_texture_width < source_texture_width)
+            fill_scale_down (dest_row,
+                             source_data + (i + dest_y) * source_rowstride + dest_x * 2 * 4,
+                             dest_width * 2);
+          else
+            fill_copy (dest_row,
+                       source_data + (i + dest_y) * source_rowstride,
+                       dest_width);
+        }
+    }
+
+  cogl_texture_set_region (dest_texture,
+                           0, 0,
+                           dest_x, dest_y,
+                           dest_width, dest_height,
+                           dest_width, dest_height,
+                           TEXTURE_FORMAT,
+                           4 * dest_width,
+                           dest_data);
+
+  if (dest_height < source_texture_height)
+    {
+      g_free (source_tmp1);
+      g_free (source_tmp2);
+    }
+
+  g_free (source_data);
+  g_free (dest_data);
+}
+
+static void
+texture_tower_revalidate (MutterTextureTower *tower,
+                          int                 level)
+{
+  if (!texture_tower_revalidate_fbo (tower, level))
+    texture_tower_revalidate_client (tower, level);
+}
+
+/**
+ * mutter_texture_tower_get_paint_texture:
+ * @tower: a MutterTextureTower
+ *
+ * Gets the texture from the tower that best matches the current
+ * rendering scale. (On the assumption here the texture is going to
+ * be rendered with vertex coordinates that correspond to its
+ * size in pixels, so a 200x200 texture will be rendered on the
+ * rectangle (0, 0, 200, 200).
+ *
+ * Return value: the COGL texture handle to use for painting, or
+ *  %COGL_INVALID_HANDLE if no base texture has yet been set.
+ */
+CoglHandle
+mutter_texture_tower_get_paint_texture (MutterTextureTower *tower)
+{
+  int texture_width, texture_height;
+  int level;
+
+  g_return_val_if_fail (tower != NULL, COGL_INVALID_HANDLE);
+
+  if (tower->textures[0] == COGL_INVALID_HANDLE)
+    return COGL_INVALID_HANDLE;
+
+  texture_width = cogl_texture_get_width (tower->textures[0]);
+  texture_height = cogl_texture_get_height (tower->textures[0]);
+
+  level = get_paint_level(texture_width, texture_height);
+  if (level < 0) /* singular paint matrix, scaled to nothing */
+    return COGL_INVALID_HANDLE;
+  level = MIN (level, tower->n_levels - 1);
+
+  if (tower->textures[level] == COGL_INVALID_HANDLE ||
+      (tower->invalid[level].x2 != tower->invalid[level].x1 &&
+       tower->invalid[level].y2 != tower->invalid[level].y1))
+    {
+      int i;
+
+      for (i = 1; i <= level; i++)
+       {
+         /* Use "floor" convention here to be consistent with the NPOT texture extension */
+         texture_width = MAX (1, texture_width / 2);
+         texture_height = MAX (1, texture_height / 2);
+
+         if (tower->textures[i] == COGL_INVALID_HANDLE)
+           texture_tower_create_texture (tower, i, texture_width, texture_height);
+       }
+
+      for (i = 1; i <= level; i++)
+       {
+         if (tower->invalid[level].x2 != tower->invalid[level].x1 &&
+             tower->invalid[level].y2 != tower->invalid[level].y1)
+           texture_tower_revalidate (tower, i);
+       }
+   }
+
+  return tower->textures[level];
+}

src/compositor/mutter-texture-tower.h

@@ -0,0 +1,69 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * MutterTextureTower
+ *
+ * Mipmap emulation by creation of scaled down images
+ *
+ * Copyright (C) 2009 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 __MUTTER_TEXTURE_TOWER_H__
+#define __MUTTER_TEXTURE_TOWER_H__
+
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION:MutterTextureTower
+ * @short_description: mipmap emulation by creation of scaled down images
+ *
+ * A #MutterTextureTower is used to get good looking scaled down images when
+ * we can't use the GL drivers mipmap support. There are two separate reasons
+ *
+ *  - Some cards (including radeon cards <= r5xx) only support
+ *    TEXTURE_RECTANGLE_ARB and not NPOT textures. Rectangular textures
+ *    are defined not to support mipmapping.
+ *  - Even when NPOT textures are available, the combination of NPOT
+ *    textures, texture_from_pixmap, and mipmapping doesn't typically
+ *    work, since the X server doesn't allocate pixmaps in the right
+ *    layout for mipmapping.
+ *
+ * So, what we do is create the "mipmap" levels ourselves by successive
+ * power-of-two scaledowns, and when rendering pick the single texture
+ * that best matches the scale we are rendering at. (Since we aren't
+ * typically using perspective transforms, we'll frequently have a single
+ * scale for the entire texture.)
+ */
+
+typedef struct _MutterTextureTower MutterTextureTower;
+
+MutterTextureTower *mutter_texture_tower_new               (void);
+void                mutter_texture_tower_free              (MutterTextureTower *tower);
+void                mutter_texture_tower_set_base_texture  (MutterTextureTower *tower,
+                                                            CoglHandle          texture);
+void                mutter_texture_tower_update_area       (MutterTextureTower *tower,
+                                                            int                 x,
+                                                            int                 y,
+                                                            int                 width,
+                                                            int                 height);
+CoglHandle          mutter_texture_tower_get_paint_texture (MutterTextureTower *tower);
+
+G_BEGIN_DECLS
+
+#endif /* __MUTTER_TEXTURE_TOWER_H__ */

src/compositor/mutter-window-group.c

@@ -0,0 +1,194 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#define _ISOC99_SOURCE /* for roundf */
+#include <math.h>
+
+#include "mutter-window-private.h"
+#include "mutter-window-group.h"
+
+struct _MutterWindowGroupClass
+{
+  ClutterGroupClass parent_class;
+};
+
+struct _MutterWindowGroup
+{
+  ClutterGroup parent;
+
+  MetaScreen *screen;
+};
+
+G_DEFINE_TYPE (MutterWindowGroup, mutter_window_group, CLUTTER_TYPE_GROUP);
+
+/* We want to find out if the window is "close enough" to
+ * 1:1 transform. We do that by converting the transformed coordinates
+ * to 24.8 fixed-point before checking if they look right.
+ */
+static inline int
+round_to_fixed (float x)
+{
+  return roundf (x * 256);
+}
+
+/* We can only (easily) apply our logic for figuring out what a window
+ * obscures if is not transformed. This function does that check and
+ * as a side effect gets the position of the upper-left corner of the
+ * actors.
+ *
+ * (We actually could handle scaled and non-integrally positioned actors
+ * too as long as they weren't shaped - no filtering is done at the
+ * edges so a rectangle stays a rectangle. But the gain from that is
+ * small, especally since most of our windows are shaped. The simple
+ * case we handle here is the case that matters when the user is just
+ * using the desktop normally.)
+ *
+ * If we assume that the window group is untransformed (it better not
+ * be!) then we could also make this determination by checking directly
+ * if the actor itself is rotated, scaled, or at a non-integral position.
+ * However, the criterion for "close enough" in that case get trickier,
+ * since, for example, the allowed rotation depends on the size of
+ * actor. The approach we take here is to just require everything
+ * to be within 1/256th of a pixel.
+ */
+static gboolean
+actor_is_untransformed (ClutterActor *actor,
+                        int          *x_origin,
+                        int          *y_origin)
+{
+  gfloat widthf, heightf;
+  int width, height;
+  ClutterVertex verts[4];
+  int v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y;
+  int x, y;
+
+  clutter_actor_get_size (actor, &widthf, &heightf);
+  width = round_to_fixed (widthf); height = round_to_fixed (heightf);
+
+  clutter_actor_get_abs_allocation_vertices (actor, verts);
+  v0x = round_to_fixed (verts[0].x); v0y = round_to_fixed (verts[0].y);
+  v1x = round_to_fixed (verts[1].x); v1y = round_to_fixed (verts[1].y);
+  v2x = round_to_fixed (verts[2].x); v2y = round_to_fixed (verts[2].y);
+  v3x = round_to_fixed (verts[3].x); v3y = round_to_fixed (verts[3].y);
+
+  /* Using shifting for converting fixed => int, gets things right for
+   * negative values. / 256. wouldn't do the same
+   */
+  x = v0x >> 8;
+  y = v0y >> 8;
+
+  /* At integral coordinates? */
+  if (x * 256 != v0x || y * 256 != v0y)
+    return FALSE;
+
+  /* Not scaled? */
+  if (v1x - v0x != width || v2y - v0y != height)
+    return FALSE;
+
+  /* Not rotated/skewed? */
+  if (v0x != v2x || v0y != v1y ||
+      v3x != v1x || v3y != v2y)
+    return FALSE;
+
+  *x_origin = x;
+  *y_origin = y;
+
+  return TRUE;
+}
+
+static void
+mutter_window_group_paint (ClutterActor *actor)
+{
+  MutterWindowGroup *window_group = MUTTER_WINDOW_GROUP (actor);
+  GdkRegion *visible_region;
+  GdkRectangle screen_rect = { 0 };
+  GList *children, *l;
+
+  /* We walk the list from top to bottom (opposite of painting order),
+   * and subtract the opaque area of each window out of the visible
+   * region that we pass to the windows below.
+   */
+  children = clutter_container_get_children (CLUTTER_CONTAINER (actor));
+  children = g_list_reverse (children);
+
+  /* Start off with the full screen area (for a multihead setup, we
+   * might want to use a more accurate union of the monitors to avoid
+   * painting in holes from mismatched monitor sizes. That's just an
+   * optimization, however.)
+   */
+  meta_screen_get_size (window_group->screen, &screen_rect.width, &screen_rect.height);
+  visible_region = gdk_region_rectangle (&screen_rect);
+
+  for (l = children; l; l = l->next)
+    {
+      MutterWindow *cw;
+      gboolean x, y;
+
+      if (!MUTTER_IS_WINDOW (l->data) || !CLUTTER_ACTOR_IS_VISIBLE (l->data))
+        continue;
+
+      cw = l->data;
+
+      if (!actor_is_untransformed (CLUTTER_ACTOR (cw), &x, &y))
+        continue;
+
+      /* Temporarily move to the coordinate system of the actor */
+      gdk_region_offset (visible_region, - x, - y);
+
+      mutter_window_set_visible_region (cw, visible_region);
+
+      if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (cw)) == 0xff)
+        {
+          GdkRegion *obscured_region = mutter_window_get_obscured_region (cw);
+          if (obscured_region)
+            gdk_region_subtract (visible_region, obscured_region);
+        }
+
+      mutter_window_set_visible_region_beneath (cw, visible_region);
+      gdk_region_offset (visible_region, x, y);
+    }
+
+  gdk_region_destroy (visible_region);
+
+  CLUTTER_ACTOR_CLASS (mutter_window_group_parent_class)->paint (actor);
+
+  /* Now that we are done painting, unset the visible regions (they will
+   * mess up painting clones of our actors)
+   */
+  for (l = children; l; l = l->next)
+    {
+      MutterWindow *cw;
+
+      if (!MUTTER_IS_WINDOW (l->data))
+        continue;
+
+      cw = l->data;
+      mutter_window_reset_visible_regions (cw);
+    }
+
+  g_list_free (children);
+}
+
+static void
+mutter_window_group_class_init (MutterWindowGroupClass *klass)
+{
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+
+  actor_class->paint = mutter_window_group_paint;
+}
+
+static void
+mutter_window_group_init (MutterWindowGroup *window_group)
+{
+}
+
+ClutterActor *
+mutter_window_group_new (MetaScreen *screen)
+{
+  MutterWindowGroup *window_group;
+
+  window_group = g_object_new (MUTTER_TYPE_WINDOW_GROUP, NULL);
+
+  window_group->screen = screen;
+
+  return CLUTTER_ACTOR (window_group);
+}

src/compositor/mutter-window-group.h

@@ -0,0 +1,52 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef MUTTER_WINDOW_GROUP_H
+#define MUTTER_WINDOW_GROUP_H
+
+#include <clutter/clutter.h>
+
+#include "screen.h"
+
+/**
+ * MutterWindowGroup:
+ *
+ * This class is a subclass of ClutterGroup with special handling for
+ * MutterWindow when painting the group. When we are painting a stack
+ * of 5-10 maximized windows, the standard bottom-to-top method of
+ * drawing every actor results in a tremendous amount of overdraw
+ * and can easily max out the available memory bandwidth on a low-end
+ * graphics chipset. It's even worse if window textures are being accessed
+ * over the AGP bus.
+ *
+ * The basic technique applied here is to do a pre-pass before painting
+ * where we walk window from top to bottom and compute the visible area
+ * at each step by subtracting out the windows above it. The visible
+ * area is passed to MutterWindow which uses it to clip the portion of
+ * the window which drawn and avoid redrawing the shadow if it is completely
+ * obscured.
+ *
+ * A caveat is that this is ineffective if applications are using ARGB
+ * visuals, since we have no way of knowing whether a window obscures
+ * the windows behind it or not. Alternate approaches using the depth
+ * or stencil buffer rather than client side regions might be able to
+ * handle alpha windows, but the combination of glAlphaFunc and stenciling
+ * tends not to be efficient except on newer cards. (And on newer cards
+ * we have lots of memory and bandwidth.)
+ */
+
+#define MUTTER_TYPE_WINDOW_GROUP            (mutter_window_group_get_type ())
+#define MUTTER_WINDOW_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroup))
+#define MUTTER_WINDOW_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroupClass))
+#define MUTTER_IS_WINDOW_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_WINDOW_GROUP))
+#define MUTTER_IS_WINDOW_GROU_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), MUTTER_TYPE_WINDOW_GROUP))
+#define MUTTER_WINDOW_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MUTTER_TYPE_WINDOW_GROUP, MutterWindowGroupClass))
+
+typedef struct _MutterWindowGroup        MutterWindowGroup;
+typedef struct _MutterWindowGroupClass   MutterWindowGroupClass;
+typedef struct _MutterWindowGroupPrivate MutterWindowGroupPrivate;
+
+GType mutter_window_group_get_type (void);
+
+ClutterActor *mutter_window_group_new (MetaScreen *screen);
+
+#endif /* MUTTER_WINDOW_GROUP_H */

src/compositor/mutter-window-private.h

@@ -0,0 +1,51 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef MUTTER_WINDOW_PRIVATE_H
+#define MUTTER_WINDOW_PRIVATE_H
+
+#include <X11/extensions/Xdamage.h>
+#include <gdk/gdk.h>
+#include "compositor-mutter.h"
+
+MutterWindow *mutter_window_new (MetaWindow *window);
+
+void mutter_window_destroy   (MutterWindow *cw);
+
+void mutter_window_show (MutterWindow   *cw,
+                         MetaCompEffect  effect);
+void mutter_window_hide (MutterWindow   *cw,
+                         MetaCompEffect  effect);
+
+void mutter_window_maximize   (MutterWindow  *cw,
+                               MetaRectangle *old_rect,
+                               MetaRectangle *new_rect);
+void mutter_window_unmaximize (MutterWindow  *cw,
+                               MetaRectangle *old_rect,
+                               MetaRectangle *new_rect);
+
+void     mutter_window_process_damage          (MutterWindow       *cw,
+                                                XDamageNotifyEvent *event);
+void     mutter_window_pre_paint               (MutterWindow       *self);
+
+gboolean mutter_window_effect_in_progress      (MutterWindow       *cw);
+void     mutter_window_sync_actor_position     (MutterWindow       *cw);
+void     mutter_window_sync_visibility         (MutterWindow       *cw);
+void     mutter_window_update_window_type      (MutterWindow       *cw);
+void     mutter_window_update_shape            (MutterWindow       *cw,
+                                                gboolean            shaped);
+void     mutter_window_update_opacity          (MutterWindow       *cw);
+void     mutter_window_mapped                  (MutterWindow       *cw);
+void     mutter_window_unmapped                (MutterWindow       *cw);
+
+GdkRegion *mutter_window_get_obscured_region   (MutterWindow       *cw);
+
+void mutter_window_set_visible_region          (MutterWindow       *cw,
+                                                GdkRegion          *visible_region);
+void mutter_window_set_visible_region_beneath  (MutterWindow       *cw,
+                                                GdkRegion          *beneath_region);
+void mutter_window_reset_visible_regions       (MutterWindow       *cw);
+
+void mutter_window_effect_completed (MutterWindow *actor,
+                                     gulong        event);
+
+#endif /* MUTTER_WINDOW_PRIVATE_H */

src/compositor/plugins/Makefile.am

@@ -1,8 +1,6 @@
 
 pkglibdir=@MUTTER_PLUGIN_DIR@
 
-if WITH_CLUTTER
-
 INCLUDES=@MUTTER_CFLAGS@ -I $(top_srcdir)/src/include -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
 
 default_la_CFLAGS   = -fPIC
@@ -18,5 +16,3 @@ pkglib_LTLIBRARIES = default.la
 install-exec-hook:
 	-rm $(DESTDIR)$(pkglibdir)/*.a
 	-rm $(DESTDIR)$(pkglibdir)/*.la
-
-endif

src/compositor/shadow.c

@@ -0,0 +1,350 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#define _GNU_SOURCE /* For M_PI */
+
+#include <math.h>
+
+#include "compositor-private.h"
+#include "shadow.h"
+#include "tidy/tidy-texture-frame.h"
+
+#define SHADOW_RADIUS 8
+#define SHADOW_OPACITY	0.9
+#define SHADOW_OFFSET_X	(SHADOW_RADIUS)
+#define SHADOW_OFFSET_Y	(SHADOW_RADIUS)
+
+#define MAX_TILE_SZ 8 	/* Must be <= shaddow radius */
+#define TILE_WIDTH  (3*MAX_TILE_SZ)
+#define TILE_HEIGHT (3*MAX_TILE_SZ)
+
+static unsigned char* shadow_gaussian_make_tile (void);
+
+ClutterActor *
+mutter_create_shadow_frame (MetaCompositor *compositor)
+{
+  ClutterActor *frame;
+
+  if (!compositor->shadow_src)
+    {
+      guchar *data;
+
+      data = shadow_gaussian_make_tile ();
+
+      compositor->shadow_src = clutter_texture_new ();
+
+      clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (compositor->shadow_src),
+                                         data,
+                                         TRUE,
+                                         TILE_WIDTH,
+                                         TILE_HEIGHT,
+                                         TILE_WIDTH*4,
+                                         4,
+                                         0,
+                                         NULL);
+      g_free (data);
+    }
+
+  frame = tidy_texture_frame_new (CLUTTER_TEXTURE (compositor->shadow_src),
+                                  MAX_TILE_SZ,
+                                  MAX_TILE_SZ,
+                                  MAX_TILE_SZ,
+                                  MAX_TILE_SZ);
+
+  clutter_actor_set_position (frame,
+                              SHADOW_OFFSET_X , SHADOW_OFFSET_Y);
+
+  return frame;
+}
+
+typedef struct GaussianMap
+{
+  int	   size;
+  double * data;
+} GaussianMap;
+
+static double
+gaussian (double r, double x, double y)
+{
+  return ((1 / (sqrt (2 * M_PI * r))) *
+	  exp ((- (x * x + y * y)) / (2 * r * r)));
+}
+
+
+static GaussianMap *
+make_gaussian_map (double r)
+{
+  GaussianMap  *c;
+  int	          size = ((int) ceil ((r * 3)) + 1) & ~1;
+  int	          center = size / 2;
+  int	          x, y;
+  double          t = 0.0;
+  double          g;
+
+  c = g_malloc (sizeof (GaussianMap) + size * size * sizeof (double));
+  c->size = size;
+
+  c->data = (double *) (c + 1);
+
+  for (y = 0; y < size; y++)
+    for (x = 0; x < size; x++)
+      {
+	g = gaussian (r, (double) (x - center), (double) (y - center));
+	t += g;
+	c->data[y * size + x] = g;
+      }
+
+  for (y = 0; y < size; y++)
+    for (x = 0; x < size; x++)
+      c->data[y*size + x] /= t;
+
+  return c;
+}
+
+static unsigned char
+sum_gaussian (GaussianMap * map, double opacity,
+              int x, int y, int width, int height)
+{
+  int	           fx, fy;
+  double         * g_data;
+  double         * g_line = map->data;
+  int	           g_size = map->size;
+  int	           center = g_size / 2;
+  int	           fx_start, fx_end;
+  int	           fy_start, fy_end;
+  double           v;
+  unsigned int     r;
+
+  /*
+   * Compute set of filter values which are "in range",
+   * that's the set with:
+   *	0 <= x + (fx-center) && x + (fx-center) < width &&
+   *  0 <= y + (fy-center) && y + (fy-center) < height
+   *
+   *  0 <= x + (fx - center)	x + fx - center < width
+   *  center - x <= fx	fx < width + center - x
+   */
+
+  fx_start = center - x;
+  if (fx_start < 0)
+    fx_start = 0;
+  fx_end = width + center - x;
+  if (fx_end > g_size)
+    fx_end = g_size;
+
+  fy_start = center - y;
+  if (fy_start < 0)
+    fy_start = 0;
+  fy_end = height + center - y;
+  if (fy_end > g_size)
+    fy_end = g_size;
+
+  g_line = g_line + fy_start * g_size + fx_start;
+
+  v = 0;
+  for (fy = fy_start; fy < fy_end; fy++)
+    {
+      g_data = g_line;
+      g_line += g_size;
+
+      for (fx = fx_start; fx < fx_end; fx++)
+	v += *g_data++;
+    }
+  if (v > 1)
+    v = 1;
+
+  v *= (opacity * 255.0);
+
+  r = (unsigned int) v;
+
+  return (unsigned char) r;
+}
+
+static unsigned char *
+shadow_gaussian_make_tile ()
+{
+  unsigned char              * data;
+  int		               size;
+  int		               center;
+  int		               x, y;
+  unsigned char                d;
+  int                          pwidth, pheight;
+  double                       opacity = SHADOW_OPACITY;
+  static GaussianMap       * gaussian_map = NULL;
+
+  struct _mypixel
+  {
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+    unsigned char a;
+  } * _d;
+
+
+  if (!gaussian_map)
+    gaussian_map =
+      make_gaussian_map (SHADOW_RADIUS);
+
+  size   = gaussian_map->size;
+  center = size / 2;
+
+  /* Top & bottom */
+
+  pwidth  = MAX_TILE_SZ;
+  pheight = MAX_TILE_SZ;
+
+  data = g_malloc0 (4 * TILE_WIDTH * TILE_HEIGHT);
+
+  _d = (struct _mypixel*) data;
+
+  /* N */
+  for (y = 0; y < pheight; y++)
+    {
+      d = sum_gaussian (gaussian_map, opacity,
+                        center, y - center,
+                        TILE_WIDTH, TILE_HEIGHT);
+      for (x = 0; x < pwidth; x++)
+	{
+	  _d[y*3*pwidth + x + pwidth].r = 0;
+	  _d[y*3*pwidth + x + pwidth].g = 0;
+	  _d[y*3*pwidth + x + pwidth].b = 0;
+	  _d[y*3*pwidth + x + pwidth].a = d;
+	}
+
+    }
+
+  /* S */
+  pwidth = MAX_TILE_SZ;
+  pheight = MAX_TILE_SZ;
+
+  for (y = 0; y < pheight; y++)
+    {
+      d = sum_gaussian (gaussian_map, opacity,
+                        center, y - center,
+                        TILE_WIDTH, TILE_HEIGHT);
+      for (x = 0; x < pwidth; x++)
+	{
+	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].r = 0;
+	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].g = 0;
+	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].b = 0;
+	  _d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x + pwidth].a = d;
+	}
+
+    }
+
+
+  /* w */
+  pwidth = MAX_TILE_SZ;
+  pheight = MAX_TILE_SZ;
+
+  for (x = 0; x < pwidth; x++)
+    {
+      d = sum_gaussian (gaussian_map, opacity,
+                        x - center, center,
+                        TILE_WIDTH, TILE_HEIGHT);
+      for (y = 0; y < pheight; y++)
+	{
+	  _d[y*3*pwidth + 3*pwidth*pheight + x].r = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + x].g = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + x].b = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + x].a = d;
+	}
+
+    }
+
+  /* E */
+  for (x = 0; x < pwidth; x++)
+    {
+      d = sum_gaussian (gaussian_map, opacity,
+					       x - center, center,
+					       TILE_WIDTH, TILE_HEIGHT);
+      for (y = 0; y < pheight; y++)
+	{
+	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].r = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].g = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].b = 0;
+	  _d[y*3*pwidth + 3*pwidth*pheight + (pwidth-x-1) + 2*pwidth].a = d;
+	}
+
+    }
+
+  /* NW */
+  pwidth = MAX_TILE_SZ;
+  pheight = MAX_TILE_SZ;
+
+  for (x = 0; x < pwidth; x++)
+    for (y = 0; y < pheight; y++)
+      {
+	d = sum_gaussian (gaussian_map, opacity,
+                          x-center, y-center,
+                          TILE_WIDTH, TILE_HEIGHT);
+
+	_d[y*3*pwidth + x].r = 0;
+	_d[y*3*pwidth + x].g = 0;
+	_d[y*3*pwidth + x].b = 0;
+	_d[y*3*pwidth + x].a = d;
+      }
+
+  /* SW */
+  for (x = 0; x < pwidth; x++)
+    for (y = 0; y < pheight; y++)
+      {
+	d = sum_gaussian (gaussian_map, opacity,
+                          x-center, y-center,
+                          TILE_WIDTH, TILE_HEIGHT);
+
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].r = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].g = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].b = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + x].a = d;
+      }
+
+  /* SE */
+  for (x = 0; x < pwidth; x++)
+    for (y = 0; y < pheight; y++)
+      {
+	d = sum_gaussian (gaussian_map, opacity,
+                          x-center, y-center,
+                          TILE_WIDTH, TILE_HEIGHT);
+
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
+	   2*pwidth].r = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
+	   2*pwidth].g = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
+	   2*pwidth].b = 0;
+	_d[(pheight-y-1)*3*pwidth + 6*pwidth*pheight + (pwidth-x-1) +
+	   2*pwidth].a = d;
+      }
+
+  /* NE */
+  for (x = 0; x < pwidth; x++)
+    for (y = 0; y < pheight; y++)
+      {
+	d = sum_gaussian (gaussian_map, opacity,
+                          x-center, y-center,
+                          TILE_WIDTH, TILE_HEIGHT);
+
+	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].r = 0;
+	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].g = 0;
+	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].b = 0;
+	_d[y*3*pwidth + (pwidth - x - 1) + 2*pwidth].a = d;
+      }
+
+  /* center */
+  pwidth = MAX_TILE_SZ;
+  pheight = MAX_TILE_SZ;
+
+  d = sum_gaussian (gaussian_map, opacity,
+                    center, center, TILE_WIDTH, TILE_HEIGHT);
+
+  for (x = 0; x < pwidth; x++)
+    for (y = 0; y < pheight; y++)
+      {
+	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].r = 0;
+	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].g = 0;
+	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].b = 0;
+	_d[y*3*pwidth + 3*pwidth*pheight + x + pwidth].a = 0;
+      }
+
+  return data;
+}

src/compositor/shadow.h

@@ -0,0 +1,9 @@
+#ifndef SHADOW_H
+#define SHADOW_H
+
+#include <clutter/clutter.h>
+#include "compositor.h"
+
+ClutterActor *mutter_create_shadow_frame (MetaCompositor *compositor);
+
+#endif /* SHADOW_H */

src/compositor/tidy/tidy-texture-frame.c

@@ -64,6 +64,8 @@ struct _TidyTextureFramePrivate
   gfloat bottom;
 
   CoglHandle material;
+
+  guint needs_paint : 1;
 };
 
 static void
@@ -175,6 +177,9 @@ tidy_texture_frame_paint (ClutterActor *self)
   if (G_UNLIKELY (priv->parent_texture == NULL))
     return;
 
+  if (!priv->needs_paint)
+    return;
+
   /* parent texture may have been hidden, so need to make sure it gets
    * realized
    */
@@ -608,3 +613,29 @@ tidy_texture_frame_get_frame (TidyTextureFrame *frame,
   if (left)
     *left = priv->left;
 }
+
+/**
+ * tidy_texture_frame_set_needs_paint:
+ * @frame: a #TidyTextureframe
+ * @needs_paint: if %FALSE, the paint will be skipped
+ *
+ * Provides a hint to the texture frame that it is totally obscured
+ * and doesn't need to be painted. This would typically be called
+ * by a parent container if it detects the condition prior to
+ * painting its children and then unset afterwards.
+ *
+ * Since it is not supposed to have any effect on display, it does
+ * not queue a repaint.
+ */
+void
+tidy_texture_frame_set_needs_paint (TidyTextureFrame *frame,
+				    gboolean          needs_paint)
+{
+  TidyTextureFramePrivate *priv;
+
+  g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
+
+  priv = frame->priv;
+
+  priv->needs_paint = needs_paint;
+}

src/compositor/tidy/tidy-texture-frame.h

@@ -76,6 +76,9 @@ void            tidy_texture_frame_get_frame          (TidyTextureFrame *frame,
                                                        gfloat           *bottom,
                                                        gfloat           *left);
 
+void            tidy_texture_frame_set_needs_paint    (TidyTextureFrame *frame,
+                                                       gboolean          needs_paint);
+
 G_END_DECLS
 
 #endif /* _HAVE_TIDY_TEXTURE_FRAME_H */

src/core/alttabhandler.c

@@ -1,138 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity Alt-Tab abstraction */
-
-/*
- * Copyright (C) 2009 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.
- */
-
-#include <config.h>
-#include "alttabhandlerdefault.h"
-#include "screen-private.h"
-
-static GType handler_type = G_TYPE_INVALID;
-
-GType meta_alt_tab_handler_default_get_type (void);
-
-void
-meta_alt_tab_handler_register (GType type)
-{
-  handler_type = type;
-}
-
-MetaAltTabHandler *
-meta_alt_tab_handler_new (MetaScreen *screen,
-                          gboolean    immediate)
-{
-  if (handler_type == G_TYPE_INVALID)
-    handler_type = meta_alt_tab_handler_default_get_type ();
-
-  return g_object_new (handler_type,
-                       "screen", screen,
-                       "immediate", immediate,
-                       NULL);
-}
-
-static void meta_alt_tab_handler_class_init (GObjectClass *object_class);
-
-GType
-meta_alt_tab_handler_get_type (void)
-{
-  static volatile gsize g_define_type_id__volatile = 0;
-
-  if (g_once_init_enter (&g_define_type_id__volatile))
-    {
-      const GTypeInfo type_info =
-      {
-        sizeof (MetaAltTabHandlerInterface), /* class_size */
-	NULL,           /* base_init */
-	NULL,		/* base_finalize */
-	(GClassInitFunc)meta_alt_tab_handler_class_init,
-	NULL,		/* class_finalize */
-	NULL,		/* class_data */
-	0,
-	0,              /* n_preallocs */
-	NULL
-      };
-      GType g_define_type_id =
-	g_type_register_static (G_TYPE_INTERFACE, "MetaAltTabHandler",
-				&type_info, 0);
-
-      g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_OBJECT);
-
-      g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
-    }
-
-  return g_define_type_id__volatile;
-}
-
-static void
-meta_alt_tab_handler_class_init (GObjectClass *object_class)
-{
-  g_object_interface_install_property (object_class,
-                                       g_param_spec_object ("screen",
-                                                            "Screen",
-                                                            "MetaScreen this is the switcher for",
-                                                            META_TYPE_SCREEN,
-                                                            G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
-  g_object_interface_install_property (object_class,
-                                       g_param_spec_boolean ("immediate",
-                                                             "Immediate mode",
-                                                             "Whether or not to select windows immediately",
-                                                             FALSE,
-                                                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
-}
-
-void
-meta_alt_tab_handler_add_window (MetaAltTabHandler *handler,
-				 MetaWindow        *window)
-{
-  META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->add_window (handler, window);
-}
-
-void
-meta_alt_tab_handler_show (MetaAltTabHandler *handler,
-                           MetaWindow        *initial_selection)
-{
-  META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->show (handler,
-                                                      initial_selection);
-}
-
-void
-meta_alt_tab_handler_destroy (MetaAltTabHandler *handler)
-{
-  META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->destroy (handler);
-}
-
-void
-meta_alt_tab_handler_forward (MetaAltTabHandler *handler)
-{
-  META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->forward (handler);
-}
-
-void
-meta_alt_tab_handler_backward (MetaAltTabHandler *handler)
-{
-  META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->backward (handler);
-}
-
-MetaWindow *
-meta_alt_tab_handler_get_selected (MetaAltTabHandler *handler)
-{
-  return META_ALT_TAB_HANDLER_GET_INTERFACE (handler)->get_selected (handler);
-}

src/core/alttabhandlerdefault.c

@@ -1,223 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity Alt-Tab abstraction: default implementation */
-
-/*
- * Copyright (C) 2009 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.
- */
-
-#include <config.h>
-#include "alttabhandlerdefault.h"
-#include "frame-private.h"
-#include "window-private.h"
-
-static void meta_alt_tab_handler_default_interface_init (MetaAltTabHandlerInterface *handler_iface);
-
-G_DEFINE_TYPE_WITH_CODE (MetaAltTabHandlerDefault, meta_alt_tab_handler_default, G_TYPE_OBJECT,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_ALT_TAB_HANDLER,
-                                                meta_alt_tab_handler_default_interface_init))
-
-enum {
-  PROP_SCREEN = 1,
-  PROP_IMMEDIATE
-};
-
-static void
-meta_alt_tab_handler_default_init (MetaAltTabHandlerDefault *hd)
-{
-  hd->entries = g_array_new (FALSE, FALSE, sizeof (MetaTabEntry));
-}
-
-static void
-meta_alt_tab_handler_default_set_property (GObject      *object,
-                                           guint         prop_id,
-                                           const GValue *value,
-                                           GParamSpec   *pspec)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (object);
-
-  switch (prop_id)
-    {
-    case PROP_SCREEN:
-      hd->screen = g_value_get_object (value);
-      break;
-    case PROP_IMMEDIATE:
-      hd->immediate_mode = g_value_get_boolean (value);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-meta_alt_tab_handler_default_finalize (GObject *object)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (object);
-
-  g_array_free (hd->entries, TRUE);
-
-  if (hd->tab_popup)
-    meta_ui_tab_popup_free (hd->tab_popup);
-
-  G_OBJECT_CLASS (meta_alt_tab_handler_default_parent_class)->finalize (object);
-}
-
-static void
-meta_alt_tab_handler_default_add_window (MetaAltTabHandler *handler,
-                                         MetaWindow        *window)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-  MetaTabEntry entry;
-  MetaRectangle r;
-
-  entry.key = (MetaTabEntryKey) window;
-  entry.title = window->title;
-  entry.icon = window->icon;
-  entry.blank = FALSE;
-  entry.hidden = !meta_window_showing_on_its_workspace (window);
-  entry.demands_attention = window->wm_state_demands_attention;
-
-  if (hd->immediate_mode || !entry.hidden ||
-      !meta_window_get_icon_geometry (window, &r))
-    meta_window_get_outer_rect (window, &r);
-  entry.rect = r;
-
-  /* Find inside of highlight rectangle to be used when window is
-   * outlined for tabbing.  This should be the size of the
-   * east/west frame, and the size of the south frame, on those
-   * sides.  On the top it should be the size of the south frame
-   * edge.
-   */
-#define OUTLINE_WIDTH 5
-  /* Top side */
-  if (!entry.hidden &&
-      window->frame && window->frame->bottom_height > 0 &&
-      window->frame->child_y >= window->frame->bottom_height)
-    entry.inner_rect.y = window->frame->bottom_height;
-  else
-    entry.inner_rect.y = OUTLINE_WIDTH;
-
-  /* Bottom side */
-  if (!entry.hidden &&
-      window->frame && window->frame->bottom_height != 0)
-    entry.inner_rect.height = r.height
-      - entry.inner_rect.y - window->frame->bottom_height;
-  else
-    entry.inner_rect.height = r.height
-      - entry.inner_rect.y - OUTLINE_WIDTH;
-
-  /* Left side */
-  if (!entry.hidden && window->frame && window->frame->child_x != 0)
-    entry.inner_rect.x = window->frame->child_x;
-  else
-    entry.inner_rect.x = OUTLINE_WIDTH;
-
-  /* Right side */
-  if (!entry.hidden &&
-      window->frame && window->frame->right_width != 0)
-    entry.inner_rect.width = r.width
-      - entry.inner_rect.x - window->frame->right_width;
-  else
-    entry.inner_rect.width = r.width
-      - entry.inner_rect.x - OUTLINE_WIDTH;
-
-  g_array_append_val (hd->entries, entry);
-}
-
-static void
-meta_alt_tab_handler_default_show (MetaAltTabHandler *handler,
-                                   MetaWindow        *initial_selection)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-
-  if (hd->tab_popup)
-    return;
-
-  hd->tab_popup = meta_ui_tab_popup_new ((MetaTabEntry *)hd->entries->data,
-                                         hd->screen->number,
-                                         hd->entries->len,
-                                         5, /* FIXME */
-                                         TRUE);
-  meta_ui_tab_popup_select (hd->tab_popup, (MetaTabEntryKey) initial_selection);
-  meta_ui_tab_popup_set_showing (hd->tab_popup, !hd->immediate_mode);
-}
-
-static void
-meta_alt_tab_handler_default_destroy (MetaAltTabHandler *handler)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-
-  if (hd->tab_popup)
-    {
-      meta_ui_tab_popup_free (hd->tab_popup);
-      hd->tab_popup = NULL;
-    }
-}
-
-static void
-meta_alt_tab_handler_default_forward (MetaAltTabHandler *handler)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-
-  if (hd->tab_popup)
-    meta_ui_tab_popup_forward (hd->tab_popup);
-}
-
-static void
-meta_alt_tab_handler_default_backward (MetaAltTabHandler *handler)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-
-  if (hd->tab_popup)
-    meta_ui_tab_popup_backward (hd->tab_popup);
-}
-
-static MetaWindow *
-meta_alt_tab_handler_default_get_selected (MetaAltTabHandler *handler)
-{
-  MetaAltTabHandlerDefault *hd = META_ALT_TAB_HANDLER_DEFAULT (handler);
-
-  if (hd->tab_popup)
-    return (MetaWindow *)meta_ui_tab_popup_get_selected (hd->tab_popup);
-  else
-    return NULL;
-}
-
-static void
-meta_alt_tab_handler_default_class_init (MetaAltTabHandlerDefaultClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->set_property = meta_alt_tab_handler_default_set_property;
-  object_class->finalize     = meta_alt_tab_handler_default_finalize;
-
-  g_object_class_override_property (object_class, PROP_SCREEN, "screen");
-  g_object_class_override_property (object_class, PROP_IMMEDIATE, "immediate");
-}
-
-static void
-meta_alt_tab_handler_default_interface_init (MetaAltTabHandlerInterface *handler_iface)
-{
-  handler_iface->add_window   = meta_alt_tab_handler_default_add_window;
-  handler_iface->show         = meta_alt_tab_handler_default_show;
-  handler_iface->destroy      = meta_alt_tab_handler_default_destroy;
-  handler_iface->forward      = meta_alt_tab_handler_default_forward;
-  handler_iface->backward     = meta_alt_tab_handler_default_backward;
-  handler_iface->get_selected = meta_alt_tab_handler_default_get_selected;
-}

src/core/bell.c

@@ -52,6 +52,9 @@
 #include "bell.h"
 #include "screen-private.h"
 #include "prefs.h"
+#ifdef HAVE_LIBCANBERRA
+#include <canberra-gtk.h>
+#endif
 
 /**
  * Flashes one entire screen.  This is done by making a window the size of the
@@ -228,18 +231,18 @@ bell_flash_window_frame (MetaWindow *window)
  */
 static void
 bell_flash_frame (MetaDisplay *display, 
-		       XkbAnyEvent *xkb_ev)
+		  XkbAnyEvent *xkb_ev)
 {
   XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent *) xkb_ev;
   MetaWindow *window;
   
   g_assert (xkb_ev->xkb_type == XkbBellNotify);
   window = meta_display_lookup_x_window (display, xkb_bell_event->window);
-  if (!window && (display->focus_window) && (display->focus_window->frame))
+  if (!window && (display->focus_window))
     {
       window = display->focus_window;
     }
-  if (window)
+  if (window && window->frame)
     {
       bell_flash_window_frame (window);
     }
@@ -285,6 +288,48 @@ meta_bell_notify (MetaDisplay *display,
   /* flash something */
   if (meta_prefs_get_visual_bell ()) 
     bell_visual_notify (display, xkb_ev);
+
+#ifdef HAVE_LIBCANBERRA
+  if (meta_prefs_bell_is_audible ())
+    {
+      ca_proplist *p;
+      XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
+      MetaWindow *window;
+      int res;
+
+      ca_proplist_create (&p);
+      ca_proplist_sets (p, CA_PROP_EVENT_ID, "bell-window-system");
+      ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION, _("Bell event"));
+      ca_proplist_sets (p, CA_PROP_CANBERRA_CACHE_CONTROL, "permanent");
+
+      window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+      if (!window && (display->focus_window) && (display->focus_window->frame))
+        window = display->focus_window;
+
+      if (window)
+        {
+          ca_proplist_sets (p, CA_PROP_WINDOW_NAME, window->title);
+          ca_proplist_setf (p, CA_PROP_WINDOW_X11_XID, "%lu", (unsigned long)window->xwindow);
+          ca_proplist_sets (p, CA_PROP_APPLICATION_NAME, window->res_name);
+          ca_proplist_setf (p, CA_PROP_APPLICATION_PROCESS_ID, "%d", window->net_wm_pid);
+        }
+
+      /* First, we try to play a real sound ... */
+      res = ca_context_play_full (ca_gtk_context_get (), 1, p, NULL, NULL);
+
+      ca_proplist_destroy (p);
+
+      if (res != CA_SUCCESS && res != CA_ERROR_DISABLED)
+        {
+          /* ...and in case that failed we use the classic X11 bell. */
+          XkbForceDeviceBell (display->xdisplay,
+                              xkb_bell_event->device,
+                              xkb_bell_event->bell_class,
+                              xkb_bell_event->bell_id,
+                              xkb_bell_event->percent);
+        }
+    }
+#endif /* HAVE_LIBCANBERRA */
 }
 #endif /* HAVE_XKB */
 
@@ -292,11 +337,19 @@ void
 meta_bell_set_audible (MetaDisplay *display, gboolean audible)
 {
 #ifdef HAVE_XKB
+#ifdef HAVE_LIBCANBERRA
+  /* When we are playing sounds using libcanberra support, we handle the
+   * bell whether its an audible bell or a visible bell */
+  gboolean enable_system_bell = FALSE;
+#else
+  gboolean enable_system_bell = audible;
+#endif /* HAVE_LIBCANBERRA */
+
   XkbChangeEnabledControls (display->xdisplay,
-			    XkbUseCoreKbd,
-			    XkbAudibleBellMask,
-			    audible ? XkbAudibleBellMask : 0);
-#endif  
+                            XkbUseCoreKbd,
+                            XkbAudibleBellMask,
+                            enable_system_bell ? XkbAudibleBellMask : 0);
+#endif /* HAVE_XKB */
 }
 
 gboolean
@@ -323,11 +376,7 @@ meta_bell_init (MetaDisplay *display)
 		       XkbUseCoreKbd,
 		       XkbBellNotifyMask,
 		       XkbBellNotifyMask);
-      XkbChangeEnabledControls (display->xdisplay,
-				XkbUseCoreKbd,
-				XkbAudibleBellMask,
-				meta_prefs_bell_is_audible () 
-				? XkbAudibleBellMask : 0);
+      meta_bell_set_audible (display, meta_prefs_bell_is_audible ());
       if (visual_bell_auto_reset) {
 	XkbSetAutoResetControls (display->xdisplay,
 				 XkbAudibleBellMask,

src/core/boxes.c

@@ -535,7 +535,7 @@ meta_rectangle_get_minimal_spanning_set_for_region (
    * enough to make this worth bothering.  Further, it is only called from
    * workspace.c:ensure_work_areas_validated (at least as of the time of
    * writing this comment), which in turn should only be called if the
-   * strut list changes or the screen or xinerama size changes.  If it ever
+   * strut list changes or the screen or monitor size changes.  If it ever
    * does show up on profiles (most likely because people start using
    * ridiculously huge numbers of partial struts), possible optimizations
    * include:
@@ -1792,14 +1792,14 @@ meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
 }
 
 GList*
-meta_rectangle_find_nonintersected_xinerama_edges (
-                                    const GList         *xinerama_rects,
+meta_rectangle_find_nonintersected_monitor_edges (
+                                    const GList         *monitor_rects,
                                     const GSList        *all_struts)
 {
   /* This function cannot easily be merged with
    * meta_rectangle_find_onscreen_edges() because real screen edges
    * and strut edges both are of the type "there ain't anything
-   * immediately on the other side"; xinerama edges are different.
+   * immediately on the other side"; monitor edges are different.
    */
   GList *ret;
   const GList  *cur;
@@ -1808,14 +1808,14 @@ meta_rectangle_find_nonintersected_xinerama_edges (
   /* Initialize the return list to be empty */
   ret = NULL;
 
-  /* start of ret with all the edges of xineramas that are adjacent to
-   * another xinerama.
+  /* start of ret with all the edges of monitors that are adjacent to
+   * another monitor.
    */
-  cur = xinerama_rects;
+  cur = monitor_rects;
   while (cur)
     {
       MetaRectangle *cur_rect = cur->data;
-      const GList *compare = xinerama_rects;
+      const GList *compare = monitor_rects;
       while (compare)
         {
           MetaRectangle *compare_rect = compare->data;
@@ -1849,15 +1849,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
               /* If the rectangles really are adjacent */
               if (x != INT_MIN)
                 {
-                  /* We need a left edge for the xinerama on the right, and
-                   * a right edge for the xinerama on the left.  Just fill
+                  /* We need a left edge for the monitor on the right, and
+                   * a right edge for the monitor on the left.  Just fill
                    * up the edges and stick 'em on the list.
                    */
                   MetaEdge *new_edge  = g_new (MetaEdge, 1);
 
                   new_edge->rect = meta_rect (x, y, width, height);
                   new_edge->side_type = side_type;
-                  new_edge->edge_type = META_EDGE_XINERAMA;
+                  new_edge->edge_type = META_EDGE_MONITOR;
 
                   ret = g_list_prepend (ret, new_edge);
                 }
@@ -1892,15 +1892,15 @@ meta_rectangle_find_nonintersected_xinerama_edges (
               /* If the rectangles really are adjacent */
               if (y != INT_MIN)
                 {
-                  /* We need a top edge for the xinerama on the bottom, and
-                   * a bottom edge for the xinerama on the top.  Just fill
+                  /* We need a top edge for the monitor on the bottom, and
+                   * a bottom edge for the monitor on the top.  Just fill
                    * up the edges and stick 'em on the list.
                    */
                   MetaEdge *new_edge = g_new (MetaEdge, 1);
 
                   new_edge->rect = meta_rect (x, y, width, height);
                   new_edge->side_type = side_type;
-                  new_edge->edge_type = META_EDGE_XINERAMA;
+                  new_edge->edge_type = META_EDGE_MONITOR;
 
                   ret = g_list_prepend (ret, new_edge);
                 }

src/core/constraints.c

@@ -27,6 +27,7 @@
 #include "constraints.h"
 #include "workspace-private.h"
 #include "place.h"
+#include "prefs.h"
 
 #include <stdlib.h>
 #include <math.h>
@@ -93,7 +94,7 @@ typedef enum
 {
   PRIORITY_MINIMUM = 0, /* Dummy value used for loop start = min(all priorities) */
   PRIORITY_ASPECT_RATIO = 0,
-  PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA = 0,
+  PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR = 0,
   PRIORITY_ENTIRELY_VISIBLE_ON_WORKAREA = 1,
   PRIORITY_SIZE_HINTS_INCREMENTS = 1,
   PRIORITY_MAXIMIZATION = 2,
@@ -127,17 +128,17 @@ typedef struct
   int                  resize_gravity;
   FixedDirections      fixed_directions;
 
-  /* work_area_xinerama - current xinerama region minus struts
-   * entire_xinerama    - current xienrama, including strut regions
+  /* work_area_monitor - current monitor region minus struts
+   * entire_monitor    - current monitor, including strut regions
    */
-  MetaRectangle        work_area_xinerama;
-  MetaRectangle        entire_xinerama;
+  MetaRectangle        work_area_monitor;
+  MetaRectangle        entire_monitor;
 
   /* Spanning rectangles for the non-covered (by struts) region of the
-   * screen and also for just the current xinerama
+   * screen and also for just the current monitor
    */
   GList  *usable_screen_region;
-  GList  *usable_xinerama_region;
+  GList  *usable_monitor_region;
 } ConstraintInfo;
 
 static gboolean constrain_maximization       (MetaWindow         *window,
@@ -160,7 +161,7 @@ static gboolean constrain_aspect_ratio       (MetaWindow         *window,
                                               ConstraintInfo     *info,
                                               ConstraintPriority  priority,
                                               gboolean            check_only);
-static gboolean constrain_to_single_xinerama (MetaWindow         *window,
+static gboolean constrain_to_single_monitor  (MetaWindow         *window,
                                               ConstraintInfo     *info,
                                               ConstraintPriority  priority,
                                               gboolean            check_only);
@@ -214,7 +215,7 @@ static const Constraint all_constraints[] = {
   {constrain_size_increments,    "constrain_size_increments"},
   {constrain_size_limits,        "constrain_size_limits"},
   {constrain_aspect_ratio,       "constrain_aspect_ratio"},
-  {constrain_to_single_xinerama, "constrain_to_single_xinerama"},
+  {constrain_to_single_monitor,  "constrain_to_single_monitor"},
   {constrain_fully_onscreen,     "constrain_fully_onscreen"},
   {constrain_titlebar_visible,   "constrain_titlebar_visible"},
   {constrain_partially_onscreen, "constrain_partially_onscreen"},
@@ -311,7 +312,7 @@ meta_window_constrain (MetaWindow          *window,
   *new = info.current;
 
   /* We may need to update window->require_fully_onscreen,
-   * window->require_on_single_xinerama, and perhaps other quantities
+   * window->require_on_single_monitor, and perhaps other quantities
    * if this was a user move or user move-and-resize operation.
    */
   update_onscreen_requirements (window, &info);
@@ -333,7 +334,7 @@ setup_constraint_info (ConstraintInfo      *info,
                        const MetaRectangle *orig,
                        MetaRectangle       *new)
 {
-  const MetaXineramaScreenInfo *xinerama_info;
+  const MetaMonitorInfo *monitor_info;
   MetaWorkspace *cur_workspace;
 
   info->orig    = *orig;
@@ -387,15 +388,15 @@ setup_constraint_info (ConstraintInfo      *info,
   if (!info->is_user_action)
     info->fixed_directions = FIXED_DIRECTION_NONE;
 
-  xinerama_info =
-    meta_screen_get_xinerama_for_rect (window->screen, &info->current);
-  meta_window_get_work_area_for_xinerama (window,
-                                          xinerama_info->number,
-                                          &info->work_area_xinerama);
+  monitor_info =
+    meta_screen_get_monitor_for_rect (window->screen, &info->current);
+  meta_window_get_work_area_for_monitor (window,
+                                         monitor_info->number,
+                                         &info->work_area_monitor);
 
   if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
     {
-      info->entire_xinerama = xinerama_info->rect;
+      info->entire_monitor = monitor_info->rect;
     }
   else
     {
@@ -403,28 +404,29 @@ setup_constraint_info (ConstraintInfo      *info,
       long monitor;
 
       monitor = window->fullscreen_monitors[i];
-      info->entire_xinerama =
-        window->screen->xinerama_infos[monitor].rect;
+      info->entire_monitor =
+        window->screen->monitor_infos[monitor].rect;
       for (i = 1; i <= 3; i++)
         {
           monitor = window->fullscreen_monitors[i];
-          meta_rectangle_union (&info->entire_xinerama,
-                                &window->screen->xinerama_infos[monitor].rect,
-                                &info->entire_xinerama);
+          meta_rectangle_union (&info->entire_monitor,
+                                &window->screen->monitor_infos[monitor].rect,
+                                &info->entire_monitor);
         }
     }
 
   cur_workspace = window->screen->active_workspace;
   info->usable_screen_region   = 
     meta_workspace_get_onscreen_region (cur_workspace);
-  info->usable_xinerama_region = 
-    meta_workspace_get_onxinerama_region (cur_workspace, 
-                                          xinerama_info->number);
+  info->usable_monitor_region = 
+    meta_workspace_get_onmonitor_region (cur_workspace, 
+                                         monitor_info->number);
 
   /* Workaround braindead legacy apps that don't know how to
    * fullscreen themselves properly.
    */
-  if (meta_rectangle_equal (new, &xinerama_info->rect) &&
+  if (meta_prefs_get_force_fullscreen() &&
+      meta_rectangle_equal (new, &monitor_info->rect) &&
       window->has_fullscreen_func &&
       !window->fullscreen)
     {
@@ -448,8 +450,8 @@ setup_constraint_info (ConstraintInfo      *info,
               "  is_user_action  : %s\n"
               "  resize_gravity  : %s\n"
               "  fixed_directions: %s\n"
-              "  work_area_xinerama: %d,%d +%d,%d\n"
-              "  entire_xinerama   : %d,%d +%d,%d\n",
+              "  work_area_monitor: %d,%d +%d,%d\n"
+              "  entire_monitor   : %d,%d +%d,%d\n",
               info->orig.x, info->orig.y, info->orig.width, info->orig.height,
               info->current.x, info->current.y, 
                 info->current.width, info->current.height,
@@ -465,11 +467,11 @@ setup_constraint_info (ConstraintInfo      *info,
                 (info->fixed_directions == FIXED_DIRECTION_X) ? "X fixed" :
                 (info->fixed_directions == FIXED_DIRECTION_Y) ? "Y fixed" :
                 "Freakin' Invalid Stupid",
-              info->work_area_xinerama.x, info->work_area_xinerama.y,
-                info->work_area_xinerama.width, 
-                info->work_area_xinerama.height,
-              info->entire_xinerama.x, info->entire_xinerama.y,
-                info->entire_xinerama.width, info->entire_xinerama.height);
+              info->work_area_monitor.x, info->work_area_monitor.y,
+                info->work_area_monitor.width, 
+                info->work_area_monitor.height,
+              info->entire_monitor.x, info->entire_monitor.y,
+                info->entire_monitor.width, info->entire_monitor.height);
 }
 
 static void
@@ -493,25 +495,25 @@ place_window_if_needed(MetaWindow     *window,
     {
       MetaRectangle placed_rect = info->orig;
       MetaWorkspace *cur_workspace;
-      const MetaXineramaScreenInfo *xinerama_info;
+      const MetaMonitorInfo *monitor_info;
 
       meta_window_place (window, info->fgeom, info->orig.x, info->orig.y,
                          &placed_rect.x, &placed_rect.y);
       did_placement = TRUE;
 
-      /* placing the window may have changed the xinerama.  Find the
-       * new xinerama and update the ConstraintInfo
+      /* placing the window may have changed the monitor.  Find the
+       * new monitor and update the ConstraintInfo
        */
-      xinerama_info =
-        meta_screen_get_xinerama_for_rect (window->screen, &placed_rect);
-      info->entire_xinerama = xinerama_info->rect;
-      meta_window_get_work_area_for_xinerama (window,
-                                              xinerama_info->number,
-                                              &info->work_area_xinerama);
+      monitor_info =
+        meta_screen_get_monitor_for_rect (window->screen, &placed_rect);
+      info->entire_monitor = monitor_info->rect;
+      meta_window_get_work_area_for_monitor (window,
+                                             monitor_info->number,
+                                             &info->work_area_monitor);
       cur_workspace = window->screen->active_workspace;
-      info->usable_xinerama_region = 
-        meta_workspace_get_onxinerama_region (cur_workspace, 
-                                              xinerama_info->number);
+      info->usable_monitor_region = 
+        meta_workspace_get_onmonitor_region (cur_workspace, 
+                                             monitor_info->number);
 
 
       info->current.x = placed_rect.x;
@@ -526,22 +528,23 @@ place_window_if_needed(MetaWindow     *window,
   if (window->placed || did_placement)
     {
       if (window->maximize_horizontally_after_placement ||
-          window->maximize_vertically_after_placement)
+          window->maximize_vertically_after_placement   ||
+          window->fullscreen_after_placement)
         {
-          /* define a sane saved_rect so that the user can unmaximize to
-           * something reasonable.
+          /* define a sane saved_rect so that the user can unmaximize or
+           * make unfullscreen to something reasonable.
            */
-          if (info->current.width >= info->work_area_xinerama.width)
+          if (info->current.width >= info->work_area_monitor.width)
             {
-              info->current.width = .75 * info->work_area_xinerama.width;
-              info->current.x = info->work_area_xinerama.x +
-                       .125 * info->work_area_xinerama.width;
+              info->current.width = .75 * info->work_area_monitor.width;
+              info->current.x = info->work_area_monitor.x +
+                       .125 * info->work_area_monitor.width;
             }
-          if (info->current.height >= info->work_area_xinerama.height)
+          if (info->current.height >= info->work_area_monitor.height)
             {
-              info->current.height = .75 * info->work_area_xinerama.height;
-              info->current.y = info->work_area_xinerama.y +
-                       .083 * info->work_area_xinerama.height;
+              info->current.height = .75 * info->work_area_monitor.height;
+              info->current.y = info->work_area_monitor.y +
+                       .083 * info->work_area_monitor.height;
             }
 
           if (window->maximize_horizontally_after_placement ||
@@ -556,6 +559,15 @@ place_window_if_needed(MetaWindow     *window,
           if (window->frame && !window->fullscreen)
             meta_frame_calc_geometry (window->frame, info->fgeom);
 
+          if (window->fullscreen_after_placement)
+            {
+              window->saved_rect = info->current;
+              window->fullscreen = TRUE;
+              window->fullscreen_after_placement = FALSE;
+
+              g_object_notify (G_OBJECT (window), "fullscreen");
+            }
+
           window->maximize_horizontally_after_placement = FALSE;
           window->maximize_vertically_after_placement = FALSE;
         }
@@ -589,7 +601,7 @@ update_onscreen_requirements (MetaWindow     *window,
     return;
 
   /* USABILITY NOTE: Naturally, I only want the require_fully_onscreen,
-   * require_on_single_xinerama, and require_titlebar_visible flags to
+   * require_on_single_monitor, and require_titlebar_visible flags to
    * *become false* due to user interactions (which is allowed since
    * certain constraints are ignored for user interactions regardless of
    * the setting of these flags).  However, whether to make these flags
@@ -603,7 +615,7 @@ update_onscreen_requirements (MetaWindow     *window,
    * problematic case but this may need to be revisited.
    */
 
-  /* The require onscreen/on-single-xinerama and titlebar_visible
+  /* The require onscreen/on-single-monitor and titlebar_visible
    * stuff is relative to the outer window, not the inner
    */
   extend_by_frame (&info->current, info->fgeom);
@@ -622,17 +634,17 @@ update_onscreen_requirements (MetaWindow     *window,
                 window->require_fully_onscreen ? "TRUE" : "FALSE");
 
   /* Update whether we want future constraint runs to require the
-   * window to be on a single xinerama.
+   * window to be on a single monitor.
    */
-  old = window->require_on_single_xinerama;
-  window->require_on_single_xinerama =
-    meta_rectangle_contained_in_region (info->usable_xinerama_region,
+  old = window->require_on_single_monitor;
+  window->require_on_single_monitor =
+    meta_rectangle_contained_in_region (info->usable_monitor_region,
                                         &info->current);
-  if (old ^ window->require_on_single_xinerama)
+  if (old ^ window->require_on_single_monitor)
     meta_topic (META_DEBUG_GEOMETRY,
-                "require_on_single_xinerama for %s toggled to %s\n",
+                "require_on_single_monitor for %s toggled to %s\n",
                 window->desc, 
-                window->require_on_single_xinerama ? "TRUE" : "FALSE");
+                window->require_on_single_monitor ? "TRUE" : "FALSE");
 
   /* Update whether we want future constraint runs to require the
    * titlebar to be visible.
@@ -700,8 +712,17 @@ get_size_limits (const MetaWindow        *window,
 
       min_size->width  += fw;
       min_size->height += fh;
-      max_size->width  += fw;
-      max_size->height += fh;
+      /* Do check to avoid overflow (e.g. max_size->width & max_size->height
+       * may be set to G_MAXINT by meta_set_normal_hints()).
+       */
+      if (max_size->width < (G_MAXINT - fw))
+        max_size->width += fw;
+      else
+        max_size->width = G_MAXINT;
+      if (max_size->height < (G_MAXINT - fh))
+        max_size->height += fh;
+      else
+        max_size->height = G_MAXINT;
     }
 }
 
@@ -726,7 +747,7 @@ constrain_maximization (MetaWindow         *window,
 
   /* Calculate target_size = maximized size of (window + frame) */
   if (window->maximized_horizontally && window->maximized_vertically)
-    target_size = info->work_area_xinerama;
+    target_size = info->work_area_monitor;
   else
     {
       /* Amount of maximization possible in a single direction depends
@@ -748,7 +769,7 @@ constrain_maximization (MetaWindow         *window,
       target_size = info->current;
       extend_by_frame (&target_size, info->fgeom);
       meta_rectangle_expand_to_avoiding_struts (&target_size,
-                                                &info->entire_xinerama,
+                                                &info->entire_monitor,
                                                 direction,
                                                 active_workspace_struts);
    }
@@ -795,7 +816,7 @@ constrain_fullscreen (MetaWindow         *window,
                       ConstraintPriority  priority,
                       gboolean            check_only)
 {
-  MetaRectangle min_size, max_size, xinerama;
+  MetaRectangle min_size, max_size, monitor;
   gboolean too_big, too_small, constraint_already_satisfied;
 
   if (priority > PRIORITY_FULLSCREEN)
@@ -805,22 +826,22 @@ constrain_fullscreen (MetaWindow         *window,
   if (!window->fullscreen)
     return TRUE;
 
-  xinerama = info->entire_xinerama;
+  monitor = info->entire_monitor;
 
   get_size_limits (window, info->fgeom, FALSE, &min_size, &max_size);
-  too_big =   !meta_rectangle_could_fit_rect (&xinerama, &min_size);
-  too_small = !meta_rectangle_could_fit_rect (&max_size, &xinerama);
+  too_big =   !meta_rectangle_could_fit_rect (&monitor, &min_size);
+  too_small = !meta_rectangle_could_fit_rect (&max_size, &monitor);
   if (too_big || too_small)
     return TRUE;
 
   /* Determine whether constraint is already satisfied; exit if it is */
   constraint_already_satisfied =
-    meta_rectangle_equal (&info->current, &xinerama);
+    meta_rectangle_equal (&info->current, &monitor);
   if (check_only || constraint_already_satisfied)
     return constraint_already_satisfied;
 
   /*** Enforce constraint ***/
-  info->current = xinerama;
+  info->current = monitor;
   return TRUE;
 }
 
@@ -1082,7 +1103,7 @@ constrain_aspect_ratio (MetaWindow         *window,
 }
 
 static gboolean
-do_screen_and_xinerama_relative_constraints (
+do_screen_and_monitor_relative_constraints (
   MetaWindow     *window,
   GList          *region_spanning_rectangles,
   ConstraintInfo *info,
@@ -1098,7 +1119,7 @@ do_screen_and_xinerama_relative_constraints (
       char spanning_region[1 + 28 * g_list_length (region_spanning_rectangles)];
 
       meta_topic (META_DEBUG_GEOMETRY,
-             "screen/xinerama constraint; region_spanning_rectangles: %s\n",
+             "screen/monitor constraint; region_spanning_rectangles: %s\n",
              meta_rectangle_region_to_string (region_spanning_rectangles, ", ",
                                               spanning_region));
     }
@@ -1156,32 +1177,32 @@ do_screen_and_xinerama_relative_constraints (
 }
 
 static gboolean
-constrain_to_single_xinerama (MetaWindow         *window,
-                              ConstraintInfo     *info,
-                              ConstraintPriority  priority,
-                              gboolean            check_only)
+constrain_to_single_monitor (MetaWindow         *window,
+                             ConstraintInfo     *info,
+                             ConstraintPriority  priority,
+                             gboolean            check_only)
 {
-  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_XINERAMA)
+  if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR)
     return TRUE;
 
   /* Exit early if we know the constraint won't apply--note that this constraint
    * is only meant for normal windows (e.g. we don't want docks to be shoved 
    * "onscreen" by their own strut) and we can't apply it to frameless windows
-   * or else users will be unable to move windows such as XMMS across xineramas.
+   * or else users will be unable to move windows such as XMMS across monitors.
    */
   if (window->type == META_WINDOW_DESKTOP   ||
       window->type == META_WINDOW_DOCK      ||
-      window->screen->n_xinerama_infos == 1 ||
-      !window->require_on_single_xinerama   ||
+      window->screen->n_monitor_infos == 1  ||
+      !window->require_on_single_monitor    ||
       !window->frame                        ||
       info->is_user_action)
     return TRUE;
 
   /* Have a helper function handle the constraint for us */
-  return do_screen_and_xinerama_relative_constraints (window, 
-                                                 info->usable_xinerama_region,
-                                                 info,
-                                                 check_only);
+  return do_screen_and_monitor_relative_constraints (window, 
+                                                     info->usable_monitor_region,
+                                                     info,
+                                                     check_only);
 }
 
 static gboolean
@@ -1205,10 +1226,10 @@ constrain_fully_onscreen (MetaWindow         *window,
     return TRUE;
 
   /* Have a helper function handle the constraint for us */
-  return do_screen_and_xinerama_relative_constraints (window, 
-                                                 info->usable_screen_region,
-                                                 info,
-                                                 check_only);
+  return do_screen_and_monitor_relative_constraints (window, 
+                                                     info->usable_screen_region,
+                                                     info,
+                                                     check_only);
 }
 
 static gboolean
@@ -1281,10 +1302,10 @@ constrain_titlebar_visible (MetaWindow         *window,
                                               horiz_amount_onscreen,
                                               vert_amount_onscreen);
   retval =
-    do_screen_and_xinerama_relative_constraints (window, 
-                                                 info->usable_screen_region,
-                                                 info,
-                                                 check_only);
+    do_screen_and_monitor_relative_constraints (window, 
+                                                info->usable_screen_region,
+                                                info,
+                                                check_only);
   meta_rectangle_expand_region_conditionally (info->usable_screen_region,
                                               -horiz_amount_offscreen,
                                               -horiz_amount_offscreen,
@@ -1356,10 +1377,10 @@ constrain_partially_onscreen (MetaWindow         *window,
                                               horiz_amount_onscreen,
                                               vert_amount_onscreen);
   retval =
-    do_screen_and_xinerama_relative_constraints (window, 
-                                                 info->usable_screen_region,
-                                                 info,
-                                                 check_only);
+    do_screen_and_monitor_relative_constraints (window, 
+                                                info->usable_screen_region,
+                                                info,
+                                                check_only);
   meta_rectangle_expand_region_conditionally (info->usable_screen_region,
                                               -horiz_amount_offscreen,
                                               -horiz_amount_offscreen,

src/core/core.c

@@ -766,7 +766,7 @@ meta_invalidate_default_icons (void)
   if (display == NULL)
     return; /* We can validly be called before the display is opened. */
 
-  windows = meta_display_list_windows (display);
+  windows = meta_display_list_windows (display, META_LIST_DEFAULT);
   for (l = windows; l != NULL; l = l->next)
     {
       MetaWindow *window = (MetaWindow*)l->data;

src/core/delete.c

@@ -55,27 +55,16 @@ delete_ping_reply_func (MetaDisplay *display,
   /* we do nothing */
 }
 
-static gboolean
-delete_window_callback (gpointer w_p)
-{
-  meta_window_kill ((MetaWindow*) w_p);
-
-  return FALSE; /* don't do it again */
-}
-
 static void
-sigchld_handler (MetaNexus *nexus, guint arg1, gpointer arg2, gpointer user_data)
+dialog_exited (GPid pid, int status, gpointer user_data)
 {
   MetaWindow *ours = (MetaWindow*) user_data;
 
-  if (GPOINTER_TO_INT (arg2) == ours->dialog_pid)
-    {
-      if (arg1 == 1 /* pressed "force quit" */)
-        g_idle_add_full (G_PRIORITY_DEFAULT,
-                         delete_window_callback, user_data, NULL);
+  ours->dialog_pid = -1;
 
-      ours->dialog_pid = -1; /* forget it anyway */
-    }
+  /* exit status of 1 means the user pressed "Force Quit" */
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 1)
+    meta_window_kill (ours);
 }
 
 static void
@@ -86,7 +75,7 @@ delete_ping_timeout_func (MetaDisplay *display,
 {
   MetaWindow *window = user_data;
   char *window_title;
-  gchar *window_content;
+  gchar *window_content, *tmp;
   GPid dialog_pid;
   
   meta_topic (META_DEBUG_PING,
@@ -101,11 +90,14 @@ delete_ping_timeout_func (MetaDisplay *display,
 
   window_title = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
 
-  window_content = g_strdup_printf(
-      _("<big><b><tt>%s</tt> is not responding.</b></big>\n\n"
-      "<i>You may choose to wait a short while for it to "
-      "continue or force the application to quit entirely.</i>"),
-      window_title);
+  /* Translators: %s is a window title */
+  tmp = g_strdup_printf (_("<tt>%s</tt> is not responding."),
+                         window_title);
+  window_content = g_strdup_printf (
+      "<big><b>%s</b></big>\n\n<i>%s</i>",
+      tmp,
+      _("You may choose to wait a short while for it to "
+        "continue or force the application to quit entirely."));
 
   g_free (window_title);
 
@@ -117,13 +109,10 @@ delete_ping_timeout_func (MetaDisplay *display,
                       NULL, NULL);
 
   g_free (window_content);
+  g_free (tmp);
 
   window->dialog_pid = dialog_pid;
-
-  g_signal_connect (sigchld_nexus, "sigchld",
-                    G_CALLBACK (sigchld_handler),
-                    window);
-
+  g_child_watch_add (dialog_pid, dialog_exited, window);
 }
 
 void
@@ -253,7 +242,7 @@ meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp)
        * mutter-dialog
        */
       
-      windows = meta_display_list_windows (window->display);
+      windows = meta_display_list_windows (window->display, META_LIST_DEFAULT);
       tmp = windows;
       while (tmp != NULL)
         {

src/core/display-private.h

@@ -52,6 +52,7 @@ typedef struct _MetaStack      MetaStack;
 typedef struct _MetaUISlave    MetaUISlave;
 
 typedef struct _MetaGroupPropHooks  MetaGroupPropHooks;
+typedef struct _MetaWindowPropHooks MetaWindowPropHooks;
 
 typedef struct MetaEdgeResistanceData MetaEdgeResistanceData;
 
@@ -60,6 +61,10 @@ typedef void (* MetaWindowPingFunc) (MetaDisplay *display,
 				     guint32      timestamp,
 				     gpointer     user_data);
 
+typedef enum {
+  META_LIST_DEFAULT                   = 0,      /* normal windows */
+  META_LIST_INCLUDE_OVERRIDE_REDIRECT = 1 << 0, /* normal and O-R */
+} MetaListWindowsFlags;
 
 #define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
 #define _NET_WM_STATE_ADD           1    /* add/set property */
@@ -145,6 +150,15 @@ struct _MetaDisplay
   
   guint32 current_time;
 
+  /* We maintain a sequence counter, incremented for each #MetaWindow
+   * created.  This is exposed by meta_window_get_stable_sequence()
+   * but is otherwise not used inside mutter.
+   *
+   * It can be useful to plugins which want to sort windows in a
+   * stable fashion.
+   */
+  guint32 window_sequence_counter;
+
   /* Pings which we're waiting for a reply from */
   GSList     *pending_pings;
 
@@ -169,19 +183,13 @@ struct _MetaDisplay
   gulong      grab_mask;
   guint       grab_have_pointer : 1;
   guint       grab_have_keyboard : 1;
-  guint       grab_wireframe_active : 1;
-  guint       grab_was_cancelled : 1;    /* Only used in wireframe mode */
   guint       grab_frame_action : 1;
-  MetaRectangle grab_wireframe_rect;
-  MetaRectangle grab_wireframe_last_xor_rect;
   MetaRectangle grab_initial_window_pos;
   int         grab_initial_x, grab_initial_y;  /* These are only relevant for */
   gboolean    grab_threshold_movement_reached; /* raise_on_click == FALSE.    */
   MetaResizePopup *grab_resize_popup;
   GTimeVal    grab_last_moveresize_time;
   guint32     grab_motion_notify_time;
-  int         grab_wireframe_last_display_width;
-  int         grab_wireframe_last_display_height;
   GList*      grab_old_window_stacking;
   MetaEdgeResistanceData *grab_edge_resistance_data;
   unsigned int grab_last_user_action_was_snap;
@@ -218,8 +226,8 @@ struct _MetaDisplay
   MetaKeyCombo overlay_key_combo;
   gboolean overlay_key_only_pressed;
   
-  /* Xinerama cache */
-  unsigned int xinerama_cache_invalidated : 1;
+  /* Monitor cache */
+  unsigned int monitor_cache_invalidated : 1;
 
   /* Opening the display */
   unsigned int display_opening : 1;
@@ -235,14 +243,27 @@ struct _MetaDisplay
   MetaWindow *window_with_menu;
 
   /* Managed by window-props.c */
-  gpointer *prop_hooks_table;
+  MetaWindowPropHooks *prop_hooks_table;
   GHashTable *prop_hooks;
+  int n_prop_hooks;
 
   /* Managed by group-props.c */
   MetaGroupPropHooks *group_prop_hooks;
 
   /* Managed by compositor.c */
   MetaCompositor *compositor;
+
+  int render_event_base;
+  int render_error_base;
+
+  int composite_event_base;
+  int composite_error_base;
+  int composite_major_version;
+  int composite_minor_version;
+  int damage_event_base;
+  int damage_error_base;
+  int xfixes_event_base;
+  int xfixes_error_base;
   
 #ifdef HAVE_STARTUP_NOTIFICATION
   SnDisplay *sn_display;
@@ -255,20 +276,6 @@ struct _MetaDisplay
   int shape_event_base;
   int shape_error_base;
 #endif
-#ifdef HAVE_RENDER
-  int render_event_base;
-  int render_error_base;
-#endif
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-  int composite_event_base;
-  int composite_error_base;
-  int composite_major_version;
-  int composite_minor_version;
-  int damage_event_base;
-  int damage_error_base;
-  int xfixes_event_base;
-  int xfixes_error_base;
-#endif
 #ifdef HAVE_XSYNC
   unsigned int have_xsync : 1;
 #define META_DISPLAY_HAS_XSYNC(display) ((display)->have_xsync)
@@ -281,24 +288,14 @@ struct _MetaDisplay
 #else
 #define META_DISPLAY_HAS_SHAPE(display) FALSE
 #endif
-#ifdef HAVE_RENDER
   unsigned int have_render : 1;
 #define META_DISPLAY_HAS_RENDER(display) ((display)->have_render)
-#else
-#define META_DISPLAY_HAS_RENDER(display) FALSE
-#endif
-#ifdef HAVE_COMPOSITE_EXTENSIONS
   unsigned int have_composite : 1;
   unsigned int have_damage : 1;
   unsigned int have_xfixes : 1;
 #define META_DISPLAY_HAS_COMPOSITE(display) ((display)->have_composite)
 #define META_DISPLAY_HAS_DAMAGE(display) ((display)->have_damage)
 #define META_DISPLAY_HAS_XFIXES(display) ((display)->have_xfixes)
-#else
-#define META_DISPLAY_HAS_COMPOSITE(display) FALSE
-#define META_DISPLAY_HAS_DAMAGE(display) FALSE
-#define META_DISPLAY_HAS_XFIXES(display) FALSE
-#endif
 };
 
 struct _MetaDisplayClass
@@ -360,11 +357,12 @@ void        meta_display_register_x_window   (MetaDisplay *display,
                                               MetaWindow  *window);
 void        meta_display_unregister_x_window (MetaDisplay *display,
                                               Window       xwindow);
-/* Return whether the xwindow is a no focus window for any of the screens */
-gboolean    meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
-                                                       Window xwindow);
 
-GSList*     meta_display_list_windows        (MetaDisplay *display);
+void        meta_display_notify_window_created (MetaDisplay  *display,
+                                                MetaWindow   *window);
+
+GSList*     meta_display_list_windows        (MetaDisplay          *display,
+                                              MetaListWindowsFlags  flags);
 
 MetaDisplay* meta_display_for_x_display  (Display     *xdisplay);
 MetaDisplay* meta_get_display            (void);
@@ -392,9 +390,8 @@ void meta_display_grab_focus_window_button   (MetaDisplay *display,
 void meta_display_ungrab_focus_window_button (MetaDisplay *display,
                                               MetaWindow  *window);
 
-/* Next two functions are defined in edge-resistance.c */
-void meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display);
-void meta_display_cleanup_edges                         (MetaDisplay *display);
+/* Next function is defined in edge-resistance.c */
+void meta_display_cleanup_edges              (MetaDisplay *display);
 
 /* make a request to ensure the event serial has changed */
 void     meta_display_increment_event_serial (MetaDisplay *display);

src/core/display.c

@@ -46,7 +46,6 @@
 #include "xprops.h"
 #include "workspace-private.h"
 #include "bell.h"
-#include "effects.h"
 #include "compositor.h"
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
@@ -62,20 +61,16 @@
 #ifdef HAVE_SHAPE
 #include <X11/extensions/shape.h>
 #endif
-#ifdef HAVE_RENDER
-#include <X11/extensions/Xrender.h>
-#endif
 #ifdef HAVE_XKB
 #include <X11/XKBlib.h>
 #endif
 #ifdef HAVE_XCURSOR
 #include <X11/Xcursor/Xcursor.h>
 #endif
-#ifdef HAVE_COMPOSITE_EXTENSIONS
+#include <X11/extensions/Xrender.h>
 #include <X11/extensions/Xcomposite.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
-#endif
 #include <string.h>
 
 #define GRAB_OP_IS_WINDOW_SWITCH(g)                     \
@@ -133,9 +128,19 @@ G_DEFINE_TYPE(MetaDisplay, meta_display, G_TYPE_OBJECT);
 enum
 {
   OVERLAY_KEY,
+  FOCUS_WINDOW,
+  WINDOW_CREATED,
+  WINDOW_DEMANDS_ATTENTION,
+  WINDOW_MARKED_URGENT,
   LAST_SIGNAL
 };
 
+enum {
+  PROP_0,
+
+  PROP_FOCUS_WINDOW
+};
+
 static guint display_signals [LAST_SIGNAL] = { 0 };
 
 /**
@@ -146,8 +151,10 @@ static guint display_signals [LAST_SIGNAL] = { 0 };
  */
 static MetaDisplay *the_display = NULL;
 
+#ifdef WITH_VERBOSE_MODE
 static void   meta_spew_event           (MetaDisplay    *display,
                                          XEvent         *event);
+#endif
 
 static gboolean event_callback          (XEvent         *event,
                                          gpointer        data);
@@ -174,9 +181,47 @@ static void    sanity_check_timestamps   (MetaDisplay *display,
 
 MetaGroup*     get_focussed_group (MetaDisplay *display);
 
+static void
+meta_display_get_property(GObject         *object,
+                          guint            prop_id,
+                          GValue          *value,
+                          GParamSpec      *pspec)
+{
+  MetaDisplay *display = META_DISPLAY (object);
+
+  switch (prop_id)
+    {
+    case PROP_FOCUS_WINDOW:
+      g_value_set_object (value, display->focus_window);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+meta_display_set_property(GObject         *object,
+                          guint            prop_id,
+                          const GValue    *value,
+                          GParamSpec      *pspec)
+{
+  switch (prop_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
 static void
 meta_display_class_init (MetaDisplayClass *klass)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->get_property = meta_display_get_property;
+  object_class->set_property = meta_display_set_property;
+
   display_signals[OVERLAY_KEY] =
     g_signal_new ("overlay-key",
                   G_TYPE_FROM_CLASS (klass),
@@ -184,9 +229,46 @@ meta_display_class_init (MetaDisplayClass *klass)
                   0,
                   NULL, NULL,
                   g_cclosure_marshal_VOID__VOID,
-                  G_TYPE_NONE, 0);  
+                  G_TYPE_NONE, 0);
+
+  display_signals[WINDOW_CREATED] =
+    g_signal_new ("window-created",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1, META_TYPE_WINDOW);
+
+  display_signals[WINDOW_DEMANDS_ATTENTION] =
+    g_signal_new ("window-demands-attention",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1, META_TYPE_WINDOW);
+
+  display_signals[WINDOW_MARKED_URGENT] =
+    g_signal_new ("window-marked-urgent",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  META_TYPE_WINDOW);
+
+  g_object_class_install_property (object_class,
+                                   PROP_FOCUS_WINDOW,
+                                   g_param_spec_object ("focus-window",
+                                                        "Focus window",
+                                                        "Currently focused window",
+                                                        META_TYPE_WINDOW,
+                                                        G_PARAM_READABLE));
 }
 
+
 /**
  * Destructor for MetaPingData structs. Will destroy the
  * event source for the struct as well.
@@ -434,7 +516,7 @@ meta_display_open (void)
   the_display->leader_window = None;
   the_display->timestamp_pinging_window = None;
 
-  the_display->xinerama_cache_invalidated = TRUE;
+  the_display->monitor_cache_invalidated = TRUE;
 
   the_display->groups_by_leader = NULL;
 
@@ -479,7 +561,6 @@ meta_display_open (void)
 #endif
 
   the_display->grab_op = META_GRAB_OP_NONE;
-  the_display->grab_wireframe_active = FALSE;
   the_display->grab_window = NULL;
   the_display->grab_screen = NULL;
   the_display->grab_resize_popup = NULL;
@@ -546,7 +627,6 @@ meta_display_open (void)
   meta_verbose ("Not compiled with Shape support\n");
 #endif /* !HAVE_SHAPE */
 
-#ifdef HAVE_RENDER
   {
     the_display->have_render = FALSE;
     
@@ -567,11 +647,7 @@ meta_display_open (void)
                   the_display->render_error_base,
                   the_display->render_event_base);
   }
-#else  /* HAVE_RENDER */
-  meta_verbose ("Not compiled with Render support\n");
-#endif /* !HAVE_RENDER */
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
   {
     the_display->have_composite = FALSE;
 
@@ -647,9 +723,6 @@ meta_display_open (void)
                   the_display->xfixes_error_base, 
                   the_display->xfixes_event_base);
   }
-#else /* HAVE_COMPOSITE_EXTENSIONS */
-  meta_verbose ("Not compiled with Composite support\n");
-#endif /* !HAVE_COMPOSITE_EXTENSIONS */
       
 #ifdef HAVE_XCURSOR
   {
@@ -682,6 +755,13 @@ meta_display_open (void)
                                     the_display->leader_window,
                                     the_display->atom__NET_WM_NAME,
                                     "Mutter");
+
+    /* The GNOME keybindings capplet should include both the Mutter and Metacity
+     * keybindings */
+    meta_prop_set_utf8_string_hint (the_display,
+                                    the_display->leader_window,
+                                    the_display->atom__GNOME_WM_KEYBINDINGS,
+                                    "Mutter,Metacity");
     
     meta_prop_set_utf8_string_hint (the_display,
                                     the_display->leader_window,
@@ -812,15 +892,6 @@ meta_display_open (void)
   return TRUE;
 }
 
-static void
-listify_func (gpointer key, gpointer value, gpointer data)
-{
-  GSList **listp;
-
-  listp = data;
-  *listp = g_slist_prepend (*listp, value);
-}
-
 static gint
 ptrcmp (gconstpointer a, gconstpointer b)
 {
@@ -832,17 +903,38 @@ ptrcmp (gconstpointer a, gconstpointer b)
     return 0;
 }
 
+/**
+ * meta_display_list_windows:
+ * @display: a #MetaDisplay
+ * @flags: options for listing
+ *
+ * Lists windows for the display, the @flags parameter for
+ * now determines whether override-redirect windows will be
+ * included.
+ *
+ * Return value: (transfer container): the list of windows.
+ */
 GSList*
-meta_display_list_windows (MetaDisplay *display)
+meta_display_list_windows (MetaDisplay          *display,
+                           MetaListWindowsFlags  flags)
 {
   GSList *winlist;
   GSList *tmp;
   GSList *prev;
-  
+  GHashTableIter iter;
+  gpointer key, value;
+
   winlist = NULL;
-  g_hash_table_foreach (display->window_ids,
-                        listify_func,
-                        &winlist);
+
+  g_hash_table_iter_init (&iter, display->window_ids);
+  while (g_hash_table_iter_next (&iter, &key, &value))
+    {
+      MetaWindow *window = value;
+
+      if (!window->override_redirect ||
+          (flags & META_LIST_INCLUDE_OVERRIDE_REDIRECT) != 0)
+        winlist = g_slist_prepend (winlist, window);
+    }
 
   /* Uniquify the list, since both frame windows and plain
    * windows are in the hash
@@ -955,6 +1047,7 @@ meta_display_close (MetaDisplay *display,
     meta_compositor_destroy (display->compositor);
   
   g_object_unref (display);
+  the_display = NULL;
 
   meta_quit (META_EXIT_SUCCESS);
 }
@@ -1146,6 +1239,7 @@ grab_op_is_mouse (MetaGrabOp op)
     case META_GRAB_OP_KEYBOARD_RESIZING_SW:
     case META_GRAB_OP_KEYBOARD_RESIZING_NW:
     case META_GRAB_OP_KEYBOARD_MOVING:
+    case META_GRAB_OP_COMPOSITOR:
       return TRUE;
 
     default:
@@ -1175,6 +1269,7 @@ grab_op_is_keyboard (MetaGrabOp op)
     case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK:
     case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP:
     case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING:
+    case META_GRAB_OP_COMPOSITOR:
       return TRUE;
 
     default:
@@ -1456,6 +1551,7 @@ event_callback (XEvent   *event,
   MetaDisplay *display;
   Window modified;
   gboolean frame_was_receiver;
+  gboolean bypass_compositor;
   gboolean filter_out_event;
 
   display = data;
@@ -1469,9 +1565,10 @@ event_callback (XEvent   *event,
   sn_display_process_event (display->sn_display, event);
 #endif
   
+  bypass_compositor = FALSE;
   filter_out_event = FALSE;
   display->current_time = event_get_time (display, event);
-  display->xinerama_cache_invalidated = TRUE;
+  display->monitor_cache_invalidated = TRUE;
   
   modified = event_get_modified_window (display, event);
   
@@ -1615,21 +1712,26 @@ event_callback (XEvent   *event,
     {
     case KeyPress:
     case KeyRelease:
-      meta_display_process_key_event (display, window, event);
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
+      /* For key events, it's important to enforce single-handling, or
+       * we can get into a confused state. So if a keybinding is
+       * handled (because it's one of our hot-keys, or because we are
+       * in a keyboard-grabbed mode like moving a window, we don't
+       * want to pass the key event to the compositor at all.
+       */
+      bypass_compositor = meta_display_process_key_event (display, window, event);
       break;
     case ButtonPress:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
       if (event->xbutton.button == 4 || event->xbutton.button == 5)
-        {
-          if (display->compositor && window)
-            {
-              return meta_compositor_process_event (display->compositor,
-                                                    event,
-                                                    window);
-            }
-          else
-            return FALSE;
-        }
-      else if ((window &&
+        /* Scrollwheel event, do nothing and deliver event to compositor below */
+        break;
+
+      if ((window &&
            grab_op_is_mouse (display->grab_op) &&
            display->grab_button != (int) event->xbutton.button &&
            display->grab_window == window) ||
@@ -1819,16 +1921,25 @@ event_callback (XEvent   *event,
         }
       break;
     case ButtonRelease:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
       if (display->grab_window == window &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       break;
     case MotionNotify:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
       if (display->grab_window == window &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
       break;
     case EnterNotify:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
       if (display->grab_window == window &&
           grab_op_is_mouse (display->grab_op))
         {
@@ -1921,6 +2032,9 @@ event_callback (XEvent   *event,
         }
       break;
     case LeaveNotify:
+      if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+        break;
+
       if (display->grab_window == window &&
           grab_op_is_mouse (display->grab_op))
         meta_window_handle_mouse_grab_op_event (window, event);
@@ -2007,9 +2121,27 @@ event_callback (XEvent   *event,
     case VisibilityNotify:
       break;
     case CreateNotify:
+      {
+        MetaScreen *screen;
+
+        screen = meta_display_screen_for_root (display,
+                                               event->xcreatewindow.parent);
+        if (screen)
+          meta_stack_tracker_create_event (screen->stack_tracker,
+                                           &event->xcreatewindow);
+      }
       break;
       
     case DestroyNotify:
+      {
+        MetaScreen *screen;
+
+        screen = meta_display_screen_for_root (display,
+                                               event->xdestroywindow.event);
+        if (screen)
+          meta_stack_tracker_destroy_event (screen->stack_tracker,
+                                            &event->xdestroywindow);
+      }
       if (window)
         {
           /* FIXME: It sucks that DestroyNotify events don't come with
@@ -2062,9 +2194,6 @@ event_callback (XEvent   *event,
                               "Window %s withdrawn\n",
                               window->desc);
 
-		  if (!window->override_redirect)
-		    meta_effect_run_close (window, NULL, NULL);
-
                   /* Unmanage withdrawn window */		  
                   window->withdrawn = TRUE;
                   meta_window_unmanage (window, timestamp);
@@ -2123,8 +2252,30 @@ event_callback (XEvent   *event,
         }
       break;
     case ReparentNotify:
+      {
+        MetaScreen *screen;
+
+        screen = meta_display_screen_for_root (display,
+                                               event->xconfigure.event);
+        if (screen)
+          {
+            if (screen)
+              meta_stack_tracker_reparent_event (screen->stack_tracker,
+                                                 &event->xreparent);
+          }
+      }
       break;
     case ConfigureNotify:
+      if (event->xconfigure.event != event->xconfigure.window)
+        {
+          MetaScreen *screen;
+
+          screen = meta_display_screen_for_root (display,
+                                                 event->xconfigure.event);
+          if (screen)
+            meta_stack_tracker_configure_event (screen->stack_tracker,
+                                                &event->xconfigure);
+        }
       if (window && window->override_redirect)
 	meta_window_configure_notify (window, &event->xconfigure);
       else
@@ -2438,7 +2589,7 @@ event_callback (XEvent   *event,
 	    {
 	    case XkbBellNotify:
               if (XSERVER_TIME_IS_BEFORE(display->last_bell_time,
-                                         xkb_ev->time - 1000))
+                                         xkb_ev->time - 100))
                 {
                   display->last_bell_time = xkb_ev->time;
                   meta_bell_notify (display, xkb_ev);
@@ -2450,7 +2601,7 @@ event_callback (XEvent   *event,
       break;
     }
 
-  if (display->compositor)
+  if (display->compositor && !bypass_compositor)
     {
       if (meta_compositor_process_event (display->compositor,
                                          event,
@@ -3092,6 +3243,22 @@ meta_display_unregister_x_window (MetaDisplay *display,
   remove_pending_pings_for_window (display, xwindow);
 }
 
+void
+meta_display_notify_window_created (MetaDisplay  *display,
+                                    MetaWindow   *window)
+{
+  g_signal_emit (display, display_signals[WINDOW_CREATED], 0, window);
+}
+
+/**
+ * meta_display_xwindow_is_a_no_focus_window:
+ * @display: A #MetaDisplay
+ * @xwindow: An X11 window
+ *
+ * Returns %TRUE iff window is one of mutter's internal "no focus" windows
+ * (there is one per screen) which will have the focus when there is no
+ * actual client window focused.
+ */
 gboolean
 meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
                                            Window xwindow)
@@ -3303,16 +3470,6 @@ meta_display_begin_grab_op (MetaDisplay *display,
 {
   Window grab_xwindow;
   
-  if (grab_op_is_mouse (op) && meta_grab_op_is_moving (op))
-    {
-      if (display->compositor)
-	{
-	  meta_compositor_begin_move (display->compositor,
-				      window, &window->rect,
-				      root_x, root_y);
-	}
-    }
-  
   meta_topic (META_DEBUG_WINDOW_OPS,
               "Doing grab op %u on window %s button %d pointer already grabbed: %d pointer pos %d,%d\n",
               op, window ? window->desc : "none", button, pointer_already_grabbed,
@@ -3405,7 +3562,6 @@ meta_display_begin_grab_op (MetaDisplay *display,
   display->grab_sync_request_alarm = None;
   display->grab_last_user_action_was_snap = FALSE;
 #endif
-  display->grab_was_cancelled = FALSE;
   display->grab_frame_action = frame_action;
 
   if (display->grab_resize_timeout_id)
@@ -3420,20 +3576,8 @@ meta_display_begin_grab_op (MetaDisplay *display,
                                           &display->grab_initial_window_pos);
       display->grab_anchor_window_pos = display->grab_initial_window_pos;
 
-      display->grab_wireframe_active =
-        (meta_prefs_get_reduced_resources () && !meta_prefs_get_gnome_accessibility ())  && 
-        (meta_grab_op_is_resizing (display->grab_op) ||
-         meta_grab_op_is_moving (display->grab_op));
-      
-      if (display->grab_wireframe_active)
-        {
-          meta_window_calc_showing (display->grab_window);
-          meta_window_begin_wireframe (window);
-        }
-      
 #ifdef HAVE_XSYNC
-      if (!display->grab_wireframe_active &&
-          meta_grab_op_is_resizing (display->grab_op) &&
+      if ( meta_grab_op_is_resizing (display->grab_op) &&
           display->grab_window->sync_request_counter != None)
         {
           XSyncAlarmAttributes values;
@@ -3494,18 +3638,6 @@ meta_display_begin_grab_op (MetaDisplay *display,
   g_assert (display->grab_window != NULL || display->grab_screen != NULL);
   g_assert (display->grab_op != META_GRAB_OP_NONE);
 
-  /* If this is a move or resize, cache the window edges for
-   * resistance/snapping
-   */
-  if (meta_grab_op_is_resizing (display->grab_op) || 
-      meta_grab_op_is_moving (display->grab_op))
-    {
-      meta_topic (META_DEBUG_WINDOW_OPS,
-                  "Computing edges to resist-movement or snap-to for %s.\n",
-                  window->desc);
-      meta_display_compute_resistance_and_snapping_edges (display);
-    }
-
   /* Save the old stacking */
   if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
     {
@@ -3584,37 +3716,6 @@ meta_display_end_grab_op (MetaDisplay *display,
       display->grab_old_window_stacking = NULL;
     }
 
-  if (display->grab_wireframe_active)
-    {
-      display->grab_wireframe_active = FALSE;
-      meta_window_end_wireframe (display->grab_window);
-
-      if (!display->grab_was_cancelled)
-        {
-          if (meta_grab_op_is_moving (display->grab_op))
-            meta_window_move (display->grab_window,
-                              TRUE,
-                              display->grab_wireframe_rect.x,
-                              display->grab_wireframe_rect.y);
-          if (meta_grab_op_is_resizing (display->grab_op))
-            meta_window_resize_with_gravity (display->grab_window,
-                                             TRUE,
-                                             display->grab_wireframe_rect.width,
-                                             display->grab_wireframe_rect.height,
-                                             meta_resize_gravity_from_grab_op (display->grab_op));
-        }
-      meta_window_calc_showing (display->grab_window);
-    }
-
-  if (display->compositor &&
-      display->grab_window &&
-      grab_op_is_mouse (display->grab_op) && 
-      meta_grab_op_is_moving (display->grab_op))
-    {
-      meta_compositor_end_move (display->compositor,
-				display->grab_window);
-    }
-  
   if (display->grab_have_pointer)
     {
       meta_topic (META_DEBUG_WINDOW_OPS,
@@ -3659,6 +3760,21 @@ meta_display_end_grab_op (MetaDisplay *display,
     }
 }
 
+/**
+ * meta_display_get_grab_op:
+ * Gets the current grab operation, if any.
+ *
+ * Return value: the current grab operation, or %META_GRAB_OP_NONE if
+ * Mutter doesn't currently have a grab. %META_GRAB_OP_COMPOSITOR will
+ * be returned if a compositor-plugin modal operation is in effect
+ * (See mutter_begin_modal_for_plugin())
+ */
+MetaGrabOp
+meta_display_get_grab_op (MetaDisplay *display)
+{
+  return display->grab_op;
+}
+
 void
 meta_display_check_threshold_reached (MetaDisplay *display,
                                       int          x,
@@ -3931,7 +4047,7 @@ meta_display_queue_retheme_all_windows (MetaDisplay *display)
   GSList* windows;
   GSList *tmp;
 
-  windows = meta_display_list_windows (display);
+  windows = meta_display_list_windows (display, META_LIST_DEFAULT);
   tmp = windows;
   while (tmp != NULL)
     {
@@ -4025,7 +4141,7 @@ meta_set_syncing (gboolean setting)
  * How long, in milliseconds, we should wait after pinging a window
  * before deciding it's not going to get back to us.
  */
-#define PING_TIMEOUT_DELAY 2250
+#define PING_TIMEOUT_DELAY 5000
 
 /**
  * Does whatever it is we decided to do when a window didn't respond
@@ -4441,7 +4557,7 @@ meta_display_get_tab_list (MetaDisplay   *display,
     GSList *tmp;
     MetaWindow *l_window;
 
-    tmp = meta_display_list_windows (display);
+    tmp = meta_display_list_windows (display, META_LIST_DEFAULT);
 
     /* Go through all windows */
     while (tmp != NULL)
@@ -4450,7 +4566,8 @@ meta_display_get_tab_list (MetaDisplay   *display,
 
         /* Check to see if it demands attention */
         if (l_window->wm_state_demands_attention && 
-            l_window->workspace!=workspace) 
+            l_window->workspace!=workspace &&
+            IN_TAB_CHAIN (l_window, type)) 
           {
             /* if it does, add it to the popup */
             tab_list = g_list_prepend (tab_list, l_window);
@@ -4500,7 +4617,7 @@ meta_display_get_tab_next (MetaDisplay   *display,
   else
     {
       skip = display->focus_window != NULL && 
-             IN_TAB_CHAIN (display->focus_window, type);
+             tab_list->data == display->focus_window;
       if (backward)
         ret = find_tab_backward (display, type, screen, workspace,
                                  tab_list, skip);
@@ -4824,7 +4941,8 @@ meta_display_unmanage_windows_for_screen (MetaDisplay *display,
   GSList *tmp;
   GSList *winlist;
 
-  winlist = meta_display_list_windows (display);
+  winlist = meta_display_list_windows (display,
+                                       META_LIST_INCLUDE_OVERRIDE_REDIRECT);
   winlist = g_slist_sort (winlist, meta_display_stack_cmp);
 
   /* Unmanage all windows */
@@ -4916,7 +5034,7 @@ prefs_changed_callback (MetaPreference pref,
       GSList *windows;
       GSList *tmp;
       
-      windows = meta_display_list_windows (display);
+      windows = meta_display_list_windows (display, META_LIST_DEFAULT);
       
       /* Ungrab all */
       tmp = windows;
@@ -5018,7 +5136,7 @@ sanity_check_timestamps (MetaDisplay *display,
                     display->last_user_time, timestamp);
       display->last_user_time = timestamp;
 
-      windows = meta_display_list_windows (display);
+      windows = meta_display_list_windows (display, META_LIST_DEFAULT);
       tmp = windows;
       while (tmp != NULL)
         {
@@ -5029,9 +5147,9 @@ sanity_check_timestamps (MetaDisplay *display,
               meta_warning ("%s appears to be one of the offending windows "
                             "with a timestamp of %u.  Working around...\n",
                             window->desc, window->net_wm_user_time);
-              window->net_wm_user_time = timestamp;
+              meta_window_set_user_time (window, timestamp);
             }
-          
+
           tmp = tmp->next;
         }
 
@@ -5151,7 +5269,6 @@ meta_display_overlay_key_activate (MetaDisplay *display)
   g_signal_emit (display, display_signals[OVERLAY_KEY], 0);
 }
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 void
 meta_display_get_compositor_version (MetaDisplay *display,
                                      int         *major,
@@ -5160,7 +5277,6 @@ meta_display_get_compositor_version (MetaDisplay *display,
   *major = display->composite_major_version;
   *minor = display->composite_minor_version;
 }
-#endif
 
 Display *
 meta_display_get_xdisplay (MetaDisplay *display)
@@ -5204,15 +5320,12 @@ meta_display_get_focus_window (MetaDisplay *display)
   return display->focus_window;
 }
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 int 
 meta_display_get_damage_event_base (MetaDisplay *display)
 {
   return display->damage_event_base;
 }
-#endif
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 #ifdef HAVE_SHAPE
 int
 meta_display_get_shape_event_base (MetaDisplay *display)
@@ -5220,7 +5333,6 @@ meta_display_get_shape_event_base (MetaDisplay *display)
   return display->shape_event_base;
 }
 #endif
-#endif
 
 Atom meta_display_get_atom (MetaDisplay *display, MetaAtom meta_atom)
 {

src/core/edge-resistance.c

@@ -63,6 +63,8 @@ struct MetaEdgeResistanceData
   ResistanceDataForAnEdge bottom_data;
 };
 
+static void compute_resistance_and_snapping_edges (MetaDisplay *display);
+
 /* !WARNING!: this function can return invalid indices (namely, either -1 or
  * edges->len); this is by design, but you need to remember this.
  */
@@ -340,12 +342,12 @@ apply_edge_resistance (MetaWindow                *window,
 
   const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_WINDOW    = 16;
   const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW   =  0;
-  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA  = 32;
-  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA =  0;
+  const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR   = 32;
+  const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR  =  0;
   const int PIXEL_DISTANCE_THRESHOLD_TOWARDS_SCREEN    = 32;
   const int PIXEL_DISTANCE_THRESHOLD_AWAYFROM_SCREEN   =  0;
   const int TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW   =   0;
-  const int TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA =   0;
+  const int TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR =   0;
   const int TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN   =   0;
 
   /* Quit if no movement was specified */
@@ -423,8 +425,8 @@ apply_edge_resistance (MetaWindow                *window,
                 case META_EDGE_WINDOW:
                   timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_WINDOW;
                   break;
-                case META_EDGE_XINERAMA:
-                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_XINERAMA;
+                case META_EDGE_MONITOR:
+                  timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_MONITOR;
                   break;
                 case META_EDGE_SCREEN:
                   timeout_length_ms = TIMEOUT_RESISTANCE_LENGTH_MS_SCREEN;
@@ -468,11 +470,11 @@ apply_edge_resistance (MetaWindow                *window,
               else
                 threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_WINDOW;
               break;
-            case META_EDGE_XINERAMA:
+            case META_EDGE_MONITOR:
               if (movement_towards_edge (edge->side_type, increment))
-                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_XINERAMA;
+                threshold = PIXEL_DISTANCE_THRESHOLD_TOWARDS_MONITOR;
               else
-                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_XINERAMA;
+                threshold = PIXEL_DISTANCE_THRESHOLD_AWAYFROM_MONITOR;
               break;
             case META_EDGE_SCREEN:
               if (movement_towards_edge (edge->side_type, increment))
@@ -550,7 +552,9 @@ apply_edge_resistance_to_each_side (MetaDisplay         *display,
   gboolean                modified;
   int new_left, new_right, new_top, new_bottom;
 
-  g_assert (display->grab_edge_resistance_data != NULL);
+  if (display->grab_edge_resistance_data == NULL)
+    compute_resistance_and_snapping_edges (display);
+
   edge_data = display->grab_edge_resistance_data;
 
   if (auto_snap)
@@ -671,7 +675,8 @@ meta_display_cleanup_edges (MetaDisplay *display)
   MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data;
   GHashTable *edges_to_be_freed;
 
-  g_assert (edge_data != NULL);
+  if (edge_data == NULL) /* Not currently cached */
+    return;
 
   /* We first need to clean out any window edges */
   edges_to_be_freed = g_hash_table_new_full (g_direct_hash, g_direct_equal,
@@ -761,7 +766,7 @@ stupid_sort_requiring_extra_pointer_dereference (gconstpointer a,
 static void
 cache_edges (MetaDisplay *display,
              GList *window_edges,
-             GList *xinerama_edges,
+             GList *monitor_edges,
              GList *screen_edges)
 {
   MetaEdgeResistanceData *edge_data;
@@ -776,7 +781,7 @@ cache_edges (MetaDisplay *display,
   if (meta_is_verbose())
     {
       int max_edges = MAX (MAX( g_list_length (window_edges), 
-                                g_list_length (xinerama_edges)),
+                                g_list_length (monitor_edges)),
                            g_list_length (screen_edges));
       char big_buffer[(EDGE_LENGTH+2)*max_edges];
 
@@ -784,9 +789,9 @@ cache_edges (MetaDisplay *display,
       meta_topic (META_DEBUG_EDGE_RESISTANCE,
                   "Window edges for resistance  : %s\n", big_buffer);
 
-      meta_rectangle_edge_list_to_string (xinerama_edges, ", ", big_buffer);
+      meta_rectangle_edge_list_to_string (monitor_edges, ", ", big_buffer);
       meta_topic (META_DEBUG_EDGE_RESISTANCE,
-                  "Xinerama edges for resistance: %s\n", big_buffer);
+                  "Monitor edges for resistance: %s\n", big_buffer);
 
       meta_rectangle_edge_list_to_string (screen_edges, ", ", big_buffer);
       meta_topic (META_DEBUG_EDGE_RESISTANCE,
@@ -807,7 +812,7 @@ cache_edges (MetaDisplay *display,
           tmp = window_edges;
           break;
         case 1:
-          tmp = xinerama_edges;
+          tmp = monitor_edges;
           break;
         case 2:
           tmp = screen_edges;
@@ -844,7 +849,7 @@ cache_edges (MetaDisplay *display,
    * 2nd: Allocate the edges
    */
   g_assert (display->grab_edge_resistance_data == NULL);
-  display->grab_edge_resistance_data = g_new (MetaEdgeResistanceData, 1);
+  display->grab_edge_resistance_data = g_new0 (MetaEdgeResistanceData, 1);
   edge_data = display->grab_edge_resistance_data;
   edge_data->left_edges   = g_array_sized_new (FALSE,
                                                FALSE,
@@ -875,7 +880,7 @@ cache_edges (MetaDisplay *display,
           tmp = window_edges;
           break;
         case 1:
-          tmp = xinerama_edges;
+          tmp = monitor_edges;
           break;
         case 2:
           tmp = screen_edges;
@@ -938,8 +943,8 @@ initialize_grab_edge_resistance_data (MetaDisplay *display)
   edge_data->bottom_data.keyboard_buildup = 0;
 }
 
-void
-meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
+static void
+compute_resistance_and_snapping_edges (MetaDisplay *display)
 {
   GList *stacked_windows;
   GList *cur_window_iter;
@@ -952,6 +957,11 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
    */
   GSList *rem_windows, *rem_win_stacking;
 
+  g_assert (display->grab_window != NULL);
+  meta_topic (META_DEBUG_WINDOW_OPS,
+              "Computing edges to resist-movement or snap-to for %s.\n",
+              display->grab_window->desc);
+
   /*
    * 1st: Get the list of relevant windows, from bottom to top
    */
@@ -1110,12 +1120,12 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display)
 
   /*
    * 5th: Cache the combination of these edges with the onscreen and
-   * xinerama edges in an array for quick access.  Free the edges since
+   * monitor edges in an array for quick access.  Free the edges since
    * they've been cached elsewhere.
    */
   cache_edges (display,
                edges,
-               display->grab_screen->active_workspace->xinerama_edges,
+               display->grab_screen->active_workspace->monitor_edges,
                display->grab_screen->active_workspace->screen_edges);
   g_list_free (edges);
 
@@ -1141,17 +1151,8 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
   MetaRectangle old_outer, proposed_outer, new_outer;
   gboolean is_resize;
 
-  if (window == window->display->grab_window &&
-      window->display->grab_wireframe_active)
-    {
-      meta_window_get_xor_rect (window,
-                                &window->display->grab_wireframe_rect,
-                                &old_outer);
-    }
-  else
-    {
-      meta_window_get_outer_rect (window, &old_outer);
-    }
+  meta_window_get_outer_rect (window, &old_outer);
+
   proposed_outer = old_outer;
   proposed_outer.x += (*new_x - old_x);
   proposed_outer.y += (*new_y - old_y);
@@ -1236,17 +1237,7 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
   int proposed_outer_width, proposed_outer_height;
   gboolean is_resize;
 
-  if (window == window->display->grab_window &&
-      window->display->grab_wireframe_active)
-    {
-      meta_window_get_xor_rect (window,
-                                &window->display->grab_wireframe_rect,
-                                &old_outer);
-    }
-  else
-    {
-      meta_window_get_outer_rect (window, &old_outer);
-    }
+  meta_window_get_outer_rect (window, &old_outer);
   proposed_outer_width  = old_outer.width  + (*new_width  - old_width);
   proposed_outer_height = old_outer.height + (*new_height - old_height);
   meta_rectangle_resize_with_gravity (&old_outer, 

src/core/effects.c

@@ -1,735 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/**
- * \file effects.c "Special effects" other than compositor effects.
- * 
- * Before we had a serious compositor, we supported swooping
- * rectangles for minimising and so on.  These are still supported
- * today, even when the compositor is enabled.  The file contains two
- * parts:
- *
- *  1) A set of functions, each of which implements a special effect.
- *     (Only the minimize function does anything interesting; we should
- *      probably get rid of the rest.)
- *
- *  2) A set of functions for moving a highlighted wireframe box around
- *     the screen, optionally with height and width shown in the middle.
- *     This is used for moving and resizing when reduced_resources is set.
- *
- * There was formerly a system which allowed callers to drop in their
- * own handlers for various things; it was never used (people who want
- * their own handlers can just modify this file, after all) and it added
- * a good deal of extra complexity, so it has been removed.  If you want it,
- * it can be found in svn r3769.
- *
- * Once upon a time there were three different ways of drawing the box
- * animation: window wireframe, window opaque, and root. People who had
- * the shape extension theoretically had the choice of all three, and
- * people who didn't weren't given the choice of the wireframe option.
- * In practice, though, the opaque animation was never perfect, so it came
- * down to the wireframe option for those who had the extension and
- * the root option for those who didn't; there was actually no way of choosing
- * any other option anyway.  Work on the opaque animation stopped in 2002;
- * anyone who wants something like that these days will be using the
- * compositor anyway.
- *
- * In svn r3769 this was made explicit.
- */
-
-/* 
- * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
- * 
- * 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 <config.h>
-#include "effects.h"
-#include "display-private.h"
-#include "ui.h"
-#include "window-private.h"
-#include "prefs.h"
-
-#ifdef HAVE_SHAPE
-#include <X11/extensions/shape.h>
-#endif
-
-#define META_MINIMIZE_ANIMATION_LENGTH 0.25
-#define META_SHADE_ANIMATION_LENGTH 0.2
-
-#include <string.h>
-
-typedef struct MetaEffect MetaEffect;
-typedef struct MetaEffectPriv MetaEffectPriv;
-
-typedef struct
-{
-  MetaScreen *screen;
-
-  double millisecs_duration;
-  GTimeVal start_time;
-
-#ifdef HAVE_SHAPE
-  /** For wireframe window */
-  Window wireframe_xwindow;
-#else
-  /** Rectangle to erase */
-  MetaRectangle last_rect;
-
-  /** First time we've plotted anything in this animation? */
-  gboolean first_time;
-
-  /** For wireframe drawn on root window */
-  GC gc;
-#endif
-
-  MetaRectangle start_rect;
-  MetaRectangle end_rect;
-  
-} BoxAnimationContext;
-
-/**
- * Information we need to know during a maximise or minimise effect.
- */
-typedef struct
-{
-  /** This is the normal-size window. */
-  MetaRectangle window_rect;
-  /** This is the size of the window when it's an icon. */
-  MetaRectangle icon_rect;
-} MetaMinimizeEffect, MetaUnminimizeEffect;
-
-struct MetaEffectPriv
-{
-  MetaEffectFinished finished;
-  gpointer           finished_data;
-};
-
-struct MetaEffect
-{
-  /** The window the effect is applied to. */
-  MetaWindow *window;
-  /** Which effect is happening here. */
-  MetaEffectType type;
-  /** The effect handler can hang data here. */
-  gpointer info;
-
-  union
-  {
-    MetaMinimizeEffect      minimize;
-    /* ... and theoretically anything else */
-  } u;
-  
-  MetaEffectPriv *priv;
-};
-
-static void run_default_effect_handler (MetaEffect *effect);
-static void run_handler (MetaEffect *effect);
-static void effect_free (MetaEffect *effect);
-
-static MetaEffect *
-create_effect (MetaEffectType      type,
-               MetaWindow         *window,
-               MetaEffectFinished  finished,
-               gpointer            finished_data);
-
-static void
-draw_box_animation (MetaScreen     *screen,
-                    MetaRectangle  *initial_rect,
-                    MetaRectangle  *destination_rect,
-                    double          seconds_duration);
-
-/**
- * Creates an effect.
- *
- */
-static MetaEffect*
-create_effect (MetaEffectType      type,
-               MetaWindow         *window,
-               MetaEffectFinished  finished,
-               gpointer            finished_data)
-{
-    MetaEffect *effect = g_new (MetaEffect, 1);
-
-    effect->type = type;
-    effect->window = window;
-    effect->priv = g_new (MetaEffectPriv, 1);
-    effect->priv->finished = finished;
-    effect->priv->finished_data = finished_data;
-
-    return effect;
-}
-
-/**
- * Destroys an effect.  If the effect has a "finished" hook, it will be
- * called before cleanup.
- *
- * \param effect  The effect.
- */
-static void
-effect_free (MetaEffect *effect)
-{
-  if (effect->priv->finished)
-    effect->priv->finished (effect->priv->finished_data);
-    
-  g_free (effect->priv);
-  g_free (effect);
-}
-
-void
-meta_effect_run_focus (MetaWindow	    *window,
-		       MetaEffectFinished   finished,
-		       gpointer		    data)
-{
-    MetaEffect *effect;
-
-    g_return_if_fail (window != NULL);
-
-    effect = create_effect (META_EFFECT_FOCUS, window, finished, data);
-    
-    run_handler (effect);
-}
-
-void
-meta_effect_run_minimize (MetaWindow         *window,
-                          MetaRectangle      *window_rect,
-                          MetaRectangle      *icon_rect,
-                          MetaEffectFinished  finished,
-                          gpointer            data)
-{
-    MetaEffect *effect;
-
-    g_return_if_fail (window != NULL);
-    g_return_if_fail (icon_rect != NULL);
-    
-    effect = create_effect (META_EFFECT_MINIMIZE, window, finished, data);
-
-    effect->u.minimize.window_rect = *window_rect;
-    effect->u.minimize.icon_rect = *icon_rect;
-
-    run_handler (effect);
-}
-
-void
-meta_effect_run_unminimize (MetaWindow         *window,
-                            MetaRectangle      *window_rect,
-                            MetaRectangle      *icon_rect,
-                            MetaEffectFinished  finished,
-                            gpointer            data)
-{
-    MetaEffect *effect;
-
-    g_return_if_fail (window != NULL);
-    g_return_if_fail (icon_rect != NULL);
-    
-    effect = create_effect (META_EFFECT_UNMINIMIZE, window, finished, data);
-
-    effect->u.minimize.window_rect = *window_rect;
-    effect->u.minimize.icon_rect = *icon_rect;
-
-    run_handler (effect);
-}
-
-void
-meta_effect_run_close (MetaWindow         *window,
-		       MetaEffectFinished  finished,
-		       gpointer            data)
-{
-    MetaEffect *effect;
-    
-    g_return_if_fail (window != NULL);
-
-    effect = create_effect (META_EFFECT_CLOSE, window,
-                            finished, data);
-
-    run_handler (effect);
-}
-
-
-/* old ugly minimization effect */
-
-#ifdef HAVE_SHAPE  
-static void
-update_wireframe_window (MetaDisplay         *display,
-                         Window               xwindow,
-                         const MetaRectangle *rect)
-{
-  XMoveResizeWindow (display->xdisplay,
-                     xwindow,
-                     rect->x, rect->y,
-                     rect->width, rect->height);
-
-#define OUTLINE_WIDTH 3
-  
-  if (rect->width > OUTLINE_WIDTH * 2 &&
-      rect->height > OUTLINE_WIDTH * 2)
-    {
-      XRectangle xrect;
-      Region inner_xregion;
-      Region outer_xregion;
-      
-      inner_xregion = XCreateRegion ();
-      outer_xregion = XCreateRegion ();
-
-      xrect.x = 0;
-      xrect.y = 0;
-      xrect.width = rect->width;
-      xrect.height = rect->height;
-  
-      XUnionRectWithRegion (&xrect, outer_xregion, outer_xregion);
-  
-      xrect.x += OUTLINE_WIDTH;
-      xrect.y += OUTLINE_WIDTH;
-      xrect.width -= OUTLINE_WIDTH * 2;
-      xrect.height -= OUTLINE_WIDTH * 2;  
-  
-      XUnionRectWithRegion (&xrect, inner_xregion, inner_xregion);
-
-      XSubtractRegion (outer_xregion, inner_xregion, outer_xregion);
-
-      XShapeCombineRegion (display->xdisplay, xwindow,
-                           ShapeBounding, 0, 0, outer_xregion, ShapeSet);
-  
-      XDestroyRegion (outer_xregion);
-      XDestroyRegion (inner_xregion);
-    }
-  else
-    {
-      /* Unset the shape */
-      XShapeCombineMask (display->xdisplay, xwindow,
-                         ShapeBounding, 0, 0, None, ShapeSet);
-    }
-}
-#endif
-
-/**
- * A hack to force the X server to synchronize with the
- * graphics hardware.
- */
-static void
-graphics_sync (BoxAnimationContext *context)
-{
-  XImage *image;
-  
-  image = XGetImage (context->screen->display->xdisplay,
-                     context->screen->xroot,
-                     0, 0, 1, 1,
-                     AllPlanes, ZPixmap);
-
-  XDestroyImage (image);
-}
-
-static gboolean
-effects_draw_box_animation_timeout (BoxAnimationContext *context)
-{
-  double elapsed;
-  GTimeVal current_time;
-  MetaRectangle draw_rect;
-  double fraction;
-  
-#ifndef HAVE_SHAPE
-  if (!context->first_time)
-    {
-       /* Restore the previously drawn background */
-       XDrawRectangle (context->screen->display->xdisplay,
-                       context->screen->xroot,
-                       context->gc,
-                       context->last_rect.x, context->last_rect.y,
-                       context->last_rect.width, context->last_rect.height);
-    }
-  else
-    context->first_time = FALSE;
-
-#endif /* !HAVE_SHAPE */
-
-  g_get_current_time (&current_time);
-  
-  /* We use milliseconds for all times */
-  elapsed =
-    ((((double)current_time.tv_sec - context->start_time.tv_sec) * G_USEC_PER_SEC +
-      (current_time.tv_usec - context->start_time.tv_usec))) / 1000.0;
-  
-  if (elapsed < 0)
-    {
-      /* Probably the system clock was set backwards? */
-      meta_warning ("System clock seemed to go backwards?\n");
-      elapsed = G_MAXDOUBLE; /* definitely done. */
-    }
-
-  if (elapsed > context->millisecs_duration)
-    {
-      /* All done */
-#ifdef HAVE_SHAPE
-        XDestroyWindow (context->screen->display->xdisplay,
-                          context->wireframe_xwindow);
-#else
-        meta_display_ungrab (context->screen->display);
-        meta_ui_pop_delay_exposes (context->screen->ui);
-        XFreeGC (context->screen->display->xdisplay,
-                 context->gc);
-#endif /* !HAVE_SHAPE */
-
-      graphics_sync (context);
-      
-      g_free (context);
-      return FALSE;
-    }
-
-  g_assert (context->millisecs_duration > 0.0);
-  fraction = elapsed / context->millisecs_duration;
-  
-  draw_rect = context->start_rect;
-  
-  /* Now add a delta proportional to elapsed time. */
-  draw_rect.x += (context->end_rect.x - context->start_rect.x) * fraction;
-  draw_rect.y += (context->end_rect.y - context->start_rect.y) * fraction;
-  draw_rect.width += (context->end_rect.width - context->start_rect.width) * fraction;
-  draw_rect.height += (context->end_rect.height - context->start_rect.height) * fraction;
-  
-  /* don't confuse X or gdk-pixbuf with bogus rectangles */
-  if (draw_rect.width < 1)
-    draw_rect.width = 1;
-  if (draw_rect.height < 1)
-    draw_rect.height = 1;
-
-#ifdef HAVE_SHAPE
-  update_wireframe_window (context->screen->display,
-                           context->wireframe_xwindow,
-                           &draw_rect);
-#else
-  context->last_rect = draw_rect;
-
-  /* Draw the rectangle */
-  XDrawRectangle (context->screen->display->xdisplay,
-                  context->screen->xroot,
-                  context->gc,
-                  draw_rect.x, draw_rect.y,
-                  draw_rect.width, draw_rect.height);
-    
-#endif /* !HAVE_SHAPE */
-
-  /* kick changes onto the server */
-  graphics_sync (context);
-  
-  return TRUE;
-}
- 
-void
-draw_box_animation (MetaScreen     *screen,
-                    MetaRectangle  *initial_rect,
-                    MetaRectangle  *destination_rect,
-                    double          seconds_duration)
-{
-  BoxAnimationContext *context;
-
-#ifdef HAVE_SHAPE
-  XSetWindowAttributes attrs;
-#else
-  XGCValues gc_values;
-#endif
-    
-  g_return_if_fail (seconds_duration > 0.0);
-
-  if (g_getenv ("MUTTER_DEBUG_EFFECTS"))
-    seconds_duration *= 10; /* slow things down */
-  
-  /* Create the animation context */
-  context = g_new0 (BoxAnimationContext, 1);
-
-  context->screen = screen;
-
-  context->millisecs_duration = seconds_duration * 1000.0;
-
-  context->start_rect = *initial_rect;
-  context->end_rect = *destination_rect;
-
-#ifdef HAVE_SHAPE
-
-  attrs.override_redirect = True;
-  attrs.background_pixel = BlackPixel (screen->display->xdisplay,
-                                       screen->number);
-
-  context->wireframe_xwindow = XCreateWindow (screen->display->xdisplay,
-                                              screen->xroot,
-                                              initial_rect->x,
-                                              initial_rect->y,
-                                              initial_rect->width,
-                                              initial_rect->height,
-                                              0,
-                                              CopyFromParent,
-                                              CopyFromParent,
-                                              (Visual *)CopyFromParent,
-                                              CWOverrideRedirect | CWBackPixel,
-                                              &attrs);
-
-  update_wireframe_window (screen->display,
-                           context->wireframe_xwindow,
-                           initial_rect);
-
-  XMapWindow (screen->display->xdisplay,
-              context->wireframe_xwindow);
-
-#else /* !HAVE_SHAPE */
-
-  context->first_time = TRUE;
-  gc_values.subwindow_mode = IncludeInferiors;
-  gc_values.function = GXinvert;
-
-  context->gc = XCreateGC (screen->display->xdisplay,
-                           screen->xroot,
-                           GCSubwindowMode | GCFunction,
-                           &gc_values);
-      
-  /* Grab the X server to avoid screen dirt */
-  meta_display_grab (context->screen->display);
-  meta_ui_push_delay_exposes (context->screen->ui);
-#endif
-
-  /* Do this only after we get the pixbuf from the server,
-   * so that the animation doesn't get truncated.
-   */
-  g_get_current_time (&context->start_time);
-  
-  /* Add the timeout - a short one, could even use an idle,
-   * but this is maybe more CPU-friendly.
-   */
-  g_timeout_add (15,
-                 (GSourceFunc)effects_draw_box_animation_timeout,
-                 context);
-
-  /* kick changes onto the server */
-  XFlush (context->screen->display->xdisplay);  
-}
-
-void
-meta_effects_begin_wireframe (MetaScreen          *screen,
-                              const MetaRectangle *rect,
-                              int                  width,
-                              int                  height)
-{
-  /* Grab the X server to avoid screen dirt */
-  meta_display_grab (screen->display);
-  meta_ui_push_delay_exposes (screen->ui);  
-
-  meta_effects_update_wireframe (screen, 
-                                 NULL, -1, -1,
-                                 rect, width, height);
-}
-
-static void
-draw_xor_rect (MetaScreen          *screen,
-               const MetaRectangle *rect,
-               int                  width,
-               int                  height)
-{
-  /* The lines in the center can't overlap the rectangle or each
-   * other, or the XOR gets reversed. So we have to draw things
-   * a bit oddly.
-   */
-  XSegment segments[8];
-  MetaRectangle shrunk_rect;
-  int i;
-  
-#define LINE_WIDTH META_WIREFRAME_XOR_LINE_WIDTH
-
-  /* We don't want the wireframe going outside the window area.
-   * It makes it harder for the user to position windows and it exposes other
-   * annoying bugs.
-   */
-  shrunk_rect = *rect;
-
-  shrunk_rect.x += LINE_WIDTH / 2 + LINE_WIDTH % 2;
-  shrunk_rect.y += LINE_WIDTH / 2 + LINE_WIDTH % 2;
-  shrunk_rect.width -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
-  shrunk_rect.height -= LINE_WIDTH + 2 * (LINE_WIDTH % 2);
-
-  XDrawRectangle (screen->display->xdisplay,
-                  screen->xroot,
-                  screen->root_xor_gc,
-                  shrunk_rect.x, shrunk_rect.y,
-                  shrunk_rect.width, shrunk_rect.height);
-
-  /* Don't put lines inside small rectangles where they won't fit */
-  if (shrunk_rect.width < (LINE_WIDTH * 4) ||
-      shrunk_rect.height < (LINE_WIDTH * 4))
-    return;
-
-  if ((width >= 0) && (height >= 0))
-    {
-      XGCValues gc_values = { 0 };
-
-      if (XGetGCValues (screen->display->xdisplay,
-                        screen->root_xor_gc, 
-                        GCFont, &gc_values))
-        {
-          char *text;
-          int text_length;
-
-          XFontStruct *font_struct;
-          int text_width, text_height; 
-          int box_x, box_y;
-          int box_width, box_height;
-
-          font_struct = XQueryFont (screen->display->xdisplay,
-                                    gc_values.font);
-
-          if (font_struct != NULL)
-            {
-              text = g_strdup_printf ("%d x %d", width, height);
-              text_length = strlen (text);
-
-              text_width = text_length * font_struct->max_bounds.width;
-              text_height = font_struct->max_bounds.descent + 
-                            font_struct->max_bounds.ascent;
-
-              box_width = text_width + 2 * LINE_WIDTH;
-              box_height = text_height + 2 * LINE_WIDTH;
-
-
-              box_x = shrunk_rect.x + (shrunk_rect.width - box_width) / 2;
-              box_y = shrunk_rect.y + (shrunk_rect.height - box_height) / 2;
-
-              if ((box_width < shrunk_rect.width) &&
-                  (box_height < shrunk_rect.height))
-                {
-                  XFillRectangle (screen->display->xdisplay,
-                                  screen->xroot,
-                                  screen->root_xor_gc,
-                                  box_x, box_y,
-                                  box_width, box_height);
-                  XDrawString (screen->display->xdisplay, 
-                               screen->xroot,
-                               screen->root_xor_gc,
-                               box_x + LINE_WIDTH,
-                               box_y + LINE_WIDTH + font_struct->max_bounds.ascent,
-                               text, text_length);
-                }
-
-              g_free (text);
-
-              XFreeFontInfo (NULL, font_struct, 1);
-
-              if ((box_width + LINE_WIDTH) >= (shrunk_rect.width / 3))
-                return;
-
-              if ((box_height + LINE_WIDTH) >= (shrunk_rect.height / 3))
-                return;
-            }
-        }
-    }
-
-  /* Two vertical lines at 1/3 and 2/3 */
-  segments[0].x1 = shrunk_rect.x + shrunk_rect.width / 3;
-  segments[0].y1 = shrunk_rect.y + LINE_WIDTH / 2 + LINE_WIDTH % 2;
-  segments[0].x2 = segments[0].x1;
-  segments[0].y2 = shrunk_rect.y + shrunk_rect.height - LINE_WIDTH / 2;  
-
-  segments[1] = segments[0];
-  segments[1].x1 = shrunk_rect.x + (shrunk_rect.width / 3) * 2;
-  segments[1].x2 = segments[1].x1;
-
-  /* Now make two horizontal lines at 1/3 and 2/3, but not
-   * overlapping the verticals
-   */
-
-  segments[2].x1 = shrunk_rect.x + LINE_WIDTH / 2 + LINE_WIDTH % 2;
-  segments[2].x2 = segments[0].x1 - LINE_WIDTH / 2;
-  segments[2].y1 = shrunk_rect.y + shrunk_rect.height / 3;
-  segments[2].y2 = segments[2].y1;
-
-  segments[3] = segments[2];
-  segments[3].x1 = segments[2].x2 + LINE_WIDTH;
-  segments[3].x2 = segments[1].x1 - LINE_WIDTH / 2;
-  
-  segments[4] = segments[3];
-  segments[4].x1 = segments[3].x2 + LINE_WIDTH;
-  segments[4].x2 = shrunk_rect.x + shrunk_rect.width - LINE_WIDTH / 2;
-
-  /* Second horizontal line is just like the first, but
-   * shifted down
-   */
-  i = 5;
-  while (i < 8)
-    {
-      segments[i] = segments[i - 3];
-      segments[i].y1 = shrunk_rect.y + (shrunk_rect.height / 3) * 2;
-      segments[i].y2 = segments[i].y1;
-      ++i;
-    }
-  
-  XDrawSegments (screen->display->xdisplay,
-                 screen->xroot,
-                 screen->root_xor_gc,
-                 segments,
-                 G_N_ELEMENTS (segments));
-}
-
-void
-meta_effects_update_wireframe (MetaScreen          *screen,
-                               const MetaRectangle *old_rect,
-                               int                  old_width,
-                               int                  old_height,
-                               const MetaRectangle *new_rect,
-                               int                  new_width,
-                               int                  new_height)
-{
-  if (old_rect)
-    draw_xor_rect (screen, old_rect, old_width, old_height);
-    
-  if (new_rect)
-    draw_xor_rect (screen, new_rect, new_width, new_height);
-    
-  XFlush (screen->display->xdisplay);
-}
-
-void
-meta_effects_end_wireframe (MetaScreen          *screen,
-                            const MetaRectangle *old_rect,
-                            int                  old_width,
-                            int                  old_height)
-{
-  meta_effects_update_wireframe (screen, 
-                                 old_rect, old_width, old_height,
-                                 NULL, -1, -1);
-  
-  meta_display_ungrab (screen->display);
-  meta_ui_pop_delay_exposes (screen->ui);
-}
-
-static void
-run_default_effect_handler (MetaEffect *effect)
-{
-    switch (effect->type)
-    {
-    case META_EFFECT_MINIMIZE:
-       draw_box_animation (effect->window->screen,
-                     &(effect->u.minimize.window_rect),
-                     &(effect->u.minimize.icon_rect),
-                     META_MINIMIZE_ANIMATION_LENGTH);
-       break;
-
-    default:
-       break;
-    }
-}
-
-static void
-run_handler (MetaEffect *effect)
-{
-  if (meta_prefs_get_gnome_animations ())
-    run_default_effect_handler (effect);
-
-  effect_free (effect);
-}

src/core/effects.h

@@ -1,170 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/**
- * \file effects.h "Special effects" other than compositor effects.
- * 
- * Before we had a serious compositor, we supported swooping
- * rectangles for minimising and so on.  These are still supported
- * today, even when the compositor is enabled.  The file contains two
- * parts:
- *
- *  1) A set of functions, each of which implements a special effect.
- *     (Only the minimize function does anything interesting; we should
- *      probably get rid of the rest.)
- *
- *  2) A set of functions for moving a highlighted wireframe box around
- *     the screen, optionally with height and width shown in the middle.
- *     This is used for moving and resizing when reduced_resources is set.
- *
- * There was formerly a system which allowed callers to drop in their
- * own handlers for various things; it was never used (people who want
- * their own handlers can just modify this file, after all) and it added
- * a good deal of extra complexity, so it has been removed.  If you want it,
- * it can be found in svn r3769.
- */
-
-/* 
- * Copyright (C) 2001 Anders Carlsson, Havoc Pennington
- * 
- * 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_EFFECTS_H
-#define META_EFFECTS_H
-
-#include "util.h"
-#include "screen-private.h"
-
-typedef enum
-{
-  META_EFFECT_MINIMIZE,
-  META_EFFECT_UNMINIMIZE,
-  META_EFFECT_FOCUS,
-  META_EFFECT_CLOSE,
-  META_NUM_EFFECTS
-} MetaEffectType;
-
-/**
- * A callback which will be called when the effect has finished.
- */
-typedef void (* MetaEffectFinished) (gpointer    data);
-
-/**
- * Performs the minimize effect.
- *
- * \param window       The window we're moving
- * \param window_rect  Its current state
- * \param target       Where it should end up
- * \param finished     Callback for when it's finished
- * \param data         Data for callback
- */
-void        meta_effect_run_minimize     (MetaWindow         *window,
-                                          MetaRectangle	     *window_rect,
-                                          MetaRectangle	     *target,
-                                          MetaEffectFinished  finished,
-                                          gpointer            data);
-
-/**
- * Performs the unminimize effect.  There is no such effect.
- * FIXME: delete this.
- *
- * \param window       The window we're moving
- * \param icon_rect    Its current state
- * \param window_rect  Where it should end up
- * \param finished     Callback for when it's finished
- * \param data         Data for callback
- */
-void        meta_effect_run_unminimize (MetaWindow         *window,
-                                          MetaRectangle      *window_rect,
-                                          MetaRectangle      *icon_rect,
-                                          MetaEffectFinished  finished,
-                                          gpointer            data);
-
-/**
- * Performs the close effect.  There is no such effect.
- * FIXME: delete this.
- *
- * \param window       The window we're moving
- * \param finished     Callback for when it's finished
- * \param data         Data for callback
- */
-void        meta_effect_run_close        (MetaWindow         *window,
-                                          MetaEffectFinished  finished,
-                                          gpointer            data);
-
-/**
- * Performs the focus effect.  There is no such effect.
- * FIXME: delete this.
- *
- * \param window       The window we're moving
- * \param finished     Callback for when it's finished
- * \param data         Data for callback
- */
-void        meta_effect_run_focus        (MetaWindow         *window,
-                                          MetaEffectFinished  finished,
-                                          gpointer            data);
-
-/**
- * Grabs the server and paints a wireframe rectangle on the screen.
- * Since this involves starting a grab, please be considerate of other
- * users and don't keep the grab for long.  You may move the wireframe
- * around using meta_effects_update_wireframe() and remove it, and undo
- * the grab, using meta_effects_end_wireframe().
- *
- * \param screen  The screen to draw the rectangle on.
- * \param rect    The size of the rectangle to draw.
- * \param width   The width to display in the middle (or 0 not to)
- * \param height  The width to display in the middle (or 0 not to)
- */
-void meta_effects_begin_wireframe  (MetaScreen          *screen,
-                                    const MetaRectangle *rect,
-                                    int                  width,
-                                    int                  height);
-
-/**
- * Moves a wireframe rectangle around after its creation by
- * meta_effects_begin_wireframe().  (Perhaps we ought to remember the old
- * positions and not require people to pass them in?)
- *
- * \param old_rect  Where the rectangle is now
- * \param old_width The width that was displayed on it (or 0 if there wasn't)
- * \param old_height The height that was displayed on it (or 0 if there wasn't)
- * \param new_rect  Where the rectangle is going
- * \param new_width The width that will be displayed on it (or 0 not to)
- * \param new_height The height that will be displayed on it (or 0 not to)
- */
-void meta_effects_update_wireframe (MetaScreen          *screen,
-                                    const MetaRectangle *old_rect,
-                                    int                  old_width,
-                                    int                  old_height,
-                                    const MetaRectangle *new_rect,
-                                    int                  new_width,
-                                    int                  new_height);
-
-/**
- * Removes a wireframe rectangle from the screen and ends the grab started by
- * meta_effects_begin_wireframe().
- *
- * \param old_rect  Where the rectangle is now
- * \param old_width The width that was displayed on it (or 0 if there wasn't)
- * \param old_height The height that was displayed on it (or 0 if there wasn't)
- */
-void meta_effects_end_wireframe    (MetaScreen          *screen,
-                                    const MetaRectangle *old_rect,
-                                    int                  width,
-                                    int                  height);
-
-#endif /* META_EFFECTS_H */

src/core/errors.c

@@ -40,31 +40,6 @@ meta_errors_init (void)
   XSetIOErrorHandler (x_io_error_handler);
 }
 
-typedef struct ForeignDisplay ForeignDisplay;
-
-struct ForeignDisplay
-{
-    Display *dpy;
-    ErrorHandler handler;
-    gpointer data;
-    ForeignDisplay *next;
-};
-
-static ForeignDisplay *foreign_displays;
-
-void
-meta_errors_register_foreign_display (Display      *foreign_dpy,
-				      ErrorHandler  handler,
-				      gpointer      data)
-{
-    ForeignDisplay *info = g_new0 (ForeignDisplay, 1);
-    info->dpy = foreign_dpy;
-    info->handler = handler;
-    info->data = data;
-    info->next = foreign_displays;
-    foreign_displays = info;
-}
-
 static void
 meta_error_trap_push_internal (MetaDisplay *display,
                                gboolean     need_sync)
@@ -206,26 +181,15 @@ x_error_handler (Display     *xdisplay,
   int retval;
   gchar buf[64];
   MetaDisplay *display;
-  ForeignDisplay *foreign;
 
-  for (foreign = foreign_displays; foreign != NULL; foreign = foreign->next)
-  {
-      if (foreign->dpy == xdisplay)
-      {
-	  foreign->handler (xdisplay, error, foreign->data);
-
-	  return 0;
-      }
-  }
-  
   XGetErrorText (xdisplay, error->error_code, buf, 63);  
 
   display = meta_display_for_x_display (xdisplay);
 
-  /* Display can be NULL here because the compositing manager
-   * has its own Display, but Xlib only has one global error handler
+  /* Display can be NULL here Xlib only has one global error handler; and
+   * there might be other displays open in the process.
    */
-  if (display->error_traps > 0)
+  if (display && display->error_traps > 0)
     {
       /* we're in an error trap, chain to the trap handler
        * saved from GDK
@@ -264,21 +228,18 @@ x_io_error_handler (Display *xdisplay)
 
   display = meta_display_for_x_display (xdisplay);
 
-  if (display == NULL)
-    meta_bug ("IO error received for unknown display?\n");
-  
   if (errno == EPIPE)
     {
       meta_warning (_("Lost connection to the display '%s';\n"
                       "most likely the X server was shut down or you killed/destroyed\n"
                       "the window manager.\n"),
-                    display->name);
+                    display ? display->name : DisplayString (xdisplay));
     }
   else
     {
       meta_warning (_("Fatal IO error %d (%s) on display '%s'.\n"),
                     errno, g_strerror (errno),
-                    display->name);
+                    display ? display->name : DisplayString (xdisplay));
     }
 
   /* Xlib would force an exit anyhow */

src/core/frame.c

@@ -29,9 +29,7 @@
 #include "errors.h"
 #include "keybindings-private.h"
 
-#ifdef HAVE_RENDER
 #include <X11/extensions/Xrender.h>
-#endif
 
 #define EVENT_MASK (SubstructureRedirectMask |                     \
                     StructureNotifyMask | SubstructureNotifyMask | \
@@ -48,6 +46,7 @@ meta_window_ensure_frame (MetaWindow *window)
   MetaFrame *frame;
   XSetWindowAttributes attrs;
   Visual *visual;
+  gulong create_serial;
   
   if (window->frame)
     return;
@@ -105,7 +104,11 @@ meta_window_ensure_frame (MetaWindow *window)
                                                 frame->rect.y,
 						frame->rect.width,
 						frame->rect.height,
-						frame->window->screen->number);
+						frame->window->screen->number,
+                                                &create_serial);
+  meta_stack_tracker_record_add (window->screen->stack_tracker,
+                                 frame->xwindow,
+                                 create_serial);
 
   meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
   attrs.event_mask = EVENT_MASK;
@@ -141,6 +144,9 @@ meta_window_ensure_frame (MetaWindow *window)
   window->rect.x = 0;
   window->rect.y = 0;
 
+  meta_stack_tracker_record_remove (window->screen->stack_tracker,
+                                    window->xwindow,
+                                    XNextRequest (window->display->xdisplay));
   XReparentWindow (window->display->xdisplay,
                    window->xwindow,
                    frame->xwindow,
@@ -199,6 +205,9 @@ meta_window_destroy_frame (MetaWindow *window)
                   "Incrementing unmaps_pending on %s for reparent back to root\n", window->desc);
       window->unmaps_pending += 1;
     }
+  meta_stack_tracker_record_add (window->screen->stack_tracker,
+                                 window->xwindow,
+                                 XNextRequest (window->display->xdisplay));
   XReparentWindow (window->display->xdisplay,
                    window->xwindow,
                    window->screen->xroot,

src/core/keybindings-private.h

@@ -45,7 +45,7 @@ gboolean meta_window_grab_all_keys          (MetaWindow  *window,
                                              guint32      timestamp);
 void     meta_window_ungrab_all_keys        (MetaWindow  *window,
                                              guint32      timestamp);
-void     meta_display_process_key_event     (MetaDisplay *display,
+gboolean meta_display_process_key_event     (MetaDisplay *display,
                                              MetaWindow  *window,
                                              XEvent      *event);
 void     meta_set_keybindings_disabled      (gboolean     setting);

src/core/keybindings.c

@@ -35,7 +35,6 @@
 #include "frame-private.h"
 #include "place.h"
 #include "prefs.h"
-#include "effects.h"
 #include "util.h"
 
 #include <X11/keysym.h>
@@ -460,7 +459,7 @@ regrab_key_bindings (MetaDisplay *display)
       tmp = tmp->next;
     }
 
-  windows = meta_display_list_windows (display);
+  windows = meta_display_list_windows (display, META_LIST_DEFAULT);
   tmp = windows;
   while (tmp != NULL)
     {
@@ -476,11 +475,11 @@ regrab_key_bindings (MetaDisplay *display)
   g_slist_free (windows);
 }
 
-static MetaKeyBindingAction
-display_get_keybinding_action (MetaDisplay  *display,
-                               unsigned int  keysym,
-                               unsigned int  keycode,
-                               unsigned long mask)
+static MetaKeyBinding *
+display_get_keybinding (MetaDisplay  *display,
+                        unsigned int  keysym,
+                        unsigned int  keycode,
+                        unsigned long mask)
 {
   int i;
 
@@ -491,13 +490,29 @@ display_get_keybinding_action (MetaDisplay  *display,
           display->key_bindings[i].keycode == keycode &&
           display->key_bindings[i].mask == mask)
         {
-          return meta_prefs_get_keybinding_action (display->key_bindings[i].name);
+          return &display->key_bindings[i];
         }
       
       --i;
     }
 
-  return META_KEYBINDING_ACTION_NONE;
+  return NULL;
+}
+
+static MetaKeyBindingAction
+display_get_keybinding_action (MetaDisplay  *display,
+                               unsigned int  keysym,
+                               unsigned int  keycode,
+                               unsigned long mask)
+{
+  MetaKeyBinding *binding;
+
+  binding = display_get_keybinding (display, keysym, keycode, mask);
+
+  if (binding)
+    return meta_prefs_get_keybinding_action (binding->name);
+  else
+    return META_KEYBINDING_ACTION_NONE;
 }
 
 void
@@ -1198,6 +1213,45 @@ process_overlay_key (MetaDisplay *display,
   return TRUE;
 }
 
+static void
+invoke_handler (MetaDisplay    *display,
+                MetaScreen     *screen,
+                MetaKeyHandler *handler,
+                MetaWindow     *window,
+                XEvent         *event,
+                MetaKeyBinding *binding)
+
+{
+  if (handler->func)
+    (* handler->func) (display, screen,
+                       handler->flags & BINDING_PER_WINDOW ?
+                           window : NULL,
+                       event,
+                       binding,
+                       handler->user_data);
+  else
+    (* handler->default_func) (display, screen,
+                               handler->flags & BINDING_PER_WINDOW ?
+                                   window: NULL,
+                               event,
+                               binding,
+                               NULL);
+}
+
+static void
+invoke_handler_by_name (MetaDisplay    *display,
+                        MetaScreen     *screen,
+                        const char     *handler_name,
+                        MetaWindow     *window,
+                        XEvent         *event)
+{
+  MetaKeyHandler *handler;
+
+  handler = find_handler (key_handlers, handler_name);
+  if (handler)
+    invoke_handler (display, screen, handler, window, event, NULL);
+}
+
 /* now called from only one place, may be worth merging */
 static gboolean
 process_event (MetaKeyBinding       *bindings,
@@ -1254,20 +1308,7 @@ process_event (MetaKeyBinding       *bindings,
        */
       display->allow_terminal_deactivation = TRUE;
 
-      if (handler->func)
-        (* handler->func) (display, screen,
-                           bindings[i].handler->flags & BINDING_PER_WINDOW ?
-                           window: NULL,
-                           event,
-                           &bindings[i],
-                           handler->user_data);
-      else
-        (* handler->default_func) (display, screen,
-                           bindings[i].handler->flags & BINDING_PER_WINDOW ?
-                           window: NULL,
-                           event,
-                           &bindings[i],
-                           NULL);
+      invoke_handler (display, screen, handler, window, event, &bindings[i]);
 
       return TRUE;
     }
@@ -1282,13 +1323,16 @@ process_event (MetaKeyBinding       *bindings,
  * right. This cannot cause infinite recursion because we never call
  * ourselves when there wasn't a grab, and we always clear the grab
  * first; the invariant is enforced using an assertion. See #112560.
+ *
+ * The return value is whether we handled the key event.
+ *
  * FIXME: We need to prove there are no race conditions here.
  * FIXME: Does it correctly handle alt-Tab being followed by another
  * grabbing keypress without letting go of alt?
  * FIXME: An iterative solution would probably be simpler to understand
  * (and help us solve the other fixmes).
  */
-void
+gboolean
 meta_display_process_key_event (MetaDisplay *display,
                                 MetaWindow  *window,
                                 XEvent      *event)
@@ -1304,7 +1348,7 @@ meta_display_process_key_event (MetaDisplay *display,
                 all_bindings_disabled ? ReplayKeyboard : AsyncKeyboard,
                 event->xkey.time);
   if (all_bindings_disabled)
-    return;
+    return FALSE;
 
   /* if key event was on root window, we have a shortcut */
   screen = meta_display_screen_for_root (display, event->xkey.window);
@@ -1315,12 +1359,12 @@ meta_display_process_key_event (MetaDisplay *display,
                                               event->xany.window);
 
   if (screen == NULL)
-    return; /* event window is destroyed */
+    return FALSE; /* event window is destroyed */
   
   /* ignore key events on popup menus and such. */
   if (window == NULL &&
       meta_ui_window_is_widget (screen->ui, event->xany.window))
-    return;
+    return FALSE;
   
   /* window may be NULL */
   
@@ -1340,7 +1384,7 @@ meta_display_process_key_event (MetaDisplay *display,
   if (all_keys_grabbed)
     {
       if (display->grab_op == META_GRAB_OP_NONE)
-        return;
+        return TRUE;
       /* If we get here we have a global grab, because
         * we're in some special keyboard mode such as window move
         * mode.
@@ -1417,18 +1461,20 @@ meta_display_process_key_event (MetaDisplay *display,
                       "Ending grab op %u on key event sym %s\n",
                       display->grab_op, XKeysymToString (keysym));
           meta_display_end_grab_op (display, event->xkey.time);
-          return;
         }
-      }
+
+      return TRUE;
+    }
   
   handled = process_overlay_key (display, screen, event, keysym);
+  if (handled)
+    return TRUE;
   
   /* Do the normal keybindings */
-  if (!handled)
-    process_event (display->key_bindings,
-                   display->n_key_bindings,
-                   display, screen, window, event, keysym,
-                   !all_keys_grabbed && window);
+  return process_event (display->key_bindings,
+                        display->n_key_bindings,
+                        display, screen, window, event, keysym,
+                        !all_keys_grabbed && window);
 }
 
 static gboolean
@@ -1447,23 +1493,19 @@ process_mouse_move_resize_grab (MetaDisplay *display,
       /* End move or resize and restore to original state.  If the
        * window was a maximized window that had been "shaken loose" we
        * need to remaximize it.  In normal cases, we need to do a
-       * moveresize now to get the position back to the original.  In
-       * wireframe mode, we just need to set grab_was_cancelled to tru
-       * to avoid avoid moveresizing to the position of the wireframe.
+       * moveresize now to get the position back to the original.
        */
       if (window->shaken_loose)
         meta_window_maximize (window,
                               META_MAXIMIZE_HORIZONTAL |
                               META_MAXIMIZE_VERTICAL);
-      else if (!display->grab_wireframe_active)
+      else
         meta_window_move_resize (display->grab_window,
                                  TRUE,
                                  display->grab_initial_window_pos.x,
                                  display->grab_initial_window_pos.y,
                                  display->grab_initial_window_pos.width,
                                  display->grab_initial_window_pos.height);
-      else
-        display->grab_was_cancelled = TRUE;
 
       /* End grab */
       return FALSE;
@@ -1494,15 +1536,7 @@ process_keyboard_move_grab (MetaDisplay *display,
   if (is_modifier (display, event->xkey.keycode))
     return TRUE;
 
-  if (display->grab_wireframe_active)
-    {
-      x = display->grab_wireframe_rect.x;
-      y = display->grab_wireframe_rect.y;
-    }
-  else
-    {
-      meta_window_get_position (window, &x, &y);
-    }
+  meta_window_get_position (window, &x, &y);
 
   smart_snap = (event->xkey.state & ShiftMask) != 0;
   
@@ -1521,23 +1555,19 @@ process_keyboard_move_grab (MetaDisplay *display,
       /* End move and restore to original state.  If the window was a
        * maximized window that had been "shaken loose" we need to
        * remaximize it.  In normal cases, we need to do a moveresize
-       * now to get the position back to the original.  In wireframe
-       * mode, we just need to set grab_was_cancelled to tru to avoid
-       * avoid moveresizing to the position of the wireframe.
+       * now to get the position back to the original.
        */
       if (window->shaken_loose)
         meta_window_maximize (window,
                               META_MAXIMIZE_HORIZONTAL |
                               META_MAXIMIZE_VERTICAL);
-      else if (!display->grab_wireframe_active)
+      else
         meta_window_move_resize (display->grab_window,
                                  TRUE,
                                  display->grab_initial_window_pos.x,
                                  display->grab_initial_window_pos.y,
                                  display->grab_initial_window_pos.width,
                                  display->grab_initial_window_pos.height);
-      else
-        display->grab_was_cancelled = TRUE;
     }
   
   /* When moving by increments, we still snap to edges if the move
@@ -1588,10 +1618,7 @@ process_keyboard_move_grab (MetaDisplay *display,
                   "Computed new window location %d,%d due to keypress\n",
                   x, y);
 
-      if (display->grab_wireframe_active)
-        old_rect = display->grab_wireframe_rect;
-      else
-        meta_window_get_client_root_coords (window, &old_rect);
+      meta_window_get_client_root_coords (window, &old_rect);
 
       meta_window_edge_resistance_for_move (window, 
                                             old_rect.x,
@@ -1602,17 +1629,7 @@ process_keyboard_move_grab (MetaDisplay *display,
                                             smart_snap,
                                             TRUE);
 
-      if (display->grab_wireframe_active)
-        {
-          meta_window_update_wireframe (window, x, y,
-                                        display->grab_wireframe_rect.width,
-                                        display->grab_wireframe_rect.height);
-        }
-      else
-        {
-          meta_window_move (window, TRUE, x, y);
-        }
-      
+      meta_window_move (window, TRUE, x, y);
       meta_window_update_keyboard_move (window);
     }
 
@@ -1767,21 +1784,13 @@ process_keyboard_resize_grab (MetaDisplay *display,
 
   if (keysym == XK_Escape)
     {
-      /* End resize and restore to original state.  If not in
-       * wireframe mode, we need to do a moveresize now to get the
-       * position back to the original.  If we are in wireframe mode,
-       * we need to avoid moveresizing to the position of the
-       * wireframe.
-       */
-      if (!display->grab_wireframe_active)
-        meta_window_move_resize (display->grab_window,
-                                 TRUE,
-                                 display->grab_initial_window_pos.x,
-                                 display->grab_initial_window_pos.y,
-                                 display->grab_initial_window_pos.width,
-                                 display->grab_initial_window_pos.height);
-      else
-        display->grab_was_cancelled = TRUE;
+      /* End resize and restore to original state. */
+      meta_window_move_resize (display->grab_window,
+                               TRUE,
+                               display->grab_initial_window_pos.x,
+                               display->grab_initial_window_pos.y,
+                               display->grab_initial_window_pos.width,
+                               display->grab_initial_window_pos.height);
 
       return FALSE;
     }
@@ -1790,16 +1799,8 @@ process_keyboard_resize_grab (MetaDisplay *display,
                                               event, keysym))
     return TRUE;
 
-  if (display->grab_wireframe_active)
-    {
-      width = display->grab_wireframe_rect.width;
-      height = display->grab_wireframe_rect.height;
-    }
-  else
-    {
-      width = window->rect.width;
-      height = window->rect.height;
-    }
+  width = window->rect.width;
+  height = window->rect.height;
 
   gravity = meta_resize_gravity_from_grab_op (display->grab_op);
 
@@ -1964,10 +1965,7 @@ process_keyboard_resize_grab (MetaDisplay *display,
                   "%dx%d, gravity %s\n",
                   width, height, meta_gravity_to_string (gravity));
       
-      if (display->grab_wireframe_active)
-        old_rect = display->grab_wireframe_rect;
-      else
-        old_rect = window->rect;  /* Don't actually care about x,y */
+      old_rect = window->rect;  /* Don't actually care about x,y */
 
       /* Do any edge resistance/snapping */
       meta_window_edge_resistance_for_resize (window,
@@ -1980,32 +1978,16 @@ process_keyboard_resize_grab (MetaDisplay *display,
                                               smart_snap,
                                               TRUE);
 
-      if (display->grab_wireframe_active)
-        {
-          MetaRectangle new_position;
-          meta_rectangle_resize_with_gravity (&display->grab_wireframe_rect, 
-                                              &new_position,
-                                              gravity,
-                                              width,
-                                              height);
-          meta_window_update_wireframe (window, 
-                                        new_position.x,
-                                        new_position.y,
-                                        new_position.width, 
-                                        new_position.height);
-        }
-      else
-        {
-          /* We don't need to update unless the specified width and height
-           * are actually different from what we had before.
-           */
-          if (window->rect.width != width || window->rect.height != height)
-            meta_window_resize_with_gravity (window, 
-                                             TRUE,
-                                             width,
-                                             height,
-                                             gravity);
-        }
+      /* We don't need to update unless the specified width and height
+       * are actually different from what we had before.
+       */
+      if (window->rect.width != width || window->rect.height != height)
+        meta_window_resize_with_gravity (window, 
+                                         TRUE,
+                                         width,
+                                         height,
+                                         gravity);
+
       meta_window_update_keyboard_resize (window, FALSE);
     }
 
@@ -2045,6 +2027,7 @@ process_tab_grab (MetaDisplay *display,
                   XEvent      *event,
                   KeySym       keysym)
 {
+  MetaKeyBinding *binding;
   MetaKeyBindingAction action;
   gboolean popup_not_showing;
   gboolean backward;
@@ -2054,79 +2037,74 @@ process_tab_grab (MetaDisplay *display,
   if (screen != display->grab_screen)
     return FALSE;
 
-  action = display_get_keybinding_action (display,
-                                          keysym,
-                                          event->xkey.keycode,
-                                          display->grab_mask);
+  binding = display_get_keybinding (display,
+                                    keysym,
+                                    event->xkey.keycode,
+                                    display->grab_mask);
+  if (binding)
+    action = meta_prefs_get_keybinding_action (binding->name);
+  else
+    action = META_KEYBINDING_ACTION_NONE;
 
   /*
    * If there is no tab_pop up object, i.e., there is some custom handler
    * implementing Alt+Tab & Co., we call this custom handler; we do not
    * mess about with the grab, as that is up to the handler to deal with.
    */
-  if (!screen->tab_handler)
+  if (!screen->tab_popup)
     {
-      MetaKeyHandler *handler = NULL;
-      const gchar    *handler_name = NULL;
+      if (event->type == KeyRelease)
+        {
+          if (end_keyboard_grab (display, event->xkey.keycode))
+            {
+              invoke_handler_by_name (display, screen, "tab_popup_select", NULL, event);
+
+              /* We return FALSE to end the grab; if the handler ended the grab itself
+               * that will be a noop. If the handler didn't end the grab, then it's a
+               * safety measure to prevent a stuck grab.
+               */
+              return FALSE;
+            }
+
+          return TRUE;
+        }
 
       switch (action)
         {
         case META_KEYBINDING_ACTION_CYCLE_PANELS:
-          handler_name = "cycle_group";
-          break;
         case META_KEYBINDING_ACTION_CYCLE_WINDOWS:
-          handler_name = "cycle_windows";
-          break;
         case META_KEYBINDING_ACTION_CYCLE_PANELS_BACKWARD:
-          handler_name = "cycle_panels_backward";
-          break;
         case META_KEYBINDING_ACTION_CYCLE_WINDOWS_BACKWARD:
-          handler_name = "cycle_windows_backward";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_PANELS:
-          handler_name = "switch_panels";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_WINDOWS:
-          handler_name = "switch_windows";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_PANELS_BACKWARD:
-          handler_name = "switch_panels_backward";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD:
-          handler_name = "switch_windows_backward";
-          break;
         case META_KEYBINDING_ACTION_CYCLE_GROUP:
-          handler_name = "cycle_group";
-          break;
         case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD:
-          handler_name = "cycle_group_backward";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_GROUP:
-          handler_name = "switch_group";
-          break;
         case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD:
-          handler_name = "switch_group_backward";
+          /* These are the tab-popup bindings. If a custom Alt-Tab implementation
+           * is in effect, we expect it to want to handle all of these as a group
+           *
+           * If there are some of them that the custom implementation didn't
+           * handle, we treat them as "unbound" for the duration - running the
+           * normal handlers could get us into trouble.
+           */
+          if (binding->handler &&
+              binding->handler->func &&
+              binding->handler->func != binding->handler->default_func)
+            {
+              invoke_handler (display, screen, binding->handler, NULL, event, binding);
+              return TRUE;
+            }
           break;
         default:
-          /*
-           * This is the case when the Alt key is released; we preserve
-           * the grab, as it is up to the custom implementaiton to free it
-           * (a plugin can catch this in their xevent_filter function).
-           */
-          return TRUE;
+          break;
         }
 
-      /*
-       * We do not want to actually call the handler, we just want to ensure
-       * that if a custom handler is installed, we do not release the grab here.
-       * The handler will get called as normal in the process_event() function.
-       */
-      handler = find_handler (key_handlers, handler_name);
-
-      if (!handler || !handler->func || handler->func == handler->default_func)
-        return FALSE;
-
-      return TRUE;
+      /* Some unhandled key press */
+      invoke_handler_by_name (display, screen, "tab_popup_cancel", NULL, event);
+      return FALSE;
     }
 
   if (event->type == KeyRelease &&
@@ -2571,7 +2549,7 @@ handle_move_to_corner_backend (MetaDisplay    *display,
   int new_x, new_y;
   int frame_width, frame_height;
 
-  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_work_area_all_monitors (window, &work_area);
   meta_window_get_outer_rect (window, &outer);
   meta_window_get_position (window, &orig_x, &orig_y);
 
@@ -2703,7 +2681,7 @@ handle_move_to_center  (MetaDisplay    *display,
   int orig_x, orig_y;
   int frame_width, frame_height;
 
-  meta_window_get_work_area_all_xineramas (window, &work_area);
+  meta_window_get_work_area_all_monitors (window, &work_area);
   meta_window_get_outer_rect (window, &outer);
   meta_window_get_position (window, &orig_x, &orig_y);
 
@@ -3108,6 +3086,27 @@ handle_cycle (MetaDisplay    *display,
                     backwards, FALSE);
 }
 
+static void
+handle_tab_popup_select (MetaDisplay    *display,
+                         MetaScreen     *screen,
+                         MetaWindow     *window,
+                         XEvent         *event,
+                         MetaKeyBinding *binding,
+                         gpointer        dummy)
+{
+  /* Stub for custom handlers; no default implementation */
+}
+
+static void
+handle_tab_popup_cancel (MetaDisplay    *display,
+                         MetaScreen     *screen,
+                         MetaWindow     *window,
+                         XEvent         *event,
+                         MetaKeyBinding *binding,
+                         gpointer        dummy)
+{
+  /* Stub for custom handlers; no default implementation */
+}
 
 static void
 handle_toggle_fullscreen  (MetaDisplay    *display,

src/core/main.c

@@ -68,15 +68,14 @@
 #include <fcntl.h>
 #include <locale.h>
 #include <time.h>
+#include <unistd.h>
 
-#ifdef WITH_CLUTTER
 #include <clutter/clutter.h>
 #include <clutter/x11/clutter-x11.h>
-#endif
 
 #ifdef HAVE_INTROSPECTION
 #include <girepository.h>
-#include "compositor/mutter/mutter-plugin-manager.h"
+#include "compositor/mutter-plugin-manager.h"
 #endif
 
 /**
@@ -126,11 +125,13 @@ log_handler (const gchar   *log_domain,
 static void
 version (void)
 {
+  const int latest_year = 2010;
+
   g_print (_("mutter %s\n"
-             "Copyright (C) 2001-2008 Havoc Pennington, Red Hat, Inc., and others\n"
+             "Copyright (C) 2001-%d Havoc Pennington, Red Hat, Inc., and others\n"
              "This is free software; see the source for copying conditions.\n"
              "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"),
-           VERSION);
+           VERSION, latest_year);
   exit (0);
 }
 
@@ -178,11 +179,6 @@ meta_print_compilation_info (void)
 #else
   meta_verbose ("Compiled without startup notification\n");
 #endif
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-  meta_verbose ("Compiled with composite extensions\n");
-#else
-  meta_verbose ("Compiled without composite extensions\n");
-#endif
 }
 
 /**
@@ -233,16 +229,12 @@ typedef struct
   gboolean sync;
   gboolean composite;
   gboolean no_composite;
+  gboolean no_force_fullscreen;
   gboolean no_tab_popup;
   gchar *introspect;
 } MetaArguments;
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 #define COMPOSITE_OPTS_FLAGS 0
-#else /* HAVE_COMPOSITE_EXTENSIONS */
-/* No compositor, so don't show the arguments in --help */
-#define COMPOSITE_OPTS_FLAGS G_OPTION_FLAG_HIDDEN
-#endif /* HAVE_COMPOSITE_EXTENSIONS */
 
 /**
  * Parses argc and argv and returns the
@@ -316,14 +308,18 @@ meta_parse_options (int *argc, char ***argv,
       N_("Turn compositing off"),
       NULL
     },
-#ifdef WITH_CLUTTER
+    {
+      "no-force-fullscreen", 0, COMPOSITE_OPTS_FLAGS, G_OPTION_ARG_NONE,
+      &my_args.no_force_fullscreen,
+      N_("Don't make fullscreen windows that are maximized and have no decorations"),
+      NULL
+    },
     {
       "mutter-plugins", 0, 0, G_OPTION_ARG_STRING,
       &my_args.mutter_plugins,
       N_("Comma-separated list of compositor plugins"),
       "PLUGINS"
     },
-#endif
     {
       "no-tab-popup", 0, 0, G_OPTION_ARG_NONE,
       &my_args.no_tab_popup,
@@ -344,15 +340,8 @@ meta_parse_options (int *argc, char ***argv,
 
   ctx = g_option_context_new (NULL);
   g_option_context_add_main_entries (ctx, options, "mutter");
-  
-#ifdef WITH_CLUTTER
-  /*
-   * This function is only available in clutter >= 0.8.2
-   */
-#if CLUTTER_CHECK_VERSION(0,8,2)
   g_option_context_add_group (ctx, clutter_get_option_group_without_init ());
-#endif
-#endif
+  g_option_context_add_group (ctx, cogl_get_option_group ());
 
   if (!g_option_context_parse (ctx, argc, argv, &error))
     {
@@ -365,8 +354,6 @@ meta_parse_options (int *argc, char ***argv,
   return ctx;
 }
 
-
-#ifdef WITH_CLUTTER
 /* Mutter is responsible for pulling events off the X queue, so Clutter
  * doesn't need (and shouldn't) run its normal event source which polls
  * the X fd, but we do have to deal with dispatching events that accumulate
@@ -419,19 +406,15 @@ meta_clutter_init (GOptionContext *ctx, int *argc, char ***argv)
   
   if (CLUTTER_INIT_SUCCESS == clutter_init (argc, argv))
     {
-      meta_compositor_can_use_clutter__ = 1;
-
       GSource *source = g_source_new (&event_funcs, sizeof (GSource));
       g_source_attach (source, NULL);
       g_source_unref (source);
     }
   else
     {
-      g_message ("Unable to initialize Clutter.\n");
-      meta_compositor_can_use_clutter__ = 0;
+	  meta_fatal ("Unable to initialize Clutter.\n");
     }
 }
-#endif
 
 /**
  * Selects which display Mutter should use. It first tries to use
@@ -455,43 +438,37 @@ meta_select_display (gchar *display_name)
 static void
 meta_finalize (void)
 {
-  meta_display_close (meta_get_display (),
-                      CurrentTime); /* I doubt correct timestamps matter here */
+  MetaDisplay *display = meta_get_display ();
+
+  if (display)
+    meta_display_close (display,
+                        CurrentTime); /* I doubt correct timestamps matter here */
 
   meta_session_shutdown ();
 }
 
+static int sigterm_pipe_fds[2] = { -1, -1 };
+
 static void
 sigterm_handler (int signum)
 {
-  meta_finalize ();
-
-  exit (meta_exit_code);
-}
-
-static guint sigchld_signal_id = 0;
-
-static void
-sigchld_handler (int signum, siginfo_t *info, void *context)
-{
-  int stat;
-
-  if (info->si_code == CLD_EXITED)
+  if (sigterm_pipe_fds[1] >= 0)
     {
-      g_signal_emit (sigchld_nexus, sigchld_signal_id, 0,
-                     info->si_status,
-                     GINT_TO_POINTER (info->si_pid));
+      int dummy;
+
+      dummy = write (sigterm_pipe_fds[1], "", 1);
+      close (sigterm_pipe_fds[1]);
+      sigterm_pipe_fds[1] = -1;
     }
-
-  g_signal_handlers_disconnect_matched (sigchld_nexus,
-                                        G_SIGNAL_MATCH_DATA,
-                                        sigchld_signal_id,
-                                        0, NULL, NULL,
-                                        GINT_TO_POINTER (info->si_pid));
-
-  waitpid (info->si_pid, &stat, WNOHANG);
 }
-    
+
+static gboolean
+on_sigterm (void)
+{
+  meta_quit (META_EXIT_SUCCESS);
+  return FALSE;
+}
+
 /**
  * This is where the story begins. It parses commandline options and
  * environment variables, sets up the screen, hands control off to
@@ -514,8 +491,9 @@ main (int argc, char **argv)
     "Pango", "GLib-GObject", "GThread"
   };
   guint i;
+  GIOChannel *channel;
   GOptionContext *ctx;
-  
+
   if (!g_thread_supported ())
     g_thread_init (NULL);
   
@@ -537,29 +515,21 @@ main (int argc, char **argv)
                 g_strerror (errno));
 #endif
 
+  if (pipe (sigterm_pipe_fds) != 0)
+    g_printerr ("Failed to create SIGTERM pipe: %s\n",
+                g_strerror (errno));
+
+  channel = g_io_channel_unix_new (sigterm_pipe_fds[0]);
+  g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
+  g_io_add_watch (channel, G_IO_IN, (GIOFunc) on_sigterm, NULL);
+  g_io_channel_set_close_on_unref (channel, TRUE);
+  g_io_channel_unref (channel);
+
   act.sa_handler = &sigterm_handler;
   if (sigaction (SIGTERM, &act, NULL) < 0)
     g_printerr ("Failed to register SIGTERM handler: %s\n",
 		g_strerror (errno));
 
-  sigchld_nexus = g_object_new (META_TYPE_NEXUS, NULL);
-
-  sigchld_signal_id =
-    g_signal_new ("sigchld", META_TYPE_NEXUS,
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL,
-                  g_cclosure_marshal_VOID__UINT_POINTER,
-                  G_TYPE_NONE,
-                  2,
-                  G_TYPE_UINT, G_TYPE_POINTER);
-  
-  act.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
-  act.sa_handler = SIG_DFL;
-  act.sa_sigaction = &sigchld_handler;
-  if (sigaction (SIGCHLD, &act, NULL) < 0)
-    g_printerr ("Failed to register SIGCHLD handler: %s\n",
-		g_strerror (errno));
-
   if (g_getenv ("MUTTER_VERBOSE"))
     meta_set_verbose (TRUE);
   if (g_getenv ("MUTTER_DEBUG"))
@@ -581,7 +551,6 @@ main (int argc, char **argv)
   /* Parse command line arguments.*/
   ctx = meta_parse_options (&argc, &argv, &meta_args);
 
-#ifdef WITH_CLUTTER
   /* This must come before the introspect below, so we load all the plugins
    * in order to get their get_type functions.
    */
@@ -603,7 +572,6 @@ main (int argc, char **argv)
       g_slist_free(plugins_list);
       g_strfreev (plugins);
     }
-#endif /* WITH_CLUTTER */
 
 #ifdef HAVE_INTROSPECTION
   g_irepository_prepend_search_path (MUTTER_PKGLIBDIR);
@@ -648,12 +616,10 @@ main (int argc, char **argv)
   
   meta_ui_init (&argc, &argv);  
 
-#ifdef WITH_CLUTTER
   /*
    * Clutter can only be initialized after the UI.
    */
   meta_clutter_init (ctx, &argc, &argv);
-#endif
 
   g_option_context_free (ctx);
 
@@ -745,6 +711,9 @@ main (int argc, char **argv)
   if (meta_args.composite || meta_args.no_composite)
     meta_prefs_set_compositing_manager (meta_args.composite);
 
+  if (meta_args.no_force_fullscreen)
+    meta_prefs_set_force_fullscreen (FALSE);
+
   if (meta_args.no_tab_popup)
     {
       meta_prefs_override_no_tab_popup (TRUE);

src/core/place.c

@@ -104,7 +104,7 @@ find_next_cascade (MetaWindow *window,
   int window_width, window_height;
   int cascade_stage;
   MetaRectangle work_area;
-  const MetaXineramaScreenInfo* current;
+  const MetaMonitorInfo* current;
   
   sorted = g_list_copy (windows);
   sorted = g_list_sort (sorted, northwestcmp);
@@ -135,8 +135,8 @@ find_next_cascade (MetaWindow *window,
    * of NW corner of window frame.
    */
 
-  current = meta_screen_get_current_xinerama (window->screen);
-  meta_window_get_work_area_for_xinerama (window, current->number, &work_area);
+  current = meta_screen_get_current_monitor (window->screen);
+  meta_window_get_work_area_for_monitor (window, current->number, &work_area);
 
   cascade_x = MAX (0, work_area.x);
   cascade_y = MAX (0, work_area.y);
@@ -257,7 +257,7 @@ find_most_freespace (MetaWindow *window,
   frame_size_left = fgeom ? fgeom->left_width : 0;
   frame_size_top  = fgeom ? fgeom->top_height : 0;
 
-  meta_window_get_work_area_current_xinerama (focus_window, &work_area);
+  meta_window_get_work_area_current_monitor (focus_window, &work_area);
   meta_window_get_outer_rect (focus_window, &avoid);
   meta_window_get_outer_rect (window, &outer);
 
@@ -508,7 +508,7 @@ find_first_fit (MetaWindow *window,
                 MetaFrameGeometry *fgeom,
                 /* visible windows on relevant workspaces */
                 GList      *windows,
-		int         xinerama,
+		int         monitor,
                 int         x,
                 int         y,
                 int        *new_x,
@@ -551,16 +551,16 @@ find_first_fit (MetaWindow *window,
 
 #ifdef WITH_VERBOSE_MODE
     {
-      char xinerama_location_string[RECT_LENGTH];
-      meta_rectangle_to_string (&window->screen->xinerama_infos[xinerama].rect,
-                                xinerama_location_string);
+      char monitor_location_string[RECT_LENGTH];
+      meta_rectangle_to_string (&window->screen->monitor_infos[monitor].rect,
+                                monitor_location_string);
       meta_topic (META_DEBUG_XINERAMA,
-		  "Natural xinerama is %s\n",
-		  xinerama_location_string);
+		  "Natural monitor is %s\n",
+		  monitor_location_string);
     }
 #endif
 
-    meta_window_get_work_area_for_xinerama (window, xinerama, &work_area);
+    meta_window_get_work_area_for_monitor (window, monitor, &work_area);
 
     center_tile_rect_in_area (&rect, &work_area);
 
@@ -658,7 +658,7 @@ meta_window_place (MetaWindow        *window,
                    int               *new_y)
 {
   GList *windows;
-  const MetaXineramaScreenInfo *xi;
+  const MetaMonitorInfo *xi;
 
   /* frame member variables should NEVER be used in here, only
    * MetaFrameGeometry. But remember fgeom == NULL
@@ -810,11 +810,11 @@ meta_window_place (MetaWindow        *window,
       window->type == META_WINDOW_MODAL_DIALOG ||
       window->type == META_WINDOW_SPLASHSCREEN)
     {
-      /* Center on current xinerama (i.e. on current monitor) */
+      /* Center on current monitor */
       int w, h;
 
       /* Warning, this function is a round trip! */
-      xi = meta_screen_get_current_xinerama (window->screen);
+      xi = meta_screen_get_current_monitor (window->screen);
 
       w = xi->rect.width;
       h = xi->rect.height;
@@ -825,7 +825,7 @@ meta_window_place (MetaWindow        *window,
       x += xi->rect.x;
       y += xi->rect.y;
       
-      meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d xinerama %d\n",
+      meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d monitor %d\n",
                   window->desc, window->screen->number, xi->number);
 
       goto done_check_denied_focus;
@@ -839,7 +839,7 @@ meta_window_place (MetaWindow        *window,
     GSList *all_windows;
     GSList *tmp;
     
-    all_windows = meta_display_list_windows (window->display);
+    all_windows = meta_display_list_windows (window->display, META_LIST_DEFAULT);
 
     tmp = all_windows;
     while (tmp != NULL)
@@ -859,7 +859,7 @@ meta_window_place (MetaWindow        *window,
   }
 
   /* Warning, this is a round trip! */
-  xi = meta_screen_get_current_xinerama (window->screen);
+  xi = meta_screen_get_current_monitor (window->screen);
   
   /* "Origin" placement algorithm */
   x = xi->rect.x;
@@ -880,9 +880,9 @@ meta_window_place (MetaWindow        *window,
       MetaRectangle workarea;
       MetaRectangle outer;
 
-      meta_window_get_work_area_for_xinerama (window,
-                                              xi->number,
-                                              &workarea);      
+      meta_window_get_work_area_for_monitor (window,
+                                             xi->number,
+                                             &workarea);      
       meta_window_get_outer_rect (window, &outer);
       
       /* If the window is bigger than the screen, then automaximize.  Do NOT

src/core/prefs.c

@@ -52,6 +52,7 @@
 #define KEY_COMPOSITOR "/apps/metacity/general/compositing_manager"
 #define KEY_GNOME_ACCESSIBILITY "/desktop/gnome/interface/accessibility"
 
+#define KEY_COMMAND_DIRECTORY "/apps/metacity/keybinding_commands"
 #define KEY_COMMAND_PREFIX "/apps/metacity/keybinding_commands/command_"
 
 #define KEY_TERMINAL_DIR "/desktop/gnome/applications/terminal"
@@ -62,12 +63,10 @@
 #define KEY_WINDOW_BINDINGS_PREFIX "/apps/metacity/window_keybindings"
 #define KEY_LIST_BINDINGS_SUFFIX "_list"
 
+#define KEY_WORKSPACE_NAME_DIRECTORY "/apps/metacity/workspace_names"
 #define KEY_WORKSPACE_NAME_PREFIX "/apps/metacity/workspace_names/name_"
 
-#ifdef WITH_CLUTTER
-#define KEY_CLUTTER_DISABLED "/apps/mutter/general/clutter_disabled"
 #define KEY_CLUTTER_PLUGINS  "/apps/mutter/general/clutter_plugins"
-#endif
 
 #define KEY_LIVE_HIDDEN_WINDOWS "/apps/mutter/general/live_hidden_windows"
 
@@ -97,13 +96,13 @@ static gboolean auto_raise = FALSE;
 static gboolean auto_raise_delay = 500;
 static gboolean provide_visual_bell = FALSE;
 static gboolean bell_is_audible = TRUE;
-static gboolean reduced_resources = FALSE;
 static gboolean gnome_accessibility = FALSE;
 static gboolean gnome_animations = TRUE;
 static char *cursor_theme = NULL;
 static int   cursor_size = 24;
 static gboolean compositing_manager = FALSE;
 static gboolean resize_with_right_button = FALSE;
+static gboolean force_fullscreen = TRUE;
 
 static MetaVisualBellType visual_bell_type = META_VISUAL_BELL_FULLSCREEN_FLASH;
 static MetaButtonLayout button_layout;
@@ -115,11 +114,8 @@ static char *terminal_command = NULL;
 
 static char *workspace_names[MAX_REASONABLE_WORKSPACES] = { NULL, };
 
-#ifdef WITH_CLUTTER
-static gboolean clutter_disabled = FALSE;
 static gboolean clutter_plugins_overridden = FALSE;
 static GSList *clutter_plugins = NULL;
-#endif
 
 static gboolean live_hidden_windows = FALSE;
 
@@ -128,13 +124,23 @@ static gboolean no_tab_popup = FALSE;
 #ifdef HAVE_GCONF
 static gboolean handle_preference_update_enum (const gchar *key, GConfValue *value);
 
-static gboolean update_key_binding     (const char *name,
+static char *binding_name (const char *gconf_key);
+
+static gboolean update_key_binding     (const char *key,
                                         const char *value);
-static gboolean find_and_update_list_binding (MetaKeyPref *bindings,
-                                              const char  *name,
-                                              GSList      *value);
-static gboolean update_key_list_binding (const char *name,
-                                         GSList      *value);
+typedef enum
+  {
+    META_LIST_OF_STRINGS,
+    META_LIST_OF_GCONFVALUE_STRINGS
+  } MetaStringListType;
+
+static gboolean find_and_update_list_binding (MetaKeyPref       *bindings,
+                                              const char        *key,
+                                              GSList            *value,
+                                              MetaStringListType type_of_value);
+static gboolean update_key_list_binding (const char         *key,
+                                         GSList             *value,
+                                         MetaStringListType  type_of_value);
 static gboolean update_command            (const char  *name,
                                            const char  *value);
 static gboolean update_workspace_name     (const char  *name,
@@ -149,14 +155,8 @@ static char* gconf_key_for_workspace_name (int i);
 
 static void queue_changed (MetaPreference  pref);
 
-typedef enum
-  {
-    META_LIST_OF_STRINGS,
-    META_LIST_OF_GCONFVALUE_STRINGS
-  } MetaStringListType;
-
-static gboolean update_list_binding       (MetaKeyPref *binding,
-                                           GSList      *value,
+static gboolean update_list_binding       (MetaKeyPref       *binding,
+                                           GSList            *value,
                                            MetaStringListType type_of_value);
 
 static void     cleanup_error             (GError **error);
@@ -403,11 +403,6 @@ static MetaBoolPreference preferences_bool[] =
       &bell_is_audible, /* FIXME: change the name: it's confusing */
       FALSE,
     },
-    { "/apps/metacity/general/reduced_resources",
-      META_PREF_REDUCED_RESOURCES,
-      &reduced_resources,
-      FALSE,
-    },
     { "/desktop/gnome/interface/accessibility",
       META_PREF_GNOME_ACCESSIBILITY,
       &gnome_accessibility,
@@ -428,13 +423,6 @@ static MetaBoolPreference preferences_bool[] =
       &resize_with_right_button,
       FALSE,
     },
-#ifdef WITH_CLUTTER
-    { "/apps/mutter/general/clutter_disabled",
-      META_PREF_CLUTTER_DISABLED,
-      &clutter_disabled,
-      FALSE,
-    },
-#endif
     { "/apps/mutter/general/live_hidden_windows",
       META_PREF_LIVE_HIDDEN_WINDOWS,
       &live_hidden_windows,
@@ -1068,13 +1056,11 @@ meta_prefs_init (void)
   handle_preference_init_string ();
   handle_preference_init_int ();
 
-#ifdef WITH_CLUTTER
   if (!clutter_plugins_overridden)
     clutter_plugins = gconf_client_get_list (default_client, KEY_CLUTTER_PLUGINS,
                                              GCONF_VALUE_STRING, &err);
 
   cleanup_error (&err);
-#endif
 
   /* @@@ Is there any reason we don't do the add_dir here? */
   for (gconf_dir_cursor=gconf_dirs_we_are_interested_in;
@@ -1167,7 +1153,7 @@ change_notify (GConfClient    *client,
 
           list = value ? gconf_value_get_list (value) : NULL;
 
-          if (update_key_list_binding (key, list))
+          if (update_key_list_binding (key, list, META_LIST_OF_GCONFVALUE_STRINGS))
             queue_changed (META_PREF_KEYBINDINGS);
         }
       else
@@ -1223,7 +1209,6 @@ change_notify (GConfClient    *client,
     {
       queue_changed (META_PREF_KEYBINDINGS);
     }
-#ifdef WITH_CLUTTER
   else if (g_str_equal (key, KEY_CLUTTER_PLUGINS) && !clutter_plugins_overridden)
     {
       GError *err = NULL;
@@ -1241,7 +1226,6 @@ change_notify (GConfClient    *client,
       clutter_plugins = l;
       queue_changed (META_PREF_CLUTTER_PLUGINS);
     }
-#endif
   else
     {
       meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Mutter\n",
@@ -1805,9 +1789,6 @@ meta_preference_to_string (MetaPreference pref)
     case META_PREF_VISUAL_BELL_TYPE:
       return "VISUAL_BELL_TYPE";
 
-    case META_PREF_REDUCED_RESOURCES:
-      return "REDUCED_RESOURCES";
-
     case META_PREF_GNOME_ACCESSIBILITY:
       return "GNOME_ACCESSIBILTY";
 
@@ -1825,14 +1806,16 @@ meta_preference_to_string (MetaPreference pref)
 
     case META_PREF_RESIZE_WITH_RIGHT_BUTTON:
       return "RESIZE_WITH_RIGHT_BUTTON";
-#ifdef WITH_CLUTTER
-    case META_PREF_CLUTTER_DISABLED:
-      return "CLUTTER_DISABLED";
+
+    case META_PREF_FORCE_FULLSCREEN:
+      return "FORCE_FULLSCREEN";
+
     case META_PREF_CLUTTER_PLUGINS:
       return "CLUTTER_PLUGINS";
-#endif
+
     case META_PREF_LIVE_HIDDEN_WINDOWS:
       return "LIVE_HIDDEN_WINDOWS";
+
     case META_PREF_NO_TAB_POPUP:
       return "NO_TAB_POPUP";
     }
@@ -1915,57 +1898,64 @@ init_special_bindings (void)
 static void
 init_bindings (void)
 {
-#ifdef HAVE_GCONF  
-  int i = 0;
-  GError *err;
+#ifdef HAVE_GCONF
+  const char *prefix[] = {
+    KEY_WINDOW_BINDINGS_PREFIX,
+    KEY_SCREEN_BINDINGS_PREFIX,
+    NULL
+  };
+  int i;
+  GSList *list, *l, *list_val;
+  const char *str_val;
+  const char *key;
+  GConfEntry *entry;
+  GConfValue *value;
+  GHashTable *to_update;
 
+  to_update = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+  for (i = 0; prefix[i]; i++)
+    {
+      list = gconf_client_all_entries (default_client, prefix[i], NULL);
+      for (l = list; l; l = l->next)
+        {
+          entry = l->data;
+          key = gconf_entry_get_key (entry);
+          value = gconf_entry_get_value (entry);
+          if (g_str_has_suffix (key, KEY_LIST_BINDINGS_SUFFIX))
+            {
+              /* List bindings are used in addition to the normal bindings and never
+               * have defaults, so we just go ahead and set them immediately; there
+               * will be only a few of them, so don't worry about the linear scan
+               * in find_and_update_list_binding.
+               */
+              list_val = gconf_client_get_list (default_client, key, GCONF_VALUE_STRING, NULL);
+ 
+              update_key_list_binding (key, list_val, META_LIST_OF_STRINGS);
+              g_slist_foreach (list_val, (GFunc)g_free, NULL);
+              g_slist_free (list_val);
+            }
+          else
+            {
+              str_val = gconf_value_get_string (value);
+              g_hash_table_insert (to_update, binding_name (key), g_strdup (str_val));
+            }
+          gconf_entry_free (entry);
+        }
+      g_slist_free (list);
+    }
+
+  i = 0;
   while (key_bindings[i].name)
     {
-      GSList *list_val, *tmp;
-      char *str_val;
-      char *key;
- 
-      key = g_strconcat (key_bindings[i].per_window?
-                         KEY_WINDOW_BINDINGS_PREFIX:
-                         KEY_SCREEN_BINDINGS_PREFIX,
-                         "/",
-                         key_bindings[i].name, NULL);
- 
-      err = NULL;
-      str_val = gconf_client_get_string (default_client, key, &err);
-      cleanup_error (&err);
-
-      update_binding (&key_bindings[i], str_val);
-
-      g_free (str_val);      
-      g_free (key);
-
-      key = g_strconcat (key_bindings[i].per_window?
-                         KEY_WINDOW_BINDINGS_PREFIX:
-                         KEY_SCREEN_BINDINGS_PREFIX,
-                         "/",
-                         key_bindings[i].name,
-                         KEY_LIST_BINDINGS_SUFFIX, NULL);
-
-      err = NULL;
-
-      list_val = gconf_client_get_list (default_client, key, GCONF_VALUE_STRING, &err);
-      cleanup_error (&err);
- 
-      update_list_binding (&key_bindings[i], list_val, META_LIST_OF_STRINGS);
-
-      tmp = list_val;
-      while (tmp)
-        {
-          g_free (tmp->data);
-          tmp = tmp->next;
-        }
-      g_slist_free (list_val);
-      g_free (key);
+      update_binding (&key_bindings[i],
+                      g_hash_table_lookup (to_update, key_bindings[i].name));
 
       ++i;
     }
 
+  g_hash_table_destroy (to_update);
+
 #else /* HAVE_GCONF */
   int i = 0;
   while (key_bindings[i].name)
@@ -1987,28 +1977,23 @@ static void
 init_commands (void)
 {
 #ifdef HAVE_GCONF
-  int i;
-  GError *err;
-  
-  i = 0;
-  while (i < MAX_COMMANDS)
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  GConfEntry *entry;
+  GConfValue *value;
+
+  list = gconf_client_all_entries (default_client, KEY_COMMAND_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
     {
-      char *str_val;
-      char *key;
-
-      key = meta_prefs_get_gconf_key_for_command (i);
-
-      err = NULL;
-      str_val = gconf_client_get_string (default_client, key, &err);
-      cleanup_error (&err);
-
+      entry = l->data;
+      key = gconf_entry_get_key (entry);
+      value = gconf_entry_get_value (entry);
+      str_val = gconf_value_get_string (value);
       update_command (key, str_val);
-
-      g_free (str_val);    
-      g_free (key);
-
-      ++i;
+      gconf_entry_free (entry);
     }
+  g_slist_free (list);
 #else
   int i;
   for (i = 0; i < MAX_COMMANDS; i++)
@@ -2020,30 +2005,23 @@ static void
 init_workspace_names (void)
 {
 #ifdef HAVE_GCONF
-  int i;
-  GError *err;
-  
-  i = 0;
-  while (i < MAX_REASONABLE_WORKSPACES)
+  GSList *list, *l;
+  const char *str_val;
+  const char *key;
+  GConfEntry *entry;
+  GConfValue *value;
+
+  list = gconf_client_all_entries (default_client, KEY_WORKSPACE_NAME_DIRECTORY, NULL);
+  for (l = list; l; l = l->next)
     {
-      char *str_val;
-      char *key;
-
-      key = gconf_key_for_workspace_name (i);
-
-      err = NULL;
-      str_val = gconf_client_get_string (default_client, key, &err);
-      cleanup_error (&err);
-
+      entry = l->data;
+      key = gconf_entry_get_key (entry);
+      value = gconf_entry_get_value (entry);
+      str_val = gconf_value_get_string (value);
       update_workspace_name (key, str_val);
-
-      g_assert (workspace_names[i] != NULL);
-      
-      g_free (str_val);    
-      g_free (key);
-
-      ++i;
+      gconf_entry_free (entry);
     }
+  g_slist_free (list);
 #else
   int i;
   for (i = 0; i < MAX_REASONABLE_WORKSPACES; i++)
@@ -2302,16 +2280,22 @@ update_list_binding (MetaKeyPref *binding,
   return changed;
 }
 
-static const gchar*
-relative_key (const gchar* key)
+static char *
+binding_name (const char *gconf_key)
 {
-  const gchar* end;
-  
-  end = strrchr (key, '/');
+  const char *start, *end;
 
-  ++end;
+  if (*gconf_key == '/')
+    start = strrchr (gconf_key, '/') + 1;
+  else
+    start = gconf_key;
 
-  return end;
+  if (g_str_has_suffix (gconf_key, KEY_LIST_BINDINGS_SUFFIX))
+    end = gconf_key + strlen(gconf_key) - strlen (KEY_LIST_BINDINGS_SUFFIX);
+  else
+    end = gconf_key + strlen(gconf_key);
+
+  return g_strndup (start, end - start);
 }
 
 /* Return value is TRUE if a preference changed and we need to
@@ -2319,22 +2303,19 @@ relative_key (const gchar* key)
  */
 static gboolean
 find_and_update_binding (MetaKeyPref *bindings, 
-                         const char  *name,
+                         const char  *key,
                          const char  *value)
 {
-  const char *key;
+  char *name = binding_name (key);
   int i;
-  
-  if (*name == '/')
-    key = relative_key (name);
-  else
-    key = name;
 
   i = 0;
   while (bindings[i].name &&
-         strcmp (key, bindings[i].name) != 0)
+         strcmp (name, bindings[i].name) != 0)
     ++i;
 
+  g_free (name);
+
   if (bindings[i].name)
     return update_binding (&bindings[i], value);
   else
@@ -2342,46 +2323,40 @@ find_and_update_binding (MetaKeyPref *bindings,
 }
 
 static gboolean
-update_key_binding (const char *name,
-                       const char *value)
+update_key_binding (const char *key,
+                    const char *value)
 {
-  return find_and_update_binding (key_bindings, name, value);
+  return find_and_update_binding (key_bindings, key, value);
 }
 
 static gboolean
-find_and_update_list_binding (MetaKeyPref *bindings,
-                              const char  *name,
-                              GSList      *value)
+find_and_update_list_binding (MetaKeyPref       *bindings,
+                              const char        *key,
+                              GSList            *value,
+                              MetaStringListType type_of_value)
 {
-  const char *key;
+  char *name = binding_name (key);
   int i;
-  gchar *name_without_suffix = g_strdup(name);
-
-  name_without_suffix[strlen(name_without_suffix) - strlen(KEY_LIST_BINDINGS_SUFFIX)] = 0;
-
-  if (*name_without_suffix == '/')
-    key = relative_key (name_without_suffix);
-  else
-    key = name_without_suffix;
 
   i = 0;
   while (bindings[i].name &&
-         strcmp (key, bindings[i].name) != 0)
+         strcmp (name, bindings[i].name) != 0)
     ++i;
 
-  g_free (name_without_suffix);
+  g_free (name);
 
   if (bindings[i].name)
-    return update_list_binding (&bindings[i], value, META_LIST_OF_GCONFVALUE_STRINGS);
+    return update_list_binding (&bindings[i], value, type_of_value);
   else
     return FALSE;
 }
 
 static gboolean
-update_key_list_binding (const char *name,
-                            GSList *value)
+update_key_list_binding (const char        *key,
+                         GSList            *value,
+                         MetaStringListType type_of_value)
 {
-  return find_and_update_list_binding (key_bindings, name, value);
+  return find_and_update_list_binding (key_bindings, key, value, type_of_value);
 }
 
 static gboolean
@@ -2728,12 +2703,6 @@ meta_prefs_get_auto_raise_delay (void)
   return auto_raise_delay;
 }
 
-gboolean
-meta_prefs_get_reduced_resources (void)
-{
-  return reduced_resources;
-}
-
 gboolean
 meta_prefs_get_gnome_accessibility ()
 {
@@ -2825,6 +2794,12 @@ meta_prefs_get_mouse_button_menu (void)
   return resize_with_right_button ? 2: 3;
 }
 
+gboolean
+meta_prefs_get_force_fullscreen (void)
+{
+  return force_fullscreen;
+}
+
 void
 meta_prefs_set_compositing_manager (gboolean whether)
 {
@@ -2847,35 +2822,6 @@ meta_prefs_set_compositing_manager (gboolean whether)
 #endif
 }
 
-#ifdef WITH_CLUTTER
-gboolean
-meta_prefs_get_clutter_disabled (void)
-{
-  return clutter_disabled;
-}
-
-void
-meta_prefs_set_clutter_disabled (gboolean whether)
-{
-#ifdef HAVE_GCONF
-  GError *err = NULL;
-
-  gconf_client_set_bool (default_client,
-                         KEY_CLUTTER_DISABLED,
-                         whether,
-                         &err);
-
-  if (err)
-    {
-      meta_warning (_("Error setting clutter status status: %s\n"),
-                    err->message);
-      g_error_free (err);
-    }
-#else
-  clutter_disabled = whether;
-#endif
-}
-
 GSList *
 meta_prefs_get_clutter_plugins (void)
 {
@@ -2885,6 +2831,7 @@ meta_prefs_get_clutter_plugins (void)
 void
 meta_prefs_set_clutter_plugins (GSList *list)
 {
+#ifdef HAVE_GCONF
   GError *err = NULL;
 
   gconf_client_set_list (default_client,
@@ -2899,6 +2846,7 @@ meta_prefs_set_clutter_plugins (GSList *list)
                     err->message);
       g_error_free (err);
     }
+#endif
 }
 
 void
@@ -2914,7 +2862,6 @@ meta_prefs_override_clutter_plugins (GSList *list)
 
   clutter_plugins = g_slist_reverse (clutter_plugins);
 }
-#endif
 
 gboolean
 meta_prefs_get_live_hidden_windows (void)
@@ -3020,3 +2967,10 @@ init_button_layout(void)
 };
 
 #endif
+
+void
+meta_prefs_set_force_fullscreen (gboolean whether)
+{
+  force_fullscreen = whether;
+}
+

src/core/screen-private.h

@@ -36,12 +36,12 @@
 #include "display-private.h"
 #include "screen.h"
 #include <X11/Xutil.h>
-#include "alttabhandler.h"
+#include "stack-tracker.h"
 #include "ui.h"
 
-typedef struct _MetaXineramaScreenInfo MetaXineramaScreenInfo;
+typedef struct _MetaMonitorInfo MetaMonitorInfo;
 
-struct _MetaXineramaScreenInfo
+struct _MetaMonitorInfo
 {
   int number;
   MetaRectangle rect;
@@ -81,9 +81,8 @@ struct _MetaScreen
   Visual *default_xvisual;
   MetaRectangle rect;  /* Size of screen; rect.x & rect.y are always 0 */
   MetaUI *ui;
-  MetaAltTabHandler *tab_handler;
-  MetaTabPopup *ws_popup;
-  
+  MetaTabPopup *tab_popup, *ws_popup;
+
   MetaWorkspace *active_workspace;
 
   /* This window holds the focus when we don't want to focus
@@ -94,6 +93,7 @@ struct _MetaScreen
   GList *workspaces;
 
   MetaStack *stack;
+  MetaStackTracker *stack_tracker;
 
   MetaCursor current_cursor;
 
@@ -103,11 +103,11 @@ struct _MetaScreen
   Atom wm_sn_atom;
   guint32 wm_sn_timestamp;
   
-  MetaXineramaScreenInfo *xinerama_infos;
-  int n_xinerama_infos;
+  MetaMonitorInfo *monitor_infos;
+  int n_monitor_infos;
 
-  /* Cache the current Xinerama */
-  int last_xinerama_index;
+  /* Cache the current monitor */
+  int last_monitor_index;
 
 #ifdef HAVE_STARTUP_NOTIFICATION
   SnMonitorContext *sn_context;
@@ -115,11 +115,10 @@ struct _MetaScreen
   guint startup_sequence_timeout;
 #endif
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
   Window wm_cm_selection_window;
-#endif
+  guint32 wm_cm_timestamp;
 
-  guint work_area_idle;
+  guint work_area_later;
 
   int rows_of_workspaces;
   int columns_of_workspaces;
@@ -131,9 +130,6 @@ struct _MetaScreen
   
   int closing;
 
-  /* gc for XOR on root window */
-  GC root_xor_gc;
-
   /* Managed by compositor.c */
   gpointer compositor_data;
   
@@ -147,7 +143,8 @@ struct _MetaScreenClass
 {
   GObjectClass parent_class;
 
-  void (*restacked) (MetaScreen *);
+  void (*restacked)         (MetaScreen *);
+  void (*workareas_changed) (MetaScreen *);
 };
 
 MetaScreen*   meta_screen_new                 (MetaDisplay                *display,
@@ -185,19 +182,19 @@ void          meta_screen_workspace_popup_destroy      (MetaScreen    *screen);
 MetaWindow*   meta_screen_get_mouse_window     (MetaScreen                 *screen,
                                                 MetaWindow                 *not_this_one);
 
-const MetaXineramaScreenInfo* meta_screen_get_current_xinerama    (MetaScreen    *screen);
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect   (MetaScreen    *screen,
-                                                                   MetaRectangle *rect);
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen    *screen,
-                                                                   MetaWindow    *window);
+const MetaMonitorInfo* meta_screen_get_current_monitor    (MetaScreen    *screen);
+const MetaMonitorInfo* meta_screen_get_monitor_for_rect   (MetaScreen    *screen,
+                                                           MetaRectangle *rect);
+const MetaMonitorInfo* meta_screen_get_monitor_for_window (MetaScreen    *screen,
+                                                           MetaWindow    *window);
 
 
-const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen,
-                                                                 int         which_xinerama,
-                                                                 MetaScreenDirection dir);
-void          meta_screen_get_natural_xinerama_list (MetaScreen *screen,
-                                                     int**       xineramas_list,
-                                                     int*        n_xineramas);
+const MetaMonitorInfo* meta_screen_get_monitor_neighbor (MetaScreen *screen,
+                                                         int         which_monitor,
+                                                         MetaScreenDirection dir);
+void          meta_screen_get_natural_monitor_list (MetaScreen *screen,
+                                                    int**       monitors_list,
+                                                    int*        n_monitors);
 
 void          meta_screen_update_workspace_layout (MetaScreen             *screen);
 void          meta_screen_update_workspace_names  (MetaScreen             *screen);
@@ -246,4 +243,9 @@ void	 meta_screen_composite_all_windows (MetaScreen *screen);
 
 void     meta_screen_restacked (MetaScreen *screen);
 
+void     meta_screen_workspace_switched (MetaScreen         *screen,
+                                         int                 from,
+                                         int                 to,
+                                         MetaMotionDirection direction);
+
 #endif

src/core/session.c

@@ -29,6 +29,7 @@
 #include <X11/Xatom.h>
 
 #include <time.h>
+#include <sys/wait.h>
 
 #ifndef HAVE_SM
 void
@@ -83,6 +84,7 @@ static char*       load_state         (const char *previous_save_file);
 static void        regenerate_save_file (void);
 static const char* full_save_file       (void);
 static void        warn_about_lame_clients_and_finish_interact (gboolean shutdown);
+static void        disconnect         (void);
 
 /* This is called when data is available on an ICE connection.  */
 static gboolean
@@ -105,9 +107,12 @@ process_ice_messages (GIOChannel *channel,
       IcePointer context = IceGetConnectionContext (connection);
 #endif
       
-      /* We were disconnected */
-      IceSetShutdownNegotiation (connection, False);
-      IceCloseConnection (connection);
+      /* We were disconnected; close our connection to the
+       * session manager, this will result in the ICE connection
+       * being cleaned up, since it is owned by libSM.
+       */
+      disconnect ();
+      meta_quit (META_EXIT_SUCCESS);
 
       return FALSE;
     }
@@ -889,7 +894,7 @@ save_state (void)
   fprintf (outfile, "<mutter_session id=\"%s\">\n",
            client_id);
 
-  windows = meta_display_list_windows (meta_get_display ());
+  windows = meta_display_list_windows (meta_get_display (), META_LIST_DEFAULT);
   stack_position = 0;
 
   windows = g_slist_sort (windows, meta_display_stack_cmp);
@@ -1104,8 +1109,6 @@ load_state (const char *previous_save_file)
         {
           /* oh, just give up */
 
-          meta_warning (_("Failed to read saved session file %s: %s\n"),
-                    canonical_session_file, error->message);
           g_error_free (error);
           g_free (session_file);
           g_free (canonical_session_file);
@@ -1749,11 +1752,11 @@ finish_interact (gboolean shutdown)
 }
 
 static void
-sigchld_handler (MetaNexus *nexus, guint arg1, gpointer arg2, gpointer user_data)
+dialog_closed (GPid pid, int status, gpointer user_data)
 {
   gboolean shutdown = GPOINTER_TO_INT (user_data);
 
-  if (arg1 == 0) /* pressed "OK" */
+  if (WIFEXITED (status) && WEXITSTATUS (status) == 0) /* pressed "OK" */
     {
       finish_interact (shutdown);
     }
@@ -1767,8 +1770,9 @@ warn_about_lame_clients_and_finish_interact (gboolean shutdown)
   GSList *lame_details = NULL;
   GSList *tmp;
   GSList *columns = NULL;
+  GPid pid;
   
-  windows = meta_display_list_windows (meta_get_display ());
+  windows = meta_display_list_windows (meta_get_display (), META_LIST_DEFAULT);
   tmp = windows;
   while (tmp != NULL)
     {
@@ -1814,23 +1818,20 @@ warn_about_lame_clients_and_finish_interact (gboolean shutdown)
     }
   g_slist_free (lame);
 
-  meta_show_dialog("--list",
-                   _("These windows do not support &quot;save current setup&quot; "
-                     "and will have to be restarted manually next time "
-                     "you log in."),
-                   "240",
-                   meta_screen_get_screen_number (meta_get_display()->active_screen),
-                   NULL, NULL,
-                   None,
-                   columns,
-                   lame_details);
+  pid = meta_show_dialog("--list",
+                         _("These windows do not support &quot;save current setup&quot; "
+                           "and will have to be restarted manually next time "
+                           "you log in."),
+                         "240",
+                         meta_screen_get_screen_number (meta_get_display()->active_screen),
+                         NULL, NULL,
+                         None,
+                         columns,
+                         lame_details);
 
   g_slist_free (lame_details);
 
-  g_signal_connect (sigchld_nexus, "sigchld",
-                    G_CALLBACK (sigchld_handler),
-                    GINT_TO_POINTER (shutdown));
-
+  g_child_watch_add (pid, dialog_closed, GINT_TO_POINTER (shutdown));
 }
 
 #endif /* HAVE_SM */

src/core/stack-tracker.c

@@ -0,0 +1,729 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2009 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.
+ */
+
+#include <config.h>
+
+#include <string.h>
+
+#include "screen-private.h"
+#include "stack-tracker.h"
+#include "util.h"
+
+#include "compositor.h"
+
+/* The complexity here comes from resolving two competing factors:
+ *
+ *  - We need to have a view of the stacking order that takes into
+ *    account everything we have done without waiting for events
+ *    back from the X server; we don't want to draw intermediate
+ *    partially-stacked stack states just because we haven't received
+ *    some notification yet.
+ *
+ *  - Only the X server has an accurate view of the complete stacking;
+ *    when we make a request to restack windows, we don't know how
+ *    it will affect override-redirect windows, because at any point
+ *    applications may restack these windows without our involvement.
+ *
+ * The technique we use is that we keep three sets of information:
+ *
+ *  - The stacking order on the server as known from the last
+ *    event we received.
+ *  - A queue of stacking requests that *we* made subsequent to
+ *    that last event.
+ *  - A predicted stacking order, derived from applying the queued
+ *    requests to the last state from the server.
+ *
+ * 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) 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
+ *    linear lookups.
+ *  Keep the stacks as a GList + reverse-mapping hash table to avoid
+ *    linear lookups and to make restacking constant-time.
+ */
+
+typedef union _MetaStackOp MetaStackOp;
+
+typedef enum {
+  STACK_OP_ADD,
+  STACK_OP_REMOVE,
+  STACK_OP_RAISE_ABOVE,
+  STACK_OP_LOWER_BELOW
+} MetaStackOpType;
+
+/* MetaStackOp represents a "stacking operation" - a change to
+ * apply to a window stack. Depending on the context, it could
+ * either reflect a request we have sent to the server, or a
+ * notification event we received from the X server.
+ */
+union _MetaStackOp
+{
+  struct {
+    MetaStackOpType type;
+    gulong serial;
+  } any;
+  struct {
+    MetaStackOpType type;
+    gulong serial;
+    Window window;
+  } add;
+  struct {
+    MetaStackOpType type;
+    gulong serial;
+    Window window;
+  } remove;
+  struct {
+    MetaStackOpType type;
+    gulong serial;
+    Window window;
+    Window sibling;
+  } raise_above;
+  struct {
+    MetaStackOpType type;
+    gulong serial;
+    Window window;
+    Window sibling;
+  } lower_below;
+};
+
+struct _MetaStackTracker
+{
+  MetaScreen *screen;
+
+  /* This is the last state of the stack as based on events received
+   * from the X server.
+   */
+  GArray *server_stack;
+
+  /* This is the serial of the last request we made that was reflected
+   * in server_stack
+   */
+  gulong server_serial;
+
+  /* This is a queue of requests we've made to change the stacking order,
+   * where we haven't yet gotten a reply back from the server.
+   */
+  GQueue *queued_requests;
+
+  /* This is how we think the stack is, based on server_stack, and
+   * on requests we've made subsequent to server_stack
+   */
+  GArray *predicted_stack;
+
+  /* Idle function used to sync the compositor's view of the window
+   * stack up with our best guess before a frame is drawn.
+   */
+  guint sync_stack_later;
+};
+
+static void
+meta_stack_op_dump (MetaStackOp *op,
+		    const char  *prefix,
+		    const char  *suffix)
+{
+  switch (op->any.type)
+    {
+    case STACK_OP_ADD:
+      meta_topic (META_DEBUG_STACK, "%sADD(%#lx; %ld)%s",
+		  prefix, op->add.window, op->any.serial, suffix);
+      break;
+    case STACK_OP_REMOVE:
+      meta_topic (META_DEBUG_STACK, "%sREMOVE(%#lx; %ld)%s",
+		  prefix, op->add.window, op->any.serial, suffix);
+      break;
+    case STACK_OP_RAISE_ABOVE:
+      meta_topic (META_DEBUG_STACK, "%sRAISE_ABOVE(%#lx, %#lx; %ld)%s",
+		  prefix,
+                  op->raise_above.window, op->raise_above.sibling,
+                  op->any.serial,
+                  suffix);
+      break;
+    case STACK_OP_LOWER_BELOW:
+      meta_topic (META_DEBUG_STACK, "%sLOWER_BELOW(%#lx, %#lx; %ld)%s",
+		  prefix,
+                  op->lower_below.window, op->lower_below.sibling,
+                  op->any.serial,
+                  suffix);
+      break;
+    }
+}
+
+static void
+meta_stack_tracker_dump (MetaStackTracker *tracker)
+{
+  guint i;
+  GList *l;
+
+  meta_topic (META_DEBUG_STACK, "MetaStackTracker state (screen=%d)\n", tracker->screen->number);
+  meta_push_no_msg_prefix ();
+  meta_topic (META_DEBUG_STACK, "  server_serial: %ld\n", tracker->server_serial);
+  meta_topic (META_DEBUG_STACK, "  server_stack: ");
+  for (i = 0; i < tracker->server_stack->len; i++)
+    meta_topic (META_DEBUG_STACK, "  %#lx", g_array_index (tracker->server_stack, Window, i));
+  if (tracker->predicted_stack)
+    {
+      meta_topic (META_DEBUG_STACK, "\n  predicted_stack: ");
+      for (i = 0; i < tracker->predicted_stack->len; i++)
+	meta_topic (META_DEBUG_STACK, "  %#lx", g_array_index (tracker->predicted_stack, Window, i));
+    }
+  meta_topic (META_DEBUG_STACK, "\n  queued_requests: [");
+  for (l = tracker->queued_requests->head; l; l = l->next)
+    {
+      MetaStackOp *op = l->data;
+      meta_stack_op_dump (op, "", l->next ? ", " : "");
+    }
+  meta_topic (META_DEBUG_STACK, "]\n");
+  meta_pop_no_msg_prefix ();
+}
+
+static void
+meta_stack_op_free (MetaStackOp *op)
+{
+  g_slice_free (MetaStackOp, op);
+}
+
+static int
+find_window (GArray *stack,
+	     Window  window)
+{
+  guint i;
+
+  for (i = 0; i < stack->len; i++)
+    if (g_array_index (stack, Window, i) == window)
+      return i;
+
+  return -1;
+}
+
+/* Returns TRUE if stack was changed */
+static gboolean
+move_window_above (GArray *stack,
+                   Window  window,
+                   int     old_pos,
+                   int     above_pos)
+{
+  int i;
+
+  if (old_pos < above_pos)
+    {
+      for (i = old_pos; i < above_pos; i++)
+	g_array_index (stack, Window, i) = g_array_index (stack, Window, i + 1);
+
+      g_array_index (stack, Window, above_pos) = window;
+
+      return TRUE;
+    }
+  else if (old_pos > above_pos + 1)
+    {
+      for (i = old_pos; i > above_pos + 1; i--)
+	g_array_index (stack, Window, i) = g_array_index (stack, Window, i - 1);
+
+      g_array_index (stack, Window, above_pos + 1) = window;
+
+      return TRUE;
+    }
+  else
+    return FALSE;
+}
+
+/* Returns TRUE if stack was changed */
+static gboolean
+meta_stack_op_apply (MetaStackOp *op,
+		     GArray      *stack)
+{
+  switch (op->any.type)
+    {
+    case STACK_OP_ADD:
+      {
+	int old_pos = find_window (stack, op->add.window);
+	if (old_pos >= 0)
+	  {
+	    g_warning ("STACK_OP_ADD: window %#lx already in stack",
+		       op->add.window);
+	    return FALSE;
+	  }
+
+	g_array_append_val (stack, op->add.window);
+	return TRUE;
+      }
+    case STACK_OP_REMOVE:
+      {
+	int old_pos = find_window (stack, op->remove.window);
+	if (old_pos < 0)
+	  {
+	    g_warning ("STACK_OP_REMOVE: window %#lx not in stack",
+		       op->remove.window);
+	    return FALSE;
+	  }
+
+	g_array_remove_index (stack, old_pos);
+	return TRUE;
+      }
+    case STACK_OP_RAISE_ABOVE:
+      {
+	int old_pos = find_window (stack, op->raise_above.window);
+	int above_pos;
+	if (old_pos < 0)
+	  {
+	    g_warning ("STACK_OP_RAISE_ABOVE: window %#lx not in stack",
+		       op->raise_above.window);
+	    return FALSE;
+	  }
+
+	if (op->raise_above.sibling != None)
+	  {
+	    above_pos = find_window (stack, op->raise_above.sibling);
+	    if (above_pos < 0)
+	      {
+		g_warning ("STACK_OP_RAISE_ABOVE: sibling window %#lx not in stack",
+			   op->raise_above.sibling);
+		return FALSE;
+	      }
+	  }
+	else
+	  {
+	    above_pos = -1;
+	  }
+
+	return move_window_above (stack, op->raise_above.window, old_pos, above_pos);
+      }
+    case STACK_OP_LOWER_BELOW:
+      {
+	int old_pos = find_window (stack, op->lower_below.window);
+	int above_pos;
+	if (old_pos < 0)
+	  {
+	    g_warning ("STACK_OP_LOWER_BELOW: window %#lx not in stack",
+		       op->lower_below.window);
+	    return FALSE;
+	  }
+
+	if (op->lower_below.sibling != None)
+	  {
+	    int below_pos = find_window (stack, op->lower_below.sibling);
+	    if (below_pos < 0)
+	      {
+		g_warning ("STACK_OP_LOWER_BELOW: sibling window %#lx not in stack",
+			   op->lower_below.sibling);
+		return FALSE;
+	      }
+
+	    above_pos = below_pos - 1;
+	  }
+	else
+	  {
+	    above_pos = stack->len - 1;
+	  }
+
+	return move_window_above (stack, op->lower_below.window, old_pos, above_pos);
+      }
+    }
+
+  g_assert_not_reached ();
+  return FALSE;
+}
+
+static GArray *
+copy_stack (Window *windows,
+	    guint   n_windows)
+{
+  GArray *stack = g_array_new (FALSE, FALSE, sizeof (Window));
+
+  g_array_set_size (stack, n_windows);
+  memcpy (stack->data, windows, sizeof (Window) * n_windows);
+
+  return stack;
+}
+
+MetaStackTracker *
+meta_stack_tracker_new (MetaScreen *screen)
+{
+  MetaStackTracker *tracker;
+  Window ignored1, ignored2;
+  Window *children;
+  guint n_children;
+
+  tracker = g_new0 (MetaStackTracker, 1);
+  tracker->screen = screen;
+
+  tracker->server_serial = XNextRequest (screen->display->xdisplay);
+
+  XQueryTree (screen->display->xdisplay,
+              screen->xroot,
+              &ignored1, &ignored2, &children, &n_children);
+  tracker->server_stack = copy_stack (children, n_children);
+  XFree (children);
+
+  tracker->queued_requests = g_queue_new ();
+
+  return tracker;
+}
+
+void
+meta_stack_tracker_free (MetaStackTracker *tracker)
+{
+  if (tracker->sync_stack_later)
+    meta_later_remove (tracker->sync_stack_later);
+
+  g_array_free (tracker->server_stack, TRUE);
+  if (tracker->predicted_stack)
+    g_array_free (tracker->predicted_stack, TRUE);
+
+  g_queue_foreach (tracker->queued_requests, (GFunc)meta_stack_op_free, NULL);
+  g_queue_free (tracker->queued_requests);
+  tracker->queued_requests = NULL;
+}
+
+static void
+stack_tracker_queue_request (MetaStackTracker *tracker,
+			     MetaStackOp      *op)
+{
+  meta_stack_op_dump (op, "Queueing: ", "\n");
+  g_queue_push_tail (tracker->queued_requests, op);
+  if (!tracker->predicted_stack ||
+      meta_stack_op_apply (op, tracker->predicted_stack))
+    meta_stack_tracker_queue_sync_stack (tracker);
+
+  meta_stack_tracker_dump (tracker);
+}
+
+void
+meta_stack_tracker_record_add (MetaStackTracker *tracker,
+			       Window            window,
+			       gulong            serial)
+{
+  MetaStackOp *op = g_slice_new (MetaStackOp);
+
+  op->any.type = STACK_OP_ADD;
+  op->any.serial = serial;
+  op->add.window = window;
+
+  stack_tracker_queue_request (tracker, op);
+}
+
+void
+meta_stack_tracker_record_remove (MetaStackTracker *tracker,
+				  Window            window,
+				  gulong            serial)
+{
+  MetaStackOp *op = g_slice_new (MetaStackOp);
+
+  op->any.type = STACK_OP_REMOVE;
+  op->any.serial = serial;
+  op->remove.window = window;
+
+  stack_tracker_queue_request (tracker, op);
+}
+
+void
+meta_stack_tracker_record_restack_windows (MetaStackTracker *tracker,
+					   Window           *windows,
+					   int               n_windows,
+					   gulong            serial)
+{
+  int i;
+
+  /* XRestackWindows() isn't actually a X requests - it's broken down
+   * by XLib into a series of XConfigureWindow(StackMode=below); we
+   * mirror that exactly here.
+   *
+   * Aside: Having a separate StackOp for this would be possible to
+   * get some extra efficiency in memory allocation and in applying
+   * the op, at the expense of a code complexity. Implementation hint
+   * for that - keep op->restack_window.n_complete, and when receiving
+   * events with intermediate serials, set n_complete rather than
+   * removing the op from the queue.
+   */
+  for (i = 0; i < n_windows - 1; i++)
+    meta_stack_tracker_record_lower_below (tracker, windows[i + 1], windows[i],
+					   serial + i);
+}
+
+void
+meta_stack_tracker_record_raise_above (MetaStackTracker *tracker,
+				       Window            window,
+				       Window            sibling,
+				       gulong            serial)
+{
+  MetaStackOp *op = g_slice_new (MetaStackOp);
+
+  op->any.type = STACK_OP_RAISE_ABOVE;
+  op->any.serial = serial;
+  op->raise_above.window = window;
+  op->raise_above.sibling = sibling;
+
+  stack_tracker_queue_request (tracker, op);
+}
+
+void
+meta_stack_tracker_record_lower_below (MetaStackTracker *tracker,
+				       Window            window,
+				       Window            sibling,
+				       gulong            serial)
+{
+  MetaStackOp *op = g_slice_new (MetaStackOp);
+
+  op->any.type = STACK_OP_LOWER_BELOW;
+  op->any.serial = serial;
+  op->lower_below.window = window;
+  op->lower_below.sibling = sibling;
+
+  stack_tracker_queue_request (tracker, op);
+}
+
+void
+meta_stack_tracker_record_lower (MetaStackTracker *tracker,
+				 Window            window,
+				 gulong            serial)
+{
+  meta_stack_tracker_record_raise_above (tracker, window, None, serial);
+}
+
+static void
+stack_tracker_event_received (MetaStackTracker *tracker,
+			      MetaStackOp      *op)
+{
+  meta_stack_op_dump (op, "Stack op event received: ", "\n");
+
+  if (op->any.serial < tracker->server_serial)
+    return;
+
+  tracker->server_serial = op->any.serial;
+
+  meta_stack_op_apply (op, tracker->server_stack);
+
+  while (tracker->queued_requests->head)
+    {
+      MetaStackOp *queued_op = tracker->queued_requests->head->data;
+      if (queued_op->any.serial > op->any.serial)
+	break;
+
+      g_queue_pop_head (tracker->queued_requests);
+      meta_stack_op_free (queued_op);
+    }
+
+  if (tracker->predicted_stack)
+    {
+      g_array_free (tracker->predicted_stack, TRUE);
+      tracker->predicted_stack = NULL;
+    }
+
+  meta_stack_tracker_dump (tracker);
+
+  meta_stack_tracker_queue_sync_stack (tracker);
+}
+
+void
+meta_stack_tracker_create_event (MetaStackTracker    *tracker,
+				 XCreateWindowEvent  *event)
+{
+  MetaStackOp op;
+
+  op.any.type = STACK_OP_ADD;
+  op.any.serial = event->serial;
+  op.add.window = event->window;
+
+  stack_tracker_event_received (tracker, &op);
+}
+
+void
+meta_stack_tracker_destroy_event (MetaStackTracker    *tracker,
+				  XDestroyWindowEvent *event)
+{
+  MetaStackOp op;
+
+  op.any.type = STACK_OP_REMOVE;
+  op.any.serial = event->serial;
+  op.remove.window = event->window;
+
+  stack_tracker_event_received (tracker, &op);
+}
+
+void
+meta_stack_tracker_reparent_event (MetaStackTracker    *tracker,
+				   XReparentEvent      *event)
+{
+  if (event->parent == event->event)
+    {
+      MetaStackOp op;
+
+      op.any.type = STACK_OP_ADD;
+      op.any.serial = event->serial;
+      op.add.window = event->window;
+
+      stack_tracker_event_received (tracker, &op);
+    }
+  else
+    {
+      MetaStackOp op;
+
+      op.any.type = STACK_OP_REMOVE;
+      op.any.serial = event->serial;
+      op.remove.window = event->window;
+
+      stack_tracker_event_received (tracker, &op);
+    }
+}
+
+void
+meta_stack_tracker_configure_event (MetaStackTracker    *tracker,
+				    XConfigureEvent     *event)
+{
+  MetaStackOp op;
+
+  op.any.type = STACK_OP_RAISE_ABOVE;
+  op.any.serial = event->serial;
+  op.raise_above.window = event->window;
+  op.raise_above.sibling = event->above;
+
+  stack_tracker_event_received (tracker, &op);
+}
+
+/**
+ * meta_stack_tracker_get_stack:
+ * @tracker: a #MetaStackTracker
+ * @windows: location to store list of windows, or %NULL
+ * @n_windows: location to store count of windows, or %NULL
+ *
+ * Returns the most current view we have of the stacking order
+ * of the children of the root window. The returned array contains
+ * everything: InputOnly windows, override-redirect windows,
+ * hidden windows, etc. Some of these will correspond to MetaWindow
+ * objects, others won't.
+ *
+ * Assuming that no other clients have made requests that change
+ * the stacking order since we last received a notification, the
+ * returned list of windows is exactly that you'd get as the
+ * children when calling XQueryTree() on the root window.
+ */
+void
+meta_stack_tracker_get_stack (MetaStackTracker *tracker,
+			      Window          **windows,
+			      int              *n_windows)
+{
+  GArray *stack;
+
+  if (tracker->queued_requests->length == 0)
+    {
+      stack = tracker->server_stack;
+    }
+  else
+    {
+      if (tracker->predicted_stack == NULL)
+        {
+          GList *l;
+
+          tracker->predicted_stack = copy_stack ((Window *)tracker->server_stack->data,
+                                                 tracker->server_stack->len);
+          for (l = tracker->queued_requests->head; l; l = l->next)
+            {
+              MetaStackOp *op = l->data;
+              meta_stack_op_apply (op, tracker->predicted_stack);
+            }
+        }
+
+      stack = tracker->predicted_stack;
+    }
+
+  if (windows)
+    *windows = (Window *)stack->data;
+  if (n_windows)
+    *n_windows = stack->len;
+}
+
+/**
+ * meta_stack_tracker_sync_stack:
+ * @tracker: a #MetaStackTracker
+ *
+ * Informs the compositor of the current stacking order of windows,
+ * based on the predicted view maintained by the #MetaStackTracker.
+ */
+void
+meta_stack_tracker_sync_stack (MetaStackTracker *tracker)
+{
+  GList *meta_windows;
+  Window *windows;
+  int n_windows;
+  int i;
+
+  if (tracker->sync_stack_later)
+    {
+      meta_later_remove (tracker->sync_stack_later);
+      tracker->sync_stack_later = 0;
+    }
+
+  meta_stack_tracker_get_stack (tracker, &windows, &n_windows);
+
+  meta_windows = NULL;
+  for (i = 0; i < n_windows; i++)
+    {
+      MetaWindow *meta_window;
+
+      meta_window = meta_display_lookup_x_window (tracker->screen->display,
+                                                  windows[i]);
+      if (meta_window)
+        meta_windows = g_list_prepend (meta_windows, meta_window);
+    }
+
+  if (tracker->screen->display->compositor)
+    meta_compositor_sync_stack (tracker->screen->display->compositor,
+                                tracker->screen,
+                                meta_windows);
+  g_list_free (meta_windows);
+
+  meta_screen_restacked (tracker->screen);
+}
+
+static gboolean
+stack_tracker_sync_stack_later (gpointer data)
+{
+  meta_stack_tracker_sync_stack (data);
+
+  return FALSE;
+}
+
+/**
+ * meta_stack_tracker_queue_sync_stack:
+ * @tracker: a #MetaStackTracker
+ *
+ * Queue informing the compositor of the new stacking order before the
+ * next redraw. (See meta_stack_tracker_sync_stack()). This is called
+ * internally when the stack of X windows changes, but also needs be
+ * called directly when we an undecorated window is first shown or
+ * withdrawn since the compositor's stacking order (which contains only
+ * the windows that have a corresponding MetaWindow) will change without
+ * any change to the stacking order of the X windows, if we are creating
+ * or destroying MetaWindows.
+ */
+void
+meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker)
+{
+  if (tracker->sync_stack_later == 0)
+    {
+      tracker->sync_stack_later = meta_later_add (META_LATER_BEFORE_REDRAW,
+                                                  stack_tracker_sync_stack_later,
+                                                  tracker, NULL);
+    }
+}
+

src/core/stack-tracker.h

@@ -0,0 +1,89 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/**
+ * \file stack-tracker.h  Track stacking order for compositor
+ *
+ * MetaStackTracker maintains the most accurate view we have at a
+ * given point of time of the ordering of the children of the root
+ * window (including override-redirect windows.) This is used to order
+ * the windows when the compositor draws them.
+ *
+ * By contrast, MetaStack is responsible for keeping track of how we
+ * think that windows *should* be ordered.  For windows we manage
+ * (non-override-redirect windows), the two stacking orders will be
+ * the same.
+ */
+
+/*
+ * Copyright (C) 2009 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_STACK_TRACKER_H
+#define META_STACK_TRACKER_H
+
+#include "screen.h"
+
+typedef struct _MetaStackTracker MetaStackTracker;
+
+MetaStackTracker *meta_stack_tracker_new  (MetaScreen       *screen);
+void              meta_stack_tracker_free (MetaStackTracker *tracker);
+
+/* These functions are called when we make an X call that changes the
+ * stacking order; this allows MetaStackTracker to predict stacking
+ * order before it receives events back from the X server */
+void meta_stack_tracker_record_add             (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);
+void meta_stack_tracker_record_remove          (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);
+void meta_stack_tracker_record_restack_windows (MetaStackTracker *tracker,
+						Window           *windows,
+						int               n_windows,
+                                                gulong            serial);
+void meta_stack_tracker_record_raise_above     (MetaStackTracker *tracker,
+						Window            window,
+						Window            sibling,
+                                                gulong            serial);
+void meta_stack_tracker_record_lower_below    (MetaStackTracker *tracker,
+						Window            window,
+						Window            sibling,
+                                                gulong            serial);
+void meta_stack_tracker_record_lower           (MetaStackTracker *tracker,
+						Window            window,
+                                                gulong            serial);
+
+/* These functions are used to update the stack when we get events
+ * reflecting changes to the stacking order */
+void meta_stack_tracker_create_event    (MetaStackTracker    *tracker,
+					 XCreateWindowEvent  *event);
+void meta_stack_tracker_destroy_event   (MetaStackTracker    *tracker,
+					 XDestroyWindowEvent *event);
+void meta_stack_tracker_reparent_event  (MetaStackTracker    *tracker,
+					 XReparentEvent      *event);
+void meta_stack_tracker_configure_event (MetaStackTracker    *tracker,
+					 XConfigureEvent     *event);
+
+void meta_stack_tracker_get_stack  (MetaStackTracker  *tracker,
+                                    Window           **windows,
+                                    int               *n_windows);
+
+void meta_stack_tracker_sync_stack       (MetaStackTracker *tracker);
+void meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker);
+
+#endif /* META_STACK_TRACKER_H */

src/core/stack.c

@@ -35,10 +35,6 @@
 #include "prefs.h"
 #include "workspace.h"
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-#include "compositor.h"
-#endif
-
 #include <X11/Xatom.h>
 
 #define WINDOW_HAS_TRANSIENT_TYPE(w)                    \
@@ -228,14 +224,14 @@ is_focused_foreach (MetaWindow *window,
 }
 
 static gboolean
-windows_on_different_xinerama (MetaWindow *a,
-                               MetaWindow *b)
+windows_on_different_monitor (MetaWindow *a,
+                              MetaWindow *b)
 {
   if (a->screen != b->screen)
     return TRUE;
 
-  return meta_screen_get_xinerama_for_window (a->screen, a) !=
-    meta_screen_get_xinerama_for_window (b->screen, b);
+  return meta_screen_get_monitor_for_window (a->screen, a) !=
+    meta_screen_get_monitor_for_window (b->screen, b);
 }
 
 /* Get layer ignoring any transient or group relationships */
@@ -245,12 +241,6 @@ get_standalone_layer (MetaWindow *window)
   MetaStackLayer layer;
   gboolean focused_transient = FALSE;
 
-  if (window->hidden)
-    {
-      layer = META_LAYER_DESKTOP;
-      return layer;
-    }
-
   switch (window->type)
     {
     case META_WINDOW_DESKTOP:
@@ -285,8 +275,8 @@ get_standalone_layer (MetaWindow *window)
                 window == window->display->expected_focus_window ||
                 window->display->expected_focus_window == NULL ||
                 (window->display->expected_focus_window != NULL &&
-                 windows_on_different_xinerama (window,
-                                                window->display->expected_focus_window))))
+                 windows_on_different_monitor (window,
+                                               window->display->expected_focus_window))))
         layer = META_LAYER_FULLSCREEN;
       else if (window->wm_state_above)
         layer = META_LAYER_TOP;
@@ -964,41 +954,33 @@ stack_ensure_sorted (MetaStack *stack)
  * This function is used to avoid raising a window above popup
  * menus and other such things.
  *
- * FIXME This is sort of an expensive function, should probably
- * do something to avoid it. One approach would be to reverse
- * the stacking algorithm to work by placing each window above
- * the others, and start by lowering a window to the bottom
- * (instead of the current way, which works by placing each
- * window below another and starting with a raise)
+ * The key to the operation of this function is that we are expecting
+ * at most one window to be added at a time. If xwindow is newly added,
+ * then its own stack position will be too high (the frame window
+ * is created at the top of the stack), but if we ignore xwindow,
+ * then the *next* managed window in the stack will be a window that
+ * we've already stacked.
+ *
+ * We could generalize this and remove the assumption that windows
+ * are added one at a time by keeping an explicit ->stacked flag in
+ * MetaWindow.
+ *
+ * An alternate approach would be to reverse the stacking algorithm to
+ * work by placing each window above the others, and start by lowering
+ * a window to the bottom (instead of the current way, which works by
+ * placing each window below another and starting with a raise)
  */
 static void
 raise_window_relative_to_managed_windows (MetaScreen *screen,
                                           Window      xwindow)
 {
 
-  Window ignored1, ignored2;
   Window *children;
-  unsigned int n_children;
+  int n_children;
   int i;
 
-  /* Normally XQueryTree() means "must grab server" but here
-   * we don't, since we know we won't manage any new windows
-   * or restack any windows before using the XQueryTree results.
-   */
-  
-  meta_error_trap_push_with_return (screen->display);
-  
-  XQueryTree (screen->display->xdisplay,
-              screen->xroot,
-              &ignored1, &ignored2, &children, &n_children);
-
-  if (meta_error_trap_pop_with_return (screen->display, TRUE) != Success)
-    {
-      meta_topic (META_DEBUG_STACK,
-                  "Error querying root children to raise window 0x%lx\n",
-                  xwindow);
-      return;
-    }
+  meta_stack_tracker_get_stack (screen->stack_tracker,
+                                &children, &n_children);
 
   /* Children are in order from bottom to top. We want to
    * find the topmost managed child, then configure
@@ -1019,27 +1001,35 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
            * to be moved below.
            */
         }
-      else if (meta_display_lookup_x_window (screen->display,
-                                             children[i]) != NULL)
+      else
         {
-          XWindowChanges changes;
-          
-          /* children[i] is the topmost managed child */
-          meta_topic (META_DEBUG_STACK,
-                      "Moving 0x%lx above topmost managed child window 0x%lx\n",
-                      xwindow, children[i]);
+          MetaWindow *other = meta_display_lookup_x_window (screen->display,
+                                                            children[i]);
+          if (other != NULL && !other->override_redirect)
+            {
+              XWindowChanges changes;
 
-          changes.sibling = children[i];
-          changes.stack_mode = Above;
+              /* children[i] is the topmost managed child */
+              meta_topic (META_DEBUG_STACK,
+                          "Moving 0x%lx above topmost managed child window 0x%lx\n",
+                          xwindow, children[i]);
 
-          meta_error_trap_push (screen->display);
-          XConfigureWindow (screen->display->xdisplay,
-                            xwindow,
-                            CWSibling | CWStackMode,
-                            &changes);
-          meta_error_trap_pop (screen->display, FALSE);
+              changes.sibling = children[i];
+              changes.stack_mode = Above;
 
-          break;
+              meta_error_trap_push (screen->display);
+              meta_stack_tracker_record_raise_above (screen->stack_tracker,
+                                                     xwindow,
+                                                     children[i],
+                                                     XNextRequest (screen->display->xdisplay));
+              XConfigureWindow (screen->display->xdisplay,
+                                xwindow,
+                                CWSibling | CWStackMode,
+                                &changes);
+              meta_error_trap_pop (screen->display, FALSE);
+
+              break;
+            }
         }
 
       --i;
@@ -1051,13 +1041,13 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
        * to be sure we're below any override redirect windows.
        */
       meta_error_trap_push (screen->display);
+      meta_stack_tracker_record_lower (screen->stack_tracker,
+                                       xwindow,
+                                       XNextRequest (screen->display->xdisplay));
       XLowerWindow (screen->display->xdisplay,
                     xwindow);
       meta_error_trap_pop (screen->display, FALSE);
     }
-  
-  if (children)
-    XFree (children);
 }
 
 /**
@@ -1066,6 +1056,10 @@ raise_window_relative_to_managed_windows (MetaScreen *screen,
  * or XConfigureWindow on a few particular windows if we do and can figure
  * out the minimum set of changes.  After that, we set __NET_CLIENT_LIST
  * and __NET_CLIENT_LIST_STACKING.
+ *
+ * FIXME: Now that we have a good view of the stacking order on the server
+ * with MetaStackTracker it should be possible to do a simpler and better
+ * job of computing the minimal set of stacking requests needed.
  */
 static void
 stack_sync_to_server (MetaStack *stack)
@@ -1084,10 +1078,6 @@ stack_sync_to_server (MetaStack *stack)
 
   stack_ensure_sorted (stack);
 
-  meta_compositor_sync_stack (stack->screen->display->compositor,
-			      stack->screen,
-			      stack->sorted);
-  
   /* Create stacked xwindow arrays.
    * Painfully, "stacked" is in bottom-to-top order for the
    * _NET hints, and "root_children_stacked" is in top-to-bottom
@@ -1159,9 +1149,15 @@ stack_sync_to_server (MetaStack *stack)
       meta_topic (META_DEBUG_STACK, "Don't know last stack state, restacking everything\n");
 
       if (root_children_stacked->len > 0)
-        XRestackWindows (stack->screen->display->xdisplay,
-                         (Window *) root_children_stacked->data,
-                         root_children_stacked->len);
+        {
+          meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
+                                                     (Window *) root_children_stacked->data,
+                                                     root_children_stacked->len,
+                                                     XNextRequest (stack->screen->display->xdisplay));
+          XRestackWindows (stack->screen->display->xdisplay,
+                           (Window *) root_children_stacked->data,
+                           root_children_stacked->len);
+        }
     }
   else if (root_children_stacked->len > 0)
     {
@@ -1223,7 +1219,10 @@ stack_sync_to_server (MetaStack *stack)
 
                   meta_topic (META_DEBUG_STACK, "Placing window 0x%lx below 0x%lx\n",
                               *newp, last_window);
-                  
+
+                  meta_stack_tracker_record_lower_below (stack->screen->stack_tracker,
+                                                         *newp, last_window,
+                                                         XNextRequest (stack->screen->display->xdisplay));
                   XConfigureWindow (stack->screen->display->xdisplay,
                                     *newp,
                                     CWSibling | CWStackMode,
@@ -1246,13 +1245,23 @@ stack_sync_to_server (MetaStack *stack)
            */
           if (newp != new_stack)
             --newp;
+          meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
+                                                     (Window *) newp, new_end - newp,
+                                                     XNextRequest (stack->screen->display->xdisplay));
           XRestackWindows (stack->screen->display->xdisplay,
                            (Window *) newp, new_end - newp);
         }
     }
 
   /* Push hidden windows to the bottom of the stack under the guard window */
+  meta_stack_tracker_record_lower (stack->screen->stack_tracker,
+                                   stack->screen->guard_window,
+                                   XNextRequest (stack->screen->display->xdisplay));
   XLowerWindow (stack->screen->display->xdisplay, stack->screen->guard_window);
+  meta_stack_tracker_record_restack_windows (stack->screen->stack_tracker,
+                                             (Window *)all_hidden->data,
+                                             all_hidden->len,
+                                             XNextRequest (stack->screen->display->xdisplay));
   XRestackWindows (stack->screen->display->xdisplay,
 		   (Window *)all_hidden->data,
 		   all_hidden->len);
@@ -1286,8 +1295,6 @@ stack_sync_to_server (MetaStack *stack)
   if (stack->last_root_children_stacked)
     g_array_free (stack->last_root_children_stacked, TRUE);
   stack->last_root_children_stacked = root_children_stacked;
-  
-  meta_screen_restacked (stack->screen);
 
   /* That was scary... */
 }

src/core/testboxes.c

@@ -85,7 +85,7 @@ new_screen_edge (int x, int y, int width, int height, int side_type)
 }
 
 static MetaEdge*
-new_xinerama_edge (int x, int y, int width, int height, int side_type)
+new_monitor_edge (int x, int y, int width, int height, int side_type)
 {
   MetaEdge* temporary;
   temporary = g_new (MetaEdge, 1);
@@ -94,7 +94,7 @@ new_xinerama_edge (int x, int y, int width, int height, int side_type)
   temporary->rect.width  = width;
   temporary->rect.height = height;
   temporary->side_type = side_type;
-  temporary->edge_type = META_EDGE_XINERAMA;
+  temporary->edge_type = META_EDGE_MONITOR;
 
   return temporary;
 }
@@ -317,15 +317,15 @@ get_screen_edges (int which)
 }
 
 static GList*
-get_xinerama_edges (int which_xinerama_set, int which_strut_set)
+get_monitor_edges (int which_monitor_set, int which_strut_set)
 {
   GList *ret;
   GSList *struts;
   GList *xins;
 
   xins = NULL;
-  g_assert (which_xinerama_set >=0 && which_xinerama_set <= 3);
-  switch (which_xinerama_set)
+  g_assert (which_monitor_set >=0 && which_monitor_set <= 3);
+  switch (which_monitor_set)
     {
     case 0:
       xins = g_list_prepend (xins, new_meta_rect (  0,   0, 1600, 1200));
@@ -348,7 +348,7 @@ get_xinerama_edges (int which_xinerama_set, int which_strut_set)
   ret = NULL;
 
   struts = get_strut_list (which_strut_set);
-  ret = meta_rectangle_find_nonintersected_xinerama_edges (xins, struts);
+  ret = meta_rectangle_find_nonintersected_monitor_edges (xins, struts);
 
   free_strut_list (struts);
   meta_rectangle_free_list_and_elements (xins);
@@ -1145,7 +1145,7 @@ test_find_onscreen_edges ()
 }
 
 static void
-test_find_nonintersected_xinerama_edges ()
+test_find_nonintersected_monitor_edges ()
 {
   GList* edges;
   GList* tmp;
@@ -1156,32 +1156,32 @@ test_find_nonintersected_xinerama_edges ()
   int bottom = META_DIRECTION_BOTTOM;
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 0 for with region 0 has the correct edges */
+  /* Make sure test monitor set 0 for with region 0 has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (0, 0);
+  edges = get_monitor_edges (0, 0);
   tmp = NULL;
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 2 for with region 1 has the correct edges */
+  /* Make sure test monitor set 2 for with region 1 has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (2, 1);
+  edges = get_monitor_edges (2, 1);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, bottom));
-  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600, 1600, 0, top));
+  tmp = g_list_prepend (tmp, new_monitor_edge (   0,  600, 1600, 0, bottom));
+  tmp = g_list_prepend (tmp, new_monitor_edge (   0,  600, 1600, 0, top));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 1 for with region 2 has the correct edges */
+  /* Make sure test monitor set 1 for with region 2 has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (1, 2);
+  edges = get_monitor_edges (1, 2);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1080, right));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,   20, 0, 1180, left));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,   20, 0, 1080, right));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,   20, 0, 1180, left));
 #if 0
   #define FUDGE 50
   char big_buffer1[(EDGE_LENGTH+2)*FUDGE], big_buffer2[(EDGE_LENGTH+2)*FUDGE];
@@ -1195,36 +1195,36 @@ test_find_nonintersected_xinerama_edges ()
   meta_rectangle_free_list_and_elements (edges);
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 3 for with region 3 has the correct edges */
+  /* Make sure test monitor set 3 for with region 3 has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (3, 3);
+  edges = get_monitor_edges (3, 3);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, bottom));
-  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, bottom));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 900,  600,  700, 0, top));
-  tmp = g_list_prepend (tmp, new_xinerama_edge (   0,  600,  700, 0, top));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  425, right));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  675, 0,  525, left));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 900,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_monitor_edge (   0,  600,  700, 0, bottom));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 900,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_monitor_edge (   0,  600,  700, 0, top));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,  675, 0,  425, right));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,  675, 0,  525, left));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 3 for with region 4 has the correct edges */
+  /* Make sure test monitor set 3 for with region 4 has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (3, 4);
+  edges = get_monitor_edges (3, 4);
   tmp = NULL;
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, bottom));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  800, 0, top));
-  tmp = g_list_prepend (tmp, new_xinerama_edge ( 800,  600,  0, 600, right));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,  600,  800, 0, bottom));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,  600,  800, 0, top));
+  tmp = g_list_prepend (tmp, new_monitor_edge ( 800,  600,  0, 600, right));
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
   meta_rectangle_free_list_and_elements (edges);
 
   /*************************************************************************/  
-  /* Make sure test xinerama set 3 for with region 5has the correct edges */
+  /* Make sure test monitor set 3 for with region 5has the correct edges */
   /*************************************************************************/  
-  edges = get_xinerama_edges (3, 5);
+  edges = get_monitor_edges (3, 5);
   tmp = NULL;
   verify_edge_lists_are_equal (edges, tmp);
   meta_rectangle_free_list_and_elements (tmp);
@@ -1405,7 +1405,7 @@ main()
 
   /* And now the functions dealing with edges more than boxes */
   test_find_onscreen_edges ();
-  test_find_nonintersected_xinerama_edges ();
+  test_find_nonintersected_monitor_edges ();
 
   /* And now the misfit functions that don't quite fit in anywhere else... */
   test_gravity_resize ();

src/core/util.c

@@ -26,9 +26,12 @@
 #define _POSIX_C_SOURCE 200112L /* for fdopen() */
 
 #include <config.h>
+#include "common.h"
 #include "util.h"
 #include "main.h"
 
+#include <clutter/clutter.h> /* For clutter_threads_add_repaint_func() */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -37,8 +40,6 @@
 #include <X11/Xlib.h>   /* must explicitly be included for Solaris; #326746 */
 #include <X11/Xutil.h>  /* Just for the definition of the various gravities */
 
-MetaNexus *sigchld_nexus;
-
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
 void
@@ -557,7 +558,7 @@ meta_show_dialog (const char *type,
   int i=0;
   GPid child_pid;
   const char **argvl = g_malloc(sizeof (char*) *
-                                (15 +
+                                (17 +
                                  g_slist_length (columns)*2 +
                                  g_slist_length (entries)));
 
@@ -565,6 +566,8 @@ meta_show_dialog (const char *type,
   argvl[i++] = type;
   argvl[i++] = "--screen";
   argvl[i++] = screen_number_text;
+  argvl[i++] = "--class";
+  argvl[i++] = "mutter-dialog";
   argvl[i++] = "--title";
   /* Translators: This is the title used on dialog boxes */
   argvl[i++] = _("Mutter");
@@ -638,29 +641,200 @@ meta_show_dialog (const char *type,
   return child_pid;
 }
 
-GType
-meta_nexus_get_type (void)
+/***************************************************************************
+ * Later functions: like idles but integrated with the Clutter repaint loop
+ ***************************************************************************/
+
+static guint last_later_id = 0;
+
+typedef struct
 {
-  static GType nexus_type = 0;
+  guint id;
+  MetaLaterType when;
+  GSourceFunc func;
+  gpointer data;
+  GDestroyNotify notify;
+  int source;
+  gboolean run_once;
+} MetaLater;
 
-  if (!nexus_type)
+static GSList *laters = NULL;
+/* This is a dummy timeline used to get the Clutter master clock running */
+static ClutterTimeline *later_timeline;
+static guint later_repaint_func = 0;
+
+static void ensure_later_repaint_func (void);
+
+static void
+destroy_later (MetaLater *later)
+{
+  if (later->source)
+    g_source_remove (later->source);
+  if (later->notify)
+    later->notify (later->data);
+  g_slice_free (MetaLater, later);
+}
+
+/* Used to sort the list of laters with the highest priority
+ * functions first.
+ */
+static int
+compare_laters (gconstpointer a,
+                gconstpointer b)
+{
+  return ((const MetaLater *)a)->when - ((const MetaLater *)b)->when;
+}
+
+static gboolean
+run_repaint_laters (gpointer data)
+{
+  GSList *old_laters = laters;
+  GSList *l;
+  gboolean keep_timeline_running = FALSE;
+  laters = NULL;
+
+  for (l = old_laters; l; l = l->next)
     {
-      static const GTypeInfo nexus_info =
-      {
-        sizeof (MetaNexusClass),
-	NULL, NULL, NULL, NULL, NULL,
-	sizeof (MetaNexus),
-	0,
-	NULL, NULL
-      };
-
-      nexus_type = g_type_register_static (G_TYPE_OBJECT,
-					   "MetaNexus",
-					   &nexus_info,
-					   0);
+      MetaLater *later = l->data;
+      if (later->source == 0 ||
+          (later->when <= META_LATER_BEFORE_REDRAW && !later->run_once))
+        {
+          if (later->func (later->data))
+            {
+              if (later->source == 0)
+                keep_timeline_running = TRUE;
+              laters = g_slist_insert_sorted (laters, later, compare_laters);
+            }
+          else
+            destroy_later (later);
+        }
+      else
+        laters = g_slist_insert_sorted (laters, later, compare_laters);
     }
 
-  return nexus_type;
+  if (!keep_timeline_running)
+    clutter_timeline_stop (later_timeline);
+
+  g_slist_free (old_laters);
+
+  /* Just keep the repaint func around - it's cheap if the list is empty */
+  return TRUE;
+}
+
+static void
+ensure_later_repaint_func (void)
+{
+  if (!later_timeline)
+    later_timeline = clutter_timeline_new (G_MAXUINT);
+
+  if (later_repaint_func == 0)
+    later_repaint_func = clutter_threads_add_repaint_func (run_repaint_laters,
+                                                           NULL, NULL);
+
+  /* Make sure the repaint function gets run */
+  clutter_timeline_start (later_timeline);
+}
+
+static gboolean
+call_idle_later (gpointer data)
+{
+  MetaLater *later = data;
+
+  if (!later->func (later->data))
+    {
+      laters = g_slist_remove (laters, later);
+      later->source = 0;
+      destroy_later (later);
+      return FALSE;
+    }
+  else
+    {
+      later->run_once = TRUE;
+      return TRUE;
+    }
+}
+
+/**
+ * meta_later_add:
+ * @when:     enumeration value determining the phase at which to run the callback
+ * @func:     callback to run later
+ * @data:     data to pass to the callback
+ * @notify:   function to call to destroy @data when it is no longer in use, or %NULL
+ *
+ * Sets up a callback  to be called at some later time. @when determines the
+ * particular later occasion at which it is called. This is much like g_idle_add(),
+ * except that the functions interact properly with clutter event handling.
+ * If a "later" function is added from a clutter event handler, and is supposed
+ * to be run before the stage is redrawn, it will be run before that redraw
+ * of the stage, not the next one.
+ *
+ * Return value: an integer ID (guaranteed to be non-zero) that can be used
+ *  to cancel the callback and prevent it from being run.
+ */
+guint
+meta_later_add (MetaLaterType  when,
+                GSourceFunc    func,
+                gpointer       data,
+                GDestroyNotify notify)
+{
+  MetaLater *later = g_slice_new0 (MetaLater);
+
+  later->id = ++last_later_id;
+  later->when = when;
+  later->func = func;
+  later->data = data;
+  later->notify = notify;
+
+  laters = g_slist_insert_sorted (laters, later, compare_laters);
+
+  switch (when)
+    {
+    case META_LATER_RESIZE:
+      /* We add this one two ways - as a high-priority idle and as a
+       * repaint func. If we are in a clutter event callback, the repaint
+       * handler will get hit first, and we'll take care of this function
+       * there so it gets called before the stage is redrawn, even if
+       * we haven't gotten back to the main loop. Otherwise, the idle
+       * handler will get hit first and we want to call this function
+       * there so it will happen before GTK+ repaints.
+       */
+      later->source = g_idle_add_full (META_PRIORITY_RESIZE, call_idle_later, later, NULL);
+      ensure_later_repaint_func ();
+      break;
+    case META_LATER_BEFORE_REDRAW:
+      ensure_later_repaint_func ();
+      break;
+    case META_LATER_IDLE:
+      later->source = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, call_idle_later, later, NULL);
+      break;
+    }
+
+  return later->id;
+}
+
+/**
+ * meta_later_remove:
+ * @later_id: the integer ID returned from meta_later_add()
+ *
+ * Removes a callback added with meta_later_add()
+ */
+void
+meta_later_remove (guint later_id)
+{
+  GSList *l;
+
+  for (l = laters; l; l = l->next)
+    {
+      MetaLater *later = l->data;
+      if (later->id == later_id)
+        {
+          laters = g_slist_remove_link (laters, l);
+          /* If this was a "repaint func" later, we just let the
+           * repaint func run and get removed
+           */
+          destroy_later (later);
+        }
+    }
 }
 
 /* eof util.c */

src/core/window-private.h

@@ -35,6 +35,7 @@
 #define META_WINDOW_PRIVATE_H
 
 #include <config.h>
+#include "compositor.h"
 #include "window.h"
 #include "screen-private.h"
 #include "util.h"
@@ -129,6 +130,12 @@ struct _MetaWindow
   /* Whether we're fullscreen */
   guint fullscreen : 1;
 
+  /* Whether the urgent flag of WM_HINTS is set */
+  guint wm_hints_urgent : 1;
+
+  /* Whether we have to fullscreen after placement */
+  guint fullscreen_after_placement : 1;
+
   /* Area to cover when in fullscreen mode.  If _NET_WM_FULLSCREEN_MONITORS has
    * been overridden (via a client message), the window will cover the union of
    * these monitors.  If not, this is the single monitor which the window's
@@ -138,8 +145,8 @@ struct _MetaWindow
   /* Whether we're trying to constrain the window to be fully onscreen */
   guint require_fully_onscreen : 1;
 
-  /* Whether we're trying to constrain the window to be on a single xinerama */
-  guint require_on_single_xinerama : 1;
+  /* Whether we're trying to constrain the window to be on a single monitor */
+  guint require_on_single_monitor : 1;
 
   /* Whether we're trying to constrain the window's titlebar to be onscreen */
   guint require_titlebar_visible : 1;
@@ -152,7 +159,6 @@ struct _MetaWindow
 
   /* Minimize is the state controlled by the minimize button */
   guint minimized : 1;
-  guint was_minimized : 1;
   guint tab_unminimized : 1;
 
   /* Whether the window is mapped; actual server-side state
@@ -165,6 +171,15 @@ struct _MetaWindow
    */
   guint hidden : 1;
 
+  /* Whether the compositor thinks the window is visible
+   */
+  guint visible_to_compositor : 1;
+
+  /* When we next show or hide the window, what effect we should
+   * tell the compositor to perform.
+   */
+  guint pending_compositor_effect : 4; /* MetaCompEffect */
+
   /* Iconic is the state in WM_STATE; happens for workspaces/shading
    * in addition to minimize
    */
@@ -237,6 +252,9 @@ struct _MetaWindow
   /* Have we placed this window? */
   guint placed : 1;
 
+  /* Must we force_save_user_window_placement? */
+  guint force_save_user_rect : 1;
+
   /* Is this not a transient of the focus window which is being denied focus? */
   guint denied_focus_and_not_transient : 1;
 
@@ -307,6 +325,9 @@ struct _MetaWindow
    */
   int unmaps_pending;
 
+  /* See docs for meta_window_get_stable_sequence() */
+  guint32 stable_sequence;
+
   /* set to the most recent user-interaction event timestamp that we
      know about for this window */
   guint32 net_wm_user_time;
@@ -358,9 +379,7 @@ struct _MetaWindow
   /* maintained by group.c */
   MetaGroup *group;
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
   GObject *compositor_private;
-#endif
 };
 
 struct _MetaWindowClass
@@ -370,6 +389,7 @@ struct _MetaWindowClass
   void (*workspace_changed) (MetaWindow *window, int  old_workspace);
   void (*focus)             (MetaWindow *window);
   void (*raised)            (MetaWindow *window);
+  void (*unmanaged)         (MetaWindow *window);
 };
 
 /* These differ from window->has_foo_func in that they consider
@@ -391,9 +411,10 @@ struct _MetaWindowClass
 MetaWindow* meta_window_new                (MetaDisplay *display,
                                             Window       xwindow,
                                             gboolean     must_be_viewable);
-MetaWindow* meta_window_new_with_attrs     (MetaDisplay *display,
-                                            Window       xwindow,
-                                            gboolean     must_be_viewable,
+MetaWindow* meta_window_new_with_attrs     (MetaDisplay       *display,
+                                            Window             xwindow,
+                                            gboolean           must_be_viewable,
+                                            MetaCompEffect     effect,
                                             XWindowAttributes *attrs);
 void        meta_window_unmanage           (MetaWindow  *window,
                                             guint32      timestamp);
@@ -481,16 +502,6 @@ void        meta_window_get_geometry         (MetaWindow  *window,
                                               int         *y,
                                               int         *width,
                                               int         *height);
-void        meta_window_get_xor_rect         (MetaWindow          *window,
-                                              const MetaRectangle *grab_wireframe_rect,
-                                              MetaRectangle       *xor_rect);
-void        meta_window_begin_wireframe (MetaWindow *window);
-void        meta_window_update_wireframe (MetaWindow *window,
-                                          int         x,
-                                          int         y,
-                                          int         width,
-                                          int         height);
-void        meta_window_end_wireframe (MetaWindow *window);
 
 void        meta_window_kill               (MetaWindow  *window);
 void        meta_window_focus              (MetaWindow  *window,
@@ -546,13 +557,13 @@ GList* meta_window_get_workspaces (MetaWindow *window);
 gboolean meta_window_located_on_workspace (MetaWindow    *window,
                                            MetaWorkspace *workspace);
 
-void meta_window_get_work_area_current_xinerama (MetaWindow    *window,
-                                                 MetaRectangle *area);
-void meta_window_get_work_area_for_xinerama     (MetaWindow    *window,
-                                                 int            which_xinerama,
-                                                 MetaRectangle *area);
-void meta_window_get_work_area_all_xineramas    (MetaWindow    *window,
-                                                 MetaRectangle *area);
+void meta_window_get_work_area_current_monitor (MetaWindow    *window,
+                                                MetaRectangle *area);
+void meta_window_get_work_area_for_monitor     (MetaWindow    *window,
+                                                int            which_monitor,
+                                                MetaRectangle *area);
+void meta_window_get_work_area_all_monitors    (MetaWindow    *window,
+                                                MetaRectangle *area);
 
 
 gboolean meta_window_same_application (MetaWindow *window,
@@ -574,8 +585,6 @@ void meta_window_free_delete_dialog (MetaWindow *window);
 void     meta_window_foreach_transient        (MetaWindow            *window,
                                                MetaWindowForeachFunc  func,
                                                void                  *data);
-gboolean meta_window_is_ancestor_of_transient (MetaWindow            *window,
-                                               MetaWindow            *transient);
 void     meta_window_foreach_ancestor         (MetaWindow            *window,
                                                MetaWindowForeachFunc  func,
                                                void                  *data);

src/core/window-props.c

@@ -56,19 +56,22 @@ typedef void (* ReloadValueFunc) (MetaWindow    *window,
                                   MetaPropValue *value,
                                   gboolean       initial);
 
-typedef struct MetaWindowPropHooks
+struct _MetaWindowPropHooks
 {
   Atom property;
   MetaPropValueType type;
   ReloadValueFunc reload_func;
-} MetaWindowPropHooks;
+  gboolean load_initially;
+  gboolean include_override_redirect;
+};
 
-static void init_prop_value            (MetaDisplay   *display,
-                                        Atom           property,
-                                        MetaPropValue *value);
-static void reload_prop_value          (MetaWindow    *window,
-                                        MetaPropValue *value,
-                                        gboolean       initial);
+static void init_prop_value            (MetaWindow          *window,
+                                        MetaWindowPropHooks *hooks,
+                                        MetaPropValue       *value);
+static void reload_prop_value          (MetaWindow          *window,
+                                        MetaWindowPropHooks *hooks,
+                                        MetaPropValue       *value,
+                                        gboolean             initial);
 static MetaWindowPropHooks* find_hooks (MetaDisplay *display,
                                         Atom         property);
 
@@ -122,7 +125,8 @@ meta_window_reload_properties_from_xwindow (MetaWindow *window,
   i = 0;
   while (i < n_properties)
     {
-      init_prop_value (window->display, properties[i], &values[i]);
+      MetaWindowPropHooks *hooks = find_hooks (window->display, properties[i]);
+      init_prop_value (window, hooks, &values[i]);
       ++i;
     }
   
@@ -132,7 +136,8 @@ meta_window_reload_properties_from_xwindow (MetaWindow *window,
   i = 0;
   while (i < n_properties)
     {
-      reload_prop_value (window, &values[i], initial);
+      MetaWindowPropHooks *hooks = find_hooks (window->display, properties[i]);
+      reload_prop_value (window, hooks, &values[i], initial);
       
       ++i;
     }
@@ -142,34 +147,78 @@ meta_window_reload_properties_from_xwindow (MetaWindow *window,
   g_free (values);
 }
 
+void
+meta_window_load_initial_properties (MetaWindow *window)
+{
+  int i, j;
+  MetaPropValue *values;
+  int n_properties = 0;
+
+  values = g_new0 (MetaPropValue, window->display->n_prop_hooks);
+
+  j = 0;
+  for (i = 0; i < window->display->n_prop_hooks; i++)
+    {
+      MetaWindowPropHooks *hooks = &window->display->prop_hooks_table[i];
+      if (hooks->load_initially)
+        {
+          init_prop_value (window, hooks, &values[j]);
+          ++j;
+        }
+    }
+  n_properties = j;
+
+  meta_prop_get_values (window->display, window->xwindow,
+                        values, n_properties);
+
+  j = 0;
+  for (i = 0; i < window->display->n_prop_hooks; i++)
+    {
+      MetaWindowPropHooks *hooks = &window->display->prop_hooks_table[i];
+      if (hooks->load_initially)
+        {
+          /* If we didn't actually manage to load anything then we don't need
+           * to call the reload function; this is different from a notification
+           * where disappearance of a previously present value is significant.
+           */
+          if (values[j].type != META_PROP_VALUE_INVALID)
+            reload_prop_value (window, hooks, &values[j], TRUE);
+          ++j;
+        }
+    }
+
+  meta_prop_free_values (values, n_properties);
+
+  g_free (values);
+}
+
 /* Fill in the MetaPropValue used to get the value of "property" */
 static void
-init_prop_value (MetaDisplay   *display,
-                 Atom           property,
-                 MetaPropValue *value)
+init_prop_value (MetaWindow          *window,
+                 MetaWindowPropHooks *hooks,
+                 MetaPropValue       *value)
 {
-  MetaWindowPropHooks *hooks = find_hooks (display, property);
-
-  if (!hooks || hooks->type == META_PROP_VALUE_INVALID)
+  if (!hooks || hooks->type == META_PROP_VALUE_INVALID ||
+      (window->override_redirect && !hooks->include_override_redirect))
     {
-  value->type = META_PROP_VALUE_INVALID;
-  value->atom = None;
+      value->type = META_PROP_VALUE_INVALID;
+      value->atom = None;
     }
   else
     {
       value->type = hooks->type;
-      value->atom = property;
+      value->atom = hooks->property;
     }
 }
 
 static void
-reload_prop_value (MetaWindow    *window,
-                   MetaPropValue *value,
-                   gboolean       initial)
+reload_prop_value (MetaWindow          *window,
+                   MetaWindowPropHooks *hooks,
+                   MetaPropValue       *value,
+                   gboolean             initial)
 {
-  MetaWindowPropHooks *hooks = find_hooks (window->display, value->atom);
-  
-  if (hooks && hooks->reload_func != NULL)
+  if (hooks && hooks->reload_func != NULL &&
+      !(window->override_redirect && !hooks->include_override_redirect))
     (* hooks->reload_func) (window, value, initial);
 }
 
@@ -423,8 +472,8 @@ set_window_title (MetaWindow *window,
     meta_ui_set_frame_title (window->screen->ui,
                              window->frame->xwindow,
                              window->title);
-  if (modified)
-    g_object_notify (G_OBJECT (window), "title");  
+
+  g_object_notify (G_OBJECT (window), "title");
 }
 
 static void
@@ -555,6 +604,7 @@ reload_net_wm_state (MetaWindow    *window,
   window->shaded = FALSE;
   window->maximized_horizontally = FALSE;
   window->maximized_vertically = FALSE;
+  window->fullscreen = FALSE;
   window->wm_state_modal = FALSE;
   window->wm_state_skip_taskbar = FALSE;
   window->wm_state_skip_pager = FALSE;
@@ -583,13 +633,7 @@ reload_net_wm_state (MetaWindow    *window,
       else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_SKIP_PAGER)
         window->wm_state_skip_pager = TRUE;
       else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_FULLSCREEN)
-        {
-          if (!window->fullscreen)
-            {
-              window->fullscreen = TRUE;
-              g_object_notify (G_OBJECT (window), "fullscreen");
-            }
-        }
+        window->fullscreen_after_placement = TRUE;
       else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_ABOVE)
         window->wm_state_above = TRUE;
       else if (value->v.atom_list.atoms[i] == window->display->atom__NET_WM_STATE_BELOW)
@@ -1301,8 +1345,10 @@ reload_wm_hints (MetaWindow    *window,
                  gboolean       initial)
 {
   Window old_group_leader;
-  
+  gboolean old_urgent;
+
   old_group_leader = window->xgroup_leader;
+  old_urgent = window->wm_hints_urgent;
   
   /* Fill in defaults */
   window->input = TRUE;
@@ -1310,7 +1356,8 @@ reload_wm_hints (MetaWindow    *window,
   window->xgroup_leader = None;
   window->wm_hints_pixmap = None;
   window->wm_hints_mask = None;
-  
+  window->wm_hints_urgent = FALSE;
+
   if (value->type != META_PROP_VALUE_INVALID)
     {
       const XWMHints *hints = value->v.wm_hints;
@@ -1329,7 +1376,10 @@ reload_wm_hints (MetaWindow    *window,
 
       if (hints->flags & IconMaskHint)
         window->wm_hints_mask = hints->icon_mask;
-      
+
+      if (hints->flags & XUrgencyHint)
+        window->wm_hints_urgent = TRUE;
+
       meta_verbose ("Read WM_HINTS input: %d iconic: %d group leader: 0x%lx pixmap: 0x%lx mask: 0x%lx\n",
                     window->input, window->initially_iconic,
                     window->xgroup_leader,
@@ -1345,6 +1395,21 @@ reload_wm_hints (MetaWindow    *window,
       meta_window_group_leader_changed (window);
     }
 
+  /*
+   * Do not emit urgency notification on the inital property load
+   */
+  if (!initial && (window->wm_hints_urgent != old_urgent))
+    g_object_notify (G_OBJECT (window), "urgent");
+
+  /*
+   * Do not emit signal for the initial property load, let the constructor to
+   * take care of it once the MetaWindow is fully constructed.
+   *
+   * Only emit if the property is both changed and set.
+   */
+  if (!initial && window->wm_hints_urgent && !old_urgent)
+    g_signal_emit_by_name (window->display, "window-marked-urgent", window);
+
   meta_icon_cache_property_changed (&window->icon_cache,
                                     window->display,
                                     XA_WM_HINTS);
@@ -1386,7 +1451,8 @@ reload_transient_for (MetaWindow    *window,
   meta_window_recalc_window_type (window);
 
   /* update stacking constraints */
-  meta_stack_update_transient (window->screen->stack, window);
+  if (!window->override_redirect)
+    meta_stack_update_transient (window->screen->stack, window);
 
   /* possibly change its group. We treat being a window's transient as
    * equivalent to making it your group leader, to work around shortcomings
@@ -1397,7 +1463,7 @@ reload_transient_for (MetaWindow    *window,
       window->xtransient_for != window->xgroup_leader)
     meta_window_group_leader_changed (window);
 
-  if (!window->constructing)
+  if (!window->constructing && !window->override_redirect)
     meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
 }
 
@@ -1418,35 +1484,51 @@ reload_transient_for (MetaWindow    *window,
 void
 meta_display_init_window_prop_hooks (MetaDisplay *display)
 {
-  MetaWindowPropHooks hooks[] = {
-    { display->atom_WM_STATE,          META_PROP_VALUE_INVALID,  NULL },
-    { display->atom_WM_CLIENT_MACHINE, META_PROP_VALUE_STRING,   reload_wm_client_machine },
-    { display->atom__NET_WM_PID,       META_PROP_VALUE_CARDINAL, reload_net_wm_pid },
-    { display->atom__NET_WM_USER_TIME, META_PROP_VALUE_CARDINAL, reload_net_wm_user_time },
-    { display->atom__NET_WM_NAME,      META_PROP_VALUE_UTF8,     reload_net_wm_name },
-    { XA_WM_NAME,                      META_PROP_VALUE_TEXT_PROPERTY, reload_wm_name },
-    { display->atom__NET_WM_ICON,      META_PROP_VALUE_INVALID,  reload_net_wm_icon },
-    { display->atom__KWM_WIN_ICON,     META_PROP_VALUE_INVALID,  reload_kwm_win_icon },
-    { display->atom__NET_WM_ICON_NAME, META_PROP_VALUE_UTF8,     reload_net_wm_icon_name },
-    { XA_WM_ICON_NAME,                 META_PROP_VALUE_TEXT_PROPERTY, reload_wm_icon_name },
-    { display->atom__NET_WM_STATE,     META_PROP_VALUE_ATOM_LIST, reload_net_wm_state },
-    { display->atom__MOTIF_WM_HINTS,   META_PROP_VALUE_MOTIF_HINTS, reload_mwm_hints },
-    { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_INVALID, NULL },
-    { XA_WM_CLASS,                     META_PROP_VALUE_CLASS_HINT, reload_wm_class },
-    { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client },
-    { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client },
-    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role },
-    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type },
-    { display->atom__NET_WM_DESKTOP,   META_PROP_VALUE_CARDINAL, reload_net_wm_desktop },
-    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts },
-    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts },
-    { display->atom__NET_STARTUP_ID,  META_PROP_VALUE_UTF8,     reload_net_startup_id },
-    { display->atom__NET_WM_SYNC_REQUEST_COUNTER, META_PROP_VALUE_SYNC_COUNTER, reload_update_counter },
-    { XA_WM_NORMAL_HINTS,              META_PROP_VALUE_SIZE_HINTS, reload_normal_hints },
-    { display->atom_WM_PROTOCOLS,      META_PROP_VALUE_ATOM_LIST, reload_wm_protocols },
-    { XA_WM_HINTS,                     META_PROP_VALUE_WM_HINTS,  reload_wm_hints },
-    { XA_WM_TRANSIENT_FOR,             META_PROP_VALUE_WINDOW,    reload_transient_for },
-    { display->atom__NET_WM_USER_TIME_WINDOW, META_PROP_VALUE_WINDOW, reload_net_wm_user_time_window },
+  /* INIT: load initially
+   * O-R:  fetch for override-redirect windows
+   *
+   * The ordering here is significant for the properties we load
+   * initially: they are roughly ordered in the order we want them to
+   * be gotten. We want to get window name and class first so we can
+   * use them in error messages and such. However, name is modified
+   * depending on wm_client_machine, so push it slightly sooner.
+   *
+   * For override-redirect windows, we pay attention to:
+   *
+   *  - properties that identify the window: useful for debugging
+   *    purposes.
+   *  - NET_WM_WINDOW_TYPE: can be used to do appropriate handling
+   *    for different types of override-redirect windows.
+   */
+  MetaWindowPropHooks hooks[] = {                                                       /* INIT   O-R     */
+    { display->atom_WM_CLIENT_MACHINE, META_PROP_VALUE_STRING,   reload_wm_client_machine, TRUE,  TRUE },
+    { display->atom__NET_WM_NAME,      META_PROP_VALUE_UTF8,     reload_net_wm_name,       TRUE,  TRUE },
+    { XA_WM_CLASS,                     META_PROP_VALUE_CLASS_HINT, reload_wm_class,        TRUE,  TRUE },
+    { display->atom__NET_WM_PID,       META_PROP_VALUE_CARDINAL, reload_net_wm_pid,        TRUE,  TRUE },
+    { XA_WM_NAME,                      META_PROP_VALUE_TEXT_PROPERTY, reload_wm_name,      TRUE,  TRUE },
+    { display->atom__NET_WM_ICON_NAME, META_PROP_VALUE_UTF8,     reload_net_wm_icon_name,  TRUE,  FALSE },
+    { XA_WM_ICON_NAME,                 META_PROP_VALUE_TEXT_PROPERTY, reload_wm_icon_name, TRUE,  FALSE },
+    { display->atom__NET_WM_DESKTOP,   META_PROP_VALUE_CARDINAL, reload_net_wm_desktop,    TRUE,  FALSE },
+    { display->atom__NET_STARTUP_ID,   META_PROP_VALUE_UTF8,     reload_net_startup_id,    TRUE,  FALSE },
+    { display->atom__NET_WM_SYNC_REQUEST_COUNTER, META_PROP_VALUE_SYNC_COUNTER, reload_update_counter, TRUE, FALSE },
+    { XA_WM_NORMAL_HINTS,              META_PROP_VALUE_SIZE_HINTS, reload_normal_hints,    TRUE,  FALSE },
+    { display->atom_WM_PROTOCOLS,      META_PROP_VALUE_ATOM_LIST, reload_wm_protocols,     TRUE,  FALSE },
+    { XA_WM_HINTS,                     META_PROP_VALUE_WM_HINTS,  reload_wm_hints,         TRUE,  FALSE },
+    { display->atom__NET_WM_USER_TIME, META_PROP_VALUE_CARDINAL, reload_net_wm_user_time,  TRUE,  FALSE },
+    { display->atom__NET_WM_STATE,     META_PROP_VALUE_ATOM_LIST, reload_net_wm_state,     TRUE,  FALSE },
+    { display->atom__MOTIF_WM_HINTS,   META_PROP_VALUE_MOTIF_HINTS, reload_mwm_hints,      TRUE,  FALSE },
+    { XA_WM_TRANSIENT_FOR,             META_PROP_VALUE_WINDOW,    reload_transient_for,    TRUE,  FALSE },
+    { display->atom__NET_WM_USER_TIME_WINDOW, META_PROP_VALUE_WINDOW, reload_net_wm_user_time_window, TRUE, FALSE },
+    { display->atom_WM_STATE,          META_PROP_VALUE_INVALID,  NULL,                     FALSE, FALSE },
+    { display->atom__NET_WM_ICON,      META_PROP_VALUE_INVALID,  reload_net_wm_icon,       FALSE, FALSE },
+    { display->atom__KWM_WIN_ICON,     META_PROP_VALUE_INVALID,  reload_kwm_win_icon,      FALSE, FALSE },
+    { display->atom__NET_WM_ICON_GEOMETRY, META_PROP_VALUE_INVALID, NULL,                  FALSE, FALSE },
+    { display->atom_WM_CLIENT_LEADER,  META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
+    { display->atom_SM_CLIENT_ID,      META_PROP_VALUE_INVALID, complain_about_broken_client, FALSE, FALSE },
+    { display->atom_WM_WINDOW_ROLE,    META_PROP_VALUE_INVALID, reload_wm_window_role,        FALSE, FALSE },
+    { display->atom__NET_WM_WINDOW_TYPE, META_PROP_VALUE_INVALID, reload_net_wm_window_type,  FALSE, TRUE },
+    { display->atom__NET_WM_STRUT,         META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
+    { display->atom__NET_WM_STRUT_PARTIAL, META_PROP_VALUE_INVALID, reload_struts,            FALSE, FALSE },
     { 0 },
   };
 
@@ -1460,6 +1542,9 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
 
   while (cursor->property)
     {
+      /* Doing initial loading doesn't make sense if we just want notification */
+      g_assert (!(hooks->load_initially && hooks->type == META_PROP_VALUE_INVALID));
+
       /* Atoms are safe to use with GINT_TO_POINTER because it's safe with
        * anything 32 bits or less, and atoms are 32 bits with the top three
        * bits clear.  (Scheifler & Gettys, 2e, p372)
@@ -1469,6 +1554,7 @@ meta_display_init_window_prop_hooks (MetaDisplay *display)
                            cursor);
       cursor++;
     }
+  display->n_prop_hooks = cursor - table;
 }
 
 void

src/core/window-props.h

@@ -95,6 +95,15 @@ void meta_window_reload_properties_from_xwindow
                                     int         n_properties,
                                     gboolean    initial);
 
+/**
+ * Requests the current values for standard properties for a given
+ * window from the server, and deals with them appropriately.
+ * Does not return them to the caller (they've been dealt with!)
+ *
+ * \param window      The window.
+ */
+void meta_window_load_initial_properties (MetaWindow *window);
+
 /**
  * Initialises the hooks used for the reload_propert* functions
  * on a particular display, and stores a pointer to them in the

src/core/workspace-private.h

@@ -47,12 +47,12 @@ struct _MetaWorkspace
   GList  *list_containing_self;
 
   MetaRectangle work_area_screen;
-  MetaRectangle *work_area_xinerama;
+  MetaRectangle *work_area_monitor;
   GList  *screen_region;
-  GList  **xinerama_region;
-  gint n_xinerama_regions;
+  GList  **monitor_region;
+  gint n_monitor_regions;
   GList  *screen_edges;
-  GList  *xinerama_edges;
+  GList  *monitor_edges;
   GSList *builtin_struts;
   GSList *all_struts;
   guint work_areas_invalid : 1;
@@ -73,19 +73,16 @@ void           meta_workspace_remove_window (MetaWorkspace *workspace,
                                              MetaWindow    *window);
 void           meta_workspace_relocate_windows (MetaWorkspace *workspace,
                                                 MetaWorkspace *new_home);
-GList*         meta_workspace_list_windows  (MetaWorkspace *workspace);
 
 void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);
 
 
-void meta_workspace_get_work_area_for_xinerama  (MetaWorkspace *workspace,
-                                                 int            which_xinerama,
+void meta_workspace_get_work_area_for_monitor   (MetaWorkspace *workspace,
+                                                 int            which_monitor,
                                                  MetaRectangle *area);
 GList* meta_workspace_get_onscreen_region       (MetaWorkspace *workspace);
-GList* meta_workspace_get_onxinerama_region     (MetaWorkspace *workspace,
-                                                 int            which_xinerama);
-void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
-                                                 MetaRectangle *area);
+GList* meta_workspace_get_onmonitor_region      (MetaWorkspace *workspace,
+                                                 int            which_monitor);
 
 void meta_workspace_focus_default_window (MetaWorkspace *workspace,
                                           MetaWindow    *not_this_one,

src/core/workspace.c

@@ -29,12 +29,13 @@
 #include "errors.h"
 #include "prefs.h"
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 #include "compositor.h"
-#endif
 
 #include <X11/Xatom.h>
 #include <string.h>
+#ifdef HAVE_LIBCANBERRA
+#include <canberra-gtk.h>
+#endif
 
 enum {
   PROP_0,
@@ -172,16 +173,16 @@ meta_workspace_new (MetaScreen *screen)
   meta_screen_foreach_window (screen, maybe_add_to_list, &workspace->mru_list);
 
   workspace->work_areas_invalid = TRUE;
-  workspace->work_area_xinerama = NULL;
+  workspace->work_area_monitor = NULL;
   workspace->work_area_screen.x = 0;
   workspace->work_area_screen.y = 0;
   workspace->work_area_screen.width = 0;
   workspace->work_area_screen.height = 0;
 
   workspace->screen_region = NULL;
-  workspace->xinerama_region = NULL;
+  workspace->monitor_region = NULL;
   workspace->screen_edges = NULL;
-  workspace->xinerama_edges = NULL;
+  workspace->monitor_edges = NULL;
   workspace->list_containing_self = g_list_prepend (NULL, workspace);
 
   workspace->builtin_struts = NULL;
@@ -265,7 +266,7 @@ meta_workspace_remove (MetaWorkspace *workspace)
   workspace->screen->workspaces =
     g_list_remove (workspace->screen->workspaces, workspace);
   
-  g_free (workspace->work_area_xinerama);
+  g_free (workspace->work_area_monitor);
 
   g_list_free (workspace->mru_list);
   g_list_free (workspace->list_containing_self);
@@ -282,12 +283,12 @@ meta_workspace_remove (MetaWorkspace *workspace)
   if (!workspace->work_areas_invalid)
     {
       workspace_free_all_struts (workspace);
-      for (i = 0; i < screen->n_xinerama_infos; i++)
-        meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
-      g_free (workspace->xinerama_region);
+      for (i = 0; i < screen->n_monitor_infos; i++)
+        meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
+      g_free (workspace->monitor_region);
       meta_rectangle_free_list_and_elements (workspace->screen_region);
       meta_rectangle_free_list_and_elements (workspace->screen_edges);
-      meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
+      meta_rectangle_free_list_and_elements (workspace->monitor_edges);
     }
 
   g_object_unref (workspace);
@@ -435,31 +436,107 @@ meta_workspace_queue_calc_showing  (MetaWorkspace *workspace)
   tmp = workspace->windows;
   while (tmp != NULL)
     {
-      if (meta_prefs_get_live_hidden_windows ())
-        {
-          /*
-           * When we hide rather than unmap windows, we need the show/hide
-           * status of the window to be recalculated *before* we call the
-           * compositor switch_workspace hook.
-           */
-          meta_window_calc_showing (tmp->data);
-        }
-      else
-        {
-          meta_window_queue (tmp->data, META_QUEUE_CALC_SHOWING);
-        }
+      meta_window_queue (tmp->data, META_QUEUE_CALC_SHOWING);
 
       tmp = tmp->next;
     }
 }
 
+static void
+workspace_switch_sound(MetaWorkspace *from,
+                       MetaWorkspace *to)
+{
+#ifdef HAVE_LIBCANBERRA
+  MetaWorkspaceLayout layout;
+  int i, nw, x, y, fi, ti;
+  const char *e;
+
+  nw = meta_screen_get_n_workspaces(from->screen);
+  fi = meta_workspace_index(from);
+  ti = meta_workspace_index(to);
+
+  meta_screen_calc_workspace_layout(from->screen,
+                                    nw,
+                                    fi,
+                                    &layout);
+
+  for (i = 0; i < nw; i++)
+    if (layout.grid[i] == ti)
+      break;
+
+  if (i >= nw)
+    {
+      meta_bug("Failed to find destination workspace in layout\n");
+      goto finish;
+    }
+
+  y = i / layout.cols;
+  x = i % layout.cols;
+
+  /* We priorize horizontal over vertical movements here. The
+     rationale for this is that horizontal movements are probably more
+     interesting for sound effects because speakers are usually
+     positioned on a horizontal and not a vertical axis. i.e. your
+     spatial "Woosh!" effects will easily be able to encode horizontal
+     movement but not such much vertical movement. */
+
+  if (x < layout.current_col)
+    e = "desktop-switch-left";
+  else if (x > layout.current_col)
+    e = "desktop-switch-right";
+  else if (y < layout.current_row)
+    e = "desktop-switch-up";
+  else if (y > layout.current_row)
+    e = "desktop-switch-down";
+  else
+    {
+      meta_bug("Uh, origin and destination workspace at same logic position!\n");
+      goto finish;
+    }
+
+  ca_context_play(ca_gtk_context_get(), 1,
+                  CA_PROP_EVENT_ID, e,
+                  CA_PROP_EVENT_DESCRIPTION, "Desktop switched",
+                  CA_PROP_CANBERRA_CACHE_CONTROL, "permanent",
+                  NULL);
+
+ finish:
+  meta_screen_free_workspace_layout (&layout);
+#endif /* HAVE_LIBCANBERRA */
+}
+
+/**
+ * meta_workspace_activate_with_focus:
+ * @workspace: a #MetaWorkspace
+ * @focus_this: the #MetaWindow to be focused, or %NULL
+ * @timestamp: timestamp for @focus_this
+ *
+ * Switches to @workspace and possibly activates the window @focus_this.
+ *
+ * The window @focus_this is activated by calling meta_window_activate()
+ * which will unminimize it and transient parents, raise it and give it
+ * the focus.
+ *
+ * If a window is currently being moved by the user, it will be
+ * moved to @workspace.
+ *
+ * The advantage of calling this function instead of meta_workspace_activate()
+ * followed by meta_window_activate() is that it happens as a unit, so
+ * no other window gets focused first before @focus_this.
+ */
 void
 meta_workspace_activate_with_focus (MetaWorkspace *workspace,
                                     MetaWindow    *focus_this,
                                     guint32        timestamp)
 {
-  MetaWorkspace *old;
-  MetaWindow *move_window;
+  MetaWorkspace  *old;
+  MetaWindow     *move_window;
+  MetaScreen     *screen;
+  MetaDisplay    *display;
+  MetaCompositor *comp;
+  MetaWorkspaceLayout layout1, layout2;
+  gint num_workspaces, current_space, new_space;
+  MetaMotionDirection direction;
   
   meta_verbose ("Activating workspace %d\n",
                 meta_workspace_index (workspace));
@@ -467,9 +544,16 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,
   if (workspace->screen->active_workspace == workspace)
     return;
 
+  /* Free any cached pointers to the workspaces's edges from
+   * a current resize or move operation */
+  meta_display_cleanup_edges (workspace->screen->display);
+
+  if (workspace->screen->active_workspace)
+    workspace_switch_sound (workspace->screen->active_workspace, workspace);
+
   /* Note that old can be NULL; e.g. when starting up */
   old = workspace->screen->active_workspace;
-  
+
   workspace->screen->active_workspace = workspace;
 
   set_active_space_hint (workspace->screen);
@@ -516,10 +600,61 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,
       /* Removes window from other spaces */
       meta_window_change_workspace (move_window, workspace);
 
+   /*
+    * Notify the compositor that the active workspace is changing.
+    */
+   screen = workspace->screen;
+   display = meta_screen_get_display (screen);
+   comp = meta_display_get_compositor (display);
+   direction = 0;
+
+   current_space = meta_workspace_index (old);
+   new_space     = meta_workspace_index (workspace);
+   num_workspaces = meta_screen_get_n_workspaces (workspace->screen);
+   meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
+                                      current_space, &layout1);
+
+   meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
+                                      new_space, &layout2);
+
+   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)
+     {
+       if (!direction)
+         direction = META_MOTION_DOWN;
+       else if (direction == META_MOTION_RIGHT)
+         direction = META_MOTION_DOWN_RIGHT;
+       else
+         direction = META_MOTION_DOWN_LEFT;
+     }
+
+   if (layout1.current_row > layout2.current_row)
+     {
+       if (!direction)
+         direction = META_MOTION_UP;
+       else if (direction == META_MOTION_RIGHT)
+         direction = META_MOTION_UP_RIGHT;
+       else
+         direction = META_MOTION_UP_LEFT;
+     }
+
+   meta_screen_free_workspace_layout (&layout1);
+   meta_screen_free_workspace_layout (&layout2);
+
+   meta_compositor_switch_workspace (comp, screen, old, workspace, direction);
+
+  /* This needs to be done after telling the compositor we are switching
+   * workspaces since focusing a window will cause it to be immediately
+   * shown and that would confuse the compositor if it didn't know we
+   * were in a workspace switch.
+   */
   if (focus_this)
     {
-      meta_window_focus (focus_this, timestamp);
-      meta_window_raise (focus_this);
+      meta_window_activate (focus_this, timestamp);
     }
   else if (move_window)
     {
@@ -531,59 +666,8 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace,
       meta_workspace_focus_default_window (workspace, NULL, timestamp);
     }
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
-  {
-    /*
-     * Notify the compositor that the active workspace changed.
-     */
-    MetaScreen     *screen = workspace->screen;
-    MetaDisplay    *display = meta_screen_get_display (screen);
-    MetaCompositor *comp = meta_display_get_compositor (display);
-    MetaWorkspaceLayout layout1, layout2;
-    gint num_workspaces, current_space, new_space;
-    MetaMotionDirection direction = 0;
-
-    current_space = meta_workspace_index (old);
-    new_space     = meta_workspace_index (workspace);
-
-    num_workspaces = meta_screen_get_n_workspaces (workspace->screen);
-    meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
-                                       current_space, &layout1);
-
-    meta_screen_calc_workspace_layout (workspace->screen, num_workspaces,
-                                       new_space, &layout2);
-
-    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)
-      {
-        if (!direction)
-          direction = META_MOTION_DOWN;
-        else if (direction == META_MOTION_RIGHT)
-          direction = META_MOTION_DOWN_RIGHT;
-        else
-          direction = META_MOTION_DOWN_LEFT;
-      }
-
-    if (layout1.current_row > layout2.current_row)
-      {
-        if (!direction)
-          direction = META_MOTION_UP;
-        else if (direction == META_MOTION_RIGHT)
-          direction = META_MOTION_UP_RIGHT;
-        else
-          direction = META_MOTION_UP_LEFT;
-      }
-
-    meta_screen_free_workspace_layout (&layout1);
-    meta_screen_free_workspace_layout (&layout2);
-
-    meta_compositor_switch_workspace (comp, screen, old, workspace, direction);
-  }
-#endif
+   /* Emit switched signal from screen.c */
+   meta_screen_workspace_switched (screen, current_space, new_space, direction);
 }
 
 void
@@ -620,8 +704,14 @@ meta_workspace_update_window_hints (MetaWorkspace *workspace)
     }
 }
 
-/* get windows contained on workspace, including workspace->windows
- * and also sticky windows.
+/**
+ * meta_workspace_list_windows:
+ * @display: a #MetaDisplay
+ *
+ * Gets windows contained on the workspace, including workspace->windows
+ * and also sticky windows. Override-redirect windows are not included.
+ *
+ * Return value: (transfer container) (element-type MetaWindow): the list of windows.
  */
 GList*
 meta_workspace_list_windows (MetaWorkspace *workspace)
@@ -630,7 +720,8 @@ meta_workspace_list_windows (MetaWorkspace *workspace)
   GSList *tmp;
   GList *workspace_windows;
   
-  display_windows = meta_display_list_windows (workspace->screen->display);
+  display_windows = meta_display_list_windows (workspace->screen->display,
+                                               META_LIST_DEFAULT);
 
   workspace_windows = NULL;
   tmp = display_windows;
@@ -695,21 +786,26 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
               "Invalidating work area for workspace %d\n",
               meta_workspace_index (workspace));
 
-  g_free (workspace->work_area_xinerama);
-  workspace->work_area_xinerama = NULL;
+  /* If we are in the middle of a resize or move operation, we
+   * might have cached pointers to the workspace's edges */
+  if (workspace == workspace->screen->active_workspace)
+    meta_display_cleanup_edges (workspace->screen->display);
+
+  g_free (workspace->work_area_monitor);
+  workspace->work_area_monitor = NULL;
       
   workspace_free_all_struts (workspace);
 
-  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
-    meta_rectangle_free_list_and_elements (workspace->xinerama_region[i]);
-  g_free (workspace->xinerama_region);
+  for (i = 0; i < workspace->screen->n_monitor_infos; i++)
+    meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
+  g_free (workspace->monitor_region);
   meta_rectangle_free_list_and_elements (workspace->screen_region);
   meta_rectangle_free_list_and_elements (workspace->screen_edges);
-  meta_rectangle_free_list_and_elements (workspace->xinerama_edges);
-  workspace->xinerama_region = NULL;
+  meta_rectangle_free_list_and_elements (workspace->monitor_edges);
+  workspace->monitor_region = NULL;
   workspace->screen_region = NULL;
   workspace->screen_edges = NULL;
-  workspace->xinerama_edges = NULL;
+  workspace->monitor_edges = NULL;
   
   workspace->work_areas_invalid = TRUE;
 
@@ -762,10 +858,10 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
     return;
 
   g_assert (workspace->all_struts == NULL);
-  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->monitor_region == NULL);
   g_assert (workspace->screen_region == NULL);
   g_assert (workspace->screen_edges == NULL);
-  g_assert (workspace->xinerama_edges == NULL);
+  g_assert (workspace->monitor_edges == NULL);
 
   /* STEP 1: Get the list of struts */
 
@@ -785,18 +881,18 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
   g_list_free (windows);
 
   /* STEP 2: Get the maximal/spanning rects for the onscreen and
-   *         on-single-xinerama regions
+   *         on-single-monitor regions
    */  
-  g_assert (workspace->xinerama_region == NULL);
+  g_assert (workspace->monitor_region == NULL);
   g_assert (workspace->screen_region   == NULL);
 
-  workspace->xinerama_region = g_new (GList*,
-                                      workspace->screen->n_xinerama_infos);
-  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+  workspace->monitor_region = g_new (GList*,
+                                      workspace->screen->n_monitor_infos);
+  for (i = 0; i < workspace->screen->n_monitor_infos; i++)
     {
-      workspace->xinerama_region[i] =
+      workspace->monitor_region[i] =
         meta_rectangle_get_minimal_spanning_set_for_region (
-          &workspace->screen->xinerama_infos[i].rect,
+          &workspace->screen->monitor_infos[i].rect,
           workspace->all_struts);
     }
   workspace->screen_region =
@@ -805,7 +901,7 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
       workspace->all_struts);
 
   /* STEP 3: Get the work areas (region-to-maximize-to) for the screen and
-   *         xineramas.
+   *         monitors.
    */
   work_area = workspace->screen->rect;  /* start with the screen */
   if (workspace->screen_region == NULL)
@@ -860,35 +956,35 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
               workspace->work_area_screen.width,
               workspace->work_area_screen.height);    
 
-  /* Now find the work areas for each xinerama */
-  g_free (workspace->work_area_xinerama);
-  workspace->work_area_xinerama = g_new (MetaRectangle,
-                                         workspace->screen->n_xinerama_infos);
+  /* Now find the work areas for each monitor */
+  g_free (workspace->work_area_monitor);
+  workspace->work_area_monitor = g_new (MetaRectangle,
+                                         workspace->screen->n_monitor_infos);
 
-  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
+  for (i = 0; i < workspace->screen->n_monitor_infos; i++)
     {
-      work_area = workspace->screen->xinerama_infos[i].rect;
+      work_area = workspace->screen->monitor_infos[i].rect;
 
-      if (workspace->xinerama_region[i] == NULL)
+      if (workspace->monitor_region[i] == NULL)
         /* FIXME: constraints.c untested with this, but it might be nice for
          * a screen reader or magnifier.
          */
         work_area = meta_rect (work_area.x, work_area.y, -1, -1);
       else
-        meta_rectangle_clip_to_region (workspace->xinerama_region[i],
+        meta_rectangle_clip_to_region (workspace->monitor_region[i],
                                        FIXED_DIRECTION_NONE,
                                        &work_area);
 
-      workspace->work_area_xinerama[i] = work_area;
+      workspace->work_area_monitor[i] = work_area;
       meta_topic (META_DEBUG_WORKAREA,
                   "Computed work area for workspace %d "
-                  "xinerama %d: %d,%d %d x %d\n",
+                  "monitor %d: %d,%d %d x %d\n",
                   meta_workspace_index (workspace),
                   i,
-                  workspace->work_area_xinerama[i].x,
-                  workspace->work_area_xinerama[i].y,
-                  workspace->work_area_xinerama[i].width,
-                  workspace->work_area_xinerama[i].height);
+                  workspace->work_area_monitor[i].x,
+                  workspace->work_area_monitor[i].y,
+                  workspace->work_area_monitor[i].width,
+                  workspace->work_area_monitor[i].height);
     }
 
   /* STEP 4: Make sure the screen_region is nonempty (separate from step 2
@@ -902,24 +998,23 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
       workspace->screen_region = g_list_prepend (NULL, nonempty_region);
     }
 
-  /* STEP 5: Cache screen and xinerama edges for edge resistance and snapping */
+  /* STEP 5: Cache screen and monitor edges for edge resistance and snapping */
   g_assert (workspace->screen_edges    == NULL);
-  g_assert (workspace->xinerama_edges  == NULL);
+  g_assert (workspace->monitor_edges  == NULL);
   workspace->screen_edges =
     meta_rectangle_find_onscreen_edges (&workspace->screen->rect,
                                         workspace->all_struts);
   tmp = NULL;
-  for (i = 0; i < workspace->screen->n_xinerama_infos; i++)
-    tmp = g_list_prepend (tmp, &workspace->screen->xinerama_infos[i].rect);
-  workspace->xinerama_edges =
-    meta_rectangle_find_nonintersected_xinerama_edges (tmp,
+  for (i = 0; i < workspace->screen->n_monitor_infos; i++)
+    tmp = g_list_prepend (tmp, &workspace->screen->monitor_infos[i].rect);
+  workspace->monitor_edges =
+    meta_rectangle_find_nonintersected_monitor_edges (tmp,
                                                        workspace->all_struts);
   g_list_free (tmp);
 
   /* We're all done, YAAY!  Record that everything has been validated. */
   workspace->work_areas_invalid = FALSE;
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
   {
     /*
      * Notify the compositor that the workspace geometry has changed.
@@ -928,9 +1023,26 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
     MetaDisplay    *display = meta_screen_get_display (screen);
     MetaCompositor *comp = meta_display_get_compositor (display);
 
-    meta_compositor_update_workspace_geometry (comp, workspace);
+    if (comp)
+      meta_compositor_update_workspace_geometry (comp, workspace);
   }
-#endif
+}
+
+static gboolean
+strut_lists_equal (GSList *l,
+                   GSList *m)
+{
+  for (; l && m; l = l->next, m = m->next)
+    {
+      MetaStrut *a = l->data;
+      MetaStrut *b = m->data;
+
+      if (a->side != b->side ||
+          !meta_rectangle_equal (&a->rect, &b->rect))
+        return FALSE;
+    }
+
+  return l == NULL && m == NULL;
 }
 
 /**
@@ -946,6 +1058,12 @@ void
 meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
                                    GSList        *struts)
 {
+  /* Reordering doesn't actually matter, so we don't catch all
+   * no-impact changes, but this is just a (possibly unnecessary
+   * anyways) optimization */
+  if (strut_lists_equal (struts, workspace->builtin_struts))
+    return;
+
   workspace_free_builtin_struts (workspace);
   workspace->builtin_struts = copy_strut_list (struts);
 
@@ -953,21 +1071,21 @@ meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
 }
 
 void
-meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace,
-                                           int            which_xinerama,
-                                           MetaRectangle *area)
+meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
+                                          int            which_monitor,
+                                          MetaRectangle *area)
 {
-  g_assert (which_xinerama >= 0);
+  g_assert (which_monitor >= 0);
 
   ensure_work_areas_validated (workspace);
-  g_assert (which_xinerama < workspace->screen->n_xinerama_infos);
+  g_assert (which_monitor < workspace->screen->n_monitor_infos);
   
-  *area = workspace->work_area_xinerama[which_xinerama];
+  *area = workspace->work_area_monitor[which_monitor];
 }
 
 void
-meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
-                                            MetaRectangle *area)
+meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
+                                           MetaRectangle *area)
 {
   ensure_work_areas_validated (workspace);
   
@@ -983,12 +1101,12 @@ meta_workspace_get_onscreen_region (MetaWorkspace *workspace)
 }
 
 GList*
-meta_workspace_get_onxinerama_region (MetaWorkspace *workspace,
-                                      int            which_xinerama)
+meta_workspace_get_onmonitor_region (MetaWorkspace *workspace,
+                                     int            which_monitor)
 {
   ensure_work_areas_validated (workspace);
 
-  return workspace->xinerama_region[which_xinerama];
+  return workspace->monitor_region[which_monitor];
 }
 
 #ifdef WITH_VERBOSE_MODE
@@ -1185,7 +1303,10 @@ focus_ancestor_or_mru_window (MetaWorkspace *workspace,
       MetaWindow *ancestor;
       ancestor = NULL;
       meta_window_foreach_ancestor (not_this_one, record_ancestor, &ancestor);
-      if (ancestor != NULL)
+      if (ancestor != NULL &&
+          (ancestor->on_all_workspaces ||
+           ancestor->workspace == workspace) &&
+          meta_window_showing_on_its_workspace (ancestor))
         {
           meta_topic (META_DEBUG_FOCUS,
                       "Focusing %s, ancestor of %s\n", 

src/core/xprops.c

@@ -264,6 +264,16 @@ cardinal_list_from_results (GetPropertyResults *results,
   *n_cardinals_p = results->n_items;
   results->prop = NULL;
   
+#if GLIB_SIZEOF_LONG == 8
+  /* Xlib sign-extends format=32 items, but we want them unsigned */
+  {
+    int i;
+
+    for (i = 0; i < *n_cardinals_p; i++)
+      (*cardinals_p)[i] = (*cardinals_p)[i] & 0xffffffff;
+  }
+#endif
+
   return TRUE;
 }
 
@@ -608,6 +618,10 @@ cardinal_with_atom_type_from_results (GetPropertyResults *results,
     return FALSE;  
 
   *cardinal_p = *(gulong*) results->prop;
+#if GLIB_SIZEOF_LONG == 8
+  /* Xlib sign-extends format=32 items, but we want them unsigned */
+  *cardinal_p &= 0xffffffff;
+#endif
   XFree (results->prop);
   results->prop = NULL;  
   

src/include/all-keybindings.h

@@ -167,7 +167,7 @@ keybind (switch_panels_backward,   handle_switch,        META_TAB_LIST_DOCKS,
           "using a popup window"))
 
 keybind (cycle_group,               handle_cycle,         META_TAB_LIST_GROUP,
-        BINDING_REVERSES,        "<Alt>F6",
+        BINDING_REVERSES,        "<Alt>grave",
         _("Move between windows of an application immediately"))
 keybind (cycle_group_backward,     handle_cycle,         META_TAB_LIST_GROUP,
         REVERSES_AND_REVERSED,   NULL,
@@ -186,6 +186,18 @@ keybind (cycle_panels_backward,    handle_cycle,         META_TAB_LIST_DOCKS,
         _("Move backward between panels and the desktop immediately"))
 
 /***********************************/
+
+/* These two are special pseudo-bindings that are provided for allowing
+ * custom handlers, but will never be bound to a key. While a tab
+ * grab is in effect, they are invoked for releasing the primary modifier
+ * or pressing some unbound key, respectively.
+ */
+keybind (tab_popup_select,        handle_tab_popup_select, 0, 0, NULL,
+         "Select window from tab popup")
+keybind (tab_popup_cancel,        handle_tab_popup_cancel, 0, 0, NULL,
+         "Cancel tab popup")
+
+/***********************************/
      
 keybind (show_desktop, handle_show_desktop, 0, 0, "<Control><Alt>d",
       _("Hide all normal windows and set focus to the desktop"))

src/include/alttabhandler.h

@@ -1,73 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity Alt-Tab abstraction */
-
-/* 
- * Copyright (C) 2009 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_ALT_TAB_HANDLER_H
-#define META_ALT_TAB_HANDLER_H
-
-#include <glib-object.h>
-
-#include "types.h"
-
-#define META_TYPE_ALT_TAB_HANDLER               (meta_alt_tab_handler_get_type ())
-#define META_ALT_TAB_HANDLER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ALT_TAB_HANDLER, MetaAltTabHandler))
-#define META_ALT_TAB_HANDLER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), META_TYPE_ALT_TAB_HANDLER, MetaAltTabHandlerInterface))
-
-typedef struct _MetaAltTabHandler          MetaAltTabHandler;
-typedef struct _MetaAltTabHandlerInterface MetaAltTabHandlerInterface;
-
-struct _MetaAltTabHandlerInterface {
-  GTypeInterface g_iface;
-
-  void         (*add_window)   (MetaAltTabHandler *handler,
-                                MetaWindow        *window);
-
-  void         (*show)         (MetaAltTabHandler *handler,
-                                MetaWindow        *initial_selection);
-  void         (*destroy)      (MetaAltTabHandler *handler);
-
-  void         (*forward)      (MetaAltTabHandler *handler);
-  void         (*backward)     (MetaAltTabHandler *handler);
-
-  MetaWindow * (*get_selected) (MetaAltTabHandler *handler);
-};
-
-GType              meta_alt_tab_handler_get_type     (void);
-
-void               meta_alt_tab_handler_register     (GType              type);
-MetaAltTabHandler *meta_alt_tab_handler_new          (MetaScreen        *screen,
-                                                      gboolean           immediate);
-
-void               meta_alt_tab_handler_add_window   (MetaAltTabHandler *handler,
-                                                      MetaWindow        *window);
-
-void               meta_alt_tab_handler_show         (MetaAltTabHandler *handler,
-                                                      MetaWindow        *initial_selection);
-void               meta_alt_tab_handler_destroy      (MetaAltTabHandler *handler);
-
-void               meta_alt_tab_handler_forward      (MetaAltTabHandler *handler);
-void               meta_alt_tab_handler_backward     (MetaAltTabHandler *handler);
-
-MetaWindow        *meta_alt_tab_handler_get_selected (MetaAltTabHandler *handler);
-
-#endif
-

src/include/alttabhandlerdefault.h

@@ -1,55 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/* Metacity Alt-Tab abstraction: default implementation */
-
-/* 
- * Copyright (C) 2009 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_ALT_TAB_HANDLER_DEFAULT_H
-#define META_ALT_TAB_HANDLER_DEFAULT_H
-
-#include "alttabhandler.h"
-#include "tabpopup.h"
-
-#define META_TYPE_ALT_TAB_HANDLER_DEFAULT (meta_alt_tab_handler_default_get_type ())
-#define META_ALT_TAB_HANDLER_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_ALT_TAB_HANDLER_DEFAULT, MetaAltTabHandlerDefault))
-
-typedef struct _MetaAltTabHandlerDefault      MetaAltTabHandlerDefault;
-typedef struct _MetaAltTabHandlerDefaultClass MetaAltTabHandlerDefaultClass;
-
-struct _MetaAltTabHandlerDefault {
-  GObject parent_instance;
-
-  MetaScreen *screen;
-
-  GArray *entries;
-  gboolean immediate_mode;
-
-  MetaTabPopup *tab_popup;
-};
-
-struct _MetaAltTabHandlerDefaultClass {
-  GObjectClass parent_class;
-
-};
-
-GType              meta_alt_tab_handler_default_get_type (void);
-
-#endif
-

src/include/atomnames.h

@@ -58,6 +58,7 @@ item(_MUTTER_RESTART_MESSAGE)
 item(_MUTTER_RELOAD_THEME_MESSAGE)
 item(_MUTTER_SET_KEYBINDINGS_MESSAGE)
 item(_MUTTER_TOGGLE_VERBOSE)
+item(_GNOME_WM_KEYBINDINGS)
 item(_GNOME_PANEL_ACTION)
 item(_GNOME_PANEL_ACTION_MAIN_MENU)
 item(_GNOME_PANEL_ACTION_RUN_DIALOG)

src/include/boxes.h

@@ -58,7 +58,7 @@ typedef enum
 typedef enum
 {
   META_EDGE_WINDOW,
-  META_EDGE_XINERAMA,
+  META_EDGE_MONITOR,
   META_EDGE_SCREEN
 } MetaEdgeType;
 
@@ -193,7 +193,7 @@ void     meta_rectangle_expand_to_avoiding_struts (
  * or
  *   meta_rectangle_find_onscreen_edges ()
  * or
- *   meta_rectangle_find_nonintersected_xinerama_edges()
+ *   meta_rectangle_find_nonintersected_monitor_edges()
  */
 void     meta_rectangle_free_list_and_elements (GList *filled_list);
 
@@ -280,11 +280,11 @@ GList* meta_rectangle_remove_intersections_with_boxes_from_edges (
 GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
                                            const GSList        *all_struts);
 
-/* Finds edges between adjacent xineramas which are not covered by the given
+/* Finds edges between adjacent monitors which are not covered by the given
  * struts.
  */
-GList* meta_rectangle_find_nonintersected_xinerama_edges (
-                                           const GList         *xinerama_rects,
+GList* meta_rectangle_find_nonintersected_monitor_edges (
+                                           const GList         *monitor_rects,
                                            const GSList        *all_struts);
 
 #endif /* META_BOXES_H */

src/include/common.h

@@ -138,7 +138,10 @@ typedef enum
   META_GRAB_OP_CLICKING_ABOVE,
   META_GRAB_OP_CLICKING_UNABOVE,
   META_GRAB_OP_CLICKING_STICK,
-  META_GRAB_OP_CLICKING_UNSTICK
+  META_GRAB_OP_CLICKING_UNSTICK,
+
+  /* Special grab op when the compositor asked for a grab */
+  META_GRAB_OP_COMPOSITOR
 } MetaGrabOp;
 
 typedef enum
@@ -233,6 +236,22 @@ typedef enum
   META_DIRECTION_VERTICAL   = META_DIRECTION_UP   | META_DIRECTION_DOWN,
 } MetaDirection;
 
+/* Negative to avoid conflicting with real workspace
+ * numbers
+ */
+typedef enum
+{
+  META_MOTION_UP = -1,
+  META_MOTION_DOWN = -2,
+  META_MOTION_LEFT = -3,
+  META_MOTION_RIGHT = -4,
+  /* These are only used for effects */
+  META_MOTION_UP_LEFT = -5,
+  META_MOTION_UP_RIGHT = -6,
+  META_MOTION_DOWN_LEFT = -7,
+  META_MOTION_DOWN_RIGHT = -8
+} MetaMotionDirection;
+
 /* Sometimes we want to talk about sides instead of directions; note
  * that the values must be as follows or meta_window_update_struts()
  * won't work. Using these values also is a safety blanket since
@@ -298,8 +317,10 @@ struct _MetaButtonLayout
  * coelesce multiple things together, the appropriate place to
  * do it is usually META_PRIORITY_BEFORE_REDRAW.
  *
- * (FIXME: Use a Clutter paint() function instead, to prevent
- * starving the repaints)
+ * Note that its usually better to use meta_later_add() rather
+ * than calling g_idle_add() directly; this will make sure things
+ * get run when added from a clutter event handler without
+ * waiting for another repaint cycle.
  *
  * If something has a priority lower than the redraw priority
  * (such as a default priority idle), then it may be arbitrarily

src/include/compositor-clutter.h

@@ -1,77 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright (C) 2008 Matthew Allum
- * Copyright (C) 2007 Iain Holmes
- * Based on xcompmgr - (c) 2003 Keith Packard
- *          xfwm4    - (c) 2005-2007 Olivier Fourdan
- *
- * 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_COMPOSITOR_CLUTTER_H_
-#define META_COMPOSITOR_CLUTTER_H_
-
-#include <clutter/clutter.h>
-#include <xlib/xlib.h>
-
-#include "types.h"
-
-/*
- * MetaCompWindow object (ClutterGroup sub-class)
- */
-#define META_TYPE_COMP_WINDOW            (meta_comp_window_get_type ())
-#define META_COMP_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_COMP_WINDOW, MetaCompWindow))
-#define META_COMP_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_COMP_WINDOW, MetaCompWindowClass))
-#define IS_META_COMP_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_COMP_WINDOW_TYPE))
-#define META_IS_COMP_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_COMP_WINDOW))
-#define META_COMP_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_COMP_WINDOW, MetaCompWindowClass))
-
-typedef struct _MetaCompWindow        MetaCompWindow;
-typedef struct _MetaCompWindowClass   MetaCompWindowClass;
-typedef struct _MetaCompWindowPrivate MetaCompWindowPrivate;
-
-struct _MetaCompWindowClass
-{
-  ClutterGroupClass parent_class;
-};
-
-struct _MetaCompWindow
-{
-  ClutterGroup           parent;
-
-  MetaCompWindowPrivate *priv;
-};
-
-GType meta_comp_window_get_type (void);
-
-Window             meta_comp_window_get_x_window    (MetaCompWindow *mcw);
-MetaCompWindowType meta_comp_window_get_window_type (MetaCompWindow *mcw);
-gint               meta_comp_window_get_workspace   (MetaCompWindow *mcw);
-
-
-/* Compositor API */
-MetaCompositor *meta_compositor_clutter_new (MetaDisplay *display);
-
-void meta_compositor_clutter_window_effect_completed (MetaCompWindow *actor, gulong event);
-
-ClutterActor * meta_compositor_clutter_get_stage_for_screen (MetaScreen *screen);
-ClutterActor * meta_compositor_clutter_get_overlay_group_for_screen (MetaScreen *screen);
-
-Window meta_compositor_clutter_get_overlay_window (MetaScreen *screen);
-
-
-#endif

src/include/compositor-mutter.h

@@ -26,63 +26,17 @@
 #define MUTTER_H_
 
 #include <clutter/clutter.h>
-#include <X11/extensions/Xfixes.h>
 #include <X11/Xlib.h>
 
 #include "types.h"
 #include "compositor.h"
+#include "mutter-window.h"
 
-/*
- * MutterWindow object (ClutterGroup sub-class)
- */
-#define MUTTER_TYPE_COMP_WINDOW       (mutter_window_get_type ())
-#define MUTTER_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindow))
-#define MUTTER_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
-#define MUTTER_IS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_COMP_WINDOW))
-#define MUTTER_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MUTTER_TYPE_COMP_WINDOW))
-#define MUTTER_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
-
-typedef struct _MutterWindow        MutterWindow;
-typedef struct _MutterWindowClass   MutterWindowClass;
-typedef struct _MutterWindowPrivate MutterWindowPrivate;
-
-struct _MutterWindowClass
-{
-  ClutterGroupClass parent_class;
-};
-
-struct _MutterWindow
-{
-  ClutterGroup           parent;
-
-  MutterWindowPrivate *priv;
-};
-
-GType mutter_window_get_type (void);
-
-Window             mutter_window_get_x_window         (MutterWindow *mcw);
-MetaCompWindowType mutter_window_get_window_type      (MutterWindow *mcw);
-gint               mutter_window_get_workspace        (MutterWindow *mcw);
-gboolean           mutter_window_is_hidden            (MutterWindow *mcw);
-MetaWindow *       mutter_window_get_meta_window      (MutterWindow *mcw);
-ClutterActor *     mutter_window_get_texture          (MutterWindow *mcw);
-gboolean           mutter_window_is_override_redirect (MutterWindow *mcw);
-const char *       mutter_window_get_description      (MutterWindow *mcw);
-gboolean       mutter_window_showing_on_its_workspace (MutterWindow *mcw);
-
-/* Compositor API */
-MetaCompositor *mutter_new (MetaDisplay *display);
-
-void mutter_window_effect_completed (MutterWindow *actor, gulong event);
-
+/* Public compositor API */
 ClutterActor * mutter_get_stage_for_screen (MetaScreen *screen);
 ClutterActor * mutter_get_overlay_group_for_screen (MetaScreen *screen);
 Window         mutter_get_overlay_window (MetaScreen *screen);
 GList        * mutter_get_windows (MetaScreen *screen);
 ClutterActor * mutter_get_window_group_for_screen (MetaScreen *screen);
 
-void mutter_set_stage_input_region   (MetaScreen   *screen,
-                                      XserverRegion region);
-void mutter_empty_stage_input_region (MetaScreen   *screen);
-
 #endif

src/include/compositor.h

@@ -53,110 +53,134 @@ typedef enum _MetaCompWindowType
 
 } MetaCompWindowType;
 
-#ifdef WITH_CLUTTER
-extern int meta_compositor_can_use_clutter__;
-#endif
-MetaCompositor *meta_compositor_new (MetaDisplay *display);
-void meta_compositor_destroy (MetaCompositor *compositor);
+/**
+ * MetaCompEffect:
+ * @META_COMP_EFFECT_CREATE: The window is newly created
+ *   (also used for a window that was previously on a different
+ *   workspace and is changed to become visible on the active
+ *   workspace.)
+ * @META_COMP_EFFECT_UNMINIMIZE: The window should be shown
+ *   as unminimizing from its icon geometry.
+ * @META_COMP_EFFECT_DESTROY: The window is being destroyed
+ * @META_COMP_EFFECT_MINIMIZE: The window should be shown
+ *   as minimizing to its icon geometry.
+ * @META_COMP_EFFECT_NONE: No effect, the window should be
+ *   shown or hidden immediately.
+ *
+ * Indicates the appropriate effect to show the user for
+ * meta_compositor_show_window() and meta_compositor_hide_window()
+ */
+typedef enum
+{
+  META_COMP_EFFECT_CREATE,
+  META_COMP_EFFECT_UNMINIMIZE,
+  META_COMP_EFFECT_DESTROY,
+  META_COMP_EFFECT_MINIMIZE,
+  META_COMP_EFFECT_NONE
+} MetaCompEffect;
 
-void meta_compositor_manage_screen (MetaCompositor *compositor,
-                                    MetaScreen     *screen);
+MetaCompositor *meta_compositor_new     (MetaDisplay    *display);
+void            meta_compositor_destroy (MetaCompositor *compositor);
+
+void meta_compositor_manage_screen   (MetaCompositor *compositor,
+                                      MetaScreen     *screen);
 void meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                       MetaScreen     *screen);
 
-void meta_compositor_add_window (MetaCompositor    *compositor,
-                                 MetaWindow        *window);
-void meta_compositor_remove_window (MetaCompositor *compositor,
-                                    MetaWindow     *window);
-
-void meta_compositor_set_updates (MetaCompositor *compositor,
-                                  MetaWindow     *window,
-                                  gboolean        updates);
-
 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                         XEvent         *event,
                                         MetaWindow     *window);
-Pixmap meta_compositor_get_window_pixmap (MetaCompositor *compositor,
-                                          MetaWindow     *window);
-void meta_compositor_set_active_window (MetaCompositor *compositor,
-                                        MetaScreen     *screen,
-                                        MetaWindow     *window);
 
-void meta_compositor_begin_move (MetaCompositor *compositor,
-                                 MetaWindow *window,
-                                 MetaRectangle *initial,
-                                 int grab_x, int grab_y);
-void meta_compositor_update_move (MetaCompositor *compositor,
-                                  MetaWindow *window,
-                                  int x, int y);
-void meta_compositor_end_move (MetaCompositor *compositor,
-                               MetaWindow *window);
-void meta_compositor_free_window (MetaCompositor *compositor,
-                                  MetaWindow *window);
+/* At a high-level, a window is not-visible or visible. When a
+ * window is added (with add_window()) it is not visible.
+ * show_window() indicates a transition from not-visible to
+ * visible. Some of the reasons for this:
+ *
+ *  - Window newly created
+ *  - Window is unminimized
+ *  - Window is moved to the current desktop
+ *  - Window was made sticky
+ *
+ * hide_window() indicates that the window has transitioned from
+ * visible to not-visible. Some reasons include:
+ *
+ *  - Window was destroyed
+ *  - Window is minimized
+ *  - Window is moved to a different desktop
+ *  - Window no longer sticky.
+ *
+ * Note that combinations are possible - a window might have first
+ * been minimized and then moved to a different desktop. The
+ * 'effect' parameter to show_window() and hide_window() is a hint
+ * as to the appropriate effect to show the user and should not
+ * be considered to be indicative of a state change.
+ *
+ * When the active workspace is changed, switch_workspace() is called
+ * first, then show_window() and hide_window() are called individually
+ * for each window affected, with an effect of META_COMP_EFFECT_NONE.
+ * If hiding windows will affect the switch workspace animation, the
+ * compositor needs to delay hiding the windows until the switch
+ * workspace animation completes.
+ *
+ * maximize_window() and unmaximize_window() are transitions within
+ * the visible state. The window is resized *before* the call, so
+ * it may be necessary to readjust the display based on the old_rect
+ * to start the animation.
+ *
+ * window_mapped() and window_unmapped() are notifications when the
+ * toplevel window (frame or client window) is mapped or unmapped.
+ * That is, when the result of meta_window_toplevel_is_mapped()
+ * changes. The main use of this is to drop resources when a window
+ * is unmapped. A window will always be mapped before show_window()
+ * is called and will not be unmapped until after hide_window() is
+ * called. If the live_hidden_windows preference is set, windows will
+ * never be unmapped.
+ */
 
-void
-meta_compositor_map_window (MetaCompositor *compositor,
-			    MetaWindow	   *window);
-
-void
-meta_compositor_unmap_window (MetaCompositor *compositor,
-			      MetaWindow     *window);
-
-void
-meta_compositor_minimize_window (MetaCompositor *compositor,
-                                 MetaWindow     *window,
-				 MetaRectangle	*window_rect,
-				 MetaRectangle  *icon_rect);
-
-void
-meta_compositor_unminimize_window (MetaCompositor *compositor,
-				   MetaWindow     *window,
-				   MetaRectangle  *window_rect,
-				   MetaRectangle  *icon_rect);
-
-void
-meta_compositor_maximize_window (MetaCompositor    *compositor,
-                                 MetaWindow        *window,
-				 MetaRectangle	   *window_rect);
-
-void
-meta_compositor_unmaximize_window (MetaCompositor    *compositor,
-                                   MetaWindow        *window,
-				   MetaRectangle     *window_rect);
-
-void
-meta_compositor_update_workspace_geometry (MetaCompositor *compositor,
-                                           MetaWorkspace  *workspace);
-
-void
-meta_compositor_switch_workspace (MetaCompositor     *compositor,
-                                  MetaScreen         *screen,
-                                  MetaWorkspace      *from,
-                                  MetaWorkspace      *to,
-                                  MetaMotionDirection direction);
-
-void
-meta_compositor_sync_stack (MetaCompositor  *compositor,
-			    MetaScreen      *screen,
-			    GList	    *stack);
-
-void
-meta_compositor_set_window_hidden (MetaCompositor *compositor,
-				   MetaScreen	  *screen,
-				   MetaWindow	  *window,
-				   gboolean	   hidden);
-
-void
-meta_compositor_sync_window_geometry (MetaCompositor *compositor,
-				      MetaWindow     *window);
-void
-meta_compositor_sync_screen_size (MetaCompositor  *compositor,
-				  MetaScreen	  *screen,
-				  guint		   width,
-				  guint		   height);
-#endif
+void meta_compositor_add_window    (MetaCompositor *compositor,
+                                    MetaWindow     *window);
+void meta_compositor_remove_window (MetaCompositor *compositor,
+                                    MetaWindow     *window);
 
+void meta_compositor_show_window       (MetaCompositor      *compositor,
+                                        MetaWindow          *window,
+                                        MetaCompEffect       effect);
+void meta_compositor_hide_window       (MetaCompositor      *compositor,
+                                        MetaWindow          *window,
+                                        MetaCompEffect       effect);
+void meta_compositor_switch_workspace  (MetaCompositor      *compositor,
+                                        MetaScreen          *screen,
+                                        MetaWorkspace       *from,
+                                        MetaWorkspace       *to,
+                                        MetaMotionDirection  direction);
 
+void meta_compositor_maximize_window   (MetaCompositor      *compositor,
+                                        MetaWindow          *window,
+                                        MetaRectangle       *old_rect,
+                                        MetaRectangle       *new_rect);
+void meta_compositor_unmaximize_window (MetaCompositor      *compositor,
+                                        MetaWindow          *window,
+                                        MetaRectangle       *old_rect,
+                                        MetaRectangle       *new_rect);
 
+void meta_compositor_window_mapped        (MetaCompositor *compositor,
+                                           MetaWindow     *window);
+void meta_compositor_window_unmapped      (MetaCompositor *compositor,
+                                           MetaWindow     *window);
+void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
+                                           MetaWindow     *window);
+void meta_compositor_set_updates          (MetaCompositor *compositor,
+                                           MetaWindow     *window,
+                                           gboolean        updates);
 
+void meta_compositor_update_workspace_geometry (MetaCompositor *compositor,
+                                                MetaWorkspace  *workspace);
+void meta_compositor_sync_stack                (MetaCompositor *compositor,
+                                                MetaScreen     *screen,
+                                                GList          *stack);
+void meta_compositor_sync_screen_size          (MetaCompositor *compositor,
+                                                MetaScreen     *screen,
+                                                guint           width,
+                                                guint           height);
 
+#endif /* META_COMPOSITOR_H */

src/include/display.h

@@ -75,6 +75,9 @@ MetaScreen *meta_display_screen_for_root (MetaDisplay *display,
                                           Window       xroot);
 MetaWindow *meta_display_get_focus_window (MetaDisplay *display);
 
+gboolean  meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
+                                                     Window xwindow);
+
 int meta_display_get_damage_event_base (MetaDisplay *display);
 int meta_display_get_shape_event_base (MetaDisplay *display);
 Atom meta_display_get_atom (MetaDisplay *display, MetaAtom meta_atom);
@@ -111,6 +114,10 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display,
                                      int          root_y);
 void     meta_display_end_grab_op   (MetaDisplay *display,
                                      guint32      timestamp);
+
+MetaGrabOp meta_display_get_grab_op (MetaDisplay *display);
+
+
 /* meta_display_set_input_focus_window is like XSetInputFocus, except
  * that (a) it can't detect timestamps later than the current time,
  * since Mutter isn't part of the XServer, and thus gives erroneous

src/include/errors.h

@@ -29,15 +29,8 @@
 #include "util.h"
 #include "display.h"
 
-typedef void (* ErrorHandler) (Display *dpy,
-                               XErrorEvent *error,
-                               gpointer data);
-
 void      meta_errors_init     (void);
-void	  meta_errors_register_foreign_display (Display      *foreign_dpy,
-						ErrorHandler  handler,
-						gpointer      data);
-						
+
 void      meta_error_trap_push (MetaDisplay *display);
 void      meta_error_trap_pop  (MetaDisplay *display,
                                 gboolean     last_request_was_roundtrip);

src/include/mutter-plugin.h

@@ -48,7 +48,7 @@
 #define MUTTER_TYPE_PLUGIN            (mutter_plugin_get_type ())
 #define MUTTER_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_PLUGIN, MutterPlugin))
 #define MUTTER_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  MUTTER_TYPE_PLUGIN, MutterPluginClass))
-#define MUTTER_IS_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_PLUGIN_TYPE))
+#define MUTTER_IS_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_PLUGIN))
 #define MUTTER_IS_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  MUTTER_TYPE_PLUGIN))
 #define MUTTER_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  MUTTER_TYPE_PLUGIN, MutterPluginClass))
 
@@ -255,6 +255,31 @@ void
 mutter_plugin_set_stage_input_region (MutterPlugin *plugin,
                                       XserverRegion region);
 
+/**
+ * MetaModalOptions:
+ * @META_MODAL_POINTER_ALREADY_GRABBED: if set the pointer is already
+ *   grabbed by the plugin and should not be grabbed again.
+ * @META_MODAL_KEYBOARD_ALREADY_GRABBED: if set the keyboard is already
+ *   grabbed by the plugin and should not be grabbed again.
+ *
+ * Options that can be provided when calling mutter_plugin_begin_modal().
+ */
+typedef enum {
+  META_MODAL_POINTER_ALREADY_GRABBED = 1 << 0,
+  META_MODAL_KEYBOARD_ALREADY_GRABBED = 1 << 1
+} MetaModalOptions;
+
+gboolean
+mutter_plugin_begin_modal (MutterPlugin      *plugin,
+                           Window             grab_window,
+                           Cursor             cursor,
+                           MetaModalOptions   options,
+                           guint32            timestamp);
+
+void
+mutter_plugin_end_modal (MutterPlugin *plugin,
+                         guint32       timestamp);
+
 GList *
 mutter_plugin_get_windows (MutterPlugin *plugin);
 

src/include/mutter-window.h

@@ -0,0 +1,71 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/*
+ * Copyright (C) 2008 Matthew Allum
+ * Copyright (C) 2007 Iain Holmes
+ * Based on xcompmgr - (c) 2003 Keith Packard
+ *          xfwm4    - (c) 2005-2007 Olivier Fourdan
+ *
+ * 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 MUTTER_WINDOW_H_
+#define MUTTER_WINDOW_H_
+
+#include <clutter/clutter.h>
+#include <X11/Xlib.h>
+
+#include "compositor.h"
+
+/*
+ * MutterWindow object (ClutterGroup sub-class)
+ */
+#define MUTTER_TYPE_COMP_WINDOW       (mutter_window_get_type ())
+#define MUTTER_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindow))
+#define MUTTER_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
+#define MUTTER_IS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MUTTER_TYPE_COMP_WINDOW))
+#define MUTTER_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MUTTER_TYPE_COMP_WINDOW))
+#define MUTTER_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MUTTER_TYPE_COMP_WINDOW, MutterWindowClass))
+
+typedef struct _MutterWindow        MutterWindow;
+typedef struct _MutterWindowClass   MutterWindowClass;
+typedef struct _MutterWindowPrivate MutterWindowPrivate;
+
+struct _MutterWindowClass
+{
+  ClutterGroupClass parent_class;
+};
+
+struct _MutterWindow
+{
+  ClutterGroup           parent;
+
+  MutterWindowPrivate *priv;
+};
+
+GType mutter_window_get_type (void);
+
+Window             mutter_window_get_x_window         (MutterWindow *mcw);
+MetaCompWindowType mutter_window_get_window_type      (MutterWindow *mcw);
+gint               mutter_window_get_workspace        (MutterWindow *mcw);
+gboolean           mutter_window_is_hidden            (MutterWindow *mcw);
+MetaWindow *       mutter_window_get_meta_window      (MutterWindow *mcw);
+ClutterActor *     mutter_window_get_texture          (MutterWindow *mcw);
+gboolean           mutter_window_is_override_redirect (MutterWindow *mcw);
+const char *       mutter_window_get_description      (MutterWindow *mcw);
+gboolean       mutter_window_showing_on_its_workspace (MutterWindow *mcw);
+
+#endif /* MUTTER_WINDOW_H */

src/include/prefs.h

@@ -53,19 +53,16 @@ typedef enum
   META_PREF_VISUAL_BELL,
   META_PREF_AUDIBLE_BELL,
   META_PREF_VISUAL_BELL_TYPE,
-  META_PREF_REDUCED_RESOURCES,
   META_PREF_GNOME_ACCESSIBILITY,
   META_PREF_GNOME_ANIMATIONS,
   META_PREF_CURSOR_THEME,
   META_PREF_CURSOR_SIZE,
   META_PREF_COMPOSITING_MANAGER,
   META_PREF_RESIZE_WITH_RIGHT_BUTTON,
-#ifdef WITH_CLUTTER
-  META_PREF_CLUTTER_DISABLED,
+  META_PREF_FORCE_FULLSCREEN,
   META_PREF_CLUTTER_PLUGINS,
-#endif
   META_PREF_LIVE_HIDDEN_WINDOWS,
-  META_PREF_NO_TAB_POPUP,
+  META_PREF_NO_TAB_POPUP
 } MetaPreference;
 
 typedef void (* MetaPrefsChangedFunc) (MetaPreference pref,
@@ -93,7 +90,6 @@ gboolean                    meta_prefs_get_application_based  (void);
 gboolean                    meta_prefs_get_disable_workarounds (void);
 gboolean                    meta_prefs_get_auto_raise         (void);
 int                         meta_prefs_get_auto_raise_delay   (void);
-gboolean                    meta_prefs_get_reduced_resources  (void);
 gboolean                    meta_prefs_get_gnome_accessibility (void);
 gboolean                    meta_prefs_get_gnome_animations   (void);
 
@@ -120,6 +116,7 @@ void        meta_prefs_change_workspace_name (int         i,
 const char* meta_prefs_get_cursor_theme      (void);
 int         meta_prefs_get_cursor_size       (void);
 gboolean    meta_prefs_get_compositing_manager (void);
+gboolean    meta_prefs_get_force_fullscreen  (void);
 
 /**
  * Sets whether the compositor is turned on.
@@ -128,10 +125,7 @@ gboolean    meta_prefs_get_compositing_manager (void);
  */
 void meta_prefs_set_compositing_manager (gboolean whether);
 
-#ifdef WITH_CLUTTER
-
-gboolean meta_prefs_get_clutter_disabled (void);
-void     meta_prefs_set_clutter_disabled (gboolean whether);
+void meta_prefs_set_force_fullscreen (gboolean whether);
 
 GSList * meta_prefs_get_clutter_plugins (void);
 
@@ -150,8 +144,6 @@ void meta_prefs_set_clutter_plugins (GSList *list);
  */
 void meta_prefs_override_clutter_plugins (GSList *list);
 
-#endif
-
 gboolean meta_prefs_get_live_hidden_windows (void);
 void     meta_prefs_set_live_hidden_windows (gboolean whether);
 

src/include/screen.h

@@ -25,11 +25,12 @@
 #include <X11/Xlib.h>
 #include <glib-object.h>
 #include "types.h"
+#include "workspace.h"
 
 #define META_TYPE_SCREEN            (meta_screen_get_type ())
 #define META_SCREEN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_SCREEN, MetaScreen))
 #define META_SCREEN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_SCREEN, MetaScreenClass))
-#define META_IS_SCREEN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_SCREEN_TYPE))
+#define META_IS_SCREEN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_SCREEN))
 #define META_IS_SCREEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  META_TYPE_SCREEN))
 #define META_SCREEN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  META_TYPE_SCREEN, MetaScreenClass))
 
@@ -51,10 +52,10 @@ void meta_screen_set_compositor_data (MetaScreen *screen,
 
 MetaScreen *meta_screen_for_x_screen (Screen *xscreen);
 
-#ifdef HAVE_COMPOSITE_EXTENSIONS
 void meta_screen_set_cm_selection (MetaScreen *screen);
 void meta_screen_unset_cm_selection (MetaScreen *screen);
-#endif
+
+GSList *meta_screen_get_startup_sequences (MetaScreen *screen);
 
 GList *meta_screen_get_workspaces (MetaScreen *screen);
 
@@ -74,4 +75,9 @@ int meta_screen_get_active_workspace_index (MetaScreen *screen);
 
 MetaWorkspace * meta_screen_get_active_workspace (MetaScreen *screen);
 
+int  meta_screen_get_n_monitors       (MetaScreen    *screen);
+void meta_screen_get_monitor_geometry (MetaScreen    *screen,
+                                       int            monitor,
+                                       MetaRectangle *geometry);
+
 #endif

src/include/ui.h

@@ -76,7 +76,8 @@ Window meta_ui_create_frame_window (MetaUI *ui,
 				    gint y,
 				    gint width,
 				    gint height,
-				    gint screen_no);
+				    gint screen_no,
+                                    gulong *create_serial);
 void meta_ui_destroy_frame_window (MetaUI *ui,
 				   Window  xwindow);
 void meta_ui_move_resize_frame (MetaUI *ui,

src/include/util.h

@@ -131,35 +131,25 @@ GPid meta_show_dialog (const char *type,
 
 #endif /* !WITH_VERBOSE_MODE */
 
-#include <glib-object.h>
-
-#define META_TYPE_NEXUS            (meta_nexus_get_type ())
-#define META_NEXUS(obj)            (GTK_CHECK_CAST ((obj), META_TYPE_NEXUS, MetaNexus))
-#define META_NEXUS_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), META_TYPE_NEXUS, MetaNexusClass))
-#define META_IS_NEXUS(obj)         (GTK_CHECK_TYPE ((obj), META_TYPE_NEXUS))
-#define META_IS_NEXUS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), META_TYPE_NEXUS))
-#define META_NEXUS_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), META_TYPE_NEXUS, MetaNexusClass))
-
-typedef struct _MetaNexus
-{
-  GObject parent_instance;
-} MetaNexus;
-
-typedef struct _MetaNexusClass
-{
-  GObjectClass parent_class;
-} MetaNexusClass;
-
-GType meta_nexus_get_type (void) G_GNUC_CONST;
-MetaNexus *meta_nexus_new ();
-
 /**
- * An object which exists purely to attach signals to; this is to receive
- * signals when a child process exits.  The signal is "sigchld" with no detail.
- *
- * \bug Eventually we should have a specialised type for objects like these.
- */
-extern MetaNexus *sigchld_nexus;
+ * MetaLaterType:
+ * @META_LATER_RESIZE: call in a resize processing phase that is done
+ *   before GTK+ repainting (including window borders) is done.
+ * @META_LATER_BEFORE_REDRAW: call before the stage is redrawn
+ * @META_LATER_IDLE: call at a very low priority (can be blocked
+ *    by running animations or redrawing applications)
+ **/
+typedef enum {
+  META_LATER_RESIZE,
+  META_LATER_BEFORE_REDRAW,
+  META_LATER_IDLE
+} MetaLaterType;
+
+guint meta_later_add    (MetaLaterType  when,
+                         GSourceFunc    func,
+                         gpointer       data,
+                         GDestroyNotify notify);
+void  meta_later_remove (guint          later_id);
 
 #endif /* META_UTIL_H */
 

src/include/window.h

@@ -70,6 +70,8 @@ GType meta_window_get_type (void);
 MetaFrame *meta_window_get_frame (MetaWindow *window);
 gboolean meta_window_has_focus (MetaWindow *window);
 gboolean meta_window_is_shaded (MetaWindow *window);
+gboolean meta_window_is_override_redirect (MetaWindow *window);
+gboolean meta_window_is_skip_taskbar (MetaWindow *window);
 MetaRectangle *meta_window_get_rect (MetaWindow *window);
 void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect);
 MetaScreen *meta_window_get_screen (MetaWindow *window);
@@ -100,6 +102,10 @@ void meta_window_configure_notify (MetaWindow *window, XConfigureEvent *event);
 const char *meta_window_get_role (MetaWindow *window);
 MetaStackLayer meta_window_get_layer (MetaWindow *window);
 MetaWindow* meta_window_find_root_ancestor    (MetaWindow *window);
+gboolean meta_window_is_ancestor_of_transient (MetaWindow            *window,
+                                               MetaWindow            *transient);
+gboolean meta_window_is_mapped (MetaWindow  *window);
+gboolean meta_window_toplevel_is_mapped (MetaWindow  *window);
 gboolean meta_window_get_icon_geometry (MetaWindow    *window,
                                         MetaRectangle *rect);
 void meta_window_maximize   (MetaWindow        *window,
@@ -110,7 +116,12 @@ void        meta_window_minimize           (MetaWindow  *window);
 void        meta_window_unminimize         (MetaWindow  *window);
 const char *meta_window_get_title (MetaWindow *window);
 MetaWindow *meta_window_get_transient_for (MetaWindow *window);
+Window      meta_window_get_transient_for_as_xid (MetaWindow *window);
 void        meta_window_delete             (MetaWindow  *window,
                                             guint32      timestamp);
-
+guint       meta_window_get_stable_sequence (MetaWindow *window);
+guint32     meta_window_get_user_time (MetaWindow *window);
+int         meta_window_get_pid (MetaWindow *window);
+const char *meta_window_get_client_machine (MetaWindow *window);
+gboolean    meta_window_is_modal (MetaWindow *window);
 #endif

src/include/workspace.h

@@ -37,22 +37,6 @@
 #include "boxes.h"
 #include "screen.h"
 
-/* Negative to avoid conflicting with real workspace
- * numbers
- */
-typedef enum
-{
-  META_MOTION_UP = -1,
-  META_MOTION_DOWN = -2,
-  META_MOTION_LEFT = -3,
-  META_MOTION_RIGHT = -4,
-  /* These are only used for effects */
-  META_MOTION_UP_LEFT = -5,
-  META_MOTION_UP_RIGHT = -6,
-  META_MOTION_DOWN_LEFT = -7,
-  META_MOTION_DOWN_RIGHT = -8
-} MetaMotionDirection;
-
 #define META_TYPE_WORKSPACE            (meta_workspace_get_type ())
 #define META_WORKSPACE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_WORKSPACE, MetaWorkspace))
 #define META_WORKSPACE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  META_TYPE_WORKSPACE, MetaWorkspaceClass))
@@ -66,8 +50,9 @@ GType meta_workspace_get_type (void);
 
 int  meta_workspace_index (MetaWorkspace *workspace);
 MetaScreen *meta_workspace_get_screen (MetaWorkspace *workspace);
-void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace,
-                                                 MetaRectangle *area);
+GList* meta_workspace_list_windows (MetaWorkspace *workspace);
+void meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
+                                                MetaRectangle *area);
 void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp);
 void meta_workspace_activate_with_focus (MetaWorkspace *workspace,
                                          MetaWindow    *focus_this,

src/mutter-enum-types.c.in

@@ -0,0 +1,40 @@
+/*** BEGIN file-header ***/
+#include "mutter-enum-types.h"
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+
+/* enumerations from "@filename@" */
+#include "@filename@"
+
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType
+@enum_name@_get_type (void)
+{
+  static volatile gsize g_enum_type_id__volatile = 0;
+
+  if (g_once_init_enter (&g_enum_type_id__volatile))
+    {
+      static const G@Type@Value values[] = {
+/*** END value-header ***/
+
+/*** BEGIN value-production ***/
+        { @VALUENAME@, "@VALUENAME@", "@valuenick@" },
+/*** END value-production ***/
+
+/*** BEGIN value-tail ***/
+        { 0, NULL, NULL }
+      };
+      GType g_enum_type_id;
+
+      g_enum_type_id =
+        g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
+
+      g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
+    }
+
+  return g_enum_type_id__volatile;
+}
+/*** END value-tail ***/