Bump version to 3.2.1

Update NEWS

.gitignore

@@ -40,10 +40,11 @@ stamp-h1
 stamp-it
 .intltool-merge-cache
 POTFILES
+po/*.pot
 50-metacity-desktop-key.xml
 50-metacity-key.xml
 inlinepixbufs.h
-libmutter-private.pc
+libmutter.pc
 mutter
 mutter-theme-viewer
 mutter.desktop
@@ -56,10 +57,13 @@ mutter-mag
 mutter-message
 mutter-window-demo
 focus-window
+test-attached
 test-gravity
 test-resizing
 test-size-hints
-wm-tester
+# We can't say just "wm-tester" here or it will ignore the directory
+# rather than the binary
+src/wm-tester/wm-tester
 INSTALL
 mkinstalldirs
 src/mutter-enum-types.[ch]

NEWS

@@ -1,3 +1,964 @@
+3.2.1
+=====
+* Allow keyboard window switching (alt-Tab) during drag-and-drop
+  [Matthias, #660457]
+* Don't add invisible resize borders to fullscreen windows
+  [Jasper, Owen; #659854]
+* Fix crash when toplevel windows were set to unexpected window types
+  [Owen; #599988]
+* Correct problems with windows moving when restarting or switching
+  window managers [Jasper; #660848]
+* Fix interaction of tiled windows with multiple monitors
+  [Rui; #642580, #657519]
+* Make meta_display_unmanage_screen() public [Jasper; #660848]
+* Fix problem with turning off window decorations on the fly [Rui; #660773]
+* Fix spurious assertion failures with themes such as Nodoka [Sandro; #661286]
+* Misc bug fixes [Adel, Jasper, Rui; #660464, #660854, #662053]
+
+Contributors:
+ Matthias Clasen, Sandro Mani, Rui Matos, Jasper St. Pierre, Owen Taylor
+
+Translations:
+ Tommi Vainikainen [fi], Miroslav Nikolić [sr, sr@latin], Muhammet Kara [tr]
+
+3.2.0
+=====
+* Fix _NET_WM_FRAME_EXTENTS not to include invisible borders [Jasper; #659848]
+* Fix application-specified window placement (-geometry) for
+  invisible borders [Jasper; #659848]
+
+Contributors:
+ Jasper St. Pierre
+
+Translations:
+ Nilamdyuti Goswami [as], Carles Ferrando [ca@valencia], Petr Kovar [cz],
+ Mario Blättermann [de], Inaki Larranaga [eu], Gabor Kelemen [hu],
+ Takayoshi Okano [ja], Changwoo Ryu [ko], Djavan Fagundes [pt_BR]
+
+3.1.92
+======
+* Fix bug with unredirecting full-screen windows on multi-monitor -
+  notably affected gnome-screensaver [Adel; #657869]
+* Disable top resizing of attached dialogs [Jasper; #657795]
+* Code cleanup [Jasper, Rui]
+* Misc bug fixes [Adel, Florian, Jasper, Rui;
+  #658069, #659266, #659523, #659477]
+
+Contributors:
+ Adel Gadllah, Rui Matos, Florian Müllner, Jasper St. Pierre
+
+Translations:
+ Joan Duran [ca], Joe Hansen [dk], Jiro Matsuzawa [ja], Daniel Korostil [uk]
+
+3.1.91.1
+========
+* Fix problem where certain application updates would get lost [#657071, Owen]
+* Fix a problem where after resuming from the screensaver, things got
+  slow [#658228, Jasper, Adel]
+* When a monitor is plugged or unplugged, keep existing windows on their
+  current monitor [#645408, Alex]
+* Remove 'Mutter' title from alerts such as
+  "The widow '%s' is not responding" [Matthias]
+* Remove pointless warning:
+   Received a _NET_WM_MOVERESIZE message for %s; these
+   messages lack timestamps and therefore suck.
+  [Rui]
+* Misc bug fixes [Jasper]
+* Build fixes [Javier]
+
+Contributors:
+ Matthias Clasen, Adel Gadllah, Javier Jardón, Alex Larsson, Rui Matos,
+ Jasper St. Pierre, Owen Taylor
+
+Translations:
+ Ihar Hrachyshka [be], Bruce Cowan [en_FB], Daniel Mustieles [es],
+ Claude Paroz [fr], Andika Triwidada [id], Luca Ferretti [it],
+ Rudolfs Mazurs [lt], Piotr Drąg [pl], Duarte Loreto [pt],
+ Matej Urbančič [sl], Tirumurti Vasudevan [ta], Chao-Hsiung Liao [zh_KH, TW]
+
+3.1.90.1
+========
+* Fix crash when no windows are open [Adel; #657692]
+* Fix annotations for new strictness in gobject-introspection [Jasper, Owen]
+* Fix some errors with rounded frame drawing [Jasper; #657661]
+
+Contributors:
+ Adel Gadllah, Jasper St. Pierre, Owen Taylor
+
+3.1.90
+======
+* Extend the draggable portion of window borders outside the visible frame
+  for easy resizing with thin borders. (New draggable_border_width GConf key
+  controls the total width of visible and invisible borders.)
+  [Jasper; #644930]
+* Draw rounded window corners with antialising [Jasper; #628195]
+* Unredirect override-redirect fullscreen windows, such as full-screen
+  3D games to avoid any performance impact [Adel; #597014]
+* Add :resizable and :above properties to MetaWindow. [Tim; #653858]
+* Add MUTTER_DISABLE_FALLBACK_COLOR environment variable to allow visualizing
+  places where a color is missing for gtk:custom() colors [Florian; #656112]
+* Don't attach modal dialogs to special windows like the desktop;
+  add meta_window_is_attached_dialog() [Dan, #646761]
+* Make MetaBackgroundActor public, allow creating multiple instances
+  (sharing a common texture), and add a :dim-factor property
+  [Rui, Owen; #656433]
+* Fix attached dialogs to not be resizable from the top and to be
+  position correctly [Jasper; #656619]
+* Misc bug fixes [Jasper, Rui; #656335, #657583]
+
+Contributors:
+ Tim Cuthbertson, Adel Gadllah, Rui Matos, Florian Müllner, Jasper St. Pierre,
+ Owen Taylor, Dan Winship
+
+Translations:
+ Alexander Shopov [bg], Jorge González [es], Fran Dieguez [gl],
+ Yaron Shahrabani [he], Takeshi Aihana [ja], Aurimas Černius [lt],
+ Kjartan Maraas [nb], A S Alam [pa], Yuri Kozlov [ru], Daniel Nylander [se],
+ Theppitak Karoonboonyanan [th], Abduxukur Abdurixit [ug], Aron Xu [zh_CN]
+
+3.1.4
+=====
+* Use better, much more subtle shadow definitions [Jakub; #649374]
+* Add the ability to use named GTK+ colors in theme files as
+  gtk:custom(name,fallback) [Florian; #648709]
+* Port from GdkColor to GdkRGBA and from GtkStyle to GtkStyleContext
+  [Florian; #650586]
+* Try to fix window bindings using the Super key [Owen; #624869]
+* Update to using more modern Cogl and Clutter APIs
+  [Adel, Emmanuele, Neil; #654551 #654729 #654730 #655064]
+* Fix for srcdir != builddir builds [Thierry; #624910]
+* Make handling of focus appearance for attached dialogs more robust
+  [Dan; #647712]
+* Misc bug fixes
+  [Dan, Florian, Jasper, Owen, Rui; #642957 #649374 #650661 #654489 #654539]
+
+Contributors:
+ Emmanuele Bassi, Adel Gadllah, Rui Matos, Florian Müllner, Neil Roberts,
+ Jasper St. Pierre, Jakub Steiner, Owen Taylor
+
+Translations:
+ Ihar Hrachyshka [be], Jorge González, Daniel Mustieles [es],
+ Fran Dieguez [gl], Yaron Shahrabani [he], Takeshi Aihana [ja],
+ Kjartan Maraas [nb], Rudolfs Mazurs [lv], Matej Urbančič [sl],
+ Abduxukur Abdurixit [ug], Nguyễn Thái Ngọc Duy [vi]
+
+3.1.3.1
+=======
+* Back API version down to "3.0" - the change to Meta-3.1.gir
+  was unintentional [Owen]
+
+Translations:
+ Yaron Shahrabani [he], Kjartan Maraas [nb], Muhammet Kara [tr]
+
+3.1.3
+=====
+* Support dark window theme variants for windows with a dark
+  widget theme; this is selected by the _GTK_THEME_VARIANT
+  property [Florian, #645355]
+* Don't draw a shadow under windows with an alpha-channel - this
+  fixes transparency for GNOME Terminal [Owen, Jasper; #635268]
+* Add a MetaWindow:wm-class property for notification [Jasper; #649315]
+* Add a MetaWindow:minimized property for notification [Florian]
+* Fix handing of unusual window shapes that Wine was setting
+  causing some applications to draw wrong [Jasper; #627880]
+* Improve replacing another compositor and being replaced:
+  release compositor selection in the right order and wait for
+  compositors that get it wrong. [Colin, Owen; #653121]
+* Remove behavior where left clicking on a window border with
+  the titlebar offscreen gave the window menu [Florian; #652369]
+* Don't set the global default textdomain, since Mutter is
+  a library as well as an application [Dan; #649202]
+* Exit with the right (success or failure) exit status [Dan]
+* Code cleanup [Florian]
+* Miscellaneous bug fixes [Owen; #649114, #652507]
+
+Contributors:
+ Florian Müllner, Jasper St. Pierre, Owen Taylor, Colin Walters, Dan Winship
+
+Translations:
+ Ihar Hrachyshka [be], Daniel Mustieles [es], Yaron Shahrabani [he],
+ Carles Ferrando [ca@valencia], Takeshi Aihana [ja], Fran Diéguez [gl],
+ Matej Urbančič [sl], Miroslav Nikolic [sr], Muhammet Kara [tr],
+ Daniel Korostil [uk]
+
+3.0.2.1
+=======
+* When saving the session, use the "program name" rather than
+  harcoding mutter, fixing session saving for gnome-shell [Matthias]
+  https://bugzilla.gnome.org/show_bug.cgi?id=648828
+
+Contributors:
+ Matthias Clasen
+
+3.0.2
+=====
+
+* Fix a crash when running without XKB support [Adam]
+  https://bugzilla.gnome.org/show_bug.cgi?id=647777
+* Fix smallish memory leaks [Colin]
+  https://bugzilla.gnome.org/show_bug.cgi?id=649500
+  https://bugzilla.gnome.org/show_bug.cgi?id=649504
+* Ignore mirrored monitors when listing monitors, fixing
+  drag-and-drop problems in GNOME Shell [Owen]
+  https://bugzilla.gnome.org/show_bug.cgi?id=649299
+* Don't allow side-by-side tiling of non-maximizable windows
+  like dialogs and utility windows [Dan]
+* Fix interaction of _NET_WM_WINDOW_OPACITY with window effects,
+  making it work again with GNOME Shell
+  https://bugzilla.gnome.org/show_bug.cgi?id=648613
+
+Contributors:
+ Adam Jackson, Colin Walters, Dan Winship
+
+Translations:
+ Abduxukur Abdurixit [ug]
+
+3.0.1
+=====
+
+* If WM_CLIENT_MACHINE isn't set, don't assume a window is remote;
+  fixes behavior of Fox toolkit applications under GNOME Shell.
+  https://bugzilla.gnome.org/show_bug.cgi?id=647662 [Colin]
+* Fix cases where windows could get stuck drawing as focused after
+  an attached modal dialog was closed. [Dan]
+  https://bugzilla.gnome.org/show_bug.cgi?id=647613
+* Fix a bug where a window that is too big to be tiled side-by-side
+  would behave strangely when using the gesture of dragging to
+  the top to maximize. [Florian]
+
+Contributors:
+ Florian Müllner, Colin Walters, Dan Winship
+
+Translations:
+ Amitakhya Phukan [as], Kristjan Schmidt [eo], Muhammet Kara [tr]
+
+3.0.0
+=====
+
+* Avoid crashing when you have a single window and try to move it between
+  workspaces. [Dan]
+  https://bugzilla.gnome.org/show_bug.cgi?id=642957
+
+Contributors:
+ Dan Winship
+
+Translations:
+ Jordi Serratosa [ca], Petr Kovar [cz], Ask H. Larsen [da], Bruce Cowan [en_GB],
+ Inaki Larranaga Murgoitio [eu], Gabor Kelemen [hu], Dirgita [id], Shankar Prasad [kn],
+ Changwoo Ryu [ko], Wouter Bolsterlee [nl], Duarte Loreto [pt],
+ Antonio Fernandes C. Neto, Rodrigo Padula de Oliveira [pt_BR], T. Vasudevan [ta],
+ Nguyễn Thái Ngọc Duy [vi], Chao-Hsiung Liao [zh_HK, zh_TW]
+
+2.91.93
+=======
+
+* Fix bug where, when a monitor was hot-plugged, all workspaces
+  would collapse to a single workspace. (There are still issues
+  when a secondary monitor is hot-plugged to the left of the
+  primary monitor.) [Alex]
+  https://bugzilla.gnome.org/show_bug.cgi?id=645408)
+
+* Fix a crash for the cycle_group action [Jasper]
+  https://bugzilla.gnome.org/show_bug.cgi?id=645843
+
+* Fix misdrawing of window shadows on some focus changes [Dan]
+  https://bugzilla.gnome.org/show_bug.cgi?id=636904
+
+* Export meta_get_replace_current_wm() to allow fixing a
+  GNOME Shell bug with --replace [Colin]
+  https://bugzilla.gnome.org/show_bug.cgi?id=645590
+
+Contributors:
+ Alexander Larsson, Jasper St. Pierre, Colin Walters, Dan Winship
+
+Translations:
+ Alexander Shopov [bg], Christian Kirbach [de], Yaron Shahrabani [he],
+ Rudolfs Mazurs [lv], A S Alam [pa], Yuri Myasoedov [ru], Daniel Nylander [se],
+ Abduxukur Abdurixit [ug], Daniel Korostil [uj], Aron Xu [zh_CN]
+
+2.91.92
+=======
+
+ * Add a workspaces_only_on_primary preferences. When set, this makes
+   workspaces switching only apply to windows on the primary monitor,
+   while windows on other monitors are unaffected.
+ * Export API for monitor handling [Alex]
+    MetaScreen::monitors-changed signal
+    meta_screen_get_primary_monitor()
+    meta_window_is_on_primary_monitor()
+    meta_window_get_monitor()
+    MetaWindow::window-entered-monitor, <etaWindow::window-left-monitor
+    meta_window_move_to_monitor() [Florian]
+ * Behavior improvemnts for attached modal dialogs:
+   - Allow dragging dragging on the titlebar to move the  parent ["Ron"]
+   - Allow resizing [Florian]
+   - Constrain to be on the current monitor [Florian]
+ * Don't turn on XSMP autorestart [Colin]
+ * Combine libmutter-wm and libmutter-private into a single libmutter
+   [Frédéric]
+ * Export methods to move and resize windows [Jeffery]
+   meta_window_move(), meta_window_resize(), meta_window_move_frame()
+ * Add a MUTTER_WM_CLASS_FILTER environment variable to allow existing
+   windows to be ignored when performance testing. [Owen]
+ * Add a new compositor-based flash for visual bell [Dan]
+ * Fix bug where application specified values for properties like
+   "skip taskbar" were sometimes ignored [Dan]
+ * Bug fixes [Dan, Florian, Giovanni, Jasper, Owen]
+ * Build fixes [Rico]
+
+Contributors:
+ Giovanni Campagna, Florian Müllner, Alexander Larsson, Jeffery Olson,
+ Frédéric Péters, Owen Taylor, Jasper St. Pierre, Rico Tzschichholz,
+ "Ron", Colin Walters, Dan Winship
+
+Translations:
+ Khaled Hosny [ar], David Planella [ca], Mario Blättermann [de],
+ Bruce Cowan [en_GB], Jorge González, Daniel Mustieles [es], Ivar Smolin [et],
+ Bruno Brouard [fr], Fran Diéguez [gl], Yaron Shahrabani [he],
+ Gabor Kelemen [hu], Luca Ferretti [it], Kjartan Maraas [nb], Piotr Drąg [pl],
+ Duarte Loreto [pt], Lucian Adrian Grijincu, Adi Roiban [ro],
+ Yuri Myasoedov [ru], Matej Urbančič [sl], Daniel Korostil [uk]
+
+Bugs fixed:
+ 624360 window shows up in when pressing alt+tab, but skip_taskbar_hint is set to True
+ 631308 Dialogs attached to parent sometimes extend out of the screen
+ 638674 [PATCH] Allow moving attached dialogs
+ 639765 a11y: visual alert only works per-window, not screen
+ 641975 Pre-_NET_WM_ICONs look corrupted
+ 642355 patch to expose MetaWindow.move(), .resize() and add/expose .move_frame() to javascript
+ 642787 MetaWindowActor has a dangling reference to its MetaWindow
+ 643597 Attached dialogs not resizable, even by app request
+ 644188 Broken build of 2.91.91
+ 644252 Add MUTTER_WM_CLASS_FILTER environment variable
+ 644529 session: Change XSMP restart style to Never
+ 644565 Kill libmutter-private ?
+ 644961 auto-tiling makes moving already-tiled windows hard
+ 645224 Translation message doesn't make much sense
+ 645247 Methods of Meta.Rectangle are missing annotations.
+ 645455 tiling: Fix dragging windows free from edge-tiling
+
+2.91.91
+=======
+
+ * Build a libmutter-wm that contains all of the logic and that
+   can be linked to to create custom executables. The mutter executable
+   becomes a small stub linked to this library [Dan]
+ * Move installed headers files into a meta/ subdirectory instead
+   of polluting the toplevel namespace [Dan]
+ * Remove various unused complications: [Dan]
+   - Ability to set the set of plugins via GConf
+   - Plugin 'params'
+   - meta_restart() and "mutter-message restart"
+ * Don't exit when we are requested to exit via XSMP, assume we'll be
+   killed along with the X server; this avoids visual artifacts from
+   unmanaging windows when logging out [Colin]
+ * Build fixes [Dan, Jani, Jeff]
+
+Contributors:
+ Jani Monoses, Jeff Olson, Colin Walters, Dan Winship
+
+Translations:
+ Bruno Brouard [fr], Kjartan Maraas [nb], Daniel Korostil [uk]
+
+Bugs fixed:
+ 643194 patch: expose new meta_window_get_window_rect
+ 643437 Don't exit on XSMP request
+ 643959 Make mutter into a library
+
+2.91.90
+=======
+
+ * Change <Alt>Above_Tab from being a cycle_group binding to
+   a switch_group binding [Rui]
+ * Make plugin-loading failure fatal [Colin]
+ * Add 'position-changed' signal to MetaWindowActor [Owen]
+ * When 'live_hidden_previews' is enabled, position hidden windows
+   to allow the creation of workspace previews [Owen]
+ * Fix bug with opacity of MetaBackgroundActor
+
+Contributors:
+  Rui Matos, Owen Taylor, Colin Walters
+
+Translations:
+  Jorge González [es],  Mattias Põldaru [et], Sweta Kothari [gu], Luca Ferretti [it],
+  Changwoo Ryu [ko], Nguyễn Thái Ngọc Duy [vi]
+
+Bugs fixed:
+  641309 When live_hidden_previews is set, force placement for hidden windows
+  641310 MetaWindowActor: Add a 'positioned-changed' signal
+  641979 Visual glitch on workspace selector closing overview mode
+  641384 Make plugin loading failure fatal
+  642426 Don't pass handled key events to GTK+
+
+2.91.6
+======
+
+ * Add meta_screen_override_window_layout() to let a plugin set the workspace
+   layout [Owen]
+ * Add a 'size-changed' signal to MetaWindowActor [Florian]
+ * Add meta_window_actor_is_destroyed() [Adel]
+ * Fix problems with window tile previews when cancelling a move [Florian]
+ * Port theme elements that use GTK+ drawing to use GtkStyleContext instead
+   of the deprecated GtkStyle. [Florian]
+ * Fix compiler warnings that were causing compilation failures [Jasper, Owen]
+ * Misc bug fixes [Gabor, Jasper, Owen, Rui]
+
+Contributors:
+ Adel Gadllah, Gabor Kelemen, Rui Matos, Florian Müllner, Jasper St. Pierre,
+ Owen Taylor
+
+Translations:
+ Khaled Hosny [ar], Alexander Shopov [bg], Petr Kovar [cz], Fran Diéguez [gl],
+ Marios Zindilis [gr], Gabor Kelemen [hu], Kjartan Maraas [nb], A S Alam [pa],
+ Daniel Nylander [se], Chao-Hsiung Liao [zh_HK, zh_TW]
+
+2.91.5
+======
+
+* Add a Above_Tab key symbol that can be used in key bindings to mean
+  the key above the Tab key. This is now the default binding for
+  cycle_group in both Mutter and Metacity. [Owen]
+* Add new frame states for tiled-on-the-left and tiled-on-the-right [Florian]
+* Add new background drawing functions that can be defined in a theme
+  for single buttons. [Florian]
+* Draw the right button backgrounds for all custom button layouts [Florian]
+* Remove vestigal --composite/--no-composite command line options [Nickolas]
+* Fix building on GLES [Andreas]
+* Code cleanups [Adel, Owen]
+
+Contributors:
+ Adel Gadllah, Nickolas Lloyd, Andreas Mueller, Florian Müllner, Owen Taylor
+
+Translations:
+ Mattias Põldaru, Ivar Smolin [et], Gheyret T. Kenji [ug]
+
+Bugs fixed:
+ 613124 Invalid visibility-related asserts in MutterWindow
+ 626875 Fix handling of --composite and --no-composite command line options
+ 629282 [PATCH] Fix errors building for gles-systems (clutter-eglx)
+ 635569 Add an "Above_Tab" pseudo-keysym
+ 635683 add specific button background for single button (per side) case
+ 635686 button backgrounds broken with rtl locales
+ 637330 [PATCH] theme: Add tiled_left/tiled_right frame states
+
+2.91.4
+======
+
+* Update for GTK+ 3 changes [Benjamin, Colin, Emmanuele, Florian]
+* Support maximizing a window by dragging to the top of the screen
+  in the same way you can tile by dragging to the edge of the screen.
+  [Ray, Florian]
+* Misc bug fixes [Milan, Owen]
+
+Contributors:
+ Emmanuele Bassi, Milan Bouchet-Valat, Florian Müllner, Benjamin Otte,
+ Ray Strode, Owen Taylor, Colin Walters
+
+Translations:
+ Matej Urbančič [sl], Nguyễn Thái Ngọc Duy [vi]
+
+Bugs fixed:
+ 630548 gnome-shell could auto-maximize windows when dragged to top edge of screen
+ 636083 workspace: Consider text direction when switching
+ 636301 Port testgradient example to GTK3
+ 636302 Replace some GDK X11 calls with future-proof ones
+ 636491 valgrind: meta_window_shape_new (meta-window-shape.c:79)
+ 637802 ui: Adapt to GDK API changes
+
+2.91.3
+======
+
+* Better shadows: [Owen]
+   - Shadows can be different for different window types and focus states
+   - Shadows are larger by default, especially for the currently active
+     window
+   - Shadows for attached modal dialogs and menus are drawn not to
+     overlap the attachment point.
+   - Shadows follow the shape of shaped windows
+ * Optimization: [Owen]
+   - Avoid repainting in situations when windows are potentially restacked
+     but aren't actually restacked.
+   - Pay attention to partial stage repaints in obscured window calculations
+   - Better optimization of painting obscured shadows; turn off shadows
+     for maximized windows.
+   - Move background repainting into Mutter; doing it here rather than
+     in plugins allows not painting obscured parts of the background.
+ * A new frame type 'attached' is added for attached modal dialogs
+   and can be referenced in theme files with a theme version of 3.2.
+ * Fix updating key bindings when the keyboard layout changes
+   [Derek, Owen, Thomas]
+ * Bug fixes [Adel, Florian]
+ * Build fixes [Dan Williams, Diego, Javier, Owen]
+
+Contributors:
+ Adel Gadllah, Javier Jardón, Florian Müllner, Derek Poon, Owen Taylor,
+ Thomas Thurman, Diego Escalante Urrelo, Dan Williams
+
+Translations:
+ Khaled Hosny [ar], Jorge González [es], Fran Diéguez [gl],
+ Yaron Shahrabani [he], Kjartan Maraas [nb], Gheyret T. Kenji [ug]
+
+Bugs fixed:
+ 634779 MetaWindowGroup: further optimize paints by using current scissor
+ 634833 Draw the root window background
+ 592382 improve shadow effect
+ 628199 Add antialising to arc and line drawing operations
+ 633002 meta-actor-window: Use G_UNLIKELY for TFP check
+ 634771 MetaStackTracker: Avoid queueing resync for obvious no-ops
+ 635421 Fix crash in check_needs_shadow
+ 635493 configure.in: it's git, not Subversion
+ 635528 configure.ac: move call to AM_GNU_GLIB_GETTEXT above cflags modification
+ 635575 meta-window-actor: remove unused meta_window_actor_get_shadow_bounds
+ 636083 workspace: Consider text direction when switching
+
+2.91.2
+======
+
+* Remove support for GTK+ 2 [Florian]
+* Adapt to deprecation of size_request deprecation in GTK+ [Matthias]
+* Include change from Metacity to fix confusion of mouse
+  tracking when double-clicking on title bar [Owen]
+* Fix bug with the the window menu getting stuck when you alt-Tab [Owen]
+
+Contributors:
+ Matthias Clasen, Florian Müllner, Owen Taylor
+
+Translations:
+ Petr Kovar [cz]
+
+Bugs fixed:
+ 633133 Remove compatibility for GTK+-2.0
+ 633352 prepare for the demise of size_request
+ 633398 Fix check for events on UI widgets
+ 633401 Fix warning from synthesized events with GdkDevice
+
+2.91.1
+======
+
+* Default build is now GTK+ 3 build
+* Mutter namespace prefix is removed, in favor of consistent
+  meta_ namespace prefixing [Owen]. Naming changes:
+    MutterWindow              => MetaWindowActor
+    mutter_get_windows        => meta_get_window_actors
+    mutter_plugin_get_windows => meta_plugin_get_window_actors
+* Add missing values in MetaKeyBindingAction - this fixes a problem where
+  key binding lookup wasn't working properly for some key bindings. [Dan]
+* Remove keysym parameter to meta_display_get_keybinding_action() - the
+  function expected the default keysym for the keycode to always be passed [Dan]
+* Clean up installed header files - in particular, theme-parser.h is merged
+  into a new public-only theme.h and private internals are moved to
+  theme-private.h.
+* Fix problems with antialiased rendering of themes [Brandon, Owen, Nickolas]
+* Fix problem with parsing color constants in themes [Jon, Owen]
+* Build fixes [Colin]
+* Miscellaneous bug fixes [Giovanni, Rico]
+
+Contributors:
+  Giovanni Campagna, Nickolas Lloyd, William Jon McCann, Owen Taylor,
+  Rico Tzschichholz, Colin Walters, Dan Winship, Brandon Wright
+
+Translations:
+  Fran Diéguez [gl], Yinghua Wang [zh_CN]
+
+Fixed bugs:
+ 628401 tint and line draw ops rendering issues
+ 628520 unfortunate namespacing
+ 631487 Fix drawing of <arc> theme elements
+ 632116 don't clobber gerrors
+ 632149 Fill in missing MetaKeyBindingAction values
+ 632155 meta_display_get_keybinding_action: remove keysym parameter
+ 632474 Remove MetaRegion
+ 632494 introspection: remove --allow-unprefixed
+
+2.91.0
+======
+
+ * Enable side-by-side tiling via a gesture of dragging to the left or right
+   edge of the screen. (enabled with an off-by-default GConf key) [Florian]
+ * Allow breaking out of maximization/tiling using a alt-middle-button window
+   resize [Owen, Florian]
+ * Add the ability to have modal dialogs attached to their parent window
+   (enabled with an off-by-default GConf key) [Maxim]
+ * Draw with Cairo rather than GDK [Florian, Benjamin]
+ * Add compatibility for changes in GTK+ 3
+   [Benjamin, Alban, Florian, Jasper, Matthias, Owen, Thierry]
+   - libmutter-private is now only installed for GTK+ 3 builds
+   - Theme parts of libmutter-private API are changed to take cairo_t
+     rather than GdkDrawable
+ * Update introspection build and annotations for new behavior of
+   g-ir-scanner [Colin]
+ * Fix bug that caused window menu options not to work [Owen]
+ * Fix misbehavior of Wine windows [Owen, Alban]
+ * Fix crashes from missing error traps [Adel]
+ * Build fixes [Colin, Florian, Owen, Rob, Tomas]
+ * Misc bug fixes [Adel, Jon, Owen, Nickolas, Tomas]
+ * Cleanups [Adel, Benjamin, Florian]
+
+Contributors:
+ Alban Browaeys, Matthias Clasen, Maxim Ermilov, Tomas Frydrych, Adel Gadllah,
+ Nickolas Lloyd, William Jon McCann, Florian Muellner, Benjamin Otte,
+ Thierry Reding, Rob Staudinger, Jasper St. Pierre, Owen Taylor, Colin Walters
+
+Translations:
+ Alexander Shopov [bg], Mario Blättermann [de], Ask H. Larsen [dk],
+ Michael Kotsarinis [el], Philip Withnall [en_UK], Jorge González [es],
+ Fran Diéguez [gl], Bruno Brouard, Claude Paroz [fr], Yaron Shahrabani [he],
+ Gabor Kelemen [hu], Luca Ferretti [it], Nils-Christoph Fiedler [nds],
+ Kjartan Maraas [nb], A S Alam [pa], Piotr Drąg [pl], Duarte Loreto [pt],
+ Antonio Fernandes C. Neto [pt_BR], Matej Urbančič [sl],
+ Miloš Popović [sr, sr@latin], Tirumurti Vasudevan [ta], Aron Xu [zh_CN],
+ Chao-Hsiung Liao [zh_HK, zh_TW]
+
+Fixed Bugs:
+ 597763 With >2 workspaces, Window menu "Move to Another Workspace" menu doesn't work
+ 598603 displays window size when moving terminal window
+ 606158 "Always on top" triggers Window manager warning:
+        Log level 8: meta_window_set_user_time: assertion `!window->override_redirect' failed
+ 610575 make meta_screen_set_cursor public
+ 613126 Do not cancel Alt+Tab grab due to Shift key events
+ 623235 BadDamage error from XSubtractDamage
+ 624757 Check for TFP usage after actually setting the pixmap
+ 625712 [mutter-shaped-texture] Remove material_workaround
+ 626583 Replace Gdk drawing API with cairo
+ 627087 Mipmap emulation not working
+ 627210 Crash with X error
+ 628544 introspection: Build with --warn-fatal, drop fix-meta-rectangle.py hack
+ 629127 build problem with recent gtk3
+ 629232 Multiple syntax errors in file mutter-message.c when building Mutter for
+        GNOME Shell dependencies
+ 629350 [mutter-shaped-texture] Use a base material for all instances
+ 629931 Allow breaking out from maximization/tiling during a mouse resize
+ 630195 Use GDK error trapping straight-up
+ 630203 Prepare mutter code for GTK3 rendering-cleanup
+ 630671 prepare mutter for the demise of GtkObject
+ 630843 gtk_window_set_visual was replaced by gtk_widget_set_visua
+ 631147 Adapt to GTK API changes
+ 631175 Mutter error compiling Gnome Shell
+
+2.31.5
+======
+
+* Support building with GTK+ 3.0 [Florian]
+* Remove deprecated usages for compatibility with GTK+ 3.0
+  [Claudio, Florian, Nickolas]
+* Export a boxed type for MetaRectangle [Owen]
+* Allow disabling -Werror with --enable-compile-warnings=yes [Nickolas]
+* Build fixes [Andreas, Florian, Owen]
+
+Contributors:
+ Nickolas Lloyd, Andreas Mueller, Florian Müllner, Claudio Saavedra,
+ Owen Taylor
+
+Translations:
+ Petr Kovar [cz], Jorge González [es], Fran Diéguez [gl],
+ Yaron Shahrabani [he], Matej Urbančič [sl]
+
+Fixed Bugs:
+ 587991 - Remove deprecated GTK+ symbols
+ 616275 - -Werror should not be enabled by default (or should be possible to disable)
+ 622303 - Allow building with Gtk+-3.0
+ 622800 - Make mutter more gtk+ 3.0 friendly
+ 623335 - Make MetaRectangle a boxed type
+ 623639 - Work around g-ir-scanner problem with Gdk.Rectangle
+ 624166 - src/core/util.c: Fix warning in case WITH_VERBOSE_MODE is not set
+
+2.31.4
+======
+
+* Clean up MutterPlugin effect interface [Maxim]
+* Track damage as the bounding box, a significant optimizations
+  for rapidly drawing clients [Robert]
+* Add meta_window_is_remote() [Colin]
+* Add meta_add_debug_topic() for turning on logging of
+  specific topics [Colin]
+* Fix bug with window unmaximization [Owen]
+
+Contributors:
+ Robert Bragg, Maxim Ermilov, Owen Taylor, Colin Walters
+
+Translations:
+ Yaron Shahrabani (he), Fran Diéguez (gl), Kjartan Maraas (nb), A S Alam (pa)
+
+Fixed Bugs:
+ 611838 - expose sub-stage redraws by streaming raw updates to ClutterX11TexturePixmap
+ 620585 - Add meta_window_is_remote
+ 620860 - function ‘meta_display_open’
+ 621082 - MutterPluginManager should call plugin->switch_workspace,
+          when screen doesn't have any window. Or function should be renamed.
+ 621413 - Maximize/Unmaximize not behaving properly for some non-gnome based programs
+
+2.31.2
+======
+
+* Theme enhancements [Owen]
+  - Add a flexible version mechanism for themes -
+    metacity-theme-3.xml is now supported, and can include
+    version="> 3.2" type attributes on the root element or
+    any subelement.
+  - Add frame_x_center/frame_y_center variables
+  - Allow a theme to turn on title ellipsization
+* Performance enhancements:
+  - Stream raw damage updates to ClutterX11TexturePixmap
+    to enable partial stage updates when windos change [Robert]
+  - Don't trap XErrors in meta_compositor_process_event [Adel]
+* Add meta_prefs_override_preference_location(); this allows
+  a plugin like GNOME Shell to redirect preferences to a
+  plugin-specific location. [Owen]
+* Support a _MUTTER_HINTS window property; this is a string
+  property holding key-value pairs with plugin-specific
+  interpretation [Tomas]
+* Build with GSEAL_ENABLE [Florian, Javier]
+* Add meta_display_get_leader_window() [Tomas]
+* Add meta_display_sort_windows_by_stacking [Colin]
+* Export
+   meta_display_get_last_user_time()
+   meta_display_xserver_time_is_before()
+   meta_window_foreach_ancestor(),
+   meta_window_foreach_transient()
+   meta_window_lower()
+   meta_window_raise()
+   meta_window_set_demands_attention()
+   meta_window_unset_demands_attention() [Colin]
+* Bug fixes [Dan, Edward, Owen, Tomas]
+* Build fixes [Owen, Dominique, Vincent]
+
+Contributors:
+ Robert Bragg, Adel Gadllah, Tomas Frydrych, Javier Jardón,
+ Dominique Leuenberger, Florian Müllner, Edward Sheldrake,
+ Owen Taylor, Vincent Untz, Colin Walters, Dan Winship
+
+Translations:
+ Xandru Armesto Fernandez (ast), Khaled Hosny (ar), Petr Kovar (cz),
+ Mario Blättermann, (de), Jorge González (es),
+ Inaki Larranaga Murgoitio [eu), Claude Paroz (fr), Luca Ferretti (it),
+ Gintautas Miliauskas (lt), Pavol Šimo (sk), Matej Urbančič (sl)
+
+Fixed Bugs:
+ 591842 - ellipsize titles when oversize
+ 592503 - Add a flexible version mechanism
+ 595496 - Use accessor functions instead direct access (use GSEAL GnomeGoal)
+ 596659 - Fix handling of grabbed key events
+ 613123 - Framework for plugin-specific per-window hint
+ 613125 - Add meta_display_get_leader_window()
+ 613127 - Keep num_workspaces key in sync with the actual workspace number
+ 613136 - remove over-restrictive assert from meta_prefs_get_workspace_name()
+ 613398 - Don't trap XErrors in meta_compositor_process_event
+ 615586 - Allow redirecting preferences to a different GConf key
+ 615672 - cant' compile mutter error: dereferencing pointer ‘p’ does break
+          strict-aliasing rules
+ 616050 - alt-tab infrastructure patches
+ 616274 - mutter from git fails with gcc 4.5 (on new warning)
+ 616546 - On dual screen maximized windows dragged to the second screen no
+          longer update their contents
+ 618138 - Work around COGL bug causing flash for new windows
+ 618613 - Fix crash with --sync option
+
+2.29.1
+======
+
+* Support and require Clutter 1.2 (Owen)
+* Add meta_display_get_keybinding_action() (Colin, Dan)
+* Add meta_window_get_wm_class_instance() (Tomas)
+* Remove workaround for bug fixed in intel driver Q2/2009 release (Robert)
+* Build fixes (Owen, Brian, Nguyễn Thái Ngọc Duy)
+
+Contributors:
+ Robert Bragg, Brian Cameron, Tomas Frydrych, Nguyễn Thái Ngọc Duy,
+ Owen Taylor, Colin Walters, Dan Winship
+
+Translations:
+ Alexander Shopov (bg), Mario Blättermann (de), Bruno Brouard (fr),
+ Nils-Christoph Fiedler (nds), Piotr Drąg (pl), Aron Xu (zh_CN)
+
+Fixed Bugs:
+
+ 610862 Support and require Clutter 1.1
+ 612506 mutter 2.29.0 fails to compile on Solaris
+ 613100 [MetaDisplay] Expose meta_display_get_keybinding_action
+ 613121 Remove workaround for multitexturing with old intel drivers
+ 613128 [MetaWindow] Accessor for the instance part of WM_CLASS property
+ 613278 meta_display_get_keybinding_action: strip out uninteresting modifiers
+
+2.29.0
+======
+
+* Improve appearance of scaled down windows using mipmap emulation (Owen)
+* Added signals: MetaDisplay::window-created, MetaDisplay::window-marked-urgent,
+  MetaDisplay::window-demands-attention, MetaWindow::unmanaged (Colin, Tomas)
+* Added properties: MetaWindow:demands-attention, MetaWindow:urgent,
+  MetaWindow:maximized-horizontally, MetaWindow:maximized-vertically (Florian, Tomas)
+* Fix nasty crash when workspace "struts" changed during a window move (Jon, Owen)
+* Bug fixes (Dan, Maxim, Neil, Owen, Tomas)
+* Build fixes (Colin, Emmanuele, Nickolas, Owen, Richard)
+* Merge Metacity changes since 2.26. Includes themable sound support
+  via libcanberra (Owen)
+
+Contributors
+ Emmanuele Bassi, Maxim Ermilov, Tomas Frydrych, Richard Hughes, Nickolas Lloyd,
+ Florian Müllner, Jon Nettleton, Neil Roberts, Owen Taylor, Colin Walters,
+ Dan Winship
+
+Additional Metacity contributors:
+ Thomas Hindoe Paaboel Andersen, Peter Bloomfield, Matthias Clasen,
+ Matt Kraai, Claude Paroz, Lennart Poettering, Ray Strode, Thomas Thurman,
+ Vincent Untz, Tomislav Vujec, Tomeu Vizoso, Travis Watkins, 'alexisdm59'
+
+Translations:
+ Khaled Hosny (ar), Petr Kovar (cz), Kjartan Maraas (nb), Djavan Fagundes (pt_BR),
+ Nils-Christoph Fiedler (nds), Matej Urbančič (sl), Vincent Untz
+
+Fixed Bugs:
+
+ 588065 Adds demands-attention signal to the window class
+ 591913 Fails to skip current window on alt+tab when another window is asking for attention
+ 592567 Dereferencing NULL in mutter_window_get_workspace()
+ 597052 Add signal to MetaDisplay so we know when a window has demanded-attention
+ 598289 Add "window-created" signal to MetaDisplay, "unmanaged" signal for MetaWindow
+ 598473 "XXX specified twice for this theme" messages not in sync with metacity.
+ 598600 "Visual Bell" option in Metacity causes Mutter to crash
+ 600068 notifications for window urgency hint
+ 601228 rdesktop does not get keypress signals
+ 602349 [PATCH] trivial - fix compilation warning in mutter
+ 602740 Remove XOR gc only used in removed reduced-resources mode
+ 602870 Fix compilation with older libGL
+ 604200 Compile issue: Use of deprecated clutter functions
+ 606388 mutter fails to build when using ld with --no-add-needed
+ 607125 Fails to build with latest introspection data
+ 607398 Do not use CGL_* symbols
+ 607746 reduce gconf roundtrips at startup
+ 608800 alt-dragging gimp windows crashes gnome-shell
+ 609350 Mutter does not support the COGL_DEBUG environment variable
+ 609546 meta_workspace_set_builtin_struts(): optimize out non-changes
+ 609585 Merge libcanberra usage from Metacity
+ 609657 Use cogl multitexture API when drawing MutterShapedTexture
+ 609665 Bug fixes from Fedora RPM
+ 609710 screencast recording broke
+ 610391 Fix crash on startup with list bindings
+
+2.28.0
+======
+
+* New exported API:
+    meta_window_get_stable_sequence() [Colin]
+    meta_window_get_transient_for_as_xid() [Tomas]
+    MutterScreen::workareas-changed signal [Tomas]
+* Fix a problem where changes processed from a Clutter event
+  callback wouldn't get handled before the screen was next
+  repainted, causing flashing [Owen]
+* Remove MetaAltTabHandler as no longer needed [Dan]
+* Bug fixes [Colin, Owen]
+
+Contributors:
+  Tomas Frydrych, Owen Taylor, Colin Walters, Dan Winship
+
+Translations:
+  Christian Kirbach (de), Claude Paroz (fr)
+
+2.27.5
+======
+
+ * Fix bug in GConf schemas where the overview activation key was specified as
+   '<Super_L>' not 'Super_L'.
+
+Contributors:
+
+ Colin Walters
+
+Translation:
+
+ Denis Arnaud (br)
+
+2.27.4
+======
+
+* Big code cleanup: when talking about multiple monitors, call them
+  "monitors", not "xineramas". [Dan]
+
+* Accessors added or made public:
+
+  meta_screen_get_n_monitors(), meta_screen_get_monitor_geometry()
+  meta_window_get_user_time() and MetaWindow:user-time property.
+
+  [Colin, Dan]
+
+* Set _GNOME_WM_KEYBINDINGS=Metacity,Mutter on the _NET_SUPPORTING_WM_CHECK
+  window so that gnome-keybinding-properties can figure out to show the
+  Metacity keybindings when Mutter is running. [Owen]
+
+* Bug and build fixes [Colin, Owen]
+
+Contributors:
+
+  Owen Taylor, Colin Walters, Dan Winship
+
+Translation:
+
+  Jorge González (es), Inaki Larranaga Murgoitio (eu), Gabor Kelemen (hu)
+
+Bugs fixed:
+
+  592393 - Clicking on a minimized window in the overview doesn't focus the window
+  593399 - Add meta_display_get_grab_op()
+  593404 - Make MUTTER_DEBUG_XINERAMA override active Xinerama
+  593407 - Add 'skip-taskbar' accessor to MetaWindow.
+  593686 - Add meta_screen_get_monitors()
+  594067 - Export a _GNOME_WM_KEYBINDINGS property
+
+2.27.3
+======
+
+* Key handling improvements:
+
+  - enforce that every key is handled no more than once.
+  - mutter_plugin_begin_modal() and mutter_plugin_begin_modal() allow
+    putting a plugin into a "modal" state where it has exclusive access
+    to key and pointer events.
+  - Add "tab_popup_select", "tab_pop_cancel" pseudo-keypress-handlers
+    that plugins can use to get notification when Alt-Tab ends
+
+  [Owen]
+
+* Accessors added or made public:
+
+   meta_window_is_override_redirect(), meta_window_is_mapped(),
+   meta_display_xwindow_is_a_no_focus_window(),
+   meta_display_get_grab_op(), meta_window_is_skip_taskbar(),
+   meta_window_is_modal(), all of errors.h
+
+ [Colin, Owen, Michael, Steve, Tomas]
+
+* Fix for various GTK+ deprecations [Javier]
+* Bug fixes [Colin, Frédéric, Owen, Thomas, Tomas, Volker]
+
+Contributors:
+
+  Javier Jardón, Steve Frécinaux, Tomas Frydrych, Michael Meeks,
+  Frédéric Péters, Volker Sobek, Owen Taylor, Thomas Thurman,
+  Colin Walters
+
+Translation:
+
+  Fran Dieguez (gl), Gabor Kelemen (hu), Daniel Nylander (se)
+
+Bugs fixed:
+
+  589457 - Fix up window property notification for "title"
+  590911 - Do not run plugin effects on WM startup
+  590978 - API to query whether window is in modal state
+  591367 - Be silent by default
+  591566 - install errors.h header ...
+  591788 - Add meta_window_is_override_redirect
+  591836 - mutter mishandles opacity
+  591913 - Fails to skip current window on alt+tab when another window is asking for attention
+  592393 - Clicking on a minimized window in the overview doesn't focus the window
+  592699 - Remove deprecated Encoding key from desktop files
+  592742 - Avoid accessing freed memory when being replaced
+  593399 - Add meta_display_get_grab_op()
+  593404 - Make MUTTER_DEBUG_XINERAMA override active Xinerama
+  593407 - Add 'skip-taskbar' accessor to MetaWindow.
+
+----------------------------- Older Metacity News -----------------------------
+
 2.26.0
 ======
 

configure.in

@@ -1,8 +1,8 @@
 AC_PREREQ(2.50)
 
-m4_define([mutter_major_version], [2])
-m4_define([mutter_minor_version], [91])
-m4_define([mutter_micro_version], [4])
+m4_define([mutter_major_version], [3])
+m4_define([mutter_minor_version], [2])
+m4_define([mutter_micro_version], [1])
 
 m4_define([mutter_version],
           [mutter_major_version.mutter_minor_version.mutter_micro_version])
@@ -15,9 +15,9 @@ AC_INIT([mutter], [mutter_version],
 AC_CONFIG_SRCDIR(src/core/display.c)
 AC_CONFIG_HEADERS(config.h)
 
-AM_INIT_AUTOMAKE([dist-bzip2 no-dist-gzip])
+AM_INIT_AUTOMAKE([1.11 no-dist-gzip dist-xz tar-ustar])
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])],)
-AM_MAINTAINER_MODE
+AM_MAINTAINER_MODE([enable])
 
 MUTTER_MAJOR_VERSION=mutter_major_version
 MUTTER_MINOR_VERSION=mutter_minor_version
@@ -61,7 +61,7 @@ AC_CHECK_SIZEOF(__int64)
 ## byte order
 AC_C_BIGENDIAN
 
-GTK_MIN_VERSION=2.90.7
+GTK_MIN_VERSION=2.91.7
 CANBERRA_GTK=libcanberra-gtk3
 CANBERRA_GTK_VERSION=0.26
 
@@ -96,11 +96,6 @@ AC_ARG_ENABLE(startup-notification,
                  [disable mutter's startup notification support, for embedded/size-sensitive custom non-GNOME builds]),,
   enable_startup_notification=auto)
 
-AC_ARG_WITH(introspection,
-  AC_HELP_STRING([--without-introspection],
-                 [disable the use of GObject introspection]),,
-  with_introspection=auto)
-
 AC_ARG_WITH(libcanberra,
   AC_HELP_STRING([--without-libcanberra],
                  [disable the use of libcanberra for playing sounds]),,
@@ -190,48 +185,31 @@ else
   AC_MSG_ERROR([no. Mutter requires the Xcomposite extension to build.])
 fi
 
-CLUTTER_VERSION=1.2.0
+CLUTTER_VERSION=1.7.5
 CLUTTER_PACKAGE=clutter-1.0
 AC_SUBST(CLUTTER_PACKAGE)
 if $PKG_CONFIG --atleast-version $CLUTTER_VERSION $CLUTTER_PACKAGE ; then
   MUTTER_PC_MODULES="$MUTTER_PC_MODULES $CLUTTER_PACKAGE "
   PKG_CHECK_MODULES(CLUTTER, $CLUTTER_PACKAGE)
   AC_DEFINE(WITH_CLUTTER, , [Building with Clutter compositor])
-
-  dnl Check for the clutter-glx-texture-pixmap header
-  mutter_save_cppflags="$CPPFLAGS"
-  CPPFLAGS="$CPPFLAGS $CLUTTER_CFLAGS"
-  AC_CHECK_HEADER([clutter/glx/clutter-glx-texture-pixmap.h],
-                  [have_glx_texture_pixmap=yes],
-                  [have_glx_texture_pixmap=no])
-  CPPFLAGS="$mutter_save_cppflags"
-
-  if test x$have_glx_texture_pixmap = xyes; then
-    AC_DEFINE(HAVE_GLX_TEXTURE_PIXMAP, ,
-              [Is ClutterGLXTexturePixmap available?])
-  fi
 else
   AC_MSG_ERROR([no. Mutter requires Clutter version $CLUTTER_VERSION.])
 fi
 
-if test x$with_introspection != xno; then
-  PKG_CHECK_MODULES(INTROSPECTION, gobject-introspection-1.0 >= 0.9.5, have_introspection=yes, have_introspection=no)
-  if test x$have_introspection=xyes; then
-    MUTTER_PC_MODULES="$MUTTER_PC_MODULES gobject-introspection-1.0"
-    AC_DEFINE(HAVE_INTROSPECTION, 1, [Define if GObject introspection is available])
-    G_IR_SCANNER=`$PKG_CONFIG --variable=g_ir_scanner gobject-introspection-1.0`
-    AC_SUBST(G_IR_SCANNER)
-    G_IR_COMPILER=`$PKG_CONFIG --variable=g_ir_compiler gobject-introspection-1.0`
-    AC_SUBST(G_IR_COMPILER)
-    G_IR_GENERATE=`$PKG_CONFIG --variable=g_ir_generate gobject-introspection-1.0`
-    AC_SUBST(G_IR_GENERATE)
-    GIRDIR=`$PKG_CONFIG --variable=girdir gobject-introspection-1.0`
-    AC_SUBST(GIRDIR)
-    TYPELIBDIR="$($PKG_CONFIG --variable=typelibdir gobject-introspection-1.0)"
-    AC_SUBST(TYPELIBDIR)
-  fi
+INTROSPECTION_VERSION=0.9.5
+GOBJECT_INTROSPECTION_CHECK([$INTROSPECTION_VERSION])
+
+if test x$found_introspection != xno; then
+  AC_DEFINE(HAVE_INTROSPECTION, 1, [Define if GObject introspection is available])
+  MUTTER_PC_MODULES="$MUTTER_PC_MODULES gobject-introspection-1.0"
+  # Since we don't make any guarantees about stability and we don't support
+  # parallel install, there's no real reason to change directories, filenames,
+  # etc. as we change the Mutter tarball version. Note that this must match
+  # api_version in src/Makefile.am
+  META_GIR=Meta_3_0_gir
+  # META_GIR=[Meta_]mutter_major_version[_]mutter_minor_version[_gir]
+  AC_SUBST(META_GIR)
 fi
-AM_CONDITIONAL(WITH_INTROSPECTION, test "$have_introspection" = "yes")
 
 AC_MSG_CHECKING([Xcursor])
 if $PKG_CONFIG xcursor; then
@@ -524,7 +502,7 @@ doc/Makefile
 doc/man/Makefile
 src/Makefile
 src/wm-tester/Makefile
-src/libmutter-private.pc
+src/libmutter.pc
 src/mutter-plugins.pc
 src/tools/Makefile
 src/compositor/plugins/Makefile
@@ -561,7 +539,7 @@ mutter-$VERSION
 	Solaris Xinerama:         ${use_solaris_xinerama}
 	Startup notification:     ${have_startup_notification}
 	libcanberra:              ${have_libcanberra}
-	Introspection:            ${have_introspection}
+	Introspection:            ${found_introspection}
 	Session management:       ${found_sm}
 	Shape extension:          ${found_shape}
 	Xsync:                    ${found_xsync}

doc/theme-format.txt

@@ -22,6 +22,28 @@ This document has separate sections for each format version. You may
 want to read the document in reverse order, since the base features
 are discussed under version 1.
 
+New Features in Theme Format Version 3.4
+========================================
+
+An additional color type is added to pick up custom colors defined
+in the GTK+ theme's CSS:
+
+  gtk:custom(name,fallback)
+
+where <name> refers to a custom color defined with @define-color in
+the GTK+ theme, and <fallback> provides an alternative color definition
+in case the color referenced by <name> is not found.
+
+New Features in Theme Format Version 3.3
+========================================
+
+Add two additional button background functions - left_single_background and
+right_single_background - for button groups with just a single button.
+
+There are now additional frame states to style left/right tiled windows
+differently ("tiled_left", "tiled_right", "tiled_left_and_shaded",
+"tiled_right_and_shaded").
+
 New Features in Theme Format Version 3.2
 ========================================
 

mutter.doap

@@ -6,6 +6,16 @@
 
   <name xml:lang="en">mutter</name>
   <shortdesc xml:lang="en">Window and compositing manager based on Clutter</shortdesc>
+  <description>Mutter is a window and compositing manager that displays and
+manages your desktop via OpenGL. Mutter combines a sophisticated display engine
+using the Clutter toolkit with solid window-management logic inherited from the
+Metacity window manager.
+
+While Mutter can be used stand-alone, it is primarily intended to be used as
+the display core of a larger system such as GNOME Shell. For this reason,
+Mutter is very extensible via plugins, which are used both to add fancy visual
+effects and to rework the window management behaviors to meet the needs of the
+environment.</description>
   <!--
   <homepage rdf:resource="http://www.gnome.org/" />
   -->

po/LINGUAS

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

po/POTFILES.in

@@ -1,5 +1,7 @@
 # List of source files containing translatable strings.
 # Please keep this file sorted alphabetically.
+src/compositor/compositor.c
+src/core/all-keybindings.h
 src/core/bell.c
 src/core/core.c
 src/core/delete.c
@@ -7,6 +9,7 @@ src/core/display.c
 src/core/errors.c
 src/core/keybindings.c
 src/core/main.c
+src/core/mutter.c
 src/core/prefs.c
 src/core/screen.c
 src/core/session.c
@@ -14,7 +17,6 @@ src/core/util.c
 src/core/window.c
 src/core/window-props.c
 src/core/xprops.c
-src/include/all-keybindings.h
 src/mutter.desktop.in
 src/mutter-wm.desktop.in
 src/mutter.schemas.in

src/Makefile.am

@@ -1,11 +1,30 @@
 # Flag build for parallelism; see https://savannah.gnu.org/patch/?6905
 .AUTOPARALLEL:
 
-lib_LTLIBRARIES = libmutter-private.la
+lib_LTLIBRARIES = libmutter.la
 
 SUBDIRS=wm-tester tools compositor/plugins
 
-INCLUDES=@MUTTER_CFLAGS@ -I $(srcdir)/include -I$(srcdir)/compositor -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PKGLIBDIR=\"$(pkglibdir)\" -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
+INCLUDES=								\
+	$(MUTTER_CFLAGS)						\
+	-I$(srcdir)							\
+	-I$(srcdir)/core						\
+	-I$(srcdir)/ui							\
+	-I$(srcdir)/compositor						\
+	-DMUTTER_LIBEXECDIR=\"$(libexecdir)\"				\
+	-DHOST_ALIAS=\"@HOST_ALIAS@\"					\
+	-DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\"		\
+	-DMUTTER_PKGDATADIR=\"$(pkgdatadir)\"				\
+	-DMUTTER_DATADIR=\"$(datadir)\"					\
+	-DG_LOG_DOMAIN=\"mutter\"					\
+	-DSN_API_NOT_YET_FROZEN=1					\
+	-DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION)			\
+	-DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION)			\
+	-DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION)			\
+	-DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION)	\
+	-DMUTTER_PKGLIBDIR=\"$(pkglibdir)\"				\
+	-DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"			\
+	-DGETTEXT_PACKAGE=\"$(GETTEXT_PACKAGE)\"
 
 mutter_built_sources = \
 	mutter-marshal.h \
@@ -13,20 +32,20 @@ mutter_built_sources = \
 	mutter-enum-types.h \
 	mutter-enum-types.c
 
-mutter_SOURCES= 				\
+libmutter_la_SOURCES =				\
 	core/async-getprop.c			\
 	core/async-getprop.h			\
 	core/bell.c				\
 	core/bell.h				\
 	core/boxes.c				\
 	core/boxes-private.h			\
-	include/boxes.h				\
+	meta/boxes.h				\
 	compositor/cogl-utils.c			\
 	compositor/cogl-utils.h			\
 	compositor/compositor.c			\
 	compositor/compositor-private.h		\
 	compositor/meta-background-actor.c	\
-	compositor/meta-background-actor.h	\
+	compositor/meta-background-actor-private.h	\
 	compositor/meta-module.c		\
 	compositor/meta-module.h		\
 	compositor/meta-plugin.c		\
@@ -36,6 +55,8 @@ mutter_SOURCES= 				\
 	compositor/meta-shadow-factory-private.h	\
 	compositor/meta-shaped-texture.c	\
 	compositor/meta-shaped-texture.h	\
+	compositor/meta-texture-rectangle.c	\
+	compositor/meta-texture-rectangle.h	\
 	compositor/meta-texture-tower.c		\
 	compositor/meta-texture-tower.h		\
 	compositor/meta-window-actor.c		\
@@ -46,36 +67,37 @@ mutter_SOURCES= 				\
 	compositor/meta-window-shape.h		\
 	compositor/region-utils.c		\
 	compositor/region-utils.h		\
-	include/compositor.h			\
-	include/meta-plugin.h			\
-	include/meta-shadow-factory.h		\
-	include/meta-window-actor.h		\
-	include/compositor-mutter.h 		\
+	meta/compositor.h			\
+	meta/meta-background-actor.h		\
+	meta/meta-plugin.h			\
+	meta/meta-shadow-factory.h		\
+	meta/meta-window-actor.h		\
+	meta/compositor-mutter.h 		\
+	core/above-tab-keycode.c		\
 	core/constraints.c			\
 	core/constraints.h			\
 	core/core.c				\
 	core/delete.c				\
 	core/display.c				\
 	core/display-private.h			\
-	include/display.h			\
+	meta/display.h				\
 	ui/draw-workspace.c			\
 	ui/draw-workspace.h			\
 	core/edge-resistance.c			\
 	core/edge-resistance.h			\
 	core/errors.c				\
-	include/errors.h			\
+	meta/errors.h				\
 	core/eventqueue.c			\
 	core/eventqueue.h			\
 	core/frame.c				\
-	core/frame-private.h			\
-	include/frame.h				\
+	core/frame.h				\
 	ui/gradient.c				\
-	ui/gradient.h				\
+	meta/gradient.h				\
 	core/group-private.h			\
 	core/group-props.c			\
 	core/group-props.h			\
 	core/group.c				\
-	include/group.h				\
+	meta/group.h				\
 	core/iconcache.c			\
 	core/iconcache.h			\
 	core/keybindings.c			\
@@ -85,11 +107,11 @@ mutter_SOURCES= 				\
 	core/place.c				\
 	core/place.h				\
 	core/prefs.c				\
-	include/prefs.h				\
+	meta/prefs.h				\
 	core/screen.c				\
 	core/screen-private.h			\
-	include/screen.h			\
-	include/types.h                         \
+	meta/screen.h				\
+	meta/types.h				\
 	core/session.c				\
 	core/session.h				\
 	core/stack.c				\
@@ -97,19 +119,19 @@ mutter_SOURCES= 				\
 	core/stack-tracker.c			\
 	core/stack-tracker.h			\
 	core/util.c				\
-	include/util.h				\
+	meta/util.h				\
 	core/window-props.c			\
 	core/window-props.h			\
 	core/window.c				\
 	core/window-private.h			\
-	include/window.h			\
+	meta/window.h				\
 	core/workspace.c			\
 	core/workspace-private.h		\
 	core/xprops.c				\
-	include/xprops.h			\
-	include/common.h			\
-	include/core.h				\
-	include/ui.h				\
+	core/xprops.h				\
+	meta/common.h				\
+	core/core.h				\
+	ui/ui.h					\
 	inlinepixbufs.h				\
 	ui/fixedtip.c				\
 	ui/fixedtip.h				\
@@ -120,71 +142,56 @@ mutter_SOURCES= 				\
 	ui/metaaccellabel.c			\
 	ui/metaaccellabel.h			\
 	ui/resizepopup.c			\
-	include/resizepopup.h			\
+	ui/resizepopup.h			\
 	ui/tabpopup.c				\
-	include/tabpopup.h				\
+	ui/tabpopup.h				\
 	ui/tile-preview.c			\
-	include/tile-preview.h			\
+	ui/tile-preview.h			\
 	ui/theme-parser.c			\
 	ui/theme.c				\
-	ui/theme.h				\
+	meta/theme.h				\
 	ui/theme-private.h			\
 	ui/ui.c					\
-	include/all-keybindings.h               \
+	core/all-keybindings.h			\
+	meta/preview-widget.h			\
+	ui/preview-widget.c			\
 	$(mutter_built_sources)
 
-# by setting libmutter_private_la_CFLAGS, the files shared with
-# mutter proper will be compiled with different names.
-libmutter_private_la_CFLAGS =
-libmutter_private_la_SOURCES=			\
-	core/boxes.c				\
-	include/boxes.h				\
-	ui/gradient.c				\
-	ui/gradient.h				\
-	core/util.c				\
-	include/util.h				\
-	include/common.h			\
-	ui/preview-widget.c			\
-	ui/preview-widget.h			\
-	ui/theme-parser.c			\
-	ui/theme.c				\
-	ui/theme.h
-
-libmutter_private_la_LDFLAGS = -no-undefined
-libmutter_private_la_LIBADD  = @MUTTER_LIBS@
+libmutter_la_LDFLAGS = -no-undefined
+libmutter_la_LIBADD  = $(MUTTER_LIBS)
 
 # Headers installed for plugins; introspected information will
 # be extracted into Mutter-<version>.gir
 libmutterinclude_base_headers =		\
-	include/boxes.h				\
-	ui/gradient.h				\
-	include/main.h				\
-	include/util.h				\
-	include/common.h			\
-	ui/theme.h				\
-	include/prefs.h				\
-	include/window.h			\
-	include/workspace.h			\
-	include/compositor.h			\
-	include/compositor-mutter.h		\
-	include/types.h				\
-	include/errors.h			\
-	include/screen.h			\
-	include/display.h			\
-	include/group.h				\
-	include/keybindings.h			\
-	include/meta-plugin.h			\
-	include/meta-shadow-factory.h		\
-	include/meta-window-actor.h
+	meta/boxes.h				\
+	meta/common.h				\
+	meta/compositor-mutter.h		\
+	meta/compositor.h			\
+	meta/display.h				\
+	meta/errors.h				\
+	meta/gradient.h				\
+	meta/group.h				\
+	meta/keybindings.h			\
+	meta/main.h				\
+	meta/meta-background-actor.h		\
+	meta/meta-plugin.h			\
+	meta/meta-shadow-factory.h		\
+	meta/meta-window-actor.h		\
+	meta/prefs.h				\
+	meta/screen.h				\
+	meta/theme.h				\
+	meta/types.h				\
+	meta/util.h				\
+	meta/window.h				\
+	meta/workspace.h
 
 # Excluded from scanning for introspection but installed
-# preview-widget.h: only part of libmutter-private
 # atomnames.h: macros cause problems for scanning process
 libmutterinclude_extra_headers =		\
-	ui/preview-widget.h			\
-	include/atomnames.h
+	meta/preview-widget.h			\
+	meta/atomnames.h
 
-libmutterincludedir = $(includedir)/mutter/mutter-private
+libmutterincludedir = $(includedir)/mutter/meta
 
 libmutterinclude_HEADERS =			\
 	$(libmutterinclude_base_headers)	\
@@ -195,9 +202,18 @@ mutter_theme_viewer_SOURCES=  \
 
 bin_PROGRAMS=mutter mutter-theme-viewer
 
-api_version = $(MUTTER_MAJOR_VERSION).$(MUTTER_MINOR_VERSION)
+mutter_SOURCES = core/mutter.c
+mutter_LDADD = $(MUTTER_LIBS) libmutter.la
+
+if HAVE_INTROSPECTION
+include $(INTROSPECTION_MAKEFILE)
+
+# Since we don't make any guarantees about stability and we don't support
+# parallel install, there's no real reason to change directories, filenames,
+# etc. as we change the Mutter tarball version.
+#api_version = $(MUTTER_MAJOR_VERSION).$(MUTTER_MINOR_VERSION)
+api_version = 3.0
 
-if WITH_INTROSPECTION
 # These files are in package-private directories, even though they may be used
 # by plugins.  If you're writing a plugin, use g-ir-compiler --add-include-path
 # and g-ir-compiler --includedir.
@@ -207,50 +223,32 @@ gir_DATA = Meta-$(api_version).gir
 typelibdir = $(pkglibdir)
 typelib_DATA = Meta-$(api_version).typelib
 
-# We need to strip out the attribute that would point back to libmutter-introspect
-# so that libgirepository looks for symbols in the executable instead
-Meta-$(api_version).gir: $(G_IR_SCANNER) mutter $(libmutterinclude_HEADERS) $(mutter_SOURCES) Makefile
-	$(AM_V_GEN) pwd=`pwd` ;				\
-        cd $(srcdir) &&					\
-	$(G_IR_SCANNER)					\
-		--namespace=Meta			\
-		--nsversion=$(api_version)		\
-		--warn-all				\
-		--warn-error				\
-		--include=GObject-2.0			\
-		--include=Gdk-3.0			\
-		--include=Gtk-3.0			\
-		--include=Clutter-1.0			\
-		--pkg=clutter-1.0			\
-		--pkg=gtk+-3.0				\
-		--include=xlib-2.0			\
-		--include=xfixes-4.0			\
-		--program=$$pwd/mutter			\
-		mutter-enum-types.h			\
-		$(filter %.c,$(mutter_SOURCES))		\
-		$(libmutterinclude_base_headers)	\
-		$(INCLUDES)				\
-		-o $$pwd/$@
+INTROSPECTION_GIRS = Meta-$(api_version).gir
+
+Meta-$(api_version).gir: libmutter.la
+@META_GIR@_INCLUDES = GObject-2.0 Gdk-3.0 Gtk-3.0 Clutter-1.0 xlib-2.0 xfixes-4.0
+@META_GIR@_PACKAGES = clutter-1.0 gtk+-3.0
+@META_GIR@_CFLAGS = $(INCLUDES)
+@META_GIR@_LIBS = libmutter.la
+@META_GIR@_FILES =				\
+	mutter-enum-types.h			\
+	$(libmutterinclude_base_headers)	\
+	$(filter %.c,$(libmutter_la_SOURCES))
+@META_GIR@_SCANNERFLAGS = --warn-all --warn-error
 
-Meta-$(api_version).typelib: $(G_IR_COMPILER) Meta-$(api_version).gir
-	$(AM_V_GEN) LD_LIBRARY_PATH=$${LD_LIBRARY_PATH:+$$LD_LIBRARY_PATH:}. $(G_IR_COMPILER) Meta-$(api_version).gir -o $@
 endif
 
-EFENCE=
-mutter_LDADD=@MUTTER_LIBS@ $(EFENCE)
-mutter_LDFLAGS=-export-dynamic
+mutter_theme_viewer_LDADD= $(MUTTER_LIBS) libmutter.la
 
-mutter_theme_viewer_LDADD= @MUTTER_LIBS@ libmutter-private.la
-
-testboxes_SOURCES=include/util.h core/util.c include/boxes.h core/boxes.c core/testboxes.c
-testgradient_SOURCES=ui/gradient.h ui/gradient.c ui/testgradient.c
-testasyncgetprop_SOURCES=core/async-getprop.h core/async-getprop.c core/testasyncgetprop.c
+testboxes_SOURCES = core/testboxes.c
+testgradient_SOURCES = ui/testgradient.c
+testasyncgetprop_SOURCES = core/testasyncgetprop.c
 
 noinst_PROGRAMS=testboxes testgradient testasyncgetprop
 
-testboxes_LDADD= @MUTTER_LIBS@
-testgradient_LDADD= @MUTTER_LIBS@
-testasyncgetprop_LDADD= @MUTTER_LIBS@
+testboxes_LDADD = $(MUTTER_LIBS) libmutter.la
+testgradient_LDADD = $(MUTTER_LIBS) libmutter.la
+testasyncgetprop_LDADD = $(MUTTER_LIBS) libmutter.la
 
 @INTLTOOL_DESKTOP_RULE@
 
@@ -264,7 +262,7 @@ wmproperties_in_files=mutter-wm.desktop.in
 wmproperties_files=$(wmproperties_in_files:.desktop.in=.desktop)
 wmproperties_DATA = $(wmproperties_files)
 
-schemadir   = @GCONF_SCHEMA_FILE_DIR@
+schemadir   = $(GCONF_SCHEMA_FILE_DIR)
 schema_in_files = mutter.schemas.in
 schema_DATA = $(schema_in_files:.schemas.in=.schemas)
 
@@ -299,7 +297,7 @@ inlinepixbufs.h: $(IMAGES)
 
 pkgconfigdir = $(libdir)/pkgconfig
 
-pkgconfig_DATA = libmutter-private.pc mutter-plugins.pc
+pkgconfig_DATA = libmutter.pc mutter-plugins.pc
 
 EXTRA_DIST=$(desktopfiles_files) 	\
 	$(wmproperties_files)		\
@@ -307,7 +305,7 @@ EXTRA_DIST=$(desktopfiles_files) 	\
 	$(desktopfiles_in_files)	\
 	$(wmproperties_in_files)	\
 	$(schema_in_files)		\
-	libmutter-private.pc.in	\
+	libmutter.pc.in \
 	mutter-plugins.pc.in  \
 	mutter-enum-types.h.in \
 	mutter-enum-types.c.in \
@@ -342,7 +340,7 @@ mutter-enum-types.h: stamp-mutter-enum-types.h Makefile
 stamp-mutter-enum-types.h: $(libmutterinclude_base_headers) mutter-enum-types.h.in
 	$(AM_V_GEN) ( cd $(srcdir) && \
 	  $(GLIB_MKENUMS) \
-	    --template $(srcdir)/mutter-enum-types.h.in \
+	    --template mutter-enum-types.h.in \
 	  $(libmutterinclude_base_headers) ) >> xgen-teth && \
 	(cmp -s xgen-teth mutter-enum-types.h || cp xgen-teth mutter-enum-types.h) && \
 	rm -f xgen-teth && \
@@ -351,7 +349,7 @@ stamp-mutter-enum-types.h: $(libmutterinclude_base_headers) mutter-enum-types.h.
 mutter-enum-types.c: stamp-mutter-enum-types.h mutter-enum-types.c.in
 	  $(AM_V_GEN) ( cd $(srcdir) && \
 	  $(GLIB_MKENUMS) \
-	    --template $(srcdir)/mutter-enum-types.c.in \
+	    --template mutter-enum-types.c.in \
 	  $(libmutterinclude_base_headers) ) >> xgen-tetc && \
 	cp xgen-tetc mutter-enum-types.c && \
 	rm -f xgen-tetc

src/compositor/cogl-utils.c

@@ -29,6 +29,10 @@
  * @green:
  * @blue:
  * @alpha:
+ * @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE;
+ *   %COGL_TEXTURE_NO_SLICING is useful if the texture will be
+ *   repeated to create a constant color fill, since hardware
+ *   repeat can't be used for a sliced texture.
  *
  * Creates a texture that is a single pixel with the specified
  * unpremultiplied color components.
@@ -36,10 +40,11 @@
  * Return value: (transfer full): a newly created Cogl texture
  */
 CoglHandle
-meta_create_color_texture_4ub (guint8 red,
-                               guint8 green,
-                               guint8 blue,
-                               guint8 alpha)
+meta_create_color_texture_4ub (guint8           red,
+                               guint8           green,
+                               guint8           blue,
+                               guint8           alpha,
+                               CoglTextureFlags flags)
 {
   CoglColor color;
   guint8 pixel[4];
@@ -53,7 +58,7 @@ meta_create_color_texture_4ub (guint8 red,
   pixel[3] = cogl_color_get_alpha_byte (&color);
 
   return cogl_texture_new_from_data (1, 1,
-                                     COGL_TEXTURE_NONE,
+                                     flags,
                                      COGL_PIXEL_FORMAT_RGBA_8888_PRE,
                                      COGL_PIXEL_FORMAT_ANY,
                                      4, pixel);
@@ -88,7 +93,8 @@ meta_create_texture_material (CoglHandle src_texture)
     {
       CoglHandle dummy_texture;
 
-      dummy_texture = meta_create_color_texture_4ub (0xff, 0xff, 0xff, 0xff);
+      dummy_texture = meta_create_color_texture_4ub (0xff, 0xff, 0xff, 0xff,
+                                                     COGL_TEXTURE_NONE);
 
       texture_material_template = cogl_material_new ();
       cogl_material_set_layer (texture_material_template, 0, dummy_texture);

src/compositor/cogl-utils.h

@@ -25,10 +25,11 @@
 
 #include <cogl/cogl.h>
 
-CoglHandle meta_create_color_texture_4ub (guint8     red,
-                                          guint8     green,
-                                          guint8     blue,
-                                          guint8     alpha);
+CoglHandle meta_create_color_texture_4ub (guint8           red,
+                                          guint8           green,
+                                          guint8           blue,
+                                          guint8           alpha,
+                                          CoglTextureFlags flags);
 CoglHandle meta_create_texture_material  (CoglHandle src_texture);
 
 #endif /* __META_COGL_UTILS_H__ */

src/compositor/compositor-private.h

@@ -5,9 +5,10 @@
 
 #include <X11/extensions/Xfixes.h>
 
-#include "compositor.h"
-#include "display.h"
+#include <meta/compositor.h>
+#include <meta/display.h>
 #include "meta-plugin-manager.h"
+#include "meta-window-actor-private.h"
 #include <clutter/clutter.h>
 
 typedef struct _MetaCompScreen MetaCompScreen;
@@ -41,6 +42,10 @@ struct _MetaCompScreen
   GHashTable            *windows_by_xid;
   Window                 output;
 
+  /* Used for unredirecting fullscreen windows */
+  guint                   disable_unredirect_count;
+  MetaWindowActor             *unredirected_window;
+
   /* Before we create the output window */
   XserverRegion     pending_input_region;
 

src/compositor/compositor.c

@@ -4,19 +4,20 @@
 
 #include <clutter/x11/clutter-x11.h>
 
-#include "screen.h"
-#include "errors.h"
-#include "window.h"
+#include <meta/screen.h>
+#include <meta/errors.h>
+#include <meta/window.h>
 #include "compositor-private.h"
-#include "compositor-mutter.h"
+#include <meta/compositor-mutter.h>
 #include "xprops.h"
-#include "prefs.h"
-#include "meta-shadow-factory.h"
+#include <meta/prefs.h>
+#include <meta/main.h>
+#include <meta/meta-shadow-factory.h>
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-background-actor.h"
-#include "../core/window-private.h" /* to check window->hidden */
-#include "../core/display-private.h" /* for meta_display_lookup_x_window() */
+#include "meta-background-actor-private.h"
+#include "window-private.h" /* to check window->hidden */
+#include "display-private.h" /* for meta_display_lookup_x_window() */
 #include <X11/extensions/shape.h>
 #include <X11/extensions/Xcomposite.h>
 
@@ -108,28 +109,6 @@ process_damage (MetaCompositor     *compositor,
   meta_window_actor_process_damage (window_actor, event);
 }
 
-#ifdef HAVE_SHAPE
-static void
-process_shape (MetaCompositor *compositor,
-               XShapeEvent    *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;
-
-  if (event->kind == ShapeBounding)
-    {
-      meta_window_actor_update_shape (window_actor, event->shaped);
-    }
-}
-#endif
-
 static void
 process_property_notify (MetaCompositor	*compositor,
                          XPropertyEvent *event,
@@ -146,8 +125,7 @@ process_property_notify (MetaCompositor	*compositor,
 	  MetaScreen  *screen = l->data;
           if (event->window == meta_screen_get_xroot (screen))
             {
-              MetaCompScreen *info = meta_screen_get_compositor_data (screen);
-              meta_background_actor_update (META_BACKGROUND_ACTOR (info->background_actor));
+              meta_background_actor_update (screen);
               return;
             }
         }
@@ -301,6 +279,12 @@ do_set_stage_input_region (MetaScreen   *screen,
   Window        xstage = clutter_x11_get_stage_window (CLUTTER_STAGE (info->stage));
 
   XFixesSetWindowShapeRegion (xdpy, xstage, ShapeInput, 0, 0, region);
+
+  /* It's generally a good heuristic that when a crossing event is generated because
+   * we reshape the overlay, we don't want it to affect focus-follows-mouse focus -
+   * it's not the user doing something, it's the environment changing under the user.
+   */
+  meta_display_add_ignored_crossing_serial (display, XNextRequest (xdpy));
   XFixesSetWindowShapeRegion (xdpy, info->output, ShapeInput, 0, 0, region);
 }
 
@@ -474,20 +458,43 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
   gint            width, height;
   XWindowAttributes attr;
   long            event_mask;
+  guint           n_retries;
+  guint           max_retries;
 
   /* Check if the screen is already managed */
   if (meta_screen_get_compositor_data (screen))
     return;
 
-  meta_error_trap_push_with_return (display);
-  XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
-  XSync (xdisplay, FALSE);
+  if (meta_get_replace_current_wm ())
+    max_retries = 5;
+  else
+    max_retries = 1;
 
-  if (meta_error_trap_pop_with_return (display))
+  n_retries = 0;
+
+  /* Some compositors (like old versions of Mutter) might not properly unredirect
+   * subwindows before destroying the WM selection window; so we wait a while
+   * for such a compositor to exit before giving up.
+   */
+  while (TRUE)
     {
-      g_warning ("Another compositing manager is running on screen %i",
-                 screen_number);
-      return;
+      meta_error_trap_push_with_return (display);
+      XCompositeRedirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
+      XSync (xdisplay, FALSE);
+
+      if (!meta_error_trap_pop_with_return (display))
+        break;
+
+      if (n_retries == max_retries)
+        {
+          /* This probably means that a non-WM compositor like xcompmgr is running;
+           * we have no way to get it to exit */
+          meta_fatal (_("Another compositing manager is already running on screen %i on display \"%s\"."),
+                      screen_number, display->name);
+        }
+
+      n_retries++;
+      g_usleep (G_USEC_PER_SEC);
     }
 
   info = g_new0 (MetaCompScreen, 1);
@@ -532,7 +539,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
   XSelectInput (xdisplay, xwin, event_mask);
 
   info->window_group = meta_window_group_new (screen);
-  info->background_actor = meta_background_actor_new (screen);
+  info->background_actor = meta_background_actor_new_for_screen (screen);
   info->overlay_group = clutter_group_new ();
   info->hidden_group = clutter_group_new ();
 
@@ -550,18 +557,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
 
   info->plugin_mgr =
     meta_plugin_manager_get (screen);
-
-  if (info->plugin_mgr != meta_plugin_manager_get_default ())
-    {
-      /* The default plugin manager has been initialized during
-       * global preferences load.
-       */
-      if (!meta_plugin_manager_load (info->plugin_mgr))
-        g_critical ("failed to load plugins");
-    }
-
-  if (!meta_plugin_manager_initialize (info->plugin_mgr))
-    g_critical ("failed to initialize plugins");
+  meta_plugin_manager_initialize (info->plugin_mgr);
 
   /*
    * Delay the creation of the overlay window as long as we can, to avoid
@@ -598,6 +594,55 @@ void
 meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                  MetaScreen     *screen)
 {
+  MetaDisplay    *display       = meta_screen_get_display (screen);
+  Display        *xdisplay      = meta_display_get_xdisplay (display);
+  Window          xroot         = meta_screen_get_xroot (screen);
+
+  /* This is the most important part of cleanup - we have to do this
+   * before giving up the window manager selection or the next
+   * window manager won't be able to redirect subwindows */
+  XCompositeUnredirectSubwindows (xdisplay, xroot, CompositeRedirectManual);
+}
+
+/*
+ * Shapes the cow so that the given window is exposed,
+ * when metaWindow is NULL it clears the shape again
+ */
+static void
+meta_shape_cow_for_window (MetaScreen *screen,
+                           MetaWindow *metaWindow)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  Display *xdisplay = meta_display_get_xdisplay (meta_screen_get_display (screen));
+
+  if (metaWindow == NULL)
+      XFixesSetWindowShapeRegion (xdisplay, info->output, ShapeBounding, 0, 0, None);
+  else
+    {
+      XserverRegion output_region;
+      XRectangle screen_rect, window_bounds;
+      int width, height;
+      MetaRectangle rect;
+
+      meta_window_get_outer_rect (metaWindow, &rect);
+
+      window_bounds.x = rect.x;
+      window_bounds.y = rect.y;
+      window_bounds.width = rect.width;
+      window_bounds.height = rect.height;
+
+      meta_screen_get_size (screen, &width, &height);
+      screen_rect.x = 0;
+      screen_rect.y = 0;
+      screen_rect.width = width;
+      screen_rect.height = height;
+
+      output_region = XFixesCreateRegion (xdisplay, &window_bounds, 1);
+
+      XFixesInvertRegion (xdisplay, output_region, &screen_rect, output_region);
+      XFixesSetWindowShapeRegion (xdisplay, info->output, ShapeBounding, 0, 0, output_region);
+      XFixesDestroyRegion (xdisplay, output_region);
+    }
 }
 
 void
@@ -620,12 +665,25 @@ meta_compositor_remove_window (MetaCompositor *compositor,
                                MetaWindow     *window)
 {
   MetaWindowActor         *window_actor     = NULL;
+  MetaScreen *screen;
+  MetaCompScreen *info;
 
   DEBUG_TRACE ("meta_compositor_remove_window\n");
   window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
   if (!window_actor)
     return;
 
+  screen = meta_window_get_screen (window);
+  info = meta_screen_get_compositor_data (screen);
+
+  if (window_actor == info->unredirected_window)
+    {
+      meta_window_actor_set_redirected (window_actor, TRUE);
+      meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
+                                 NULL);
+      info->unredirected_window = NULL;
+    }
+
   meta_window_actor_destroy (window_actor);
 }
 
@@ -653,6 +711,16 @@ is_grabbed_event (XEvent *event)
 
   return FALSE;
 }
+
+void
+meta_compositor_window_shape_changed (MetaCompositor *compositor,
+                                      MetaWindow     *window)
+{
+  MetaWindowActor *window_actor;
+  window_actor = META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
+  meta_window_actor_update_shape (window_actor);
+}
+
 /**
  * meta_compositor_process_event: (skip)
  *
@@ -732,13 +800,6 @@ meta_compositor_process_event (MetaCompositor *compositor,
 	  DEBUG_TRACE ("meta_compositor_process_event (process_damage)\n");
           process_damage (compositor, (XDamageNotifyEvent *) event, window);
         }
-#ifdef HAVE_SHAPE
-      else if (event->type == meta_display_get_shape_event_base (compositor->display) + ShapeNotify)
-	{
-	  DEBUG_TRACE ("meta_compositor_process_event (process_shape)\n");
-	  process_shape (compositor, (XShapeEvent *) event, window);
-	}
-#endif /* HAVE_SHAPE */
       break;
     }
 
@@ -974,7 +1035,10 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
 
           if (old_window->hidden &&
               !meta_window_actor_effect_in_progress (old_actor))
-            old_stack = g_list_delete_link (old_stack, old_stack);
+            {
+              old_stack = g_list_delete_link (old_stack, old_stack);
+              old_actor = NULL;
+            }
           else
             break;
         }
@@ -1082,7 +1146,7 @@ meta_compositor_sync_screen_size (MetaCompositor  *compositor,
 
   clutter_actor_set_size (info->stage, width, height);
 
-  meta_background_actor_screen_size_changed (META_BACKGROUND_ACTOR (info->background_actor));
+  meta_background_actor_screen_size_changed (screen);
 
   meta_verbose ("Changed size for stage on screen %d to %dx%d\n",
 		meta_screen_get_screen_number (screen),
@@ -1093,6 +1157,36 @@ static void
 pre_paint_windows (MetaCompScreen *info)
 {
   GList *l;
+  MetaWindowActor *top_window;
+  MetaWindowActor *expected_unredirected_window = NULL;
+
+  if (info->windows == NULL)
+    return;
+
+  top_window = g_list_last (info->windows)->data;
+
+  if (meta_window_actor_should_unredirect (top_window) &&
+      info->disable_unredirect_count == 0)
+    expected_unredirected_window = top_window;
+
+  if (info->unredirected_window != expected_unredirected_window)
+    {
+      if (info->unredirected_window != NULL)
+        {
+          meta_window_actor_set_redirected (info->unredirected_window, TRUE);
+          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (info->unredirected_window)),
+                                     NULL);
+        }
+
+      if (expected_unredirected_window != NULL)
+        {
+          meta_shape_cow_for_window (meta_window_get_screen (meta_window_actor_get_meta_window (top_window)),
+                                     meta_window_actor_get_meta_window (top_window));
+          meta_window_actor_set_redirected (top_window, FALSE);
+        }
+
+      info->unredirected_window = expected_unredirected_window;
+    }
 
   for (l = info->windows; l; l = l->next)
     meta_window_actor_pre_paint (l->data);
@@ -1195,3 +1289,78 @@ meta_get_overlay_window (MetaScreen *screen)
 
   return info->output;
 }
+
+/**
+ * meta_disable_unredirect_for_screen:
+ * @screen: a #MetaScreen
+ *
+ * Disables unredirection, can be usefull in situations where having
+ * unredirected windows is undesireable like when recording a video.
+ *
+ */
+void
+meta_disable_unredirect_for_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  if (info != NULL)
+    info->disable_unredirect_count = info->disable_unredirect_count + 1;
+}
+
+/**
+ * meta_enable_unredirect_for_screen:
+ * @screen: a #MetaScreen
+ *
+ * Enables unredirection which reduces the overhead for apps like games.
+ *
+ */
+void
+meta_enable_unredirect_for_screen (MetaScreen *screen)
+{
+  MetaCompScreen *info = meta_screen_get_compositor_data (screen);
+  if (info != NULL)
+   info->disable_unredirect_count = MAX(0, info->disable_unredirect_count - 1);
+}
+
+#define FLASH_TIME_MS 50
+
+static void
+flash_out_completed (ClutterAnimation *animation,
+                     ClutterActor     *flash)
+{
+  clutter_actor_destroy (flash);
+}
+
+static void
+flash_in_completed (ClutterAnimation *animation,
+                    ClutterActor     *flash)
+{
+  clutter_actor_animate (flash, CLUTTER_EASE_IN_QUAD,
+                         FLASH_TIME_MS,
+                         "opacity", 0,
+                         "signal-after::completed", flash_out_completed, flash,
+                         NULL);
+}
+
+void
+meta_compositor_flash_screen (MetaCompositor *compositor,
+                              MetaScreen     *screen)
+{
+  ClutterActor *stage;
+  ClutterActor *flash;
+  ClutterColor black = { 0, 0, 0, 255 };
+  gfloat width, height;
+
+  stage = meta_get_stage_for_screen (screen);
+  clutter_actor_get_size (stage, &width, &height);
+
+  flash = clutter_rectangle_new_with_color (&black);
+  clutter_actor_set_size (flash, width, height);
+  clutter_actor_set_opacity (flash, 0);
+  clutter_container_add_actor (CLUTTER_CONTAINER (stage), flash);
+
+  clutter_actor_animate (flash, CLUTTER_EASE_OUT_QUAD,
+                         FLASH_TIME_MS,
+                         "opacity", 192,
+                         "signal-after::completed", flash_in_completed, flash,
+                         NULL);
+}

src/compositor/meta-background-actor-private.h

@@ -0,0 +1,15 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#ifndef META_BACKGROUND_ACTOR_PRIVATE_H
+#define META_BACKGROUND_ACTOR_PRIVATE_H
+
+#include <meta/screen.h>
+#include <meta/meta-background-actor.h>
+
+void meta_background_actor_set_visible_region  (MetaBackgroundActor *self,
+                                                cairo_region_t      *visible_region);
+
+void meta_background_actor_update              (MetaScreen *screen);
+void meta_background_actor_screen_size_changed (MetaScreen *screen);
+
+#endif /* META_BACKGROUND_ACTOR_PRIVATE_H */

src/compositor/meta-background-actor.c

@@ -32,72 +32,181 @@
 
 #include "cogl-utils.h"
 #include "compositor-private.h"
-#include "errors.h"
-#include "meta-background-actor.h"
+#include <meta/errors.h>
+#include "meta-background-actor-private.h"
 
-struct _MetaBackgroundActorClass
+/* We allow creating multiple MetaBackgroundActors for the same MetaScreen to
+ * allow different rendering options to be set for different copies.
+ * But we want to share the same underlying CoglTexture for efficiency and
+ * to avoid driver bugs that might occur if we created multiple CoglTexturePixmaps
+ * for the same pixmap.
+ *
+ * This structure holds common information.
+ */
+typedef struct _MetaScreenBackground MetaScreenBackground;
+
+struct _MetaScreenBackground
 {
-  ClutterActorClass parent_class;
-};
-
-struct _MetaBackgroundActor
-{
-  ClutterActor parent;
-
-  CoglHandle material;
   MetaScreen *screen;
-  cairo_region_t *visible_region;
+  GSList *actors;
+
   float texture_width;
   float texture_height;
-
+  CoglHandle texture;
+  CoglMaterialWrapMode wrap_mode;
   guint have_pixmap : 1;
 };
 
+struct _MetaBackgroundActorPrivate
+{
+  MetaScreenBackground *background;
+  CoglHandle material;
+  cairo_region_t *visible_region;
+  float dim_factor;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_DIM_FACTOR,
+
+  PROP_LAST
+};
+
+static GParamSpec *obj_props[PROP_LAST];
+
 G_DEFINE_TYPE (MetaBackgroundActor, meta_background_actor, CLUTTER_TYPE_ACTOR);
 
-static void
-update_wrap_mode (MetaBackgroundActor *self)
-{
-  int width, height;
-  CoglMaterialWrapMode wrap_mode;
+static void set_texture                (MetaScreenBackground *background,
+                                        CoglHandle            texture);
+static void set_texture_to_stage_color (MetaScreenBackground *background);
 
-  meta_screen_get_size (self->screen, &width, &height);
+static void
+on_notify_stage_color (GObject              *stage,
+                       GParamSpec           *pspec,
+                       MetaScreenBackground *background)
+{
+  if (!background->have_pixmap)
+    set_texture_to_stage_color (background);
+}
+
+static void
+free_screen_background (MetaScreenBackground *background)
+{
+  set_texture (background, COGL_INVALID_HANDLE);
+
+  if (background->screen != NULL)
+    {
+      ClutterActor *stage = meta_get_stage_for_screen (background->screen);
+      g_signal_handlers_disconnect_by_func (stage,
+                                            (gpointer) on_notify_stage_color,
+                                            background);
+      background->screen = NULL;
+    }
+}
+
+static MetaScreenBackground *
+meta_screen_background_get (MetaScreen *screen)
+{
+  MetaScreenBackground *background;
+
+  background = g_object_get_data (G_OBJECT (screen), "meta-screen-background");
+  if (background == NULL)
+    {
+      ClutterActor *stage;
+
+      background = g_new0 (MetaScreenBackground, 1);
+
+      background->screen = screen;
+      g_object_set_data_full (G_OBJECT (screen), "meta-screen-background",
+                              background, (GDestroyNotify) free_screen_background);
+
+      stage = meta_get_stage_for_screen (screen);
+      g_signal_connect (stage, "notify::color",
+                        G_CALLBACK (on_notify_stage_color), background);
+
+      meta_background_actor_update (screen);
+    }
+
+  return background;
+}
+
+static void
+update_wrap_mode_of_actor (MetaBackgroundActor *self)
+{
+  MetaBackgroundActorPrivate *priv = self->priv;
+
+  cogl_material_set_layer_wrap_mode (priv->material, 0, priv->background->wrap_mode);
+}
+
+static void
+update_wrap_mode (MetaScreenBackground *background)
+{
+  GSList *l;
+  int width, height;
+
+  meta_screen_get_size (background->screen, &width, &height);
 
   /* We turn off repeating when we have a full-screen pixmap to keep from
    * getting artifacts from one side of the image sneaking into the other
    * side of the image via bilinear filtering.
    */
-  if (width == self->texture_width && height == self->texture_height)
-    wrap_mode = COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE;
+  if (width == background->texture_width && height == background->texture_height)
+    background->wrap_mode = COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE;
   else
-    wrap_mode = COGL_MATERIAL_WRAP_MODE_REPEAT;
+    background->wrap_mode = COGL_MATERIAL_WRAP_MODE_REPEAT;
 
-  cogl_material_set_layer_wrap_mode (self->material, 0, wrap_mode);
+  for (l = background->actors; l; l = l->next)
+    update_wrap_mode_of_actor (l->data);
 }
 
 static void
-set_texture (MetaBackgroundActor *self,
-             CoglHandle           texture)
+set_texture_on_actor (MetaBackgroundActor *self)
 {
-  MetaDisplay *display;
-
-  display = meta_screen_get_display (self->screen);
+  MetaBackgroundActorPrivate *priv = self->priv;
+  MetaDisplay *display = meta_screen_get_display (priv->background->screen);
 
   /* This may trigger destruction of an old texture pixmap, which, if
    * the underlying X pixmap is already gone has the tendency to trigger
    * X errors inside DRI. For safety, trap errors */
   meta_error_trap_push (display);
-  cogl_material_set_layer (self->material, 0, texture);
+  cogl_material_set_layer (priv->material, 0, priv->background->texture);
   meta_error_trap_pop (display);
 
-  self->texture_width = cogl_texture_get_width (texture);
-  self->texture_height = cogl_texture_get_height (texture);
-
-  update_wrap_mode (self);
-
   clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
 }
 
+static void
+set_texture (MetaScreenBackground *background,
+             CoglHandle            texture)
+{
+  MetaDisplay *display = meta_screen_get_display (background->screen);
+  GSList *l;
+
+  /* This may trigger destruction of an old texture pixmap, which, if
+   * the underlying X pixmap is already gone has the tendency to trigger
+   * X errors inside DRI. For safety, trap errors */
+  meta_error_trap_push (display);
+  if (background->texture != COGL_INVALID_HANDLE)
+    {
+      cogl_handle_unref (background->texture);
+      background->texture = COGL_INVALID_HANDLE;
+    }
+  meta_error_trap_pop (display);
+
+  if (texture != COGL_INVALID_HANDLE)
+    background->texture = cogl_handle_ref (texture);
+
+  background->texture_width = cogl_texture_get_width (background->texture);
+  background->texture_height = cogl_texture_get_height (background->texture);
+
+  for (l = background->actors; l; l = l->next)
+    set_texture_on_actor (l->data);
+
+  update_wrap_mode (background);
+}
+
 /* Sets our material to paint with a 1x1 texture of the stage's background
  * color; doing this when we have no pixmap allows the application to turn
  * off painting the stage. There might be a performance benefit to
@@ -106,48 +215,42 @@ set_texture (MetaBackgroundActor *self,
  * actually pick up the (small?) performance win. This is just a fallback.
  */
 static void
-set_texture_to_stage_color (MetaBackgroundActor *self)
+set_texture_to_stage_color (MetaScreenBackground *background)
 {
-  ClutterActor *stage = meta_get_stage_for_screen (self->screen);
+  ClutterActor *stage = meta_get_stage_for_screen (background->screen);
   ClutterColor color;
   CoglHandle texture;
 
   clutter_stage_get_color (CLUTTER_STAGE (stage), &color);
-  texture = meta_create_color_texture_4ub (color.red, color.green,
-                                           color.blue, 0xff);
-  set_texture (self, texture);
-  cogl_handle_unref (texture);
-}
 
-static void
-on_notify_stage_color (GObject             *stage,
-                       GParamSpec          *pspec,
-                       MetaBackgroundActor *self)
-{
-  if (!self->have_pixmap)
-    set_texture_to_stage_color (self);
+  /* Slicing will prevent COGL from using hardware texturing for
+   * the tiled 1x1 pixmap, and will cause it to draw the window
+   * background in millions of separate 1x1 rectangles */
+  texture = meta_create_color_texture_4ub (color.red, color.green,
+                                           color.blue, 0xff,
+                                           COGL_TEXTURE_NO_SLICING);
+  set_texture (background, texture);
+  cogl_handle_unref (texture);
 }
 
 static void
 meta_background_actor_dispose (GObject *object)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
+  MetaBackgroundActorPrivate *priv = self->priv;
 
   meta_background_actor_set_visible_region (self, NULL);
 
-  if (self->material != COGL_INVALID_HANDLE)
+  if (priv->background != NULL)
     {
-      cogl_handle_unref (self->material);
-      self->material = COGL_INVALID_HANDLE;
+      priv->background->actors = g_slist_remove (priv->background->actors, self);
+      priv->background = NULL;
     }
 
-  if (self->screen != NULL)
+  if (priv->material != COGL_INVALID_HANDLE)
     {
-      ClutterActor *stage = meta_get_stage_for_screen (self->screen);
-      g_signal_handlers_disconnect_by_func (stage,
-                                            (gpointer) on_notify_stage_color,
-                                            self);
-      self->screen = NULL;
+      cogl_handle_unref (priv->material);
+      priv->material = COGL_INVALID_HANDLE;
     }
 }
 
@@ -158,14 +261,15 @@ meta_background_actor_get_preferred_width (ClutterActor *actor,
                                            gfloat       *natural_width_p)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  MetaBackgroundActorPrivate *priv = self->priv;
   int width, height;
 
-  meta_screen_get_size (self->screen, &width, &height);
+  meta_screen_get_size (priv->background->screen, &width, &height);
 
   if (min_width_p)
     *min_width_p = width;
   if (natural_width_p)
-    *natural_width_p = height;
+    *natural_width_p = width;
 }
 
 static void
@@ -176,9 +280,10 @@ meta_background_actor_get_preferred_height (ClutterActor *actor,
 
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  MetaBackgroundActorPrivate *priv = self->priv;
   int width, height;
 
-  meta_screen_get_size (self->screen, &width, &height);
+  meta_screen_get_size (priv->background->screen, &width, &height);
 
   if (min_height_p)
     *min_height_p = height;
@@ -190,28 +295,39 @@ static void
 meta_background_actor_paint (ClutterActor *actor)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  MetaBackgroundActorPrivate *priv = self->priv;
+  guint8 opacity = clutter_actor_get_paint_opacity (actor);
+  guint8 color_component;
   int width, height;
 
-  meta_screen_get_size (self->screen, &width, &height);
+  meta_screen_get_size (priv->background->screen, &width, &height);
 
-  cogl_set_source (self->material);
+  color_component = (int)(0.5 + opacity * priv->dim_factor);
 
-  if (self->visible_region)
+  cogl_material_set_color4ub (priv->material,
+                              color_component,
+                              color_component,
+                              color_component,
+                              opacity);
+
+  cogl_set_source (priv->material);
+
+  if (priv->visible_region)
     {
-      int n_rectangles = cairo_region_num_rectangles (self->visible_region);
+      int n_rectangles = cairo_region_num_rectangles (priv->visible_region);
       int i;
 
       for (i = 0; i < n_rectangles; i++)
         {
           cairo_rectangle_int_t rect;
-          cairo_region_get_rectangle (self->visible_region, i, &rect);
+          cairo_region_get_rectangle (priv->visible_region, i, &rect);
 
           cogl_rectangle_with_texture_coords (rect.x, rect.y,
                                               rect.x + rect.width, rect.y + rect.height,
-                                              rect.x / self->texture_width,
-                                              rect.y / self->texture_height,
-                                              (rect.x + rect.width) / self->texture_width,
-                                              (rect.y + rect.height) / self->texture_height);
+                                              rect.x / priv->background->texture_width,
+                                              rect.y / priv->background->texture_height,
+                                              (rect.x + rect.width) / priv->background->texture_width,
+                                              (rect.y + rect.height) / priv->background->texture_height);
         }
     }
   else
@@ -219,85 +335,160 @@ meta_background_actor_paint (ClutterActor *actor)
       cogl_rectangle_with_texture_coords (0.0f, 0.0f,
                                           width, height,
                                           0.0f, 0.0f,
-                                          width / self->texture_width,
-                                          height / self->texture_height);
+                                          width / priv->background->texture_width,
+                                          height / priv->background->texture_height);
     }
 }
 
-#if CLUTTER_CHECK_VERSION(1, 5, 2)
 static gboolean
 meta_background_actor_get_paint_volume (ClutterActor       *actor,
                                         ClutterPaintVolume *volume)
 {
   MetaBackgroundActor *self = META_BACKGROUND_ACTOR (actor);
+  MetaBackgroundActorPrivate *priv = self->priv;
   int width, height;
 
-  meta_screen_get_size (self->screen, &width, &height);
+  meta_screen_get_size (priv->background->screen, &width, &height);
 
   clutter_paint_volume_set_width (volume, width);
   clutter_paint_volume_set_height (volume, height);
 
   return TRUE;
 }
-#endif
+
+static void
+meta_background_actor_set_dim_factor (MetaBackgroundActor *self,
+                                      gfloat               dim_factor)
+{
+  MetaBackgroundActorPrivate *priv = self->priv;
+
+  if (priv->dim_factor == dim_factor)
+    return;
+
+  priv->dim_factor = dim_factor;
+
+  clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_DIM_FACTOR]);
+}
+
+static void
+meta_background_actor_get_property(GObject         *object,
+                                   guint            prop_id,
+                                   GValue          *value,
+                                   GParamSpec      *pspec)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
+  MetaBackgroundActorPrivate *priv = self->priv;
+
+  switch (prop_id)
+    {
+    case PROP_DIM_FACTOR:
+      g_value_set_float (value, priv->dim_factor);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+meta_background_actor_set_property(GObject         *object,
+                                   guint            prop_id,
+                                   const GValue    *value,
+                                   GParamSpec      *pspec)
+{
+  MetaBackgroundActor *self = META_BACKGROUND_ACTOR (object);
+
+  switch (prop_id)
+    {
+    case PROP_DIM_FACTOR:
+      meta_background_actor_set_dim_factor (self, g_value_get_float (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
 
 static void
 meta_background_actor_class_init (MetaBackgroundActorClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (klass, sizeof (MetaBackgroundActorPrivate));
 
   object_class->dispose = meta_background_actor_dispose;
+  object_class->get_property = meta_background_actor_get_property;
+  object_class->set_property = meta_background_actor_set_property;
 
   actor_class->get_preferred_width = meta_background_actor_get_preferred_width;
   actor_class->get_preferred_height = meta_background_actor_get_preferred_height;
   actor_class->paint = meta_background_actor_paint;
-#if CLUTTER_CHECK_VERSION(1, 5, 2)
   actor_class->get_paint_volume = meta_background_actor_get_paint_volume;
-#endif
+
+  /**
+   * MetaBackgroundActor:dim-factor:
+   *
+   * Factor to dim the background by, between 0.0 (black) and 1.0 (original
+   * colors)
+   */
+  pspec = g_param_spec_float ("dim-factor",
+                              "Dim factor",
+                              "Factor to dim the background by",
+                              0.0, 1.0,
+                              1.0,
+                              G_PARAM_READWRITE);
+  obj_props[PROP_DIM_FACTOR] = pspec;
+  g_object_class_install_property (object_class, PROP_DIM_FACTOR, pspec);
 }
 
 static void
-meta_background_actor_init (MetaBackgroundActor *background_actor)
+meta_background_actor_init (MetaBackgroundActor *self)
 {
+  MetaBackgroundActorPrivate *priv;
+
+  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+                                                   META_TYPE_BACKGROUND_ACTOR,
+                                                   MetaBackgroundActorPrivate);
+  priv->dim_factor = 1.0;
 }
 
 /**
- * @screen: the #MetaScreen
  * meta_background_actor_new:
+ * @screen: the #MetaScreen
  *
  * Creates a new actor to draw the background for the given screen.
  *
- * Return value: (transfer none): the newly created background actor
+ * Return value: the newly created background actor
  */
 ClutterActor *
-meta_background_actor_new (MetaScreen *screen)
+meta_background_actor_new_for_screen (MetaScreen *screen)
 {
   MetaBackgroundActor *self;
-  ClutterActor *stage;
+  MetaBackgroundActorPrivate *priv;
 
   g_return_val_if_fail (META_IS_SCREEN (screen), NULL);
 
   self = g_object_new (META_TYPE_BACKGROUND_ACTOR, NULL);
+  priv = self->priv;
 
-  self->screen = screen;
+  priv->background = meta_screen_background_get (screen);
+  priv->background->actors = g_slist_prepend (priv->background->actors, self);
 
-  self->material = meta_create_texture_material (NULL);
-  cogl_material_set_layer_wrap_mode (self->material, 0,
-                                     COGL_MATERIAL_WRAP_MODE_REPEAT);
+  priv->material = meta_create_texture_material (NULL);
 
-  stage = meta_get_stage_for_screen (self->screen);
-  g_signal_connect (stage, "notify::color",
-                    G_CALLBACK (on_notify_stage_color), self);
-
-  meta_background_actor_update (self);
+  set_texture_on_actor (self);
+  update_wrap_mode_of_actor (self);
 
   return CLUTTER_ACTOR (self);
 }
 
 /**
  * meta_background_actor_update:
- * @self: a #MetaBackgroundActor
+ * @screen: a #MetaScreen
  *
  * Refetches the _XROOTPMAP_ID property for the root window and updates
  * the contents of the background actor based on that. There's no attempt
@@ -307,8 +498,9 @@ meta_background_actor_new (MetaScreen *screen)
  * a PropertyNotify event for the property.
  */
 void
-meta_background_actor_update (MetaBackgroundActor *self)
+meta_background_actor_update (MetaScreen *screen)
 {
+  MetaScreenBackground *background;
   MetaDisplay *display;
   MetaCompositor *compositor;
   Atom type;
@@ -318,14 +510,13 @@ meta_background_actor_update (MetaBackgroundActor *self)
   guchar *data;
   Pixmap root_pixmap_id;
 
-  g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
-
-  display = meta_screen_get_display (self->screen);
+  background = meta_screen_background_get (screen);
+  display = meta_screen_get_display (screen);
   compositor = meta_display_get_compositor (display);
 
   root_pixmap_id = None;
   if (!XGetWindowProperty (meta_display_get_xdisplay (display),
-                           meta_screen_get_xroot  (self->screen),
+                           meta_screen_get_xroot (screen),
                            compositor->atom_x_root_pixmap,
                            0, LONG_MAX,
                            False,
@@ -353,16 +544,16 @@ meta_background_actor_update (MetaBackgroundActor *self)
 
       if (texture != COGL_INVALID_HANDLE)
         {
-          set_texture (self, texture);
+          set_texture (background, texture);
           cogl_handle_unref (texture);
 
-          self->have_pixmap = True;
+          background->have_pixmap = True;
           return;
         }
     }
 
-  self->have_pixmap = False;
-  set_texture_to_stage_color (self);
+  background->have_pixmap = False;
+  set_texture_to_stage_color (background);
 }
 
 /**
@@ -378,37 +569,46 @@ void
 meta_background_actor_set_visible_region (MetaBackgroundActor *self,
                                           cairo_region_t      *visible_region)
 {
+  MetaBackgroundActorPrivate *priv;
+
   g_return_if_fail (META_IS_BACKGROUND_ACTOR (self));
 
-  if (self->visible_region)
+  priv = self->priv;
+
+  if (priv->visible_region)
     {
-      cairo_region_destroy (self->visible_region);
-      self->visible_region = NULL;
+      cairo_region_destroy (priv->visible_region);
+      priv->visible_region = NULL;
     }
 
   if (visible_region)
     {
       cairo_rectangle_int_t screen_rect = { 0 };
-      meta_screen_get_size (self->screen, &screen_rect.width, &screen_rect.height);
+      meta_screen_get_size (priv->background->screen, &screen_rect.width, &screen_rect.height);
 
       /* Doing the intersection here is probably unnecessary - MetaWindowGroup
        * should never compute a visible area that's larger than the root screen!
        * but it's not that expensive and adds some extra robustness.
        */
-      self->visible_region = cairo_region_create_rectangle (&screen_rect);
-      cairo_region_intersect (self->visible_region, visible_region);
+      priv->visible_region = cairo_region_create_rectangle (&screen_rect);
+      cairo_region_intersect (priv->visible_region, visible_region);
     }
 }
 
 /**
  * meta_background_actor_screen_size_changed:
- * @self: a #MetaBackgroundActor
+ * @screen: a #MetaScreen
  *
  * Called by the compositor when the size of the #MetaScreen changes
  */
 void
-meta_background_actor_screen_size_changed (MetaBackgroundActor *self)
+meta_background_actor_screen_size_changed (MetaScreen *screen)
 {
-  update_wrap_mode (self);
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
+  MetaScreenBackground *background = meta_screen_background_get (screen);
+  GSList *l;
+
+  update_wrap_mode (background);
+
+  for (l = background->actors; l; l = l->next)
+    clutter_actor_queue_relayout (l->data);
 }

src/compositor/meta-module.c

@@ -21,7 +21,7 @@
  * 02111-1307, USA.
  */
 
-#include "meta-plugin.h"
+#include <meta/meta-plugin.h>
 #include "meta-module.h"
 
 #include <gmodule.h>

src/compositor/meta-plugin-manager.c

@@ -24,20 +24,18 @@
 #include "config.h"
 #include "compositor-private.h"
 #include "meta-plugin-manager.h"
-#include "prefs.h"
-#include "errors.h"
-#include "workspace.h"
+#include <meta/prefs.h>
+#include <meta/errors.h>
+#include <meta/workspace.h>
 #include "meta-module.h"
-#include "../core/window-private.h"
+#include "window-private.h"
 
 #include <string.h>
+#include <stdlib.h>
 
 #include <clutter/x11/clutter-x11.h>
 
-/*
- * There is only one instace of each module per the process.
- */
-static GHashTable *plugin_modules = NULL;
+static GSList *plugin_types;
 
 /*
  * We have one "default plugin manager" that acts for the first screen,
@@ -45,270 +43,79 @@ static GHashTable *plugin_modules = NULL;
  * plugin managers for each screen. (This is ugly. Probably we should
  * have one plugin manager and only make the plugins per-screen.)
  */
-
 static MetaPluginManager *default_plugin_manager;
 
-static gboolean meta_plugin_manager_reload (MetaPluginManager *plugin_mgr);
-
 struct MetaPluginManager
 {
   MetaScreen   *screen;
 
-  GList /* MetaPlugin */       *plugins;  /* TODO -- maybe use hash table */
-  GList                        *unload;  /* Plugins that are disabled and pending unload */
-
-  guint         idle_unload_id;
+  GList /* MetaPlugin */ *plugins;  /* TODO -- maybe use hash table */
 };
 
 /*
- * Checks that the plugin is compatible with the WM and sets up the plugin
- * struct.
+ * Loads the given plugin.
  */
-static MetaPlugin *
-meta_plugin_load (MetaPluginManager *mgr,
-                  MetaModule        *module,
-                  const gchar       *params)
-{
-  MetaPlugin *plugin = NULL;
-  GType         plugin_type = meta_module_get_plugin_type (module);
-
-  if (!plugin_type)
-    {
-      g_warning ("Plugin type not registered !!!");
-      return NULL;
-    }
-
-  plugin = g_object_new (plugin_type,
-                         "params", params,
-                         NULL);
-
-  return plugin;
-}
-
-/*
- * Attempst to unload a plugin; returns FALSE if plugin cannot be unloaded at
- * present (e.g., and effect is in progress) and should be scheduled for
- * removal later.
- */
-static gboolean
-meta_plugin_unload (MetaPlugin *plugin)
-{
-  if (meta_plugin_running (plugin))
-    {
-      g_object_set (plugin, "disabled", TRUE, NULL);
-      return FALSE;
-    }
-
-  g_object_unref (plugin);
-
-  return TRUE;
-}
-
-/*
- * Iddle callback to remove plugins that could not be removed directly and are
- * pending for removal.
- */
-static gboolean
-meta_plugin_manager_idle_unload (MetaPluginManager *plugin_mgr)
-{
-  GList *l = plugin_mgr->unload;
-  gboolean dont_remove = TRUE;
-
-  while (l)
-    {
-      MetaPlugin *plugin = l->data;
-
-      if (meta_plugin_unload (plugin))
-        {
-          /* Remove from list */
-          GList *p = l->prev;
-          GList *n = l->next;
-
-          if (!p)
-            plugin_mgr->unload = n;
-          else
-            p->next = n;
-
-          if (n)
-            n->prev = p;
-
-          g_list_free_1 (l);
-
-          l = n;
-        }
-      else
-        l = l->next;
-    }
-
-  if (!plugin_mgr->unload)
-    {
-      /* If no more unloads are pending, remove the handler as well */
-      dont_remove = FALSE;
-      plugin_mgr->idle_unload_id = 0;
-    }
-
-  return dont_remove;
-}
-
-/*
- * Unloads all plugins
- */
-static void
-meta_plugin_manager_unload (MetaPluginManager *plugin_mgr)
-{
-  GList *plugins = plugin_mgr->plugins;
-
-  while (plugins)
-    {
-      MetaPlugin *plugin = plugins->data;
-
-      /* If the plugin could not be removed, move it to the unload list */
-      if (!meta_plugin_unload (plugin))
-        {
-          plugin_mgr->unload = g_list_prepend (plugin_mgr->unload, plugin);
-
-          if (!plugin_mgr->idle_unload_id)
-            {
-              plugin_mgr->idle_unload_id = g_idle_add ((GSourceFunc)
-                            meta_plugin_manager_idle_unload,
-                            plugin_mgr);
-            }
-        }
-
-      plugins = plugins->next;
-    }
-
-  g_list_free (plugin_mgr->plugins);
-  plugin_mgr->plugins = NULL;
-}
-
-static void
-prefs_changed_callback (MetaPreference pref,
-                        void          *data)
-{
-  MetaPluginManager *plugin_mgr = data;
-
-  if (pref == META_PREF_CLUTTER_PLUGINS)
-    {
-      meta_plugin_manager_reload (plugin_mgr);
-    }
-}
-
-static MetaModule *
-meta_plugin_manager_get_module (const gchar *path)
-{
-  MetaModule *module = g_hash_table_lookup (plugin_modules, path);
-
-  if (!module &&
-      (module = g_object_new (META_TYPE_MODULE, "path", path, NULL)))
-    {
-      g_hash_table_insert (plugin_modules, g_strdup (path), module);
-    }
-
-  return module;
-}
-
-/*
- * Loads all plugins listed in gconf registry.
- */
-gboolean
-meta_plugin_manager_load (MetaPluginManager *plugin_mgr)
+void
+meta_plugin_manager_load (MetaPluginManager *plugin_mgr,
+                          const gchar       *plugin_name)
 {
   const gchar *dpath = MUTTER_PLUGIN_DIR "/";
-  GSList      *plugins, *fallback = NULL;
+  gchar       *path;
+  MetaModule  *module;
+  GType        plugin_type;
 
-  plugins = meta_prefs_get_clutter_plugins ();
+  if (g_path_is_absolute (plugin_name))
+    path = g_strdup (plugin_name);
+  else
+    path = g_strconcat (dpath, plugin_name, ".so", NULL);
 
-  if (!plugins)
+  module = g_object_new (META_TYPE_MODULE, "path", path, NULL);
+  if (!module || !g_type_module_use (G_TYPE_MODULE (module)))
     {
-      /*
-       * If no plugins are specified, try to load the default plugin.
+      /* This is fatal under the assumption that a monitoring
+       * process like gnome-session will take over and handle
+       * our untimely exit.
        */
-      fallback = g_slist_append (fallback, "default");
-      plugins = fallback;
+      g_printerr ("Unable to load plugin module [%s]: %s",
+                  path, g_module_error());
+      exit (1);
     }
 
-  while (plugins)
-    {
-      gchar   *plugin_string;
-      gchar   *params;
+  plugin_type = meta_module_get_plugin_type (module);
+  meta_plugin_manager_register (plugin_mgr, plugin_type);
 
-      plugin_string = g_strdup (plugins->data);
-
-      if (plugin_string)
-        {
-          MetaModule *module;
-          gchar        *path;
-
-          params = strchr (plugin_string, ':');
-
-          if (params)
-            {
-              *params = 0;
-              ++params;
-            }
-
-          if (g_path_is_absolute (plugin_string))
-            path = g_strdup (plugin_string);
-          else
-            path = g_strconcat (dpath, plugin_string, ".so", NULL);
-
-          module = meta_plugin_manager_get_module (path);
-
-          if (module)
-            {
-              gboolean      use_succeeded;
-
-              /*
-               * This dlopens the module and registers the plugin type with the
-               * GType system, if the module is not already loaded.  When we
-               * create a plugin, the type system also calls g_type_module_use()
-               * to guarantee the module will not be unloaded during the plugin
-               * life time. Consequently we can unuse() the module again.
-               */
-              use_succeeded = g_type_module_use (G_TYPE_MODULE (module));
-
-              if (use_succeeded)
-                {
-                  MetaPlugin *plugin = meta_plugin_load (plugin_mgr, module, params);
-
-                  if (plugin)
-                    plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
-                  else
-                    g_warning ("Plugin load for [%s] failed", path);
-
-                  g_type_module_unuse (G_TYPE_MODULE (module));
-                }
-            }
-          else
-            g_warning ("Unable to load plugin module [%s]: %s",
-                       path, g_module_error());
-
-          g_free (path);
-          g_free (plugin_string);
-        }
-
-      plugins = plugins->next;
-    }
-
-
-  if (fallback)
-    g_slist_free (fallback);
-
-  if (plugin_mgr->plugins != NULL)
-    {
-      meta_prefs_add_listener (prefs_changed_callback, plugin_mgr);
-      return TRUE;
-    }
-
-  return FALSE;
+  g_type_module_unuse (G_TYPE_MODULE (module));
+  g_free (path);
 }
 
-gboolean
+/*
+ * Registers the given plugin type
+ */
+void
+meta_plugin_manager_register (MetaPluginManager *plugin_mgr,
+                              GType              plugin_type)
+{
+  MetaPlugin  *plugin;
+
+  plugin_types = g_slist_prepend (plugin_types, GSIZE_TO_POINTER (plugin_type));
+
+  plugin = g_object_new (plugin_type, NULL);
+  plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
+}
+
+void
 meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr)
 {
   GList *iter;
 
+  if (!plugin_mgr->plugins)
+    {
+      /*
+       * If no plugins are specified, load the default plugin.
+       */
+      meta_plugin_manager_load (plugin_mgr, "default");
+    }
+
   for (iter = plugin_mgr->plugins; iter; iter = iter->next)
     {
       MetaPlugin *plugin = (MetaPlugin*) iter->data;
@@ -321,26 +128,6 @@ meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr)
       if (klass->start)
         klass->start (plugin);
     }
-
-  return TRUE;
-}
-
-/*
- * Reloads all plugins
- */
-static gboolean
-meta_plugin_manager_reload (MetaPluginManager *plugin_mgr)
-{
-  /* TODO -- brute force; should we build a list of plugins to load and list of
-   * plugins to unload? We are probably not going to have large numbers of
-   * plugins loaded at the same time, so it might not be worth it.
-   */
-
-  /* Prevent stale grabs on unloaded plugins */
-  meta_check_end_modal (plugin_mgr->screen);
-
-  meta_plugin_manager_unload (plugin_mgr);
-  return meta_plugin_manager_load (plugin_mgr);
 }
 
 static MetaPluginManager *
@@ -348,15 +135,8 @@ meta_plugin_manager_new (MetaScreen *screen)
 {
   MetaPluginManager *plugin_mgr;
 
-  if (!plugin_modules)
-    {
-      plugin_modules = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
-                                              NULL);
-    }
-
   plugin_mgr = g_new0 (MetaPluginManager, 1);
-
-  plugin_mgr->screen        = screen;
+  plugin_mgr->screen = screen;
 
   if (screen)
     g_object_set_data (G_OBJECT (screen), "meta-plugin-manager", plugin_mgr);
@@ -397,7 +177,20 @@ meta_plugin_manager_get (MetaScreen *screen)
     }
   else
     {
-      return meta_plugin_manager_new (screen);
+      GSList *iter;
+      GType plugin_type;
+      MetaPlugin *plugin;
+
+      plugin_mgr = meta_plugin_manager_new (screen);
+
+      for (iter = plugin_types; iter; iter = iter->next)
+        {
+          plugin_type = (GType)GPOINTER_TO_SIZE (iter->data);
+          plugin = g_object_new (plugin_type, "screen", screen,  NULL);
+          plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
+        }
+
+      return plugin_mgr;
     }
 }
 

src/compositor/meta-plugin-manager.h

@@ -24,11 +24,11 @@
 #ifndef META_PLUGIN_MANAGER_H_
 #define META_PLUGIN_MANAGER_H_
 
-#include "types.h"
-#include "screen.h"
+#include <meta/types.h>
+#include <meta/screen.h>
 
 #define  META_PLUGIN_FROM_MANAGER_
-#include "meta-plugin.h"
+#include <meta/meta-plugin.h>
 #undef   META_PLUGIN_FROM_MANAGER_
 
 #define META_PLUGIN_MINIMIZE         (1<<0)
@@ -49,8 +49,12 @@ typedef struct MetaPluginManager MetaPluginManager;
 MetaPluginManager * meta_plugin_manager_get         (MetaScreen *screen);
 MetaPluginManager * meta_plugin_manager_get_default (void);
 
-gboolean meta_plugin_manager_load         (MetaPluginManager *mgr);
-gboolean meta_plugin_manager_initialize   (MetaPluginManager *plugin_mgr);
+void     meta_plugin_manager_load         (MetaPluginManager *mgr,
+                                           const gchar       *plugin_name);
+void     meta_plugin_manager_register     (MetaPluginManager *mgr,
+                                           GType              plugin_type);
+void     meta_plugin_manager_initialize   (MetaPluginManager *mgr);
+
 gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr,
                                            MetaWindowActor   *actor,
                                            unsigned long      event);

src/compositor/meta-plugin.c

@@ -21,9 +21,10 @@
  * 02111-1307, USA.
  */
 
-#include "meta-plugin.h"
-#include "screen.h"
-#include "display.h"
+#include <meta/meta-plugin.h>
+#include "meta-plugin-manager.h"
+#include <meta/screen.h>
+#include <meta/display.h>
 
 #include <string.h>
 #include <X11/Xlib.h>
@@ -43,7 +44,6 @@ enum
 {
   PROP_0,
   PROP_SCREEN,
-  PROP_PARAMS,
   PROP_FEATURES,
   PROP_DISABLED,
   PROP_DEBUG_MODE,
@@ -52,7 +52,6 @@ enum
 struct _MetaPluginPrivate
 {
   MetaScreen   *screen;
-  gchar        *params;
   gulong        features;
 
   gint          running;
@@ -61,6 +60,46 @@ struct _MetaPluginPrivate
   gboolean      debug    : 1;
 };
 
+static void
+meta_plugin_set_features (MetaPlugin *plugin)
+{
+  MetaPluginPrivate  *priv     = plugin->priv;
+  MetaPluginClass    *klass    = META_PLUGIN_GET_CLASS (plugin);
+
+  priv->features = 0;
+
+  /*
+   * Feature flags: identify events that the plugin can handle; a plugin can
+   * handle one or more events.
+   */
+  if (klass->minimize)
+    priv->features |= META_PLUGIN_MINIMIZE;
+
+  if (klass->maximize)
+    priv->features |= META_PLUGIN_MAXIMIZE;
+
+  if (klass->unmaximize)
+    priv->features |= META_PLUGIN_UNMAXIMIZE;
+
+  if (klass->map)
+    priv->features |= META_PLUGIN_MAP;
+
+  if (klass->destroy)
+    priv->features |= META_PLUGIN_DESTROY;
+
+  if (klass->switch_workspace)
+    priv->features |= META_PLUGIN_SWITCH_WORKSPACE;
+}
+
+static void
+meta_plugin_constructed (GObject *object)
+{
+  meta_plugin_set_features (META_PLUGIN (object));
+
+  if (G_OBJECT_CLASS (meta_plugin_parent_class)->constructed)
+      G_OBJECT_CLASS (meta_plugin_parent_class)->constructed (object);
+}
+
 static void
 meta_plugin_dispose (GObject *object)
 {
@@ -70,97 +109,9 @@ meta_plugin_dispose (GObject *object)
 static void
 meta_plugin_finalize (GObject *object)
 {
-  MetaPluginPrivate *priv = META_PLUGIN (object)->priv;
-
-  g_free (priv->params);
-  priv->params = NULL;
-
   G_OBJECT_CLASS (meta_plugin_parent_class)->finalize (object);
 }
 
-static void
-meta_plugin_parse_params (MetaPlugin *plugin)
-{
-  char                  *p;
-  gulong                features = 0;
-  MetaPluginPrivate  *priv     = plugin->priv;
-  MetaPluginClass    *klass    = META_PLUGIN_GET_CLASS (plugin);
-
-/*
- * Feature flags: identify events that the plugin can handle; a plugin can
- * handle one or more events.
- */
-  if (klass->minimize)
-    features |= META_PLUGIN_MINIMIZE;
-
-  if (klass->maximize)
-    features |= META_PLUGIN_MAXIMIZE;
-
-  if (klass->unmaximize)
-    features |= META_PLUGIN_UNMAXIMIZE;
-
-  if (klass->map)
-    features |= META_PLUGIN_MAP;
-
-  if (klass->destroy)
-    features |= META_PLUGIN_DESTROY;
-
-  if (klass->switch_workspace)
-    features |= META_PLUGIN_SWITCH_WORKSPACE;
-
-  if (priv->params)
-    {
-      gboolean debug = FALSE;
-
-      if ((p = strstr (priv->params, "disable:")))
-        {
-          gchar *d = g_strdup (p+8);
-
-          p = strchr (d, ';');
-
-          if (p)
-            *p = 0;
-
-          if (strstr (d, "minimize"))
-            features &= ~ META_PLUGIN_MINIMIZE;
-
-          if (strstr (d, "maximize"))
-            features &= ~ META_PLUGIN_MAXIMIZE;
-
-          if (strstr (d, "unmaximize"))
-            features &= ~ META_PLUGIN_UNMAXIMIZE;
-
-          if (strstr (d, "map"))
-            features &= ~ META_PLUGIN_MAP;
-
-          if (strstr (d, "destroy"))
-            features &= ~ META_PLUGIN_DESTROY;
-
-          if (strstr (d, "switch-workspace"))
-            features &= ~META_PLUGIN_SWITCH_WORKSPACE;
-
-          g_free (d);
-        }
-
-      if (strstr (priv->params, "debug"))
-        debug = TRUE;
-
-      if (debug != priv->debug)
-        {
-          priv->debug = debug;
-
-          g_object_notify (G_OBJECT (plugin), "debug-mode");
-        }
-    }
-
-  if (features != priv->features)
-    {
-      priv->features = features;
-
-      g_object_notify (G_OBJECT (plugin), "features");
-    }
-}
-
 static void
 meta_plugin_set_property (GObject      *object,
                           guint         prop_id,
@@ -174,10 +125,6 @@ meta_plugin_set_property (GObject      *object,
     case PROP_SCREEN:
       priv->screen = g_value_get_object (value);
       break;
-    case PROP_PARAMS:
-      priv->params = g_value_dup_string (value);
-      meta_plugin_parse_params (META_PLUGIN (object));
-      break;
     case PROP_DISABLED:
       priv->disabled = g_value_get_boolean (value);
       break;
@@ -203,9 +150,6 @@ meta_plugin_get_property (GObject    *object,
     case PROP_SCREEN:
       g_value_set_object (value, priv->screen);
       break;
-    case PROP_PARAMS:
-      g_value_set_string (value, priv->params);
-      break;
     case PROP_DISABLED:
       g_value_set_boolean (value, priv->disabled);
       break;
@@ -227,6 +171,7 @@ meta_plugin_class_init (MetaPluginClass *klass)
 {
   GObjectClass      *gobject_class = G_OBJECT_CLASS (klass);
 
+  gobject_class->constructed     = meta_plugin_constructed;
   gobject_class->finalize        = meta_plugin_finalize;
   gobject_class->dispose         = meta_plugin_dispose;
   gobject_class->set_property    = meta_plugin_set_property;
@@ -240,15 +185,6 @@ meta_plugin_class_init (MetaPluginClass *klass)
                                                         META_TYPE_SCREEN,
                                                         G_PARAM_READWRITE));
 
-  g_object_class_install_property (gobject_class,
-				   PROP_PARAMS,
-				   g_param_spec_string ("params",
-							"Parameters",
-							"Plugin Parameters",
-							NULL,
-							G_PARAM_READWRITE |
-                                                        G_PARAM_CONSTRUCT));
-
   g_object_class_install_property (gobject_class,
 				   PROP_FEATURES,
 				   g_param_spec_ulong ("features",
@@ -613,3 +549,18 @@ meta_plugin_get_screen (MetaPlugin *plugin)
   return priv->screen;
 }
 
+/**
+ * meta_plugin_type_register:
+ * @plugin_type: a #MetaPlugin type
+ *
+ * Register @plugin_type as a compositor plugin type to be used.
+ * You must call this before calling meta_init().
+ */
+void
+meta_plugin_type_register (GType plugin_type)
+{
+  MetaPluginManager *plugin_manager;
+
+  plugin_manager = meta_plugin_manager_get_default ();
+  meta_plugin_manager_register (plugin_manager, plugin_type);
+}

src/compositor/meta-shadow-factory-private.h

@@ -28,7 +28,7 @@
 #include <cairo.h>
 #include <clutter/clutter.h>
 #include "meta-window-shape.h"
-#include "meta-shadow-factory.h"
+#include <meta/meta-shadow-factory.h>
 
 /**
  * MetaShadow:
@@ -47,7 +47,8 @@ void        meta_shadow_paint       (MetaShadow            *shadow,
                                      int                    window_width,
                                      int                    window_height,
                                      guint8                 opacity,
-                                     cairo_region_t        *clip);
+                                     cairo_region_t        *clip,
+                                     gboolean               clip_strictly);
 void        meta_shadow_get_bounds  (MetaShadow            *shadow,
                                      int                    window_x,
                                      int                    window_y,

src/compositor/meta-shadow-factory.c

@@ -120,17 +120,17 @@ static guint signals[LAST_SIGNAL] = { 0 };
 /* The first element in this array also defines the default parameters
  * for newly created classes */
 MetaShadowClassInfo default_shadow_classes[] = {
-  { "normal",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
-  { "dialog",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
-  { "modal_dialog", { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
-  { "utility",      { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
-  { "border",       { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
-  { "menu",         { 12, -1, 0, 8, 255 }, { 6, -1, 0, 4, 255 } },
+  { "normal",       { 6, -1, 0, 3, 255 }, { 3, -1, 0, 3, 128 } },
+  { "dialog",       { 6, -1, 0, 3, 255 }, { 3, -1, 0, 3, 128 } },
+  { "modal_dialog", { 6, -1, 0, 1, 255 }, { 3, -1, 0, 3, 128 } },
+  { "utility",      { 3, -1, 0, 1, 255 }, { 3, -1, 0, 1, 128 } },
+  { "border",       { 6, -1, 0, 3, 255 }, { 3, -1, 0, 3, 128 } },
+  { "menu",         { 6, -1, 0, 3, 255 }, { 3, -1, 0, 0, 128 } },
 
-  { "popup-menu",    { 6, -1, 0, 4, 255 }, { 6, -1, 0, 4, 255 } },
+  { "popup-menu",    { 1, -1, 0, 1, 128 }, { 1, -1, 0, 1, 128 } },
 
-  { "dropdown-menu", { 6, 25, 0, 4, 255 }, { 6, 100, 0, 4, 255 } },
-  { "attached",      { 6, 25, 0, 4, 255 }, { 6, 100, 0, 4, 255 } }
+  { "dropdown-menu", { 1, 10, 0, 1, 128 }, { 1, 10, 0, 1, 128 } },
+  { "attached",      { 2, 50, 0, 1, 255 }, { 1, 50, 0, 1, 128 } }
 };
 
 G_DEFINE_TYPE (MetaShadowFactory, meta_shadow_factory, G_TYPE_OBJECT);
@@ -189,8 +189,10 @@ meta_shadow_unref (MetaShadow *shadow)
  * @window_width: actual width of the region to paint a shadow for
  * @window_height: actual height of the region to paint a shadow for
  * @clip: (allow-none): if non-%NULL specifies the visible portion
- *   of the shadow. Drawing won't be strictly clipped to this region
- *   but it will be used to optimize what is drawn.
+ *   of the shadow.
+ * @clip_strictly: if %TRUE, drawing will be clipped strictly
+ *   to @clip, otherwise, it will be only used to optimize
+ *   drawing.
  *
  * Paints the shadow at the given position, for the specified actual
  * size of the region. (Since a #MetaShadow can be shared between
@@ -204,7 +206,8 @@ meta_shadow_paint (MetaShadow     *shadow,
                    int             window_width,
                    int             window_height,
                    guint8          opacity,
-                   cairo_region_t *clip)
+                   cairo_region_t *clip,
+                   gboolean        clip_strictly)
 {
   float texture_width = cogl_texture_get_width (shadow->texture);
   float texture_height = cogl_texture_get_height (shadow->texture);
@@ -276,6 +279,9 @@ meta_shadow_paint (MetaShadow     *shadow,
       dest_rect.y = dest_y[j];
       dest_rect.height = dest_y[j + 1] - dest_y[j];
 
+      if (dest_rect.height == 0)
+        continue;
+
       for (i = 0; i < n_x; i++)
         {
           cairo_region_overlap_t overlap;
@@ -283,16 +289,64 @@ meta_shadow_paint (MetaShadow     *shadow,
           dest_rect.x = dest_x[i];
           dest_rect.width = dest_x[i + 1] - dest_x[i];
 
+          if (dest_rect.width == 0)
+            continue;
+
           if (clip)
             overlap = cairo_region_contains_rectangle (clip, &dest_rect);
           else
-            overlap = CAIRO_REGION_OVERLAP_PART;
+            overlap = CAIRO_REGION_OVERLAP_IN;
 
-          if (overlap != CAIRO_REGION_OVERLAP_OUT)
-            cogl_rectangle_with_texture_coords (dest_x[i], dest_y[j],
-                                                dest_x[i + 1], dest_y[j + 1],
-                                                src_x[i], src_y[j],
-                                                src_x[i + 1], src_y[j + 1]);
+          /* There's quite a bit of overhead from allocating a new
+           * region in order to find an exact intersection and
+           * generating more geometry - we make the assumption that
+           * unless we have to clip strictly it will be cheaper to
+           * just draw the entire rectangle.
+           */
+          if (overlap == CAIRO_REGION_OVERLAP_IN ||
+              (overlap == CAIRO_REGION_OVERLAP_PART && !clip_strictly))
+            {
+              cogl_rectangle_with_texture_coords (dest_x[i], dest_y[j],
+                                                  dest_x[i + 1], dest_y[j + 1],
+                                                  src_x[i], src_y[j],
+                                                  src_x[i + 1], src_y[j + 1]);
+            }
+          else if (overlap == CAIRO_REGION_OVERLAP_PART)
+            {
+              cairo_region_t *intersection;
+              int n_rectangles, k;
+
+              intersection = cairo_region_create_rectangle (&dest_rect);
+              cairo_region_intersect (intersection, clip);
+
+              n_rectangles = cairo_region_num_rectangles (intersection);
+              for (k = 0; k < n_rectangles; k++)
+                {
+                  cairo_rectangle_int_t rect;
+                  float src_x1, src_x2, src_y1, src_y2;
+
+                  cairo_region_get_rectangle (intersection, k, &rect);
+
+                  /* Separately linear interpolate X and Y coordinates in the source
+                   * based on the destination X and Y coordinates */
+
+                  src_x1 = (src_x[i] * (dest_rect.x + dest_rect.width - rect.x) +
+                            src_x[i + 1] * (rect.x - dest_rect.x)) / dest_rect.width;
+                  src_x2 = (src_x[i] * (dest_rect.x + dest_rect.width - (rect.x + rect.width)) +
+                            src_x[i + 1] * (rect.x + rect.width - dest_rect.x)) / dest_rect.width;
+
+                  src_y1 = (src_y[j] * (dest_rect.y + dest_rect.height - rect.y) +
+                            src_y[j + 1] * (rect.y - dest_rect.y)) / dest_rect.height;
+                  src_y2 = (src_y[j] * (dest_rect.y + dest_rect.height - (rect.y + rect.height)) +
+                            src_y[j + 1] * (rect.y + rect.height - dest_rect.y)) / dest_rect.height;
+
+                  cogl_rectangle_with_texture_coords (rect.x, rect.y,
+                                                      rect.x + rect.width, rect.y + rect.height,
+                                                      src_x1, src_y1, src_x2, src_y2);
+                }
+
+              cairo_region_destroy (intersection);
+            }
         }
     }
 }
@@ -317,7 +371,7 @@ meta_shadow_get_bounds  (MetaShadow            *shadow,
                          cairo_rectangle_int_t *bounds)
 {
   bounds->x = window_x - shadow->outer_border_left;
-  bounds->y = window_x - shadow->outer_border_top;
+  bounds->y = window_y - shadow->outer_border_top;
   bounds->width = window_width + shadow->outer_border_left + shadow->outer_border_right;
   bounds->height = window_height + shadow->outer_border_top + shadow->outer_border_bottom;
 }

src/compositor/meta-shaped-texture.c

@@ -27,13 +27,13 @@
 
 #include "meta-shaped-texture.h"
 #include "meta-texture-tower.h"
+#include "meta-texture-rectangle.h"
 
 #include <clutter/clutter.h>
 #include <cogl/cogl.h>
 #include <string.h>
 
 static void meta_shaped_texture_dispose  (GObject    *object);
-static void meta_shaped_texture_finalize (GObject    *object);
 static void meta_shaped_texture_notify   (GObject    *object,
 					  GParamSpec *pspec);
 
@@ -49,13 +49,8 @@ static void meta_shaped_texture_update_area (ClutterX11TexturePixmap *texture,
 
 static void meta_shaped_texture_dirty_mask (MetaShapedTexture *stex);
 
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
-               CLUTTER_GLX_TYPE_TEXTURE_PIXMAP);
-#else /* HAVE_GLX_TEXTURE_PIXMAP */
 G_DEFINE_TYPE (MetaShapedTexture, meta_shaped_texture,
                CLUTTER_X11_TYPE_TEXTURE_PIXMAP);
-#endif /* HAVE_GLX_TEXTURE_PIXMAP */
 
 #define META_SHAPED_TEXTURE_GET_PRIVATE(obj) \
   (G_TYPE_INSTANCE_GET_PRIVATE ((obj), META_TYPE_SHAPED_TEXTURE, \
@@ -69,11 +64,15 @@ struct _MetaShapedTexturePrivate
   CoglHandle material_unshaped;
 
   cairo_region_t *clip_region;
+  cairo_region_t *shape_region;
+
+  cairo_region_t *overlay_region;
+  cairo_path_t *overlay_path;
+
+  cairo_region_t *visible_pixels_region;
 
   guint mask_width, mask_height;
 
-  GArray *rectangles;
-
   guint create_mipmaps : 1;
 };
 
@@ -85,7 +84,6 @@ meta_shaped_texture_class_init (MetaShapedTextureClass *klass)
   ClutterX11TexturePixmapClass *x11_texture_class = (ClutterX11TexturePixmapClass *) klass;
 
   gobject_class->dispose = meta_shaped_texture_dispose;
-  gobject_class->finalize = meta_shaped_texture_finalize;
   gobject_class->notify = meta_shaped_texture_notify;
 
   actor_class->paint = meta_shaped_texture_paint;
@@ -103,8 +101,10 @@ meta_shaped_texture_init (MetaShapedTexture *self)
 
   priv = self->priv = META_SHAPED_TEXTURE_GET_PRIVATE (self);
 
-  priv->rectangles = g_array_new (FALSE, FALSE, sizeof (XRectangle));
-
+  priv->shape_region = NULL;
+  priv->overlay_path = NULL;
+  priv->overlay_region = NULL;
+  priv->visible_pixels_region = NULL;
   priv->paint_tower = meta_texture_tower_new ();
   priv->mask_texture = COGL_INVALID_HANDLE;
   priv->create_mipmaps = TRUE;
@@ -133,22 +133,13 @@ meta_shaped_texture_dispose (GObject *object)
       priv->material_unshaped = COGL_INVALID_HANDLE;
     }
 
+  meta_shaped_texture_set_shape_region (self, NULL);
   meta_shaped_texture_set_clip_region (self, NULL);
+  meta_shaped_texture_set_overlay_path (self, NULL, NULL);
 
   G_OBJECT_CLASS (meta_shaped_texture_parent_class)->dispose (object);
 }
 
-static void
-meta_shaped_texture_finalize (GObject *object)
-{
-  MetaShapedTexture *self = (MetaShapedTexture *) object;
-  MetaShapedTexturePrivate *priv = self->priv;
-
-  g_array_free (priv->rectangles, TRUE);
-
-  G_OBJECT_CLASS (meta_shaped_texture_parent_class)->finalize (object);
-}
-
 static void
 meta_shaped_texture_notify (GObject    *object,
 			    GParamSpec *pspec)
@@ -179,25 +170,139 @@ meta_shaped_texture_dirty_mask (MetaShapedTexture *stex)
 {
   MetaShapedTexturePrivate *priv = stex->priv;
 
-  if (priv->mask_texture != COGL_INVALID_HANDLE)
+  if (priv->visible_pixels_region != NULL)
     {
-      GLuint mask_gl_tex;
-      GLenum mask_gl_target;
+      cairo_region_destroy (priv->visible_pixels_region);
+      priv->visible_pixels_region = NULL;
 
-      cogl_texture_get_gl_texture (priv->mask_texture,
-                                   &mask_gl_tex, &mask_gl_target);
-
-      if (mask_gl_target == GL_TEXTURE_RECTANGLE_ARB)
-        glDeleteTextures (1, &mask_gl_tex);
-
-      cogl_handle_unref (priv->mask_texture);
-      priv->mask_texture = COGL_INVALID_HANDLE;
+      if (priv->mask_texture != COGL_INVALID_HANDLE)
+        {
+          cogl_handle_unref (priv->mask_texture);
+          priv->mask_texture = COGL_INVALID_HANDLE;
+        }
 
       if (priv->material != COGL_INVALID_HANDLE)
         cogl_material_set_layer (priv->material, 1, COGL_INVALID_HANDLE);
     }
 }
 
+static void
+scan_visible_region (MetaShapedTexture *stex,
+                     guchar            *mask_data,
+                     int                stride)
+{
+  MetaShapedTexturePrivate *priv = stex->priv;
+  cairo_region_t *visible_pixels_region;
+  cairo_region_t *overlay_region;
+  int i, n_rects;
+
+  /* The visible pixels region contains all pixel values above 0.
+   * This is somewhat complicated when there's an overlay: we
+   * need to scan all regions potentially modified by it.
+   */
+
+  if (priv->visible_pixels_region)
+    cairo_region_destroy (priv->visible_pixels_region);
+
+  priv->visible_pixels_region = cairo_region_copy (priv->shape_region);
+
+  visible_pixels_region = priv->visible_pixels_region;
+  overlay_region = priv->overlay_region;
+
+  /* With no overlay region, the visible region is defined
+   * by the mask region, so we don't need to scan anything. */
+  if (overlay_region == NULL)
+      return;
+
+  /* Subtract all the rectangles in the overlay region so that we can
+   * scan all the pixels potentially added by the overlay path. */
+  cairo_region_subtract (visible_pixels_region, overlay_region);
+
+  n_rects = cairo_region_num_rectangles (overlay_region);
+
+  for (i = 0; i < n_rects; i++)
+    {
+      int x, y;
+      cairo_rectangle_int_t rect;
+
+      cairo_region_get_rectangle (overlay_region, i, &rect);
+
+      for (y = rect.y; y < (rect.y + rect.height); y++)
+        {
+          for (x = rect.x; x < (rect.x + rect.width); x++)
+            {
+              int w = x;
+              while (mask_data[y * stride + w] > 0 && w < (rect.x + rect.width))
+                w++;
+
+              if (w > 0)
+                {
+                  cairo_rectangle_int_t tmp;
+                  tmp.x = x;
+                  tmp.y = y;
+                  tmp.width = w - x;
+                  tmp.height = 1;
+                  cairo_region_union_rectangle (visible_pixels_region, &tmp);
+                  x = w;
+                }
+            }
+        }
+    }
+}
+
+static void
+install_overlay_path (MetaShapedTexture *stex,
+                      guchar            *mask_data,
+                      int                tex_width,
+                      int                tex_height,
+                      int                stride)
+{
+  MetaShapedTexturePrivate *priv = stex->priv;
+  int i, n_rects;
+  cairo_t *cr;
+  cairo_rectangle_int_t rect;
+  cairo_surface_t *surface;
+
+  if (priv->overlay_region == NULL)
+    return;
+
+  surface = cairo_image_surface_create_for_data (mask_data,
+                                                 CAIRO_FORMAT_A8,
+                                                 tex_width,
+                                                 tex_height,
+                                                 stride);
+
+  cr = cairo_create (surface);
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+
+  n_rects = cairo_region_num_rectangles (priv->overlay_region);
+  for (i = 0; i < n_rects; i++)
+    {
+      cairo_region_get_rectangle (priv->overlay_region, i, &rect);
+      cairo_rectangle (cr, rect.x, rect.y, rect.width, rect.height);
+    }
+
+  cairo_fill_preserve (cr);
+  if (priv->overlay_path == NULL)
+    {
+      /* If we have an overlay region but not an overlay path, then we
+       * just need to clear the rectangles in the overlay region. */
+      goto out;
+    }
+
+  cairo_clip (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+  cairo_set_source_rgba (cr, 1, 1, 1, 1);
+
+  cairo_append_path (cr, priv->overlay_path);
+  cairo_fill (cr);
+
+ out:
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+}
+
 static void
 meta_shaped_texture_ensure_mask (MetaShapedTexture *stex)
 {
@@ -220,22 +325,42 @@ meta_shaped_texture_ensure_mask (MetaShapedTexture *stex)
     meta_shaped_texture_dirty_mask (stex);
 
   /* If we don't have a mask texture yet then create one */
-  if (priv->mask_texture == COGL_INVALID_HANDLE)
+  if (priv->visible_pixels_region == NULL)
     {
       guchar *mask_data;
-      const XRectangle *rect;
+      int i;
+      int n_rects;
+      int stride;
       GLenum paint_gl_target;
 
-      /* Create data for an empty image */
-      mask_data = g_malloc0 (tex_width * tex_height);
-
-      /* Cut out a hole for each rectangle */
-      for (rect = (XRectangle *) priv->rectangles->data
-             + priv->rectangles->len;
-           rect-- > (XRectangle *) priv->rectangles->data;)
+      /* If we have no shape region and no (or an empty) overlay region, we
+       * don't need to create a full mask texture, so quit early. */
+      if (priv->shape_region == NULL &&
+          (priv->overlay_region == NULL ||
+           cairo_region_num_rectangles (priv->overlay_region) == 0))
         {
-          gint x1 = rect->x, x2 = x1 + rect->width;
-          gint y1 = rect->y, y2 = y1 + rect->height;
+          /* With no mask, the visible region is just
+           * {0, 0, tex_width, tex_height}. */
+          cairo_rectangle_int_t rect = { 0, 0, tex_width, tex_height };
+          priv->visible_pixels_region = cairo_region_create_rectangle (&rect);
+          return;
+        }
+
+      stride = cairo_format_stride_for_width (CAIRO_FORMAT_A8, tex_width);
+
+      /* Create data for an empty image */
+      mask_data = g_malloc0 (stride * tex_height);
+
+      n_rects = cairo_region_num_rectangles (priv->shape_region);
+
+      /* Fill in each rectangle. */
+      for (i = 0; i < n_rects; i ++)
+        {
+          cairo_rectangle_int_t rect;
+          cairo_region_get_rectangle (priv->shape_region, i, &rect);
+
+          gint x1 = rect.x, x2 = x1 + rect.width;
+          gint y1 = rect.y, y2 = y1 + rect.height;
           guchar *p;
 
           /* Clip the rectangle to the size of the texture */
@@ -245,41 +370,40 @@ meta_shaped_texture_ensure_mask (MetaShapedTexture *stex)
           y2 = CLAMP (y2, y1, (gint) tex_height);
 
           /* Fill the rectangle */
-          for (p = mask_data + y1 * tex_width + x1;
+          for (p = mask_data + y1 * stride + x1;
                y1 < y2;
-               y1++, p += tex_width)
+               y1++, p += stride)
             memset (p, 255, x2 - x1);
         }
 
+      install_overlay_path (stex, mask_data, tex_width, tex_height, stride);
+      scan_visible_region (stex, mask_data, stride);
+
       cogl_texture_get_gl_texture (paint_tex, NULL, &paint_gl_target);
 
+#ifdef GL_TEXTURE_RECTANGLE_ARB
       if (paint_gl_target == GL_TEXTURE_RECTANGLE_ARB)
         {
-          GLuint tex;
-
-          glGenTextures (1, &tex);
-          glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
-          glPixelStorei (GL_UNPACK_ROW_LENGTH, tex_width);
-          glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-          glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
-          glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
-          glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
-                        GL_ALPHA, tex_width, tex_height,
-                        0, GL_ALPHA, GL_UNSIGNED_BYTE, mask_data);
-
           priv->mask_texture
-            = cogl_texture_new_from_foreign (tex,
-                                             GL_TEXTURE_RECTANGLE_ARB,
-                                             tex_width, tex_height,
-                                             0, 0,
-                                             COGL_PIXEL_FORMAT_A_8);
+            = meta_texture_rectangle_new (tex_width, tex_height,
+                                          0, /* flags */
+                                          /* data format */
+                                          COGL_PIXEL_FORMAT_A_8,
+                                          /* internal GL format */
+                                          GL_ALPHA,
+                                          /* internal cogl format */
+                                          COGL_PIXEL_FORMAT_A_8,
+                                          /* rowstride */
+                                          stride,
+                                          mask_data);
         }
       else
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
         priv->mask_texture = cogl_texture_new_from_data (tex_width, tex_height,
                                                          COGL_TEXTURE_NONE,
                                                          COGL_PIXEL_FORMAT_A_8,
                                                          COGL_PIXEL_FORMAT_ANY,
-                                                         tex_width,
+                                                         stride,
                                                          mask_data);
 
       g_free (mask_data);
@@ -338,9 +462,9 @@ meta_shaped_texture_paint (ClutterActor *actor)
   if (tex_width == 0 || tex_height == 0) /* no contents yet */
     return;
 
-  if (priv->rectangles->len < 1)
+  if (priv->shape_region == NULL)
     {
-      /* If there are no rectangles use a single-layer texture */
+      /* No region means an unclipped shape. Use a single-layer texture. */
 
       if (priv->material_unshaped == COGL_INVALID_HANDLE) 
         {
@@ -440,8 +564,8 @@ meta_shaped_texture_pick (ClutterActor       *actor,
   MetaShapedTexture *stex = (MetaShapedTexture *) actor;
   MetaShapedTexturePrivate *priv = stex->priv;
 
-  /* If there are no rectangles then use the regular pick */
-  if (priv->rectangles->len < 1)
+  /* If there is no region then use the regular pick */
+  if (priv->shape_region == NULL)
     CLUTTER_ACTOR_CLASS (meta_shaped_texture_parent_class)
       ->pick (actor, color);
   else if (clutter_actor_should_pick_paint (actor))
@@ -561,7 +685,8 @@ meta_shaped_texture_clear (MetaShapedTexture *stex)
 }
 
 void
-meta_shaped_texture_clear_rectangles (MetaShapedTexture *stex)
+meta_shaped_texture_set_shape_region (MetaShapedTexture *stex,
+                                      cairo_region_t    *region)
 {
   MetaShapedTexturePrivate *priv;
 
@@ -569,40 +694,85 @@ meta_shaped_texture_clear_rectangles (MetaShapedTexture *stex)
 
   priv = stex->priv;
 
-  g_array_set_size (priv->rectangles, 0);
-  meta_shaped_texture_dirty_mask (stex);
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
-}
+  if (priv->shape_region != NULL)
+    {
+      cairo_region_destroy (priv->shape_region);
+      priv->shape_region = NULL;
+    }
 
-void
-meta_shaped_texture_add_rectangle (MetaShapedTexture *stex,
-				   const XRectangle  *rect)
-{
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  meta_shaped_texture_add_rectangles (stex, 1, rect);
-}
-
-void
-meta_shaped_texture_add_rectangles (MetaShapedTexture *stex,
-				    size_t             num_rects,
-				    const XRectangle  *rects)
-{
-  MetaShapedTexturePrivate *priv;
-
-  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
-
-  priv = stex->priv;
-
-  g_array_append_vals (priv->rectangles, rects, num_rects);
+  if (region != NULL)
+    {
+      cairo_region_reference (region);
+      priv->shape_region = region;
+    }
 
   meta_shaped_texture_dirty_mask (stex);
   clutter_actor_queue_redraw (CLUTTER_ACTOR (stex));
 }
 
+/**
+ * meta_shaped_texture_get_visible_pixels_region:
+ * @stex: a #MetaShapedTexture
+ *
+ * Return a region enclosing only visible pixels: those with
+ * alpha values above 0.
+ *
+ * Returns: a #cairo_region_t
+ */
+cairo_region_t *
+meta_shaped_texture_get_visible_pixels_region (MetaShapedTexture *stex)
+{
+  g_return_val_if_fail (META_IS_SHAPED_TEXTURE (stex), NULL);
+
+  meta_shaped_texture_ensure_mask (stex);
+  return stex->priv->visible_pixels_region;
+}
+
+/**
+ * meta_shaped_texture_set_overlay_path:
+ * @stex: a #MetaShapedTexture
+ * @overlay_region: A region containing the parts of the mask to overlay.
+ *   All rectangles in this region are wiped clear to full transparency,
+ *   and the overlay path is clipped to this region.
+ * @overlay_path (transfer full): This path will be painted onto the mask
+ *   texture with a fully opaque source. Due to the lack of refcounting
+ *   in #cairo_path_t, ownership of the path is assumed.
+ */
+void
+meta_shaped_texture_set_overlay_path (MetaShapedTexture *stex,
+                                      cairo_region_t    *overlay_region,
+                                      cairo_path_t      *overlay_path)
+{
+  MetaShapedTexturePrivate *priv;
+
+  g_return_if_fail (META_IS_SHAPED_TEXTURE (stex));
+
+  priv = stex->priv;
+
+  if (priv->overlay_region != NULL)
+    {
+      cairo_region_destroy (priv->overlay_region);
+      priv->overlay_region = NULL;
+    }
+
+  if (priv->overlay_path != NULL)
+    {
+      cairo_path_destroy (priv->overlay_path);
+      priv->overlay_path = NULL;
+    }
+
+  cairo_region_reference (overlay_region);
+  priv->overlay_region = overlay_region;
+
+  /* cairo_path_t does not have refcounting. */
+  priv->overlay_path = overlay_path;
+
+  meta_shaped_texture_dirty_mask (stex);
+}
+
 /**
  * meta_shaped_texture_set_clip_region:
- * @frame: a #TidyTextureframe
+ * @frame: a #MetaShapedTexture
  * @clip_region: (transfer full): the region of the texture that
  *   is visible and should be painted. OWNERSHIP IS ASSUMED BY
  *   THE FUNCTION (for efficiency to avoid a copy.)

src/compositor/meta-shaped-texture.h

@@ -29,9 +29,7 @@
 #include <config.h>
 
 #include <clutter/clutter.h>
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-#include <clutter/glx/clutter-glx.h>
-#endif /* HAVE_GLX_TEXTURE_PIXMAP */
+#include <clutter/x11/clutter-x11.h>
 
 G_BEGIN_DECLS
 
@@ -48,20 +46,12 @@ typedef struct _MetaShapedTexturePrivate MetaShapedTexturePrivate;
 
 struct _MetaShapedTextureClass
 {
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-  ClutterGLXTexturePixmapClass parent_class;
-#else
   ClutterX11TexturePixmapClass parent_class;
-#endif
 };
 
 struct _MetaShapedTexture
 {
-#ifdef HAVE_GLX_TEXTURE_PIXMAP
-  ClutterGLXTexturePixmap parent;
-#else
   ClutterX11TexturePixmap parent;
-#endif
 
   MetaShapedTexturePrivate *priv;
 };
@@ -75,13 +65,14 @@ void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
 
 void meta_shaped_texture_clear (MetaShapedTexture *stex);
 
-void meta_shaped_texture_clear_rectangles (MetaShapedTexture *stex);
+void meta_shaped_texture_set_shape_region (MetaShapedTexture *stex,
+                                           cairo_region_t    *region);
 
-void meta_shaped_texture_add_rectangle  (MetaShapedTexture *stex,
-					 const XRectangle  *rect);
-void meta_shaped_texture_add_rectangles (MetaShapedTexture *stex,
-					 size_t             num_rects,
-					 const XRectangle  *rects);
+cairo_region_t *meta_shaped_texture_get_visible_pixels_region (MetaShapedTexture *stex);
+
+void meta_shaped_texture_set_overlay_path (MetaShapedTexture *stex,
+                                           cairo_region_t    *overlay_region,
+                                           cairo_path_t      *overlay_path);
 
 /* Assumes ownership of clip_region */
 void meta_shaped_texture_set_clip_region (MetaShapedTexture *stex,

src/compositor/meta-texture-rectangle.c

@@ -0,0 +1,118 @@
+/*
+ * texture rectangle
+ *
+ * A small utility function to help create a rectangle texture
+ *
+ * Authored By Neil Roberts  <neil@linux.intel.com>
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "meta-texture-rectangle.h"
+
+#ifdef GL_TEXTURE_RECTANGLE_ARB
+
+static void (* pf_glGetIntegerv) (GLenum pname, GLint *params);
+static void (* pf_glTexImage2D) (GLenum target, GLint level,
+                                 GLint internalFormat,
+                                 GLsizei width, GLsizei height,
+                                 GLint border, GLenum format, GLenum type,
+                                 const GLvoid *pixels);
+static void (* pf_glGenTextures) (GLsizei n, GLuint *textures);
+static void (* pf_glDeleteTextures) (GLsizei n, const GLuint *texture);
+static void (* pf_glBindTexture) (GLenum target, GLuint texture);
+
+static void
+rectangle_texture_destroy_cb (void *user_data)
+{
+  GLuint tex = GPOINTER_TO_UINT (user_data);
+
+  pf_glDeleteTextures (1, &tex);
+}
+
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
+
+CoglHandle
+meta_texture_rectangle_new (unsigned int width,
+                            unsigned int height,
+                            CoglTextureFlags flags,
+                            CoglPixelFormat format,
+                            GLenum internal_gl_format,
+                            GLenum internal_format,
+                            unsigned int rowstride,
+                            const guint8 *data)
+{
+  CoglHandle cogl_tex = COGL_INVALID_HANDLE;
+
+#ifdef GL_TEXTURE_RECTANGLE_ARB
+
+  static CoglUserDataKey user_data_key;
+  GLint old_binding;
+  GLuint tex;
+
+  if (pf_glGenTextures == NULL)
+    {
+      pf_glGetIntegerv = (void *) cogl_get_proc_address ("glGetIntegerv");
+      pf_glTexImage2D = (void *) cogl_get_proc_address ("glTexImage2D");
+      pf_glGenTextures = (void *) cogl_get_proc_address ("glGenTextures");
+      pf_glDeleteTextures = (void *) cogl_get_proc_address ("glDeleteTextures");
+      pf_glBindTexture = (void *) cogl_get_proc_address ("glBindTexture");
+    }
+
+  pf_glGenTextures (1, &tex);
+  pf_glGetIntegerv (GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
+  pf_glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
+  pf_glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
+                   internal_gl_format, width, height,
+                   0, internal_gl_format,
+                   GL_UNSIGNED_BYTE, NULL);
+  pf_glBindTexture (GL_TEXTURE_RECTANGLE_ARB, old_binding);
+
+  cogl_tex = cogl_texture_new_from_foreign (tex,
+                                            GL_TEXTURE_RECTANGLE_ARB,
+                                            width, height,
+                                            0, 0, /* no waste */
+                                            internal_format);
+
+  /* Cogl won't destroy the GL texture when a foreign texture is used
+     so we need to destroy it manually. We can set a destroy
+     notification callback to do this transparently */
+  cogl_object_set_user_data (cogl_tex,
+                             &user_data_key,
+                             GUINT_TO_POINTER (tex),
+                             rectangle_texture_destroy_cb);
+
+  /* Use cogl_texture_set_region instead of uploading the data
+     directly with GL calls so that we can let Cogl deal with setting
+     the pixel store parameters and handling format conversion */
+  if (data)
+    cogl_texture_set_region (cogl_tex,
+                             0, 0, /* src x/y */
+                             0, 0, /* dst x/y */
+                             width, height, /* dst width/height */
+                             width, height, /* src width/height */
+                             format,
+                             rowstride,
+                             data);
+
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
+
+  return cogl_tex;
+}

src/compositor/meta-texture-rectangle.h

@@ -0,0 +1,45 @@
+/*
+ * texture rectangle
+ *
+ * A small utility function to help create a rectangle texture
+ *
+ * Authored By Neil Roberts  <neil@linux.intel.com>
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef __META_TEXTURE_RECTANGLE_H__
+#define __META_TEXTURE_RECTANGLE_H__
+
+#include <cogl/cogl.h>
+
+G_BEGIN_DECLS
+
+CoglHandle
+meta_texture_rectangle_new (unsigned int width,
+                            unsigned int height,
+                            CoglTextureFlags flags,
+                            CoglPixelFormat format,
+                            GLenum internal_gl_format,
+                            GLenum internal_format,
+                            unsigned int rowstride,
+                            const guint8 *data);
+
+G_END_DECLS
+
+#endif /* __META_TEXTURE_RECTANGLE_H__ */

src/compositor/meta-texture-tower.c

@@ -26,6 +26,7 @@
 #include <string.h>
 
 #include "meta-texture-tower.h"
+#include "meta-texture-rectangle.h"
 
 #ifndef M_LOG2E
 #define M_LOG2E 1.4426950408889634074
@@ -97,6 +98,7 @@ meta_texture_tower_free (MetaTextureTower *tower)
   g_slice_free (MetaTextureTower, tower);
 }
 
+#ifdef GL_TEXTURE_RECTANGLE_ARB
 static gboolean
 texture_is_rectangle (CoglHandle texture)
 {
@@ -106,24 +108,11 @@ texture_is_rectangle (CoglHandle texture)
   cogl_texture_get_gl_texture (texture, &gl_tex, &gl_target);
   return gl_target == GL_TEXTURE_RECTANGLE_ARB;
 }
-
-static void
-free_texture (CoglHandle texture)
-{
-  GLuint gl_tex;
-  GLenum gl_target;
-
-  cogl_texture_get_gl_texture (texture, &gl_tex, &gl_target);
-
-  if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
-    glDeleteTextures (1, &gl_tex);
-
-  cogl_handle_unref (texture);
-}
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
 
 /**
- * meta_texture_tower_update_area:
- * @tower: a MetaTextureTower
+ * meta_texture_tower_set_base_texture:
+ * @tower: a #MetaTextureTower
  * @texture: the new texture used as a base for scaled down versions
  *
  * Sets the base texture that is the scaled texture that the
@@ -148,7 +137,7 @@ meta_texture_tower_set_base_texture (MetaTextureTower *tower,
         {
           if (tower->textures[i] != COGL_INVALID_HANDLE)
             {
-              free_texture (tower->textures[i]);
+              cogl_handle_unref (tower->textures[i]);
               tower->textures[i] = COGL_INVALID_HANDLE;
             }
 
@@ -186,7 +175,7 @@ meta_texture_tower_set_base_texture (MetaTextureTower *tower,
 
 /**
  * meta_texture_tower_update_area:
- * @tower: a MetaTextureTower
+ * @tower: a #MetaTextureTower
  * @x: X coordinate of upper left of rectangle that changed
  * @y: Y coordinate of upper left of rectangle that changed
  * @width: width of rectangle that changed
@@ -362,11 +351,13 @@ get_paint_level (int width, int height)
     return (int)(0.5 + lambda);
 }
 
+#ifdef GL_TEXTURE_RECTANGLE_ARB
 static gboolean
 is_power_of_two (int x)
 {
   return (x & (x - 1)) == 0;
 }
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
 
 static void
 texture_tower_create_texture (MetaTextureTower *tower,
@@ -374,28 +365,25 @@ texture_tower_create_texture (MetaTextureTower *tower,
                               int               width,
                               int               height)
 {
+#ifdef GL_TEXTURE_RECTANGLE_ARB
   if ((!is_power_of_two (width) || !is_power_of_two (height)) &&
       texture_is_rectangle (tower->textures[level - 1]))
     {
-      GLuint tex = 0;
-
-      glGenTextures (1, &tex);
-      glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
-      glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0,
-                    GL_RGBA, width,height,
-#if TEXTURE_FORMAT == COGL_PIXEL_FORMAT_BGRA_8888_PRE
-                    0, GL_BGRA, GL_UNSIGNED_BYTE,
-#else /* assume big endian */
-                    0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
-#endif
-                    NULL);
-
-      tower->textures[level] = cogl_texture_new_from_foreign (tex, GL_TEXTURE_RECTANGLE_ARB,
-                                                              width, height,
-                                                              0, 0,
-                                                              TEXTURE_FORMAT);
+      tower->textures[level] =
+        meta_texture_rectangle_new (width, height,
+                                    0, /* flags */
+                                    /* data format */
+                                    TEXTURE_FORMAT,
+                                    /* internal GL format */
+                                    GL_RGBA,
+                                    /* internal cogl format */
+                                    TEXTURE_FORMAT,
+                                    /* rowstride */
+                                    width * 4,
+                                    NULL);
     }
   else
+#endif /* GL_TEXTURE_RECTANGLE_ARB */
     {
       tower->textures[level] = cogl_texture_new_with_size (width, height,
                                                            COGL_TEXTURE_NO_AUTO_MIPMAP,
@@ -422,12 +410,7 @@ texture_tower_revalidate_fbo (MetaTextureTower *tower,
   CoglMatrix modelview;
 
   if (tower->fbos[level] == COGL_INVALID_HANDLE)
-    {
-      /* Work around http://bugzilla.openedhand.com/show_bug.cgi?id=2110 */
-      cogl_flush();
-
-      tower->fbos[level] = cogl_offscreen_new_to_texture (dest_texture);
-    }
+    tower->fbos[level] = cogl_offscreen_new_to_texture (dest_texture);
 
   if (tower->fbos[level] == COGL_INVALID_HANDLE)
     return FALSE;
@@ -596,7 +579,7 @@ texture_tower_revalidate (MetaTextureTower *tower,
 
 /**
  * meta_texture_tower_get_paint_texture:
- * @tower: a MetaTextureTower
+ * @tower: a #MetaTextureTower
  *
  * Gets the texture from the tower that best matches the current
  * rendering scale. (On the assumption here the texture is going to

src/compositor/meta-window-actor-private.h

@@ -6,7 +6,7 @@
 #include <config.h>
 
 #include <X11/extensions/Xdamage.h>
-#include "compositor-mutter.h"
+#include <meta/compositor-mutter.h>
 
 MetaWindowActor *meta_window_actor_new (MetaWindow *window);
 
@@ -26,15 +26,22 @@ void meta_window_actor_unmaximize (MetaWindowActor *self,
 
 void meta_window_actor_process_damage (MetaWindowActor    *self,
                                        XDamageNotifyEvent *event);
+
 void meta_window_actor_pre_paint      (MetaWindowActor    *self);
 
 void meta_window_actor_invalidate_shadow (MetaWindowActor *self);
 
+void meta_window_actor_set_redirected (MetaWindowActor *self, gboolean state);
+
+gboolean meta_window_actor_should_unredirect (MetaWindowActor *self);
+
+void meta_window_actor_get_shape_bounds (MetaWindowActor       *self,
+                                          cairo_rectangle_int_t *bounds);
+
 gboolean meta_window_actor_effect_in_progress  (MetaWindowActor *self);
 void     meta_window_actor_sync_actor_position (MetaWindowActor *self);
 void     meta_window_actor_sync_visibility     (MetaWindowActor *self);
-void     meta_window_actor_update_shape        (MetaWindowActor *self,
-                                                gboolean         shaped);
+void     meta_window_actor_update_shape        (MetaWindowActor *self);
 void     meta_window_actor_update_opacity      (MetaWindowActor *self);
 void     meta_window_actor_mapped              (MetaWindowActor *self);
 void     meta_window_actor_unmapped            (MetaWindowActor *self);

src/compositor/meta-window-group.c

@@ -7,9 +7,10 @@
 
 #include <gdk/gdk.h> /* for gdk_rectangle_intersect() */
 
+#include "compositor-private.h"
 #include "meta-window-actor-private.h"
 #include "meta-window-group.h"
-#include "meta-background-actor.h"
+#include "meta-background-actor-private.h"
 
 struct _MetaWindowGroupClass
 {
@@ -103,12 +104,19 @@ actor_is_untransformed (ClutterActor *actor,
 static void
 meta_window_group_paint (ClutterActor *actor)
 {
-  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
   cairo_region_t *visible_region;
-  GLboolean scissor_test;
-  cairo_rectangle_int_t screen_rect = { 0 };
-  cairo_rectangle_int_t scissor_rect;
-  GList *children, *l;
+  cairo_region_t *unredirected_window_region = NULL;
+  ClutterActor *stage;
+  cairo_rectangle_int_t visible_rect, unredirected_rect;
+  GList *children, *l, *effects;
+
+  MetaWindowGroup *window_group = META_WINDOW_GROUP (actor);
+  MetaCompScreen *info = meta_screen_get_compositor_data (window_group->screen);
+  if (info->unredirected_window != NULL)
+    {
+      meta_window_actor_get_shape_bounds (META_WINDOW_ACTOR (info->unredirected_window), &unredirected_rect);
+      unredirected_window_region = cairo_region_create_rectangle (&unredirected_rect);
+    }
 
   /* We walk the list from top to bottom (opposite of painting order),
    * and subtract the opaque area of each window out of the visible
@@ -117,45 +125,48 @@ meta_window_group_paint (ClutterActor *actor)
   children = clutter_container_get_children (CLUTTER_CONTAINER (actor));
   children = g_list_reverse (children);
 
-  /* Start off with the full screen area (for a multihead setup, we
-   * might want to use a more accurate union of the monitors to avoid
-   * painting in holes from mismatched monitor sizes. That's just an
-   * optimization, however.)
-   */
-  meta_screen_get_size (window_group->screen, &screen_rect.width, &screen_rect.height);
+  /* Get the clipped redraw bounds from Clutter so that we can avoid
+   * painting shadows on windows that don't need to be painted in this
+   * frame. In the case of a multihead setup with mismatched monitor
+   * sizes, we could intersect this with an accurate union of the
+   * monitors to avoid painting shadows that are visible only in the
+   * holes. */
+  stage = clutter_actor_get_stage (actor);
+  clutter_stage_get_redraw_clip_bounds (CLUTTER_STAGE (stage),
+                                        &visible_rect);
 
-  /* When doing a partial stage paint, Clutter will set the GL scissor
-   * box to the clip rectangle for the partial repaint. We combine the screen
-   * rectangle with the scissor box to get the region we need to
-   * paint. (Strangely, the scissor box sometimes seems to be bigger
-   * than the stage ... Clutter should probably be clampimg)
-   */
-  glGetBooleanv (GL_SCISSOR_TEST, &scissor_test);
+  visible_region = cairo_region_create_rectangle (&visible_rect);
 
-  if (scissor_test)
-    {
-      GLint scissor_box[4];
-      glGetIntegerv (GL_SCISSOR_BOX, scissor_box);
-
-      scissor_rect.x = scissor_box[0];
-      scissor_rect.y = screen_rect.height - (scissor_box[1] + scissor_box[3]);
-      scissor_rect.width = scissor_box[2];
-      scissor_rect.height = scissor_box[3];
-
-      gdk_rectangle_intersect (&scissor_rect, &screen_rect, &scissor_rect);
-    }
-  else
-    {
-      scissor_rect = screen_rect;
-    }
-
-  visible_region = cairo_region_create_rectangle (&scissor_rect);
+  if (unredirected_window_region)
+    cairo_region_subtract (visible_region, unredirected_window_region);
 
   for (l = children; l; l = l->next)
     {
       if (!CLUTTER_ACTOR_IS_VISIBLE (l->data))
         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 ((effects = clutter_actor_get_effects (l->data)) != NULL)
+        {
+          g_list_free (effects);
+          continue;
+        }
+
       if (META_IS_WINDOW_ACTOR (l->data))
         {
           MetaWindowActor *window_actor = l->data;
@@ -188,6 +199,9 @@ meta_window_group_paint (ClutterActor *actor)
 
   cairo_region_destroy (visible_region);
 
+  if (unredirected_window_region)
+    cairo_region_destroy (unredirected_window_region);
+
   CLUTTER_ACTOR_CLASS (meta_window_group_parent_class)->paint (actor);
 
   /* Now that we are done painting, unset the visible regions (they will

src/compositor/meta-window-group.h

@@ -5,7 +5,7 @@
 
 #include <clutter/clutter.h>
 
-#include "screen.h"
+#include <meta/screen.h>
 
 /**
  * MetaWindowGroup:

src/compositor/plugins/Makefile.am

@@ -1,7 +1,7 @@
 
 pkglibdir=@MUTTER_PLUGIN_DIR@
 
-INCLUDES=@MUTTER_CFLAGS@ -I $(top_srcdir)/src/include -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
+INCLUDES=@MUTTER_CFLAGS@ -I $(top_srcdir)/src -DMUTTER_LIBEXECDIR=\"$(libexecdir)\" -DHOST_ALIAS=\"@HOST_ALIAS@\" -DMUTTER_LOCALEDIR=\"$(prefix)/@DATADIRNAME@/locale\" -DMUTTER_PKGDATADIR=\"$(pkgdatadir)\" -DMUTTER_DATADIR=\"$(datadir)\" -DG_LOG_DOMAIN=\"mutter\" -DSN_API_NOT_YET_FROZEN=1 -DMUTTER_MAJOR_VERSION=$(MUTTER_MAJOR_VERSION) -DMUTTER_MINOR_VERSION=$(MUTTER_MINOR_VERSION) -DMUTTER_MICRO_VERSION=$(MUTTER_MICRO_VERSION) -DMUTTER_PLUGIN_API_VERSION=$(MUTTER_PLUGIN_API_VERSION) -DMUTTER_PLUGIN_DIR=\"@MUTTER_PLUGIN_DIR@\"
 
 default_la_CFLAGS   = -fPIC
 default_la_SOURCES  = default.c

src/compositor/plugins/README

@@ -1,41 +0,0 @@
-
-Plugins implement effects associated with WM events, such as window map,
-minimizing, maximizing, unmaximizing, destruction and workspace switching. The
-plugin API is documented in src/include/compositor-clutter-plugin.h; in
-addition the simple plugin can be used as a reference implementation.
-
-The API is intended to be generic, exposing no implementation details of the WM
-to the plugins; this will facilitate reuse without modification with another WM
-(there are plans to use the same plugin API with Matchbox 2).
-
-Multiple plugins can implement the same effect and be loaded at the same time;
-however, stacking arbitrary effects in this way might not work as expected;
-this is particularly true of more complex effects, such as those for workspace
-switching.
-
-Plugins are installed in ${prefix}/lib/metacity/plugins/clutter; from there the
-WM will load plugins listed in the clutter_plugins key in the Metacity gconf
-general preferences group. Each entry in preferences has the format
-
-  'name: optional parameters'
-
-where 'name' is the name of the library without the .so suffix.
-
-As noted above, additional parameters can be passed to the plugin via the
-preference key. In such case, the plugin name is immediately followed by a
-colon, separating it from the parameters. Two common parameters should be
-handled by all plugins:
-
-  'debug'   indicates that the plugin is run in a debug mode (what exactly that
-            means is left to the plugin to determine).
-
-  'disable' parameter indicates which effects within the plugin should be
-            disabled; the format of the disable parameter is
-
-              'disable: effect1[, effect2];'
-
-            where effect1, etc., matches the effects listed in the
-            compositor-clutter-plugin.h file (currently one of 'map', 'destroy',
-            'maximize', 'unmaximize', 'switch-workspace'). Example 'disable:
-            minimize, maximize;'.
-

src/compositor/plugins/default.c

@@ -21,8 +21,8 @@
  * 02111-1307, USA.
  */
 
-#include "meta-plugin.h"
-#include "window.h"
+#include <meta/meta-plugin.h>
+#include <meta/window.h>
 
 #include <libintl.h>
 #define _(x) dgettext (GETTEXT_PACKAGE, x)
@@ -319,12 +319,10 @@ switch_workspace (MetaPlugin *plugin,
 {
   MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv;
   GList        *l;
-  gint          n_workspaces;
   ClutterActor *workspace0  = clutter_group_new ();
   ClutterActor *workspace1  = clutter_group_new ();
   ClutterActor *stage;
   int           screen_width, screen_height;
-  MetaScreen   *screen = meta_plugin_get_screen (plugin);
   ClutterAnimation *animation;
 
   stage = meta_plugin_get_stage (plugin);
@@ -350,8 +348,6 @@ switch_workspace (MetaPlugin *plugin,
       return;
     }
 
-  n_workspaces = meta_screen_get_n_workspaces (screen);
-
   l = g_list_last (meta_plugin_get_window_actors (plugin));
 
   while (l)

src/compositor/region-utils.c

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

src/core/above-tab-keycode.c

@@ -0,0 +1,243 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Find the keycode for the key above the tab key */
+/*
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* The standard cycle-windows keybinding should be the key above the
+ * tab key. This will have a different keysym on different keyboards -
+ * it's the ` (grave) key on US keyboards but something else on many
+ * other national layouts. So we need to figure out the keycode for
+ * this key without reference to key symbol.
+ *
+ * The "correct" way to do this is to get the XKB geometry from the
+ * X server, find the Tab key, find the key above the Tab key in the
+ * same section and use the keycode for that key. This is what I
+ * implemented here, but unfortunately, fetching the geometry is rather
+ * slow (It could take 20ms or more.)
+ *
+ * If you looking for a way to optimize Mutter startup performance:
+ * On all Linux systems using evdev the key above TAB will have
+ * keycode 49. (KEY_GRAVE=41 + the 8 code point offset between
+ * evdev keysyms and X keysyms.) So a configure option
+ * --with-above-tab-keycode=49 could be added that bypassed this
+ * code. It wouldn't work right for displaying Mutter remotely
+ * to a non-Linux X server, but that is pretty rare.
+ */
+
+#include <config.h>
+
+#include <string.h>
+
+#include "display-private.h"
+
+#include <X11/keysym.h>
+
+#ifdef HAVE_XKB
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKBgeom.h>
+
+static guint
+compute_above_tab_keycode (Display *xdisplay)
+{
+  XkbDescPtr keyboard;
+  XkbGeometryPtr geometry;
+  int i, j, k;
+  int tab_keycode;
+  char *tab_name;
+  XkbSectionPtr tab_section;
+  XkbBoundsRec tab_bounds;
+  XkbKeyPtr best_key = NULL;
+  guint best_keycode = (guint)-1;
+  int best_x_dist = G_MAXINT;
+  int best_y_dist = G_MAXINT;
+
+  /* We need only the Names and the Geometry, but asking for these results
+   * in the Keyboard information retrieval failing for unknown reasons.
+   * (Testing with xorg-1.9.1.) So we ask for a part that we don't need
+   * as well.
+   */
+  keyboard = XkbGetKeyboard (xdisplay,
+                             XkbGBN_ClientSymbolsMask | XkbGBN_KeyNamesMask | XkbGBN_GeometryMask,
+                             XkbUseCoreKbd);
+  if (!keyboard)
+    return best_keycode;
+
+  geometry = keyboard->geom;
+
+  /* There could potentially be multiple keys with the Tab keysym on the keyboard;
+   * but XKeysymToKeycode() returns us the one that the alt-Tab binding will
+   * use which is good enough
+   */
+  tab_keycode = XKeysymToKeycode (xdisplay, XK_Tab);
+  if (tab_keycode == 0 || tab_keycode < keyboard->min_key_code || tab_keycode > keyboard->max_key_code)
+    goto out;
+
+  /* The keyboard geometry is stored by key "name" rather than keycode.
+   * (Key names are 4-character strings like like TAB or AE01.) We use the
+   * 'names' part of the keyboard description to map keycode to key name.
+   *
+   * XKB has a "key aliases" feature where a single keyboard key can have
+   * multiple names (with separate sets of aliases in the 'names' part and
+   * in the 'geometry' part), but I don't really understand it or how it is used,
+   * so I'm ignoring it here.
+   */
+
+  tab_name = keyboard->names->keys[tab_keycode].name; /* Not NULL terminated! */
+
+  /* First, iterate through the keyboard geometry to find the tab key; the keyboard
+   * geometry has a three-level heirarchy of section > row > key
+   */
+  for (i = 0; i < geometry->num_sections; i++)
+    {
+      XkbSectionPtr section = &geometry->sections[i];
+      for (j = 0; j < section->num_rows; j++)
+        {
+          int x = 0;
+          int y = 0;
+
+          XkbRowPtr row = &section->rows[j];
+          for (k = 0; k < row->num_keys; k++)
+            {
+              XkbKeyPtr key = &row->keys[k];
+              XkbShapePtr shape = XkbKeyShape (geometry, key);
+
+              if (row->vertical)
+                y += key->gap;
+              else
+                x += key->gap;
+
+              if (strncmp (key->name.name, tab_name, XkbKeyNameLength) == 0)
+                {
+                  tab_section = section;
+                  tab_bounds = shape->bounds;
+                  tab_bounds.x1 += row->left + x;
+                  tab_bounds.x2 += row->left + x;
+                  tab_bounds.y1 += row->top + y;
+                  tab_bounds.y2 += row->top + y;
+
+                  goto found_tab;
+                }
+
+              if (row->vertical)
+                y += (shape->bounds.y2 - shape->bounds.y1);
+              else
+                x += (shape->bounds.x2 - shape->bounds.x1);
+            }
+        }
+    }
+
+  /* No tab key found */
+  goto out;
+
+ found_tab:
+
+  /* Now find the key that:
+   *  - Is in the same section as the Tab key
+   *  - Has a horizontal center in the Tab key's horizonal bounds
+   *  - Is above the Tab key at a distance closer than any other key
+   *  - In case of ties, has its horizontal center as close as possible
+   *    to the Tab key's horizontal center
+   */
+  for (j = 0; j < tab_section->num_rows; j++)
+    {
+      int x = 0;
+      int y = 0;
+
+      XkbRowPtr row = &tab_section->rows[j];
+      for (k = 0; k < row->num_keys; k++)
+        {
+          XkbKeyPtr key = &row->keys[k];
+          XkbShapePtr shape = XkbKeyShape(geometry, key);
+          XkbBoundsRec bounds = shape->bounds;
+          int x_center;
+          int x_dist, y_dist;
+
+          if (row->vertical)
+            y += key->gap;
+          else
+            x += key->gap;
+
+          bounds.x1 += row->left + x;
+          bounds.x2 += row->left + x;
+          bounds.y1 += row->top + y;
+          bounds.y2 += row->top + y;
+
+          y_dist = tab_bounds.y1 - bounds.y2;
+          if (y_dist < 0)
+            continue;
+
+          x_center = (bounds.x1 + bounds.x2) / 2;
+          if (x_center < tab_bounds.x1 || x_center > tab_bounds.x2)
+            continue;
+
+          x_dist = ABS (x_center - (tab_bounds.x1 + tab_bounds.x2) / 2);
+
+          if (y_dist < best_y_dist ||
+              (y_dist == best_y_dist && x_dist < best_x_dist))
+            {
+              best_key = key;
+              best_x_dist = x_dist;
+              best_y_dist = y_dist;
+             }
+
+          if (row->vertical)
+            y += (shape->bounds.y2 - shape->bounds.y1);
+          else
+            x += (shape->bounds.x2 - shape->bounds.x1);
+        }
+    }
+
+  if (best_key == NULL)
+    goto out;
+
+  /* Now we need to resolve the name of the best key back to a keycode */
+  for (i = keyboard->min_key_code; i < keyboard->max_key_code; i++)
+    {
+      if (strncmp (best_key->name.name, keyboard->names->keys[i].name, XkbKeyNameLength) == 0)
+        {
+          best_keycode = i;
+          break;
+        }
+    }
+
+ out:
+  XkbFreeKeyboard (keyboard, 0, True);
+
+  return best_keycode;
+}
+#else /* !HAVE_XKB */
+static guint
+compute_above_tab_keycode (Display *xdisplay)
+{
+  return XKeysymToKeycode (xdisplay, XK_grave);
+}
+#endif /* HAVE_XKB */
+
+guint
+meta_display_get_above_tab_keycode (MetaDisplay *display)
+{
+  if (display->above_tab_keycode == 0) /* not yet computed */
+    display->above_tab_keycode = compute_above_tab_keycode (display->xdisplay);
+
+  if (display->above_tab_keycode == (guint)-1) /* failed to compute */
+    return 0;
+  else
+    return display->above_tab_keycode;
+}

src/core/all-keybindings.h

@@ -146,7 +146,7 @@ keybind (switch_to_workspace_down, handle_switch_to_workspace,
  */
 
 keybind (switch_group,              handle_switch,        META_TAB_LIST_GROUP,
-         BINDING_REVERSES,       NULL,
+         BINDING_REVERSES,       "<Alt>Above_Tab",
         _("Move between windows of an application, using a popup window"))
 keybind (switch_group_backward,    handle_switch,        META_TAB_LIST_GROUP,
          REVERSES_AND_REVERSED,  NULL,
@@ -167,7 +167,7 @@ keybind (switch_panels_backward,   handle_switch,        META_TAB_LIST_DOCKS,
           "using a popup window"))
 
 keybind (cycle_group,               handle_cycle,         META_TAB_LIST_GROUP,
-        BINDING_REVERSES,        "<Alt>grave",
+        BINDING_REVERSES,        "<Alt>F6",
         _("Move between windows of an application immediately"))
 keybind (cycle_group_backward,     handle_cycle,         META_TAB_LIST_GROUP,
         REVERSES_AND_REVERSED,   NULL,

src/core/bell.c

@@ -51,7 +51,7 @@
 #include <config.h>
 #include "bell.h"
 #include "screen-private.h"
-#include "prefs.h"
+#include <meta/prefs.h>
 #ifdef HAVE_LIBCANBERRA
 #include <canberra-gtk.h>
 #endif
@@ -149,7 +149,7 @@ bell_flash_screen (MetaDisplay *display,
 #ifdef HAVE_XKB
 static void
 bell_flash_fullscreen (MetaDisplay *display, 
-			    XkbAnyEvent *xkb_ev)
+                       XkbAnyEvent *xkb_ev)
 {
   XkbBellNotifyEvent *xkb_bell_ev = (XkbBellNotifyEvent *) xkb_ev;
   MetaScreen *screen;
@@ -159,7 +159,12 @@ bell_flash_fullscreen (MetaDisplay *display,
     {
       screen = meta_display_screen_for_xwindow (display, xkb_bell_ev->window);
       if (screen)
-	bell_flash_screen (display, screen);
+        {
+          if (display->compositor)
+            meta_compositor_flash_screen (display->compositor, screen);
+          else
+            bell_flash_screen (display, screen);
+        }
     }
   else 
     {
@@ -167,7 +172,10 @@ bell_flash_fullscreen (MetaDisplay *display,
       while (screen_list) 
 	{
 	  screen = (MetaScreen *) screen_list->data;
-	  bell_flash_screen (display, screen);
+          if (display->compositor)
+            meta_compositor_flash_screen (display->compositor, screen);
+          else
+            bell_flash_screen (display, screen);
 	  screen_list = screen_list->next;
 	}
     }

src/core/bell.h

@@ -36,7 +36,7 @@
 #include <X11/XKBlib.h>
 #endif
 #include "display-private.h"
-#include "frame-private.h"
+#include "frame.h"
 
 #ifdef HAVE_XKB
 /**

src/core/boxes-private.h

@@ -25,8 +25,8 @@
 #define META_BOXES_PRIVATE_H
 
 #include <glib-object.h>
-#include "common.h"
-#include "boxes.h"
+#include <meta/common.h>
+#include <meta/boxes.h>
 
 #define BOX_LEFT(box)    ((box).x)                /* Leftmost pixel of rect */
 #define BOX_RIGHT(box)   ((box).x + (box).width)  /* One pixel past right   */

src/core/boxes.c

@@ -27,7 +27,7 @@
  */
 
 #include "boxes-private.h"
-#include "util.h"
+#include <meta/util.h>
 #include <X11/Xutil.h>  /* Just for the definition of the various gravities */
 
 /* It would make sense to use GSlice here, but until we clean up the
@@ -179,6 +179,16 @@ meta_rectangle_area (const MetaRectangle *rect)
   return rect->width * rect->height;
 }
 
+/**
+ * meta_rectangle_intersect:
+ * @src1: a #MetaRectangle
+ * @src2: another #MetaRectangle
+ * @dest: (out caller-allocates): an empty #MetaRectangle, to be filled
+ *   with the coordinates of the intersection.
+ *
+ * Returns: TRUE is some intersection exists and is not degenerate, FALSE
+ *   otherwise.
+ */
 gboolean
 meta_rectangle_intersect (const MetaRectangle *src1,
 			  const MetaRectangle *src2,
@@ -226,6 +236,13 @@ meta_rectangle_equal (const MetaRectangle *src1,
           (src1->height == src2->height));
 }
 
+/**
+ * meta_rectangle_union:
+ * @rect1: a #MetaRectangle
+ * @rect2: another #MetaRectangle
+ * @dest: (out caller-allocates): an empty #MetaRectangle, to be filled
+ *   with the coordinates of the bounding box.
+ */
 void
 meta_rectangle_union (const MetaRectangle *rect1,
                       const MetaRectangle *rect2,
@@ -340,7 +357,6 @@ meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
    */
 
   /* First, the x direction */
-  int adjust = 0;
   switch (gravity)
     {
     case NorthWestGravity:
@@ -373,7 +389,6 @@ meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
   rect->width = new_width;
   
   /* Next, the y direction */
-  adjust = 0;
   switch (gravity)
     {
     case NorthWestGravity:

src/core/constraints.c

@@ -28,7 +28,7 @@
 #include "constraints.h"
 #include "workspace-private.h"
 #include "place.h"
-#include "prefs.h"
+#include <meta/prefs.h>
 
 #include <stdlib.h>
 #include <math.h>
@@ -118,7 +118,7 @@ typedef struct
 {
   MetaRectangle        orig;
   MetaRectangle        current;
-  MetaFrameGeometry   *fgeom;
+  MetaFrameBorders    *borders;
   ActionType           action_type;
   gboolean             is_user_action;
 
@@ -142,6 +142,11 @@ typedef struct
   GList  *usable_screen_region;
   GList  *usable_monitor_region;
 } ConstraintInfo;
+
+static gboolean do_screen_and_monitor_relative_constraints (MetaWindow     *window,
+                                                            GList          *region_spanning_rectangles,
+                                                            ConstraintInfo *info,
+                                                            gboolean        check_only);
 static gboolean constrain_modal_dialog       (MetaWindow         *window,
                                               ConstraintInfo     *info,
                                               ConstraintPriority  priority,
@@ -189,7 +194,7 @@ static gboolean constrain_partially_onscreen (MetaWindow         *window,
 
 static void setup_constraint_info        (ConstraintInfo      *info,
                                           MetaWindow          *window,
-                                          MetaFrameGeometry   *orig_fgeom,
+                                          MetaFrameBorders    *orig_borders,
                                           MetaMoveResizeFlags  flags,
                                           int                  resize_gravity,
                                           const MetaRectangle *orig,
@@ -199,11 +204,11 @@ static void place_window_if_needed       (MetaWindow     *window,
 static void update_onscreen_requirements (MetaWindow     *window,
                                           ConstraintInfo *info);
 static void extend_by_frame              (MetaRectangle           *rect,
-                                          const MetaFrameGeometry *fgeom);
+                                          const MetaFrameBorders  *borders);
 static void unextend_by_frame            (MetaRectangle           *rect,
-                                          const MetaFrameGeometry *fgeom);
+                                          const MetaFrameBorders  *borders);
 static inline void get_size_limits       (const MetaWindow        *window,
-                                          const MetaFrameGeometry *fgeom,
+                                          const MetaFrameBorders  *borders,
                                           gboolean include_frame,
                                           MetaRectangle *min_size,
                                           MetaRectangle *max_size);
@@ -274,7 +279,7 @@ do_all_constraints (MetaWindow         *window,
 
 void
 meta_window_constrain (MetaWindow          *window,
-                       MetaFrameGeometry   *orig_fgeom,
+                       MetaFrameBorders    *orig_borders,
                        MetaMoveResizeFlags  flags,
                        int                  resize_gravity,
                        const MetaRectangle *orig,
@@ -297,7 +302,7 @@ meta_window_constrain (MetaWindow          *window,
 
   setup_constraint_info (&info,
                          window, 
-                         orig_fgeom, 
+                         orig_borders,
                          flags,
                          resize_gravity,
                          orig,
@@ -332,14 +337,14 @@ meta_window_constrain (MetaWindow          *window,
    * not gobject-style--gobject would be more pain than it's worth) or
    * smart pointers would be so much nicer here.  *shrug*
    */
-  if (!orig_fgeom)
-    g_free (info.fgeom);
+  if (!orig_borders)
+    g_free (info.borders);
 }
 
 static void
 setup_constraint_info (ConstraintInfo      *info,
                        MetaWindow          *window,
-                       MetaFrameGeometry   *orig_fgeom,
+                       MetaFrameBorders    *orig_borders,
                        MetaMoveResizeFlags  flags,
                        int                  resize_gravity,
                        const MetaRectangle *orig,
@@ -352,10 +357,10 @@ setup_constraint_info (ConstraintInfo      *info,
   info->current = *new;
 
   /* Create a fake frame geometry if none really exists */
-  if (orig_fgeom && !window->fullscreen)
-    info->fgeom = orig_fgeom;
+  if (orig_borders && !window->fullscreen)
+    info->borders = orig_borders;
   else
-    info->fgeom = g_new0 (MetaFrameGeometry, 1);
+    info->borders = g_new0 (MetaFrameBorders, 1);
 
   if (flags & META_IS_MOVE_ACTION && flags & META_IS_RESIZE_ACTION)
     info->action_type = ACTION_MOVE_AND_RESIZE;
@@ -456,7 +461,6 @@ setup_constraint_info (ConstraintInfo      *info,
               "Setting up constraint info:\n"
               "  orig: %d,%d +%d,%d\n"
               "  new : %d,%d +%d,%d\n"
-              "  fgeom: %d,%d,%d,%d\n"
               "  action_type     : %s\n"
               "  is_user_action  : %s\n"
               "  resize_gravity  : %s\n"
@@ -466,8 +470,6 @@ setup_constraint_info (ConstraintInfo      *info,
               info->orig.x, info->orig.y, info->orig.width, info->orig.height,
               info->current.x, info->current.y, 
                 info->current.width, info->current.height,
-              info->fgeom->left_width, info->fgeom->right_width,
-                info->fgeom->top_height, info->fgeom->bottom_height,
               (info->action_type == ACTION_MOVE) ? "Move" :
                 (info->action_type == ACTION_RESIZE) ? "Resize" :
                 (info->action_type == ACTION_MOVE_AND_RESIZE) ? "Move&Resize" :
@@ -508,7 +510,7 @@ place_window_if_needed(MetaWindow     *window,
       MetaWorkspace *cur_workspace;
       const MetaMonitorInfo *monitor_info;
 
-      meta_window_place (window, info->fgeom, 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;
 
@@ -568,7 +570,7 @@ place_window_if_needed(MetaWindow     *window,
 
           /* maximization may have changed frame geometry */
           if (window->frame && !window->fullscreen)
-            meta_frame_calc_geometry (window->frame, info->fgeom);
+            meta_frame_calc_borders (window->frame, info->borders);
 
           if (window->fullscreen_after_placement)
             {
@@ -629,7 +631,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 (&info->current, info->fgeom);
+  extend_by_frame (&info->current, info->borders);
 
   /* Update whether we want future constraint runs to require the
    * window to be on fully onscreen.
@@ -665,7 +667,7 @@ update_onscreen_requirements (MetaWindow     *window,
       MetaRectangle titlebar_rect;
 
       titlebar_rect = info->current;
-      titlebar_rect.height = info->fgeom->top_height;
+      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,
@@ -678,32 +680,32 @@ update_onscreen_requirements (MetaWindow     *window,
     }
 
   /* Don't forget to restore the position of the window */
-  unextend_by_frame (&info->current, info->fgeom);
+  unextend_by_frame (&info->current, info->borders);
 }
 
 static void
 extend_by_frame (MetaRectangle           *rect,
-                 const MetaFrameGeometry *fgeom)
+                 const MetaFrameBorders *borders)
 {
-  rect->x -= fgeom->left_width;
-  rect->y -= fgeom->top_height;
-  rect->width  += fgeom->left_width + fgeom->right_width;
-  rect->height += fgeom->top_height + fgeom->bottom_height;
+  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 (MetaRectangle           *rect,
-                   const MetaFrameGeometry *fgeom)
+                   const MetaFrameBorders *borders)
 {
-  rect->x += fgeom->left_width;
-  rect->y += fgeom->top_height;
-  rect->width  -= fgeom->left_width + fgeom->right_width;
-  rect->height -= fgeom->top_height + fgeom->bottom_height;
+  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 (const MetaWindow        *window,
-                 const MetaFrameGeometry *fgeom,
+                 const MetaFrameBorders *borders,
                  gboolean                 include_frame,
                  MetaRectangle *min_size,
                  MetaRectangle *max_size)
@@ -718,8 +720,8 @@ get_size_limits (const MetaWindow        *window,
 
   if (include_frame)
     {
-      int fw = fgeom->left_width + fgeom->right_width;
-      int fh = fgeom->top_height + fgeom->bottom_height;
+      int fw = borders->visible.left + borders->visible.right;
+      int fh = borders->visible.top + borders->visible.bottom;
 
       min_size->width  += fw;
       min_size->height += fh;
@@ -747,27 +749,25 @@ constrain_modal_dialog (MetaWindow         *window,
   MetaWindow *parent = meta_window_get_transient_for (window);
   gboolean constraint_already_satisfied;
 
-  if (!meta_prefs_get_attach_modal_dialogs ())
-    return TRUE;
-  if (window->type != META_WINDOW_MODAL_DIALOG || !parent || parent == window)
+  if (!meta_window_is_attached_dialog (window))
     return TRUE;
 
   x = parent->rect.x + (parent->rect.width / 2  - info->current.width / 2);
   y = 0;
   if (parent->frame)
     {
-      MetaFrameGeometry fgeom;
+      MetaFrameBorders borders;
 
       x += parent->frame->rect.x;
       y += parent->frame->rect.y;
 
-      meta_frame_calc_geometry (parent->frame, &fgeom);
-      y += fgeom.top_height;
+      meta_frame_calc_borders (parent->frame, &borders);
+      y += borders.total.top;
 
-      y += info->fgeom->top_height;
+      y += info->borders->visible.top;
     }
   else
-    y = parent->rect.y + info->fgeom->top_height;
+    y = parent->rect.y + info->borders->visible.top;
 
   constraint_already_satisfied = (x == info->current.x) && (y == info->current.y);
 
@@ -776,7 +776,12 @@ constrain_modal_dialog (MetaWindow         *window,
 
   info->current.y = y;
   info->current.x = x;
-  return TRUE;
+  /* The calculated position above may need adjustment to make sure the
+   * dialog does not end up partially off-screen */
+  return do_screen_and_monitor_relative_constraints (window,
+                                                     info->usable_screen_region,
+                                                     info,
+                                                     check_only);
 }
 
 static gboolean
@@ -800,8 +805,14 @@ constrain_maximization (MetaWindow         *window,
     return TRUE;
 
   /* Calculate target_size = maximized size of (window + frame) */
-  if (window->maximized_horizontally && window->maximized_vertically)
-    target_size = info->work_area_monitor;
+  if (META_WINDOW_TILED_MAXIMIZED (window))
+    {
+      meta_window_get_current_tile_area (window, &target_size);
+    }
+  else if (META_WINDOW_MAXIMIZED (window))
+    {
+      target_size = info->work_area_monitor;
+    }
   else
     {
       /* Amount of maximization possible in a single direction depends
@@ -821,19 +832,19 @@ constrain_maximization (MetaWindow         *window,
       active_workspace_struts = window->screen->active_workspace->all_struts;
 
       target_size = info->current;
-      extend_by_frame (&target_size, info->fgeom);
+      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 (&target_size, info->fgeom);
+  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, info->fgeom, 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)
@@ -887,12 +898,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 (&target_size, info->fgeom);
+  unextend_by_frame (&target_size, info->borders);
 
   /* Check min size constraints; max size constraints are ignored as for
    * maximized windows.
    */
-  get_size_limits (window, info->fgeom, 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)
@@ -935,7 +946,7 @@ constrain_fullscreen (MetaWindow         *window,
 
   monitor = info->entire_monitor;
 
-  get_size_limits (window, info->fgeom, 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)
@@ -1044,7 +1055,7 @@ constrain_size_limits (MetaWindow         *window,
     return TRUE;
 
   /* Determine whether constraint is already satisfied; exit if it is */
-  get_size_limits (window, info->fgeom, 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);
@@ -1236,8 +1247,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, info->fgeom, TRUE, &min_size, &max_size);
-  extend_by_frame (&info->current, info->fgeom);
+  get_size_limits (window, info->borders, TRUE, &min_size, &max_size);
+  extend_by_frame (&info->current, info->borders);
 
   if (info->action_type != ACTION_MOVE)
     {
@@ -1257,7 +1268,7 @@ do_screen_and_monitor_relative_constraints (
                                         &info->current);
   if (exit_early || constraint_satisfied || check_only)
     {
-      unextend_by_frame (&info->current, info->fgeom);
+      unextend_by_frame (&info->current, info->borders);
       return constraint_satisfied;
     }
 
@@ -1281,7 +1292,7 @@ do_screen_and_monitor_relative_constraints (
                                       info->fixed_directions,
                                       &info->current);
 
-  unextend_by_frame (&info->current, info->fgeom);
+  unextend_by_frame (&info->current, info->borders);
   return TRUE;
 }
 
@@ -1394,8 +1405,8 @@ constrain_titlebar_visible (MetaWindow         *window,
    */
   if (window->frame)
     {
-      bottom_amount = info->current.height + info->fgeom->bottom_height;
-      vert_amount_onscreen = info->fgeom->top_height;
+      bottom_amount = info->current.height + info->borders->visible.bottom;
+      vert_amount_onscreen = info->borders->visible.top;
     }
   else
     bottom_amount = vert_amount_offscreen;
@@ -1469,8 +1480,8 @@ constrain_partially_onscreen (MetaWindow         *window,
    */
   if (window->frame)
     {
-      bottom_amount = info->current.height + info->fgeom->bottom_height;
-      vert_amount_onscreen = info->fgeom->top_height;
+      bottom_amount = info->current.height + info->borders->visible.bottom;
+      vert_amount_onscreen = info->borders->visible.top;
     }
   else
     bottom_amount = vert_amount_offscreen;

src/core/constraints.h

@@ -25,9 +25,9 @@
 #ifndef META_CONSTRAINTS_H
 #define META_CONSTRAINTS_H
 
-#include "util.h"
+#include <meta/util.h>
 #include "window-private.h"
-#include "frame-private.h"
+#include "frame.h"
 
 typedef enum
 {
@@ -39,7 +39,7 @@ typedef enum
 } MetaMoveResizeFlags;
 
 void meta_window_constrain (MetaWindow          *window,
-                            MetaFrameGeometry   *orig_fgeom,
+                            MetaFrameBorders    *orig_borders,
                             MetaMoveResizeFlags  flags,
                             int                  resize_gravity,
                             const MetaRectangle *orig,

src/core/core.c

@@ -25,10 +25,10 @@
 
 #include <config.h>
 #include "core.h"
-#include "frame-private.h"
+#include "frame.h"
 #include "workspace-private.h"
-#include "prefs.h"
-#include "errors.h"
+#include <meta/prefs.h>
+#include <meta/errors.h>
 
 /* Looks up the MetaWindow representing the frame of the given X window.
  * Used as a helper function by a bunch of the functions below.
@@ -107,9 +107,6 @@ meta_core_get (Display *xdisplay,
       case META_CORE_GET_CLIENT_HEIGHT:
         *((gint*)answer) = window->rect.height;
         break;
-      case META_CORE_IS_TITLEBAR_ONSCREEN:
-        *((gboolean*)answer) = meta_window_titlebar_is_onscreen (window);
-        break;
       case META_CORE_GET_CLIENT_XWINDOW:
         *((Window*)answer) = window->xwindow;
         break;
@@ -146,6 +143,9 @@ meta_core_get (Display *xdisplay,
       case META_CORE_GET_FRAME_HEIGHT:
         *((gint*)answer) = window->frame->rect.height;
         break;
+      case META_CORE_GET_THEME_VARIANT:
+        *((char**)answer) = window->gtk_theme_variant;
+        break;
       case META_CORE_GET_SCREEN_WIDTH:
         *((gint*)answer) = window->screen->rect.width;
         break;
@@ -261,25 +261,25 @@ meta_core_user_lower_and_unfocus (Display *xdisplay,
 }
 
 void
-meta_core_lower_beneath_focus_window (Display *xdisplay,
-                                      Window   xwindow,
-                                      guint32  timestamp)
+meta_core_lower_beneath_grab_window (Display *xdisplay,
+                                     Window   xwindow,
+                                     guint32  timestamp)
 {
   XWindowChanges changes;
   MetaDisplay *display;
   MetaScreen *screen;
-  MetaWindow *focus_window;
+  MetaWindow *grab_window;
 
   display = meta_display_for_x_display (xdisplay);
   screen = meta_display_screen_for_xwindow (display, xwindow);
-  focus_window = meta_stack_get_top (screen->stack);
+  grab_window = display->grab_window;
 
-  if (focus_window == NULL)
+  if (grab_window == NULL)
     return;
 
   changes.stack_mode = Below;
-  changes.sibling = focus_window->frame ? focus_window->frame->xwindow
-                                        : focus_window->xwindow;
+  changes.sibling = grab_window->frame ? grab_window->frame->xwindow
+                                       : grab_window->xwindow;
 
   meta_stack_tracker_record_lower_below (screen->stack_tracker,
                                          xwindow,

src/core/core.h

@@ -27,7 +27,7 @@
 
 /* Don't include core headers here */
 #include <gdk/gdkx.h>
-#include "common.h"
+#include <meta/common.h>
 
 typedef enum
 {
@@ -35,7 +35,6 @@ typedef enum
   META_CORE_WINDOW_HAS_FRAME,
   META_CORE_GET_CLIENT_WIDTH,
   META_CORE_GET_CLIENT_HEIGHT,
-  META_CORE_IS_TITLEBAR_ONSCREEN,
   META_CORE_GET_CLIENT_XWINDOW,
   META_CORE_GET_FRAME_FLAGS,
   META_CORE_GET_FRAME_TYPE,
@@ -48,6 +47,7 @@ typedef enum
   META_CORE_GET_FRAME_Y,
   META_CORE_GET_FRAME_WIDTH,
   META_CORE_GET_FRAME_HEIGHT,
+  META_CORE_GET_THEME_VARIANT,
   META_CORE_GET_SCREEN_WIDTH,
   META_CORE_GET_SCREEN_HEIGHT,
 } MetaCoreGetType;
@@ -116,9 +116,9 @@ void meta_core_user_focus   (Display *xdisplay,
                              Window   frame_xwindow,
                              guint32  timestamp);
 
-void meta_core_lower_beneath_focus_window (Display *xdisplay,
-                                           Window   xwindow,
-                                           guint32  timestamp);
+void meta_core_lower_beneath_grab_window (Display *xdisplay,
+                                          Window   xwindow,
+                                          guint32  timestamp);
 
 void meta_core_minimize         (Display *xdisplay,
                                  Window   frame_xwindow);

src/core/delete.c

@@ -25,10 +25,10 @@
 #define _XOPEN_SOURCE /* for kill() */
 
 #include <config.h>
-#include "util.h"
+#include <meta/util.h>
 #include "window-private.h"
-#include "errors.h"
-#include "workspace.h"
+#include <meta/errors.h>
+#include <meta/workspace.h>
 
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -88,23 +88,41 @@ delete_ping_timeout_func (MetaDisplay *display,
       return;
     }
 
-  window_title = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
+  /* This is to get a better string if the title isn't representable
+   * in the locale encoding; actual conversion to UTF-8 is done inside
+   * meta_show_dialog */
+
+  if (window->title && window->title[0])
+    {
+      tmp = g_locale_from_utf8 (window->title, -1, NULL, NULL, NULL);
+      if (tmp == NULL)
+        window_title = NULL;
+      else
+        window_title = window->title;
+      g_free (tmp);
+    }
+  else
+    {
+      window_title = NULL;
+    }
 
   /* Translators: %s is a window title */
-  tmp = g_strdup_printf (_("<tt>%s</tt> is not responding."),
-                         window_title);
+  if (window_title)
+    tmp = g_markup_printf_escaped (_("<tt>%s</tt> is not responding."),
+                                   window_title);
+  else
+    tmp = g_strdup (_("Application is not responding."));
+
   window_content = g_strdup_printf (
       "<big><b>%s</b></big>\n\n<i>%s</i>",
       tmp,
       _("You may choose to wait a short while for it to "
         "continue or force the application to quit entirely."));
 
-  g_free (window_title);
-
   dialog_pid =
     meta_show_dialog ("--question",
-                      window_content, 0,
-                      window->screen->number,
+                      window_content, NULL,
+                      window->screen->screen_name,
                       _("_Wait"), _("_Force Quit"), window->xwindow,
                       NULL, NULL);
 

src/core/display-private.h

@@ -34,11 +34,11 @@
 #include <glib.h>
 #include <X11/Xlib.h>
 #include "eventqueue.h"
-#include "common.h"
-#include "boxes.h"
-#include "display.h"
+#include <meta/common.h>
+#include <meta/boxes.h>
+#include <meta/display.h>
 #include "keybindings-private.h"
-#include "prefs.h"
+#include <meta/prefs.h>
 
 #ifdef HAVE_STARTUP_NOTIFICATION
 #include <libsn/sn.h>
@@ -73,9 +73,18 @@ typedef enum {
 /* This is basically a bogus number, just has to be large enough
  * to handle the expected case of the alt+tab operation, where
  * we want to ignore serials from UnmapNotify on the tab popup,
- * and the LeaveNotify/EnterNotify from the pointer ungrab
+ * and the LeaveNotify/EnterNotify from the pointer ungrab. It
+ * also has to be big enough to hold ignored serials from the point
+ * where we reshape the stage to the point where we get events back.
  */
-#define N_IGNORED_SERIALS           4
+#define N_IGNORED_CROSSING_SERIALS  10
+
+typedef enum {
+  META_TILE_NONE,
+  META_TILE_LEFT,
+  META_TILE_RIGHT,
+  META_TILE_MAXIMIZED
+} MetaTileMode;
 
 struct _MetaDisplay
 {
@@ -92,7 +101,7 @@ struct _MetaDisplay
    * class is constructed.
    */
 #define item(x)  Atom atom_##x;
-#include "atomnames.h"
+#include <meta/atomnames.h>
 #undef item
 
   /* This is the actual window from focus events,
@@ -146,7 +155,7 @@ struct _MetaDisplay
    * correspond to an enter event we should
    * ignore
    */
-  unsigned long ignored_serials[N_IGNORED_SERIALS];
+  unsigned long ignored_crossing_serials[N_IGNORED_CROSSING_SERIALS];
   Window ungrab_should_not_cause_focus_window;
   
   guint32 current_time;
@@ -179,6 +188,8 @@ struct _MetaDisplay
   int         grab_anchor_root_x;
   int         grab_anchor_root_y;
   MetaRectangle grab_anchor_window_pos;
+  MetaTileMode  grab_tile_mode;
+  int           grab_tile_monitor_number;
   int         grab_latest_motion_x;
   int         grab_latest_motion_y;
   gulong      grab_mask;
@@ -221,6 +232,7 @@ struct _MetaDisplay
   KeySym *keymap;
   int keysyms_per_keycode;
   XModifierKeymap *modmap;
+  unsigned int above_tab_keycode;
   unsigned int ignored_modifier_mask;
   unsigned int num_lock_mask;
   unsigned int scroll_lock_mask;
@@ -332,10 +344,6 @@ MetaScreen*   meta_display_screen_for_xwindow  (MetaDisplay *display,
 void          meta_display_grab                (MetaDisplay *display);
 void          meta_display_ungrab              (MetaDisplay *display);
 
-void          meta_display_unmanage_screen     (MetaDisplay *display,
-                                                MetaScreen  *screen,
-                                                guint32      timestamp);
-
 void          meta_display_unmanage_windows_for_screen (MetaDisplay *display,
                                                         MetaScreen  *screen,
                                                         guint32      timestamp);
@@ -433,4 +441,7 @@ void meta_display_remove_autoraise_callback (MetaDisplay *display);
 
 void meta_display_overlay_key_activate (MetaDisplay *display);
 
+/* In above-tab-keycode.c */
+guint meta_display_get_above_tab_keycode (MetaDisplay *display);
+
 #endif

src/core/display.c

@@ -34,21 +34,21 @@
 
 #include <config.h>
 #include "display-private.h"
-#include "util.h"
-#include "main.h"
+#include <meta/util.h>
+#include <meta/main.h>
 #include "screen-private.h"
 #include "window-private.h"
 #include "window-props.h"
 #include "group-props.h"
-#include "frame-private.h"
-#include "errors.h"
+#include "frame.h"
+#include <meta/errors.h>
 #include "keybindings-private.h"
-#include "prefs.h"
+#include <meta/prefs.h>
 #include "resizepopup.h"
 #include "xprops.h"
 #include "workspace-private.h"
 #include "bell.h"
-#include "compositor.h"
+#include <meta/compositor.h>
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #ifdef HAVE_SOLARIS_XINERAMA
@@ -387,26 +387,6 @@ enable_compositor (MetaDisplay *display,
     }
 }
 
-static void
-disable_compositor (MetaDisplay *display)
-{
-  GSList *list;
-  
-  if (!display->compositor)
-    return;
-  
-  for (list = display->screens; list != NULL; list = list->next)
-    {
-      MetaScreen *screen = list->data;
-      
-      meta_compositor_unmanage_screen (screen->display->compositor,
-				       screen);
-    }
-  
-  meta_compositor_destroy (display->compositor);
-  display->compositor = NULL;
-}
-
 static void
 meta_display_init (MetaDisplay *disp)
 {
@@ -437,7 +417,7 @@ meta_display_open (void)
   /* A list of all atom names, so that we can intern them in one go. */
   char *atom_names[] = {
 #define item(x) #x,
-#include "atomnames.h"
+#include <meta/atomnames.h>
 #undef item
   };
   Atom atoms[G_N_ELEMENTS(atom_names)];
@@ -510,7 +490,7 @@ meta_display_open (void)
   {
     int i = 0;    
 #define item(x) the_display->atom_##x = atoms[i++];
-#include "atomnames.h"
+#include <meta/atomnames.h>
 #undef item
   }
 
@@ -552,9 +532,9 @@ meta_display_open (void)
                                           meta_unsigned_long_equal);
   
   i = 0;
-  while (i < N_IGNORED_SERIALS)
+  while (i < N_IGNORED_CROSSING_SERIALS)
     {
-      the_display->ignored_serials[i] = 0;
+      the_display->ignored_crossing_serials[i] = 0;
       ++i;
     }
   the_display->ungrab_should_not_cause_focus_window = None;
@@ -573,6 +553,8 @@ meta_display_open (void)
   the_display->grab_window = NULL;
   the_display->grab_screen = NULL;
   the_display->grab_resize_popup = NULL;
+  the_display->grab_tile_mode = META_TILE_NONE;
+  the_display->grab_tile_monitor_number = -1;
 
   the_display->grab_edge_resistance_data = NULL;
 
@@ -839,8 +821,7 @@ meta_display_open (void)
   /* We don't composite the windows here because they will be composited 
      faster with the call to meta_screen_manage_all_windows further down 
      the code */
-  if (1) /* meta_prefs_get_compositing_manager ()) FIXME */
-    enable_compositor (the_display, FALSE);
+  enable_compositor (the_display, FALSE);
    
   meta_display_grab (the_display);
   
@@ -1403,37 +1384,48 @@ meta_display_get_current_time_roundtrip (MetaDisplay *display)
   return timestamp;
 }
 
-static void
-add_ignored_serial (MetaDisplay  *display,
-                    unsigned long serial)
+/**
+ * meta_display_add_ignored_crossing_serial:
+ * @display: a #MetaDisplay
+ * @serial: the serial to ignore
+ *
+ * Save the specified serial and ignore crossing events with that
+ * serial for the purpose of focus-follows-mouse. This can be used
+ * for certain changes to the window hierarchy that we don't want
+ * to change the focus window, even if they cause the pointer to
+ * end up in a new window.
+ */
+void
+meta_display_add_ignored_crossing_serial (MetaDisplay  *display,
+                                          unsigned long serial)
 {
   int i;
 
   /* don't add the same serial more than once */
-  if (display->ignored_serials[N_IGNORED_SERIALS-1] == serial)
+  if (display->ignored_crossing_serials[N_IGNORED_CROSSING_SERIALS-1] == serial)
     return;
   
   /* shift serials to the left */
   i = 0;
-  while (i < (N_IGNORED_SERIALS - 1))
+  while (i < (N_IGNORED_CROSSING_SERIALS - 1))
     {
-      display->ignored_serials[i] = display->ignored_serials[i+1];
+      display->ignored_crossing_serials[i] = display->ignored_crossing_serials[i+1];
       ++i;
     }
   /* put new one on the end */
-  display->ignored_serials[i] = serial;
+  display->ignored_crossing_serials[i] = serial;
 }
 
 static gboolean
-serial_is_ignored (MetaDisplay  *display,
-                   unsigned long serial)
+crossing_serial_is_ignored (MetaDisplay  *display,
+                            unsigned long serial)
 {
   int i;
 
   i = 0;
-  while (i < N_IGNORED_SERIALS)
+  while (i < N_IGNORED_CROSSING_SERIALS)
     {
-      if (display->ignored_serials[i] == serial)
+      if (display->ignored_crossing_serials[i] == serial)
         return TRUE;
       ++i;
     }
@@ -1441,14 +1433,14 @@ serial_is_ignored (MetaDisplay  *display,
 }
 
 static void
-reset_ignores (MetaDisplay *display)
+reset_ignored_crossing_serials (MetaDisplay *display)
 {
   int i;
 
   i = 0;
-  while (i < N_IGNORED_SERIALS)
+  while (i < N_IGNORED_CROSSING_SERIALS)
     {
-      display->ignored_serials[i] = 0;
+      display->ignored_crossing_serials[i] = 0;
       ++i;
     }
 
@@ -1623,7 +1615,7 @@ event_callback (XEvent   *event,
       if (meta_ui_window_should_not_cause_focus (display->xdisplay,
                                                  modified))
         {
-          add_ignored_serial (display, event->xany.serial);
+          meta_display_add_ignored_crossing_serial (display, event->xany.serial);
           meta_topic (META_DEBUG_FOCUS,
                       "Adding EnterNotify serial %lu to ignored focus serials\n",
                       event->xany.serial);
@@ -1633,7 +1625,7 @@ event_callback (XEvent   *event,
            event->xcrossing.mode == NotifyUngrab &&
            modified == display->ungrab_should_not_cause_focus_window)
     {
-      add_ignored_serial (display, event->xany.serial);
+      meta_display_add_ignored_crossing_serial (display, event->xany.serial);
       meta_topic (META_DEBUG_FOCUS,
                   "Adding LeaveNotify serial %lu to ignored focus serials\n",
                   event->xany.serial);
@@ -1717,12 +1709,9 @@ event_callback (XEvent   *event,
                               window->desc);
                 }
 
-              if (window->frame)
-                {
-                  window->frame->need_reapply_frame_shape = TRUE;
-		  meta_warning("from event callback\n");		  
-                  meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
-                }
+              if (display->compositor)
+                meta_compositor_window_shape_changed (display->compositor,
+                                                      window);
             }
         }
       else
@@ -1766,9 +1755,10 @@ event_callback (XEvent   *event,
        * we can get into a confused state. So if a keybinding is
        * handled (because it's one of our hot-keys, or because we are
        * in a keyboard-grabbed mode like moving a window, we don't
-       * want to pass the key event to the compositor at all.
+       * want to pass the key event to the compositor or GTK+ at all.
        */
-      bypass_compositor = meta_display_process_key_event (display, window, event);
+      if (meta_display_process_key_event (display, window, event))
+        filter_out_event = bypass_compositor = TRUE;
       break;
     case ButtonPress:
       if (display->grab_op == META_GRAB_OP_COMPOSITOR)
@@ -2011,7 +2001,7 @@ event_callback (XEvent   *event,
       /* Check if we've entered a window; do this even if window->has_focus to
        * avoid races.
        */
-      if (window && !serial_is_ignored (display, event->xany.serial) &&
+      if (window && !crossing_serial_is_ignored (display, event->xany.serial) &&
                event->xcrossing.mode != NotifyGrab && 
                event->xcrossing.mode != NotifyUngrab &&
                event->xcrossing.detail != NotifyInferior &&
@@ -2036,7 +2026,7 @@ event_callback (XEvent   *event,
                   meta_window_focus (window, event->xcrossing.time);
 
                   /* stop ignoring stuff */
-                  reset_ignores (display);
+                  reset_ignored_crossing_serials (display);
                   
                   if (meta_prefs_get_auto_raise ()) 
                     {
@@ -2305,11 +2295,8 @@ event_callback (XEvent   *event,
         screen = meta_display_screen_for_root (display,
                                                event->xconfigure.event);
         if (screen)
-          {
-            if (screen)
-              meta_stack_tracker_reparent_event (screen->stack_tracker,
-                                                 &event->xreparent);
-          }
+          meta_stack_tracker_reparent_event (screen->stack_tracker,
+                                             &event->xreparent);
       }
       break;
     case ConfigureNotify:
@@ -2543,12 +2530,6 @@ event_callback (XEvent   *event,
                       meta_workspace_focus_default_window (screen->active_workspace, NULL, timestamp);
                     }
                 }
-              else if (event->xclient.message_type ==
-                       display->atom__MUTTER_RESTART_MESSAGE)
-                {
-                  meta_verbose ("Received restart request\n");
-                  meta_restart ();
-                }
               else if (event->xclient.message_type ==
                        display->atom__MUTTER_RELOAD_THEME_MESSAGE)
                 {
@@ -3519,6 +3500,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
                             int          root_x,
                             int          root_y)
 {
+  MetaWindow *grab_window = NULL;
   Window grab_xwindow;
   
   meta_topic (META_DEBUG_WINDOW_OPS,
@@ -3548,14 +3530,24 @@ meta_display_begin_grab_op (MetaDisplay *display,
         }
     }
 
+  /* If window is a modal dialog attached to its parent,
+   * grab the parent instead for moving.
+   */
+  if (window && meta_window_is_attached_dialog (window) &&
+      meta_grab_op_is_moving (op))
+    grab_window = meta_window_get_transient_for (window);
+
+  if (grab_window == NULL)
+    grab_window = window;
+
   /* FIXME:
    *   If we have no MetaWindow we do our best
    *   and try to do the grab on the RootWindow.
    *   This will fail if anyone else has any
    *   key grab on the RootWindow.
    */
-  if (window)
-    grab_xwindow = window->frame ? window->frame->xwindow : window->xwindow;
+  if (grab_window)
+    grab_xwindow = grab_window->frame ? grab_window->frame->xwindow : grab_window->xwindow;
   else
     grab_xwindow = screen->xroot;
 
@@ -3567,7 +3559,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
   meta_display_set_grab_op_cursor (display, screen, op, FALSE, grab_xwindow,
                                    timestamp);
 
-  if (!display->grab_have_pointer)
+  if (!display->grab_have_pointer && !grab_op_is_keyboard (op))
     {
       meta_topic (META_DEBUG_WINDOW_OPS,
                   "XGrabPointer() failed\n");
@@ -3577,9 +3569,9 @@ meta_display_begin_grab_op (MetaDisplay *display,
   /* Grab keys for keyboard ops and mouse move/resizes; see #126497 */
   if (grab_op_is_keyboard (op) || grab_op_is_mouse_only (op))
     {
-      if (window)
+      if (grab_window)
         display->grab_have_keyboard =
-                     meta_window_grab_all_keys (window, timestamp);
+                     meta_window_grab_all_keys (grab_window, timestamp);
 
       else
         display->grab_have_keyboard =
@@ -3596,11 +3588,21 @@ meta_display_begin_grab_op (MetaDisplay *display,
     }
   
   display->grab_op = op;
-  display->grab_window = window;
+  display->grab_window = grab_window;
   display->grab_screen = screen;
   display->grab_xwindow = grab_xwindow;
   display->grab_button = button;
   display->grab_mask = modmask;
+  if (window)
+    {
+      display->grab_tile_mode = window->tile_mode;
+      display->grab_tile_monitor_number = window->tile_monitor_number;
+    }
+  else
+    {
+      display->grab_tile_mode = META_TILE_NONE;
+      display->grab_tile_monitor_number = -1;
+    }
   display->grab_anchor_root_x = root_x;
   display->grab_anchor_root_y = root_y;
   display->grab_latest_motion_x = root_x;
@@ -3797,6 +3799,8 @@ meta_display_end_grab_op (MetaDisplay *display,
   display->grab_window = NULL;
   display->grab_screen = NULL;
   display->grab_xwindow = None;
+  display->grab_tile_mode = META_TILE_NONE;
+  display->grab_tile_monitor_number = -1;
   display->grab_op = META_GRAB_OP_NONE;
 
   if (display->grab_resize_popup)
@@ -4108,8 +4112,6 @@ meta_display_queue_retheme_all_windows (MetaDisplay *display)
       meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
       if (window->frame)
         {
-          window->frame->need_reapply_frame_shape = TRUE;
-          
           meta_frame_queue_draw (window->frame);
         }
       
@@ -4324,11 +4326,7 @@ process_request_frame_extents (MetaDisplay    *display,
                                          &hints);
   if ((hints_set && hints->decorations) || !hints_set)
     {
-      int top = 0;
-      int bottom = 0;
-      int left = 0;
-      int right = 0;
-
+      MetaFrameBorders borders;
       MetaScreen *screen;
 
       screen = meta_display_screen_for_xwindow (display,
@@ -4346,15 +4344,11 @@ process_request_frame_extents (MetaDisplay    *display,
       meta_ui_theme_get_frame_borders (screen->ui,
                                        META_FRAME_TYPE_NORMAL,
                                        0,
-                                       &top,
-                                       &bottom,
-                                       &left,
-                                       &right);
-
-      data[0] = left;
-      data[1] = right;
-      data[2] = top;
-      data[3] = bottom;
+                                       &borders);
+      data[0] = borders.visible.left;
+      data[1] = borders.visible.right;
+      data[2] = borders.visible.top;
+      data[3] = borders.visible.bottom;
     }
 
   meta_topic (META_DEBUG_GEOMETRY,
@@ -5080,7 +5074,7 @@ meta_display_stack_cmp (const void *a,
  * An example of using this would be to sort the list of transient dialogs for a
  * window into their current stacking order.
  *
- * Returns: (transfer container): Input windows sorted by stacking order, from lowest to highest
+ * Returns: (transfer container) (element-type MetaWindow): Input windows sorted by stacking order, from lowest to highest
  */
 GSList *
 meta_display_sort_windows_by_stacking (MetaDisplay *display,
@@ -5188,43 +5182,6 @@ prefs_changed_callback (MetaPreference pref,
     {
       meta_bell_set_audible (display, meta_prefs_bell_is_audible ());
     }
-  else if (pref == META_PREF_COMPOSITING_MANAGER)
-    {
-      gboolean cm = meta_prefs_get_compositing_manager ();
-
-      if (cm)
-        enable_compositor (display, TRUE);
-      else
-	disable_compositor (display);
-    }
-  else if (pref == META_PREF_ATTACH_MODAL_DIALOGS)
-    {
-      MetaDisplay *display = data;
-      GSList *windows;
-      GSList *tmp;
-
-      windows = meta_display_list_windows (display, META_LIST_DEFAULT);
-
-      for (tmp = windows; tmp != NULL; tmp = tmp->next)
-        {
-          MetaWindow *w = tmp->data;
-          MetaWindow *parent = meta_window_get_transient_for (w);
-          meta_window_recalc_features (w);
-
-          if (w->type == META_WINDOW_MODAL_DIALOG && parent && parent != w)
-            {
-              int x, y;
-              /* Forcing a call to move_resize() does two things: first, it handles
-               * resizing the dialog frame window to the correct size when we remove
-               * or add the decorations. Second, it will take care of positioning the
-               * dialog as "attached" to the parent when we turn the preference on
-               * via the constrain_modal_dialog() constraint.
-               **/
-              meta_window_get_position (w, &x, &y);
-              meta_window_move (w, FALSE, x, y);
-            }
-        }
-    }
 }
 
 void

src/core/errors.c

@@ -23,7 +23,7 @@
  */
 
 #include <config.h>
-#include "errors.h"
+#include <meta/errors.h>
 #include "display-private.h"
 #include <errno.h>
 #include <stdlib.h>

src/core/frame.c

@@ -24,9 +24,9 @@
  */
 
 #include <config.h>
-#include "frame-private.h"
+#include "frame.h"
 #include "bell.h"
-#include "errors.h"
+#include <meta/errors.h>
 #include "keybindings-private.h"
 
 #include <X11/extensions/Xrender.h>
@@ -67,7 +67,6 @@ meta_window_ensure_frame (MetaWindow *window)
   frame->current_cursor = 0;
 
   frame->mapped = FALSE;
-  frame->need_reapply_frame_shape = TRUE;
   frame->is_flashing = FALSE;
   
   meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
@@ -117,11 +116,6 @@ meta_window_ensure_frame (MetaWindow *window)
   
   meta_display_register_x_window (window->display, &frame->xwindow, window);
 
-  /* Now that frame->xwindow is registered with window, we can set its
-   * background.
-   */
-  meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);
-
   /* 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
@@ -157,6 +151,12 @@ meta_window_ensure_frame (MetaWindow *window)
   
   /* stick frame to the window */
   window->frame = frame;
+
+  /* Now that frame->xwindow is registered with window, we can set its
+   * style and background.
+   */
+  meta_ui_update_frame_style (window->screen->ui, frame->xwindow);
+  meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);
   
   if (window->title)
     meta_ui_set_frame_title (window->screen->ui,
@@ -166,14 +166,6 @@ meta_window_ensure_frame (MetaWindow *window)
   /* Move keybindings to frame instead of window */
   meta_window_grab_keys (window);
 
-  /* Shape mask */
-  meta_ui_apply_frame_shape (frame->window->screen->ui,
-                             frame->xwindow,
-                             frame->rect.width,
-                             frame->rect.height,
-                             frame->window->has_shape);
-  frame->need_reapply_frame_shape = FALSE;
-  
   meta_display_ungrab (window->display);
 }
 
@@ -181,6 +173,7 @@ void
 meta_window_destroy_frame (MetaWindow *window)
 {
   MetaFrame *frame;
+  MetaFrameBorders borders;
   
   if (window->frame == NULL)
     return;
@@ -188,6 +181,8 @@ meta_window_destroy_frame (MetaWindow *window)
   meta_verbose ("Unframing window %s\n", window->desc);
   
   frame = window->frame;
+
+  meta_frame_calc_borders (frame, &borders);
   
   meta_bell_notify_frame_destroy (frame);
   
@@ -215,8 +210,8 @@ meta_window_destroy_frame (MetaWindow *window)
                     * coordinates here means we'll need to ensure a configure
                     * notify event is sent; see bug 399552.
                     */
-                   window->frame->rect.x,
-                   window->frame->rect.y);
+                   window->frame->rect.x + borders.invisible.left,
+                   window->frame->rect.y + borders.invisible.top);
   meta_error_trap_pop (window->display);
 
   meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);
@@ -225,6 +220,11 @@ meta_window_destroy_frame (MetaWindow *window)
                                     frame->xwindow);
   
   window->frame = NULL;
+  if (window->frame_bounds)
+    {
+      cairo_region_destroy (window->frame_bounds);
+      window->frame_bounds = NULL;
+    }
 
   /* Move keybindings to window instead of frame */
   meta_window_grab_keys (window);
@@ -282,7 +282,7 @@ meta_frame_get_flags (MetaFrame *frame)
   if (frame->window->shaded)
     flags |= META_FRAME_SHADED;
 
-  if (frame->window->on_all_workspaces)
+  if (frame->window->on_all_workspaces_requested)
     flags |= META_FRAME_STUCK;
 
   /* FIXME: Should we have some kind of UI for windows that are just vertically
@@ -291,6 +291,12 @@ meta_frame_get_flags (MetaFrame *frame)
   if (META_WINDOW_MAXIMIZED (frame->window))
     flags |= META_FRAME_MAXIMIZED;
 
+  if (META_WINDOW_TILED_LEFT (frame->window))
+    flags |= META_FRAME_TILED_LEFT;
+
+  if (META_WINDOW_TILED_RIGHT (frame->window))
+    flags |= META_FRAME_TILED_RIGHT;
+
   if (frame->window->fullscreen)
     flags |= META_FRAME_FULLSCREEN;
 
@@ -304,50 +310,42 @@ meta_frame_get_flags (MetaFrame *frame)
 }
 
 void
-meta_frame_calc_geometry (MetaFrame         *frame,
-                          MetaFrameGeometry *geomp)
+meta_frame_borders_clear (MetaFrameBorders *self)
 {
-  MetaFrameGeometry geom;
-  MetaWindow *window;
-
-  window = frame->window;
-
-  meta_ui_get_frame_geometry (window->screen->ui,
-                              frame->xwindow,
-                              &geom.top_height,
-                              &geom.bottom_height,
-                              &geom.left_width,
-                              &geom.right_width);
-  
-  *geomp = geom;
-}
-
-static void
-update_shape (MetaFrame *frame)
-{
-  if (frame->need_reapply_frame_shape)
-    {
-      meta_ui_apply_frame_shape (frame->window->screen->ui,
-                                 frame->xwindow,
-                                 frame->rect.width,
-                                 frame->rect.height,
-                                 frame->window->has_shape);
-      frame->need_reapply_frame_shape = FALSE;
-    }
+  self->visible.top    = self->invisible.top    = self->total.top    = 0;
+  self->visible.bottom = self->invisible.bottom = self->total.bottom = 0;
+  self->visible.left   = self->invisible.left   = self->total.left   = 0;
+  self->visible.right  = self->invisible.right  = self->total.right  = 0;
 }
 
 void
+meta_frame_calc_borders (MetaFrame        *frame,
+                         MetaFrameBorders *borders)
+{
+  meta_ui_get_frame_borders (frame->window->screen->ui,
+                             frame->xwindow,
+                             borders);
+}
+
+void
+meta_frame_get_corner_radiuses (MetaFrame *frame,
+                                float     *top_left,
+                                float     *top_right,
+                                float     *bottom_left,
+                                float     *bottom_right)
+{
+  meta_ui_get_corner_radiuses (frame->window->screen->ui,
+                               frame->xwindow,
+                               top_left, top_right,
+                               bottom_left, bottom_right);
+}
+
+gboolean
 meta_frame_sync_to_window (MetaFrame *frame,
                            int        resize_gravity,
                            gboolean   need_move,
                            gboolean   need_resize)
 {
-  if (!(need_move || need_resize))
-    {
-      update_shape (frame);
-      return;
-    }
-
   meta_topic (META_DEBUG_GEOMETRY,
               "Syncing frame geometry %d,%d %dx%d (SE: %d,%d)\n",
               frame->rect.x, frame->rect.y,
@@ -362,19 +360,8 @@ meta_frame_sync_to_window (MetaFrame *frame,
                                   frame->xwindow,
                                   frame->rect.width,
                                   frame->rect.height);
-
-      /* we need new shape if we're resized */
-      frame->need_reapply_frame_shape = TRUE;
     }
 
-  /* Done before the window resize, because doing it before means
-   * part of the window being resized becomes unshaped, which may
-   * be sort of hard to see with bg = None. If we did it after
-   * window resize, part of the window being resized would become
-   * shaped, which might be more visible.
-   */
-  update_shape (frame);
-  
   meta_ui_move_resize_frame (frame->window->screen->ui,
 			     frame->xwindow,
 			     frame->rect.x,
@@ -395,6 +382,17 @@ meta_frame_sync_to_window (MetaFrame *frame,
         meta_ui_repaint_frame (frame->window->screen->ui,
                                frame->xwindow);
     }
+
+  return need_resize;
+}
+
+cairo_region_t *
+meta_frame_get_frame_bounds (MetaFrame *frame)
+{
+  return meta_ui_get_frame_bounds (frame->window->screen->ui,
+                                   frame->xwindow,
+                                   frame->rect.width,
+                                   frame->rect.height);
 }
 
 void

src/core/frame.h

@@ -24,20 +24,8 @@
 #ifndef META_FRAME_PRIVATE_H
 #define META_FRAME_PRIVATE_H
 
-#include "frame.h"
 #include "window-private.h"
 
-typedef struct _MetaFrameGeometry MetaFrameGeometry;
-
-struct _MetaFrameGeometry
-{  
-  /* border sizes (space between frame and child) */
-  int left_width;
-  int right_width;
-  int top_height;
-  int bottom_height;
-};
-
 struct _MetaFrame
 {
   /* window we frame */
@@ -68,16 +56,26 @@ void     meta_window_ensure_frame           (MetaWindow *window);
 void     meta_window_destroy_frame          (MetaWindow *window);
 void     meta_frame_queue_draw              (MetaFrame  *frame);
 
-MetaFrameFlags meta_frame_get_flags (MetaFrame *frame);
+MetaFrameFlags meta_frame_get_flags   (MetaFrame *frame);
+Window         meta_frame_get_xwindow (MetaFrame *frame);
 
 /* These should ONLY be called from meta_window_move_resize_internal */
-void meta_frame_calc_geometry      (MetaFrame         *frame,
-                                    MetaFrameGeometry *geomp);
-void meta_frame_sync_to_window     (MetaFrame         *frame,
+void meta_frame_calc_borders      (MetaFrame        *frame,
+                                   MetaFrameBorders *borders);
+
+void meta_frame_get_corner_radiuses (MetaFrame *frame,
+                                     float     *top_left,
+                                     float     *top_right,
+                                     float     *bottom_left,
+                                     float     *bottom_right);
+
+gboolean meta_frame_sync_to_window (MetaFrame         *frame,
                                     int                gravity,
                                     gboolean           need_move,
                                     gboolean           need_resize);
 
+cairo_region_t *meta_frame_get_frame_bounds (MetaFrame *frame);
+
 void meta_frame_set_screen_cursor (MetaFrame	*frame,
 				   MetaCursor	cursor);
 

src/core/group-private.h

@@ -24,7 +24,7 @@
 #ifndef META_GROUP_PRIVATE_H
 #define META_GROUP_PRIVATE_H
 
-#include "group.h"
+#include <meta/group.h>
 
 struct _MetaGroup
 {

src/core/group-props.h

@@ -24,7 +24,7 @@
 #ifndef META_GROUP_PROPS_H
 #define META_GROUP_PROPS_H
 
-#include "group.h"
+#include <meta/group.h>
 #include "window-private.h"
 
 void meta_group_reload_property         (MetaGroup   *group,