gpu-kms: Protect against NULL crtc->current_mode

When failing to apply the CRTC mode, Mutter throws a warning
message. This warning message would try to access the name of
the CRTC's current mode.

There are ocasions, however, where the current mode is NULL.
On these cases, Mutter would crash.

Fix that by protecting against NULL CRTC modes.

.gitignore

@@ -1,9 +1,25 @@
+Makefile
+Makefile.in
+Makefile.in.in
+aclocal.m4
+autom4te.cache
 build-aux
 compile
+config.guess
 config.h
 config.h.in
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+intltool-extract.in
+intltool-merge.in
+libtool
 ltmain.sh
 missing
+.deps
 50-mutter-navigation.xml
 50-mutter-system.xml
 50-mutter-windows.xml
@@ -17,11 +33,15 @@ mutter-wayland.desktop
 *.swp
 *.gir
 *.typelib
+stamp-h1
 *.gmo
 *.make
 *.log
 *.trs
 *~
+stamp-it
+.intltool-merge-cache
+ABOUT-NLS
 POTFILES
 Makevars.template
 po/*.header
@@ -44,7 +64,9 @@ org.gnome.mutter.wayland.gschema.xml
 testasyncgetprop
 testboxes
 testgradient
+m4/*
 INSTALL
+mkinstalldirs
 meta-enum-types.[ch]
 src/stamp-meta-enum-types.h
 src/meta-dbus-display-config.[ch]
@@ -72,8 +94,6 @@ src/xwayland-keyboard-grab-unstable-v1-protocol.c
 src/xwayland-keyboard-grab-unstable-v1-server-protocol.h
 src/tablet-unstable-v*-protocol.c
 src/tablet-unstable-v*-server-protocol.h
-src/text-input-unstable-v*-protocol.c
-src/text-input-unstable-v*-server-protocol.h
 src/keyboard-shortcuts-inhibit-unstable-v*-protocol.c
 src/keyboard-shortcuts-inhibit-unstable-v*-server-protocol.h
 src/linux-dmabuf-unstable-v*-protocol.c
@@ -100,6 +120,12 @@ doc/reference/meta-undocumented.txt
 doc/reference/meta-unused.txt
 doc/reference/meta-docs.sgml
 doc/reference/meta.types
+gtk-doc.m4
+intltool.m4
+libtool.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+lt~obsolete.m4
 .dirstamp
 **/tags.*
-build/

.gitlab-ci.yml

@@ -1,20 +0,0 @@
-image: registry.gitlab.gnome.org/gnome/mutter/master:v1
-
-stages:
- - build
- - test
-
-build-mutter:
-  stage: build
-  script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
-    - ninja -C build
-    - ninja -C build install
-
-test-mutter:
-  stage: test
-  script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
-    - ninja -C build
-    - glib-compile-schemas $PWD/build/data
-    - env XDG_RUNTIME_DIR=/tmp/ GSETTINGS_SCHEMA_DIR=$PWD/build/data dbus-run-session -- xvfb-run -s '+iglx -noreset' meson test -C build -t 10 --verbose --no-stdsplit --wrap catchsegv

.gitlab-ci/Dockerfile

@@ -1,20 +0,0 @@
-FROM fedora:29
-
-RUN dnf -y update && dnf -y upgrade && \
-    dnf install -y 'dnf-command(builddep)' && \
-    dnf builddep -y mutter && \
-
-    # Until Fedora catches up with meson build-deps
-    dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
-
-    # For running unit tests
-    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
-
-    # Unpackaged versions
-    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
-
-    # Packages not yet in stable
-    dnf install -y https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-devel-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-libs-0.2.5-1.fc29.x86_64.rpm && \
-
-    dnf install -y intltool redhat-rpm-config make && \
-    dnf clean all

Makefile.am

@@ -0,0 +1,11 @@
+
+SUBDIRS = cogl clutter data src po doc
+
+ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+
+DISTCLEANFILES = \
+	intltool-extract \
+	intltool-merge \
+	intltool-update \
+	po/stamp-it \
+	po/.intltool-merge-cache

NEWS

@@ -1,140 +1,10 @@
-3.31.4
-======
-* keybindings: Limit corner move to current monitor [Jānis; #320]
-* xdg-output: Report rotated physical dimensions [Olivier; #369]
-* Add continuous integration pipeline [Jonas; #193]
-* Improve performance on secondary GPUs [Pekka; #323, !313]
-* Use the actual hardware refresh rate [Daniel; #781296]
-* Remove hide-titlebar-when-maximized support [Florian; !221]
-* wayland: Implement buffer transforms [Robert; !322]
-* Remove ability to externally set sync-to-vblank [Georges; !191]
-* Turn off touchscreens together with DPMS [Carlos; gnome-settings-daemon#29]
-* Mipmap the wallpaper when shrinking [Daniel; gnome-shell#254]
-* Implement RecordWindow method for screen-casts [Olivier; !306]
-* Fix EGLStream texture downloading [Jonas; !362]
-* Split out display-server-specific code from MetaWindowActor [Georges; !368]
-* Improve render performance on some KMS devices with software GL [Jonas; #106]
-* Fix damage area of transformed surfaces [Robert; !366]
-* Remove autotools support [George]
-* Misc. bug fixes and cleanups [Jonas, Alan, Olivier, Carlos, Javier, Peter,
-  Daniel, Robert, Florian; !309, #790207, #272, #393, #276, #404, #104, !343,
-  #765011, #786663, #342, !356, #414, #782344, #781034, #423, !374, !382, !383]
-
-Contributors:
-  Jonas Ådahl, Nikita Churaev, Alan Coopersmith, Jānis Džeriņš, Olivier Fourdan,
-  Carlos Garnacho, Niels De Graef, Peter Hutterer, Javier Jardón,
-  Abderrahim Kitouni, Andre Klapper, Ting-Wei Lan, Robert Mader,
-  Emilio Pozuelo Monfort, Florian Müllner, Georges Basile Stavracas Neto,
-  Pekka Paalanen, Daniel Stone, Marco Trevisan (Treviño), Daniel van Vugt
-
-3.31.2
-======
-* Fix handling of non-UTF8 encodings [Florian; !227]
-* Fix memory leaks introduced in 3.30.1 [Jonas; #653]
-* Fix regression when overriding workspace layout [Ron; #270]
-* Fix crash when restarting window manager [Andrea; gnome-shell#595]
-* Add meson build support [Jonas; !167]
-* Freeze clock when headless [Jonas; !170]
-* Fix crash on monitor hotplug [Olivier; #189]
-* Misc. bug fixes [Jonas; #353, !132, #382]
-
-Contributors:
-  Jonas Ådahl, Andrea Azzarone, Olivier Fourdan, Niels De Graef,
-  Alexander Mikhaylenko, Florian Müllner, Akira Nakajima,
-  Georges Basile Stavracas Neto, Pekka Paalanen, Peter Uithoven,
-  Daniel van Vugt, Ron Yorston
-
-3.30.1
-======
-* Improve trackball detection [Tony; #258]
-* Fix clipping of scaled surfaces [Jonas; #300]
-* Improve tracking of monitor switch configuration [Daniel; !213]
-* Fix parent-relative positioning of constrained windows [Jonas; #332]
-* Add clutter_input_method_forward_key() method [Carlos; gnome-shell#531]
-* Various crash fixes [Olivier, Jonas; #194, #336]
-* Misc. bug fixes [Carlos, Florian, Olivier, Jonas; gnome-shell#540, #294,
-  #221, !229, #30, #331]
-
-Contributors:
-  Jonas Ådahl, Daniel Drake, Olivier Fourdan, Carlos Garnacho, Peter Hutterer,
-  Ting-Wei Lan, Florian Müllner, Tony Novak, Pekka Paalanen, Sam Spilsbury
-
-Translators:
-  Yuras Shumovich [be], Марко Костић [sr], Marek Cernocky [cs]
-
-3.30.0
-======
-
-Translators:
-  Fran Dieguez [gl], Balázs Meskó [hu], Rūdolfs Mazurs [lv],
-  Trần Ngọc Quân [vi], Ask Hjorth Larsen [da], gogo [hr]
-
-3.29.92
-=======
-* Avoid crash when a cursor is not found [Sebastian; #254]
-* Fix screen rotation regression [Jonas; #216]
-* Handle requests to unmanaged windows gracefully [Jonas; #240]
-* Move popups together with their parent [Jonas; #274]
-* Fix non-lowercase letters on virtual key devices [Carlos; gnome-shell#135]
-* Misc. bug fixes [Iain, Jonas; #223, #192, #279]
-
-Contributors:
-  Jonas Ådahl, Carlos Garnacho, Sebastian Keller, Iain Lane, Robert Mader,
-  Daniel van Vugt
-
-Translators:
-  Gwan-gyeong Mun [ko], Kukuh Syafaat [id], Milo Casagrande [it],
-  Anders Jonsson [sv], Rafael Fontenelle [pt_BR], Marek Cernocky [cs]
-
-3.29.91
-=======
-* Various crash fixes [Olivier, Iain; #255, #223]
-* Fix lock up with some DRI drivers [Alex; #127]
-* Send correct button codes from virtual evdev devices [Jonas; !190]
-* Improve grab-device clock updates on X11 [Jeff; !174]
-* Fix popups closing immediately on key down [Jonas; !180]
-* Prevent clients from modifying the shared keymap [Jonas; #784206]
-
-Contributors:
-  Jonas Ådahl, Andrea Azzarone, Piotr Drąg, Olivier Fourdan, Carlos Garnacho,
-  Jan Grulich, Iain Lane, Alex Villacís Lasso, Jeff Smith, Daniel van Vugt
-
-Translators:
-  Matej Urbančič [sl], Mario Blättermann [de], Piotr Drąg [pl],
-  Aurimas Černius [lt], Yi-Jyun Pan [zh_TW], Emin Tufan Çetin [tr],
-  Fabio Tomat [fur], Bruce Cowan [en_GB]
-
-3.29.90
-=======
-* Various crash fixes [Olivier, Jonas, Florian; #189, #70, #194, #15, #130]
-* Don't expose resolutions that are below the minimum [Andrea; #793223]
-* Remove support for preference overrides [Florian; #786496]
-* Misc. bug fixes and cleanups [Daniel, Jonas, Florian; #131, #245, !176]
-
-Contributors:
-  Jonas Ådahl, Andrea Azzarone, Olivier Fourdan, Florian Müllner, Kevin Tamool,
-  Daniel van Vugt
-
-Translators:
-  Daniel Mustieles [es], Claude Paroz [fr]
-
-3.29.4
-======
-* Fix crash with parent-less modal dialogs [Olivier; #174]
-* Preserve paint volumes where possible to optimize CPU usage [Carlos; #782344]
-
-Contributors:
-  Jonas Ådahl, Olivier Fourdan, Carlos Garnacho, Iain Lane, Bastien Nocera
-
-Translators:
-  Daniel Șerbănescu [ro]
-
 3.29.3
 ======
 * Fix Korean Hangul support on wayland [Changwoo; #152]
 * Improve support for proprietary Nvidia driver [Jonas; #790316]
 * Only upload HW cursor sprite to the GPU that will display them [Jonas; #77]
-* Improve EGLstream support [Miguel; #2, #782575]
+* nvidia [Miguel; #2]
+* nvidia [Miguel; #782575]
 * Remove MetaScreen to prepare for non-mandatary X11 dependency
   [Armin, Jonas; #759538]
 * Misc. bug fixes [Olivier, Jonas, Sam; #160, !130, #786929, #788834]

README.md

@@ -1,31 +0,0 @@
-# Mutter
-
-Mutter is a Wayland display server and X11 window manager and compositor library.
-
-When used as a Wayland display server, it runs on top of KMS and libinput. It
-implements the compositor side of the Wayland core protocol as well as various
-protocol extensions. It also has functionality related to running X11
-applications using Xwayland.
-
-When used on top of Xorg it acts as a X11 window manager and compositing manager.
-
-It contains functionality related to, among other things, window management,
-window compositing, focus tracking, workspace management, keybindings and
-monitor configuration.
-
-Internally it uses a fork of Cogl, a hardware acceleration abstraction library
-used to simplify usage of OpenGL pipelines, as well as a fork af Clutter, a
-scene graph and user interface toolkit.
-
-Mutter is used by, for example, GNOME Shell, the GNOME core user interface, and
-by  Gala, elementary OS's window manager. It can also be run standalone, using
-the  command "mutter", but just running plain mutter is only intended for
-debugging purposes.
-
-## License
-
-Mutter is distributed under the terms of the GNU General Public License,
-version 2 or later. See the [COPYING][license] file for detalis.
-
-[bug-tracker]: https://gitlab.gnome.org/GNOME/mutter/issues
-[license]: COPYING

autogen.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+# Run this to generate all the initial makefiles, etc.
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+REQUIRED_AUTOMAKE_VERSION=1.11
+
+olddir="$(pwd)"
+
+cd "${srcdir}"
+
+(test -f configure.ac \
+  && test -d src) || {
+    echo -n "**Error**: Directory "\`$srcdir\'" does not look like the"
+    echo " top-level mutter directory"
+    exit 1
+}
+
+aclocal --install || exit 1
+intltoolize --force --copy --automake || exit 1
+autoreconf --verbose --force --install || exit 1
+
+cd "${olddir}"
+
+if [ "$NOCONFIGURE" = "" ]; then
+    "${srcdir}/configure" "$@" || exit 1
+fi

clutter/.gitignore

@@ -23,6 +23,7 @@ clutter-build-config.h.in
 clutter-config.h
 clutter-enum-types.[ch]
 clutter-marshal.[ch]
+clutter-version.h
 gcov-report.txt
 clutter-json.h
 clutter-lcov.info

clutter/Makefile.am

@@ -0,0 +1,53 @@
+NULL =
+
+SUBDIRS = build clutter tests
+
+if BUILD_EXAMPLES
+SUBDIRS += examples
+endif
+
+DIST_SUBDIRS = clutter tests examples build
+
+# XXX - this is a massive hack to make autoreconf honour the ACLOCAL_FLAGS
+# that jhbuild sets while still retaining build/autotools as the authoritative
+# source for m4 macros
+ACLOCAL_AMFLAGS = -I build/autotools ${ACLOCAL_FLAGS}
+
+CLEANFILES = $(pcfiles)
+
+DISTCLEANFILES =
+
+DISTCHECK_CONFIGURE_FLAGS = --enable-maintainer-flags
+
+# proxy rules for tests
+test-report full-report:
+	$(MAKE) -C tests/conform $(@)
+
+perf-report:
+	$(MAKE) -C tests/performance $(@)
+
+if ENABLE_GCOV
+# use recursive makes in order to ignore errors during check/perf
+lcov:
+	-$(MAKE) $(AM_MAKEFLAGS) -C clutter check
+	-$(MAKE) $(AM_MAKEFLAGS) -C tests/conform test
+	$(MAKE) $(AM_MAKEFLAGS) genlcov
+
+# we have to massage the lcov.info file slightly to hide the effect of libtool
+# placing the objects files in the .libs/ directory separate from the *.c
+genlcov:
+	$(LTP) --directory $(top_builddir) --capture --output-file clutter-lcov.info --test-name CLUTTER_TEST --no-checksum
+	$(SED) -e 's#.libs/##' < clutter-lcov.info > clutter-lcov.info.tmp
+	LANG=C $(LTP_GENHTML) --prefix $(top_builddir) --output-directory clutter-lcov --title "Clutter Code Coverage" --show-details clutter-lcov.info.tmp
+	rm -f clutter-lcov.info.tmp
+
+lcov-clean:
+	-$(LTP) --directory $(top_builddir) -z
+	-$(RM) -rf clutter-lcov.info clutter-lcov
+else
+lcov genlcov lcov-clean:
+	@echo You need to configure Clutter with support for gcov enabled.
+	@echo e.g., ./configure --enable-gcov
+endif
+
+.PHONY: test-report full-report perf-report lcov genlcov lcov-clean

clutter/build/Makefile.am

@@ -0,0 +1 @@
+SUBDIRS = autotools

clutter/build/autotools/.gitignore

@@ -0,0 +1,8 @@
+gtk-doc.m4
+libtool.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+lt~obsolete.m4
+shave
+shave-libtool

clutter/build/autotools/Makefile.am

@@ -0,0 +1,10 @@
+NULL =
+
+EXTRA_DIST = \
+	introspection.m4	\
+	as-compiler-flag.m4	\
+	glibtests.m4		\
+	glib-tap.mk		\
+	tap-driver.sh		\
+	tap-test		\
+	$(NULL)

clutter/build/autotools/as-compiler-flag.m4

@@ -0,0 +1,62 @@
+dnl as-compiler-flag.m4 0.1.0
+
+dnl autostars m4 macro for detection of compiler flags
+
+dnl David Schleef <ds@schleef.org>
+
+dnl $Id: as-compiler-flag.m4,v 1.1 2005/12/15 23:35:19 ds Exp $
+
+dnl AS_COMPILER_FLAG(CFLAGS, ACTION-IF-ACCEPTED, [ACTION-IF-NOT-ACCEPTED])
+dnl Tries to compile with the given CFLAGS.
+dnl Runs ACTION-IF-ACCEPTED if the compiler can compile with the flags,
+dnl and ACTION-IF-NOT-ACCEPTED otherwise.
+
+AC_DEFUN([AS_COMPILER_FLAG],
+[
+  AC_MSG_CHECKING([to see if compiler understands $1])
+
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS $1"
+
+  AC_TRY_COMPILE([ ], [], [flag_ok=yes], [flag_ok=no])
+  CFLAGS="$save_CFLAGS"
+
+  if test "X$flag_ok" = Xyes ; then
+    m4_ifvaln([$2],[$2])
+    true
+  else
+    m4_ifvaln([$3],[$3])
+    true
+  fi
+  AC_MSG_RESULT([$flag_ok])
+])
+
+dnl AS_COMPILER_FLAGS(VAR, FLAGS)
+dnl Tries to compile with the given CFLAGS.
+
+AC_DEFUN([AS_COMPILER_FLAGS],
+[
+  list=$2
+  flags_supported=""
+  flags_unsupported=""
+  AC_MSG_CHECKING([for supported compiler flags])
+  for each in $list
+  do
+    save_CFLAGS="$CFLAGS"
+    CFLAGS="$CFLAGS $each"
+    AC_TRY_COMPILE([ ], [], [flag_ok=yes], [flag_ok=no])
+    CFLAGS="$save_CFLAGS"
+
+    if test "X$flag_ok" = Xyes ; then
+      flags_supported="$flags_supported $each"
+    else
+      flags_unsupported="$flags_unsupported $each"
+    fi
+  done
+  AC_MSG_RESULT([$flags_supported])
+  if test "X$flags_unsupported" != X ; then
+    AC_MSG_WARN([unsupported compiler flags: $flags_unsupported])
+  fi
+  $1="$$1 $flags_supported"
+])
+

clutter/build/autotools/glib-tap.mk

@@ -0,0 +1,134 @@
+# GLIB - Library of useful C routines
+
+TESTS_ENVIRONMENT= \
+	G_TEST_SRCDIR="$(abs_srcdir)" 		\
+	G_TEST_BUILDDIR="$(abs_builddir)" 	\
+	G_DEBUG=gc-friendly 			\
+	MALLOC_CHECK_=2 			\
+	MALLOC_PERTURB_=$$(($${RANDOM:-256} % 256))
+LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) $(top_srcdir)/build/autotools/tap-driver.sh
+LOG_COMPILER = $(top_srcdir)/build/autotools/tap-test
+
+NULL =
+
+# initialize variables for unconditional += appending
+BUILT_SOURCES =
+BUILT_EXTRA_DIST =
+CLEANFILES = *.log *.trs
+DISTCLEANFILES =
+MAINTAINERCLEANFILES =
+EXTRA_DIST =
+TESTS =
+
+installed_test_LTLIBRARIES =
+installed_test_PROGRAMS =
+installed_test_SCRIPTS =
+nobase_installed_test_DATA =
+
+noinst_LTLIBRARIES =
+noinst_PROGRAMS =
+noinst_SCRIPTS =
+noinst_DATA =
+
+check_LTLIBRARIES =
+check_PROGRAMS =
+check_SCRIPTS =
+check_DATA =
+
+# We support a fairly large range of possible variables.  It is expected that all types of files in a test suite
+# will belong in exactly one of the following variables.
+#
+# First, we support the usual automake suffixes, but in lowercase, with the customary meaning:
+#
+#   test_programs, test_scripts, test_data, test_ltlibraries
+#
+# The above are used to list files that are involved in both uninstalled and installed testing.  The
+# test_programs and test_scripts are taken to be actual testcases and will be run as part of the test suite.
+# Note that _data is always used with the nobase_ automake variable name to ensure that installed test data is
+# installed in the same way as it appears in the package layout.
+#
+# In order to mark a particular file as being only for one type of testing, use 'installed' or 'uninstalled',
+# like so:
+#
+#   installed_test_programs, uninstalled_test_programs
+#   installed_test_scripts, uninstalled_test_scripts
+#   installed_test_data, uninstalled_test_data
+#   installed_test_ltlibraries, uninstalled_test_ltlibraries
+#
+# Additionally, we support 'extra' infixes for programs and scripts.  This is used for support programs/scripts
+# that should not themselves be run as testcases (but exist to be used from other testcases):
+#
+#   test_extra_programs, installed_test_extra_programs, uninstalled_test_extra_programs
+#   test_extra_scripts, installed_test_extra_scripts, uninstalled_test_extra_scripts
+#
+# Additionally, for _scripts and _data, we support the customary dist_ prefix so that the named script or data
+# file automatically end up in the tarball.
+#
+#   dist_test_scripts, dist_test_data, dist_test_extra_scripts
+#   dist_installed_test_scripts, dist_installed_test_data, dist_installed_test_extra_scripts
+#   dist_uninstalled_test_scripts, dist_uninstalled_test_data, dist_uninstalled_test_extra_scripts
+#
+# Note that no file is automatically disted unless it appears in one of the dist_ variables.  This follows the
+# standard automake convention of not disting programs scripts or data by default.
+#
+# test_programs, test_scripts, uninstalled_test_programs and uninstalled_test_scripts (as well as their disted
+# variants) will be run as part of the in-tree 'make check'.  These are all assumed to be runnable under
+# gtester.  That's a bit strange for scripts, but it's possible.
+
+TESTS += $(test_programs) $(test_scripts) $(uninstalled_test_programs) $(uninstalled_test_scripts) \
+         $(dist_test_scripts) $(dist_uninstalled_test_scripts)
+
+# Note: build even the installed-only targets during 'make check' to ensure that they still work.
+# We need to do a bit of trickery here and manage disting via EXTRA_DIST instead of using dist_ prefixes to
+# prevent automake from mistreating gmake functions like $(wildcard ...) and $(addprefix ...) as if they were
+# filenames, including removing duplicate instances of the opening part before the space, eg. '$(addprefix'.
+all_test_programs     = $(test_programs) $(uninstalled_test_programs) $(installed_test_programs) \
+                        $(test_extra_programs) $(uninstalled_test_extra_programs) $(installed_test_extra_programs)
+all_test_scripts      = $(test_scripts) $(uninstalled_test_scripts) $(installed_test_scripts) \
+                        $(test_extra_scripts) $(uninstalled_test_extra_scripts) $(installed_test_extra_scripts)
+all_dist_test_scripts = $(dist_test_scripts) $(dist_uninstalled_test_scripts) $(dist_installed_test_scripts) \
+                        $(dist_test_extra_scripts) $(dist_uninstalled_test_extra_scripts) $(dist_installed_test_extra_scripts)
+all_test_scripts     += $(all_dist_test_scripts)
+EXTRA_DIST           += $(all_dist_test_scripts)
+all_test_data         = $(test_data) $(uninstalled_test_data) $(installed_test_data)
+all_dist_test_data    = $(dist_test_data) $(dist_uninstalled_test_data) $(dist_installed_test_data)
+all_test_data        += $(all_dist_test_data)
+EXTRA_DIST           += $(all_dist_test_data)
+all_test_ltlibs       = $(test_ltlibraries) $(uninstalled_test_ltlibraries) $(installed_test_ltlibraries)
+
+if ENABLE_ALWAYS_BUILD_TESTS
+noinst_LTLIBRARIES += $(all_test_ltlibs)
+noinst_PROGRAMS += $(all_test_programs)
+noinst_SCRIPTS += $(all_test_scripts)
+noinst_DATA += $(all_test_data)
+else
+check_LTLIBRARIES += $(all_test_ltlibs)
+check_PROGRAMS += $(all_test_programs)
+check_SCRIPTS += $(all_test_scripts)
+check_DATA += $(all_test_data)
+endif
+
+if ENABLE_INSTALLED_TESTS
+installed_test_PROGRAMS += $(test_programs) $(installed_test_programs) \
+                          $(test_extra_programs) $(installed_test_extra_programs)
+installed_test_SCRIPTS += $(test_scripts) $(installed_test_scripts) \
+                          $(test_extra_scripts) $(test_installed_extra_scripts)
+installed_test_SCRIPTS += $(dist_test_scripts) $(dist_test_extra_scripts) \
+                          $(dist_installed_test_scripts) $(dist_installed_test_extra_scripts)
+nobase_installed_test_DATA += $(test_data) $(installed_test_data)
+nobase_installed_test_DATA += $(dist_test_data) $(dist_installed_test_data)
+installed_test_LTLIBRARIES += $(test_ltlibraries) $(installed_test_ltlibraries)
+installed_testcases = $(test_programs) $(installed_test_programs) \
+                      $(test_scripts) $(installed_test_scripts) \
+                      $(dist_test_scripts) $(dist_installed_test_scripts)
+
+installed_test_meta_DATA = $(installed_testcases:=.test)
+
+%.test: %$(EXEEXT) Makefile
+	$(AM_V_GEN) (echo '[Test]' > $@.tmp; \
+	echo 'Type=session' >> $@.tmp; \
+	echo 'Exec=env G_ENABLE_DIAGNOSTIC=0 CLUTTER_ENABLE_DIAGNOSTIC=0 $(installed_testdir)/$<' >> $@.tmp; \
+	mv $@.tmp $@)
+
+CLEANFILES += $(installed_test_meta_DATA)
+endif

clutter/build/autotools/glibtests.m4

@@ -0,0 +1,28 @@
+dnl GLIB_TESTS
+dnl
+
+AC_DEFUN([GLIB_TESTS],
+[
+  AC_ARG_ENABLE(installed-tests,
+                AS_HELP_STRING([--enable-installed-tests],
+                               [Enable installation of some test cases]),
+                [case ${enableval} in
+                  yes) ENABLE_INSTALLED_TESTS="1"  ;;
+                  no)  ENABLE_INSTALLED_TESTS="" ;;
+                  *) AC_MSG_ERROR([bad value ${enableval} for --enable-installed-tests]) ;;
+                 esac])
+  AM_CONDITIONAL([ENABLE_INSTALLED_TESTS], test "$ENABLE_INSTALLED_TESTS" = "1")
+  AC_ARG_ENABLE(always-build-tests,
+                AS_HELP_STRING([--enable-always-build-tests],
+                               [Enable always building tests during 'make all']),
+                [case ${enableval} in
+                  yes) ENABLE_ALWAYS_BUILD_TESTS="1"  ;;
+                  no)  ENABLE_ALWAYS_BUILD_TESTS="" ;;
+                  *) AC_MSG_ERROR([bad value ${enableval} for --enable-always-build-tests]) ;;
+                 esac])
+  AM_CONDITIONAL([ENABLE_ALWAYS_BUILD_TESTS], test "$ENABLE_ALWAYS_BUILD_TESTS" = "1")
+  if test "$ENABLE_INSTALLED_TESTS" = "1"; then
+    AC_SUBST(installed_test_metadir, [${datadir}/installed-tests/]AC_PACKAGE_NAME)
+    AC_SUBST(installed_testdir, [${libexecdir}/installed-tests/]AC_PACKAGE_NAME)
+  fi
+])

clutter/build/autotools/introspection.m4

@@ -0,0 +1,96 @@
+dnl -*- mode: autoconf -*-
+dnl Copyright 2009 Johan Dahlin
+dnl
+dnl This file is free software; the author(s) gives unlimited
+dnl permission to copy and/or distribute it, with or without
+dnl modifications, as long as this notice is preserved.
+dnl
+
+# serial 1
+
+m4_define([_GOBJECT_INTROSPECTION_CHECK_INTERNAL],
+[
+    AC_BEFORE([AC_PROG_LIBTOOL],[$0])dnl setup libtool first
+    AC_BEFORE([AM_PROG_LIBTOOL],[$0])dnl setup libtool first
+    AC_BEFORE([LT_INIT],[$0])dnl setup libtool first
+
+    dnl enable/disable introspection
+    m4_if([$2], [require],
+    [dnl
+        enable_introspection=yes
+    ],[dnl
+        AC_ARG_ENABLE(introspection,
+                  AS_HELP_STRING([--enable-introspection[=@<:@no/auto/yes@:>@]],
+                                 [Enable introspection for this build]),, 
+                                 [enable_introspection=auto])
+    ])dnl
+
+    AC_MSG_CHECKING([for gobject-introspection])
+
+    dnl presence/version checking
+    AS_CASE([$enable_introspection],
+    [no], [dnl
+        found_introspection="no (disabled, use --enable-introspection to enable)"
+    ],dnl
+    [yes],[dnl
+        PKG_CHECK_EXISTS([gobject-introspection-1.0],,
+                         AC_MSG_ERROR([gobject-introspection-1.0 is not installed]))
+        PKG_CHECK_EXISTS([gobject-introspection-1.0 >= $1],
+                         found_introspection=yes,
+                         AC_MSG_ERROR([You need to have gobject-introspection >= $1 installed to build AC_PACKAGE_NAME]))
+    ],dnl
+    [auto],[dnl
+        PKG_CHECK_EXISTS([gobject-introspection-1.0 >= $1], found_introspection=yes, found_introspection=no)
+	dnl Canonicalize enable_introspection
+	enable_introspection=$found_introspection
+    ],dnl
+    [dnl	
+        AC_MSG_ERROR([invalid argument passed to --enable-introspection, should be one of @<:@no/auto/yes@:>@])
+    ])dnl
+
+    AC_MSG_RESULT([$found_introspection])
+
+    INTROSPECTION_SCANNER=
+    INTROSPECTION_COMPILER=
+    INTROSPECTION_GENERATE=
+    INTROSPECTION_GIRDIR=
+    INTROSPECTION_TYPELIBDIR=
+    if test "x$found_introspection" = "xyes"; then
+       INTROSPECTION_SCANNER=`$PKG_CONFIG --variable=g_ir_scanner gobject-introspection-1.0`
+       INTROSPECTION_COMPILER=`$PKG_CONFIG --variable=g_ir_compiler gobject-introspection-1.0`
+       INTROSPECTION_GENERATE=`$PKG_CONFIG --variable=g_ir_generate gobject-introspection-1.0`
+       INTROSPECTION_GIRDIR=`$PKG_CONFIG --variable=girdir gobject-introspection-1.0`
+       INTROSPECTION_TYPELIBDIR="$($PKG_CONFIG --variable=typelibdir gobject-introspection-1.0)"
+       INTROSPECTION_CFLAGS=`$PKG_CONFIG --cflags gobject-introspection-1.0`
+       INTROSPECTION_LIBS=`$PKG_CONFIG --libs gobject-introspection-1.0`
+       INTROSPECTION_MAKEFILE=`$PKG_CONFIG --variable=datadir gobject-introspection-1.0`/gobject-introspection-1.0/Makefile.introspection
+    fi
+    AC_SUBST(INTROSPECTION_SCANNER)
+    AC_SUBST(INTROSPECTION_COMPILER)
+    AC_SUBST(INTROSPECTION_GENERATE)
+    AC_SUBST(INTROSPECTION_GIRDIR)
+    AC_SUBST(INTROSPECTION_TYPELIBDIR)
+    AC_SUBST(INTROSPECTION_CFLAGS)
+    AC_SUBST(INTROSPECTION_LIBS)
+    AC_SUBST(INTROSPECTION_MAKEFILE)
+
+    AM_CONDITIONAL(HAVE_INTROSPECTION, test "x$found_introspection" = "xyes")
+])
+
+
+dnl Usage:
+dnl   GOBJECT_INTROSPECTION_CHECK([minimum-g-i-version])
+
+AC_DEFUN([GOBJECT_INTROSPECTION_CHECK],
+[
+  _GOBJECT_INTROSPECTION_CHECK_INTERNAL([$1])
+])
+
+dnl Usage:
+dnl   GOBJECT_INTROSPECTION_REQUIRE([minimum-g-i-version])
+
+
+AC_DEFUN([GOBJECT_INTROSPECTION_REQUIRE],
+[
+  _GOBJECT_INTROSPECTION_CHECK_INTERNAL([$1], [require])
+])

clutter/build/autotools/tap-driver.sh

@@ -0,0 +1,652 @@
+#! /bin/sh
+# Copyright (C) 2011-2013 Free Software Foundation, 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, 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, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+scriptversion=2011-12-27.17; # UTC
+
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+
+me=tap-driver.sh
+
+fatal ()
+{
+  echo "$me: fatal: $*" >&2
+  exit 1
+}
+
+usage_error ()
+{
+  echo "$me: $*" >&2
+  print_usage >&2
+  exit 2
+}
+
+print_usage ()
+{
+  cat <<END
+Usage:
+  tap-driver.sh --test-name=NAME --log-file=PATH --trs-file=PATH
+                [--expect-failure={yes|no}] [--color-tests={yes|no}]
+                [--enable-hard-errors={yes|no}] [--ignore-exit]
+                [--diagnostic-string=STRING] [--merge|--no-merge]
+                [--comments|--no-comments] [--] TEST-COMMAND
+The \`--test-name', \`--log-file' and \`--trs-file' options are mandatory.
+END
+}
+
+# TODO: better error handling in option parsing (in particular, ensure
+# TODO: $log_file, $trs_file and $test_name are defined).
+test_name= # Used for reporting.
+log_file=  # Where to save the result and output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=0
+color_tests=0
+merge=0
+ignore_exit=0
+comments=0
+diag_string='#'
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "$me $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) shift;; # No-op.
+  --merge) merge=1;;
+  --no-merge) merge=0;;
+  --ignore-exit) ignore_exit=1;;
+  --comments) comments=1;;
+  --no-comments) comments=0;;
+  --diagnostic-string) diag_string=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+  esac
+  shift
+done
+
+test $# -gt 0 || usage_error "missing test command"
+
+case $expect_failure in
+  yes) expect_failure=1;;
+    *) expect_failure=0;;
+esac
+
+if test $color_tests = yes; then
+  init_colors='
+    color_map["red"]="" # Red.
+    color_map["grn"]="" # Green.
+    color_map["lgn"]="" # Light green.
+    color_map["blu"]="" # Blue.
+    color_map["mgn"]="" # Magenta.
+    color_map["std"]=""     # No color.
+    color_for_result["ERROR"] = "mgn"
+    color_for_result["PASS"]  = "grn"
+    color_for_result["XPASS"] = "red"
+    color_for_result["FAIL"]  = "red"
+    color_for_result["XFAIL"] = "lgn"
+    color_for_result["SKIP"]  = "blu"'
+else
+  init_colors=''
+fi
+
+# :; is there to work around a bug in bash 3.2 (and earlier) which
+# does not always set '$?' properly on redirection failure.
+# See the Autoconf manual for more details.
+:;{
+  (
+    # Ignore common signals (in this subshell only!), to avoid potential
+    # problems with Korn shells.  Some Korn shells are known to propagate
+    # to themselves signals that have killed a child process they were
+    # waiting for; this is done at least for SIGINT (and usually only for
+    # it, in truth).  Without the `trap' below, such a behaviour could
+    # cause a premature exit in the current subshell, e.g., in case the
+    # test command it runs gets terminated by a SIGINT.  Thus, the awk
+    # script we are piping into would never seen the exit status it
+    # expects on its last input line (which is displayed below by the
+    # last `echo $?' statement), and would thus die reporting an internal
+    # error.
+    # For more information, see the Autoconf manual and the threads:
+    # <http://lists.gnu.org/archive/html/bug-autoconf/2011-09/msg00004.html>
+    # <http://mail.opensolaris.org/pipermail/ksh93-integration-discuss/2009-February/004121.html>
+    trap : 1 3 2 13 15
+    if test $merge -gt 0; then
+      exec 2>&1
+    else
+      exec 2>&3
+    fi
+    "$@"
+    echo $?
+  ) | LC_ALL=C ${AM_TAP_AWK-awk} \
+        -v me="$me" \
+        -v test_script_name="$test_name" \
+        -v log_file="$log_file" \
+        -v trs_file="$trs_file" \
+        -v expect_failure="$expect_failure" \
+        -v merge="$merge" \
+        -v ignore_exit="$ignore_exit" \
+        -v comments="$comments" \
+        -v diag_string="$diag_string" \
+'
+# FIXME: the usages of "cat >&3" below could be optimized when using
+# FIXME: GNU awk, and/on on systems that supports /dev/fd/.
+
+# Implementation note: in what follows, `result_obj` will be an
+# associative array that (partly) simulates a TAP result object
+# from the `TAP::Parser` perl module.
+
+## ----------- ##
+##  FUNCTIONS  ##
+## ----------- ##
+
+function fatal(msg)
+{
+  print me ": " msg | "cat >&2"
+  exit 1
+}
+
+function abort(where)
+{
+  fatal("internal error " where)
+}
+
+# Convert a boolean to a "yes"/"no" string.
+function yn(bool)
+{
+  return bool ? "yes" : "no";
+}
+
+function add_test_result(result)
+{
+  if (!test_results_index)
+    test_results_index = 0
+  test_results_list[test_results_index] = result
+  test_results_index += 1
+  test_results_seen[result] = 1;
+}
+
+# Whether the test script should be re-run by "make recheck".
+function must_recheck()
+{
+  for (k in test_results_seen)
+    if (k != "XFAIL" && k != "PASS" && k != "SKIP")
+      return 1
+  return 0
+}
+
+# Whether the content of the log file associated to this test should
+# be copied into the "global" test-suite.log.
+function copy_in_global_log()
+{
+  for (k in test_results_seen)
+    if (k != "PASS")
+      return 1
+  return 0
+}
+
+# FIXME: this can certainly be improved ...
+function get_global_test_result()
+{
+    if ("ERROR" in test_results_seen)
+      return "ERROR"
+    if ("FAIL" in test_results_seen || "XPASS" in test_results_seen)
+      return "FAIL"
+    all_skipped = 1
+    for (k in test_results_seen)
+      if (k != "SKIP")
+        all_skipped = 0
+    if (all_skipped)
+      return "SKIP"
+    return "PASS";
+}
+
+function stringify_result_obj(result_obj)
+{
+  if (result_obj["is_unplanned"] || result_obj["number"] != testno)
+    return "ERROR"
+
+  if (plan_seen == LATE_PLAN)
+    return "ERROR"
+
+  if (result_obj["directive"] == "TODO")
+    return result_obj["is_ok"] ? "XPASS" : "XFAIL"
+
+  if (result_obj["directive"] == "SKIP")
+    return result_obj["is_ok"] ? "SKIP" : COOKED_FAIL;
+
+  if (length(result_obj["directive"]))
+      abort("in function stringify_result_obj()")
+
+  return result_obj["is_ok"] ? COOKED_PASS : COOKED_FAIL
+}
+
+function decorate_result(result)
+{
+  color_name = color_for_result[result]
+  if (color_name)
+    return color_map[color_name] "" result "" color_map["std"]
+  # If we are not using colorized output, or if we do not know how
+  # to colorize the given result, we should return it unchanged.
+  return result
+}
+
+function report(result, details)
+{
+  if (result ~ /^(X?(PASS|FAIL)|SKIP|ERROR)/)
+    {
+      msg = ": " test_script_name
+      add_test_result(result)
+    }
+  else if (result == "#")
+    {
+      msg = " " test_script_name ":"
+    }
+  else
+    {
+      abort("in function report()")
+    }
+  if (length(details))
+    msg = msg " " details
+  # Output on console might be colorized.
+  print decorate_result(result) msg
+  # Log the result in the log file too, to help debugging (this is
+  # especially true when said result is a TAP error or "Bail out!").
+  print result msg | "cat >&3";
+}
+
+function testsuite_error(error_message)
+{
+  report("ERROR", "- " error_message)
+}
+
+function handle_tap_result()
+{
+  details = result_obj["number"];
+  if (length(result_obj["description"]))
+    details = details " " result_obj["description"]
+
+  if (plan_seen == LATE_PLAN)
+    {
+      details = details " # AFTER LATE PLAN";
+    }
+  else if (result_obj["is_unplanned"])
+    {
+       details = details " # UNPLANNED";
+    }
+  else if (result_obj["number"] != testno)
+    {
+       details = sprintf("%s # OUT-OF-ORDER (expecting %d)",
+                         details, testno);
+    }
+  else if (result_obj["directive"])
+    {
+      details = details " # " result_obj["directive"];
+      if (length(result_obj["explanation"]))
+        details = details " " result_obj["explanation"]
+    }
+
+  report(stringify_result_obj(result_obj), details)
+}
+
+# `skip_reason` should be empty whenever planned > 0.
+function handle_tap_plan(planned, skip_reason)
+{
+  planned += 0 # Avoid getting confused if, say, `planned` is "00"
+  if (length(skip_reason) && planned > 0)
+    abort("in function handle_tap_plan()")
+  if (plan_seen)
+    {
+      # Error, only one plan per stream is acceptable.
+      testsuite_error("multiple test plans")
+      return;
+    }
+  planned_tests = planned
+  # The TAP plan can come before or after *all* the TAP results; we speak
+  # respectively of an "early" or a "late" plan.  If we see the plan line
+  # after at least one TAP result has been seen, assume we have a late
+  # plan; in this case, any further test result seen after the plan will
+  # be flagged as an error.
+  plan_seen = (testno >= 1 ? LATE_PLAN : EARLY_PLAN)
+  # If testno > 0, we have an error ("too many tests run") that will be
+  # automatically dealt with later, so do not worry about it here.  If
+  # $plan_seen is true, we have an error due to a repeated plan, and that
+  # has already been dealt with above.  Otherwise, we have a valid "plan
+  # with SKIP" specification, and should report it as a particular kind
+  # of SKIP result.
+  if (planned == 0 && testno == 0)
+    {
+      if (length(skip_reason))
+        skip_reason = "- "  skip_reason;
+      report("SKIP", skip_reason);
+    }
+}
+
+function extract_tap_comment(line)
+{
+  if (index(line, diag_string) == 1)
+    {
+      # Strip leading `diag_string` from `line`.
+      line = substr(line, length(diag_string) + 1)
+      # And strip any leading and trailing whitespace left.
+      sub("^[ \t]*", "", line)
+      sub("[ \t]*$", "", line)
+      # Return what is left (if any).
+      return line;
+    }
+  return "";
+}
+
+# When this function is called, we know that line is a TAP result line,
+# so that it matches the (perl) RE "^(not )?ok\b".
+function setup_result_obj(line)
+{
+  # Get the result, and remove it from the line.
+  result_obj["is_ok"] = (substr(line, 1, 2) == "ok" ? 1 : 0)
+  sub("^(not )?ok[ \t]*", "", line)
+
+  # If the result has an explicit number, get it and strip it; otherwise,
+  # automatically assing the next progresive number to it.
+  if (line ~ /^[0-9]+$/ || line ~ /^[0-9]+[^a-zA-Z0-9_]/)
+    {
+      match(line, "^[0-9]+")
+      # The final `+ 0` is to normalize numbers with leading zeros.
+      result_obj["number"] = substr(line, 1, RLENGTH) + 0
+      line = substr(line, RLENGTH + 1)
+    }
+  else
+    {
+      result_obj["number"] = testno
+    }
+
+  if (plan_seen == LATE_PLAN)
+    # No further test results are acceptable after a "late" TAP plan
+    # has been seen.
+    result_obj["is_unplanned"] = 1
+  else if (plan_seen && testno > planned_tests)
+    result_obj["is_unplanned"] = 1
+  else
+    result_obj["is_unplanned"] = 0
+
+  # Strip trailing and leading whitespace.
+  sub("^[ \t]*", "", line)
+  sub("[ \t]*$", "", line)
+
+  # This will have to be corrected if we have a "TODO"/"SKIP" directive.
+  result_obj["description"] = line
+  result_obj["directive"] = ""
+  result_obj["explanation"] = ""
+
+  if (index(line, "#") == 0)
+    return # No possible directive, nothing more to do.
+
+  # Directives are case-insensitive.
+  rx = "[ \t]*#[ \t]*([tT][oO][dD][oO]|[sS][kK][iI][pP])[ \t]*"
+
+  # See whether we have the directive, and if yes, where.
+  pos = match(line, rx "$")
+  if (!pos)
+    pos = match(line, rx "[^a-zA-Z0-9_]")
+
+  # If there was no TAP directive, we have nothing more to do.
+  if (!pos)
+    return
+
+  # Let`s now see if the TAP directive has been escaped.  For example:
+  #  escaped:     ok \# SKIP
+  #  not escaped: ok \\# SKIP
+  #  escaped:     ok \\\\\# SKIP
+  #  not escaped: ok \ # SKIP
+  if (substr(line, pos, 1) == "#")
+    {
+      bslash_count = 0
+      for (i = pos; i > 1 && substr(line, i - 1, 1) == "\\"; i--)
+        bslash_count += 1
+      if (bslash_count % 2)
+        return # Directive was escaped.
+    }
+
+  # Strip the directive and its explanation (if any) from the test
+  # description.
+  result_obj["description"] = substr(line, 1, pos - 1)
+  # Now remove the test description from the line, that has been dealt
+  # with already.
+  line = substr(line, pos)
+  # Strip the directive, and save its value (normalized to upper case).
+  sub("^[ \t]*#[ \t]*", "", line)
+  result_obj["directive"] = toupper(substr(line, 1, 4))
+  line = substr(line, 5)
+  # Now get the explanation for the directive (if any), with leading
+  # and trailing whitespace removed.
+  sub("^[ \t]*", "", line)
+  sub("[ \t]*$", "", line)
+  result_obj["explanation"] = line
+}
+
+function get_test_exit_message(status)
+{
+  if (status == 0)
+    return ""
+  if (status !~ /^[1-9][0-9]*$/)
+    abort("getting exit status")
+  if (status < 127)
+    exit_details = ""
+  else if (status == 127)
+    exit_details = " (command not found?)"
+  else if (status >= 128 && status <= 255)
+    exit_details = sprintf(" (terminated by signal %d?)", status - 128)
+  else if (status > 256 && status <= 384)
+    # We used to report an "abnormal termination" here, but some Korn
+    # shells, when a child process die due to signal number n, can leave
+    # in $? an exit status of 256+n instead of the more standard 128+n.
+    # Apparently, both behaviours are allowed by POSIX (2008), so be
+    # prepared to handle them both.  See also Austing Group report ID
+    # 0000051 <http://www.austingroupbugs.net/view.php?id=51>
+    exit_details = sprintf(" (terminated by signal %d?)", status - 256)
+  else
+    # Never seen in practice.
+    exit_details = " (abnormal termination)"
+  return sprintf("exited with status %d%s", status, exit_details)
+}
+
+function write_test_results()
+{
+  print ":global-test-result: " get_global_test_result() > trs_file
+  print ":recheck: "  yn(must_recheck()) > trs_file
+  print ":copy-in-global-log: " yn(copy_in_global_log()) > trs_file
+  for (i = 0; i < test_results_index; i += 1)
+    print ":test-result: " test_results_list[i] > trs_file
+  close(trs_file);
+}
+
+BEGIN {
+
+## ------- ##
+##  SETUP  ##
+## ------- ##
+
+'"$init_colors"'
+
+# Properly initialized once the TAP plan is seen.
+planned_tests = 0
+
+COOKED_PASS = expect_failure ? "XPASS": "PASS";
+COOKED_FAIL = expect_failure ? "XFAIL": "FAIL";
+
+# Enumeration-like constants to remember which kind of plan (if any)
+# has been seen.  It is important that NO_PLAN evaluates "false" as
+# a boolean.
+NO_PLAN = 0
+EARLY_PLAN = 1
+LATE_PLAN = 2
+
+testno = 0     # Number of test results seen so far.
+bailed_out = 0 # Whether a "Bail out!" directive has been seen.
+
+# Whether the TAP plan has been seen or not, and if yes, which kind
+# it is ("early" is seen before any test result, "late" otherwise).
+plan_seen = NO_PLAN
+
+## --------- ##
+##  PARSING  ##
+## --------- ##
+
+is_first_read = 1
+
+while (1)
+  {
+    # Involutions required so that we are able to read the exit status
+    # from the last input line.
+    st = getline
+    if (st < 0) # I/O error.
+      fatal("I/O error while reading from input stream")
+    else if (st == 0) # End-of-input
+      {
+        if (is_first_read)
+          abort("in input loop: only one input line")
+        break
+      }
+    if (is_first_read)
+      {
+        is_first_read = 0
+        nextline = $0
+        continue
+      }
+    else
+      {
+        curline = nextline
+        nextline = $0
+        $0 = curline
+      }
+    # Copy any input line verbatim into the log file.
+    print | "cat >&3"
+    # Parsing of TAP input should stop after a "Bail out!" directive.
+    if (bailed_out)
+      continue
+
+    # TAP test result.
+    if ($0 ~ /^(not )?ok$/ || $0 ~ /^(not )?ok[^a-zA-Z0-9_]/)
+      {
+        testno += 1
+        setup_result_obj($0)
+        handle_tap_result()
+      }
+    # TAP plan (normal or "SKIP" without explanation).
+    else if ($0 ~ /^1\.\.[0-9]+[ \t]*$/)
+      {
+        # The next two lines will put the number of planned tests in $0.
+        sub("^1\\.\\.", "")
+        sub("[^0-9]*$", "")
+        handle_tap_plan($0, "")
+        continue
+      }
+    # TAP "SKIP" plan, with an explanation.
+    else if ($0 ~ /^1\.\.0+[ \t]*#/)
+      {
+        # The next lines will put the skip explanation in $0, stripping
+        # any leading and trailing whitespace.  This is a little more
+        # tricky in truth, since we want to also strip a potential leading
+        # "SKIP" string from the message.
+        sub("^[^#]*#[ \t]*(SKIP[: \t][ \t]*)?", "")
+        sub("[ \t]*$", "");
+        handle_tap_plan(0, $0)
+      }
+    # "Bail out!" magic.
+    # Older versions of prove and TAP::Harness (e.g., 3.17) did not
+    # recognize a "Bail out!" directive when preceded by leading
+    # whitespace, but more modern versions (e.g., 3.23) do.  So we
+    # emulate the latter, "more modern" behaviour.
+    else if ($0 ~ /^[ \t]*Bail out!/)
+      {
+        bailed_out = 1
+        # Get the bailout message (if any), with leading and trailing
+        # whitespace stripped.  The message remains stored in `$0`.
+        sub("^[ \t]*Bail out![ \t]*", "");
+        sub("[ \t]*$", "");
+        # Format the error message for the
+        bailout_message = "Bail out!"
+        if (length($0))
+          bailout_message = bailout_message " " $0
+        testsuite_error(bailout_message)
+      }
+    # Maybe we have too look for dianogtic comments too.
+    else if (comments != 0)
+      {
+        comment = extract_tap_comment($0);
+        if (length(comment))
+          report("#", comment);
+      }
+  }
+
+## -------- ##
+##  FINISH  ##
+## -------- ##
+
+# A "Bail out!" directive should cause us to ignore any following TAP
+# error, as well as a non-zero exit status from the TAP producer.
+if (!bailed_out)
+  {
+    if (!plan_seen)
+      {
+        testsuite_error("missing test plan")
+      }
+    else if (planned_tests != testno)
+      {
+        bad_amount = testno > planned_tests ? "many" : "few"
+        testsuite_error(sprintf("too %s tests run (expected %d, got %d)",
+                                bad_amount, planned_tests, testno))
+      }
+    if (!ignore_exit)
+      {
+        # Fetch exit status from the last line.
+        exit_message = get_test_exit_message(nextline)
+        if (exit_message)
+          testsuite_error(exit_message)
+      }
+  }
+
+write_test_results()
+
+exit 0
+
+} # End of "BEGIN" block.
+'
+
+# TODO: document that we consume the file descriptor 3 :-(
+} 3>"$log_file"
+
+test $? -eq 0 || fatal "I/O or internal error"
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

clutter/build/autotools/tap-test

@@ -0,0 +1,5 @@
+#! /bin/sh
+
+# run a GTest in tap mode. The test binary is passed as $1
+
+$1 -k --tap

clutter/clutter/Makefile.am

@@ -0,0 +1,727 @@
+AUTOMAKE_OPTIONS = subdir-objects
+
+# preamble
+NULL =
+
+# common definitions
+CLEANFILES =
+DISTCLEANFILES =
+EXTRA_DIST =
+BUILT_SOURCES =
+
+AM_CPPFLAGS = \
+	-DCLUTTER_PREFIX=\""$(prefix)"\"	\
+	-DCLUTTER_LIBDIR=\""$(libdir)"\"	\
+	-DCLUTTER_DATADIR=\""$(datadir)"\"	\
+	-DCLUTTER_LOCALEDIR=\""$(localedir)"\"	\
+	-DCLUTTER_SYSCONFDIR=\""$(sysconfdir)"\" \
+	-DCLUTTER_COMPILATION=1			\
+	-DCOGL_DISABLE_DEPRECATION_WARNINGS	\
+	-DG_LOG_DOMAIN=\"Clutter\" 		\
+	-I$(top_srcdir) 			\
+	-I$(top_srcdir)/clutter			\
+	-I$(top_srcdir)/clutter/cally		\
+	-I$(top_builddir)			\
+	-I$(top_builddir)/clutter		\
+	-I$(top_srcdir)/../cogl			\
+	-I$(top_builddir)/../cogl		\
+	-I$(top_builddir)/../cogl/cogl		\
+	$(CLUTTER_DEPRECATED_CFLAGS)		\
+	$(CLUTTER_DEBUG_CFLAGS)			\
+	$(CLUTTER_HIDDEN_VISIBILITY_CFLAGS)	\
+	$(NULL)
+
+AM_CFLAGS = $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
+
+# these are the gir files we generate using g-ir-scanner
+INTROSPECTION_GIRS =
+
+# the base include path for headers
+clutter_base_includedir = $(includedir)/mutter/clutter-$(LIBMUTTER_API_VERSION)
+clutter_includedir = $(clutter_base_includedir)/clutter
+clutter_deprecateddir = $(clutter_base_includedir)/clutter/deprecated
+
+# pkg-config files
+pc_files =
+
+# common sources - please, keep these sorted alphabetically
+source_h =					\
+	clutter-action.h		\
+	clutter-actor-meta.h		\
+	clutter-actor.h		\
+	clutter-align-constraint.h	\
+	clutter-animatable.h          \
+	clutter-backend.h		\
+	clutter-bind-constraint.h	\
+	clutter-binding-pool.h 	\
+	clutter-bin-layout.h		\
+	clutter-blur-effect.h		\
+	clutter-box-layout.h		\
+	clutter-brightness-contrast-effect.h	\
+	clutter-cairo.h		\
+	clutter-canvas.h		\
+	clutter-child-meta.h		\
+	clutter-click-action.h	\
+	clutter-clone.h		\
+	clutter-color-static.h	\
+	clutter-color.h		\
+	clutter-colorize-effect.h	\
+	clutter-constraint.h		\
+	clutter-container.h		\
+	clutter-content.h		\
+	clutter-deform-effect.h	\
+	clutter-deprecated.h		\
+	clutter-desaturate-effect.h	\
+	clutter-device-manager.h	\
+	clutter-drag-action.h		\
+	clutter-drop-action.h		\
+	clutter-effect.h		\
+	clutter-enums.h		\
+	clutter-event.h 		\
+	clutter-feature.h 		\
+	clutter-fixed-layout.h	\
+	clutter-flow-layout.h		\
+	clutter-gesture-action.h 	\
+	clutter-grid-layout.h 	\
+	clutter-group.h 		\
+	clutter-image.h		\
+	clutter-input-device.h	\
+	clutter-input-device-tool.h	\
+	clutter-input-focus.h	\
+	clutter-input-method.h	\
+        clutter-interval.h            \
+	clutter-keyframe-transition.h	\
+	clutter-keysyms.h 		\
+	clutter-layout-manager.h	\
+	clutter-layout-meta.h		\
+	clutter-macros.h		\
+	clutter-main.h		\
+	clutter-offscreen-effect.h	\
+	clutter-page-turn-effect.h	\
+	clutter-paint-nodes.h		\
+	clutter-paint-node.h		\
+	clutter-pan-action.h		\
+	clutter-path-constraint.h	\
+	clutter-path.h		\
+	clutter-property-transition.h	\
+	clutter-rotate-action.h	\
+	clutter-script.h		\
+	clutter-scriptable.h		\
+	clutter-scroll-actor.h	\
+	clutter-settings.h		\
+	clutter-shader-effect.h	\
+	clutter-shader-types.h	\
+	clutter-swipe-action.h	\
+	clutter-snap-constraint.h	\
+	clutter-stage.h 		\
+	clutter-stage-manager.h	\
+	clutter-tap-action.h		\
+	clutter-test-utils.h		\
+	clutter-texture.h 		\
+	clutter-text.h		\
+	clutter-text-buffer.h		\
+	clutter-timeline.h 		\
+	clutter-transition-group.h	\
+	clutter-transition.h		\
+	clutter-types.h		\
+	clutter-units.h 		\
+	clutter-virtual-input-device.h	\
+	clutter-zoom-action.h		\
+	$(NULL)
+
+source_c = \
+	clutter-action.c		\
+	clutter-actor-box.c		\
+	clutter-actor-meta.c		\
+	clutter-actor.c		\
+	clutter-align-constraint.c	\
+	clutter-animatable.c		\
+	clutter-backend.c		\
+	clutter-base-types.c		\
+	clutter-bezier.c		\
+	clutter-bind-constraint.c	\
+	clutter-binding-pool.c	\
+	clutter-bin-layout.c		\
+	clutter-blur-effect.c		\
+	clutter-box-layout.c		\
+	clutter-brightness-contrast-effect.c	\
+	clutter-cairo.c		\
+	clutter-canvas.c		\
+	clutter-child-meta.c		\
+	clutter-click-action.c	\
+	clutter-clone.c		\
+	clutter-color.c 		\
+	clutter-colorize-effect.c	\
+	clutter-constraint.c		\
+	clutter-container.c		\
+	clutter-content.c		\
+	clutter-deform-effect.c	\
+	clutter-desaturate-effect.c	\
+	clutter-device-manager.c	\
+	clutter-drag-action.c		\
+	clutter-drop-action.c		\
+	clutter-effect.c		\
+	clutter-event.c 		\
+	clutter-feature.c 		\
+	clutter-fixed-layout.c	\
+	clutter-flatten-effect.c	\
+	clutter-flow-layout.c		\
+	clutter-gesture-action.c 	\
+	clutter-grid-layout.c 	\
+	clutter-image.c		\
+	clutter-input-device.c	\
+	clutter-input-device-tool.c	\
+	clutter-input-focus.c	\
+	clutter-input-method.c	\
+	clutter-virtual-input-device.c	\
+	clutter-interval.c            \
+	clutter-keyframe-transition.c	\
+	clutter-keysyms-table.c	\
+	clutter-layout-manager.c	\
+	clutter-layout-meta.c		\
+	clutter-main.c 		\
+	clutter-master-clock.c	\
+	clutter-master-clock-default.c	\
+	clutter-offscreen-effect.c	\
+	clutter-page-turn-effect.c	\
+	clutter-paint-nodes.c		\
+	clutter-paint-node.c		\
+	clutter-pan-action.c		\
+	clutter-path-constraint.c	\
+	clutter-path.c		\
+	clutter-property-transition.c	\
+	clutter-rotate-action.c	\
+	clutter-script.c		\
+	clutter-script-parser.c	\
+	clutter-scriptable.c		\
+	clutter-scroll-actor.c	\
+	clutter-settings.c		\
+	clutter-shader-effect.c	\
+	clutter-shader-types.c	\
+	clutter-swipe-action.c	\
+	clutter-snap-constraint.c	\
+	clutter-stage.c		\
+	clutter-stage-manager.c	\
+	clutter-stage-window.c	\
+	clutter-tap-action.c		\
+	clutter-test-utils.c		\
+	clutter-text.c		\
+	clutter-text-buffer.c		\
+	clutter-transition-group.c	\
+	clutter-transition.c		\
+	clutter-timeline.c 		\
+	clutter-units.c		\
+	clutter-util.c 		\
+	clutter-paint-volume.c 	\
+	clutter-zoom-action.c 	\
+	$(NULL)
+
+# private headers; these should not be distributed or introspected
+source_h_priv = \
+	clutter-actor-meta-private.h		\
+	clutter-actor-private.h			\
+	clutter-backend-private.h		\
+	clutter-bezier.h			\
+	clutter-constraint-private.h		\
+	clutter-content-private.h		\
+	clutter-debug.h 			\
+	clutter-device-manager-private.h	\
+	clutter-easing.h			\
+	clutter-effect-private.h		\
+	clutter-event-translator.h		\
+	clutter-event-private.h			\
+	clutter-flatten-effect.h		\
+	clutter-gesture-action-private.h	\
+	clutter-id-pool.h 			\
+	clutter-input-focus-private.h		\
+	clutter-input-method-private.h		\
+	clutter-master-clock.h			\
+	clutter-master-clock-default.h		\
+	clutter-offscreen-effect-private.h	\
+	clutter-paint-node-private.h		\
+	clutter-paint-volume-private.h		\
+	clutter-private.h 			\
+	clutter-script-private.h		\
+	clutter-settings-private.h		\
+	clutter-stage-manager-private.h		\
+	clutter-stage-private.h			\
+	clutter-stage-view.h			\
+	clutter-stage-window.h			\
+	$(NULL)
+
+# private source code; these should not be introspected
+source_c_priv = \
+	clutter-easing.c		\
+	clutter-event-translator.c	\
+	clutter-id-pool.c 		\
+	clutter-stage-view.c		\
+	$(NULL)
+
+# deprecated installed headers
+deprecated_h = \
+	deprecated/clutter-actor.h			\
+	deprecated/clutter-alpha.h 			\
+	deprecated/clutter-animatable.h		\
+	deprecated/clutter-animation.h		\
+	deprecated/clutter-animator.h			\
+	deprecated/clutter-backend.h			\
+	deprecated/clutter-behaviour.h 		\
+	deprecated/clutter-behaviour-depth.h 		\
+	deprecated/clutter-behaviour-ellipse.h	\
+	deprecated/clutter-behaviour-opacity.h 	\
+	deprecated/clutter-behaviour-path.h 		\
+	deprecated/clutter-behaviour-rotate.h 	\
+	deprecated/clutter-behaviour-scale.h 		\
+	deprecated/clutter-bin-layout.h		\
+	deprecated/clutter-box.h			\
+	deprecated/clutter-cairo-texture.h		\
+	deprecated/clutter-container.h		\
+	deprecated/clutter-frame-source.h		\
+	deprecated/clutter-group.h			\
+	deprecated/clutter-input-device.h		\
+	deprecated/clutter-keysyms.h			\
+	deprecated/clutter-list-model.h			\
+	deprecated/clutter-main.h			\
+	deprecated/clutter-media.h			\
+	deprecated/clutter-model.h			\
+	deprecated/clutter-rectangle.h		\
+	deprecated/clutter-score.h 			\
+	deprecated/clutter-shader.h 			\
+	deprecated/clutter-stage-manager.h		\
+	deprecated/clutter-stage.h			\
+	deprecated/clutter-state.h			\
+	deprecated/clutter-table-layout.h		\
+	deprecated/clutter-texture.h			\
+	deprecated/clutter-timeline.h 		\
+	deprecated/clutter-timeout-pool.h 		\
+	deprecated/clutter-util.h 			\
+	$(NULL)
+
+# deprecated source code
+deprecated_c = \
+	deprecated/clutter-actor-deprecated.c		\
+	deprecated/clutter-alpha.c 			\
+	deprecated/clutter-animation.c		\
+	deprecated/clutter-animator.c			\
+	deprecated/clutter-behaviour.c 		\
+	deprecated/clutter-behaviour-depth.c		\
+	deprecated/clutter-behaviour-ellipse.c	\
+	deprecated/clutter-behaviour-opacity.c	\
+	deprecated/clutter-behaviour-path.c		\
+	deprecated/clutter-behaviour-rotate.c		\
+	deprecated/clutter-behaviour-scale.c		\
+	deprecated/clutter-box.c			\
+	deprecated/clutter-cairo-texture.c		\
+	deprecated/clutter-frame-source.c		\
+	deprecated/clutter-group.c 			\
+	deprecated/clutter-input-device-deprecated.c	\
+	deprecated/clutter-layout-manager-deprecated.c \
+	deprecated/clutter-list-model.c			\
+	deprecated/clutter-media.c			\
+	deprecated/clutter-model.c			\
+	deprecated/clutter-rectangle.c 		\
+	deprecated/clutter-score.c 			\
+	deprecated/clutter-shader.c 			\
+	deprecated/clutter-state.c			\
+	deprecated/clutter-table-layout.c		\
+	deprecated/clutter-texture.c 			\
+	deprecated/clutter-timeout-pool.c		\
+	$(NULL)
+
+# deprecated private headers; these should not be installed
+deprecated_h_priv = \
+	deprecated/clutter-model-private.h	\
+	deprecated/clutter-timeout-interval.h	\
+	$(NULL)
+
+# deprecated private source code; these should not be introspected
+deprecated_c_priv = \
+	deprecated/clutter-timeout-interval.c	\
+	$(NULL)
+
+# built sources
+built_source_c = \
+	clutter-enum-types.c			\
+	clutter-marshal.c			\
+	$(NULL)
+
+# built headers
+built_source_h = \
+	clutter-enum-types.h			\
+	clutter-marshal.h			\
+	$(NULL)
+
+# config header
+DISTCLEANFILES += clutter-config.h
+EXTRA_DIST += clutter-config.h.in
+
+# version header
+DISTCLEANFILES += clutter-version.h
+EXTRA_DIST += clutter-version.h.in clutter-version.h
+
+# key symbol update script
+EXTRA_DIST += clutter-keysyms-update.pl
+
+pc_files += mutter-clutter-$(LIBMUTTER_API_VERSION).pc
+
+# in order to be compatible with Clutter < 1.10, when we shipped a single
+# shared library whose name was determined by the single backend it
+# supported, we need to install symbolic links so that existing applications
+# using Clutter won't break in the Brave New World of multi-backend support
+# in the same shared object.
+compat_libs =
+
+# backends source listings
+#
+#   backend_source_c := source code
+#   backend_source_h := installed public headers
+#   backend_source_c_priv := source that should not be scanned by g-i
+#   backend_source_h_priv := private headers
+#   backend_source_built := built sources
+#
+backend_source_c =
+backend_source_h =
+backend_source_c_priv =
+backend_source_h_priv =
+backend_source_built =
+
+# X11 backend rules
+x11_source_c = \
+	x11/clutter-backend-x11.c		\
+	x11/clutter-device-manager-core-x11.c	\
+	x11/clutter-event-x11.c		\
+	x11/clutter-input-device-core-x11.c	\
+	x11/clutter-keymap-x11.c		\
+	x11/clutter-stage-x11.c		\
+	x11/clutter-x11-texture-pixmap.c	\
+	x11/clutter-xkb-a11y-x11.c		\
+	$(NULL)
+
+x11_source_h = \
+	x11/clutter-x11.h			\
+	x11/clutter-x11-texture-pixmap.h	\
+	$(NULL)
+
+x11_source_h_priv = \
+	x11/clutter-backend-x11.h		\
+	x11/clutter-device-manager-core-x11.h	\
+	x11/clutter-input-device-core-x11.h	\
+	x11/clutter-keymap-x11.h		\
+	x11/clutter-settings-x11.h		\
+	x11/clutter-stage-x11.h		\
+	x11/clutter-xkb-a11y-x11.h		\
+	$(NULL)
+
+x11_source_c_priv = \
+	x11/xsettings/xsettings-client.c	\
+	x11/xsettings/xsettings-client.h	\
+	x11/xsettings/xsettings-common.c	\
+	x11/xsettings/xsettings-common.h	\
+	$(NULL)
+
+x11_source_c += \
+	x11/clutter-device-manager-xi2.c	\
+	x11/clutter-input-device-xi2.c	\
+	x11/clutter-input-device-tool-xi2.c \
+	$(NULL)
+
+x11_source_h_priv += \
+	x11/clutter-device-manager-xi2.h	\
+	x11/clutter-input-device-xi2.h	\
+	x11/clutter-input-device-tool-xi2.h \
+	$(NULL)
+
+x11_source_c += \
+	x11/clutter-virtual-input-device-x11.c	\
+	$(NULL)
+
+x11_source_h_priv += \
+	x11/clutter-virtual-input-device-x11.h	\
+	$(NULL)
+
+backend_source_h += $(x11_source_h)
+backend_source_c += $(x11_source_c)
+backend_source_h_priv += $(x11_source_h_priv)
+backend_source_c_priv += $(x11_source_c_priv)
+
+# the list of files we want to introspect on X11
+x11_introspection = $(x11_source_c) $(x11_source_h)
+
+clutterx11_includedir = $(clutter_includedir)/x11
+clutterx11_include_HEADERS = $(x11_source_h)
+
+mutter-clutter-x11-@LIBMUTTER_API_VERSION@.pc: mutter-clutter-$(LIBMUTTER_API_VERSION).pc
+	$(QUIET_GEN)cp -f $< $(@F)
+
+pc_files += mutter-clutter-x11-$(LIBMUTTER_API_VERSION).pc
+
+# Shared cogl backend files
+cogl_source_h =
+
+cogl_source_c = \
+	cogl/clutter-stage-cogl.c	\
+	$(NULL)
+
+cogl_source_h_priv = \
+	cogl/clutter-stage-cogl.h	\
+	$(NULL)
+
+cogl_source_c_priv =
+
+backend_source_h += $(cogl_source_h)
+backend_source_c += $(cogl_source_c)
+backend_source_h_priv += $(cogl_source_h_priv)
+backend_source_c_priv += $(cogl_source_c_priv)
+
+backend_source_h += $(glx_source_h)
+backend_source_c += $(glx_source_c)
+
+evdev_c_priv = \
+	evdev/clutter-device-manager-evdev.c	\
+	evdev/clutter-input-device-evdev.c	\
+	evdev/clutter-seat-evdev.c		\
+	evdev/clutter-virtual-input-device-evdev.c	\
+	evdev/clutter-event-evdev.c		\
+	evdev/clutter-input-device-tool-evdev.c	\
+	$(NULL)
+evdev_h_priv = \
+	evdev/clutter-device-manager-evdev.h	\
+	evdev/clutter-input-device-evdev.h	\
+	evdev/clutter-seat-evdev.h		\
+	evdev/clutter-input-device-tool-evdev.h	\
+	evdev/clutter-virtual-input-device-evdev.h	\
+	$(NULL)
+evdev_h = evdev/clutter-evdev.h
+
+if SUPPORT_WAYLAND
+backend_source_c_priv += $(evdev_c_priv)
+backend_source_h_priv += $(evdev_h_priv)
+backend_source_h += $(evdev_h)
+
+clutterevdev_includedir = $(clutter_includedir)/evdev
+clutterevdev_include_HEADERS = $(evdev_h)
+
+backend_source_c += evdev/clutter-xkb-utils.c
+backend_source_h_priv += evdev/clutter-xkb-utils.h
+
+# EGL backend rules
+egl_source_h = \
+	egl/clutter-egl-headers.h	\
+	egl/clutter-egl.h		\
+	$(NULL)
+
+egl_source_h_priv = egl/clutter-backend-eglnative.h
+egl_source_c = egl/clutter-backend-eglnative.c
+
+wayland_compositor_source_h = \
+	wayland/clutter-wayland-compositor.h		\
+	wayland/clutter-wayland-surface.h
+backend_source_h += $(wayland_compositor_source_h)
+backend_source_c += \
+	wayland/clutter-wayland-surface.c
+
+wayland_compositor_includedir = $(clutter_includedir)/wayland
+wayland_compositor_include_HEADERS = $(wayland_compositor_source_h)
+
+backend_source_h += $(egl_source_h)
+backend_source_c += $(egl_source_c)
+backend_source_h_priv += $(egl_source_h_priv)
+
+clutteregl_includedir = $(clutter_includedir)/egl
+clutteregl_include_HEADERS = $(egl_source_h)
+endif # SUPPORT_WAYLAND
+
+# cally
+cally_sources_h = \
+	cally/cally-actor.h		\
+	cally/cally-clone.h		\
+	cally/cally-factory.h		\
+	cally/cally-group.h		\
+	cally/cally.h			\
+	cally/cally-main.h		\
+	cally/cally-rectangle.h	\
+	cally/cally-root.h		\
+	cally/cally-stage.h		\
+	cally/cally-text.h		\
+	cally/cally-texture.h		\
+	cally/cally-util.h		\
+	$(NULL)
+
+cally_sources_c = \
+	cally/cally-actor.c		\
+	cally/cally.c			\
+	cally/cally-clone.c		\
+	cally/cally-group.c		\
+	cally/cally-rectangle.c	\
+	cally/cally-root.c		\
+	cally/cally-stage.c		\
+	cally/cally-text.c		\
+	cally/cally-texture.c		\
+	cally/cally-util.c		\
+	$(NULL)
+
+cally_sources_private = \
+	cally/cally-actor-private.h	\
+	$(NULL)
+
+cally_includedir = $(clutter_base_includedir)/cally
+cally_include_HEADERS = $(cally_sources_h)
+
+# general build rules:
+# you should not need to modify anything below this point
+
+# glib-genmarshal rules
+glib_marshal_list = clutter-marshal.list
+glib_marshal_prefix = _clutter_marshal
+include $(srcdir)/Makefile.am.marshal
+
+# glib-mkenums rules
+glib_enum_h = clutter-enum-types.h
+glib_enum_c = clutter-enum-types.c
+glib_enum_headers = $(source_h) $(deprecated_h)
+include $(srcdir)/Makefile.am.enums
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = $(pc_files)
+DISTCLEANFILES += $(pc_files)
+
+clutter_include_HEADERS = $(source_h) clutter.h clutter-version.h clutter-autocleanups.h clutter-mutter.h
+nodist_clutter_include_HEADERS = clutter-config.h $(built_source_h)
+
+clutter_deprecated_HEADERS = $(deprecated_h)
+
+mutterlibdir = $(libdir)/mutter
+mutterlib_LTLIBRARIES = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
+
+libmutter_clutter_@LIBMUTTER_API_VERSION@_la_LIBADD = \
+	$(LIBM) \
+	$(CLUTTER_LIBS) \
+	$(top_builddir)/../cogl/cogl/libmutter-cogl-$(LIBMUTTER_API_VERSION).la \
+	$(top_builddir)/../cogl/cogl-pango/libmutter-cogl-pango-$(LIBMUTTER_API_VERSION).la \
+	$(top_builddir)/../cogl/cogl-path/libmutter-cogl-path-$(LIBMUTTER_API_VERSION).la \
+	$(NULL)
+
+libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
+	$(backend_source_c) \
+	$(backend_source_h) \
+	$(backend_source_c_priv) \
+	$(backend_source_h_priv) \
+	$(source_c) \
+	$(source_h) \
+	$(source_c_priv) \
+	$(source_h_priv) \
+	$(deprecated_c) \
+	$(deprecated_h) \
+	$(deprecated_c_priv) \
+	$(deprecated_h_priv) \
+	$(cally_sources_c) \
+	$(cally_sources_h) \
+	$(cally_sources_private) \
+	$(NULL)
+
+nodist_libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
+	$(backend_source_built) \
+	$(built_source_c) \
+	$(built_source_h)
+
+libmutter_clutter_@LIBMUTTER_API_VERSION@_la_LDFLAGS = \
+	$(CLUTTER_LINK_FLAGS) \
+	$(CLUTTER_LT_LDFLAGS) \
+	-export-dynamic \
+	-rpath $(mutterlibdir) \
+	$(NULL)
+
+install-exec-local:
+	test -z "$(mutterlibdir)" || $(MKDIR_P) "$(DESTDIR)$(mutterlibdir)"
+	for lib in `echo $(compat_libs)`; do \
+	  (cd $(DESTDIR)$(mutterlibdir) && \
+	    rm -f $$lib.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION); \
+	  ) ; \
+	  (cd $(DESTDIR)$(mutterlibdir) && \
+	    { ln -s -f libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib.0 || \
+	      { rm -f $$lib.0 && ln -s libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib.0; }; \
+	    } \
+	  ) ; \
+	  (cd $(DESTDIR)$(mutterlibdir) && \
+	    { ln -s -f libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib || \
+	      { rm -f $$lib && ln -s libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib; }; \
+	    } \
+	  ) ; \
+	done
+
+# gobject-introspection rules
+-include $(INTROSPECTION_MAKEFILE)
+
+INTROSPECTION_SCANNER_ARGS = \
+	--add-include-path=$(top_builddir)/../cogl/cogl \
+	--add-include-path=$(top_builddir)/../cogl/cogl-pango
+INTROSPECTION_COMPILER_ARGS = \
+	--includedir=$(top_builddir)/../cogl/cogl \
+	--includedir=$(top_builddir)/../cogl/cogl-pango
+INTROSPECTION_SCANNER_ENV = \
+	PKG_CONFIG_PATH=$(top_builddir)/../cogl/cogl/:$(top_builddir)/../cogl/cogl-pango/:$${PKG_CONFIG_PATH}
+
+Clutter-@LIBMUTTER_API_VERSION@.gir: libmutter-clutter-@LIBMUTTER_API_VERSION@.la Makefile
+
+Clutter_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = Clutter
+Clutter_@LIBMUTTER_API_VERSION@_gir_VERSION = @LIBMUTTER_API_VERSION@
+Clutter_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
+Clutter_@LIBMUTTER_API_VERSION@_gir_FILES = \
+	$(clutter_include_HEADERS) \
+	$(clutter_deprecated_HEADERS) \
+	$(nodist_clutter_include_HEADERS) \
+	$(source_c) \
+	$(deprecated_c) \
+	$(built_source_c)
+Clutter_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
+Clutter_@LIBMUTTER_API_VERSION@_gir_INCLUDES = GL-1.0 GObject-2.0 cairo-1.0 Cogl-@LIBMUTTER_API_VERSION@ CoglPango-@LIBMUTTER_API_VERSION@ Atk-1.0 Json-1.0
+Clutter_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
+	--warn-all \
+	--c-include='clutter/clutter.h' \
+	--pkg-export=mutter-clutter-@LIBMUTTER_API_VERSION@
+
+INTROSPECTION_GIRS += Clutter-@LIBMUTTER_API_VERSION@.gir
+
+Cally-@LIBMUTTER_API_VERSION@.gir: Makefile Clutter-@LIBMUTTER_API_VERSION@.gir
+
+Cally_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = Cally
+Cally_@LIBMUTTER_API_VERSION@_gir_VERSION = @LIBMUTTER_API_VERSION@
+Cally_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
+Cally_@LIBMUTTER_API_VERSION@_gir_FILES = $(cally_sources_h) $(cally_sources_c)
+Cally_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
+Cally_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
+	--warn-all \
+	--c-include='cally/cally.h' \
+	--pkg-export=mutter-clutter-@LIBMUTTER_API_VERSION@ \
+	--include-uninstalled=$(top_builddir)/clutter/Clutter-@LIBMUTTER_API_VERSION@.gir
+
+INTROSPECTION_GIRS += Cally-@LIBMUTTER_API_VERSION@.gir
+
+ClutterX11-@LIBMUTTER_API_VERSION@.gir: Makefile Clutter-@LIBMUTTER_API_VERSION@.gir
+
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = ClutterX11
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_INCLUDES = xlib-2.0
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_FILES = $(x11_introspection)
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
+ClutterX11_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
+	--warn-all \
+	--c-include='clutter/x11/clutter-x11.h' \
+	--pkg-export=mutter-clutter-x11-@LIBMUTTER_API_VERSION@ \
+	--include-uninstalled=$(top_builddir)/clutter/Clutter-@LIBMUTTER_API_VERSION@.gir
+
+INTROSPECTION_GIRS += ClutterX11-@LIBMUTTER_API_VERSION@.gir
+
+# INTROSPECTION_GIRDIR/INTROSPECTION_TYPELIBDIR aren't the right place to
+# install anything - we need to install inside our prefix.
+girdir = $(mutterlibdir)
+gir_DATA = $(INTROSPECTION_GIRS)
+
+typelibdir = $(mutterlibdir)
+typelib_DATA = $(INTROSPECTION_GIRS:.gir=.typelib)
+
+EXTRA_DIST += \
+	Makefile.am.marshal	\
+	Makefile.am.enums
+
+CLEANFILES += $(gir_DATA) $(typelib_DATA)

clutter/clutter/Makefile.am.enums

@@ -0,0 +1,52 @@
+# Rules for generating enumeration types using glib-mkenums
+#
+# Define:
+# 	glib_enum_h = header template file
+# 	glib_enum_c = source template file
+# 	glib_enum_headers = list of headers to parse
+#
+# before including Makefile.am.enums. You will also need to have
+# the following targets already defined:
+#
+# 	CLEANFILES
+#	DISTCLEANFILES
+#	BUILT_SOURCES
+#	EXTRA_DIST
+#
+# Author: Emmanuele Bassi <ebassi@linux.intel.com>
+
+# Basic sanity checks
+$(if $(GLIB_MKENUMS),,$(error Need to define GLIB_MKENUMS))
+
+$(if $(or $(glib_enum_h), \
+          $(glib_enum_c)),, \
+    $(error Need to define glib_enum_h and glib_enum_c))
+
+$(if $(glib_enum_headers),,$(error Need to define glib_enum_headers))
+
+enum_tmpl_h=$(addprefix $(srcdir)/, $(glib_enum_h:.h=.h.in))
+enum_tmpl_c=$(addprefix $(srcdir)/, $(glib_enum_c:.c=.c.in))
+enum_headers=$(addprefix $(srcdir)/, $(glib_enum_headers))
+
+CLEANFILES += stamp-enum-types
+DISTCLEANFILES += $(glib_enum_h) $(glib_enum_c)
+BUILT_SOURCES += $(glib_enum_h) $(glib_enum_c)
+EXTRA_DIST += $(enum_tmpl_h) $(enum_tmpl_c)
+
+stamp-enum-types: $(enum_headers) $(enum_tmpl_h)
+	$(AM_V_GEN)$(GLIB_MKENUMS) \
+		--template $(enum_tmpl_h) \
+	$(enum_headers) > xgen-eh \
+	&& (cmp -s xgen-eh $(glib_enum_h) || cp -f xgen-eh $(glib_enum_h)) \
+	&& rm -f xgen-eh \
+	&& echo timestamp > $(@F)
+
+$(glib_enum_h): stamp-enum-types
+	@true
+
+$(glib_enum_c): $(enum_headers) $(enum_tmpl_h) $(enum_tmpl_c)
+	$(AM_V_GEN)$(GLIB_MKENUMS) \
+		--template $(enum_tmpl_c) \
+	$(enum_headers) > xgen-ec \
+	&& cp -f xgen-ec $(glib_enum_c) \
+	&& rm -f xgen-ec

clutter/clutter/Makefile.am.marshal

@@ -0,0 +1,54 @@
+# Rules for generating marshal files using glib-genmarshal
+#
+# Define:
+# 	glib_marshal_list = marshal list file
+# 	glib_marshal_prefix = prefix for marshal functions
+#
+# before including Makefile.am.marshal. You will also need to have
+# the following targets already defined:
+#
+# 	CLEANFILES
+#	DISTCLEANFILES
+#	BUILT_SOURCES
+#	EXTRA_DIST
+#
+# Author: Emmanuele Bassi <ebassi@linux.intel.com>
+
+# Basic sanity checks
+$(if $(GLIB_GENMARSHAL),,$(error Need to define GLIB_GENMARSHAL))
+
+$(if $(or $(glib_marshal_list), \
+          $(glib_marshal_prefix)),, \
+    $(error Need to define glib_marshal_list and glib_marshal_prefix))
+
+marshal_h = $(glib_marshal_list:.list=.h)
+marshal_c = $(glib_marshal_list:.list=.c)
+marshal_list = $(addprefix $(srcdir)/, $(glib_marshal_list))
+
+CLEANFILES += stamp-marshal
+DISTCLEANFILES += $(marshal_h) $(marshal_c)
+BUILT_SOURCES += $(marshal_h) $(marshal_c)
+EXTRA_DIST += $(marshal_list)
+
+stamp-marshal: $(marshal_list)
+	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
+		--prefix=$(glib_marshal_prefix) \
+		--header \
+		--valist-marshallers \
+	$(marshal_list) > xgen-mh \
+	&& (cmp -s xgen-mh $(marshal_h) || cp -f xgen-mh $(marshal_h)) \
+	&& rm -f xgen-mh \
+	&& echo timestamp > $(@F)
+
+$(marshal_h): stamp-marshal
+	@true
+
+$(marshal_c): $(marshal_h)
+	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
+		--prefix=$(glib_marshal_prefix) \
+		--body \
+		--valist-marshallers \
+		--prototypes \
+	$(marshal_list) > xgen-mc \
+	&& (cmp -s xgen-mc $(marshal_c) || cp -f xgen-mc $(marshal_c)) \
+	&& rm -f xgen-mc

clutter/clutter/cally/cally-actor.c

@@ -67,7 +67,9 @@
  *
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <glib.h>
 #include <clutter/clutter.h>

clutter/clutter/cally/cally-actor.h

@@ -126,19 +126,19 @@ struct _CallyActorClass
   gpointer _padding_dummy[32];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_actor_get_type              (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_actor_new                   (ClutterActor        *actor);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 guint      cally_actor_add_action            (CallyActor          *cally_actor,
                                               const gchar         *action_name,
                                               const gchar         *action_description,
                                               const gchar         *action_keybinding,
                                               CallyActionFunc      action_func);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 guint      cally_actor_add_action_full       (CallyActor          *cally_actor,
                                               const gchar         *action_name,
                                               const gchar         *action_description,
@@ -147,11 +147,11 @@ guint      cally_actor_add_action_full       (CallyActor          *cally_actor,
                                               gpointer             user_data,
                                               GDestroyNotify       notify);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean   cally_actor_remove_action         (CallyActor          *cally_actor,
                                               gint                 action_id);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean   cally_actor_remove_action_by_name (CallyActor          *cally_actor,
                                               const gchar         *action_name);
 

clutter/clutter/cally/cally-clone.h

@@ -74,9 +74,9 @@ struct _CallyCloneClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_clone_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_clone_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-group.h

@@ -77,9 +77,9 @@ struct _CallyGroupClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_group_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_group_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-main.h

@@ -34,9 +34,9 @@
 
 G_BEGIN_DECLS
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean cally_get_cally_initialized (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean cally_accessibility_init    (void);
 
 G_END_DECLS

clutter/clutter/cally/cally-rectangle.h

@@ -74,9 +74,9 @@ struct _CallyRectangleClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_rectangle_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_rectangle_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-root.h

@@ -74,9 +74,9 @@ struct _CallyRootClass
   gpointer _padding_dummy[16];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_root_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_root_new      (void);
 
 G_END_DECLS

clutter/clutter/cally/cally-stage.h

@@ -74,9 +74,9 @@ struct _CallyStageClass
   gpointer _padding_dummy[16];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_stage_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_stage_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-text.c

@@ -39,7 +39,9 @@
  *
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "cally-text.h"
 #include "cally-actor-private.h"

clutter/clutter/cally/cally-text.h

@@ -74,9 +74,9 @@ struct _CallyTextClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_text_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_text_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-texture.h

@@ -74,9 +74,9 @@ struct _CallyTextureClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_texture_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_texture_new      (ClutterActor *actor);
 
 G_END_DECLS

clutter/clutter/cally/cally-util.c

@@ -38,7 +38,9 @@
  * available any accessible object.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <stdlib.h>
 #include <string.h>
@@ -142,7 +144,7 @@ cally_util_get_toolkit_name (void)
 static const gchar *
 cally_util_get_toolkit_version (void)
 {
-  return MUTTER_VERSION;
+  return CLUTTER_VERSION_S;
 }
 
 static guint

clutter/clutter/cally/cally-util.h

@@ -74,7 +74,7 @@ struct _CallyUtilClass
   gpointer _padding_dummy[8];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType cally_util_get_type (void) G_GNUC_CONST;
 
 void _cally_util_override_atk_util (void);

clutter/clutter/cally/cally.c

@@ -29,7 +29,9 @@
  *
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 

clutter/clutter/clutter-action.c

@@ -41,7 +41,9 @@
  * #ClutterAction is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-action.h"
 

clutter/clutter/clutter-action.h

@@ -78,32 +78,32 @@ struct _ClutterActionClass
   void (* _clutter_action8) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_action_get_type (void) G_GNUC_CONST;
 
 /* ClutterActor API */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action            (ClutterActor  *self,
                                                     ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action_with_name  (ClutterActor  *self,
                                                     const gchar   *name,
                                                     ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action         (ClutterActor  *self,
                                                     ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action_by_name (ClutterActor  *self,
                                                     const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *clutter_actor_get_action            (ClutterActor  *self,
                                                     const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GList *        clutter_actor_get_actions           (ClutterActor  *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_clear_actions         (ClutterActor  *self);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean       clutter_actor_has_actions           (ClutterActor  *self);
 
 G_END_DECLS

clutter/clutter/clutter-actor-box.c

@@ -1,4 +1,6 @@
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 

clutter/clutter/clutter-actor-meta.c

@@ -41,7 +41,9 @@
  * #ClutterActorMeta is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-actor-meta-private.h"
 

clutter/clutter/clutter-actor-meta.h

@@ -97,21 +97,21 @@ struct _ClutterActorMetaClass
   void (* _clutter_meta7) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_name     (ClutterActorMeta *meta,
                                                  const gchar      *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 const gchar *   clutter_actor_meta_get_name     (ClutterActorMeta *meta);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_enabled  (ClutterActorMeta *meta,
                                                  gboolean          is_enabled);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean        clutter_actor_meta_get_enabled  (ClutterActorMeta *meta);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *  clutter_actor_meta_get_actor    (ClutterActorMeta *meta);
 
 G_END_DECLS

clutter/clutter/clutter-actor-private.h

@@ -275,13 +275,13 @@ void                            _clutter_actor_set_enable_paint_unmapped
 void                            _clutter_actor_set_has_pointer                          (ClutterActor *self,
                                                                                          gboolean      has_pointer);
 
-void                            _clutter_actor_queue_redraw_with_clip                   (ClutterActor             *self,
+void                            _clutter_actor_queue_redraw_with_clip                   (ClutterActor       *self,
-                                                                                         ClutterRedrawFlags        flags,
+                                                                                         ClutterRedrawFlags  flags,
-                                                                                         const ClutterPaintVolume *clip_volume);
+                                                                                         ClutterPaintVolume *clip_volume);
-void                            _clutter_actor_queue_redraw_full                        (ClutterActor             *self,
+void                            _clutter_actor_queue_redraw_full                        (ClutterActor       *self,
-                                                                                         ClutterRedrawFlags        flags,
+                                                                                         ClutterRedrawFlags  flags,
-                                                                                         const ClutterPaintVolume *volume,
+                                                                                         ClutterPaintVolume *volume,
-                                                                                         ClutterEffect            *effect);
+                                                                                         ClutterEffect      *effect);
 
 ClutterPaintVolume *            _clutter_actor_get_queue_redraw_clip                    (ClutterActor       *self);
 void                            _clutter_actor_set_queue_redraw_clip                    (ClutterActor       *self,

clutter/clutter/clutter-actor.c

@@ -841,7 +841,6 @@ struct _ClutterActorPrivate
   guint needs_x_expand              : 1;
   guint needs_y_expand              : 1;
   guint needs_paint_volume_update   : 1;
-  guint had_effects_on_last_paint_volume_update : 1;
 };
 
 enum
@@ -1094,11 +1093,6 @@ static void clutter_actor_set_child_transform_internal (ClutterActor        *sel
 static void     clutter_actor_realize_internal          (ClutterActor *self);
 static void     clutter_actor_unrealize_internal        (ClutterActor *self);
 
-static void clutter_actor_push_in_cloned_branch (ClutterActor *self,
-                                                 gulong        count);
-static void clutter_actor_pop_in_cloned_branch (ClutterActor *self,
-                                                gulong        count);
-
 /* Helper macro which translates by the anchor coord, applies the
    given transformation and then translates back */
 #define TRANSFORM_ABOUT_ANCHOR_COORD(a,m,c,_transform)  G_STMT_START { \
@@ -1722,22 +1716,6 @@ set_show_on_set_parent (ClutterActor *self,
     }
 }
 
-static void
-clutter_actor_queue_redraw_on_parent (ClutterActor *self)
-{
-  const ClutterPaintVolume *pv;
-
-  if (!self->priv->parent)
-    return;
-
-  /* A relayout/redraw is underway */
-  if (self->priv->needs_allocation)
-    return;
-
-  pv = clutter_actor_get_transformed_paint_volume (self, self->priv->parent);
-  _clutter_actor_queue_redraw_with_clip (self->priv->parent, 0, pv);
-}
-
 /**
  * clutter_actor_show:
  * @self: A #ClutterActor
@@ -1793,7 +1771,7 @@ clutter_actor_show (ClutterActor *self)
   g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_VISIBLE]);
 
   if (priv->parent != NULL)
-    clutter_actor_queue_redraw (self);
+    clutter_actor_queue_redraw (priv->parent);
 
   g_object_thaw_notify (G_OBJECT (self));
 }
@@ -1918,10 +1896,8 @@ clutter_actor_hide (ClutterActor *self)
   g_signal_emit (self, actor_signals[HIDE], 0);
   g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_VISIBLE]);
 
-  if (priv->parent != NULL && priv->needs_allocation)
+  if (priv->parent != NULL)
     clutter_actor_queue_redraw (priv->parent);
-  else
-    clutter_actor_queue_redraw_on_parent (self);
 
   g_object_thaw_notify (G_OBJECT (self));
 }
@@ -2245,46 +2221,25 @@ static void
 clutter_actor_real_pick (ClutterActor       *self,
 			 const ClutterColor *color)
 {
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
-
   /* the default implementation is just to paint a rectangle
    * with the same size of the actor using the passed color
    */
   if (clutter_actor_should_pick_paint (self))
     {
-      static CoglPipeline *default_pick_pipeline = NULL;
       ClutterActorBox box = { 0, };
-      CoglPipeline *pick_pipeline;
       float width, height;
 
-      if (G_UNLIKELY (default_pick_pipeline == NULL))
-        {
-          CoglContext *ctx =
-            clutter_backend_get_cogl_context (clutter_get_default_backend ());
-
-          default_pick_pipeline = cogl_pipeline_new (ctx);
-        }
-
-      g_assert (default_pick_pipeline != NULL);
-      pick_pipeline = cogl_pipeline_copy (default_pick_pipeline);
-
       clutter_actor_get_allocation_box (self, &box);
 
       width = box.x2 - box.x1;
       height = box.y2 - box.y1;
 
-      cogl_pipeline_set_color4ub (pick_pipeline,
+      cogl_set_source_color4ub (color->red,
-                                  color->red,
+                                color->green,
-                                  color->green,
+                                color->blue,
-                                  color->blue,
+                                color->alpha);
-                                  color->alpha);
 
-      cogl_framebuffer_draw_rectangle (framebuffer,
+      cogl_rectangle (0, 0, width, height);
-                                       pick_pipeline,
-                                       0, 0,
-                                       width, height);
-
-      cogl_object_unref (pick_pipeline);
     }
 
   /* XXX - this thoroughly sucks, but we need to maintain compatibility
@@ -4334,9 +4289,6 @@ clutter_actor_remove_child_internal (ClutterActor                 *self,
 
   self->priv->age += 1;
 
-  if (self->priv->in_cloned_branch)
-    clutter_actor_pop_in_cloned_branch (child, self->priv->in_cloned_branch);
-
   /* if the child that got removed was visible and set to
    * expand then we want to reset the parent's state in
    * case the child was the only thing that was making it
@@ -4880,8 +4832,7 @@ clutter_actor_set_scale_factor (ClutterActor      *self,
   g_assert (pspec != NULL);
   g_assert (scale_p != NULL);
 
-  if (*scale_p != factor)
+  _clutter_actor_create_transition (self, pspec, *scale_p, factor);
-    _clutter_actor_create_transition (self, pspec, *scale_p, factor);
 }
 
 static inline void
@@ -8763,14 +8714,15 @@ _clutter_actor_get_allocation_clip (ClutterActor *self,
 }
 
 void
-_clutter_actor_queue_redraw_full (ClutterActor             *self,
+_clutter_actor_queue_redraw_full (ClutterActor       *self,
-                                  ClutterRedrawFlags        flags,
+                                  ClutterRedrawFlags  flags,
-                                  const ClutterPaintVolume *volume,
+                                  ClutterPaintVolume *volume,
-                                  ClutterEffect            *effect)
+                                  ClutterEffect      *effect)
 {
   ClutterActorPrivate *priv = self->priv;
   ClutterPaintVolume allocation_pv;
-  ClutterPaintVolume *pv = NULL;
+  ClutterPaintVolume *pv;
+  gboolean should_free_pv;
   ClutterActor *stage;
 
   /* Here's an outline of the actor queue redraw mechanism:
@@ -8912,15 +8864,21 @@ _clutter_actor_queue_redraw_full (ClutterActor             *self,
       clutter_paint_volume_set_height (pv,
                                        allocation_clip.y2 -
                                        allocation_clip.y1);
+      should_free_pv = TRUE;
+    }
+  else
+    {
+      pv = volume;
+      should_free_pv = FALSE;
     }
 
   self->priv->queue_redraw_entry =
     _clutter_stage_queue_actor_redraw (CLUTTER_STAGE (stage),
                                        priv->queue_redraw_entry,
                                        self,
-                                       pv ? pv : volume);
+                                       pv);
 
-  if (pv)
+  if (should_free_pv)
     clutter_paint_volume_free (pv);
 
   /* If this is the first redraw queued then we can directly use the
@@ -9034,9 +8992,9 @@ clutter_actor_queue_redraw (ClutterActor *self)
  * picking of your actor.
  */
 void
-_clutter_actor_queue_redraw_with_clip (ClutterActor             *self,
+_clutter_actor_queue_redraw_with_clip (ClutterActor       *self,
-                                       ClutterRedrawFlags        flags,
+                                       ClutterRedrawFlags  flags,
-                                       const ClutterPaintVolume *volume)
+                                       ClutterPaintVolume *volume)
 {
   _clutter_actor_queue_redraw_full (self,
                                     flags, /* flags */
@@ -9057,7 +9015,7 @@ _clutter_actor_queue_only_relayout (ClutterActor *self)
       priv->needs_allocation)
     return; /* save some cpu cycles */
 
-#ifdef CLUTTER_ENABLE_DEBUG
+#if CLUTTER_ENABLE_DEBUG
   if (!CLUTTER_ACTOR_IS_TOPLEVEL (self) && CLUTTER_ACTOR_IN_RELAYOUT (self))
     {
       g_warning ("The actor '%s' is currently inside an allocation "
@@ -10313,10 +10271,9 @@ clutter_actor_set_position (ClutterActor *self,
   cur_position.x = clutter_actor_get_x (self);
   cur_position.y = clutter_actor_get_y (self);
 
-  if (!clutter_point_equals (&cur_position, &new_position))
+  _clutter_actor_create_transition (self, obj_props[PROP_POSITION],
-    _clutter_actor_create_transition (self, obj_props[PROP_POSITION],
+                                    &cur_position,
-                                      &cur_position,
+                                    &new_position);
-                                      &new_position);
 }
 
 /**
@@ -12953,9 +12910,6 @@ clutter_actor_add_child_internal (ClutterActor              *self,
 
   self->priv->age += 1;
 
-  if (self->priv->in_cloned_branch)
-    clutter_actor_push_in_cloned_branch (child, self->priv->in_cloned_branch);
-
   /* if push_internal() has been called then we automatically set
    * the flag on the actor
    */
@@ -13675,7 +13629,7 @@ clutter_actor_set_child_above_sibling (ClutterActor *self,
                                     sibling);
   g_object_unref(child);
 
-  clutter_actor_queue_redraw_on_parent (child);
+  clutter_actor_queue_relayout (self);
 }
 
 /**
@@ -13722,7 +13676,7 @@ clutter_actor_set_child_below_sibling (ClutterActor *self,
                                     sibling);
   g_object_unref(child);
 
-  clutter_actor_queue_redraw_on_parent (child);
+  clutter_actor_queue_relayout (self);
 }
 
 /**
@@ -15224,8 +15178,9 @@ clutter_actor_transform_stage_point (ClutterActor *self,
    *   http://www.cs.cmu.edu/~ph/src/texfund/
    *
    * Our texture is a rectangle with origin [0, 0], so we are mapping from
-   * quad to rectangle only, which significantly simplifies things.
+   * quad to rectangle only, which significantly simplifies things; the
-   * Function calls have been unrolled.
+   * function calls have been unrolled, and most of the math is done in fixed
+   * point.
    */
   clutter_actor_get_abs_allocation_vertices (self, v);
 
@@ -17519,7 +17474,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
            */
           effects = _clutter_meta_group_peek_metas (priv->effects);
           for (l = effects;
-               l != NULL && l->data != priv->current_effect;
+               l != NULL || (l != NULL && l->data != priv->current_effect);
                l = l->next)
             {
               if (!_clutter_effect_get_paint_volume (l->data, pv))
@@ -17555,32 +17510,6 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
   return TRUE;
 }
 
-static gboolean
-_clutter_actor_has_active_paint_volume_override_effects (ClutterActor *self)
-{
-  const GList *l;
-
-  if (self->priv->effects == NULL)
-    return FALSE;
-
-  /* We just need to all effects current effect to see
-   * if anyone wants to override the paint volume. If so, then
-   * we need to recompute, since the paint volume returned can
-   * change from call to call. */
-  for (l = _clutter_meta_group_peek_metas (self->priv->effects);
-       l != NULL;
-       l = l->next)
-    {
-      ClutterEffect *effect = l->data;
-
-      if (clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)) &&
-          _clutter_effect_has_custom_paint_volume (effect))
-        return TRUE;
-    }
-
-  return FALSE;
-}
-
 /* The public clutter_actor_get_paint_volume API returns a const
  * pointer since we return a pointer directly to the cached
  * PaintVolume associated with the actor and don't want the user to
@@ -17591,33 +17520,17 @@ _clutter_actor_has_active_paint_volume_override_effects (ClutterActor *self)
 static ClutterPaintVolume *
 _clutter_actor_get_paint_volume_mutable (ClutterActor *self)
 {
-  gboolean has_paint_volume_override_effects;
   ClutterActorPrivate *priv;
 
   priv = self->priv;
 
-  has_paint_volume_override_effects = _clutter_actor_has_active_paint_volume_override_effects (self);
-
   if (priv->paint_volume_valid)
     {
-      /* If effects are applied, the actor paint volume
+      if (!priv->needs_paint_volume_update)
-       * needs to be recomputed on each paint, since those
-       * paint volumes could change over the duration of the
-       * effect.
-       *
-       * We also need to update the paint volume if we went
-       * from having effects to not having effects on the last
-       * paint volume update. */
-      if (!priv->needs_paint_volume_update &&
-          priv->current_effect == NULL &&
-          !has_paint_volume_override_effects &&
-          !priv->had_effects_on_last_paint_volume_update)
         return &priv->paint_volume;
       clutter_paint_volume_free (&priv->paint_volume);
     }
 
-  priv->had_effects_on_last_paint_volume_update = has_paint_volume_override_effects;
-
   if (_clutter_actor_get_paint_volume_real (self, &priv->paint_volume))
     {
       priv->paint_volume_valid = TRUE;
@@ -20791,31 +20704,29 @@ clutter_actor_get_child_transform (ClutterActor  *self,
 }
 
 static void
-clutter_actor_push_in_cloned_branch (ClutterActor *self,
+clutter_actor_push_in_cloned_branch (ClutterActor *self)
-                                     gulong        count)
 {
   ClutterActor *iter;
 
   for (iter = self->priv->first_child;
        iter != NULL;
        iter = iter->priv->next_sibling)
-    clutter_actor_push_in_cloned_branch (iter, count);
+    clutter_actor_push_in_cloned_branch (iter);
 
-  self->priv->in_cloned_branch += count;
+  self->priv->in_cloned_branch += 1;
 }
 
 static void
-clutter_actor_pop_in_cloned_branch (ClutterActor *self,
+clutter_actor_pop_in_cloned_branch (ClutterActor *self)
-                                    gulong        count)
 {
   ClutterActor *iter;
 
-  self->priv->in_cloned_branch -= count;
+  self->priv->in_cloned_branch -= 1;
 
   for (iter = self->priv->first_child;
        iter != NULL;
        iter = iter->priv->next_sibling)
-    clutter_actor_pop_in_cloned_branch (iter, count);
+    clutter_actor_pop_in_cloned_branch (iter);
 }
 
 void
@@ -20831,7 +20742,7 @@ _clutter_actor_attach_clone (ClutterActor *actor,
 
   g_hash_table_add (priv->clones, clone);
 
-  clutter_actor_push_in_cloned_branch (actor, 1);
+  clutter_actor_push_in_cloned_branch (actor);
 }
 
 void
@@ -20846,7 +20757,7 @@ _clutter_actor_detach_clone (ClutterActor *actor,
       g_hash_table_lookup (priv->clones, clone) == NULL)
     return;
 
-  clutter_actor_pop_in_cloned_branch (actor, 1);
+  clutter_actor_pop_in_cloned_branch (actor);
 
   g_hash_table_remove (priv->clones, clone);
 
@@ -21189,7 +21100,6 @@ clutter_actor_bind_model_with_properties (ClutterActor *self,
 
       model_property = va_arg (args, char *);
     }
-  va_end (args);
 
   clutter_actor_bind_model (self, model, bind_child_with_properties, clos, bind_closure_free);
 }

clutter/clutter/clutter-actor.h

@@ -61,7 +61,7 @@ G_BEGIN_DECLS
  *   internal state.
  */
 #define CLUTTER_ACTOR_SET_FLAGS(a,f) \
-  CLUTTER_MACRO_DEPRECATED \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24 \
   (((ClutterActor*)(a))->flags |= (f))
 
 /**
@@ -76,23 +76,23 @@ G_BEGIN_DECLS
  *   internal state.
  */
 #define CLUTTER_ACTOR_UNSET_FLAGS(a,f) \
-  CLUTTER_MACRO_DEPRECATED \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24 \
   (((ClutterActor*)(a))->flags &= ~(f))
 
 #define CLUTTER_ACTOR_IS_MAPPED(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
   ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_MAPPED) != FALSE)
 
 #define CLUTTER_ACTOR_IS_REALIZED(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
   ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REALIZED) != FALSE)
 
 #define CLUTTER_ACTOR_IS_VISIBLE(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
   ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_VISIBLE) != FALSE)
 
 #define CLUTTER_ACTOR_IS_REACTIVE(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
   ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REACTIVE) != FALSE)
 
 typedef struct _ClutterActorClass    ClutterActorClass;
@@ -322,97 +322,97 @@ struct _ClutterActorIter
   gpointer CLUTTER_PRIVATE_FIELD (dummy5);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_actor_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_new                               (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_flags                         (ClutterActor                *self,
                                                                                  ClutterActorFlags            flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unset_flags                       (ClutterActor                *self,
                                                                                  ClutterActorFlags            flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorFlags               clutter_actor_get_flags                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_show                              (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_hide                              (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_realize                           (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unrealize                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_map                               (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unmap                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_paint                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_continue_paint                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_queue_redraw                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_queue_redraw_with_clip            (ClutterActor                *self,
                                                                                  const cairo_rectangle_int_t *clip);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_queue_relayout                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_destroy                           (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_name                          (ClutterActor                *self,
                                                                                  const gchar                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *                   clutter_actor_get_name                          (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 AtkObject *                     clutter_actor_get_accessible                    (ClutterActor                *self);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_visible                        (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_mapped                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_realized                       (ClutterActor                *self);
 
 /* Size negotiation */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_request_mode                  (ClutterActor                *self,
                                                                                  ClutterRequestMode           mode);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterRequestMode              clutter_actor_get_request_mode                  (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_width               (ClutterActor                *self,
                                                                                  gfloat                       for_height,
                                                                                  gfloat                      *min_width_p,
                                                                                  gfloat                      *natural_width_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_height              (ClutterActor                *self,
                                                                                  gfloat                       for_width,
                                                                                  gfloat                      *min_height_p,
                                                                                  gfloat                      *natural_height_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_size                (ClutterActor                *self,
                                                                                  gfloat                      *min_width_p,
                                                                                  gfloat                      *min_height_p,
                                                                                  gfloat                      *natural_width_p,
                                                                                  gfloat                      *natural_height_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate                          (ClutterActor                *self,
                                                                                  const ClutterActorBox       *box,
                                                                                  ClutterAllocationFlags       flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self,
                                                                                  ClutterAllocationFlags       flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_available_size           (ClutterActor                *self,
                                                                                  gfloat                       x,
                                                                                  gfloat                       y,
                                                                                  gfloat                       available_width,
                                                                                  gfloat                       available_height,
                                                                                  ClutterAllocationFlags       flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_align_fill               (ClutterActor                *self,
                                                                                  const ClutterActorBox       *box,
                                                                                  gdouble                      x_align,
@@ -420,448 +420,448 @@ void                            clutter_actor_allocate_align_fill
                                                                                  gboolean                     x_fill,
                                                                                  gboolean                     y_fill,
                                                                                  ClutterAllocationFlags       flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_allocation                    (ClutterActor                *self,
                                                                                  const ClutterActorBox       *box,
                                                                                  ClutterAllocationFlags       flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_box                (ClutterActor                *self,
                                                                                  ClutterActorBox             *box);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
                                                                                  ClutterActor                *ancestor,
                                                                                  ClutterVertex                verts[]);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_size                          (ClutterActor                *self,
                                                                                  gfloat                       width,
                                                                                  gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_size                          (ClutterActor                *self,
                                                                                  gfloat                      *width,
                                                                                  gfloat                      *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_position                      (ClutterActor                *self,
                                                                                  gfloat                       x,
                                                                                  gfloat                       y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_position                      (ClutterActor                *self,
                                                                                  gfloat                      *x,
                                                                                  gfloat                      *y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_fixed_position_set            (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_fixed_position_set            (ClutterActor                *self,
                                                                                  gboolean                     is_set);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_move_by                           (ClutterActor                *self,
                                                                                  gfloat                       dx,
                                                                                  gfloat                       dy);
 
 /* Actor geometry */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_width                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_height                        (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_width                         (ClutterActor                *self,
                                                                                  gfloat                       width);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_height                        (ClutterActor                *self,
                                                                                  gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_x                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_y                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_x                             (ClutterActor                *self,
                                                                                  gfloat                       x);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_y                             (ClutterActor                *self,
                                                                                  gfloat                       y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_z_position                    (ClutterActor                *self,
                                                                                  gfloat                       z_position);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gfloat                          clutter_actor_get_z_position                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_layout_manager                (ClutterActor                *self,
                                                                                  ClutterLayoutManager        *manager);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterLayoutManager *          clutter_actor_get_layout_manager                (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_x_align                       (ClutterActor                *self,
                                                                                  ClutterActorAlign            x_align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActorAlign               clutter_actor_get_x_align                       (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_y_align                       (ClutterActor                *self,
                                                                                  ClutterActorAlign            y_align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActorAlign               clutter_actor_get_y_align                       (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_top                    (ClutterActor                *self,
                                                                                  gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_top                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_bottom                 (ClutterActor                *self,
                                                                                  gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_bottom                 (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_left                   (ClutterActor                *self,
                                                                                  gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_left                   (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_right                  (ClutterActor                *self,
                                                                                  gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_right                  (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin                        (ClutterActor                *self,
                                                                                  const ClutterMargin         *margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_margin                        (ClutterActor                *self,
                                                                                  ClutterMargin               *margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_x_expand                      (ClutterActor                *self,
                                                                                  gboolean                     expand);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_get_x_expand                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_y_expand                      (ClutterActor                *self,
                                                                                  gboolean                     expand);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_get_y_expand                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_needs_expand                      (ClutterActor                *self,
                                                                                  ClutterOrientation           orientation);
 
 /* Paint */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip                          (ClutterActor                *self,
                                                                                  gfloat                       xoff,
                                                                                  gfloat                       yoff,
                                                                                  gfloat                       width,
                                                                                  gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_remove_clip                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_clip                          (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_clip                          (ClutterActor               *self,
                                                                                  gfloat                     *xoff,
                                                                                  gfloat                     *yoff,
                                                                                  gfloat                     *width,
                                                                                  gfloat                     *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip_to_allocation            (ClutterActor               *self,
                                                                                  gboolean                    clip_set);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_clip_to_allocation            (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_opacity                       (ClutterActor               *self,
                                                                                  guint8                      opacity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_opacity                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_paint_opacity                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_visibility              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 void                            clutter_actor_set_offscreen_redirect            (ClutterActor               *self,
                                                                                  ClutterOffscreenRedirect    redirect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 ClutterOffscreenRedirect        clutter_actor_get_offscreen_redirect            (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_should_pick_paint                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_in_clone_paint                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_box                     (ClutterActor               *self,
                                                                                  ClutterActorBox            *box);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 gboolean                        clutter_actor_has_overlaps                      (ClutterActor               *self);
 
 /* Content */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content                       (ClutterActor               *self,
                                                                                  ClutterContent             *content);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContent *                clutter_actor_get_content                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content_gravity               (ClutterActor               *self,
                                                                                  ClutterContentGravity       gravity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContentGravity           clutter_actor_get_content_gravity               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content_scaling_filters       (ClutterActor               *self,
                                                                                  ClutterScalingFilter        min_filter,
                                                                                  ClutterScalingFilter        mag_filter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_content_scaling_filters       (ClutterActor               *self,
                                                                                  ClutterScalingFilter       *min_filter,
                                                                                  ClutterScalingFilter       *mag_filter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_content_repeat                (ClutterActor               *self,
                                                                                  ClutterContentRepeat        repeat);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterContentRepeat            clutter_actor_get_content_repeat                (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_content_box                   (ClutterActor               *self,
                                                                                  ClutterActorBox            *box);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_background_color              (ClutterActor               *self,
                                                                                  const ClutterColor         *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_background_color              (ClutterActor               *self,
                                                                                  ClutterColor               *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_paint_volume                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_transformed_paint_volume      (ClutterActor               *self,
                                                                                  ClutterActor               *relative_to_ancestor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 const ClutterPaintVolume *      clutter_actor_get_default_paint_volume          (ClutterActor               *self);
 
 /* Events */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_reactive                      (ClutterActor               *actor,
                                                                                  gboolean                    reactive);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_reactive                      (ClutterActor               *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_key_focus                     (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_grab_key_focus                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_event                             (ClutterActor               *actor,
                                                                                  const ClutterEvent         *event,
                                                                                  gboolean                    capture);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_pointer                       (ClutterActor               *self);
 
 /* Text */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_get_pango_context                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_create_pango_context              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoLayout *                   clutter_actor_create_pango_layout               (ClutterActor               *self,
                                                                                  const gchar                *text);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_text_direction                (ClutterActor               *self,
                                                                                  ClutterTextDirection        text_dir);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTextDirection            clutter_actor_get_text_direction                (ClutterActor               *self);
 
 /* Actor hierarchy */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_add_child                         (ClutterActor               *self,
                                                                                  ClutterActor               *child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_at_index             (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_above                (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_below                (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_replace_child                     (ClutterActor               *self,
                                                                                  ClutterActor               *old_child,
                                                                                  ClutterActor               *new_child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_child                      (ClutterActor               *self,
                                                                                  ClutterActor               *child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_all_children               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_destroy_all_children              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GList *                         clutter_actor_get_children                      (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gint                            clutter_actor_get_n_children                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_child_at_index                (ClutterActor               *self,
                                                                                  gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_previous_sibling              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_next_sibling                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_first_child                   (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_last_child                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *                  clutter_actor_get_parent                        (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean                        clutter_actor_contains                          (ClutterActor               *self,
                                                                                  ClutterActor               *descendant);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor*                   clutter_actor_get_stage                         (ClutterActor               *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_below_sibling           (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_above_sibling           (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_at_index                (ClutterActor               *self,
                                                                                  ClutterActor               *child,
                                                                                  gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_init                         (ClutterActorIter           *iter,
                                                                                  ClutterActor               *root);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                        clutter_actor_iter_next                         (ClutterActorIter           *iter,
                                                                                  ClutterActor              **child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                        clutter_actor_iter_prev                         (ClutterActorIter           *iter,
                                                                                  ClutterActor              **child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_remove                       (ClutterActorIter           *iter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_destroy                      (ClutterActorIter           *iter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_iter_is_valid                     (const ClutterActorIter     *iter);
 
 /* Transformations */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_rotated                        (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_scaled                         (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_pivot_point                   (ClutterActor               *self,
                                                                                  gfloat                      pivot_x,
                                                                                  gfloat                      pivot_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_pivot_point                   (ClutterActor               *self,
                                                                                  gfloat                     *pivot_x,
                                                                                  gfloat                     *pivot_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_pivot_point_z                 (ClutterActor               *self,
                                                                                  gfloat                      pivot_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gfloat                          clutter_actor_get_pivot_point_z                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_rotation_angle                (ClutterActor               *self,
                                                                                  ClutterRotateAxis           axis,
                                                                                  gdouble                     angle);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gdouble                         clutter_actor_get_rotation_angle                (ClutterActor               *self,
                                                                                  ClutterRotateAxis           axis);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_scale                         (ClutterActor               *self,
                                                                                  gdouble                     scale_x,
                                                                                  gdouble                     scale_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_scale                         (ClutterActor               *self,
                                                                                  gdouble                    *scale_x,
                                                                                  gdouble                    *scale_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_scale_z                       (ClutterActor               *self,
                                                                                  gdouble                     scale_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gdouble                         clutter_actor_get_scale_z                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_translation                   (ClutterActor               *self,
                                                                                  gfloat                      translate_x,
                                                                                  gfloat                      translate_y,
                                                                                  gfloat                      translate_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_translation                   (ClutterActor               *self,
                                                                                  gfloat                     *translate_x,
                                                                                  gfloat                     *translate_y,
                                                                                  gfloat                     *translate_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_transform                     (ClutterActor               *self,
                                                                                  const ClutterMatrix        *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_transform                     (ClutterActor               *self,
                                                                                  ClutterMatrix              *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_child_transform               (ClutterActor               *self,
                                                                                  const ClutterMatrix        *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_child_transform               (ClutterActor               *self,
                                                                                  ClutterMatrix              *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_transformed_position          (ClutterActor               *self,
                                                                                  gfloat                     *x,
                                                                                  gfloat                     *y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_transformed_size              (ClutterActor               *self,
                                                                                  gfloat                     *width,
                                                                                  gfloat                     *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_transform_stage_point             (ClutterActor               *self,
                                                                                  gfloat                      x,
                                                                                  gfloat                      y,
                                                                                  gfloat                     *x_out,
                                                                                  gfloat                     *y_out);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_abs_allocation_vertices       (ClutterActor               *self,
                                                                                  ClutterVertex               verts[]);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_transform_to_point          (ClutterActor               *self,
                                                                                  const ClutterVertex        *point,
                                                                                  ClutterVertex              *vertex);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_relative_transform_to_point (ClutterActor               *self,
                                                                                  ClutterActor               *ancestor,
                                                                                  const ClutterVertex        *point,
                                                                                  ClutterVertex              *vertex);
 
 /* Implicit animations */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_save_easing_state                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_restore_easing_state              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_mode                   (ClutterActor               *self,
                                                                                  ClutterAnimationMode        mode);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterAnimationMode            clutter_actor_get_easing_mode                   (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_duration               (ClutterActor               *self,
                                                                                  guint                       msecs);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 guint                           clutter_actor_get_easing_duration               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_delay                  (ClutterActor               *self,
                                                                                  guint                       msecs);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 guint                           clutter_actor_get_easing_delay                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterTransition *             clutter_actor_get_transition                    (ClutterActor               *self,
                                                                                  const char                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_add_transition                    (ClutterActor               *self,
                                                                                  const char                 *name,
                                                                                  ClutterTransition          *transition);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_transition                 (ClutterActor               *self,
                                                                                  const char                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_all_transitions            (ClutterActor               *self);
 
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_16
 gboolean                        clutter_actor_has_mapped_clones                 (ClutterActor *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_22
 void                            clutter_actor_set_opacity_override              (ClutterActor               *self,
                                                                                  gint                        opacity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_22
 gint                            clutter_actor_get_opacity_override              (ClutterActor               *self);
 
 /**
@@ -883,13 +883,13 @@ gint                            clutter_actor_get_opacity_override
 typedef ClutterActor * (* ClutterActorCreateChildFunc) (gpointer item,
                                                         gpointer user_data);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 void                            clutter_actor_bind_model                        (ClutterActor               *self,
                                                                                  GListModel                 *model,
                                                                                  ClutterActorCreateChildFunc create_child_func,
                                                                                  gpointer                    user_data,
                                                                                  GDestroyNotify              notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 void                            clutter_actor_bind_model_with_properties        (ClutterActor               *self,
                                                                                  GListModel                 *model,
                                                                                  GType                       child_type,

clutter/clutter/clutter-align-constraint.c

@@ -34,7 +34,9 @@
  * #ClutterAlignConstraint is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-align-constraint.h"
 

clutter/clutter/clutter-align-constraint.h

@@ -48,28 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterAlignConstraint          ClutterAlignConstraint;
 typedef struct _ClutterAlignConstraintClass     ClutterAlignConstraintClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_align_constraint_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *clutter_align_constraint_new            (ClutterActor           *source,
                                                             ClutterAlignAxis        axis,
                                                             gfloat                  factor);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_source     (ClutterAlignConstraint *align,
                                                             ClutterActor           *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *     clutter_align_constraint_get_source     (ClutterAlignConstraint *align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
                                                             ClutterAlignAxis        axis);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAlignAxis   clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_factor     (ClutterAlignConstraint *align,
                                                             gfloat                  factor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gfloat             clutter_align_constraint_get_factor     (ClutterAlignConstraint *align);
 
 G_END_DECLS

clutter/clutter/clutter-animatable.c

@@ -45,7 +45,9 @@
  * #ClutterAnimatable is available since Clutter 1.0
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 

clutter/clutter/clutter-animatable.h

@@ -95,21 +95,21 @@ struct _ClutterAnimatableIface
                                      GValue            *value);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_animatable_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *clutter_animatable_find_property     (ClutterAnimatable *animatable,
                                                   const gchar       *property_name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   GValue            *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_set_final_state   (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   const GValue      *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 gboolean    clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   ClutterInterval   *interval,

clutter/clutter/clutter-backend-private.h

@@ -135,7 +135,7 @@ gboolean                _clutter_backend_translate_event                (Clutter
                                                                          gpointer                native,
                                                                          ClutterEvent           *event);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_MUTTER
 void                    _clutter_backend_add_event_translator           (ClutterBackend         *backend,
                                                                          ClutterEventTranslator *translator);
 
@@ -150,7 +150,7 @@ gint32                  _clutter_backend_get_units_serial               (Clutter
 
 PangoDirection          _clutter_backend_get_keymap_direction           (ClutterBackend         *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_MUTTER
 void                    _clutter_backend_reset_cogl_framebuffer         (ClutterBackend         *backend);
 
 void                    clutter_set_allowed_drivers                     (const char             *drivers);

clutter/clutter/clutter-backend.c

@@ -38,7 +38,9 @@
  * #ClutterBackend is available since Clutter 0.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 
@@ -51,6 +53,7 @@
 #include "clutter-stage-manager-private.h"
 #include "clutter-stage-private.h"
 #include "clutter-stage-window.h"
+#include "clutter-version.h"
 #include "clutter-device-manager-private.h"
 
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
@@ -430,7 +433,7 @@ clutter_backend_real_get_features (ClutterBackend *backend)
   if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_THROTTLE))
     {
       CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers throttling");
-      flags |= CLUTTER_FEATURE_SWAP_THROTTLE;
+      flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
     }
   else
     CLUTTER_NOTE (BACKEND, "Cogl doesn't support swap buffers throttling");

clutter/clutter/clutter-backend.h

@@ -53,34 +53,34 @@ G_BEGIN_DECLS
 typedef struct _ClutterBackend          ClutterBackend;
 typedef struct _ClutterBackendClass     ClutterBackendClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_backend_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterBackend *                clutter_get_default_backend             (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_16
 void                            clutter_set_windowing_backend           (const char *backend_type);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gdouble                         clutter_backend_get_resolution          (ClutterBackend             *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_backend_set_font_options        (ClutterBackend             *backend,
                                                                          const cairo_font_options_t *options);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 const cairo_font_options_t *    clutter_backend_get_font_options        (ClutterBackend             *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 CoglContext *                   clutter_backend_get_cogl_context        (ClutterBackend             *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_backend_bell_notify             (ClutterBackend             *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_MUTTER
 ClutterInputMethod *            clutter_backend_get_input_method        (ClutterBackend             *backend);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_MUTTER
 void                            clutter_backend_set_input_method        (ClutterBackend             *backend,
                                                                          ClutterInputMethod         *method);
 G_END_DECLS

clutter/clutter/clutter-base-types.c

@@ -30,7 +30,9 @@
  * across the whole API.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-types.h"
 #include "clutter-private.h"

clutter/clutter/clutter-bin-layout.c

@@ -43,7 +43,9 @@
  * #ClutterBinLayout is available since Clutter 1.2
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 

clutter/clutter/clutter-bin-layout.h

@@ -74,10 +74,10 @@ struct _ClutterBinLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_bin_layout_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *  clutter_bin_layout_new  (ClutterBinAlignment x_align,
                                                  ClutterBinAlignment y_align);
 

clutter/clutter/clutter-bind-constraint.c

@@ -80,7 +80,9 @@
  * #ClutterBindConstraint is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 

clutter/clutter/clutter-bind-constraint.h

@@ -48,28 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterBindConstraint           ClutterBindConstraint;
 typedef struct _ClutterBindConstraintClass      ClutterBindConstraintClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_bind_constraint_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *   clutter_bind_constraint_new            (ClutterActor          *source,
                                                               ClutterBindCoordinate  coordinate,
                                                               gfloat                 offset);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_source     (ClutterBindConstraint *constraint,
                                                               ClutterActor          *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *        clutter_bind_constraint_get_source     (ClutterBindConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
                                                               ClutterBindCoordinate  coordinate);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterBindCoordinate clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_offset     (ClutterBindConstraint *constraint,
                                                               gfloat                 offset);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gfloat                clutter_bind_constraint_get_offset     (ClutterBindConstraint *constraint);
 
 G_END_DECLS

clutter/clutter/clutter-binding-pool.c

@@ -94,7 +94,9 @@
  * #ClutterBindingPool is available since Clutter 1.0
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-binding-pool.h"
 #include "clutter-debug.h"

clutter/clutter/clutter-binding-pool.h

@@ -71,17 +71,17 @@ typedef gboolean (* ClutterBindingActionFunc) (GObject             *gobject,
                                                ClutterModifierType  modifiers,
                                                gpointer             user_data);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_binding_pool_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_new              (const gchar         *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_get_for_class    (gpointer             klass);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_find             (const gchar         *name);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_action   (ClutterBindingPool  *pool,
                                                              const gchar         *action_name,
                                                              guint                key_val,
@@ -89,44 +89,44 @@ void                  clutter_binding_pool_install_action   (ClutterBindingPool
                                                              GCallback            callback,
                                                              gpointer             data,
                                                              GDestroyNotify       notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_closure  (ClutterBindingPool  *pool,
                                                              const gchar         *action_name,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GClosure            *closure);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_action  (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GCallback            callback,
                                                              gpointer             data,
                                                              GDestroyNotify       notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_closure (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GClosure            *closure);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 const gchar *         clutter_binding_pool_find_action      (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_remove_action    (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_binding_pool_activate         (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GObject             *gobject);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_block_action     (ClutterBindingPool  *pool,
                                                              const gchar         *action_name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_unblock_action   (ClutterBindingPool  *pool,
                                                              const gchar         *action_name);
 

clutter/clutter/clutter-blur-effect.c

@@ -37,7 +37,9 @@
 #define CLUTTER_IS_BLUR_EFFECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BLUR_EFFECT))
 #define CLUTTER_BLUR_EFFECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 
@@ -160,7 +162,6 @@ static void
 clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
 {
   ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   guint8 paint_opacity;
 
   paint_opacity = clutter_actor_get_paint_opacity (self->actor);
@@ -170,11 +171,11 @@ clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
-                                   self->pipeline,
+
-                                   0, 0,
+  cogl_pop_source ();
-                                   self->tex_width, self->tex_height);
 }
 
 static gboolean

clutter/clutter/clutter-blur-effect.h

@@ -48,10 +48,10 @@ G_BEGIN_DECLS
 typedef struct _ClutterBlurEffect       ClutterBlurEffect;
 typedef struct _ClutterBlurEffectClass  ClutterBlurEffectClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_blur_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_blur_effect_new (void);
 
 G_END_DECLS

clutter/clutter/clutter-box-layout.c

@@ -48,7 +48,9 @@
  * #ClutterBoxLayout is available since Clutter 1.2
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 

clutter/clutter/clutter-box-layout.h

@@ -77,41 +77,41 @@ struct _ClutterBoxLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_box_layout_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *  clutter_box_layout_new                 (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                    clutter_box_layout_set_orientation      (ClutterBoxLayout    *layout,
                                                                  ClutterOrientation   orientation);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterOrientation      clutter_box_layout_get_orientation      (ClutterBoxLayout    *layout);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_spacing          (ClutterBoxLayout    *layout,
                                                                  guint                spacing);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 guint                   clutter_box_layout_get_spacing          (ClutterBoxLayout    *layout);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_homogeneous      (ClutterBoxLayout    *layout,
                                                                  gboolean             homogeneous);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_homogeneous      (ClutterBoxLayout    *layout);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_pack_start       (ClutterBoxLayout    *layout,
                                                                  gboolean             pack_start);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_pack_start       (ClutterBoxLayout    *layout);
 
-CLUTTER_DEPRECATED_FOR(clutter_box_layout_set_orientation)
+CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_set_orientation)
 void                    clutter_box_layout_set_vertical         (ClutterBoxLayout    *layout,
                                                                  gboolean             vertical);
-CLUTTER_DEPRECATED_FOR(clutter_box_layout_get_orientation)
+CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_get_orientation)
 gboolean                clutter_box_layout_get_vertical         (ClutterBoxLayout    *layout);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_pack                 (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  gboolean             expand,
@@ -119,48 +119,48 @@ void                    clutter_box_layout_pack                 (ClutterBoxLayou
                                                                  gboolean             y_fill,
                                                                  ClutterBoxAlignment  x_align,
                                                                  ClutterBoxAlignment  y_align);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_alignment        (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  ClutterBoxAlignment  x_align,
                                                                  ClutterBoxAlignment  y_align);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_get_alignment        (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  ClutterBoxAlignment *x_align,
                                                                  ClutterBoxAlignment *y_align);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_fill             (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  gboolean             x_fill,
                                                                  gboolean             y_fill);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_get_fill             (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  gboolean            *x_fill,
                                                                  gboolean            *y_fill);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_expand           (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  gboolean             expand);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 gboolean                clutter_box_layout_get_expand           (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor);
 
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_use_animations   (ClutterBoxLayout    *layout,
                                                                  gboolean             animate);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 gboolean                clutter_box_layout_get_use_animations   (ClutterBoxLayout    *layout);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_easing_mode      (ClutterBoxLayout    *layout,
                                                                  gulong               mode);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 gulong                  clutter_box_layout_get_easing_mode      (ClutterBoxLayout    *layout);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_easing_duration  (ClutterBoxLayout    *layout,
                                                                  guint                msecs);
-CLUTTER_DEPRECATED
+CLUTTER_DEPRECATED_IN_1_12
 guint                   clutter_box_layout_get_easing_duration  (ClutterBoxLayout    *layout);
 
 G_END_DECLS

clutter/clutter/clutter-brightness-contrast-effect.c

@@ -37,7 +37,9 @@
 #define CLUTTER_IS_BRIGHTNESS_CONTRAST_EFFECT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT))
 #define CLUTTER_BRIGHTNESS_CONTRAST_EFFECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT, ClutterBrightnessContrastEffectClass))
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 
@@ -178,7 +180,6 @@ static void
 clutter_brightness_contrast_effect_paint_target (ClutterOffscreenEffect *effect)
 {
   ClutterBrightnessContrastEffect *self = CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   ClutterActor *actor;
   guint8 paint_opacity;
 
@@ -190,11 +191,11 @@ clutter_brightness_contrast_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
-                                   self->pipeline,
+
-                                   0, 0,
+  cogl_pop_source ();
-                                   self->tex_width, self->tex_height);
 }
 
 static void

clutter/clutter/clutter-brightness-contrast-effect.h

@@ -49,35 +49,35 @@ G_BEGIN_DECLS
 typedef struct _ClutterBrightnessContrastEffect         ClutterBrightnessContrastEffect;
 typedef struct _ClutterBrightnessContrastEffectClass    ClutterBrightnessContrastEffectClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_brightness_contrast_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterEffect * clutter_brightness_contrast_effect_new                          (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness_full          (ClutterBrightnessContrastEffect *effect,
                                                                                  float                            red,
                                                                                  float                            green,
                                                                                  float                            blue);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness               (ClutterBrightnessContrastEffect *effect,
                                                                                  float                            brightness);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_brightness               (ClutterBrightnessContrastEffect *effect,
                                                                                  float                           *red,
                                                                                  float                           *green,
                                                                                  float                           *blue);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast_full            (ClutterBrightnessContrastEffect *effect,
                                                                                  float                            red,
                                                                                  float                            green,
                                                                                  float                            blue);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast                 (ClutterBrightnessContrastEffect *effect,
                                                                                  float                            contrast);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_contrast                 (ClutterBrightnessContrastEffect *effect,
                                                                                  float                           *red,
                                                                                  float                           *green,

clutter/clutter/clutter-build-config.h.meson

@@ -1,14 +0,0 @@
-/* Mutter version */
-#mesondefine MUTTER_VERSION
-
-/* List of Cogl drivers */
-#mesondefine CLUTTER_DRIVERS
-
-/* Have evdev support for input handling */
-#mesondefine HAVE_EVDEV
-
-/* Building with libwacom for advanced tablet management */
-#mesondefine HAVE_LIBWACOM
-
-/* Supports PangoFt2 */
-#mesondefine HAVE_PANGO_FT2

clutter/clutter/clutter-cairo.c

@@ -27,7 +27,9 @@
  * Clutter provides some utility functions for using Cairo.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-cairo.h"
 #include "clutter-color.h"

clutter/clutter/clutter-cairo.h

@@ -50,9 +50,9 @@ G_BEGIN_DECLS
 #define CLUTTER_CAIRO_FORMAT_ARGB32     (COGL_PIXEL_FORMAT_ARGB_8888_PRE)
 #endif
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void    clutter_cairo_clear             (cairo_t               *cr);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void    clutter_cairo_set_source_color  (cairo_t               *cr,
                                          const ClutterColor    *color);
 

clutter/clutter/clutter-canvas.c

@@ -42,7 +42,9 @@
  * #ClutterCanvas is available since Clutter 1.10.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <cogl/cogl.h>
 #include <cairo-gobject.h>

clutter/clutter/clutter-canvas.h

@@ -85,20 +85,20 @@ struct _ClutterCanvasClass
   gpointer _padding[16];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_canvas_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContent *        clutter_canvas_new                      (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                clutter_canvas_set_size                 (ClutterCanvas *canvas,
                                                                  int            width,
                                                                  int            height);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_18
 void                    clutter_canvas_set_scale_factor         (ClutterCanvas *canvas,
                                                                  int            scale);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_18
 int                     clutter_canvas_get_scale_factor         (ClutterCanvas *canvas);
 
 G_END_DECLS

clutter/clutter/clutter-child-meta.c

@@ -36,8 +36,9 @@
  *
  * #ClutterChildMeta is available since Clutter 0.8
  */
-
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-child-meta.h"
 #include "clutter-container.h"

clutter/clutter/clutter-child-meta.h

@@ -109,12 +109,12 @@ struct _ClutterChildMetaClass
   GObjectClass parent_class;
 }; 
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_child_meta_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterContainer *      clutter_child_meta_get_container        (ClutterChildMeta *data);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor     *      clutter_child_meta_get_actor            (ClutterChildMeta *data);
 
 G_END_DECLS

clutter/clutter/clutter-click-action.c

@@ -92,7 +92,9 @@
  * #ClutterClickAction is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-click-action.h"
 

clutter/clutter/clutter-click-action.h

@@ -97,22 +97,22 @@ struct _ClutterClickActionClass
   void (* _clutter_click_action7) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_click_action_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *        clutter_click_action_new        (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 guint                  clutter_click_action_get_button (ClutterClickAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterModifierType    clutter_click_action_get_state  (ClutterClickAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_click_action_get_coords (ClutterClickAction *action,
                                                         gfloat             *press_x,
                                                         gfloat             *press_y);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                   clutter_click_action_release    (ClutterClickAction *action);
 
 G_END_DECLS

clutter/clutter/clutter-clone.c

@@ -37,7 +37,9 @@
  * #ClutterClone is available since Clutter 1.0
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-actor-private.h"

clutter/clutter/clutter-clone.h

@@ -78,15 +78,15 @@ struct _ClutterCloneClass
   void (*_clutter_actor_clone4) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_clone_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *  clutter_clone_new               (ClutterActor *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_clone_set_source        (ClutterClone *self,
                                                  ClutterActor *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *  clutter_clone_get_source        (ClutterClone *self);
 
 G_END_DECLS

clutter/clutter/clutter-color.c

@@ -33,7 +33,9 @@
  * The alpha channel is fully opaque at 255 and fully transparent at 0.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <math.h>
 

clutter/clutter/clutter-color.h

@@ -68,76 +68,76 @@ struct _ClutterColor
  */
 #define CLUTTER_COLOR_INIT(r,g,b,a)     { (r), (g), (b), (a) }
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_color_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_new         (guint8              red,
                                          guint8              green,
                                          guint8              blue,
                                          guint8              alpha);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_alloc       (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_init        (ClutterColor       *color,
                                          guint8              red,
                                          guint8              green,
                                          guint8              blue,
                                          guint8              alpha);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_copy        (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_free        (ClutterColor       *color);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_add         (const ClutterColor *a,
                                          const ClutterColor *b,
                                          ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_subtract    (const ClutterColor *a,
                                          const ClutterColor *b,
                                          ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_lighten     (const ClutterColor *color,
                                          ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_darken      (const ClutterColor *color,
                                          ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_shade       (const ClutterColor *color,
                                          gdouble             factor,
                                          ClutterColor       *result);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gchar *       clutter_color_to_string   (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 gboolean      clutter_color_from_string (ClutterColor       *color,
                                          const gchar        *str);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_to_hls      (const ClutterColor *color,
                                          gfloat             *hue,
 					 gfloat             *luminance,
 					 gfloat             *saturation);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_hls    (ClutterColor       *color,
                                          gfloat              hue,
                                          gfloat              luminance,
                                          gfloat              saturation);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint32       clutter_color_to_pixel    (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_pixel  (ClutterColor       *color,
                                          guint32             pixel);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 guint         clutter_color_hash        (gconstpointer       v);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean      clutter_color_equal       (gconstpointer       v1,
                                          gconstpointer       v2);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 void          clutter_color_interpolate (const ClutterColor *initial,
                                          const ClutterColor *final,
                                          gdouble             progress,
@@ -177,22 +177,22 @@ struct _ClutterParamSpecColor
   ClutterColor *default_value;
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                    clutter_value_set_color         (GValue             *value,
                                                          const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 const ClutterColor *    clutter_value_get_color         (const GValue       *value);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_param_color_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *    clutter_param_spec_color        (const gchar        *name,
                                                  const gchar        *nick,
                                                  const gchar        *blurb,
                                                  const ClutterColor *default_value,
                                                  GParamFlags         flags);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterColor *clutter_color_get_static (ClutterStaticColor color);
 
 G_END_DECLS

clutter/clutter/clutter-colorize-effect.c

@@ -37,7 +37,9 @@
 #define CLUTTER_IS_COLORIZE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_COLORIZE_EFFECT))
 #define CLUTTER_COLORIZE_EFFECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_COLORIZE_EFFECT, ClutterColorizeEffectClass))
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 
@@ -148,7 +150,6 @@ static void
 clutter_colorize_effect_paint_target (ClutterOffscreenEffect *effect)
 {
   ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect);
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   ClutterActor *actor;
   guint8 paint_opacity;
 
@@ -160,11 +161,11 @@ clutter_colorize_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
-                                   self->pipeline,
+
-                                   0, 0,
+  cogl_pop_source ();
-                                   self->tex_width, self->tex_height);
 }
 
 static void

clutter/clutter/clutter-colorize-effect.h

@@ -49,16 +49,16 @@ G_BEGIN_DECLS
 typedef struct _ClutterColorizeEffect           ClutterColorizeEffect;
 typedef struct _ClutterColorizeEffectClass      ClutterColorizeEffectClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_colorize_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_colorize_effect_new      (const ClutterColor *tint);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
                                                  const ClutterColor    *tint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_get_tint (ClutterColorizeEffect *effect,
                                                  ClutterColor          *tint);
 

clutter/clutter/clutter-constraint.c

@@ -128,7 +128,9 @@
  * can be recovered at any point using clutter_actor_meta_get_actor().
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <string.h>
 

clutter/clutter/clutter-constraint.h

@@ -96,32 +96,32 @@ struct _ClutterConstraintClass
   void (* _clutter_constraint7) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_constraint_get_type (void) G_GNUC_CONST;
 
 /* ClutterActor API */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_add_constraint            (ClutterActor      *self,
                                                             ClutterConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_add_constraint_with_name  (ClutterActor      *self,
                                                             const gchar       *name,
                                                             ClutterConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_remove_constraint         (ClutterActor      *self,
                                                             ClutterConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_remove_constraint_by_name (ClutterActor      *self,
                                                             const gchar       *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GList *            clutter_actor_get_constraints           (ClutterActor      *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *clutter_actor_get_constraint            (ClutterActor      *self,
                                                             const gchar       *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_clear_constraints         (ClutterActor      *self);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean           clutter_actor_has_constraints           (ClutterActor      *self);
 
 G_END_DECLS

clutter/clutter/clutter-container.c

@@ -26,7 +26,9 @@
  * Author: Emmanuele Bassi <ebassi@openedhand.com>
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include <stdarg.h>
 #include <glib-object.h>

clutter/clutter/clutter-container.h

@@ -141,52 +141,52 @@ struct _ClutterContainerIface
                           GParamSpec       *pspec);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_container_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *          clutter_container_find_child_by_name            (ClutterContainer *container,
                                                                          const gchar      *child_name);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GParamSpec *            clutter_container_class_find_child_property     (GObjectClass     *klass,
                                                                          const gchar      *property_name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GParamSpec **           clutter_container_class_list_child_properties   (GObjectClass     *klass,
                                                                          guint            *n_properties);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_create_child_meta             (ClutterContainer *container,
                                                                          ClutterActor     *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_destroy_child_meta            (ClutterContainer *container,
                                                                          ClutterActor     *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterChildMeta *      clutter_container_get_child_meta                (ClutterContainer *container,
                                                                          ClutterActor     *actor);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_child_set_property            (ClutterContainer *container,
                                                                          ClutterActor     *child,
                                                                          const gchar      * property,
                                                                          const GValue     *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_child_get_property            (ClutterContainer *container,
                                                                          ClutterActor     *child,
                                                                          const gchar      *property,
                                                                          GValue           *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_child_set                     (ClutterContainer *container,
                                                                          ClutterActor     *actor,
                                                                          const gchar      *first_prop,
                                                                          ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_child_get                     (ClutterContainer *container,
                                                                          ClutterActor     *actor,
                                                                          const gchar      *first_prop,
                                                                          ...) G_GNUC_NULL_TERMINATED;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_container_child_notify                  (ClutterContainer *container,
                                                                          ClutterActor     *child,
                                                                          GParamSpec       *pspec);

clutter/clutter/clutter-content.c

@@ -36,7 +36,9 @@
  * #ClutterContent is available since Clutter 1.10.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-content-private.h"
 

clutter/clutter/clutter-content.h

@@ -88,14 +88,14 @@ struct _ClutterContentIface
   void          (* invalidate)          (ClutterContent   *content);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_content_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean        clutter_content_get_preferred_size      (ClutterContent *content,
                                                          gfloat         *width,
                                                          gfloat         *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_content_invalidate              (ClutterContent *content);
 
 G_END_DECLS

clutter/clutter/clutter-debug.h

@@ -39,8 +39,7 @@ typedef enum {
   CLUTTER_DEBUG_DISABLE_CULLING         = 1 << 4,
   CLUTTER_DEBUG_DISABLE_OFFSCREEN_REDIRECT = 1 << 5,
   CLUTTER_DEBUG_CONTINUOUS_REDRAW       = 1 << 6,
-  CLUTTER_DEBUG_PAINT_DEFORM_TILES      = 1 << 7,
+  CLUTTER_DEBUG_PAINT_DEFORM_TILES      = 1 << 7
-  CLUTTER_DEBUG_PAINT_DAMAGE_REGION     = 1 << 8,
 } ClutterDrawDebugFlag;
 
 #ifdef CLUTTER_ENABLE_DEBUG

clutter/clutter/clutter-deform-effect.c

@@ -51,7 +51,9 @@
  * deformation algorithm.
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-deform-effect.h"

clutter/clutter/clutter-deform-effect.h

@@ -92,24 +92,24 @@ struct _ClutterDeformEffectClass
   void (*_clutter_deform7) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_deform_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
                                                          CoglHandle           material);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 CoglHandle      clutter_deform_effect_get_back_material (ClutterDeformEffect *effect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_deform_effect_set_n_tiles       (ClutterDeformEffect *effect,
                                                          guint                x_tiles,
                                                          guint                y_tiles);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_deform_effect_get_n_tiles       (ClutterDeformEffect *effect,
                                                          guint               *x_tiles,
                                                          guint               *y_tiles);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_deform_effect_invalidate        (ClutterDeformEffect *effect);
 
 G_END_DECLS

clutter/clutter/clutter-deprecated.h

@@ -26,6 +26,7 @@
 #include "deprecated/clutter-keysyms.h"
 #include "deprecated/clutter-list-model.h"
 #include "deprecated/clutter-main.h"
+#include "deprecated/clutter-media.h"
 #include "deprecated/clutter-model.h"
 #include "deprecated/clutter-rectangle.h"
 #include "deprecated/clutter-score.h"

clutter/clutter/clutter-desaturate-effect.c

@@ -39,7 +39,9 @@
 #define CLUTTER_IS_DESATURATE_EFFECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DESATURATE_EFFECT))
 #define CLUTTER_DESATURATE_EFFECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DESATURATE_EFFECT, ClutterDesaturateEffectClass))
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 
@@ -155,7 +157,6 @@ static void
 clutter_desaturate_effect_paint_target (ClutterOffscreenEffect *effect)
 {
   ClutterDesaturateEffect *self = CLUTTER_DESATURATE_EFFECT (effect);
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   ClutterActor *actor;
   CoglHandle texture;
   guint8 paint_opacity;
@@ -171,12 +172,13 @@ clutter_desaturate_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
+  cogl_rectangle (0, 0,
-                                   self->pipeline,
+                  cogl_texture_get_width (texture),
-                                   0, 0,
+                  cogl_texture_get_height (texture));
-                                   cogl_texture_get_width (texture),
+
-                                   cogl_texture_get_height (texture));
+  cogl_pop_source ();
 }
 
 static void

clutter/clutter/clutter-desaturate-effect.h

@@ -48,16 +48,16 @@ G_BEGIN_DECLS
 typedef struct _ClutterDesaturateEffect         ClutterDesaturateEffect;
 typedef struct _ClutterDesaturateEffectClass    ClutterDesaturateEffectClass;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_desaturate_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_desaturate_effect_new        (gdouble                  factor);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
                                                      gdouble                  factor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gdouble        clutter_desaturate_effect_get_factor (ClutterDesaturateEffect *effect);
 
 G_END_DECLS

clutter/clutter/clutter-device-manager-private.h

@@ -167,10 +167,6 @@ struct _ClutterInputDeviceClass
   gboolean (* is_grouped) (ClutterInputDevice *device,
                            ClutterInputDevice *other_device);
 
-  gboolean (* get_physical_size) (ClutterInputDevice *device,
-                                  gdouble            *width,
-                                  gdouble            *height);
-
   /* Keyboard accessbility */
   void (* process_kbd_a11y_event) (ClutterEvent               *event,
                                    ClutterInputDevice         *device,

clutter/clutter/clutter-device-manager.c

@@ -36,7 +36,9 @@
  * #ClutterDeviceManager is available since Clutter 1.2
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-backend-private.h"
 #include "clutter-debug.h"

clutter/clutter/clutter-device-manager.h

@@ -125,34 +125,34 @@ struct _ClutterDeviceManagerClass
   gpointer _padding[6];
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_device_manager_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterDeviceManager *clutter_device_manager_get_default     (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GSList *              clutter_device_manager_list_devices    (ClutterDeviceManager   *device_manager);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 const GSList *        clutter_device_manager_peek_devices    (ClutterDeviceManager   *device_manager);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputDevice *  clutter_device_manager_get_device      (ClutterDeviceManager   *device_manager,
                                                               gint                    device_id);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputDevice *  clutter_device_manager_get_core_device (ClutterDeviceManager   *device_manager,
                                                               ClutterInputDeviceType  device_type);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterVirtualInputDevice *clutter_device_manager_create_virtual_device (ClutterDeviceManager  *device_manager,
                                                                          ClutterInputDeviceType device_type);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterVirtualDeviceType clutter_device_manager_get_supported_virtual_device_types (ClutterDeviceManager *device_manager);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
 

clutter/clutter/clutter-drag-action.c

@@ -63,7 +63,9 @@
  * #ClutterDragAction is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-drag-action.h"
 

clutter/clutter/clutter-drag-action.h

@@ -105,45 +105,45 @@ struct _ClutterDragActionClass
   void (* _clutter_drag_action4) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_drag_action_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction * clutter_drag_action_new                   (void);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
                                                         gint               x_threshold,
                                                         gint               y_threshold);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_drag_threshold (ClutterDragAction *action,
                                                         guint             *x_threshold,
                                                         guint             *y_threshold);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_handle    (ClutterDragAction *action,
                                                         ClutterActor      *handle);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *  clutter_drag_action_get_drag_handle    (ClutterDragAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_axis      (ClutterDragAction *action,
                                                         ClutterDragAxis    axis);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterDragAxis clutter_drag_action_get_drag_axis      (ClutterDragAction *action);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_press_coords   (ClutterDragAction *action,
                                                         gfloat            *press_x,
                                                         gfloat            *press_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_motion_coords  (ClutterDragAction *action,
                                                         gfloat            *motion_x,
                                                         gfloat            *motion_y);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean        clutter_drag_action_get_drag_area      (ClutterDragAction *action,
                                                         ClutterRect       *drag_area);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void            clutter_drag_action_set_drag_area      (ClutterDragAction *action,
                                                         const ClutterRect *drag_area);
 

clutter/clutter/clutter-drop-action.c

@@ -58,7 +58,9 @@
  * #ClutterDropAction is available since Clutter 1.8
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-drop-action.h"
 

clutter/clutter/clutter-drop-action.h

@@ -104,10 +104,10 @@ struct _ClutterDropActionClass
   void (*_clutter_drop_action8) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 GType clutter_drop_action_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 ClutterAction *         clutter_drop_action_new         (void);
 
 G_END_DECLS

clutter/clutter/clutter-effect-private.h

@@ -9,7 +9,6 @@ gboolean        _clutter_effect_pre_paint               (ClutterEffect
 void            _clutter_effect_post_paint              (ClutterEffect           *effect);
 gboolean        _clutter_effect_get_paint_volume        (ClutterEffect           *effect,
                                                          ClutterPaintVolume      *volume);
-gboolean        _clutter_effect_has_custom_paint_volume (ClutterEffect           *effect);
 void            _clutter_effect_paint                   (ClutterEffect           *effect,
                                                          ClutterEffectPaintFlags  flags);
 void            _clutter_effect_pick                    (ClutterEffect           *effect,

clutter/clutter/clutter-effect.c

@@ -160,7 +160,9 @@
  * #ClutterEffect is available since Clutter 1.4
  */
 
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
+#endif
 
 #include "clutter-effect.h"
 
@@ -306,14 +308,6 @@ _clutter_effect_get_paint_volume (ClutterEffect      *effect,
   return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume (effect, volume);
 }
 
-gboolean
-_clutter_effect_has_custom_paint_volume (ClutterEffect *effect)
-{
-  g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
-
-  return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume != clutter_effect_real_get_paint_volume;
-}
-
 /**
  * clutter_effect_queue_repaint:
  * @effect: A #ClutterEffect which needs redrawing

clutter/clutter/clutter-effect.h

@@ -91,38 +91,38 @@ struct _ClutterEffectClass
   void (* _clutter_effect6) (void);
 };
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_effect_get_type (void) G_GNUC_CONST;
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 void    clutter_effect_queue_repaint    (ClutterEffect *effect);
 
 /*
  * ClutterActor API
  */
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_effect            (ClutterActor  *self,
                                                     ClutterEffect *effect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_effect_with_name  (ClutterActor  *self,
                                                     const gchar   *name,
                                                     ClutterEffect *effect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_effect         (ClutterActor  *self,
                                                     ClutterEffect *effect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_effect_by_name (ClutterActor  *self,
                                                     const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GList *        clutter_actor_get_effects           (ClutterActor  *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_actor_get_effect            (ClutterActor  *self,
                                                     const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_clear_effects         (ClutterActor  *self);
 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean       clutter_actor_has_effects           (ClutterActor  *self);
 
 G_END_DECLS