Bump version to 3.10.4

Update NEWS.
idle-monitor: avoid XSyncBadAlarm X error
2014-02-19 19:40:16 +01:00 · 2014-02-15 13:14:29 +01:00 · 2014-02-13 13:19:32 +01:00 · 2014-02-06 15:37:28 +02:00 · 2014-02-05 16:27:18 +05:30 · 2014-02-05 09:48:01 +01:00
53 changed files with 1976 additions and 3872 deletions
--- a/Makefile.am
+++ b/Makefile.am
@ -8,5 +8,3 @@ EXTRA_DIST = HACKING MAINTAINERS rationales.txt
 DISTCLEANFILES = intltool-extract intltool-merge intltool-update po/stamp-it po/.intltool-merge-cache

 DISTCHECK_CONFIGURE_FLAGS = --enable-gtk-doc
-
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
--- a/62
+++ b/62
@ -1,26 +1,52 @@
-3.11.2
+3.10.4
 ======
-* Fix resize operations using mouse-button-modifier [Lionel; #710251]
-* Misc. fixes and cleanups [Jasper, Rico, Florian; #711731]
+* Fix CSD titlebars being placed off-screen [Jasper; #719772]
+* Expose MetaWindow:skip-taskbar property [Florian; #723307]
+* Fix legacy tray icons showing up blank [Adel; #721596]
+* Fix configuration of cloned monitors [Adel; #710610]
+* Use correct output property for backlight control [Robert; #723606]
+* Misc. bug fixes [Jasper, Adel, Giovanni, Ryan; #720630, #723468, #724258,
+  #724364]

 Contributors:
-  Lionel Landwerlin, Florian Müllner, Jasper St. Pierre, Rico Tzschichholz
-
-3.11.1
-======
-* Don't require at least one output device to be connected [Giovanni; #709009]
-* Name the guard window [Andrew; #710346]
-* Use new UPower API [Bastien]
-* Expose min-backlight-step [Asad; #710380]
-* Don't focus the no-focus-window for globally active windows [Jasper; #710296]
-* Misc. fixes and cleanups [Jasper, Rico, Olav, Magdalen; #709776]
-
-Contributors:
-  Magdalen Berns, Giovanni Campagna, Asad Mehmood, Bastien Nocera,
-  Jasper St. Pierre, Rico Tzschichholz, Olav Vitters, Andrew Walton
+  Robert Ancell, Giovanni Campagna, Adel Gadllah, Ryan Lortie, Florian Müllner,
+  Jasper St. Pierre

 Translations:
-  Reinout van Schouwen [nl]
+  Shankar Prasad [kn], Khaled Hosny [ar]
+
+3.10.3
+======
+* xrandr: Use "hotplug_mode_update" property [Marc-André; #711216]
+* Don't focus the no-focus-window for globally active windows [Jasper; #710296]
+* Fix window group paint volume [Owen; #719669]
+* Fix checks for KeyPress/ButtonPress [Jasper; #720545]
+* Fix problems with focus tracking [Owen; #720558]
+* Don't leave focus on windows that are being unmanaged [Owen; #711618]
+* Reduce server grabs [Daniel; #721345, #721709]
+
+Contributors:
+  Daniel Drake, Marc-André Lureau, Jasper St. Pierre, Owen W. Taylor
+
+Translations:
+  甘露(Gan  Lu) [zh_CN]
+
+3.10.2
+======
+* Fix resize operations using mouse-button-modifier [Lionel; #710251]
+
+Contributors:
+  Lionel Landwerlin
+
+Translations:
+  Efstathios Iosifidis [el], Reinout van Schouwen [nl]
+
+3.10.1.1
+========
+* Don't assert that at least one output is connected [Giovanni; #709009]
+
+Contributors:
+  Giovanni Campagna

 3.10.1
 ======
--- a/configure.ac
+++ b/configure.ac
@ -1,9 +1,8 @@
 AC_PREREQ(2.50)
-AC_CONFIG_MACRO_DIR([m4])

 m4_define([mutter_major_version], [3])
-m4_define([mutter_minor_version], [11])
-m4_define([mutter_micro_version], [2])
+m4_define([mutter_minor_version], [10])
+m4_define([mutter_micro_version], [4])

 m4_define([mutter_version],
          [mutter_major_version.mutter_minor_version.mutter_micro_version])
@ -77,7 +76,7 @@ MUTTER_PC_MODULES="
   xcomposite >= 0.2 xfixes xrender xdamage xi >= 1.6.0
   $CLUTTER_PACKAGE >= 1.15.90
   cogl-1.0 >= 1.15.6
-   upower-glib >= 0.99.0
+   upower-glib > 0.9.11
   gnome-desktop-3.0
 "

--- a/doc/reference/Makefile.am
+++ b/doc/reference/Makefile.am
@ -49,8 +49,8 @@ FIXXREF_OPTIONS=
 # Used for dependencies. The docs will be rebuilt if any of these change.
 # e.g. HFILE_GLOB=$(top_srcdir)/gtk/*.h
 # e.g. CFILE_GLOB=$(top_srcdir)/gtk/*.c
-HFILE_GLOB=$(top_srcdir)/src/*/*.h
-CFILE_GLOB=$(top_srcdir)/src/*/*.c
+HFILE_GLOB=$(top_srcdir)/src/*.h
+CFILE_GLOB=$(top_srcdir)/src/*.c

 # Extra header to include when scanning, which are not under DOC_SOURCE_DIR
 # e.g. EXTRA_HFILES=$(top_srcdir}/contrib/extra.h
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@ -96,6 +96,8 @@ meta_compositor_hide_window
 meta_compositor_switch_workspace
 meta_compositor_maximize_window
 meta_compositor_unmaximize_window
+meta_compositor_window_mapped
+meta_compositor_window_unmapped
 meta_compositor_sync_window_geometry
 meta_compositor_set_updates_frozen
 meta_compositor_queue_frame_drawn
@ -205,6 +207,7 @@ meta_key_binding_get_modifiers
 meta_key_binding_get_mask
 meta_key_binding_is_builtin
 meta_keybindings_set_custom_handler
+meta_keybindings_switch_window
 meta_screen_ungrab_all_keys
 meta_screen_grab_all_keys
 </SECTION>
@ -386,23 +389,6 @@ MetaWindowActorPrivate
 meta_window_actor_get_type
 </SECTION>

-<SECTION>
-<FILE>meta-cullable</FILE>
-<TITLE>MetaCullable</TITLE>
-MetaCullable
-MetaCullableInterface
-meta_cullable_cull_out
-meta_cullable_reset_culling
-meta_cullable_cull_out_children
-meta_cullable_reset_culling_children
-<SUBSECTION Standard>
-META_TYPE_CULLABLE
-META_CULLABLE
-META_IS_CULLABLE
-META_CULLABLE_GET_IFACE
-meta_cullable_get_type
-</SECTION>
-
 <SECTION>
 <FILE>prefs</FILE>
 MetaPreference
@ -556,10 +542,7 @@ meta_window_is_override_redirect
 meta_window_is_skip_taskbar
 meta_window_get_rect
 meta_window_get_input_rect
-meta_window_get_frame_rect
 meta_window_get_outer_rect
-meta_window_client_rect_to_frame_rect
-meta_window_frame_rect_to_client_rect
 meta_window_get_screen
 meta_window_get_display
 meta_window_get_xwindow
--- a/mutter.doap
+++ b/mutter.doap
@ -21,7 +21,6 @@ environment.</description>
  -->
  <mailing-list rdf:resource="http://mail.gnome.org/mailman/listinfo/gnome-shell-list" />
  <download-page rdf:resource="http://download.gnome.org/sources/mutter/" />
-  <download-page rdf:resource="http://download.gnome.org/sources/mutter-wayland/" />
  <bug-database rdf:resource="http://bugzilla.gnome.org/browse.cgi?product=mutter" />

  <category rdf:resource="http://api.gnome.org/doap-extensions#desktop" />
--- a/po/ar.po
+++ b/po/ar.po
@ -4,14 +4,14 @@
 # Arafat Medini <lumina@silverpen.de>, 2003.
 # Abdulaziz Al-Arfaj <alarfaj0@yahoo.com>, 2004.
 # Djihed Afifi <djihed@gmail.com>, 2006.
-# Khaled Hosny <khaledhosny@eglug.org>, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013.
+# Khaled Hosny <khaledhosny@eglug.org>, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014.
 # Anas Afif Emad <anas.e87@gmail.com>, 2008.
 msgid ""
 msgstr ""
 "Project-Id-Version: metacity.HEAD\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2013-10-07 17:09+0200\n"
-"PO-Revision-Date: 2013-10-07 17:09+0200\n"
+"POT-Creation-Date: 2014-02-06 15:37+0200\n"
+"PO-Revision-Date: 2014-02-06 15:37+0200\n"
 "Last-Translator: Khaled Hosny <khaledhosny@eglug.org>\n"
 "Language-Team: Arabic <doc@arabeyes.org>\n"
 "Language: ar\n"
@ -314,16 +314,16 @@ msgstr "تعذّر إيجاد سِمة! تأكد من وجود %s و احتوا

 #: ../src/core/monitor.c:696
 msgid "Built-in display"
-msgstr ""
+msgstr "شاشة مدمجة"

 #. TRANSLATORS: this is a monitor name (in case we don't know
 #. the vendor), it's Unknown followed by a size in inches,
 #. like 'Unknown 15"'
 #.
 #: ../src/core/monitor.c:724
-#, fuzzy, c-format
+#, c-format
 msgid "Unknown %s"
-msgstr "عنصر مجهول %s"
+msgstr "غير معروفة %s"

 #: ../src/core/mutter.c:40
 #, c-format
@ -503,7 +503,7 @@ msgid "Window manager error: "
 msgstr "خطأ مدير النوافذ: "

 #. first time through
-#: ../src/core/window.c:7515
+#: ../src/core/window.c:7497
 #, c-format
 msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
@ -519,7 +519,7 @@ msgstr ""
 #. * MWM but not WM_NORMAL_HINTS are basically broken. We complain
 #. * about these apps but make them work.
 #.
-#: ../src/core/window.c:8345
+#: ../src/core/window.c:8329
 #, c-format
 msgid ""
 "Window %s sets an MWM hint indicating it isn't resizable, but sets min size "
--- a/po/el.po
+++ b/po/el.po
--- a/po/kn.po
+++ b/po/kn.po
--- a/po/nl.po
+++ b/po/nl.po
@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: mutter\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2013-10-25 00:25+0200\n"
+"POT-Creation-Date: 2013-10-25 00:15+0200\n"
 "PO-Revision-Date: 2013-10-25 00:23+0200\n"
 "Last-Translator: Reinout van Schouwen <reinouts@gnome.org>\n"
 "Language-Team: Dutch <vertaling@vrijschrift.org>\n"
@ -256,12 +256,12 @@ msgstr "_Wachten"
 msgid "_Force Quit"
 msgstr "Ge_forceerd afsluiten"

-#: ../src/core/display.c:421
+#: ../src/core/display.c:422
 #, c-format
 msgid "Missing %s extension required for compositing"
 msgstr "Benodigde extensie ‘%s’ voor ‘compositing’ ontbreekt"

-#: ../src/core/display.c:513
+#: ../src/core/display.c:514
 #, c-format
 msgid "Failed to open X Window System display '%s'\n"
 msgstr "Openen van X Window System display ‘%s’ mislukt\n"
@ -389,12 +389,12 @@ msgstr ""
 msgid "Workspace %d"
 msgstr "Werkblad %d"

-#: ../src/core/screen.c:540
+#: ../src/core/screen.c:537
 #, c-format
 msgid "Screen %d on display '%s' is invalid\n"
 msgstr "Scherm %d op display '%s' is ongeldig\n"

-#: ../src/core/screen.c:556
+#: ../src/core/screen.c:553
 #, c-format
 msgid ""
 "Screen %d on display \"%s\" already has a window manager; try using the --"
@ -403,19 +403,19 @@ msgstr ""
 "Scherm %d op display ‘%s’ heeft al een ‘window manager’; probeer de optie: --"
 "replace te gebruiken om de huidige ‘window manager’ te vervangen.\n"

-#: ../src/core/screen.c:583
+#: ../src/core/screen.c:580
 #, c-format
 msgid ""
 "Could not acquire window manager selection on screen %d display \"%s\"\n"
 msgstr ""
 "Kon ‘window manager’-selectie niet verkrijgen op scherm %d display ‘%s’\n"

-#: ../src/core/screen.c:661
+#: ../src/core/screen.c:658
 #, c-format
 msgid "Screen %d on display \"%s\" already has a window manager\n"
 msgstr "Scherm %d op display ‘%s’ heeft al een ‘window manager’\n"

-#: ../src/core/screen.c:853
+#: ../src/core/screen.c:850
 #, c-format
 msgid "Could not release screen %d on display \"%s\"\n"
 msgstr "Kon scherm %d op display ‘%s’ niet vrijmaken\n"
@ -511,7 +511,7 @@ msgid "Window manager error: "
 msgstr "Fout van vensterbeheer:"

 #. first time through
-#: ../src/core/window.c:7510
+#: ../src/core/window.c:7515
 #, c-format
 msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
@ -527,7 +527,7 @@ msgstr ""
 #. * MWM but not WM_NORMAL_HINTS are basically broken. We complain
 #. * about these apps but make them work.
 #.
-#: ../src/core/window.c:8340
+#: ../src/core/window.c:8345
 #, c-format
 msgid ""
 "Window %s sets an MWM hint indicating it isn't resizable, but sets min size "
@ -683,9 +683,9 @@ msgid ""
 "the focus will not be changed immediately when entering a window, but only "
 "after the pointer stops moving."
 msgstr ""
-"Indien op ‘true’ ingesteld en de aandachtsmodus is ofwel ‘sloppy’ of "
-"‘mouse’, dan zal de aandacht niet direct veranderd worden bij het binnengaan "
-"van een venster, maar slechts wanneer de muispijl stopt met bewegen."
+"Indien op ‘true’ ingesteld en de aandachtsmodus is ofwel ‘sloppy’ of ‘mouse’, "
+"dan zal de aandacht niet direct veranderd worden bij het binnengaan van een "
+"venster, maar slechts wanneer de muispijl stopt met bewegen."

 #: ../src/org.gnome.mutter.gschema.xml.in.h:15
 msgid "Draggable border width"
@ -697,8 +697,8 @@ msgid ""
 "not enough, invisible borders will be added to meet this value."
 msgstr ""
 "Het totaal aantal sleepbare randen. Als de zichtbare randen in het thema "
-"onvoldoende zijn, worden onzichtbare randen toegevoegd om deze waarde te "
-"bereiken."
+"onvoldoende zijn, worden onzichtbare randen toegevoegd om deze waarde "
+"te bereiken."

 #: ../src/org.gnome.mutter.gschema.xml.in.h:17
 msgid "Auto maximize nearly monitor sized windows"
@ -968,8 +968,8 @@ msgid ""
 "GTK custom color specification must have color name and fallback in "
 "parentheses, e.g. gtk:custom(foo,bar); could not parse \"%s\""
 msgstr ""
-"Aangepaste GTK-kleurspecificatie moet een kleurnaam en terugvaloptie hebben "
-"tussen haakjes, dus: gtk:custom(foo,bar); kon ‘%s’ niet verwerken"
+"Aangepaste GTK-kleurspecificatie moet een kleurnaam en terugvaloptie "
+"hebben tussen haakjes, dus: gtk:custom(foo,bar); kon ‘%s’ niet verwerken"

 #: ../src/ui/theme.c:1219
 #, c-format
@ -977,8 +977,8 @@ msgid ""
 "Invalid character '%c' in color_name parameter of gtk:custom, only A-Za-z0-9-"
 "_ are valid"
 msgstr ""
-"Ongeldig teken ‘%c’ in color_name-parameter van gtk:custom, alleen A-Za-z0-9-"
-"_ zijn geldig"
+"Ongeldig teken ‘%c’ in color_name-parameter van gtk:custom, alleen A-Za-z0-9-_ "
+"zijn geldig"

 #: ../src/ui/theme.c:1233
 #, c-format
@ -986,8 +986,8 @@ msgid ""
 "Gtk:custom format is \"gtk:custom(color_name,fallback)\", \"%s\" does not "
 "fit the format"
 msgstr ""
-"Gtk:custom-formaat is ‘gtk:custom(color_name,fallback)’, ‘%s’ voldoet niet "
-"aan dit formaat"
+"Gtk:custom-formaat is ‘gtk:custom(color_name,fallback)’, ‘%s’ voldoet "
+"niet aan dit formaat"

 #: ../src/ui/theme.c:1278
 #, c-format
--- a/po/zh_CN.po
+++ b/po/zh_CN.po
@ -16,7 +16,7 @@ msgstr ""
 "Project-Id-Version: mutter master\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/enter_bug.cgi?"
 "product=mutter&keywords=I18N+L10N&component=general\n"
-"POT-Creation-Date: 2013-12-05 16:15+0000\n"
+"POT-Creation-Date: 2013-12-04 16:17+0000\n"
 "PO-Revision-Date: 2013-11-30 17:50+0800\n"
 "Last-Translator: 甘露(Gan Lu) <rhythm.gan@gmail.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
@ -260,12 +260,12 @@ msgstr "等待(_W)"
 msgid "_Force Quit"
 msgstr "强制退出(_F)"

-#: ../src/core/display.c:415
+#: ../src/core/display.c:422
 #, c-format
 msgid "Missing %s extension required for compositing"
 msgstr "缺少复合效果所需的 %s 扩展"

-#: ../src/core/display.c:507
+#: ../src/core/display.c:514
 #, c-format
 msgid "Failed to open X Window System display '%s'\n"
 msgstr "无法打开 X Window System 显示“%s”\n"
@ -382,12 +382,12 @@ msgstr "在配置数据库中找到的“%s”不是按键组合“%s”的有
 msgid "Workspace %d"
 msgstr "工作区 %d"

-#: ../src/core/screen.c:540
+#: ../src/core/screen.c:537
 #, c-format
 msgid "Screen %d on display '%s' is invalid\n"
 msgstr "显示“%2$s”上的屏幕 %1$d 无效\n"

-#: ../src/core/screen.c:556
+#: ../src/core/screen.c:553
 #, c-format
 msgid ""
 "Screen %d on display \"%s\" already has a window manager; try using the --"
@ -396,18 +396,18 @@ msgstr ""
 "显示“%2$s”上的屏幕 %1$d 已经有一个窗口管理器；请尝试使用 --replace 选项替换当"
 "前的窗口管理器。\n"

-#: ../src/core/screen.c:583
+#: ../src/core/screen.c:580
 #, c-format
 msgid ""
 "Could not acquire window manager selection on screen %d display \"%s\"\n"
 msgstr "无法获得显示“%2$s”上的屏幕 %1$d 的窗口管理器选定项\n"

-#: ../src/core/screen.c:661
+#: ../src/core/screen.c:658
 #, c-format
 msgid "Screen %d on display \"%s\" already has a window manager\n"
 msgstr "在显示“%2$s”上的 %1$d 屏幕已经有一个窗口管理器\n"

-#: ../src/core/screen.c:853
+#: ../src/core/screen.c:850
 #, c-format
 msgid "Could not release screen %d on display \"%s\"\n"
 msgstr "无法释放显示“%2$s”上的屏幕 %1$d\n"
@ -503,7 +503,7 @@ msgid "Window manager error: "
 msgstr "窗口管理器错误："

 #. first time through
-#: ../src/core/window.c:7613
+#: ../src/core/window.c:7515
 #, c-format
 msgid ""
 "Window %s sets SM_CLIENT_ID on itself, instead of on the WM_CLIENT_LEADER "
@ -519,7 +519,7 @@ msgstr ""
 #. * MWM but not WM_NORMAL_HINTS are basically broken. We complain
 #. * about these apps but make them work.
 #.
-#: ../src/core/window.c:8535
+#: ../src/core/window.c:8345
 #, c-format
 msgid ""
 "Window %s sets an MWM hint indicating it isn't resizable, but sets min size "
@ -528,22 +528,22 @@ msgstr ""
 "窗口 %s 设置了一个 MWM 提示，表明它是不可改变大小的，但设置最小尺寸为 %d x "
 "%d，最大尺寸为 %d x %d；这没有任何意义。\n"

-#: ../src/core/window-props.c:350
+#: ../src/core/window-props.c:347
 #, c-format
 msgid "Application set a bogus _NET_WM_PID %lu\n"
 msgstr "应用程序设置一个假的 _NET_WM_PID %lu\n"

-#: ../src/core/window-props.c:466
+#: ../src/core/window-props.c:463
 #, c-format
 msgid "%s (on %s)"
 msgstr "%s (于 %s)"

-#: ../src/core/window-props.c:1549
+#: ../src/core/window-props.c:1546
 #, c-format
 msgid "Invalid WM_TRANSIENT_FOR window 0x%lx specified for %s.\n"
 msgstr "为 %2$s 指定了无效的 WM_TRANSIENT_FOR 窗口 0x%1$lx。\n"

-#: ../src/core/window-props.c:1560
+#: ../src/core/window-props.c:1557
 #, c-format
 msgid "WM_TRANSIENT_FOR window 0x%lx for %s would create loop.\n"
 msgstr "为 %2$s 指定的 WM_TRANSIENT_FOR 窗口 0x%1$lx 将导致循环。\n"
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -55,8 +55,7 @@ libmutter_la_SOURCES =				\
 	compositor/meta-background-actor.c	\
 	compositor/meta-background-actor-private.h	\
 	compositor/meta-background-group.c	\
-	compositor/meta-cullable.c		\
-	compositor/meta-cullable.h		\
+	compositor/meta-background-group-private.h	\
 	compositor/meta-module.c		\
 	compositor/meta-module.h		\
 	compositor/meta-plugin.c		\
@ -169,9 +168,7 @@ libmutter_la_SOURCES =				\
 	ui/theme.c				\
 	meta/theme.h				\
 	ui/theme-private.h			\
-	ui/ui.c
-
-nodist_libmutter_la_SOURCES =			\
+	ui/ui.c					\
 	$(mutter_built_sources)

 libmutter_la_LDFLAGS = -no-undefined
@ -252,7 +249,7 @@ Meta-$(api_version).gir: libmutter.la
@META_GIR@_FILES =				\
 	mutter-enum-types.h			\
 	$(libmutterinclude_base_headers)	\
-	$(filter %.c,$(libmutter_la_SOURCES) $(nodist_libmutter_la_SOURCES))
+	$(filter %.c,$(libmutter_la_SOURCES))
@META_GIR@_SCANNERFLAGS = --warn-all --warn-error

 endif
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@ -17,6 +17,8 @@ struct _MetaCompositor
 {
  MetaDisplay    *display;

+  Atom            atom_x_root_pixmap;
+  Atom            atom_net_wm_window_opacity;
  guint           repaint_func_id;

  ClutterActor   *shadow_src;
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@ -42,6 +42,15 @@
 * the call, so it may be necessary to readjust the display based on the
 * old_rect to start the animation.
 *
+ * meta_compositor_window_mapped() and meta_compositor_window_unmapped() are
+ * notifications when the toplevel window (frame or client window) is mapped or
+ * unmapped. That is, when the result of meta_window_toplevel_is_mapped()
+ * changes. The main use of this is to drop resources when a window is unmapped.
+ * A window will always be mapped before meta_compositor_show_window()
+ * is called and will not be unmapped until after meta_compositor_hide_window()
+ * is called. If the live_hidden_windows preference is set, windows will never
+ * be unmapped.
+ *
 * # Containers #
 *
 * There's two containers in the stage that are used to place window actors, here
@ -166,6 +175,31 @@ process_damage (MetaCompositor     *compositor,
  meta_window_actor_process_damage (window_actor, event);
 }

+static void
+process_property_notify (MetaCompositor	*compositor,
+                         XPropertyEvent *event,
+                         MetaWindow     *window)
+{
+  MetaWindowActor *window_actor;
+
+  if (window == NULL)
+    return;
+
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  if (window_actor == NULL)
+    return;
+
+  /* Check for the opacity changing */
+  if (event->atom == compositor->atom_net_wm_window_opacity)
+    {
+      meta_window_actor_update_opacity (window_actor);
+      DEBUG_TRACE ("process_property_notify: net_wm_window_opacity\n");
+      return;
+    }
+
+  DEBUG_TRACE ("process_property_notify: unknown\n");
+}
+
 static Window
 get_output_window (MetaScreen *screen)
 {
@ -651,6 +685,15 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
  clutter_actor_add_child (info->stage, info->window_group);
  clutter_actor_add_child (info->stage, info->top_window_group);

+  info->plugin_mgr = meta_plugin_manager_new (screen);
+
+  /*
+   * Delay the creation of the overlay window as long as we can, to avoid
+   * blanking out the screen. This means that during the plugin loading, the
+   * overlay window is not accessible; if the plugin needs to access it
+   * directly, it should hook into the "show" signal on stage, and do
+   * its stuff there.
+   */
  info->output = get_output_window (screen);
  XReparentWindow (xdisplay, xwin, info->output, 0, 0);

@ -671,8 +714,6 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
      info->pending_input_region = None;
    }

-  info->plugin_mgr = meta_plugin_manager_new (screen);
-
  /* Map overlay window before redirecting windows offscreen so we catch their
   * contents until we show the stage.
   */
@ -715,7 +756,7 @@ meta_shape_cow_for_window (MetaScreen *screen,
      int width, height;
      MetaRectangle rect;

-      meta_window_get_frame_rect (metaWindow, &rect);
+      meta_window_get_outer_rect (metaWindow, &rect);

      window_bounds.x = rect.x;
      window_bounds.y = rect.y;
@ -843,18 +884,6 @@ meta_compositor_window_shape_changed (MetaCompositor *compositor,
  meta_window_actor_update_shape (window_actor);
 }

-void
-meta_compositor_window_opacity_changed (MetaCompositor *compositor,
-                                        MetaWindow     *window)
-{
-  MetaWindowActor *window_actor;
-  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
-  if (!window_actor)
-    return;
-
-  meta_window_actor_update_opacity (window_actor);
-}
-
 /* Clutter makes the assumption that there is only one X window
 * per stage, which is a valid assumption to make for a generic
 * application toolkit. As such, it will ignore any events sent
@ -961,19 +990,28 @@ meta_compositor_process_event (MetaCompositor *compositor,
 	}
    }

-  if (event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
+  switch (event->type)
    {
-      /* Core code doesn't handle damage events, so we need to extract the MetaWindow
-       * ourselves
-       */
-      if (window == NULL)
-        {
-          Window xwin = ((XDamageNotifyEvent *) event)->drawable;
-          window = meta_display_lookup_x_window (compositor->display, xwin);
-        }
+    case PropertyNotify:
+      process_property_notify (compositor, (XPropertyEvent *) event, window);
+      break;

-      DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
-      process_damage (compositor, (XDamageNotifyEvent *) event, window);
+    default:
+      if (event->type == meta_display_get_damage_event_base (compositor->display) + XDamageNotify)
+        {
+          /* Core code doesn't handle damage events, so we need to extract the MetaWindow
+           * ourselves
+           */
+          if (window == NULL)
+            {
+              Window xwin = ((XDamageNotifyEvent *) event)->drawable;
+              window = meta_display_lookup_x_window (compositor->display, xwin);
+            }
+
+	  DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
+          process_damage (compositor, (XDamageNotifyEvent *) event, window);
+        }
+      break;
    }

  /* Clutter needs to know about MapNotify events otherwise it will
@ -1273,6 +1311,30 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
  sync_actor_stacking (info);
 }

+void
+meta_compositor_window_mapped (MetaCompositor *compositor,
+                               MetaWindow     *window)
+{
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  DEBUG_TRACE ("meta_compositor_window_mapped\n");
+  if (!window_actor)
+    return;
+
+  meta_window_actor_mapped (window_actor);
+}
+
+void
+meta_compositor_window_unmapped (MetaCompositor *compositor,
+                                 MetaWindow     *window)
+{
+  MetaWindowActor *window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  DEBUG_TRACE ("meta_compositor_window_unmapped\n");
+  if (!window_actor)
+    return;
+
+  meta_window_actor_unmapped (window_actor);
+}
+
 void
 meta_compositor_sync_window_geometry (MetaCompositor *compositor,
 				      MetaWindow *window,
@ -1453,7 +1515,13 @@ on_shadow_factory_changed (MetaShadowFactory *factory,
 MetaCompositor *
 meta_compositor_new (MetaDisplay *display)
 {
+  char *atom_names[] = {
+    "_XROOTPMAP_ID",
+    "_NET_WM_WINDOW_OPACITY",
+  };
+  Atom                   atoms[G_N_ELEMENTS(atom_names)];
  MetaCompositor        *compositor;
+  Display               *xdisplay = meta_display_get_xdisplay (display);

  if (!composite_at_least_version (display, 0, 3))
    return NULL;
@ -1465,11 +1533,18 @@ meta_compositor_new (MetaDisplay *display)
  if (g_getenv("META_DISABLE_MIPMAPS"))
    compositor->no_mipmaps = TRUE;

+  meta_verbose ("Creating %d atoms\n", (int) G_N_ELEMENTS (atom_names));
+  XInternAtoms (xdisplay, atom_names, G_N_ELEMENTS (atom_names),
+                False, atoms);
+
  g_signal_connect (meta_shadow_factory_get_default (),
                    "changed",
                    G_CALLBACK (on_shadow_factory_changed),
                    compositor);

+  compositor->atom_x_root_pixmap = atoms[0];
+  compositor->atom_net_wm_window_opacity = atoms[1];
+
  compositor->repaint_func_id = clutter_threads_add_repaint_func (meta_repaint_func,
                                                                  compositor,
                                                                  NULL);
--- a/src/compositor/meta-background-actor-private.h
+++ b/src/compositor/meta-background-actor-private.h
@ -6,6 +6,9 @@
 #include <meta/screen.h>
 #include <meta/meta-background-actor.h>

+void meta_background_actor_set_clip_region  (MetaBackgroundActor *self,
+                                             cairo_region_t      *clip_region);
+
 cairo_region_t *meta_background_actor_get_clip_region (MetaBackgroundActor *self);

 #endif /* META_BACKGROUND_ACTOR_PRIVATE_H */
--- a/src/compositor/meta-background-actor.c
+++ b/src/compositor/meta-background-actor.c
@ -41,35 +41,20 @@
 #include <meta/errors.h>
 #include <meta/meta-background.h>
 #include "meta-background-actor-private.h"
-#include "meta-cullable.h"

 struct _MetaBackgroundActorPrivate
 {
  cairo_region_t *clip_region;
 };

-static void cullable_iface_init (MetaCullableInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
-
-static void
-set_clip_region (MetaBackgroundActor *self,
-                 cairo_region_t      *clip_region)
-{
-  MetaBackgroundActorPrivate *priv = self->priv;
-
-  g_clear_pointer (&priv->clip_region, (GDestroyNotify) cairo_region_destroy);
-  if (clip_region)
-    priv->clip_region = cairo_region_copy (clip_region);
-}
+G_DEFINE_TYPE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR);

 static void
 meta_background_actor_dispose (GObject *object)
 {
  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);

-  set_clip_region (self, NULL);
+  meta_background_actor_set_clip_region (self, NULL);

  G_OBJECT_CLASS (meta_background_actor_parent_class)->dispose (object);
 }
@ -119,6 +104,26 @@ meta_background_actor_get_preferred_height (ClutterActor *actor,
    *natural_height_p = height;
 }

+static gboolean
+meta_background_actor_get_paint_volume (ClutterActor       *actor,
+                                        ClutterPaintVolume *volume)
+{
+  ClutterContent *content;
+  gfloat width, height;
+
+  content = clutter_actor_get_content (actor);
+
+  if (!content)
+    return FALSE;
+
+  clutter_content_get_preferred_size (content, &width, &height);
+
+  clutter_paint_volume_set_width (volume, width);
+  clutter_paint_volume_set_height (volume, height);
+
+  return TRUE;
+}
+
 static void
 meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 {
@ -131,6 +136,7 @@ meta_background_actor_class_init (MetaBackgroundActorClass *klass)

  actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
  actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
+  actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
 }

 static void
@ -160,27 +166,31 @@ meta_background_actor_new (void)
  return CLUTTER_ACTOR (self);
 }

-static void
-meta_background_actor_cull_out (MetaCullable   *cullable,
-                                cairo_region_t *unobscured_region,
-                                cairo_region_t *clip_region)
+/**
+ * meta_background_actor_set_clip_region:
+ * @self: a #MetaBackgroundActor
+ * @clip_region: (allow-none): the area of the actor (in allocate-relative
+ *   coordinates) that is visible.
+ *
+ * Sets the area of the background that is unobscured by overlapping windows.
+ * This is used to optimize and only paint the visible portions.
+ */
+void
+meta_background_actor_set_clip_region (MetaBackgroundActor *self,
+                                       cairo_region_t      *clip_region)
 {
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (cullable);
-  set_clip_region (self, clip_region);
-}
+  MetaBackgroundActorPrivate *priv;

-static void
-meta_background_actor_reset_culling (MetaCullable *cullable)
-{
-  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (cullable);
-  set_clip_region (self, NULL);
-}
+  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));

-static void
-cullable_iface_init (MetaCullableInterface *iface)
-{
-  iface->cull_out = meta_background_actor_cull_out;
-  iface->reset_culling = meta_background_actor_reset_culling;
+  priv = self->priv;
+
+  g_clear_pointer (&priv->clip_region,
+                   (GDestroyNotify)
+                   cairo_region_destroy);
+
+  if (clip_region)
+    priv->clip_region = cairo_region_copy (clip_region);
 }

 /**
--- a/src/compositor/meta-background-group-private.h
+++ b/src/compositor/meta-background-group-private.h
@ -0,0 +1,11 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef META_BACKGROUND_GROUP_PRIVATE_H
+#define META_BACKGROUND_GROUP_PRIVATE_H
+
+#include <meta/screen.h>
+#include <meta/meta-background-group.h>
+
+void meta_background_group_set_clip_region  (MetaBackgroundGroup *self,
+                                             cairo_region_t      *visible_region);
+#endif /* META_BACKGROUND_GROUP_PRIVATE_H */
--- a/src/compositor/meta-background-group.c
+++ b/src/compositor/meta-background-group.c
@ -16,43 +16,87 @@

 #include <config.h>

-#include <meta/meta-background-group.h>
-#include "meta-cullable.h"
+#include "compositor-private.h"
+#include "clutter-utils.h"
+#include "meta-background-actor-private.h"
+#include "meta-background-group-private.h"

-static void cullable_iface_init (MetaCullableInterface *iface);
+G_DEFINE_TYPE (MetaBackgroundGroup, meta_background_group, CLUTTER_TYPE_ACTOR);

-G_DEFINE_TYPE_WITH_CODE (MetaBackgroundGroup, meta_background_group, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+struct _MetaBackgroundGroupPrivate
+{
+  gpointer dummy;
+};
+
+static void
+meta_background_group_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (meta_background_group_parent_class)->dispose (object);
+}
+
+static gboolean
+meta_background_group_get_paint_volume (ClutterActor       *actor,
+                                        ClutterPaintVolume *volume)
+{
+  return clutter_paint_volume_set_from_allocation (volume, actor);
+}

 static void
 meta_background_group_class_init (MetaBackgroundGroupClass *klass)
 {
-}
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);

-static void
-meta_background_group_cull_out (MetaCullable   *cullable,
-                                cairo_region_t *unobscured_region,
-                                cairo_region_t *clip_region)
-{
-  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
-}
+  actor_class->get_paint_volume = meta_background_group_get_paint_volume;
+  object_class->dispose = meta_background_group_dispose;

-static void
-meta_background_group_reset_culling (MetaCullable *cullable)
-{
-  meta_cullable_reset_culling_children (cullable);
-}
-
-static void
-cullable_iface_init (MetaCullableInterface *iface)
-{
-  iface->cull_out = meta_background_group_cull_out;
-  iface->reset_culling = meta_background_group_reset_culling;
+  g_type_class_add_private (klass, sizeof (MetaBackgroundGroupPrivate));
 }

 static void
 meta_background_group_init (MetaBackgroundGroup *self)
 {
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+                                            META_TYPE_BACKGROUND_GROUP,
+                                            MetaBackgroundGroupPrivate);
+}
+
+/**
+ * meta_background_group_set_clip_region:
+ * @self: a #MetaBackgroundGroup
+ * @region: (allow-none): the parts of the background to paint
+ *
+ * Sets the area of the backgrounds that is unobscured by overlapping windows.
+ * This is used to optimize and only paint the visible portions.
+ */
+void
+meta_background_group_set_clip_region (MetaBackgroundGroup *self,
+                                       cairo_region_t      *region)
+{
+  GList *children, *l;
+
+  children = clutter_actor_get_children (CLUTTER_ACTOR (self));
+  for (l = children; l; l = l->next)
+    {
+      ClutterActor *actor = l->data;
+
+      if (META_IS_BACKGROUND_ACTOR (actor))
+        {
+          meta_background_actor_set_clip_region (META_BACKGROUND_ACTOR (actor), region);
+        }
+      else if (META_IS_BACKGROUND_GROUP (actor))
+        {
+          int x, y;
+
+          if (!meta_actor_is_untransformed (actor, &x, &y))
+            continue;
+
+          cairo_region_translate (region, -x, -y);
+          meta_background_group_set_clip_region (META_BACKGROUND_GROUP (actor), region);
+          cairo_region_translate (region, x, y);
+        }
+    }
+  g_list_free (children);
 }

 ClutterActor *
--- a/src/compositor/meta-cullable.c
+++ b/src/compositor/meta-cullable.c
@ -1,191 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * Copyright (C) 2013 Red Hat
- *
- * 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.
- *
- * Written by:
- *     Owen Taylor <otaylor@redhat.com>
- *     Ray Strode <rstrode@redhat.com>
- *     Jasper St. Pierre <jstpierre@mecheye.net>
- */
-
-#include "config.h"
-#include "meta-cullable.h"
-#include "clutter-utils.h"
-
-G_DEFINE_INTERFACE (MetaCullable, meta_cullable, CLUTTER_TYPE_ACTOR);
-
-/**
- * SECTION:meta-cullable
- * @title: MetaCullable
- * @short_description: CPU culling operations for efficient drawing
- *
- * When we are painting a stack of 5-10 large actors, the standard
- * bottom-to-top method of drawing every actor results in a tremendous
- * amount of overdraw. If these actors are painting textures like
- * windows, it 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.
- *
- * #MetaCullable is our solution. The basic technique applied here is to
- * do a pre-pass before painting where we walk each actor from top to bottom
- * and ask each actor to "cull itself out". We pass in a region it can copy
- * to clip its drawing to, and the actor can subtract its fully opaque pixels
- * so that actors underneath know not to draw there as well.
- */
-
-/**
- * meta_cullable_cull_out_children:
- * @cullable: The #MetaCullable
- * @unobscured_region: The unobscured region, as passed into cull_out()
- * @clip_region: The clip region, as passed into cull_out()
- *
- * This is a helper method for actors that want to recurse over their
- * child actors, and cull them out.
- *
- * See #MetaCullable and meta_cullable_cull_out() for more details.
- */
-void
-meta_cullable_cull_out_children (MetaCullable   *cullable,
-                                 cairo_region_t *unobscured_region,
-                                 cairo_region_t *clip_region)
-{
-  ClutterActor *actor = CLUTTER_ACTOR (cullable);
-  ClutterActor *child;
-  ClutterActorIter iter;
-
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_prev (&iter, &child))
-    {
-      int x, y;
-
-      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
-        continue;
-
-      /* If an actor has effects applied, then that can change the area
-       * it paints and the opacity, so we no longer can figure out what
-       * portion of the actor is obscured and what portion of the screen
-       * it obscures, so we skip the actor.
-       *
-       * This has a secondary beneficial effect: if a ClutterOffscreenEffect
-       * is applied to an actor, then our clipped redraws interfere with the
-       * caching of the FBO - even if we only need to draw a small portion
-       * of the window right now, ClutterOffscreenEffect may use other portions
-       * of the FBO later. So, skipping actors with effects applied also
-       * prevents these bugs.
-       *
-       * Theoretically, we should check clutter_actor_get_offscreen_redirect()
-       * as well for the same reason, but omitted for simplicity in the
-       * hopes that no-one will do that.
-       */
-      if (clutter_actor_has_effects (child))
-        continue;
-
-      if (!META_IS_CULLABLE (child))
-        continue;
-
-      if (!meta_actor_is_untransformed (child, &x, &y))
-        continue;
-
-      /* Temporarily move to the coordinate system of the actor */
-      cairo_region_translate (unobscured_region, - x, - y);
-      cairo_region_translate (clip_region, - x, - y);
-
-      meta_cullable_cull_out (META_CULLABLE (child), unobscured_region, clip_region);
-
-      cairo_region_translate (unobscured_region, x, y);
-      cairo_region_translate (clip_region, x, y);
-    }
-}
-
-/**
- * meta_cullable_reset_culling_children:
- * @cullable: The #MetaCullable
- *
- * This is a helper method for actors that want to recurse over their
- * child actors, and cull them out.
- *
- * See #MetaCullable and meta_cullable_reset_culling() for more details.
- */
-void
-meta_cullable_reset_culling_children (MetaCullable *cullable)
-{
-  ClutterActor *actor = CLUTTER_ACTOR (cullable);
-  ClutterActor *child;
-  ClutterActorIter iter;
-
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_next (&iter, &child))
-    {
-      if (!META_IS_CULLABLE (child))
-        continue;
-
-      meta_cullable_reset_culling (META_CULLABLE (child));
-    }
-}
-
-static void
-meta_cullable_default_init (MetaCullableInterface *iface)
-{
-}
-
-/**
- * meta_cullable_cull_out:
- * @cullable: The #MetaCullable
- * @unobscured_region: The unobscured region, in @cullable's space.
- * @clip_region: The clip region, in @cullable's space.
- *
- * When #MetaWindowGroup is painted, we walk over its direct cullable
- * children from top to bottom and ask themselves to "cull out". Cullables
- * can use @unobscured_region and @clip_region to clip their drawing. Actors
- * interested in eliminating overdraw should copy the @clip_region and only
- * paint those parts, as everything else has been obscured by actors above it.
- *
- * Actors that may have fully opaque parts should also subtract out a region
- * that is fully opaque from @unobscured_region and @clip_region.
- *
- * @unobscured_region and @clip_region are extremely similar. The difference
- * is that @clip_region starts off with the stage's clip, if Clutter detects
- * that we're doing a clipped redraw. @unobscured_region, however, starts off
- * with the full stage size, so actors that may want to record what parts of
- * their window are unobscured for e.g. scheduling repaints can do so.
- *
- * Actors that have children can also use the meta_cullable_cull_out_children()
- * helper method to do a simple cull across all their children.
- */
-void
-meta_cullable_cull_out (MetaCullable   *cullable,
-                        cairo_region_t *unobscured_region,
-                        cairo_region_t *clip_region)
-{
-  META_CULLABLE_GET_IFACE (cullable)->cull_out (cullable, unobscured_region, clip_region);
-}
-
-/**
- * meta_cullable_reset_culling:
- * @cullable: The #MetaCullable
- *
- * Actors that copied data in their cull_out() implementation can now
- * reset their data, as the paint is now over. Additional paints may be
- * done by #ClutterClone or similar, and they should not be affected by
- * the culling operation.
- */
-void
-meta_cullable_reset_culling (MetaCullable *cullable)
-{
-  META_CULLABLE_GET_IFACE (cullable)->reset_culling (cullable);
-}
--- a/src/compositor/meta-cullable.h
+++ b/src/compositor/meta-cullable.h
@ -1,68 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-/*
- * Copyright (C) 2013 Red Hat
- *
- * 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.
- *
- * Written by:
- *     Owen Taylor <otaylor@redhat.com>
- *     Ray Strode <rstrode@redhat.com>
- *     Jasper St. Pierre <jstpierre@mecheye.net>
- */
-
-#ifndef __META_CULLABLE_H__
-#define __META_CULLABLE_H__
-
-#include <clutter/clutter.h>
-
-G_BEGIN_DECLS
-
-#define META_TYPE_CULLABLE             (meta_cullable_get_type ())
-#define META_CULLABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_CULLABLE, MetaCullable))
-#define META_IS_CULLABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_CULLABLE))
-#define META_CULLABLE_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj),  META_TYPE_CULLABLE, MetaCullableInterface))
-
-typedef struct _MetaCullable MetaCullable;
-typedef struct _MetaCullableInterface MetaCullableInterface;
-
-struct _MetaCullableInterface
-{
-  GTypeInterface g_iface;
-
-  void (* cull_out)      (MetaCullable   *cullable,
-                          cairo_region_t *unobscured_region,
-                          cairo_region_t *clip_region);
-  void (* reset_culling) (MetaCullable  *cullable);
-};
-
-GType meta_cullable_get_type (void);
-
-void meta_cullable_cull_out (MetaCullable   *cullable,
-                             cairo_region_t *unobscured_region,
-                             cairo_region_t *clip_region);
-void meta_cullable_reset_culling (MetaCullable *cullable);
-
-/* Utility methods for implementations */
-void meta_cullable_cull_out_children (MetaCullable   *cullable,
-                                      cairo_region_t *unobscured_region,
-                                      cairo_region_t *clip_region);
-void meta_cullable_reset_culling_children (MetaCullable *cullable);
-
-G_END_DECLS
-
-#endif /* __META_CULLABLE_H__ */
-
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@ -72,7 +72,6 @@ struct _MetaShapedTexturePrivate

  cairo_region_t *clip_region;
  cairo_region_t *opaque_region;
-  cairo_region_t *input_shape_region;

  guint tex_width, tex_height;

@ -395,60 +394,45 @@ meta_shaped_texture_pick (ClutterActor       *actor,
  MetaShapedTexture *stex = (MetaShapedTexture *) actor;
  MetaShapedTexturePrivate *priv = stex->priv;

-  if (!clutter_actor_should_pick_paint (actor) ||
-      (priv->clip_region && cairo_region_is_empty (priv->clip_region)))
-    return;
-
  /* If there is no region then use the regular pick */
-  if (priv->input_shape_region == NULL)
+  if (priv->mask_texture == NULL)
    CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)->pick (actor, color);
-  else
+  else if (clutter_actor_should_pick_paint (actor))
    {
-      int n_rects;
-      float *rectangles;
-      int i;
+      CoglTexture *paint_tex;
+      ClutterActorBox alloc;
+      guint tex_width, tex_height;
      CoglPipeline *pipeline;
      CoglContext *ctx;
      CoglFramebuffer *fb;
      CoglColor cogl_color;

-      /* Note: We don't bother trying to intersect the pick and clip regions
-       * since needing to copy the region, do the intersection, and probably
-       * increase the number of rectangles seems more likely to have a negative
-       * effect.
-       *
-       * NB: Most of the time when just using rectangles for picking then
-       * picking shouldn't involve any rendering, and minimizing the number of
-       * rectangles has more benefit than reducing the area of the pick
-       * region.
-       */
+      paint_tex = COGL_TEXTURE (priv->texture);

-      n_rects = cairo_region_num_rectangles (priv->input_shape_region);
-      rectangles = g_alloca (sizeof (float) * 4 * n_rects);
+      if (paint_tex == NULL)
+        return;

-      for (i = 0; i < n_rects; i++)
-        {
-          cairo_rectangle_int_t rect;
-          int pos = i * 4;
+      tex_width = cogl_texture_get_width (paint_tex);
+      tex_height = cogl_texture_get_height (paint_tex);

-          cairo_region_get_rectangle (priv->input_shape_region, i, &rect);
-
-          rectangles[pos] = rect.x;
-          rectangles[pos + 1] = rect.y;
-          rectangles[pos + 2] = rect.x + rect.width;
-          rectangles[pos + 3] = rect.y + rect.height;
-        }
+      if (tex_width == 0 || tex_height == 0) /* no contents yet */
+        return;

      ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
      fb = cogl_get_draw_framebuffer ();

      cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);

-      pipeline = cogl_pipeline_new (ctx);
+      pipeline = get_masked_pipeline (ctx);
+      cogl_pipeline_set_layer_texture (pipeline, 1, priv->mask_texture);
      cogl_pipeline_set_color (pipeline, &cogl_color);

-      cogl_framebuffer_draw_rectangles (fb, pipeline,
-                                        rectangles, n_rects);
+      clutter_actor_get_allocation_box (actor, &alloc);
+
+      cogl_framebuffer_draw_rectangle (fb, pipeline,
+                                       0, 0,
+                                       alloc.x2 - alloc.x1,
+                                       alloc.y2 - alloc.y1);
      cogl_object_unref (pipeline);
    }
 }
@ -707,41 +691,6 @@ meta_shaped_texture_get_texture (MetaShapedTexture *stex)
  return COGL_TEXTURE (stex->priv->texture);
 }

-/**
- * meta_shaped_texture_set_input_shape_region:
- * @stex: a #MetaShapedTexture
- * @shape_region: the region of the texture that should respond to
- *    input.
- *
- * Determines what region of the texture should accept input. For
- * X based windows this is defined by the ShapeInput region of the
- * window.
- */
-void
-meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                            cairo_region_t    *shape_region)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  if (priv->input_shape_region != NULL)
-    {
-      cairo_region_destroy (priv->input_shape_region);
-      priv->input_shape_region = NULL;
-    }
-
-  if (shape_region != NULL)
-    {
-      cairo_region_reference (shape_region);
-      priv->input_shape_region = shape_region;
-    }
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-}
-
 /**
 * meta_shaped_texture_set_clip_region:
 * @stex: a #MetaShapedTexture
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@ -55,6 +55,14 @@ void     meta_window_actor_set_updates_frozen  (MetaWindowActor *self,
 void     meta_window_actor_queue_frame_drawn   (MetaWindowActor *self,
                                                gboolean         no_delay_frame);

+cairo_region_t *meta_window_actor_get_obscured_region (MetaWindowActor *self);
+
+void meta_window_actor_set_clip_region         (MetaWindowActor *self,
+                                                cairo_region_t  *clip_region);
+void meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
+                                                cairo_region_t  *beneath_region);
+void meta_window_actor_reset_clip_regions      (MetaWindowActor *self);
+
 void meta_window_actor_set_unobscured_region      (MetaWindowActor *self,
                                                   cairo_region_t  *unobscured_region);

--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@ -32,7 +32,6 @@
 #include "meta-texture-rectangle.h"
 #include "region-utils.h"
 #include "monitor-private.h"
-#include "meta-cullable.h"

 enum {
  POSITION_CHANGED,
@ -46,6 +45,7 @@ static guint signals[LAST_SIGNAL] = {0};
 struct _MetaWindowActorPrivate
 {
  MetaWindow       *window;
+  Window            xwindow;
  MetaScreen       *screen;

  ClutterActor     *actor;
@ -68,10 +68,10 @@ struct _MetaWindowActorPrivate

  Damage            damage;

+  guint8            opacity;
+
  /* A region that matches the shape of the window, including frame bounds */
  cairo_region_t   *shape_region;
-  /* If the window has an input shape, a region that matches the shape */
-  cairo_region_t   *input_region;
  /* The opaque region, from _NET_WM_OPAQUE_REGION, intersected with
   * the shape region. */
  cairo_region_t   *opaque_region;
@ -109,6 +109,7 @@ struct _MetaWindowActorPrivate
  GList            *frames;

  guint		    visible                : 1;
+  guint		    mapped                 : 1;
  guint		    argb32                 : 1;
  guint		    disposed               : 1;
  guint             redecorating           : 1;
@ -151,6 +152,8 @@ struct _FrameData
 enum
 {
  PROP_META_WINDOW = 1,
+  PROP_META_SCREEN,
+  PROP_X_WINDOW,
  PROP_NO_SHADOW,
  PROP_SHADOW_CLASS
 };
@ -186,10 +189,7 @@ static void do_send_frame_timings (MetaWindowActor  *self,
                                   gint             refresh_interval,
                                   gint64           presentation_time);

-static void cullable_iface_init (MetaCullableInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (MetaWindowActor, meta_window_actor, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+G_DEFINE_TYPE (MetaWindowActor, meta_window_actor, CLUTTER_TYPE_ACTOR);

 static void
 frame_data_free (FrameData *frame)
@ -219,12 +219,33 @@ meta_window_actor_class_init (MetaWindowActorClass *klass)
                               "MetaWindow",
                               "The displayed MetaWindow",
                               META_TYPE_WINDOW,
-                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT);

  g_object_class_install_property (object_class,
                                   PROP_META_WINDOW,
                                   pspec);

+  pspec = g_param_spec_pointer ("meta-screen",
+				"MetaScreen",
+				"MetaScreen",
+				G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+  g_object_class_install_property (object_class,
+                                   PROP_META_SCREEN,
+                                   pspec);
+
+  pspec = g_param_spec_ulong ("x-window",
+			      "Window",
+			      "Window",
+			      0,
+			      G_MAXULONG,
+			      0,
+			      G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+  g_object_class_install_property (object_class,
+                                   PROP_X_WINDOW,
+                                   pspec);
+
  pspec = g_param_spec_boolean ("no-shadow",
                                "No shadow",
                                "Do not add shaddow to this window",
@ -267,6 +288,7 @@ meta_window_actor_init (MetaWindowActor *self)
  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 						   META_TYPE_WINDOW_ACTOR,
 						   MetaWindowActorPrivate);
+  priv->opacity = 0xff;
  priv->shadow_class = NULL;
 }

@ -277,9 +299,11 @@ window_decorated_notify (MetaWindow *mw,
 {
  MetaWindowActor        *self     = META_WINDOW_ACTOR (data);
  MetaWindowActorPrivate *priv     = self->priv;
+  MetaFrame              *frame    = meta_window_get_frame (mw);
  MetaScreen             *screen   = priv->screen;
  MetaDisplay            *display  = meta_screen_get_display (screen);
  Display                *xdisplay = meta_display_get_xdisplay (display);
+  Window                  new_xwindow;

  /*
   * Basically, we have to reconstruct the the internals of this object
@ -287,6 +311,11 @@ window_decorated_notify (MetaWindow *mw,
   */
  priv->redecorating = TRUE;

+  if (frame)
+    new_xwindow = meta_frame_get_xwindow (frame);
+  else
+    new_xwindow = meta_window_get_xwindow (mw);
+
  meta_window_actor_detach (self);

  /*
@ -301,6 +330,8 @@ window_decorated_notify (MetaWindow *mw,
      priv->damage = None;
    }

+  priv->xwindow = new_xwindow;
+
  /*
   * Recreate the contents.
   */
@ -315,30 +346,18 @@ window_appears_focused_notify (MetaWindow *mw,
  clutter_actor_queue_redraw (CLUTTER_ACTOR (data));
 }

-static gboolean
-is_non_opaque (MetaWindowActor *self)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
-
-  return priv->argb32 || (window->opacity != 0xFF);
-}
-
 static void
 meta_window_actor_constructed (GObject *object)
 {
  MetaWindowActor        *self     = META_WINDOW_ACTOR (object);
  MetaWindowActorPrivate *priv     = self->priv;
-  MetaWindow             *window   = priv->window;
-  MetaScreen             *screen   = meta_window_get_screen (window);
+  MetaScreen             *screen   = priv->screen;
  MetaDisplay            *display  = meta_screen_get_display (screen);
+  Window                  xwindow  = priv->xwindow;
+  MetaWindow             *window   = priv->window;
  Display                *xdisplay = meta_display_get_xdisplay (display);
  XRenderPictFormat      *format;
-  Window                  xwindow;

-  xwindow = meta_window_get_toplevel_xwindow (window);
-
-  priv->screen = screen;
  priv->damage = XDamageCreate (xdisplay, xwindow,
                                XDamageReportBoundingBox);

@ -361,6 +380,19 @@ meta_window_actor_constructed (GObject *object)
       * We will release it in dispose().
       */
      g_object_ref (priv->actor);
+
+      g_signal_connect_object (window, "notify::decorated",
+                               G_CALLBACK (window_decorated_notify), self, 0);
+      g_signal_connect_object (window, "notify::appears-focused",
+                               G_CALLBACK (window_appears_focused_notify), self, 0);
+    }
+  else
+    {
+      /*
+       * This is the case where existing window is gaining/loosing frame.
+       * Just ensure the actor is top most (i.e., above shadow).
+       */
+      clutter_actor_set_child_above_sibling (CLUTTER_ACTOR (self), priv->actor, NULL);
    }

  meta_window_actor_update_opacity (self);
@ -400,7 +432,6 @@ meta_window_actor_dispose (GObject *object)

  g_clear_pointer (&priv->unobscured_region, cairo_region_destroy);
  g_clear_pointer (&priv->shape_region, cairo_region_destroy);
-  g_clear_pointer (&priv->input_region, cairo_region_destroy);
  g_clear_pointer (&priv->opaque_region, cairo_region_destroy);
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);

@ -453,12 +484,17 @@ meta_window_actor_set_property (GObject      *object,
  switch (prop_id)
    {
    case PROP_META_WINDOW:
-      priv->window = g_value_dup_object (value);
-
-      g_signal_connect_object (priv->window, "notify::decorated",
-                               G_CALLBACK (window_decorated_notify), self, 0);
-      g_signal_connect_object (priv->window, "notify::appears-focused",
-                               G_CALLBACK (window_appears_focused_notify), self, 0);
+      {
+        if (priv->window)
+          g_object_unref (priv->window);
+        priv->window = g_value_dup_object (value);
+      }
+      break;
+    case PROP_META_SCREEN:
+      priv->screen = g_value_get_pointer (value);
+      break;
+    case PROP_X_WINDOW:
+      priv->xwindow = g_value_get_ulong (value);
      break;
    case PROP_NO_SHADOW:
      {
@ -504,6 +540,12 @@ meta_window_actor_get_property (GObject      *object,
    case PROP_META_WINDOW:
      g_value_set_object (value, priv->window);
      break;
+    case PROP_META_SCREEN:
+      g_value_set_pointer (value, priv->screen);
+      break;
+    case PROP_X_WINDOW:
+      g_value_set_ulong (value, priv->xwindow);
+      break;
    case PROP_NO_SHADOW:
      g_value_set_boolean (value, priv->no_shadow);
      break;
@ -601,7 +643,7 @@ clip_shadow_under_window (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;

-  return is_non_opaque (self) && priv->window->frame;
+  return (priv->argb32 || priv->opacity != 0xff) && priv->window->frame;
 }

 static void
@ -627,7 +669,6 @@ meta_window_actor_paint (ClutterActor *actor)
      MetaShadowParams params;
      cairo_rectangle_int_t shape_bounds;
      cairo_region_t *clip = priv->shadow_clip;
-      MetaWindow *window = priv->window;

      meta_window_actor_get_shape_bounds (self, &shape_bounds);
      meta_window_actor_get_shadow_params (self, appears_focused, &params);
@ -651,7 +692,7 @@ meta_window_actor_paint (ClutterActor *actor)
                         params.y_offset + shape_bounds.y,
                         shape_bounds.width,
                         shape_bounds.height,
-                         (clutter_actor_get_paint_opacity (actor) * params.opacity * window->opacity) / (255 * 255),
+                         (clutter_actor_get_paint_opacity (actor) * params.opacity * priv->opacity) / (255 * 255),
                         clip,
                         clip_shadow_under_window (self)); /* clip_strictly - not just as an optimization */

@ -693,8 +734,12 @@ meta_window_actor_get_paint_volume (ClutterActor       *actor,
      gdk_rectangle_union (&bounds, &shadow_bounds, &bounds);
    }

-  if (priv->unobscured_region)
-    cairo_region_intersect_rectangle (priv->unobscured_region, &bounds);
+  if (priv->unobscured_region && !clutter_actor_has_mapped_clones (actor))
+    {
+      cairo_rectangle_int_t unobscured_bounds;
+      cairo_region_get_extents (priv->unobscured_region, &unobscured_bounds);
+      gdk_rectangle_intersect (&bounds, &unobscured_bounds, &bounds);
+    }

  origin.x = bounds.x;
  origin.y = bounds.y;
@ -738,10 +783,10 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
    return TRUE;

  /*
-   * Do not add shadows to non-opaque windows; eventually we should generate
-   * a shadow from the input shape for such windows.
+   * Do not add shadows to ARGB windows; eventually we should generate a
+   * shadow from the input shape for such windows.
   */
-  if (is_non_opaque (self))
+  if (priv->argb32 || priv->opacity != 0xff)
    return FALSE;

  /*
@ -772,6 +817,20 @@ meta_window_actor_has_shadow (MetaWindowActor *self)
  return FALSE;
 }

+/**
+ * meta_window_actor_get_x_window: (skip)
+ * @self: a #MetaWindowActor
+ *
+ */
+Window
+meta_window_actor_get_x_window (MetaWindowActor *self)
+{
+  if (!self)
+    return None;
+
+  return self->priv->xwindow;
+}
+
 /**
 * meta_window_actor_get_meta_window:
 * @self: a #MetaWindowActor
@ -939,7 +998,7 @@ meta_window_actor_damage_all (MetaWindowActor *self)

  texture = meta_shaped_texture_get_texture (META_SHAPED_TEXTURE (priv->actor));

-  if (priv->needs_pixmap)
+  if (!priv->mapped || priv->needs_pixmap)
    return;

  redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
@ -1028,7 +1087,7 @@ meta_window_actor_queue_frame_drawn (MetaWindowActor *self,
        {
          queue_send_frame_messages_timeout (self);
        }
-      else
+      else if (priv->mapped && !priv->needs_pixmap)
        {
          const cairo_rectangle_int_t clip = { 0, 0, 1, 1 };
          clutter_actor_queue_redraw_with_clip (priv->actor, &clip);
@ -1060,6 +1119,9 @@ meta_window_actor_queue_create_pixmap (MetaWindowActor *self)

  priv->needs_pixmap = TRUE;

+  if (!priv->mapped)
+    return;
+
  if (is_frozen (self))
    return;

@ -1273,7 +1335,7 @@ meta_window_actor_should_unredirect (MetaWindowActor *self)
  if (meta_window_requested_dont_bypass_compositor (metaWindow))
    return FALSE;

-  if (metaWindow->opacity != 0xFF)
+  if (priv->opacity != 0xff)
    return FALSE;

  if (metaWindow->shape_region != NULL)
@ -1304,7 +1366,7 @@ meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state)
  MetaDisplay *display = meta_window_get_display (metaWindow);

  Display *xdisplay = meta_display_get_xdisplay (display);
-  Window  xwin = meta_window_get_toplevel_xwindow (metaWindow);
+  Window  xwin = meta_window_actor_get_x_window (self);

  if (state)
    {
@ -1337,6 +1399,12 @@ meta_window_actor_destroy (MetaWindowActor *self)
  window_type = meta_window_get_window_type (window);
  meta_window_set_compositor_private (window, NULL);

+  if (priv->send_frame_messages_timer != 0)
+    {
+      g_source_remove (priv->send_frame_messages_timer);
+      priv->send_frame_messages_timer = 0;
+    }
+
  /*
   * We remove the window from internal lookup hashes and thus any other
   * unmap events etc fail
@ -1558,10 +1626,22 @@ meta_window_actor_new (MetaWindow *window)
  MetaCompScreen         *info = meta_screen_get_compositor_data (screen);
  MetaWindowActor        *self;
  MetaWindowActorPrivate *priv;
+  MetaFrame		 *frame;
+  Window		  top_window;
  ClutterActor           *window_group;

+  frame = meta_window_get_frame (window);
+  if (frame)
+    top_window = meta_frame_get_xwindow (frame);
+  else
+    top_window = meta_window_get_xwindow (window);
+
+  meta_verbose ("add window: Meta %p, xwin 0x%x\n", window, (guint)top_window);
+
  self = g_object_new (META_TYPE_WINDOW_ACTOR,
-                       "meta-window", window,
+                       "meta-window",         window,
+                       "x-window",            top_window,
+                       "meta-screen",         screen,
                       NULL);

  priv = self->priv;
@ -1569,6 +1649,10 @@ meta_window_actor_new (MetaWindow *window)
  priv->last_width = -1;
  priv->last_height = -1;

+  priv->mapped = meta_window_toplevel_is_mapped (priv->window);
+  if (priv->mapped)
+    meta_window_actor_queue_create_pixmap (self);
+
  meta_window_actor_set_updates_frozen (self,
                                        meta_window_updates_are_frozen (priv->window));

@ -1602,6 +1686,34 @@ meta_window_actor_new (MetaWindow *window)
  return self;
 }

+void
+meta_window_actor_mapped (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+
+  g_return_if_fail (!priv->mapped);
+
+  priv->mapped = TRUE;
+
+  meta_window_actor_queue_create_pixmap (self);
+}
+
+void
+meta_window_actor_unmapped (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = self->priv;
+
+  g_return_if_fail (priv->mapped);
+
+  priv->mapped = FALSE;
+
+  if (meta_window_actor_effect_in_progress (self))
+    return;
+
+  meta_window_actor_detach (self);
+  priv->needs_pixmap = FALSE;
+}
+
 /**
 * meta_window_actor_get_obscured_region:
 * @self: a #MetaWindowActor
@ -1612,13 +1724,12 @@ meta_window_actor_new (MetaWindow *window)
 * Return value: (transfer none): the area obscured by the window,
 *  %NULL is the same as an empty region.
 */
-static cairo_region_t *
+cairo_region_t *
 meta_window_actor_get_obscured_region (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;

-  if (priv->back_pixmap && window->opacity != 0xFF && !priv->window->shaded)
+  if (priv->back_pixmap && priv->opacity == 0xff && !priv->window->shaded)
    return priv->opaque_region;
  else
    return NULL;
@ -1702,7 +1813,7 @@ meta_window_actor_set_unobscured_region (MetaWindowActor *self,
 * not drawn in this frame.
 * This will be set before painting then unset afterwards.
 */
-static void
+void
 meta_window_actor_set_clip_region (MetaWindowActor *self,
                                   cairo_region_t  *clip_region)
 {
@ -1724,7 +1835,7 @@ meta_window_actor_set_clip_region (MetaWindowActor *self,
 * shadow hid by the window itself. This will be set before painting
 * then unset afterwards.
 */
-static void
+void
 meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
                                           cairo_region_t  *beneath_region)
 {
@ -1744,38 +1855,16 @@ meta_window_actor_set_clip_region_beneath (MetaWindowActor *self,
    }
 }

-static void
-meta_window_actor_cull_out (MetaCullable   *cullable,
-                            cairo_region_t *unobscured_region,
-                            cairo_region_t *clip_region)
+/**
+ * meta_window_actor_reset_clip_regions:
+ * @self: a #MetaWindowActor
+ *
+ * Unsets the regions set by meta_window_actor_set_clip_region() and
+ * meta_window_actor_set_clip_region_beneath()
+ */
+void
+meta_window_actor_reset_clip_regions (MetaWindowActor *self)
 {
-  MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
-  MetaCompScreen *info = meta_screen_get_compositor_data (self->priv->screen);
-
-  /* Don't do any culling for the unredirected window */
-  if (self == info->unredirected_window)
-    return;
-
-  meta_window_actor_set_unobscured_region (self, unobscured_region);
-  meta_window_actor_set_clip_region (self, clip_region);
-
-  if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (self)) == 0xff)
-    {
-      cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (self);
-      if (obscured_region)
-        {
-          cairo_region_subtract (unobscured_region, obscured_region);
-          cairo_region_subtract (clip_region, obscured_region);
-        }
-    }
-
-  meta_window_actor_set_clip_region_beneath (self, clip_region);
-}
-
-static void
-meta_window_actor_reset_culling (MetaCullable *cullable)
-{
-  MetaWindowActor *self = META_WINDOW_ACTOR (cullable);
  MetaWindowActorPrivate *priv = self->priv;

  meta_shaped_texture_set_clip_region (META_SHAPED_TEXTURE (priv->actor),
@ -1783,13 +1872,6 @@ meta_window_actor_reset_culling (MetaCullable *cullable)
  g_clear_pointer (&priv->shadow_clip, cairo_region_destroy);
 }

-static void
-cullable_iface_init (MetaCullableInterface *iface)
-{
-  iface->cull_out = meta_window_actor_cull_out;
-  iface->reset_culling = meta_window_actor_reset_culling;
-}
-
 static void
 check_needs_pixmap (MetaWindowActor *self)
 {
@ -1798,12 +1880,15 @@ check_needs_pixmap (MetaWindowActor *self)
  MetaDisplay         *display  = meta_screen_get_display (screen);
  Display             *xdisplay = meta_display_get_xdisplay (display);
  MetaCompScreen      *info     = meta_screen_get_compositor_data (screen);
-  Window               xwindow  = meta_window_get_toplevel_xwindow (priv->window);
  MetaCompositor      *compositor;
+  Window               xwindow  = priv->xwindow;

  if (!priv->needs_pixmap)
    return;

+  if (!priv->mapped)
+    return;
+
  if (xwindow == meta_screen_get_xroot (screen) ||
      xwindow == clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage)))
    return;
@ -1861,7 +1946,7 @@ check_needs_pixmap (MetaWindowActor *self)
      if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture))))
        g_warning ("NOTE: Not using GLX TFP!\n");

-      /* ::size-changed is supposed to refer to meta_window_get_frame_rect().
+      /* ::size-changed is supposed to refer to meta_window_get_outer_rect().
       * Emitting it here works pretty much OK because a new value of the
       * *input* rect (which is the outer rect with the addition of invisible
       * borders) forces a new pixmap and we get here. In the rare case where
@ -1889,6 +1974,9 @@ check_needs_shadow (MetaWindowActor *self)
  gboolean should_have_shadow;
  gboolean appears_focused;

+  if (!priv->mapped)
+    return;
+
  /* Calling meta_window_actor_has_shadow() here at every pre-paint is cheap
   * and avoids the need to explicitly handle window type changes, which
   * we would do if tried to keep track of when we might be adding or removing
@ -1954,7 +2042,7 @@ meta_window_actor_process_damage (MetaWindowActor    *self,
  if (meta_window_is_fullscreen (priv->window) && g_list_last (info->windows)->data == self && !priv->unredirected)
    {
      MetaRectangle window_rect;
-      meta_window_get_frame_rect (priv->window, &window_rect);
+      meta_window_get_outer_rect (priv->window, &window_rect);

      if (window_rect.x == event->area.x &&
          window_rect.y == event->area.y &&
@ -1992,7 +2080,7 @@ meta_window_actor_process_damage (MetaWindowActor    *self,
      return;
    }

-  if (priv->needs_pixmap)
+  if (!priv->mapped || priv->needs_pixmap)
    return;

  redraw_queued = meta_shaped_texture_update_area (META_SHAPED_TEXTURE (priv->actor),
@ -2178,46 +2266,9 @@ meta_window_actor_update_shape_region (MetaWindowActor       *self,
  priv->shape_region = region;

  g_clear_pointer (&priv->shadow_shape, meta_window_shape_unref);
-
  meta_window_actor_invalidate_shadow (self);
 }

-static void
-meta_window_actor_update_input_region (MetaWindowActor       *self,
-                                       cairo_rectangle_int_t *client_area)
-{
-  MetaWindowActorPrivate *priv = self->priv;
-  MetaShapedTexture *stex = META_SHAPED_TEXTURE (priv->actor);
-  cairo_region_t *region = NULL;
-
-  if (priv->window->frame != NULL && priv->window->input_region != NULL)
-    {
-      region = meta_frame_get_frame_bounds (priv->window->frame);
-
-      cairo_region_subtract_rectangle (region, client_area);
-
-      /* input_region is in client window coordinates, so translate the
-       * input region into that coordinate system and back */
-      cairo_region_translate (region, -client_area->x, -client_area->y);
-      cairo_region_union (region, priv->window->input_region);
-      cairo_region_translate (region, client_area->x, client_area->y);
-    }
-  else if (priv->window->input_region != NULL)
-    {
-      region = cairo_region_reference (priv->window->input_region);
-    }
-  else
-    {
-      /* If we don't have a shape on the server, that means that
-       * we have an implicit shape of one rectangle covering the
-       * entire window. */
-      region = cairo_region_create_rectangle (client_area);
-    }
-
-  meta_shaped_texture_set_input_shape_region (stex, region);
-  cairo_region_destroy (region);
-}
-
 static void
 meta_window_actor_update_opaque_region (MetaWindowActor *self)
 {
@ -2261,6 +2312,9 @@ check_needs_reshape (MetaWindowActor *self)
  MetaFrameBorders borders;
  cairo_rectangle_int_t client_area;

+  if (!priv->mapped)
+    return;
+
  if (!priv->needs_reshape)
    return;

@ -2275,10 +2329,10 @@ check_needs_reshape (MetaWindowActor *self)
    client_area.height = priv->window->rect.height;

  meta_window_actor_update_shape_region (self, &client_area);
-  meta_window_actor_update_input_region (self, &client_area);
  meta_window_actor_update_opaque_region (self);

  priv->needs_reshape = FALSE;
+  meta_window_actor_invalidate_shadow (self);
 }

 void
@ -2523,9 +2577,23 @@ void
 meta_window_actor_update_opacity (MetaWindowActor *self)
 {
  MetaWindowActorPrivate *priv = self->priv;
-  MetaWindow *window = priv->window;
+  MetaDisplay *display = meta_screen_get_display (priv->screen);
+  MetaCompositor *compositor = meta_display_get_compositor (display);
+  Window xwin = meta_window_get_xwindow (priv->window);
+  gulong value;
+  guint8 opacity;

-  clutter_actor_set_opacity (self->priv->actor, window->opacity);
+  if (meta_prop_get_cardinal (display, xwin,
+                              compositor->atom_net_wm_window_opacity,
+                              &value))
+    {
+      opacity = (guint8)((gfloat)value * 255.0 / ((gfloat)0xffffffff));
+    }
+  else
+    opacity = 255;
+
+  self->priv->opacity = opacity;
+  clutter_actor_set_opacity (self->priv->actor, opacity);
 }

 void
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@ -11,8 +11,8 @@
 #include "compositor-private.h"
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "window-private.h"
-#include "meta-cullable.h"
+#include "meta-background-actor-private.h"
+#include "meta-background-group-private.h"

 struct _MetaWindowGroupClass
 {
@ -26,10 +26,7 @@ struct _MetaWindowGroup
  MetaScreen *screen;
 };

-static void cullable_iface_init (MetaCullableInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (MetaWindowGroup, meta_window_group, CLUTTER_TYPE_ACTOR,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init));
+G_DEFINE_TYPE (MetaWindowGroup, meta_window_group, CLUTTER_TYPE_ACTOR);

 /* Help macros to scale from OpenGL <-1,1> coordinates system to
 * window coordinates ranging [0,window-size]. Borrowed from clutter-utils.c
@ -89,27 +86,6 @@ painting_untransformed (MetaWindowGroup *window_group,
  return meta_actor_vertices_are_untransformed (vertices, width, height, x_origin, y_origin);
 }

-static void
-meta_window_group_cull_out (MetaCullable   *cullable,
-                            cairo_region_t *unobscured_region,
-                            cairo_region_t *clip_region)
-{
-  meta_cullable_cull_out_children (cullable, unobscured_region, clip_region);
-}
-
-static void
-meta_window_group_reset_culling (MetaCullable *cullable)
-{
-  meta_cullable_reset_culling_children (cullable);
-}
-
-static void
-cullable_iface_init (MetaCullableInterface *iface)
-{
-  iface->cull_out = meta_window_group_cull_out;
-  iface->reset_culling = meta_window_group_reset_culling;
-}
-
 static void
 meta_window_group_paint (ClutterActor *actor)
 {
@ -118,13 +94,13 @@ meta_window_group_paint (ClutterActor *actor)
  ClutterActorIter iter;
  ClutterActor *child;
  cairo_rectangle_int_t visible_rect, clip_rect;
-  int paint_x_offset, paint_y_offset;
  int paint_x_origin, paint_y_origin;
  int actor_x_origin, actor_y_origin;
+  int paint_x_offset, paint_y_offset;

  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
-  ClutterActor *stage = clutter_actor_get_stage (actor);
  MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);
+  ClutterActor *stage = clutter_actor_get_stage (actor);

  /* Start off by treating all windows as completely unobscured, so damage anywhere
   * in a window queues redraws, but confine it more below. */
@ -158,6 +134,9 @@ meta_window_group_paint (ClutterActor *actor)
      return;
    }

+  paint_x_offset = paint_x_origin - actor_x_origin;
+  paint_y_offset = paint_y_origin - actor_y_origin;
+
  visible_rect.x = visible_rect.y = 0;
  visible_rect.width = clutter_actor_get_width (CLUTTER_ACTOR (stage));
  visible_rect.height = clutter_actor_get_height (CLUTTER_ACTOR (stage));
@ -175,28 +154,127 @@ meta_window_group_paint (ClutterActor *actor)

  clip_region = cairo_region_create_rectangle (&clip_rect);

-  paint_x_offset = paint_x_origin - actor_x_origin;
-  paint_y_offset = paint_y_origin - actor_y_origin;
-  cairo_region_translate (clip_region, -paint_x_offset, -paint_y_offset);
-
  if (info->unredirected_window != NULL)
    {
      cairo_rectangle_int_t unredirected_rect;
      MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);

-      meta_window_get_frame_rect (window, (MetaRectangle *)&unredirected_rect);
+      meta_window_get_outer_rect (window, (MetaRectangle *)&unredirected_rect);
      cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
      cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
    }

-  meta_cullable_cull_out (META_CULLABLE (window_group), unobscured_region, clip_region);
+  /* 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.
+   */
+  clutter_actor_iter_init (&iter, actor);
+  while (clutter_actor_iter_prev (&iter, &child))
+    {
+      if (!CLUTTER_ACTOR_IS_VISIBLE (child))
+        continue;
+
+      if (info->unredirected_window != NULL &&
+          child == CLUTTER_ACTOR (info->unredirected_window))
+        continue;
+
+      /* If an actor has effects applied, then that can change the area
+       * it paints and the opacity, so we no longer can figure out what
+       * portion of the actor is obscured and what portion of the screen
+       * it obscures, so we skip the actor.
+       *
+       * This has a secondary beneficial effect: if a ClutterOffscreenEffect
+       * is applied to an actor, then our clipped redraws interfere with the
+       * caching of the FBO - even if we only need to draw a small portion
+       * of the window right now, ClutterOffscreenEffect may use other portions
+       * of the FBO later. So, skipping actors with effects applied also
+       * prevents these bugs.
+       *
+       * Theoretically, we should check clutter_actor_get_offscreen_redirect()
+       * as well for the same reason, but omitted for simplicity in the
+       * hopes that no-one will do that.
+       */
+      if (clutter_actor_has_effects (child))
+        continue;
+
+      if (META_IS_WINDOW_ACTOR (child))
+        {
+          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
+          int x, y;
+
+          if (!meta_actor_is_untransformed (CLUTTER_ACTOR (window_actor), &x, &y))
+            continue;
+
+          x += paint_x_offset;
+          y += paint_y_offset;
+
+
+          /* Temporarily move to the coordinate system of the actor */
+          cairo_region_translate (unobscured_region, - x, - y);
+          cairo_region_translate (clip_region, - x, - y);
+
+          meta_window_actor_set_unobscured_region (window_actor, unobscured_region);
+          meta_window_actor_set_clip_region (window_actor, clip_region);
+
+          if (clutter_actor_get_paint_opacity (CLUTTER_ACTOR (window_actor)) == 0xff)
+            {
+              cairo_region_t *obscured_region = meta_window_actor_get_obscured_region (window_actor);
+              if (obscured_region)
+                {
+                  cairo_region_subtract (unobscured_region, obscured_region);
+                  cairo_region_subtract (clip_region, obscured_region);
+                }
+            }
+
+          meta_window_actor_set_clip_region_beneath (window_actor, clip_region);
+
+          cairo_region_translate (unobscured_region, x, y);
+          cairo_region_translate (clip_region, x, y);
+        }
+      else if (META_IS_BACKGROUND_ACTOR (child) ||
+               META_IS_BACKGROUND_GROUP (child))
+        {
+          int x, y;
+
+          if (!meta_actor_is_untransformed (child, &x, &y))
+            continue;
+
+          x += paint_x_offset;
+          y += paint_y_offset;
+
+          cairo_region_translate (clip_region, - x, - y);
+
+          if (META_IS_BACKGROUND_GROUP (child))
+            meta_background_group_set_clip_region (META_BACKGROUND_GROUP (child), clip_region);
+          else
+            meta_background_actor_set_clip_region (META_BACKGROUND_ACTOR (child), clip_region);
+
+          cairo_region_translate (clip_region, x, y);
+        }
+    }

  cairo_region_destroy (unobscured_region);
  cairo_region_destroy (clip_region);

  CLUTTER_ACTOR_CLASS (meta_window_group_parent_class)->paint (actor);

-  meta_cullable_reset_culling (META_CULLABLE (window_group));
+  /* Now that we are done painting, unset the visible regions (they will
+   * mess up painting clones of our actors)
+   */
+  clutter_actor_iter_init (&iter, actor);
+  while (clutter_actor_iter_next (&iter, &child))
+    {
+      if (META_IS_WINDOW_ACTOR (child))
+        {
+          MetaWindowActor *window_actor = META_WINDOW_ACTOR (child);
+          meta_window_actor_reset_clip_regions (window_actor);
+        }
+      else if (META_IS_BACKGROUND_ACTOR (child))
+        {
+          MetaBackgroundActor *background_actor = META_BACKGROUND_ACTOR (child);
+          meta_background_actor_set_clip_region (background_actor, NULL);
+        }
+    }
 }

 /* Adapted from clutter_actor_update_default_paint_volume() */
--- a/src/compositor/meta-window-group.h
+++ b/src/compositor/meta-window-group.h
@ -11,9 +11,29 @@
 * MetaWindowGroup:
 *
 * This class is a subclass of ClutterActor with special handling for
- * #MetaCullable when painting children. It uses code similar to
- * meta_cullable_cull_out_children(), but also has additional special
- * cases for the undirected window, and similar.
+ * MetaWindowActor/MetaBackgroundActor/MetaBackgroundGroup when painting
+ * children.
+ *
+ * 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 MetaWindowActor 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 META_TYPE_WINDOW_GROUP            (meta_window_group_get_type ())
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@ -118,6 +118,8 @@ typedef struct
 {
  MetaRectangle        orig;
  MetaRectangle        current;
+  MetaFrameBorders    *borders;
+  gboolean             must_free_borders;
  ActionType           action_type;
  gboolean             is_user_action;

@ -193,6 +195,7 @@ static gboolean constrain_partially_onscreen (MetaWindow         *window,

 static void setup_constraint_info        (ConstraintInfo      *info,
                                          MetaWindow          *window,
+                                          MetaFrameBorders    *orig_borders,
                                          MetaMoveResizeFlags  flags,
                                          int                  resize_gravity,
                                          const MetaRectangle *orig,
@ -201,12 +204,13 @@ static void place_window_if_needed       (MetaWindow     *window,
                                          ConstraintInfo *info);
 static void update_onscreen_requirements (MetaWindow     *window,
                                          ConstraintInfo *info);
-static void extend_by_frame              (MetaWindow     *window,
-                                          MetaRectangle  *rect);
-static void unextend_by_frame            (MetaWindow     *window,
-                                          MetaRectangle  *rect);
-static inline void get_size_limits       (MetaWindow    *window,
-                                          gboolean       include_frame,
+static void extend_by_frame              (MetaRectangle           *rect,
+                                          const MetaFrameBorders  *borders);
+static void unextend_by_frame            (MetaRectangle           *rect,
+                                          const MetaFrameBorders  *borders);
+static inline void get_size_limits       (const MetaWindow        *window,
+                                          const MetaFrameBorders  *borders,
+                                          gboolean include_frame,
                                          MetaRectangle *min_size,
                                          MetaRectangle *max_size);

@ -276,6 +280,7 @@ do_all_constraints (MetaWindow         *window,

 void
 meta_window_constrain (MetaWindow          *window,
+                       MetaFrameBorders    *orig_borders,
                       MetaMoveResizeFlags  flags,
                       int                  resize_gravity,
                       const MetaRectangle *orig,
@ -298,6 +303,7 @@ meta_window_constrain (MetaWindow          *window,

  setup_constraint_info (&info,
                         window, 
+                         orig_borders,
                         flags,
                         resize_gravity,
                         orig,
@ -327,11 +333,19 @@ meta_window_constrain (MetaWindow          *window,
   * if this was a user move or user move-and-resize operation.
   */
  update_onscreen_requirements (window, &info);
+
+  /* Ew, what an ugly way to do things.  Destructors (in a real OOP language,
+   * not gobject-style--gobject would be more pain than it's worth) or
+   * smart pointers would be so much nicer here.  *shrug*
+   */
+  if (info.must_free_borders)
+    g_free (info.borders);
 }

 static void
 setup_constraint_info (ConstraintInfo      *info,
                       MetaWindow          *window,
+                       MetaFrameBorders    *orig_borders,
                       MetaMoveResizeFlags  flags,
                       int                  resize_gravity,
                       const MetaRectangle *orig,
@ -343,6 +357,18 @@ setup_constraint_info (ConstraintInfo      *info,
  info->orig    = *orig;
  info->current = *new;

+  /* Create a fake frame geometry if none really exists */
+  if (orig_borders && !window->fullscreen)
+    {
+      info->borders = orig_borders;
+      info->must_free_borders = FALSE;
+    }
+  else
+    {
+      info->borders = g_new0 (MetaFrameBorders, 1);
+      info->must_free_borders = TRUE;
+    }
+
  if (flags & META_IS_MOVE_ACTION && flags & META_IS_RESIZE_ACTION)
    info->action_type = ACTION_MOVE_AND_RESIZE;
  else if (flags & META_IS_RESIZE_ACTION)
@ -493,12 +519,11 @@ place_window_if_needed(MetaWindow     *window,
      !window->minimized &&
      !window->fullscreen)
    {
-      MetaRectangle placed_rect;
+      MetaRectangle placed_rect = info->orig;
      MetaWorkspace *cur_workspace;
      const MetaMonitorInfo *monitor_info;

-      meta_window_get_frame_rect (window, &placed_rect);
-      meta_window_place (window, info->orig.x, info->orig.y,
+      meta_window_place (window, info->borders, info->orig.x, info->orig.y,
                         &placed_rect.x, &placed_rect.y);
      did_placement = TRUE;

@ -516,7 +541,6 @@ place_window_if_needed(MetaWindow     *window,
        meta_workspace_get_onmonitor_region (cur_workspace, 
                                             monitor_info->number);

-      meta_window_frame_rect_to_client_rect (window, &placed_rect, &placed_rect);

      info->current.x = placed_rect.x;
      info->current.y = placed_rect.y;
@ -562,6 +586,10 @@ place_window_if_needed(MetaWindow     *window,
                (window->maximize_vertically_after_placement ?
                 META_MAXIMIZE_VERTICAL : 0), &info->current);

+          /* maximization may have changed frame geometry */
+          if (!window->fullscreen)
+            meta_frame_calc_borders (window->frame, info->borders);
+
          if (window->fullscreen_after_placement)
            {
              window->saved_rect = info->current;
@ -621,7 +649,7 @@ update_onscreen_requirements (MetaWindow     *window,
  /* The require onscreen/on-single-monitor and titlebar_visible
   * stuff is relative to the outer window, not the inner
   */
-  extend_by_frame (window, &info->current);
+  extend_by_frame (&info->current, info->borders);

  /* Update whether we want future constraint runs to require the
   * window to be on fully onscreen.
@ -654,13 +682,10 @@ update_onscreen_requirements (MetaWindow     *window,
   */
  if (window->frame && window->decorated)
    {
-      MetaFrameBorders borders;
      MetaRectangle titlebar_rect;

-      meta_frame_calc_borders (window->frame, &borders);
-
      titlebar_rect = info->current;
-      titlebar_rect.height = borders.visible.top;
+      titlebar_rect.height = info->borders->visible.top;
      old = window->require_titlebar_visible;
      window->require_titlebar_visible =
        meta_rectangle_overlaps_with_region (info->usable_screen_region,
@ -673,33 +698,39 @@ update_onscreen_requirements (MetaWindow     *window,
    }

  /* Don't forget to restore the position of the window */
-  unextend_by_frame (window, &info->current);
+  unextend_by_frame (&info->current, info->borders);
 }

 static void
-extend_by_frame (MetaWindow    *window,
-                 MetaRectangle *rect)
+extend_by_frame (MetaRectangle           *rect,
+                 const MetaFrameBorders *borders)
 {
-  meta_window_client_rect_to_frame_rect (window, rect, rect);
+  rect->x -= borders->visible.left;
+  rect->y -= borders->visible.top;
+  rect->width  += borders->visible.left + borders->visible.right;
+  rect->height += borders->visible.top + borders->visible.bottom;
 }

 static void
-unextend_by_frame (MetaWindow    *window,
-                   MetaRectangle *rect)
+unextend_by_frame (MetaRectangle           *rect,
+                   const MetaFrameBorders *borders)
 {
-  meta_window_frame_rect_to_client_rect (window, rect, rect);
+  rect->x += borders->visible.left;
+  rect->y += borders->visible.top;
+  rect->width  -= borders->visible.left + borders->visible.right;
+  rect->height -= borders->visible.top + borders->visible.bottom;
 }

 static inline void
-get_size_limits (MetaWindow    *window,
-                 gboolean       include_frame,
+get_size_limits (const MetaWindow        *window,
+                 const MetaFrameBorders *borders,
+                 gboolean                 include_frame,
                 MetaRectangle *min_size,
                 MetaRectangle *max_size)
 {
  /* We pack the results into MetaRectangle structs just for convienience; we
   * don't actually use the position of those rects.
   */
-  min_size->x = min_size->y = max_size->x = max_size->y = 0;
  min_size->width  = window->size_hints.min_width;
  min_size->height = window->size_hints.min_height;
  max_size->width  = window->size_hints.max_width;
@ -707,8 +738,22 @@ get_size_limits (MetaWindow    *window,

  if (include_frame)
    {
-      meta_window_client_rect_to_frame_rect (window, min_size, min_size);
-      meta_window_client_rect_to_frame_rect (window, max_size, max_size);
+      int fw = borders->visible.left + borders->visible.right;
+      int fh = borders->visible.top + borders->visible.bottom;
+
+      min_size->width  += fw;
+      min_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;
    }
 }

@ -720,28 +765,18 @@ constrain_modal_dialog (MetaWindow         *window,
 {
  int x, y;
  MetaWindow *parent = meta_window_get_transient_for (window);
-  MetaRectangle child_rect, parent_rect;
  gboolean constraint_already_satisfied;

  if (!meta_window_is_attached_dialog (window))
    return TRUE;

-  /* We want to center the dialog on the parent, including the decorations
-     for both of them. info->current is in client X window coordinates, so we need
-     to convert them to frame coordinates, apply the centering and then
-     convert back to client.
-  */
-
-  child_rect = info->current;
-  extend_by_frame (window, &child_rect);
-
-  meta_window_get_frame_rect (parent, &parent_rect);
-
-  child_rect.x = parent_rect.x + (parent_rect.width / 2  - child_rect.width / 2);
-  child_rect.y = parent_rect.y + (parent_rect.height / 2 - child_rect.height / 2);
-  unextend_by_frame (window, &child_rect);
-  x = child_rect.x;
-  y = child_rect.y;
+  x = parent->rect.x + (parent->rect.width / 2  - info->current.width / 2);
+  y = parent->rect.y + (parent->rect.height / 2 - info->current.height / 2);
+  if (parent->frame)
+    {
+      x += parent->frame->rect.x;
+      y += parent->frame->rect.y;
+    }

  constraint_already_satisfied = (x == info->current.x) && (y == info->current.y);

@ -806,19 +841,19 @@ constrain_maximization (MetaWindow         *window,
      active_workspace_struts = window->screen->active_workspace->all_struts;

      target_size = info->current;
-      extend_by_frame (window, &target_size);
+      extend_by_frame (&target_size, info->borders);
      meta_rectangle_expand_to_avoiding_struts (&target_size,
                                                &info->entire_monitor,
                                                direction,
                                                active_workspace_struts);
   }
  /* Now make target_size = maximized size of client window */
-  unextend_by_frame (window, &target_size);
+  unextend_by_frame (&target_size, info->borders);

  /* Check min size constraints; max size constraints are ignored for maximized
   * windows, as per bug 327543.
   */
-  get_size_limits (window, FALSE, &min_size, &max_size);
+  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
  hminbad = target_size.width < min_size.width && window->maximized_horizontally;
  vminbad = target_size.height < min_size.height && window->maximized_vertically;
  if (hminbad || vminbad)
@ -872,12 +907,12 @@ constrain_tiling (MetaWindow         *window,
   * use an external function for the actual calculation
   */
  meta_window_get_current_tile_area (window, &target_size);
-  unextend_by_frame (window, &target_size);
+  unextend_by_frame (&target_size, info->borders);

  /* Check min size constraints; max size constraints are ignored as for
   * maximized windows.
   */
-  get_size_limits (window, FALSE, &min_size, &max_size);
+  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
  hminbad = target_size.width < min_size.width;
  vminbad = target_size.height < min_size.height;
  if (hminbad || vminbad)
@ -920,7 +955,7 @@ constrain_fullscreen (MetaWindow         *window,

  monitor = info->entire_monitor;

-  get_size_limits (window, FALSE, &min_size, &max_size);
+  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
  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)
@ -1029,7 +1064,7 @@ constrain_size_limits (MetaWindow         *window,
    return TRUE;

  /* Determine whether constraint is already satisfied; exit if it is */
-  get_size_limits (window, FALSE, &min_size, &max_size);
+  get_size_limits (window, info->borders, FALSE, &min_size, &max_size);
  /* We ignore max-size limits for maximized windows; see #327543 */
  if (window->maximized_horizontally)
    max_size.width = MAX (max_size.width, info->current.width);
@ -1221,8 +1256,8 @@ do_screen_and_monitor_relative_constraints (

  /* Determine whether constraint applies; exit if it doesn't */
  how_far_it_can_be_smushed = info->current;
-  get_size_limits (window, TRUE, &min_size, &max_size);
-  extend_by_frame (window, &info->current);
+  get_size_limits (window, info->borders, TRUE, &min_size, &max_size);
+  extend_by_frame (&info->current, info->borders);

  if (info->action_type != ACTION_MOVE)
    {
@ -1242,7 +1277,7 @@ do_screen_and_monitor_relative_constraints (
                                        &info->current);
  if (exit_early || constraint_satisfied || check_only)
    {
-      unextend_by_frame (window, &info->current);
+      unextend_by_frame (&info->current, info->borders);
      return constraint_satisfied;
    }

@ -1266,7 +1301,7 @@ do_screen_and_monitor_relative_constraints (
                                      info->fixed_directions,
                                      &info->current);

-  unextend_by_frame (window, &info->current);
+  unextend_by_frame (&info->current, info->borders);
  return TRUE;
 }

@ -1355,7 +1390,6 @@ constrain_titlebar_visible (MetaWindow         *window,
      window->type == META_WINDOW_DOCK    ||
      window->fullscreen                  ||
      !window->require_titlebar_visible   ||
-      !window->decorated                  ||
      unconstrained_user_action)
    return TRUE;

@ -1379,11 +1413,8 @@ constrain_titlebar_visible (MetaWindow         *window,
   */
  if (window->frame)
    {
-      MetaFrameBorders borders;
-      meta_frame_calc_borders (window->frame, &borders);
-
-      bottom_amount = info->current.height + borders.visible.bottom;
-      vert_amount_onscreen = borders.visible.top;
+      bottom_amount = info->current.height + info->borders->visible.bottom;
+      vert_amount_onscreen = info->borders->visible.top;
    }
  else
    bottom_amount = vert_amount_offscreen;
@ -1457,11 +1488,8 @@ constrain_partially_onscreen (MetaWindow         *window,
   */
  if (window->frame)
    {
-      MetaFrameBorders borders;
-      meta_frame_calc_borders (window->frame, &borders);
-
-      bottom_amount = info->current.height + borders.visible.bottom;
-      vert_amount_onscreen = borders.visible.top;
+      bottom_amount = info->current.height + info->borders->visible.bottom;
+      vert_amount_onscreen = info->borders->visible.top;
    }
  else
    bottom_amount = vert_amount_offscreen;
--- a/src/core/constraints.h
+++ b/src/core/constraints.h
@ -39,6 +39,7 @@ typedef enum
 } MetaMoveResizeFlags;

 void meta_window_constrain (MetaWindow          *window,
+                            MetaFrameBorders    *orig_borders,
                            MetaMoveResizeFlags  flags,
                            int                  resize_gravity,
                            const MetaRectangle *orig,
--- a/src/core/core.c
+++ b/src/core/core.c
@ -171,7 +171,6 @@ meta_core_queue_frame_resize (Display *xdisplay,
  MetaWindow *window = get_window (xdisplay, frame_xwindow);

  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
-  meta_window_frame_size_changed (window);
 }

 void
@ -280,7 +279,8 @@ meta_core_lower_beneath_grab_window (Display *xdisplay,
    return;

  changes.stack_mode = Below;
-  changes.sibling = meta_window_get_toplevel_xwindow (grab_window);
+  changes.sibling = grab_window->frame ? grab_window->frame->xwindow
+                                       : grab_window->xwindow;

  meta_stack_tracker_record_lower_below (screen->stack_tracker,
                                         xwindow,
@ -469,6 +469,26 @@ meta_core_change_workspace (Display *xdisplay,
                                                                    new_workspace));
 }

+int
+meta_core_get_num_workspaces (Screen  *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_screen_get_n_workspaces (screen);
+}
+
+int
+meta_core_get_active_workspace (Screen *xscreen)
+{
+  MetaScreen *screen;
+
+  screen = meta_screen_for_x_screen (xscreen);
+
+  return meta_workspace_index (screen->active_workspace);
+}
+
 void
 meta_core_show_window_menu (Display *xdisplay,
                            Window   frame_xwindow,
--- a/src/core/core.h
+++ b/src/core/core.h
@ -153,6 +153,8 @@ void meta_core_change_workspace (Display *xdisplay,
                                 Window   frame_xwindow,
                                 int      new_workspace);

+int meta_core_get_num_workspaces (Screen  *xscreen);
+int meta_core_get_active_workspace (Screen *xscreen);
 int meta_core_get_frame_workspace (Display *xdisplay,
                                   Window frame_xwindow);
 const char* meta_core_get_workspace_name_with_index (Display *xdisplay,
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@ -138,6 +138,14 @@ struct _MetaDisplay
   */
  guint allow_terminal_deactivation : 1;

+  /* If true, server->focus_serial refers to us changing the focus; in
+   * this case, we can ignore focus events that have exactly focus_serial,
+   * since we take care to make another request immediately afterwards.
+   * But if focus is being changed by another client, we have to accept
+   * multiple events with the same serial.
+   */
+  guint focused_by_us : 1;
+
  guint static_gravity_works : 1;
  
  /*< private-ish >*/
--- a/src/core/display.c
+++ b/src/core/display.c
@ -51,6 +51,7 @@
 #include <meta/compositor.h>
 #include <meta/compositor-mutter.h>
 #include <X11/Xatom.h>
+#include <X11/cursorfont.h>
 #include "mutter-enum-types.h"
 #include "meta-idle-monitor-private.h"

@ -117,6 +118,12 @@ typedef struct
  guint        ping_timeout_id;
 } MetaPingData;

+typedef struct 
+{
+  MetaDisplay *display;
+  Window xwindow;
+} MetaAutoRaiseData;
+
 typedef struct
 {
  MetaDisplay *display;
@ -918,8 +925,6 @@ meta_display_open (void)

  enable_compositor (the_display);
   
-  meta_display_grab (the_display);
-  
  /* Now manage all existing windows */
  tmp = the_display->screens;
  while (tmp != NULL)
@ -971,8 +976,6 @@ meta_display_open (void)

  meta_idle_monitor_init_dbus ();

-  meta_display_ungrab (the_display);
-
  /* Done opening new display */
  the_display->display_opening = FALSE;

@ -1217,7 +1220,18 @@ meta_display_screen_for_x_screen (MetaDisplay *display,
  return NULL;
 }

-/* Grab/ungrab routines taken from fvwm */
+/* Grab/ungrab routines taken from fvwm.
+ * Calling this function will cause X to ignore all other clients until
+ * you ungrab. This may not be quite as bad as it sounds, yet there is
+ * agreement that avoiding server grabs except when they are clearly needed
+ * is a good thing.
+ *
+ * If you do use such grabs, please clearly explain the necessity for their
+ * usage in a comment. Try to keep their scope extremely limited. In
+ * particular, try to avoid emitting any signals or notifications while
+ * a grab is active (if the signal receiver tries to block on an X request
+ * from another client at this point, you will have a deadlock).
+ */
 void
 meta_display_grab (MetaDisplay *display)
 {
@ -1579,10 +1593,23 @@ reset_ignored_crossing_serials (MetaDisplay *display)
 static gboolean 
 window_raise_with_delay_callback (void *data)
 {
-  MetaWindow *window = data;
+  MetaWindow *window;
+  MetaAutoRaiseData *auto_raise;

-  window->display->autoraise_timeout_id = 0;
-  window->display->autoraise_window = NULL;
+  auto_raise = data;
+
+  meta_topic (META_DEBUG_FOCUS, 
+	      "In autoraise callback for window 0x%lx\n", 
+	      auto_raise->xwindow);
+
+  auto_raise->display->autoraise_timeout_id = 0;
+  auto_raise->display->autoraise_window = NULL;
+
+  window  = meta_display_lookup_x_window (auto_raise->display, 
+					  auto_raise->xwindow);
+  
+  if (window == NULL) 
+    return FALSE;

  /* If we aren't already on top, check whether the pointer is inside
   * the window and raise the window if so.
@ -1591,7 +1618,6 @@ window_raise_with_delay_callback (void *data)
    {
      int x, y, root_x, root_y;
      Window root, child;
-      MetaRectangle frame_rect;
      unsigned int mask;
      gboolean same_screen;
      gboolean point_in_window;
@ -1603,8 +1629,9 @@ window_raise_with_delay_callback (void *data)
 				   &root_x, &root_y, &x, &y, &mask);
      meta_error_trap_pop (window->display);

-      meta_window_get_frame_rect (window, &frame_rect);
-      point_in_window = POINT_IN_RECT (root_x, root_y, frame_rect);
+      point_in_window = 
+        (window->frame && POINT_IN_RECT (root_x, root_y, window->frame->rect)) ||
+        (window->frame == NULL && POINT_IN_RECT (root_x, root_y, window->rect));
      if (same_screen && point_in_window)
 	meta_window_raise (window);
      else
@ -1619,8 +1646,7 @@ window_raise_with_delay_callback (void *data)
 static void
 meta_display_mouse_mode_focus (MetaDisplay *display,
                               MetaWindow  *window,
-                               guint32      timestamp)
-{
+                               guint32      timestamp) {
  if (window->type != META_WINDOW_DESKTOP)
    {
      meta_topic (META_DEBUG_FOCUS,
@ -1659,8 +1685,7 @@ meta_display_mouse_mode_focus (MetaDisplay *display,
 }

 static gboolean
-window_focus_on_pointer_rest_callback (gpointer data)
-{
+window_focus_on_pointer_rest_callback (gpointer data) {
  MetaFocusData *focus_data;
  MetaDisplay *display;
  MetaScreen *screen;
@ -1705,9 +1730,9 @@ window_focus_on_pointer_rest_callback (gpointer data)
    goto out;

  window =
-    meta_stack_get_default_focus_window_at_point (screen->stack,
-                                                  screen->active_workspace,
-                                                  None, root_x, root_y);
+      meta_stack_get_default_focus_window_at_point (screen->stack,
+                                                    screen->active_workspace,
+                                                    None, root_x, root_y);

  if (window == NULL)
    goto out;
@ -1715,7 +1740,7 @@ window_focus_on_pointer_rest_callback (gpointer data)
  timestamp = meta_display_get_current_time_roundtrip (display);
  meta_display_mouse_mode_focus (display, window, timestamp);

- out:
+out:
  display->focus_timeout_id = 0;
  return FALSE;
 }
@ -1724,11 +1749,17 @@ void
 meta_display_queue_autoraise_callback (MetaDisplay *display,
                                       MetaWindow  *window)
 {
+  MetaAutoRaiseData *auto_raise_data;
+
  meta_topic (META_DEBUG_FOCUS, 
              "Queuing an autoraise timeout for %s with delay %d\n", 
              window->desc, 
              meta_prefs_get_auto_raise_delay ());
  
+  auto_raise_data = g_new (MetaAutoRaiseData, 1);
+  auto_raise_data->display = window->display;
+  auto_raise_data->xwindow = window->xwindow;
+  
  if (display->autoraise_timeout_id != 0)
    g_source_remove (display->autoraise_timeout_id);

@ -1736,7 +1767,8 @@ meta_display_queue_autoraise_callback (MetaDisplay *display,
    g_timeout_add_full (G_PRIORITY_DEFAULT,
                        meta_prefs_get_auto_raise_delay (),
                        window_raise_with_delay_callback,
-                        window, NULL);
+                        auto_raise_data,
+                        g_free);
  display->autoraise_window = window;
 }

@ -1865,9 +1897,11 @@ static void
 update_focus_window (MetaDisplay *display,
                     MetaWindow  *window,
                     Window       xwindow,
-                     gulong       serial)
+                     gulong       serial,
+                     gboolean     focused_by_us)
 {
  display->focus_serial = serial;
+  display->focused_by_us = focused_by_us;

  if (display->focus_xwindow == xwindow)
    return;
@ -1978,7 +2012,8 @@ request_xserver_input_focus_change (MetaDisplay *display,
  update_focus_window (display,
                       meta_window,
                       xwindow,
-                       serial);
+                       serial,
+                       TRUE);

  meta_error_trap_pop (display);

@ -2092,28 +2127,23 @@ handle_window_focus_event (MetaDisplay  *display,
  else
    g_return_if_reached ();

-  if (display->server_focus_serial > display->focus_serial)
+  /* If display->focused_by_us, then the focus_serial will be used only
+   * for a focus change we made and have already accounted for.
+   * (See request_xserver_input_focus_change().) Otherwise, we can get
+   * multiple focus events with the same serial.
+   */
+  if (display->server_focus_serial > display->focus_serial ||
+      (!display->focused_by_us &&
+       display->server_focus_serial == display->focus_serial))
    {
      update_focus_window (display,
                           focus_window,
                           focus_window ? focus_window->xwindow : None,
-                           display->server_focus_serial);
+                           display->server_focus_serial,
+                           FALSE);
    }
 }

-static gboolean
-window_has_xwindow (MetaWindow *window,
-                    Window      xwindow)
-{
-  if (window->xwindow == xwindow)
-    return TRUE;
-
-  if (window->frame && window->frame->xwindow == xwindow)
-    return TRUE;
-
-  return FALSE;
-}
-
 /**
 * event_callback:
 * @event: The event that just happened
@ -2167,16 +2197,18 @@ event_callback (XEvent   *event,
  display->current_time = event_get_time (display, event);
  display->monitor_cache_invalidated = TRUE;

-  if (event->xany.serial > display->focus_serial &&
+  if (display->focused_by_us &&
+      event->xany.serial > display->focus_serial &&
      display->focus_window &&
-      !window_has_xwindow (display->focus_window, display->server_focus_window))
+      display->focus_window->xwindow != display->server_focus_window)
    {
      meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                  display->focus_window->desc);
      update_focus_window (display,
                           meta_display_lookup_x_window (display, display->server_focus_window),
                           display->server_focus_window,
-                           display->server_focus_serial);
+                           display->server_focus_serial,
+                           FALSE);
    }

  screen = meta_display_screen_for_root (display, event->xany.window);
@ -2424,15 +2456,15 @@ event_callback (XEvent   *event,
                    {
                      gboolean north, south;
                      gboolean west, east;
-                      MetaRectangle frame_rect;
+                      int root_x, root_y;
                      MetaGrabOp op;

-                      meta_window_get_frame_rect (window, &frame_rect);
+                      meta_window_get_position (window, &root_x, &root_y);

-                      west = device_event->root_x <  (frame_rect.x + 1 * frame_rect.width  / 3);
-                      east = device_event->root_x >  (frame_rect.x + 2 * frame_rect.width  / 3);
-                      north = device_event->root_y < (frame_rect.y + 1 * frame_rect.height / 3);
-                      south = device_event->root_y > (frame_rect.y + 2 * frame_rect.height / 3);
+                      west = device_event->root_x <  (root_x + 1 * window->rect.width  / 3);
+                      east = device_event->root_x >  (root_x + 2 * window->rect.width  / 3);
+                      north = device_event->root_y < (root_y + 1 * window->rect.height / 3);
+                      south = device_event->root_y > (root_y + 2 * window->rect.height / 3);

                      if (north && west)
                        op = META_GRAB_OP_RESIZING_NW;
@ -2762,14 +2794,14 @@ event_callback (XEvent   *event,
              && meta_display_screen_for_root (display, event->xmap.event))
            {
              window = meta_window_new (display, event->xmap.window,
-                                        FALSE);
+                                        FALSE, META_COMP_EFFECT_CREATE);
            }
          break;
        case MapRequest:
          if (window == NULL)
            {
              window = meta_window_new (display, event->xmaprequest.window,
-                                        FALSE);
+                                        FALSE, META_COMP_EFFECT_CREATE);
            }
          /* if frame was receiver it's some malicious send event or something */
          else if (!frame_was_receiver && window)        
@ -3847,6 +3879,85 @@ meta_display_xwindow_is_a_no_focus_window (MetaDisplay *display,
  return is_a_no_focus_window;
 }

+Cursor
+meta_display_create_x_cursor (MetaDisplay *display,
+                              MetaCursor cursor)
+{
+  Cursor xcursor;
+  guint glyph = XC_num_glyphs;
+  const char *name = NULL;
+
+  switch (cursor)
+    {
+    case META_CURSOR_DEFAULT:
+      glyph = XC_left_ptr;
+      break;
+    case META_CURSOR_NORTH_RESIZE:
+      glyph = XC_top_side;
+      break;
+    case META_CURSOR_SOUTH_RESIZE:
+      glyph = XC_bottom_side;
+      break;
+    case META_CURSOR_WEST_RESIZE:
+      glyph = XC_left_side;
+      break;
+    case META_CURSOR_EAST_RESIZE:
+      glyph = XC_right_side;
+      break;
+    case META_CURSOR_SE_RESIZE:
+      glyph = XC_bottom_right_corner;
+      break;
+    case META_CURSOR_SW_RESIZE:
+      glyph = XC_bottom_left_corner;
+      break;
+    case META_CURSOR_NE_RESIZE:
+      glyph = XC_top_right_corner;
+      break;
+    case META_CURSOR_NW_RESIZE:
+      glyph = XC_top_left_corner;
+      break;
+    case META_CURSOR_MOVE_OR_RESIZE_WINDOW:
+      glyph = XC_fleur;
+      break;
+    case META_CURSOR_BUSY:
+      glyph = XC_watch;
+      break;
+    case META_CURSOR_DND_IN_DRAG:
+      name = "dnd-none";
+      break;
+    case META_CURSOR_DND_MOVE:
+      name = "dnd-move";
+      break;
+    case META_CURSOR_DND_COPY:
+      name = "dnd-copy";
+      break;
+    case META_CURSOR_DND_UNSUPPORTED_TARGET:
+      name = "dnd-none";
+      break;
+    case META_CURSOR_POINTING_HAND:
+      glyph = XC_hand2;
+      break;
+    case META_CURSOR_CROSSHAIR:
+      glyph = XC_crosshair;
+      break;
+    case META_CURSOR_IBEAM:
+      glyph = XC_xterm;
+      break;
+
+    default:
+      g_assert_not_reached ();
+      glyph = 0; /* silence compiler */
+      break;
+    }
+
+  if (name != NULL)
+    xcursor = XcursorLibraryLoadCursor (display->xdisplay, name);
+  else
+    xcursor = XCreateFontCursor (display->xdisplay, glyph);
+
+  return xcursor;
+}
+
 static Cursor
 xcursor_for_op (MetaDisplay *display,
                MetaGrabOp   op)
@ -4008,7 +4119,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
   *   key grab on the RootWindow.
   */
  if (grab_window)
-    grab_xwindow = meta_window_get_toplevel_xwindow (grab_window);
+    grab_xwindow = grab_window->frame ? grab_window->frame->xwindow : grab_window->xwindow;
  else
    grab_xwindow = screen->xroot;

@ -4536,7 +4647,6 @@ meta_display_queue_retheme_all_windows (MetaDisplay *display)
      MetaWindow *window = tmp->data;
      
      meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
-      meta_window_frame_size_changed (window);
      if (window->frame)
        {
          meta_frame_queue_draw (window->frame);
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@ -985,7 +985,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
        {
          MetaRectangle *new_rect;
          new_rect = g_new (MetaRectangle, 1);
-          meta_window_get_frame_rect (cur_window, new_rect);
+          meta_window_get_outer_rect (cur_window, new_rect);
          obscuring_windows = g_slist_prepend (obscuring_windows, new_rect);
          window_stacking = 
            g_slist_prepend (window_stacking, GINT_TO_POINTER (stack_position));
@ -1010,7 +1010,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
    {
      MetaRectangle  cur_rect;
      MetaWindow    *cur_window = cur_window_iter->data;
-      meta_window_get_frame_rect (cur_window, &cur_rect);
+      meta_window_get_outer_rect (cur_window, &cur_rect);

      /* Check if we want to use this window's edges for edge
       * resistance (note that dock edges are considered screen edges
@ -1151,7 +1151,7 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
  MetaRectangle old_outer, proposed_outer, new_outer;
  gboolean is_resize;

-  meta_window_get_frame_rect (window, &old_outer);
+  meta_window_get_outer_rect (window, &old_outer);

  proposed_outer = old_outer;
  proposed_outer.x += (*new_x - old_x);
@ -1237,7 +1237,7 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
  int proposed_outer_width, proposed_outer_height;
  gboolean is_resize;

-  meta_window_get_frame_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, 
--- a/src/core/frame.c
+++ b/src/core/frame.c
@ -51,9 +51,6 @@ meta_window_ensure_frame (MetaWindow *window)
  if (window->frame)
    return;
  
-  /* See comment below for why this is required. */
-  meta_display_grab (window->display);
-  
  frame = g_new (MetaFrame, 1);

  frame->window = window;
@ -68,7 +65,6 @@ meta_window_ensure_frame (MetaWindow *window)

  frame->mapped = FALSE;
  frame->is_flashing = FALSE;
-  frame->borders_cached = FALSE;
  
  meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
                window->desc,
@ -117,14 +113,6 @@ meta_window_ensure_frame (MetaWindow *window)
  
  meta_display_register_x_window (window->display, &frame->xwindow, window);

-  /* Reparent the client window; it may be destroyed,
-   * thus the error trap. We'll get a destroy notify later
-   * and free everything. Comment in FVWM source code says
-   * we need a server grab or the child can get its MapNotify
-   * before we've finished reparenting and getting the decoration
-   * window onscreen, so ensure_frame must be called with
-   * a grab.
-   */
  meta_error_trap_push (window->display);
  if (window->mapped)
    {
@ -166,8 +154,6 @@ meta_window_ensure_frame (MetaWindow *window)

  /* Move keybindings to frame instead of window */
  meta_window_grab_keys (window);
-
-  meta_display_ungrab (window->display);
 }

 void
@ -328,23 +314,9 @@ meta_frame_calc_borders (MetaFrame        *frame,
  if (frame == NULL)
    meta_frame_borders_clear (borders);
  else
-    {
-      if (!frame->borders_cached)
-        {
-          meta_ui_get_frame_borders (frame->window->screen->ui,
-                                     frame->xwindow,
-                                     &frame->cached_borders);
-          frame->borders_cached = TRUE;
-        }
-
-      *borders = frame->cached_borders;
-    }
-}
-
-void
-meta_frame_clear_cached_borders (MetaFrame *frame)
-{
-  frame->borders_cached = FALSE;
+    meta_ui_get_frame_borders (frame->window->screen->ui,
+                               frame->xwindow,
+                               borders);
 }

 gboolean
--- a/src/core/frame.h
+++ b/src/core/frame.h
@ -41,8 +41,6 @@ struct _MetaFrame
   */
  MetaRectangle rect;

-  MetaFrameBorders cached_borders; /* valid if borders_cached is set */
-
  /* position of client, size of frame */
  int child_x;
  int child_y;
@ -52,7 +50,6 @@ struct _MetaFrame
  guint mapped : 1;
  guint need_reapply_frame_shape : 1;
  guint is_flashing : 1; /* used by the visual bell flash */
-  guint borders_cached : 1;
 };

 void     meta_window_ensure_frame           (MetaWindow *window);
@ -71,8 +68,6 @@ gboolean meta_frame_sync_to_window (MetaFrame         *frame,
                                    gboolean           need_move,
                                    gboolean           need_resize);

-void meta_frame_clear_cached_borders (MetaFrame *frame);
-
 cairo_region_t *meta_frame_get_frame_bounds (MetaFrame *frame);

 void meta_frame_get_mask (MetaFrame *frame,
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@ -1277,7 +1277,7 @@ meta_window_grab_keys (MetaWindow  *window)
    }

  meta_window_change_keygrabs (window,
-                               meta_window_get_toplevel_xwindow (window),
+                               window->frame ? window->frame->xwindow : window->xwindow,
                               TRUE);

  window->keys_grabbed = TRUE;
@ -1580,7 +1580,7 @@ meta_window_grab_all_keys (MetaWindow  *window,
              window->desc);
  meta_window_focus (window, timestamp);

-  grabwindow = meta_window_get_toplevel_xwindow (window);
+  grabwindow = window->frame ? window->frame->xwindow : window->xwindow;

  meta_topic (META_DEBUG_KEYBINDINGS,
              "Grabbing all keys on window %s\n", window->desc);
@ -1835,6 +1835,7 @@ invoke_handler_by_name (MetaDisplay    *display,
    invoke_handler (display, screen, handler, window, event, NULL);
 }

+/* now called from only one place, may be worth merging */
 static gboolean
 process_event (MetaKeyBinding       *bindings,
               int                   n_bindings,
@ -1842,6 +1843,7 @@ process_event (MetaKeyBinding       *bindings,
               MetaScreen           *screen,
               MetaWindow           *window,
               XIDeviceEvent        *event,
+               KeySym                keysym,
               gboolean              on_window)
 {
  int i;
@ -1859,6 +1861,7 @@ process_event (MetaKeyBinding       *bindings,
      MetaKeyHandler *handler = bindings[i].handler;

      if ((!on_window && handler->flags & META_KEY_BINDING_PER_WINDOW) ||
+          event->evtype != XI_KeyPress ||
          bindings[i].keycode != event->detail ||
          ((event->mods.effective & 0xff & ~(display->ignored_modifier_mask)) !=
           bindings[i].mask) ||
@ -1925,7 +1928,7 @@ process_overlay_key (MetaDisplay *display,
           */
          if (process_event (display->key_bindings,
                             display->n_key_bindings,
-                             display, screen, NULL, event,
+                             display, screen, NULL, event, keysym,
                             FALSE))
            {
              /* As normally, after we've handled a global key
@ -2189,7 +2192,7 @@ meta_display_process_key_event (MetaDisplay   *display,
  /* Do the normal keybindings */
  return process_event (display->key_bindings,
                        display->n_key_bindings,
-                        display, screen, window, event,
+                        display, screen, window, event, keysym,
                        !all_keys_grabbed && window);
 }

@ -3137,20 +3140,6 @@ handle_maximize_horizontally (MetaDisplay    *display,
    }
 }

-static void
-handle_always_on_top          (MetaDisplay    *display,
-                              MetaScreen     *screen,
-                              MetaWindow     *window,
-                              XIDeviceEvent  *event,
-                              MetaKeyBinding *binding,
-                              gpointer        dummy)
-{
-  if (window->wm_state_above == FALSE)
-    meta_window_make_above (window);
-  else
-    meta_window_unmake_above (window);
-}
-
 /* Move a window to a corner; to_bottom/to_right are FALSE for the
 * top or left edge, or TRUE for the bottom/right edge.  xchange/ychange
 * are FALSE if that dimension is not to be changed, TRUE otherwise.
@ -3168,17 +3157,17 @@ handle_move_to_corner_backend (MetaDisplay    *display,
                               gpointer        dummy)
 {
  MetaRectangle work_area;
-  MetaRectangle frame_rect;
+  MetaRectangle outer;
  int orig_x, orig_y;
  int new_x, new_y;

  meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_frame_rect (window, &frame_rect);
+  meta_window_get_outer_rect (window, &outer);
  meta_window_get_position (window, &orig_x, &orig_y);

  if (xchange) {
    new_x = work_area.x + (to_right ?
-                           work_area.width - frame_rect.width :
+                           work_area.width - outer.width :
                           0);
  } else {
    new_x = orig_x;
@ -3186,7 +3175,7 @@ handle_move_to_corner_backend (MetaDisplay    *display,

  if (ychange) {
    new_y = work_area.y + (to_bottom ?
-                           work_area.height - frame_rect.height :
+                           work_area.height - outer.height :
                           0);
  } else {
    new_y = orig_y;
@ -3295,12 +3284,12 @@ handle_move_to_center  (MetaDisplay    *display,
                        gpointer        dummy)
 {
  MetaRectangle work_area;
-  MetaRectangle frame_rect;
+  MetaRectangle outer;
  int orig_x, orig_y;
  int frame_width, frame_height;

  meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_frame_rect (window, &frame_rect);
+  meta_window_get_outer_rect (window, &outer);
  meta_window_get_position (window, &orig_x, &orig_y);

  frame_width = (window->frame ? window->frame->child_x : 0);
@ -3308,8 +3297,8 @@ handle_move_to_center  (MetaDisplay    *display,

  meta_window_move_resize (window,
                           TRUE,
-                           work_area.x + (work_area.width +frame_width -frame_rect.width )/2,
-                           work_area.y + (work_area.height+frame_height-frame_rect.height)/2,
+                           work_area.x + (work_area.width +frame_width -outer.width )/2,
+                           work_area.y + (work_area.height+frame_height-outer.height)/2,
                           window->rect.width,
                           window->rect.height);
 }
@ -4002,8 +3991,8 @@ handle_raise_or_lower (MetaDisplay    *display,

      if (above->mapped)
        {
-          meta_window_get_frame_rect (window, &win_rect);
-          meta_window_get_frame_rect (above, &above_rect);
+          meta_window_get_outer_rect (window, &win_rect);
+          meta_window_get_outer_rect (above, &above_rect);

          /* Check if obscured */
          if (meta_rectangle_intersect (&win_rect, &above_rect, &tmp))
@ -4143,6 +4132,28 @@ meta_keybindings_set_custom_handler (const gchar        *name,
  return TRUE;
 }

+/**
+ * meta_keybindings_switch_window: (skip)
+ * @display: a #MetaDisplay
+ * @screen: a #MetaScreen
+ * @event_window: a #MetaWindow
+ * @event: a #XIDeviceEvent
+ * @binding: a #MetaKeyBinding
+ *
+ */
+void
+meta_keybindings_switch_window (MetaDisplay    *display,
+                                MetaScreen     *screen,
+                                MetaWindow     *event_window,
+                                XIDeviceEvent  *event,
+                                MetaKeyBinding *binding)
+{
+  gint backwards = (binding->handler->flags & META_KEY_BINDING_IS_REVERSED) != 0;
+
+  do_choose_window (display, screen, event_window, event, binding,
+                    backwards, FALSE);
+}
+
 static void
 init_builtin_key_bindings (MetaDisplay *display)
 {
@ -4664,13 +4675,6 @@ init_builtin_key_bindings (MetaDisplay *display)
                          META_KEYBINDING_ACTION_MAXIMIZE_HORIZONTALLY,
                          handle_maximize_horizontally, 0);

-  add_builtin_keybinding (display,
-                          "always-on-top",
-                          common_keybindings,
-                          META_KEY_BINDING_PER_WINDOW,
-                          META_KEYBINDING_ACTION_ALWAYS_ON_TOP,
-                          handle_always_on_top, 0);
-
  add_builtin_keybinding (display,
                          "move-to-corner-nw",
                          common_keybindings,
--- a/src/core/meta-cursor-tracker.c
+++ b/src/core/meta-cursor-tracker.c
@ -37,9 +37,7 @@

 #include <gdk/gdk.h>

-#include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
-#include <X11/Xcursor/Xcursor.h>

 #include "meta-cursor-tracker-private.h"
 #include "screen-private.h"
@ -71,106 +69,6 @@ enum {

 static guint signals[LAST_SIGNAL];

-static void
-translate_meta_cursor (MetaCursor   cursor,
-                       guint       *glyph_out,
-                       const char **name_out)
-{
-  guint glyph = XC_num_glyphs;
-  const char *name = NULL;
-
-  switch (cursor)
-    {
-    case META_CURSOR_DEFAULT:
-      glyph = XC_left_ptr;
-      break;
-    case META_CURSOR_NORTH_RESIZE:
-      glyph = XC_top_side;
-      break;
-    case META_CURSOR_SOUTH_RESIZE:
-      glyph = XC_bottom_side;
-      break;
-    case META_CURSOR_WEST_RESIZE:
-      glyph = XC_left_side;
-      break;
-    case META_CURSOR_EAST_RESIZE:
-      glyph = XC_right_side;
-      break;
-    case META_CURSOR_SE_RESIZE:
-      glyph = XC_bottom_right_corner;
-      break;
-    case META_CURSOR_SW_RESIZE:
-      glyph = XC_bottom_left_corner;
-      break;
-    case META_CURSOR_NE_RESIZE:
-      glyph = XC_top_right_corner;
-      break;
-    case META_CURSOR_NW_RESIZE:
-      glyph = XC_top_left_corner;
-      break;
-    case META_CURSOR_MOVE_OR_RESIZE_WINDOW:
-      glyph = XC_fleur;
-      break;
-    case META_CURSOR_BUSY:
-      glyph = XC_watch;
-      break;
-    case META_CURSOR_DND_IN_DRAG:
-      name = "dnd-none";
-      break;
-    case META_CURSOR_DND_MOVE:
-      name = "dnd-move";
-      break;
-    case META_CURSOR_DND_COPY:
-      name = "dnd-copy";
-      break;
-    case META_CURSOR_DND_UNSUPPORTED_TARGET:
-      name = "dnd-none";
-      break;
-    case META_CURSOR_POINTING_HAND:
-      glyph = XC_hand2;
-      break;
-    case META_CURSOR_CROSSHAIR:
-      glyph = XC_crosshair;
-      break;
-    case META_CURSOR_IBEAM:
-      glyph = XC_xterm;
-      break;
-
-    default:
-      g_assert_not_reached ();
-      glyph = 0; /* silence compiler */
-      break;
-    }
-
-  *glyph_out = glyph;
-  *name_out = name;
-}
-
-static Cursor
-load_cursor_on_server (MetaDisplay *display,
-                       MetaCursor   cursor)
-{
-  Cursor xcursor;
-  guint glyph;
-  const char *name;
-
-  translate_meta_cursor (cursor, &glyph, &name);
-
-  if (name != NULL)
-    xcursor = XcursorLibraryLoadCursor (display->xdisplay, name);
-  else
-    xcursor = XCreateFontCursor (display->xdisplay, glyph);
-
-  return xcursor;
-}
-
-Cursor
-meta_display_create_x_cursor (MetaDisplay *display,
-                              MetaCursor cursor)
-{
-  return load_cursor_on_server (display, cursor);
-}
-
 static void
 meta_cursor_tracker_init (MetaCursorTracker *self)
 {
--- a/src/core/meta-idle-monitor.c
+++ b/src/core/meta-idle-monitor.c
@ -501,7 +501,7 @@ make_watch (MetaIdleMonitor           *monitor,
      if (meta_idle_monitor_get_idletime (monitor) > (gint64)timeout_msec)
        watch->idle_source_id = g_idle_add (fire_watch_idle, watch);
    }
-  else
+  else if (monitor->user_active_alarm != None)
    {
      watch->xalarm = monitor->user_active_alarm;

@ -842,8 +842,6 @@ on_bus_acquired (GDBusConnection *connection,
  for (iter = devices; iter; iter = iter->next)
    on_device_added (device_manager, iter->data, manager);

-  g_slist_free (devices);
-
  g_signal_connect_object (device_manager, "device-added",
                           G_CALLBACK (on_device_added), manager, 0);
  g_signal_connect_object (device_manager, "device-removed",
--- a/src/core/monitor-config.c
+++ b/src/core/monitor-config.c
@ -99,9 +99,8 @@ static gboolean meta_monitor_config_assign_crtcs (MetaConfiguration  *config,
                                                  GPtrArray          *crtcs,
                                                  GPtrArray          *outputs);

-static void     power_client_changed_cb (UpClient   *client,
-                                         GParamSpec *pspec,
-                                         gpointer    user_data);
+static void     power_client_changed_cb (UpClient *client,
+                                         gpointer  user_data);

 static void
 free_output_key (MetaOutputKey *key)
@ -233,7 +232,7 @@ meta_monitor_config_init (MetaMonitorConfig *self)
  self->up_client = up_client_new ();
  self->lid_is_closed = up_client_get_lid_is_closed (self->up_client);

-  g_signal_connect_object (self->up_client, "notify::lid-is-closed",
+  g_signal_connect_object (self->up_client, "changed",
                           G_CALLBACK (power_client_changed_cb), self, 0);
 }

@ -1361,9 +1360,8 @@ turn_off_laptop_display (MetaMonitorConfig  *self,
 }

 static void
-power_client_changed_cb (UpClient   *client,
-                         GParamSpec *pspec,
-                         gpointer    user_data)
+power_client_changed_cb (UpClient *client,
+                         gpointer  user_data)
 {
  MetaMonitorManager *manager = meta_monitor_manager_get ();
  MetaMonitorConfig *self = user_data;
--- a/src/core/monitor-xrandr.c
+++ b/src/core/monitor-xrandr.c
@ -187,7 +187,7 @@ output_get_backlight_xrandr (MetaMonitorManagerXrandr *manager_xrandr,

  XRRGetOutputProperty (manager_xrandr->xdisplay,
                        (XID)output->output_id,
-                        display->atom_BACKLIGHT,
+                        display->atom_Backlight,
                        0, G_MAXLONG, False, False, XA_INTEGER,
                        &actual_type, &actual_format,
                        &nitems, &bytes_after, &buffer);
@ -212,7 +212,7 @@ output_get_backlight_limits_xrandr (MetaMonitorManagerXrandr *manager_xrandr,
  meta_error_trap_push (display);
  info = XRRQueryOutputProperty (manager_xrandr->xdisplay,
                                 (XID)output->output_id,
-                                 display->atom_BACKLIGHT);
+                                 display->atom_Backlight);
  meta_error_trap_pop (display);

  if (info == NULL)
@ -453,10 +453,8 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
      XRRFreeCrtcInfo (crtc);
    }

-  meta_error_trap_push (meta_get_display ());
  primary_output = XRRGetOutputPrimary (manager_xrandr->xdisplay,
 					DefaultRootWindow (manager_xrandr->xdisplay));
-  meta_error_trap_pop (meta_get_display ());

  n_actual_outputs = 0;
  for (i = 0; i < (unsigned)resources->noutput; i++)
@ -695,11 +693,10 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
 						 unsigned int         n_outputs)
 {
  MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
-  MetaDisplay *display = meta_get_display ();
  unsigned i;
  int width, height, width_mm, height_mm;

-  meta_display_grab (display);
+  meta_display_grab (meta_get_display ());

  /* First compute the new size of the screen (framebuffer) */
  width = 0; height = 0;
@ -793,10 +790,10 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
   */
  width_mm = (width / DPI_FALLBACK) * 25.4 + 0.5;
  height_mm = (height / DPI_FALLBACK) * 25.4 + 0.5;
-  meta_error_trap_push (display);
+  meta_error_trap_push (meta_get_display ());
  XRRSetScreenSize (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
                    width, height, width_mm, height_mm);
-  meta_error_trap_pop (display);
+  meta_error_trap_pop (meta_get_display ());

  for (i = 0; i < n_crtcs; i++)
    {
@ -853,7 +850,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
              goto next;
            }

-          meta_error_trap_push (display);
+          meta_error_trap_push (meta_get_display ());
          ok = XRRSetCrtcConfig (manager_xrandr->xdisplay,
                                 manager_xrandr->resources,
                                 (XID)crtc->crtc_id,
@ -862,7 +859,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
                                 (XID)mode->mode_id,
                                 wl_transform_to_xrandr (crtc_info->transform),
                                 outputs, n_outputs);
-          meta_error_trap_pop (display);
+          meta_error_trap_pop (meta_get_display ());

          if (ok != Success)
            {
@ -903,11 +900,9 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,

      if (output_info->is_primary)
        {
-          meta_error_trap_push (display);
          XRRSetOutputPrimary (manager_xrandr->xdisplay,
                               DefaultRootWindow (manager_xrandr->xdisplay),
                               (XID)output_info->output->output_id);
-          meta_error_trap_pop (display);
        }

      output_set_presentation_xrandr (manager_xrandr,
@ -933,7 +928,7 @@ meta_monitor_manager_xrandr_apply_configuration (MetaMonitorManager *manager,
      output->is_primary = FALSE;
    }

-  meta_display_ungrab (display);
+  meta_display_ungrab (meta_get_display ());
 }

 static void
@ -950,7 +945,7 @@ meta_monitor_manager_xrandr_change_backlight (MetaMonitorManager *manager,
  meta_error_trap_push (display);
  XRRChangeOutputProperty (manager_xrandr->xdisplay,
                           (XID)output->output_id,
-                           display->atom_BACKLIGHT,
+                           display->atom_Backlight,
                           XA_INTEGER, 32, PropModeReplace,
                           (unsigned char *) &hw_value, 1);
  meta_error_trap_pop (display);
--- a/src/core/monitor.c
+++ b/src/core/monitor.c
@ -406,7 +406,7 @@ make_logical_config (MetaMonitorManager *manager)

      for (j = 0; j < monitor_infos->len; j++)
        {
-          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, i);
+          MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, j);
          if (meta_rectangle_equal (&crtc->rect,
                                    &info->rect))
            {
@ -806,9 +806,6 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
                             g_variant_new_take_string (make_display_name (manager, output)));
      g_variant_builder_add (&properties, "{sv}", "backlight",
                             g_variant_new_int32 (output->backlight));
-      g_variant_builder_add (&properties, "{sv}", "min-backlight-step",
-                             g_variant_new_int32 ((output->backlight_max - output->backlight_min) ?
-                                                  100 / (output->backlight_max - output->backlight_min) : -1));
      g_variant_builder_add (&properties, "{sv}", "primary",
                             g_variant_new_boolean (output->is_primary));
      g_variant_builder_add (&properties, "{sv}", "presentation",
--- a/src/core/place.c
+++ b/src/core/place.c
@ -47,18 +47,34 @@ northwestcmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
-  MetaRectangle a_frame;
-  MetaRectangle b_frame;
  int from_origin_a;
  int from_origin_b;
  int ax, ay, bx, by;

-  meta_window_get_frame_rect (aw, &a_frame);
-  meta_window_get_frame_rect (bw, &b_frame);
-  ax = a_frame.x;
-  ay = a_frame.y;
-  bx = b_frame.x;
-  by = b_frame.y;
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    {
+      ax = aw->frame->rect.x;
+      ay = aw->frame->rect.y;
+    }
+  else
+    {
+      ax = aw->rect.x;
+      ay = aw->rect.y;
+    }
+
+  if (bw->frame)
+    {
+      bx = bw->frame->rect.x;
+      by = bw->frame->rect.y;
+    }
+  else
+    {
+      bx = bw->rect.x;
+      by = bw->rect.y;
+    }
  
  /* probably there's a fast good-enough-guess we could use here. */
  from_origin_a = sqrt (ax * ax + ay * ay);
@ -74,6 +90,7 @@ northwestcmp (gconstpointer a, gconstpointer b)

 static void
 find_next_cascade (MetaWindow *window,
+                   MetaFrameBorders *borders,
                   /* visible windows on relevant workspaces */
                   GList      *windows,
                   int         x,
@ -85,7 +102,6 @@ find_next_cascade (MetaWindow *window,
  GList *sorted;
  int cascade_x, cascade_y;
  int x_threshold, y_threshold;
-  MetaRectangle frame_rect;
  int window_width, window_height;
  int cascade_stage;
  MetaRectangle work_area;
@ -104,13 +120,10 @@ find_next_cascade (MetaWindow *window,
   * manually cascade.
   */
 #define CASCADE_FUZZ 15
-  if (window->frame)
+  if (borders)
    {
-      MetaFrameBorders borders;
-
-      meta_frame_calc_borders (window->frame, &borders);
-      x_threshold = MAX (borders.visible.left, CASCADE_FUZZ);
-      y_threshold = MAX (borders.visible.top, CASCADE_FUZZ);
+      x_threshold = MAX (borders->visible.left, CASCADE_FUZZ);
+      y_threshold = MAX (borders->visible.top, CASCADE_FUZZ);
    }
  else
    {
@ -130,25 +143,30 @@ find_next_cascade (MetaWindow *window,
  cascade_y = MAX (0, work_area.y);
  
  /* Find first cascade position that's not used. */
-
-  meta_window_get_frame_rect (window, &frame_rect);
-  window_width = frame_rect.width;
-  window_height = frame_rect.height;
+  
+  window_width = window->frame ? window->frame->rect.width : window->rect.width;
+  window_height = window->frame ? window->frame->rect.height : window->rect.height;
  
  cascade_stage = 0;
  tmp = sorted;
  while (tmp != NULL)
    {
      MetaWindow *w;
-      MetaRectangle w_frame_rect;
      int wx, wy;
      
      w = tmp->data;

      /* we want frame position, not window position */
-      meta_window_get_frame_rect (w, &w_frame_rect);
-      wx = w_frame_rect.x;
-      wy = w_frame_rect.y;
+      if (w->frame)
+        {
+          wx = w->frame->rect.x;
+          wy = w->frame->rect.y;
+        }
+      else
+        {
+          wx = w->rect.x;
+          wy = w->rect.y;
+        }
      
      if (ABS (wx - cascade_x) < x_threshold &&
          ABS (wy - cascade_y) < y_threshold)
@ -205,12 +223,22 @@ find_next_cascade (MetaWindow *window,
  
  g_list_free (sorted);

-  *new_x = cascade_x;
-  *new_y = cascade_y;
+  /* Convert coords to position of window, not position of frame. */
+  if (borders == NULL)
+    {
+      *new_x = cascade_x;
+      *new_y = cascade_y;
+    }
+  else
+    {
+      *new_x = cascade_x + borders->visible.left;
+      *new_y = cascade_y + borders->visible.top;
+    }
 }

 static void
 find_most_freespace (MetaWindow *window,
+                     MetaFrameBorders *borders,
                     /* visible windows on relevant workspaces */
                     MetaWindow *focus_window,
                     int         x,
@ -222,25 +250,29 @@ find_most_freespace (MetaWindow *window,
  int max_area;
  int max_width, max_height, left, right, top, bottom;
  int left_space, right_space, top_space, bottom_space;
+  int frame_size_left, frame_size_top;
  MetaRectangle work_area;
  MetaRectangle avoid;
-  MetaRectangle frame_rect;
+  MetaRectangle outer;
+
+  frame_size_left = borders ? borders->visible.left : 0;
+  frame_size_top  = borders ? borders->visible.top : 0;

  meta_window_get_work_area_current_monitor (focus_window, &work_area);
-  meta_window_get_frame_rect (focus_window, &avoid);
-  meta_window_get_frame_rect (window, &frame_rect);
+  meta_window_get_outer_rect (focus_window, &avoid);
+  meta_window_get_outer_rect (window, &outer);

  /* Find the areas of choosing the various sides of the focus window */
-  max_width  = MIN (avoid.width, frame_rect.width);
-  max_height = MIN (avoid.height, frame_rect.height);
+  max_width  = MIN (avoid.width, outer.width);
+  max_height = MIN (avoid.height, outer.height);
  left_space   = avoid.x - work_area.x;
  right_space  = work_area.width - (avoid.x + avoid.width - work_area.x);
  top_space    = avoid.y - work_area.y;
  bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
-  left   = MIN (left_space,   frame_rect.width);
-  right  = MIN (right_space,  frame_rect.width);
-  top    = MIN (top_space,    frame_rect.height);
-  bottom = MIN (bottom_space, frame_rect.height);
+  left   = MIN (left_space,   outer.width);
+  right  = MIN (right_space,  outer.width);
+  top    = MIN (top_space,    outer.height);
+  bottom = MIN (bottom_space, outer.height);

  /* Find out which side of the focus_window can show the most of the window */
  side = META_LEFT;
@ -272,56 +304,39 @@ find_most_freespace (MetaWindow *window,
  switch (side)
    {
    case META_LEFT:
-      *new_y = avoid.y;
-      if (left_space > frame_rect.width)
-        *new_x = avoid.x - frame_rect.width;
+      *new_y = avoid.y + frame_size_top;
+      if (left_space > outer.width)
+        *new_x = avoid.x - outer.width + frame_size_left;
      else
-        *new_x = work_area.x;
+        *new_x = work_area.x + frame_size_left;
      break;
    case META_RIGHT:
-      *new_y = avoid.y;
-      if (right_space > frame_rect.width)
-        *new_x = avoid.x + avoid.width;
+      *new_y = avoid.y + frame_size_top;
+      if (right_space > outer.width)
+        *new_x = avoid.x + avoid.width + frame_size_left;
      else
-        *new_x = work_area.x + work_area.width - frame_rect.width;
+        *new_x = work_area.x + work_area.width - outer.width + frame_size_left;
      break;
    case META_TOP:
-      *new_x = avoid.x;
-      if (top_space > frame_rect.height)
-        *new_y = avoid.y - frame_rect.height;
+      *new_x = avoid.x + frame_size_left;
+      if (top_space > outer.height)
+        *new_y = avoid.y - outer.height + frame_size_top;
      else
-        *new_y = work_area.y;
+        *new_y = work_area.y + frame_size_top;
      break;
    case META_BOTTOM:
-      *new_x = avoid.x;
-      if (bottom_space > frame_rect.height)
-        *new_y = avoid.y + avoid.height;
+      *new_x = avoid.x + frame_size_left;
+      if (bottom_space > outer.height)
+        *new_y = avoid.y + avoid.height + frame_size_top;
      else
-        *new_y = work_area.y + work_area.height - frame_rect.height;
+        *new_y = work_area.y + work_area.height - outer.height + frame_size_top;
      break;
    }
 }

-static gboolean
-window_overlaps_focus_window (MetaWindow *window)
-{
-  MetaWindow *focus_window;
-  MetaRectangle window_frame, focus_frame, overlap;
-
-  focus_window = window->display->focus_window;
-  if (focus_window == NULL)
-    return FALSE;
-
-  meta_window_get_frame_rect (window, &window_frame);
-  meta_window_get_frame_rect (focus_window, &focus_frame);
-
-  return meta_rectangle_intersect (&window_frame,
-                                   &focus_frame,
-                                   &overlap);
-}
-
 static void
 avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
+                                             MetaFrameBorders *borders,
                                             int        *x,
                                             int        *y)
 {
@ -340,17 +355,18 @@ avoid_being_obscured_as_second_modal_dialog (MetaWindow *window,
   */

  MetaWindow *focus_window;
+  MetaRectangle overlap;

  focus_window = window->display->focus_window;

-  /* denied_focus_and_not_transient is only set when focus_window != NULL */
-
  if (window->denied_focus_and_not_transient &&
      window->wm_state_modal && /* FIXME: Maybe do this for all transients? */
      meta_window_same_application (window, focus_window) &&
-      window_overlaps_focus_window (window))
+      meta_rectangle_intersect (&window->rect,
+                                &focus_window->rect,
+                                &overlap))
    {
-      find_most_freespace (window, focus_window, *x, *y, x, y);
+      find_most_freespace (window, borders, focus_window, *x, *y, x, y);
      meta_topic (META_DEBUG_PLACEMENT,
                  "Dialog window %s was denied focus but may be modal "
                  "to the focus window; had to move it to avoid the "
@ -393,7 +409,7 @@ rectangle_overlaps_some_window (MetaRectangle *rect,
        case META_WINDOW_UTILITY:
        case META_WINDOW_TOOLBAR:
        case META_WINDOW_MENU:
-          meta_window_get_frame_rect (other, &other_rect);
+          meta_window_get_outer_rect (other, &other_rect);
          
          if (meta_rectangle_intersect (rect, &other_rect, &dest))
            return TRUE;
@ -411,14 +427,20 @@ leftmost_cmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
-  MetaRectangle a_frame;
-  MetaRectangle b_frame;
  int ax, bx;

-  meta_window_get_frame_rect (aw, &a_frame);
-  meta_window_get_frame_rect (bw, &b_frame);
-  ax = a_frame.x;
-  bx = b_frame.x;
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ax = aw->frame->rect.x;
+  else
+    ax = aw->rect.x;
+
+  if (bw->frame)
+    bx = bw->frame->rect.x;
+  else
+    bx = bw->rect.x;

  if (ax < bx)
    return -1;
@ -433,14 +455,20 @@ topmost_cmp (gconstpointer a, gconstpointer b)
 {
  MetaWindow *aw = (gpointer) a;
  MetaWindow *bw = (gpointer) b;
-  MetaRectangle a_frame;
-  MetaRectangle b_frame;
  int ay, by;

-  meta_window_get_frame_rect (aw, &a_frame);
-  meta_window_get_frame_rect (bw, &b_frame);
-  ay = a_frame.y;
-  by = b_frame.y;
+  /* we're interested in the frame position for cascading,
+   * not meta_window_get_position()
+   */
+  if (aw->frame)
+    ay = aw->frame->rect.y;
+  else
+    ay = aw->rect.y;
+
+  if (bw->frame)
+    by = bw->frame->rect.y;
+  else
+    by = bw->rect.y;

  if (ay < by)
    return -1;
@ -478,6 +506,7 @@ center_tile_rect_in_area (MetaRectangle *rect,
 */
 static gboolean
 find_first_fit (MetaWindow *window,
+                MetaFrameBorders *borders,
                /* visible windows on relevant workspaces */
                GList      *windows,
 		int         monitor,
@ -511,8 +540,15 @@ find_first_fit (MetaWindow *window,
  right_sorted = g_list_copy (windows);
  right_sorted = g_list_sort (right_sorted, topmost_cmp);
  right_sorted = g_list_sort (right_sorted, leftmost_cmp);
-
-  meta_window_get_frame_rect (window, &rect);
+  
+  rect.width = window->rect.width;
+  rect.height = window->rect.height;
+  
+  if (borders)
+    {
+      rect.width += borders->visible.left + borders->visible.right;
+      rect.height += borders->visible.top + borders->visible.bottom;
+    }

 #ifdef WITH_VERBOSE_MODE
    {
@ -534,6 +570,11 @@ find_first_fit (MetaWindow *window,
      {
        *new_x = rect.x;
        *new_y = rect.y;
+        if (borders)
+          {
+            *new_x += borders->visible.left;
+            *new_y += borders->visible.top;
+          }
    
        retval = TRUE;
       
@ -545,18 +586,23 @@ find_first_fit (MetaWindow *window,
    while (tmp != NULL)
      {
        MetaWindow *w = tmp->data;
-        MetaRectangle frame_rect;
+        MetaRectangle outer_rect;

-        meta_window_get_frame_rect (w, &frame_rect);
+        meta_window_get_outer_rect (w, &outer_rect);
      
-        rect.x = frame_rect.x;
-        rect.y = frame_rect.y + frame_rect.height;
+        rect.x = outer_rect.x;
+        rect.y = outer_rect.y + outer_rect.height;
      
        if (meta_rectangle_contains_rect (&work_area, &rect) &&
            !rectangle_overlaps_some_window (&rect, below_sorted))
          {
            *new_x = rect.x;
            *new_y = rect.y;
+            if (borders)
+              {
+                *new_x += borders->visible.left;
+                *new_y += borders->visible.top;
+              }
          
            retval = TRUE;
          
@ -571,18 +617,23 @@ find_first_fit (MetaWindow *window,
    while (tmp != NULL)
      {
        MetaWindow *w = tmp->data;
-        MetaRectangle frame_rect;
+        MetaRectangle outer_rect;
   
-        meta_window_get_frame_rect (w, &frame_rect);
+        meta_window_get_outer_rect (w, &outer_rect);
     
-        rect.x = frame_rect.x + frame_rect.width;
-        rect.y = frame_rect.y;
+        rect.x = outer_rect.x + outer_rect.width;
+        rect.y = outer_rect.y;
   
        if (meta_rectangle_contains_rect (&work_area, &rect) &&
            !rectangle_overlaps_some_window (&rect, right_sorted))
          {
            *new_x = rect.x;
            *new_y = rect.y;
+            if (borders)
+              {
+                *new_x += borders->visible.left;
+                *new_y += borders->visible.top;
+              }
        
            retval = TRUE;
       
@ -601,6 +652,7 @@ find_first_fit (MetaWindow *window,

 void
 meta_window_place (MetaWindow        *window,
+                   MetaFrameBorders  *borders,
                   int                x,
                   int                y,
                   int               *new_x,
@ -609,6 +661,13 @@ meta_window_place (MetaWindow        *window,
  GList *windows;
  const MetaMonitorInfo *xi;

+  /* frame member variables should NEVER be used in here, only
+   * MetaFrameBorders. But remember borders == NULL
+   * for undecorated windows. Also, this function should
+   * NEVER have side effects other than computing the
+   * placement coordinates.
+   */
+
  meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);

  windows = NULL;
@ -697,7 +756,7 @@ meta_window_place (MetaWindow        *window,
        {
          meta_topic (META_DEBUG_PLACEMENT,
                      "Not placing window with PPosition or USPosition set\n");
-          avoid_being_obscured_as_second_modal_dialog (window, &x, &y);
+          avoid_being_obscured_as_second_modal_dialog (window, borders, &x, &y);
          goto done_no_constraints;
        }
    }
@ -716,27 +775,29 @@ meta_window_place (MetaWindow        *window,

      if (parent)
        {
-          MetaRectangle frame_rect, parent_frame_rect;
+          int w;

-          meta_window_get_frame_rect (window, &frame_rect);
-          meta_window_get_frame_rect (parent, &parent_frame_rect);
-
-          y = parent_frame_rect.y;
+          meta_window_get_position (parent, &x, &y);
+          w = parent->rect.width;

          /* center of parent */
-          x = parent_frame_rect.x + parent_frame_rect.width / 2;
+          x = x + w / 2;
          /* center of child over center of parent */
-          x -= frame_rect.width / 2;
+          x -= window->rect.width / 2;

          /* "visually" center window over parent, leaving twice as
           * much space below as on top.
           */
-          y += (parent_frame_rect.height - frame_rect.height)/3;
+          y += (parent->rect.height - window->rect.height)/3;
+
+          /* put top of child's frame, not top of child's client */
+          if (borders)
+            y += borders->visible.top;

          meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
                      window->desc);
          
-          avoid_being_obscured_as_second_modal_dialog (window, &x, &y);
+          avoid_being_obscured_as_second_modal_dialog (window, borders, &x, &y);

          goto done;
        }
@ -752,9 +813,6 @@ meta_window_place (MetaWindow        *window,
    {
      /* Center on current monitor */
      int w, h;
-      MetaRectangle frame_rect;
-
-      meta_window_get_frame_rect (window, &frame_rect);

      /* Warning, this function is a round trip! */
      xi = meta_screen_get_current_monitor_info (window->screen);
@ -762,8 +820,8 @@ meta_window_place (MetaWindow        *window,
      w = xi->rect.width;
      h = xi->rect.height;

-      x = (w - frame_rect.width) / 2;
-      y = (h - frame_rect.height) / 2;
+      x = (w - window->rect.width) / 2;
+      y = (h - window->rect.height) / 2;

      x += xi->rect.x;
      y += xi->rect.y;
@ -807,7 +865,7 @@ meta_window_place (MetaWindow        *window,
  x = xi->rect.x;
  y = xi->rect.y;

-  if (find_first_fit (window, windows,
+  if (find_first_fit (window, borders, windows,
                      xi->number,
                      x, y, &x, &y))
    goto done_check_denied_focus;
@ -820,17 +878,17 @@ meta_window_place (MetaWindow        *window,
      !window->fullscreen)
    {
      MetaRectangle workarea;
-      MetaRectangle frame_rect;
+      MetaRectangle outer;

      meta_window_get_work_area_for_monitor (window,
                                             xi->number,
                                             &workarea);      
-      meta_window_get_frame_rect (window, &frame_rect);
+      meta_window_get_outer_rect (window, &outer);
      
      /* If the window is bigger than the screen, then automaximize.  Do NOT
       * auto-maximize the directions independently.  See #419810.
       */
-      if (frame_rect.width >= workarea.width && frame_rect.height >= workarea.height)
+      if (outer.width >= workarea.width && outer.height >= workarea.height)
        {
          window->maximize_horizontally_after_placement = TRUE;
          window->maximize_vertically_after_placement = TRUE;
@ -841,7 +899,7 @@ meta_window_place (MetaWindow        *window,
   * fully overlapping window (e.g. starting multiple terminals)
   * */
  if (x == xi->rect.x && y == xi->rect.y)  
-    find_next_cascade (window, windows, x, y, &x, &y);
+    find_next_cascade (window, borders, windows, x, y, &x, &y);

 done_check_denied_focus:
  /* If the window is being denied focus and isn't a transient of the
@ -851,14 +909,17 @@ meta_window_place (MetaWindow        *window,
   */
  if (window->denied_focus_and_not_transient)
    {
-      MetaWindow    *focus_window;
      gboolean       found_fit;
+      MetaWindow    *focus_window;
+      MetaRectangle  overlap;

      focus_window = window->display->focus_window;
      g_assert (focus_window != NULL);

      /* No need to do anything if the window doesn't overlap at all */
-      found_fit = !window_overlaps_focus_window (window);
+      found_fit = !meta_rectangle_intersect (&window->rect,
+                                             &focus_window->rect,
+                                             &overlap);

      /* Try to do a first fit again, this time only taking into account the
       * focus window.
@ -872,7 +933,7 @@ meta_window_place (MetaWindow        *window,
          x = xi->rect.x;
          y = xi->rect.y;

-          found_fit = find_first_fit (window, focus_window_list,
+          found_fit = find_first_fit (window, borders, focus_window_list,
                                      xi->number,
                                      x, y, &x, &y);
          g_list_free (focus_window_list);
@ -882,7 +943,7 @@ meta_window_place (MetaWindow        *window,
       * as possible.
       */
      if (!found_fit)
-        find_most_freespace (window, focus_window, x, y, &x, &y);
+        find_most_freespace (window, borders, focus_window, x, y, &x, &y);
    }
  
 done:
--- a/src/core/place.h
+++ b/src/core/place.h
@ -28,6 +28,7 @@
 #include "frame.h"

 void meta_window_place (MetaWindow *window,
+                        MetaFrameBorders *borders,
                        int         x,
                        int         y,
                        int        *new_x,
--- a/src/core/screen.c
+++ b/src/core/screen.c
@ -392,6 +392,8 @@ int
 meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen,
                                             int         index)
 {
+  g_return_val_if_fail (index >= 0 && index < screen->n_monitor_infos, -1);
+
  meta_screen_ensure_xinerama_indices (screen);

  return screen->monitor_infos[index].xinerama_index;
@ -476,9 +478,6 @@ create_guard_window (Display *xdisplay, MetaScreen *screen)
 		   CWEventMask|CWOverrideRedirect|CWBackPixel,
 		   &attributes);

-  /* https://bugzilla.gnome.org/show_bug.cgi?id=710346 */
-  XStoreName (xdisplay, guard_window, "mutter guard window");
-
  {
    unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
    XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
@ -859,9 +858,9 @@ meta_screen_free (MetaScreen *screen,
                  screen->wm_sn_selection_window);
  
  if (screen->work_area_later != 0)
-    meta_later_remove (screen->work_area_later);
+    g_source_remove (screen->work_area_later);
  if (screen->check_fullscreen_later != 0)
-    meta_later_remove (screen->check_fullscreen_later);
+    g_source_remove (screen->check_fullscreen_later);

  if (screen->monitor_infos)
    g_free (screen->monitor_infos);
@ -880,83 +879,31 @@ meta_screen_free (MetaScreen *screen,
  meta_display_ungrab (display);
 }

-typedef struct
-{
-  Window		xwindow;
-  XWindowAttributes	attrs;
-} WindowInfo;
-
-static GList *
-list_windows (MetaScreen *screen)
-{
-  Window ignored1, ignored2;
-  Window *children;
-  guint n_children, i;
-  GList *result;
-
-  XQueryTree (screen->display->xdisplay,
-              screen->xroot,
-              &ignored1, &ignored2, &children, &n_children);
-
-  result = NULL;
-  for (i = 0; i < n_children; ++i)
-    {
-      WindowInfo *info = g_new0 (WindowInfo, 1);
-
-      meta_error_trap_push_with_return (screen->display);
-      
-      XGetWindowAttributes (screen->display->xdisplay,
-                            children[i], &info->attrs);
-
-      if (meta_error_trap_pop_with_return (screen->display))
-	{
-          meta_verbose ("Failed to get attributes for window 0x%lx\n",
-                        children[i]);
-	  g_free (info);
-        }
-      else
-        {
-	  info->xwindow = children[i];
-	}
-
-      result = g_list_prepend (result, info);
-    }
-
-  if (children)
-    XFree (children);
-
-  return g_list_reverse (result);
-}
-
 void
 meta_screen_manage_all_windows (MetaScreen *screen)
 {
-  GList *windows;
-  GList *list;
-
-  meta_display_grab (screen->display);
+  Window *_children;
+  Window *children;
+  int n_children, i;

  if (screen->guard_window == None)
    screen->guard_window = create_guard_window (screen->display->xdisplay,
                                                screen);

-  windows = list_windows (screen);
-
  meta_stack_freeze (screen->stack);
-  for (list = windows; list != NULL; list = list->next)
+  meta_stack_tracker_get_stack (screen->stack_tracker, &_children, &n_children);
+
+  /* Copy the stack as it will be modified as part of the loop */
+  children = g_memdup (_children, sizeof (Window) * n_children);
+
+  for (i = 0; i < n_children; ++i)
    {
-      WindowInfo *info = list->data;
-
-      meta_window_new_with_attrs (screen->display, info->xwindow, TRUE,
-                                  META_COMP_EFFECT_NONE,
-                                  &info->attrs);
+      meta_window_new (screen->display, children[i], TRUE,
+                       META_COMP_EFFECT_NONE);
    }
+
+  g_free (children);
  meta_stack_thaw (screen->stack);
-
-  g_list_foreach (windows, (GFunc)g_free, NULL);
-  g_list_free (windows);
-
-  meta_display_ungrab (screen->display);
 }

 /**
@ -1528,7 +1475,7 @@ meta_screen_tab_popup_create (MetaScreen      *screen,
      if (show_type == META_TAB_SHOW_INSTANTLY ||
          !entries[i].hidden                   ||
          !meta_window_get_icon_geometry (window, &r))
-        meta_window_get_frame_rect (window, &r);
+        meta_window_get_outer_rect (window, &r);

      entries[i].rect = r;

@ -1911,7 +1858,7 @@ meta_screen_get_monitor_for_window (MetaScreen *screen,
 {
  MetaRectangle window_rect;
  
-  meta_window_get_frame_rect (window, &window_rect);
+  meta_window_get_outer_rect (window, &window_rect);

  return meta_screen_get_monitor_for_rect (screen, &window_rect);
 }
--- a/src/core/stack.c
+++ b/src/core/stack.c
@ -1465,7 +1465,7 @@ window_contains_point (MetaWindow *window,
 {
  MetaRectangle rect;

-  meta_window_get_frame_rect (window, &rect);
+  meta_window_get_outer_rect (window, &rect);

  return POINT_IN_RECT (root_x, root_y, rect);
 }
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@ -352,12 +352,6 @@ struct _MetaWindow
  /* if non-NULL, the opaque region _NET_WM_OPAQUE_REGION */
  cairo_region_t *opaque_region;

-  /* the input shape region for picking */
-  cairo_region_t *input_region;
-
-  /* _NET_WM_WINDOW_OPACITY */
-  guint opacity;
-
  /* if TRUE, the we have the new form of sync request counter which
   * also handles application frames */
  guint extended_sync_request_counter : 1;
@ -490,12 +484,8 @@ 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,
-                                            MetaCompEffect     effect,
-                                            XWindowAttributes *attrs);
+                                            gboolean     must_be_viewable,
+                                            MetaCompEffect     effect);
 void        meta_window_unmanage           (MetaWindow  *window,
                                            guint32      timestamp);
 void        meta_window_calc_showing       (MetaWindow  *window);
@ -518,7 +508,6 @@ void        meta_window_update_fullscreen_monitors (MetaWindow    *window,
                                                    unsigned long  left,
                                                    unsigned long  right);

-
 /* args to move are window pos, not frame pos */
 void        meta_window_move               (MetaWindow  *window,
                                            gboolean     user_op,
@ -662,8 +651,6 @@ void meta_window_recalc_features    (MetaWindow *window);

 void meta_window_recalc_window_type (MetaWindow *window);

-void meta_window_frame_size_changed (MetaWindow *window);
-
 void meta_window_stack_just_below (MetaWindow *window,
                                   MetaWindow *below_this_one);

@ -691,16 +678,8 @@ void meta_window_set_opaque_region        (MetaWindow     *window,
                                           cairo_region_t *region);
 void meta_window_update_opaque_region_x11 (MetaWindow *window);

-void meta_window_set_input_region         (MetaWindow     *window,
-                                           cairo_region_t *region);
-void meta_window_update_input_region_x11  (MetaWindow *window);
-
 void meta_window_set_shape_region         (MetaWindow     *window,
                                           cairo_region_t *region);
 void meta_window_update_shape_region_x11  (MetaWindow *window);
-void meta_window_set_opacity              (MetaWindow *window,
-                                           guint       opacity);
-
-Window meta_window_get_toplevel_xwindow (MetaWindow *window);

 #endif
--- a/src/core/window-props.c
+++ b/src/core/window-props.c
@ -316,9 +316,6 @@ reload_gtk_frame_extents (MetaWindow    *window,
    {
      window->has_custom_frame_extents = FALSE;
    }
-
-  if (!initial)
-    meta_window_queue(window, META_QUEUE_MOVE_RESIZE);
 }

 static void
@ -1709,20 +1706,6 @@ reload_bypass_compositor (MetaWindow    *window,
  window->bypass_compositor = requested_value;
 }

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

--- a/src/core/window.c
+++ b/src/core/window.c
--- a/src/meta/atomnames.h
+++ b/src/meta/atomnames.h
@ -80,7 +80,7 @@ item(MULTIPLE)
 item(TIMESTAMP)
 item(VERSION)
 item(ATOM_PAIR)
-item(BACKLIGHT)
+item(Backlight)
 item(hotplug_mode_update)

 /* Oddities: These are used, and we need atoms for them,
@ -179,7 +179,6 @@ item(_NET_WM_BYPASS_COMPOSITOR)
 item(_NET_WM_OPAQUE_REGION)
 item(_NET_WM_FRAME_DRAWN)
 item(_NET_WM_FRAME_TIMINGS)
-item(_NET_WM_WINDOW_OPACITY)

 #if 0
 /* We apparently never use: */
--- a/src/meta/compositor.h
+++ b/src/meta/compositor.h
@ -66,8 +66,6 @@ void meta_compositor_unmanage_screen (MetaCompositor *compositor,

 void meta_compositor_window_shape_changed (MetaCompositor *compositor,
                                           MetaWindow     *window);
-void meta_compositor_window_opacity_changed (MetaCompositor *compositor,
-                                             MetaWindow     *window);

 gboolean meta_compositor_process_event (MetaCompositor *compositor,
                                        XEvent         *event,
@ -77,10 +75,11 @@ gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor,
                                            MetaScreen     *screen,
                                            MetaKeyBinding *binding);

-void meta_compositor_add_window        (MetaCompositor      *compositor,
-                                        MetaWindow          *window);
-void meta_compositor_remove_window     (MetaCompositor      *compositor,
-                                        MetaWindow          *window);
+void meta_compositor_add_window    (MetaCompositor *compositor,
+                                    MetaWindow     *window);
+void meta_compositor_remove_window (MetaCompositor *compositor,
+                                    MetaWindow     *window);
+
 void meta_compositor_show_window       (MetaCompositor      *compositor,
                                        MetaWindow          *window,
                                        MetaCompEffect       effect);
@ -102,6 +101,10 @@ void meta_compositor_unmaximize_window (MetaCompositor      *compositor,
                                        MetaRectangle       *old_rect,
                                        MetaRectangle       *new_rect);

+void meta_compositor_window_mapped        (MetaCompositor *compositor,
+                                           MetaWindow     *window);
+void meta_compositor_window_unmapped      (MetaCompositor *compositor,
+                                           MetaWindow     *window);
 void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
                                           MetaWindow     *window,
                                           gboolean        did_placement);
--- a/src/meta/keybindings.h
+++ b/src/meta/keybindings.h
@ -35,6 +35,13 @@ gboolean meta_keybindings_set_custom_handler (const gchar        *name,
 					      gpointer            user_data,
 					      GDestroyNotify      free_data);

+void meta_keybindings_switch_window (MetaDisplay    *display,
+				     MetaScreen     *screen,
+				     MetaWindow     *event_window,
+                                     XIDeviceEvent  *event,
+				     MetaKeyBinding *binding);
+
+
 void     meta_screen_ungrab_all_keys (MetaScreen *screen, guint32 timestamp);
 gboolean meta_screen_grab_all_keys (MetaScreen *screen, guint32 timestamp);
 #endif
--- a/src/meta/meta-shaped-texture.h
+++ b/src/meta/meta-shaped-texture.h
@ -83,8 +83,6 @@ CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex);

 void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
                                           CoglTexture       *mask_texture);
-void meta_shaped_texture_set_input_shape_region (MetaShapedTexture *stex,
-                                                 cairo_region_t    *shape_region);

 void meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,
 					  cairo_region_t    *clip_region);
--- a/src/meta/prefs.h
+++ b/src/meta/prefs.h
@ -258,7 +258,6 @@ void     meta_prefs_set_ignore_request_hide_titlebar (gboolean whether);
 * @META_KEYBINDING_ACTION_MOVE_TO_SIDE_W: FILLME 
 * @META_KEYBINDING_ACTION_MOVE_TO_CENTER: FILLME 
 * @META_KEYBINDING_ACTION_OVERLAY_KEY: FILLME 
- * @META_KEYBINDING_ACTION_ALWAYS_ON_TOP: FILLME 
 * @META_KEYBINDING_ACTION_LAST: FILLME 
 */
 /* XXX FIXME This should be x-macroed, but isn't yet because it would be
@ -352,7 +351,6 @@ typedef enum _MetaKeyBindingAction
  META_KEYBINDING_ACTION_MOVE_TO_CENTER,
  META_KEYBINDING_ACTION_OVERLAY_KEY,
  META_KEYBINDING_ACTION_ISO_NEXT_GROUP,
-  META_KEYBINDING_ACTION_ALWAYS_ON_TOP,

  META_KEYBINDING_ACTION_LAST
 } MetaKeyBindingAction;
--- a/src/meta/window.h
+++ b/src/meta/window.h
@ -100,17 +100,7 @@ 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_input_rect (const MetaWindow *window, MetaRectangle *rect);
-
-void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
-void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect) G_GNUC_DEPRECATED;
-
-void meta_window_client_rect_to_frame_rect (MetaWindow    *window,
-                                            MetaRectangle *client_rect,
-                                            MetaRectangle *frame_rect);
-void meta_window_frame_rect_to_client_rect (MetaWindow    *window,
-                                            MetaRectangle *frame_rect,
-                                            MetaRectangle *client_rect);
-
+void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect);
 MetaScreen *meta_window_get_screen (MetaWindow *window);
 MetaDisplay *meta_window_get_display (MetaWindow *window);
 Window meta_window_get_xwindow (MetaWindow *window);
@ -150,7 +140,8 @@ void meta_window_unset_demands_attention (MetaWindow *window);
 const char* meta_window_get_startup_id (MetaWindow *window);
 void meta_window_change_workspace_by_index (MetaWindow *window,
                                            gint        space_index,
-                                            gboolean    append);
+                                            gboolean    append,
+                                            guint32     timestamp);
 void meta_window_change_workspace          (MetaWindow  *window,
                                            MetaWorkspace *workspace);
 GObject *meta_window_get_compositor_private (MetaWindow *window);
Author	SHA1	Message	Date
Florian Müllner	489ad9e978	Bump version to 3.10.4 Update NEWS.	2014-02-19 19:40:16 +01:00
Ryan Lortie	a3f3c60a6c	idle-monitor: avoid XSyncBadAlarm X error If we fail to find the IDLETIME counter, then the alarm variable will be uninitialised. Most code paths are careful to check this before submitting XSync calls, but there is one check missing. https://bugzilla.gnome.org/show_bug.cgi?id=724364	2014-02-15 13:14:29 +01:00
Giovanni Campagna	b39ef6a961	window: don't set _NET_WM_FULLSCREEN_MONITORS to bogus values Prior to the DisplayConfig merge, we would set _NET_WM_FULLSCREEN_MONITORS to (unsigned)-1 when unset. After that, we would have invalid reads inside meta_screen_monitor_index_to_xinerama_index() (called with -1). The way I read the specification, the proper way to indicate that the window is back to fullscreen on all monitors is to remove the property, so do that. Also, add an assertion that meta_screne_monitor_index_to_xinerama_index() is doing the right thing. https://bugzilla.gnome.org/show_bug.cgi?id=724258	2014-02-13 13:19:32 +01:00
Khaled Hosny	14dbe8ac8a	Update Arabic translation	2014-02-06 15:37:28 +02:00
Shankar Prasad	d158e19133	updated kn.po	2014-02-05 16:27:18 +05:30
Robert Ancell	c2dadecab8	xrandr: Use specified output property name for backlight control Backlight controls are set using the "BACKLIGHT" XRANDR output property. This should be "Backlight" according to the XRANDR spec [1]. Some drivers (Intel) export both properties and some only the specified property (nvidia). Users of drivers that only export the specified property cannot change their backlight using XRANDR. [1] http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt section 9.1 https://bugzilla.gnome.org/show_bug.cgi?id=723606	2014-02-05 09:48:01 +01:00
Adel Gadllah	099059c930	monitorManager: Fix logic bug in make_logical_config The code that prevents the creation of multiple MonitorInfos for clones wasn't working due to using the wrong index when getting the already created info so fix that to use the correct one. https://bugzilla.gnome.org/show_bug.cgi?id=710610	2014-02-02 15:16:04 +01:00
Adel Gadllah	24f5b37d6b	window_actor: Remove the frame_messages timeout in destroy Otherwise it might fire off later and cause a crash. https://bugzilla.gnome.org/show_bug.cgi?id=723468	2014-02-02 15:16:02 +01:00
Adel Gadllah	2958b15a61	window-actor: Fix unobscured_region handling when computing paint volume We currently ignore the unobscured region when we have mapped clones in meta_window_actor_process_damage and meta_window_actor_damage_all but use it unconditionally when computing the paint volume. This is wrong. We should ignore it there as well or we will end up with empty clones if the cloned window is completly obscured (like the tray icons in gnome-shell). https://bugzilla.gnome.org/show_bug.cgi?id=721596	2014-01-31 15:27:20 +01:00
Jasper St. Pierre	fd263d8457	window-actor: Fix optimization in get_paint_volume We need to clip the paint volume to the unobscured region, not the other way around... https://bugzilla.gnome.org/show_bug.cgi?id=720630	2014-01-31 15:27:04 +01:00
Florian Müllner	47758f0f5f	window: Add "skip-taskbar" property We currently only have a method to query the skip-taskbar hint. Add a corresponding property to allow listening for change notifications. https://bugzilla.gnome.org/show_bug.cgi?id=723307	2014-01-31 10:09:36 +01:00
Jasper St. Pierre	477eb1afed	constraints: CSD windows need to have their titlebar kept onscreen too GTK+ CSD windows are considered undecorated by the code, so we should not force ourselves to only run on decorated windows. https://bugzilla.gnome.org/show_bug.cgi?id=719772	2014-01-29 12:26:41 -05:00
Florian Müllner	3b8b05518c	Bump version to 3.10.3 Update NEWS.	2014-01-15 15:21:39 +01:00
Daniel Drake	0bd30696b1	window: don't grab server during calc_showing This grab was added in commit `caf43a123f` https://bugzilla.gnome.org/show_bug.cgi?id=381127 to minimize window flickering when switching workspaces. While this grab is held, some signals are emitted to the shell, which can lead to deadlocks (reproduced under Mali binary OpenGLESv2 drivers). Now that we are a compositing window manager, we do not have to worry about flickers, this grab should no longer be necessary. https://bugzilla.gnome.org/show_bug.cgi?id=721709	2014-01-07 14:26:35 -06:00
Daniel Drake	fb4e9d2232	Reduce server grabs during window creation Remove some obvious server grabs from the window creation codepath, also ones that are taken at startup. During startup, there is no need to grab: we install the event handlers before querying for the already-existing windows, so there is no danger that we will 'lose' some window. We might try to create a window twice (if it comes back in the original query and then we get an event for it) but the code is already protected against such conditions. When windows are created later, we also do not need grabs, we just need appropriate error checking as the window may be destroyed at any time (or it may have already been destroyed). The stack tracker is unaffected here - as it listens to CreateNotify and DestroyNotify events and responds directly, the internal stack representation will always be consistent even if the window goes away while we are processing MapRequest or similar. https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:16:31 -06:00
Daniel Drake	e072295395	meta_window_new: clean up error handling The return code of XGetWindowAttributes() indicates whether an error was encountered or not. There is no need to specifically check the error trap. The trap around XAddToSaveSet() was superfluous. We have a global error trap to ignore any errors here, and there is no need to XSync() as GDK will later ignore the error asynchronously if one is raised. Also move common error exit path to an error label. https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:16:23 -06:00
Daniel Drake	1066c19e67	screen: use stack tracker for initial window query In meta_screen_manage_all_windows() we can use our own stack tracker to get the list of windows - no need to query X again. A copy is needed because the stack gets modified as part of the loop. Specifically, meta_stack_tracker_get_stack() at this time returns the predicted stack, and meta_window_new() performs a few operations (e.g. framing) which cause immediate changes to the predicted stack. https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:16:15 -06:00
Daniel Drake	d654c93ed2	frame: remove unnecessary server grab meta_window_ensure_frame() creates its own grab and has a comment claiming that it must be called under a grab too. But the reasoning given in the comment does not seem relevant here. We only frame non-override-redirect windows, so we are creating the frame in response to MapRequest. There is no way that the child could receive a MapNotify at this point, since that only happens much later, once we go through the CALC_SHOWING queue and call XMapWindow() from meta_window_show(). Remove the unnecessary grab. https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:16:07 -06:00
Daniel Drake	7d1611f666	Discourage server grabs Server grabs are not as evil as you might expect, but there is agreement in that their usage should be limited. Server grabs can cause things to go rather wrong when mutter emits a signal while it has grabbed the server. If the receiver of that signal waits for a synchronous action performed by another client, then you have a deadlock. This happens with Mali binary GLESv2 drivers :( https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:15:58 -06:00
Daniel Drake	2579e48f21	Remove meta_window_new_with_attrs The compositor code used to handle X windows that didn't have a corresponding MetaWindow (see commit `d538690b`), which is why the attribute query is separated. As that doesn't happen any more, we can clean up. No functional changes. Suggested by Owen Taylor. https://bugzilla.gnome.org/show_bug.cgi?id=721345	2014-01-06 16:15:50 -06:00
Owen W. Taylor	7278f9bd6b	display: Don't leave focus on a window we are unmanaging when sending WM_TAKE_FOCUS When we move focus elsewhere when unmanaging a window, we need to move the focus, so if the target is globally active, move the focus to the no-focus-window in anticipation that the focus will normally get moved to the right window when the target window responds to WM_TAKE_FOCUS. If the window doesn't respond to WM_TAKE_FOCUS, then focus will be left on the no-focus-window, but there's no way to distinguish whether the app will respond or not. https://bugzilla.gnome.org/show_bug.cgi?id=711618	2013-12-24 11:30:04 -05:00
Owen W. Taylor	da55e27c3b	Be willing to unfocus the grab window when we are unmanaging it When we are unmanaging the grab window, we /need/ to unfocus it, so we shouldn't bail out early from meta_window_focus(). https://bugzilla.gnome.org/show_bug.cgi?id=711618	2013-12-24 11:29:53 -05:00
Owen W. Taylor	f3196e356b	Fix problems with focus tracking When a client spontaneously focuses their window, perhaps in response to WM_TAKE_FOCUS we'll get a FocusOut/FocusIn pair with same serial. Updating display->focus_serial in response to FocusOut then was causing us to ignore FocusIn and think that the focus was not on any window. We need to distinguish this spontaneous case from the case where we set the focus ourselves - when we set the focus ourselves, we're careful to combine the SetFocus with a property change so that we know definitively what focus events we have already accounted for. https://bugzilla.gnome.org/show_bug.cgi?id=720558	2013-12-18 09:41:49 -05:00
Jasper St. Pierre	491b17af19	display: Fix checks for KeyPress/ButtonPress https://bugzilla.gnome.org/show_bug.cgi?id=720545	2013-12-16 15:13:25 -05:00
Owen W. Taylor	01e0eaf1fc	MetaWindowGroup: fix paint volume In the past, MetaWindowGroup was allocated the size of the screen and painted the size of the screen because it contained the screen background, but now we also have the "top window group" which contains only popup windows, so the allocation doesn't properly reflect the paint bounds of the window group. Compute the paint bounds accurately from the children. https://bugzilla.gnome.org/show_bug.cgi?id=719669	2013-12-09 15:29:33 -05:00
甘露(Gan Lu)	f679ce7017	Update Chinese simplified translation	2013-12-07 15:03:56 +08:00
Jasper St. Pierre	844f4e9348	display: Don't focus the no-focus-window when sending WM_TAKE_FOCUS to a globally active window Clients like on-screen keyboards try not to take focus when the user clicks on their window by setting the Input hint to false. However, due to GTK+ and GDK bugs, the public API for setting the Input hint to false don't remove WM_TAKE_FOCUS from WM_PROTOCOLS, unintentionally putting them into Globally Active mode. These clients also expect that since they don't want to take focus, they want the focus to remain on the existing window. In this case, for clients like on-screen keyboards, it's so they can send synthesized keyboard events to the focused window. https://bugzilla.gnome.org/show_bug.cgi?id=710296	2013-12-04 11:09:57 -05:00
Marc-André Lureau	5cfc1461a1	xrandr: use "hotplug_mode_update" property Use the "hotplug_mode_update" connector property indicating that the screen settings should be updated: get a new preferred mode on hotplug events to handle dynamic guest resizing (where you resize the host window and the guest resizes with it). https://bugzilla.gnome.org/show_bug.cgi?id=711216	2013-11-14 14:57:23 +01:00
Florian Müllner	323e1aba59	Bump version to 3.10.2 Update NEWS.	2013-11-14 12:28:08 +00:00
Lionel Landwerlin	992b97d565	window: don't ignore resize button release event for move/resize actions https://bugzilla.gnome.org/show_bug.cgi?id=710251	2013-11-04 13:53:21 +00:00
Reinout van Schouwen	da5b9f3255	Updated Dutch translation	2013-10-25 00:24:34 +02:00
Efstathios Iosifidis	6c1eff0dc2	Updated Greek translation	2013-10-24 11:05:09 +03:00
Florian Müllner	1ff986e227	Bump version to 3.10.1.1 Update NEWS.	2013-10-15 23:42:40 +02:00
Giovanni Campagna	b86a289ee3	monitor-config: prevent assert that at least one output is connected Apparently some connector technologies don't distinguish between on and off, and there might be valid use cases for running without any connected monitor. In that case, just avoid any configuration at all. https://bugzilla.gnome.org/show_bug.cgi?id=709009	2013-10-15 23:22:05 +02:00