clutter: remove deprecated ClutterStage/ClutterAnimator

Removing one without the other was quite the headache, so just remove
both of them together instead.

.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]
@@ -100,6 +122,13 @@ 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,44 +1,24 @@
 image: registry.gitlab.gnome.org/gnome/mutter/master:v1
 
 stages:
- - review
  - build
  - test
 
-check-commit-log:
-  stage: review
-  script:
-    - ./.gitlab-ci/check-commit-log.sh
-  only:
-    - merge_requests
-
 build-mutter:
   stage: build
   script:
-    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror
+    - meson . build -Degl_device=true -Dwayland_eglstream=true
     - ninja -C build
     - ninja -C build install
-  artifacts:
-    expire_in: 1 day
-    paths:
-      - build
-  only:
-    - merge_requests
-    - /^.*$/
 
 test-mutter:
   stage: test
-  dependencies:
-    - build-mutter
-  variables:
-    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
-    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
   script:
-    - mkdir -m 700 $XDG_RUNTIME_DIR
-    - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
-    - >
-      dbus-run-session -- xvfb-run -s '+iglx -noreset'
-      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --wrap catchsegv
-  only:
-    - merge_requests
-    - /^.*$/
+    - 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 --verbose --no-stdsplit
+  artifacts:
+    paths:
+      - build/meson-logs
+    when: on_failure

.gitlab-ci/Dockerfile

@@ -10,8 +10,5 @@ RUN dnf -y update && dnf -y upgrade && \
     # 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/00848426-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/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
-
     dnf install -y intltool redhat-rpm-config make && \
     dnf clean all

.gitlab-ci/check-commit-log.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-if [ -z "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" ]; then
-  echo Cannot review non-merge request
-  exit 1
-fi
-
-git fetch $CI_MERGE_REQUEST_PROJECT_URL.git $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
-
-branch_point=$(git merge-base HEAD FETCH_HEAD)
-
-commits=$(git log --format='format:%H' $branch_point..$CI_COMMIT_SHA)
-
-if [ -z "$commits" ]; then
-  echo Commit range empty
-  exit 1
-fi
-
-function commit_message_has_url() {
-  commit=$1
-  commit_message=$(git show -s --format='format:%b' $commit)
-  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
-  return $?
-}
-
-for commit in $commits; do
-  if ! commit_message_has_url $commit; then
-    echo "Missing merge request or issue URL on commit $(echo $commit | cut -c -8)"
-    exit 1
-  fi
-done

Makefile.am

@@ -0,0 +1,13 @@
+pkgdatadir = $(datadir)/mutter-$(LIBMUTTER_API_VERSION)
+pkglibdir = $(libdir)/mutter-$(LIBMUTTER_API_VERSION)
+
+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,80 +1,3 @@
-3.31.91
-=======
-* Fix infinite loop in EDID matching [Marco; #459]
-* wayland: Don't resetin text-input state prematurely [Carlos; !410]
-* wayland: Don't maximize windows if minimum size is too big [Olivier; #463]
-* Fix crash when using "restore shortcuts" without focus window [Olivier; #464]
-* Add flag parameter to grab accelerator API [Andrea; !169]
-* Reuse old CRTC if possible to avoid flicker on hotplug [Pekka, Emilio; #373]
-* Misc. bug fixes and cleanups [Marco, Jonas, Niels, Adam, Olivier; !436,
-  !421, #462, !439, !440, !444, !321, !445, !456]
-
-Contributors:
-  Jonas Ådahl, Andrea Azzarone, Olivier Fourdan, Carlos Garnacho,
-  Niels De Graef, Adam Jackson, Emilio Pozuelo Monfort, Pekka Paalanen,
-  Marco Trevisan (Treviño)
-
-Translators:
-  Jiri Grönroos [fi], Charles Monzat [fr], Claude Paroz [fr], Fran Dieguez [gl],
-  Emin Tufan Çetin [tr], Aurimas Černius [lt], Anders Jonsson [sv],
-  Matej Urbančič [sl], Marek Cernocky [cs], Daniel Șerbănescu [ro],
-  Alan Mortensen [da], Baurzhan Muftakhidinov [kk], Yi-Jyun Pan [zh_TW],
-  Daniel Mustieles [es], Rafael Fontenelle [pt_BR]
-
-3.31.90
-=======
-* Fix support of extended characters in on-screen keyboard [Andrea; #109]
-* Improve selection of the primary GPU [Pekka, Emilio; !271]
-* Screen-cast cursor updates as PipeWire stream metadata [Jonas; !357]
-* Fix rendering glitches in magnifier [Daniel; gnome-shell#387]
-* Fix monitor recording on HiDPI [Jonas; !415]
-* Honour secondary GPU supported pixel formats [Pekka; !341]
-* Fall back to CPU copy path when using a software renderer [Emilio; !325]
-* Remove fallback app menu [Florian; gnome-shell#624]
-* wayland: Add support for viewporter protocol [Robert; !323]
-* Misc. bug fixes and cleanups [Florian, Carlos, Olivier, Marco, Robert,
-  Daniel, Pekka, Jonas, Ole, Georges; !391, #335, #442, !406, !395, #447,
-  !375, gnome-shell#349, #451, !416, #784199, !408, !181, !405]
-
-Contributors:
-  Jonas Ådahl, Andrea Azzarone, Ole Jørgen Brønner, Piotr Drąg, Olivier Fourdan,
-  Dariusz Gadomski, Carlos Garnacho, Antoine Jacoutot, Iain Lane, Robert Mader,
-  Emilio Pozuelo Monfort, Florian Müllner, Georges Basile Stavracas Neto,
-  Pekka Paalanen, Marco Trevisan (Treviño), Josh Triplett, Daniel van Vugt
-
-Translators:
-  Fabio Tomat [fur], Balázs Úr [hu], Daniel Mustieles [es], Kukuh Syafaat [id],
-  Jordi Mas [ca], Piotr Drąg [pl]
-
-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]

README.md

@@ -22,20 +22,6 @@ 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.
 
-## Contributing
-
-To contribute, open merge requests at https://gitlab.gnome.org/GNOME/mutter.
-
-The coding style used is primarily the GNU flavor of the [GNOME coding
-style](https://developer.gnome.org/programming-guidelines/stable/c-coding-style.html.en)
-with some minor additions such as preferring `stdint.h` types over GLib
-fundamental types, and a soft 80 character line limit. However, in general,
-look at the file you're editing for inspiration.
-
-Commit messages should follow the [GNOME commit message
-guidelines](https://wiki.gnome.org/Git/CommitMessages). We require an URL
-to either an issue or a merge request in each commit.
-
 ## License
 
 Mutter is distributed under the terms of the GNU General Public License,

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/Makefile.am

@@ -0,0 +1,49 @@
+NULL =
+
+SUBDIRS = build clutter tests
+
+DIST_SUBDIRS = clutter tests 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,672 @@
+AUTOMAKE_OPTIONS = subdir-objects
+
+# preamble
+NULL =
+
+# common definitions
+CLEANFILES =
+DISTCLEANFILES =
+EXTRA_DIST =
+BUILT_SOURCES =
+
+AM_CPPFLAGS = \
+	-DCLUTTER_SYSCONFDIR=\""$(sysconfdir)"\" \
+	-DCLUTTER_COMPILATION=1			\
+	-DCOGL_DISABLE_DEPRECATION_WARNINGS	\
+	-DG_LOG_DOMAIN=\"Clutter\" 		\
+	-fvisibility=hidden			\
+	-I$(top_srcdir) 			\
+	-I$(top_srcdir)/clutter			\
+	-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)			\
+	$(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-$(LIBMUTTER_API_VERSION)/clutter
+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-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-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-cairo-texture.h		\
+	deprecated/clutter-container.h		\
+	deprecated/clutter-input-device.h		\
+	deprecated/clutter-keysyms.h			\
+	deprecated/clutter-main.h			\
+	deprecated/clutter-rectangle.h		\
+	deprecated/clutter-stage-manager.h		\
+	deprecated/clutter-stage.h			\
+	deprecated/clutter-texture.h			\
+	deprecated/clutter-timeline.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-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-cairo-texture.c		\
+	deprecated/clutter-input-device-deprecated.c	\
+	deprecated/clutter-layout-manager-deprecated.c \
+	deprecated/clutter-rectangle.c 		\
+	deprecated/clutter-texture.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
+
+# 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)
+
+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
+
+backend_source_h += $(egl_source_h)
+backend_source_c += $(egl_source_c)
+backend_source_h_priv += $(egl_source_h_priv)
+
+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-autocleanups.h clutter-mutter.h
+nodist_clutter_include_HEADERS = clutter-config.h $(built_source_h)
+
+clutter_deprecated_HEADERS = $(deprecated_h)
+
+mutterlibdir = $(libdir)/mutter-@LIBMUTTER_API_VERSION@
+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) \
+	$(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-group.c

@@ -1,147 +0,0 @@
-/* CALLY - The Clutter Accessibility Implementation Library
- *
- * Copyright (C) 2008 Igalia, S.L.
- *
- * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
- *
- * Based on GailContainer from GAIL
- * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-/**
- * SECTION:cally-group
- * @Title: CallyGroup
- * @short_description: Implementation of the ATK interfaces for a #ClutterGroup
- * @see_also: #ClutterGroup
- *
- * #CallyGroup implements the required ATK interfaces of #ClutterGroup
- * In particular it exposes each of the Clutter actors contained in the
- * group.
- */
-
-#include "clutter-build-config.h"
-
-#include "cally-group.h"
-#include "cally-actor-private.h"
-
-static gint       cally_group_get_n_children  (AtkObject *obj);
-static AtkObject* cally_group_ref_child       (AtkObject *obj,
-                                              gint       i);
-static void       cally_group_real_initialize (AtkObject *obj,
-                                              gpointer   data);
-
-G_DEFINE_TYPE (CallyGroup, cally_group, CALLY_TYPE_ACTOR)
-
-static void
-cally_group_class_init (CallyGroupClass *klass)
-{
-/*   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass); */
-  AtkObjectClass *class         = ATK_OBJECT_CLASS (klass);
-
-  class->get_n_children = cally_group_get_n_children;
-  class->ref_child      = cally_group_ref_child;
-  class->initialize     = cally_group_real_initialize;
-}
-
-static void
-cally_group_init (CallyGroup      *group)
-{
-  /* nothing to do yet */
-}
-
-/**
- * cally_group_new:
- * @actor: a #ClutterGroup
- *
- * Creates a #CallyGroup for @actor
- *
- * Return value: the newly created #CallyGroup
- *
- * Since: 1.4
- */
-AtkObject *
-cally_group_new (ClutterActor *actor)
-{
-  GObject   *object     = NULL;
-  AtkObject *accessible = NULL;
-
-  g_return_val_if_fail (CLUTTER_IS_GROUP (actor), NULL);
-
-  object = g_object_new (CALLY_TYPE_GROUP, NULL);
-
-  accessible = ATK_OBJECT (object);
-  atk_object_initialize (accessible, actor);
-
-  return accessible;
-}
-
-static gint
-cally_group_get_n_children (AtkObject *obj)
-{
-  ClutterActor *actor = NULL;
-  gint          count = 0;
-
-  g_return_val_if_fail (CALLY_IS_GROUP (obj), count);
-
-  actor = CALLY_GET_CLUTTER_ACTOR (obj);
-
-  if (actor == NULL) /* defunct */
-    return 0;
-
-  g_return_val_if_fail (CLUTTER_IS_GROUP(actor), count);
-
-  count = clutter_actor_get_n_children (actor);
-
-  return count;
-}
-
-static AtkObject*
-cally_group_ref_child (AtkObject *obj,
-                       gint       i)
-{
-  AtkObject    *accessible = NULL;
-  ClutterActor *actor      = NULL;
-  ClutterActor *child      = NULL;
-
-  g_return_val_if_fail (CALLY_IS_GROUP (obj), NULL);
-  g_return_val_if_fail ((i >= 0), NULL);
-
-  actor = CALLY_GET_CLUTTER_ACTOR (obj);
-
-  g_return_val_if_fail (CLUTTER_IS_GROUP(actor), NULL);
-  child = clutter_actor_get_child_at_index (actor, i);
-
-  if (!child)
-    return NULL;
-
-  accessible = clutter_actor_get_accessible (child);
-
-  if (accessible != NULL)
-    g_object_ref (accessible);
-
-  return accessible;
-}
-
-static void
-cally_group_real_initialize (AtkObject *obj,
-                            gpointer   data)
-{
-  ATK_OBJECT_CLASS (cally_group_parent_class)->initialize (obj, data);
-
-  obj->role = ATK_ROLE_PANEL;
-}

clutter/clutter/cally/cally-group.h

@@ -1,87 +0,0 @@
-/* CALLY - The Clutter Accessibility Implementation Library
- *
- * Copyright (C) 2008 Igalia, S.L.
- *
- * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
- *
- * Based on GailContainer from GAIL
- * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __CALLY_GROUP_H__
-#define __CALLY_GROUP_H__
-
-#if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <cally/cally.h> can be included directly."
-#endif
-
-#include <cally/cally-actor.h>
-#include <clutter/clutter.h>
-
-G_BEGIN_DECLS
-
-#define CALLY_TYPE_GROUP                         (cally_group_get_type ())
-#define CALLY_GROUP(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_GROUP, CallyGroup))
-#define CALLY_GROUP_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_GROUP, CallyGroupClass))
-#define CALLY_IS_GROUP(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_GROUP))
-#define CALLY_IS_GROUP_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_GROUP))
-#define CALLY_GROUP_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_GROUP, CallyGroupClass))
-
-typedef struct _CallyGroup        CallyGroup;
-typedef struct _CallyGroupClass   CallyGroupClass;
-typedef struct _CallyGroupPrivate CallyGroupPrivate;
-
-/**
- * CallyGroup:
- *
- * The <structname>CallyGroup</structname> structure contains only
- * private data and should be accessed using the provided API
- *
- * Since: 1.4
- */
-struct _CallyGroup
-{
-  /*< private >*/
-  CallyActor parent;
-
-  CallyGroupPrivate *priv;
-};
-
-/**
- * CallyGroupClass:
- *
- * The <structname>CallyGroupClass</structname> structure contains only
- * private data
- *
- * Since: 1.4
- */
-struct _CallyGroupClass
-{
-  /*< private >*/
-  CallyActorClass parent_class;
-
-  /* padding for future expansion */
-  gpointer _padding_dummy[8];
-};
-
-CLUTTER_EXPORT
-GType      cally_group_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
-AtkObject* cally_group_new      (ClutterActor *actor);
-
-G_END_DECLS
-
-#endif /* __CALLY_GROUP_H__ */

clutter/clutter/cally/cally-stage.c

@@ -63,7 +63,7 @@ struct _CallyStagePrivate
 
 G_DEFINE_TYPE_WITH_CODE (CallyStage,
                          cally_stage,
-                         CALLY_TYPE_GROUP,
+                         CALLY_TYPE_ACTOR,
                          G_ADD_PRIVATE (CallyStage)
                          G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
                                                 cally_stage_window_interface_init));

clutter/clutter/cally/cally-stage.h

@@ -25,7 +25,7 @@
 #error "Only <cally/cally.h> can be included directly."
 #endif
 
-#include <cally/cally-group.h>
+#include <cally/cally-actor.h>
 #include <clutter/clutter.h>
 
 G_BEGIN_DECLS
@@ -52,7 +52,7 @@ typedef struct _CallyStagePrivate CallyStagePrivate;
 struct _CallyStage
 {
   /*< private >*/
-  CallyGroup parent;
+  CallyActor parent;
 
   CallyStagePrivate *priv;
 };
@@ -68,7 +68,7 @@ struct _CallyStage
 struct _CallyStageClass
 {
   /*< private >*/
-  CallyGroupClass parent_class;
+  CallyActorClass parent_class;
 
   /* padding for future expansion */
   gpointer _padding_dummy[16];

clutter/clutter/cally/cally.c

@@ -36,7 +36,6 @@
 #include "cally.h"
 
 #include "cally-actor.h"
-#include "cally-group.h"
 #include "cally-stage.h"
 #include "cally-text.h"
 #include "cally-texture.h"
@@ -53,7 +52,6 @@
 
 /* factories initialization*/
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_ACTOR, cally_actor, cally_actor_new)
-CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_GROUP, cally_group, cally_group_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_STAGE, cally_stage, cally_stage_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_TEXT, cally_text, cally_text_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_TEXTURE, cally_texture, cally_texture_new)
@@ -75,7 +73,6 @@ cally_accessibility_init (void)
 {
   /* setting the factories */
   CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_ACTOR, cally_actor);
-  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_GROUP, cally_group);
   CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_STAGE, cally_stage);
   CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_TEXT, cally_text);
   CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_TEXTURE, cally_texture);

clutter/clutter/cally/cally.h

@@ -26,7 +26,6 @@
 #include "cally-actor.h"
 #include "cally-clone.h"
 #include "cally-factory.h"
-#include "cally-group.h"
 #include "cally-main.h"
 #include "cally-rectangle.h"
 #include "cally-root.h"

clutter/clutter/clutter-actor-box-private.h

@@ -1,12 +0,0 @@
-#ifndef __CLUTTER_ACTOR_BOX_PRIVATE_H__
-#define __CLUTTER_ACTOR_BOX_PRIVATE_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-void _clutter_actor_box_enlarge_for_effects (ClutterActorBox *box);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ACTOR_BOX_PRIVATE_H__ */

clutter/clutter/clutter-actor-box.c

@@ -5,7 +5,6 @@
 #include "clutter-types.h"
 #include "clutter-interval.h"
 #include "clutter-private.h"
-#include "clutter-actor-box-private.h"
 
 /**
  * clutter_actor_box_new:
@@ -543,57 +542,6 @@ clutter_actor_box_set_size (ClutterActorBox *box,
   box->y2 = box->y1 + height;
 }
 
-void
-_clutter_actor_box_enlarge_for_effects (ClutterActorBox *box)
-{
-  float width, height;
-
-  /* The aim here is that for a given rectangle defined with floating point
-   * coordinates we want to determine a stable quantized size in pixels
-   * that doesn't vary due to the original box's sub-pixel position.
-   *
-   * The reason this is important is because effects will use this
-   * API to determine the size of offscreen framebuffers and so for
-   * a fixed-size object that may be animated accross the screen we
-   * want to make sure that the stage paint-box has an equally stable
-   * size so that effects aren't made to continuously re-allocate
-   * a corresponding fbo.
-   *
-   * The other thing we consider is that the calculation of this box is
-   * subject to floating point precision issues that might be slightly
-   * different to the precision issues involved with actually painting the
-   * actor, which might result in painting slightly leaking outside the
-   * user's calculated paint-volume. For this we simply aim to pad out the
-   * paint-volume by at least half a pixel all the way around.
-   */
-  width = box->x2 - box->x1;
-  height = box->y2 - box->y1;
-  width = CLUTTER_NEARBYINT (width);
-  height = CLUTTER_NEARBYINT (height);
-  /* XXX: NB the width/height may now be up to 0.5px too small so we
-   * must also pad by 0.25px all around to account for this. In total we
-   * must padd by at least 0.75px around all sides. */
-
-  /* XXX: The furthest that we can overshoot the bottom right corner by
-   * here is 1.75px in total if you consider that the 0.75 padding could
-   * just cross an integer boundary and so ceil will effectively add 1.
-   */
-  box->x2 = ceilf (box->x2 + 0.75);
-  box->y2 = ceilf (box->y2 + 0.75);
-
-  /* Now we redefine the top-left relative to the bottom right based on the
-   * rounded width/height determined above + a constant so that the overall
-   * size of the box will be stable and not dependant on the box's
-   * position.
-   *
-   * Adding 3px to the width/height will ensure we cover the maximum of
-   * 1.75px padding on the bottom/right and still ensure we have > 0.75px
-   * padding on the top/left.
-   */
-  box->x1 = box->x2 - width - 3;
-  box->y1 = box->y2 - height - 3;
-}
-
 G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterActorBox, clutter_actor_box,
                                clutter_actor_box_copy,
                                clutter_actor_box_free,

clutter/clutter/clutter-actor-private.h

@@ -275,14 +275,17 @@ 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,
-                                                                                         ClutterRedrawFlags        flags,
-                                                                                         const ClutterPaintVolume *clip_volume);
-void                            _clutter_actor_queue_redraw_full                        (ClutterActor             *self,
-                                                                                         ClutterRedrawFlags        flags,
-                                                                                         const ClutterPaintVolume *volume,
-                                                                                         ClutterEffect            *effect);
+void                            _clutter_actor_queue_redraw_with_clip                   (ClutterActor       *self,
+                                                                                         ClutterRedrawFlags  flags,
+                                                                                         ClutterPaintVolume *clip_volume);
+void                            _clutter_actor_queue_redraw_full                        (ClutterActor       *self,
+                                                                                         ClutterRedrawFlags  flags,
+                                                                                         ClutterPaintVolume *volume,
+                                                                                         ClutterEffect      *effect);
 
+ClutterPaintVolume *            _clutter_actor_get_queue_redraw_clip                    (ClutterActor       *self);
+void                            _clutter_actor_set_queue_redraw_clip                    (ClutterActor       *self,
+                                                                                         ClutterPaintVolume *clip_volume);
 void                            _clutter_actor_finish_queue_redraw                      (ClutterActor       *self,
                                                                                          ClutterPaintVolume *clip);
 

clutter/clutter/clutter-actor.c

@@ -635,7 +635,6 @@
 #include "clutter-interval.h"
 #include "clutter-main.h"
 #include "clutter-marshal.h"
-#include "clutter-mutter.h"
 #include "clutter-paint-nodes.h"
 #include "clutter-paint-node-private.h"
 #include "clutter-paint-volume-private.h"
@@ -1023,7 +1022,7 @@ typedef struct _TransitionClosure
 
 static void clutter_container_iface_init  (ClutterContainerIface  *iface);
 static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
-static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);
+static void clutter_animatable_iface_init (ClutterAnimatableIface *iface);
 static void atk_implementor_iface_init    (AtkImplementorIface    *iface);
 
 /* These setters are all static for now, maybe they should be in the
@@ -1722,22 +1721,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 +1776,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 +1901,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 +2226,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,
-                                  color->red,
-                                  color->green,
-                                  color->blue,
-                                  color->alpha);
+      cogl_set_source_color4ub (color->red,
+                                color->green,
+                                color->blue,
+                                color->alpha);
 
-      cogl_framebuffer_draw_rectangle (framebuffer,
-                                       pick_pipeline,
-                                       0, 0,
-                                       width, height);
-
-      cogl_object_unref (pick_pipeline);
+      cogl_rectangle (0, 0, width, height);
     }
 
   /* XXX - this thoroughly sucks, but we need to maintain compatibility
@@ -2689,12 +2649,9 @@ clutter_actor_real_allocate (ClutterActor           *self,
 }
 
 static void
-_clutter_actor_propagate_queue_redraw (ClutterActor       *self,
-                                       ClutterActor       *origin,
-                                       ClutterPaintVolume *pv)
+_clutter_actor_signal_queue_redraw (ClutterActor *self,
+                                    ClutterActor *origin)
 {
-  gboolean stop = FALSE;
-
   /* no point in queuing a redraw on a destroyed actor */
   if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
     return;
@@ -2703,33 +2660,27 @@ _clutter_actor_propagate_queue_redraw (ClutterActor       *self,
    * the actor bas been cloned. In this case the clone will need to
    * receive the signal so it can queue its own redraw.
    */
-  while (self)
-    {
-      _clutter_actor_queue_redraw_on_clones (self);
 
-      /* calls klass->queue_redraw in default handler */
-      if (g_signal_has_handler_pending (self, actor_signals[QUEUE_REDRAW],
+  _clutter_actor_queue_redraw_on_clones (self);
+
+  /* calls klass->queue_redraw in default handler */
+  if (g_signal_has_handler_pending (self, actor_signals[QUEUE_REDRAW],
                                     0, TRUE))
-        {
-          g_signal_emit (self, actor_signals[QUEUE_REDRAW], 0, origin, pv, &stop);
-        }
-      else
-        {
-          stop = CLUTTER_ACTOR_GET_CLASS (self)->queue_redraw (self, origin, pv);
-        }
-
-      if (stop)
-        break;
-
-      self = clutter_actor_get_parent (self);
+    {
+      g_signal_emit (self, actor_signals[QUEUE_REDRAW], 0, origin);
+    }
+  else
+    {
+      CLUTTER_ACTOR_GET_CLASS (self)->queue_redraw (self, origin);
     }
 }
 
-static gboolean
-clutter_actor_real_queue_redraw (ClutterActor       *self,
-                                 ClutterActor       *origin,
-                                 ClutterPaintVolume *paint_volume)
+static void
+clutter_actor_real_queue_redraw (ClutterActor *self,
+                                 ClutterActor *origin)
 {
+  ClutterActor *parent;
+
   CLUTTER_NOTE (PAINT, "Redraw queued on '%s' (from: '%s')",
                 _clutter_actor_get_debug_name (self),
                 origin != NULL ? _clutter_actor_get_debug_name (origin)
@@ -2737,7 +2688,7 @@ clutter_actor_real_queue_redraw (ClutterActor       *self,
 
   /* no point in queuing a redraw on a destroyed actor */
   if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
-    return TRUE;
+    return;
 
   /* If the queue redraw is coming from a child then the actor has
      become dirty and any queued effect is no longer valid */
@@ -2752,7 +2703,7 @@ clutter_actor_real_queue_redraw (ClutterActor       *self,
    * won't change so we don't have to propagate up the hierarchy.
    */
   if (!CLUTTER_ACTOR_IS_VISIBLE (self))
-    return TRUE;
+    return;
 
   /* Although we could determine here that a full stage redraw
    * has already been queued and immediately bail out, we actually
@@ -2766,7 +2717,7 @@ clutter_actor_real_queue_redraw (ClutterActor       *self,
       ClutterActor *stage = _clutter_actor_get_stage_internal (self);
       if (stage != NULL &&
           _clutter_stage_has_full_redraw_queued (CLUTTER_STAGE (stage)))
-        return TRUE;
+        return;
     }
 
   self->priv->propagated_one_redraw = TRUE;
@@ -2774,7 +2725,12 @@ clutter_actor_real_queue_redraw (ClutterActor       *self,
   /* notify parents, if they are all visible eventually we'll
    * queue redraw on the stage, which queues the redraw idle.
    */
-  return FALSE;
+  parent = clutter_actor_get_parent (self);
+  if (parent != NULL)
+    {
+      /* this will go up recursively */
+      _clutter_actor_signal_queue_redraw (parent, origin);
+    }
 }
 
 static void
@@ -3738,7 +3694,7 @@ clutter_actor_paint_node (ClutterActor     *actor,
       if (!clutter_stage_get_no_clear_hint (CLUTTER_STAGE (actor)))
         clear_flags |= COGL_BUFFER_BIT_COLOR;
 
-      node = clutter_root_node_new (fb, &bg_color, clear_flags);
+      node = _clutter_root_node_new (fb, &bg_color, clear_flags);
       clutter_paint_node_set_name (node, "stageClear");
       clutter_paint_node_add_rectangle (node, &box);
       clutter_paint_node_add_child (root, node);
@@ -3777,7 +3733,7 @@ clutter_actor_paint_node (ClutterActor     *actor,
     }
 #endif /* CLUTTER_ENABLE_DEBUG */
 
-  clutter_paint_node_paint (root);
+  _clutter_paint_node_paint (root);
 
   return TRUE;
 }
@@ -3975,7 +3931,9 @@ clutter_actor_paint (ClutterActor *self)
     }
 
   if (priv->effects == NULL)
-    priv->next_effect_to_paint = NULL;
+    {
+      priv->next_effect_to_paint = NULL;
+    }
   else
     priv->next_effect_to_paint =
       _clutter_meta_group_peek_metas (priv->effects);
@@ -4865,8 +4823,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
@@ -7994,7 +7951,6 @@ clutter_actor_class_init (ClutterActorClass *klass)
    * ClutterActor::queue-redraw:
    * @actor: the actor we're bubbling the redraw request through
    * @origin: the actor which initiated the redraw request
-   * @volume: paint volume to redraw
    *
    * The ::queue_redraw signal is emitted when clutter_actor_queue_redraw()
    * is called on @origin.
@@ -8048,12 +8004,10 @@ clutter_actor_class_init (ClutterActorClass *klass)
 		  G_SIGNAL_RUN_LAST |
                   G_SIGNAL_NO_HOOKS,
 		  G_STRUCT_OFFSET (ClutterActorClass, queue_redraw),
-                  g_signal_accumulator_true_handled,
-		  NULL,
-		  _clutter_marshal_BOOLEAN__OBJECT_BOXED,
-		  G_TYPE_BOOLEAN, 2,
-                  CLUTTER_TYPE_ACTOR,
-                  CLUTTER_TYPE_PAINT_VOLUME);
+		  NULL, NULL,
+		  _clutter_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+                  CLUTTER_TYPE_ACTOR);
 
   /**
    * ClutterActor::queue-relayout:
@@ -8652,7 +8606,8 @@ _clutter_actor_finish_queue_redraw (ClutterActor *self,
                                     ClutterPaintVolume *clip)
 {
   ClutterActorPrivate *priv = self->priv;
-  ClutterPaintVolume *pv = NULL;
+  ClutterPaintVolume *pv;
+  gboolean clipped;
 
   /* Remove queue entry early in the process, otherwise a new
      queue_redraw() during signal handling could put back this
@@ -8679,7 +8634,8 @@ _clutter_actor_finish_queue_redraw (ClutterActor *self,
    */
   if (clip)
     {
-      pv = clip;
+      _clutter_actor_set_queue_redraw_clip (self, clip);
+      clipped = TRUE;
     }
   else if (G_LIKELY (priv->last_paint_volume_valid))
     {
@@ -8689,12 +8645,36 @@ _clutter_actor_finish_queue_redraw (ClutterActor *self,
           ClutterActor *stage = _clutter_actor_get_stage_internal (self);
 
           /* make sure we redraw the actors old position... */
-          _clutter_actor_propagate_queue_redraw (stage, stage,
-                                                 &priv->last_paint_volume);
-        }
-    }
+          _clutter_actor_set_queue_redraw_clip (stage,
+                                                &priv->last_paint_volume);
+          _clutter_actor_signal_queue_redraw (stage, stage);
+          _clutter_actor_set_queue_redraw_clip (stage, NULL);
 
-  _clutter_actor_propagate_queue_redraw (self, self, pv);
+          /* XXX: Ideally the redraw signal would take a clip volume
+           * argument, but that would be an ABI break. Until we can
+           * break the ABI we pass the argument out-of-band
+           */
+
+          /* setup the clip for the actors new position... */
+          _clutter_actor_set_queue_redraw_clip (self, pv);
+          clipped = TRUE;
+        }
+      else
+        clipped = FALSE;
+    }
+  else
+    clipped = FALSE;
+
+  _clutter_actor_signal_queue_redraw (self, self);
+
+  /* Just in case anyone is manually firing redraw signals without
+   * using the public queue_redraw() API we are careful to ensure that
+   * our out-of-band clip member is cleared before returning...
+   *
+   * Note: A NULL clip denotes a full-stage, un-clipped redraw
+   */
+  if (G_LIKELY (clipped))
+    _clutter_actor_set_queue_redraw_clip (self, NULL);
 }
 
 static void
@@ -8724,14 +8704,15 @@ _clutter_actor_get_allocation_clip (ClutterActor *self,
 }
 
 void
-_clutter_actor_queue_redraw_full (ClutterActor             *self,
-                                  ClutterRedrawFlags        flags,
-                                  const ClutterPaintVolume *volume,
-                                  ClutterEffect            *effect)
+_clutter_actor_queue_redraw_full (ClutterActor       *self,
+                                  ClutterRedrawFlags  flags,
+                                  ClutterPaintVolume *volume,
+                                  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:
@@ -8854,7 +8835,8 @@ _clutter_actor_queue_redraw_full (ClutterActor             *self,
         {
           /* NB: NULL denotes an undefined clip which will result in a
            * full redraw... */
-          _clutter_actor_propagate_queue_redraw (self, self, NULL);
+          _clutter_actor_set_queue_redraw_clip (self, NULL);
+          _clutter_actor_signal_queue_redraw (self, self);
           return;
         }
 
@@ -8872,15 +8854,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
@@ -8994,9 +8982,9 @@ clutter_actor_queue_redraw (ClutterActor *self)
  * picking of your actor.
  */
 void
-_clutter_actor_queue_redraw_with_clip (ClutterActor             *self,
-                                       ClutterRedrawFlags        flags,
-                                       const ClutterPaintVolume *volume)
+_clutter_actor_queue_redraw_with_clip (ClutterActor       *self,
+                                       ClutterRedrawFlags  flags,
+                                       ClutterPaintVolume *volume)
 {
   _clutter_actor_queue_redraw_full (self,
                                     flags, /* flags */
@@ -10273,10 +10261,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],
-                                      &cur_position,
-                                      &new_position);
+  _clutter_actor_create_transition (self, obj_props[PROP_POSITION],
+                                    &cur_position,
+                                    &new_position);
 }
 
 /**
@@ -13635,7 +13622,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);
 }
 
 /**
@@ -13682,7 +13669,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);
 }
 
 /**
@@ -15119,7 +15106,7 @@ clutter_actor_set_final_state (ClutterAnimatable *animatable,
 }
 
 static void
-clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
+clutter_animatable_iface_init (ClutterAnimatableIface *iface)
 {
   iface->find_property = clutter_actor_find_property;
   iface->get_initial_state = clutter_actor_get_initial_state;
@@ -15184,8 +15171,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.
-   * Function calls have been unrolled.
+   * quad to rectangle only, which significantly simplifies things; the
+   * function calls have been unrolled, and most of the math is done in fixed
+   * point.
    */
   clutter_actor_get_abs_allocation_vertices (self, v);
 
@@ -16447,12 +16435,6 @@ clutter_actor_is_in_clone_paint (ClutterActor *self)
   return FALSE;
 }
 
-gboolean
-clutter_actor_has_damage (ClutterActor *actor)
-{
-  return actor->priv->is_dirty;
-}
-
 static gboolean
 set_direction_recursive (ClutterActor *actor,
                          gpointer      user_data)
@@ -16670,6 +16652,26 @@ clutter_actor_has_pointer (ClutterActor *self)
   return self->priv->has_pointer;
 }
 
+/* XXX: This is a workaround for not being able to break the ABI of
+ * the QUEUE_REDRAW signal. It is an out-of-band argument.  See
+ * clutter_actor_queue_clipped_redraw() for details.
+ */
+ClutterPaintVolume *
+_clutter_actor_get_queue_redraw_clip (ClutterActor *self)
+{
+  return g_object_get_data (G_OBJECT (self),
+                            "-clutter-actor-queue-redraw-clip");
+}
+
+void
+_clutter_actor_set_queue_redraw_clip (ClutterActor       *self,
+                                      ClutterPaintVolume *clip)
+{
+  g_object_set_data (G_OBJECT (self),
+                     "-clutter-actor-queue-redraw-clip",
+                     clip);
+}
+
 /**
  * clutter_actor_has_allocation:
  * @self: a #ClutterActor
@@ -18413,10 +18415,6 @@ clutter_actor_set_margin_top (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
-
-  if (info->margin.top == margin)
-    return;
-
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_TOP],
                                     info->margin.top,
                                     margin);
@@ -18461,10 +18459,6 @@ clutter_actor_set_margin_bottom (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
-
-  if (info->margin.bottom == margin)
-    return;
-
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_BOTTOM],
                                     info->margin.bottom,
                                     margin);
@@ -18509,10 +18503,6 @@ clutter_actor_set_margin_left (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
-
-  if (info->margin.left == margin)
-    return;
-
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_LEFT],
                                     info->margin.left,
                                     margin);
@@ -18557,10 +18547,6 @@ clutter_actor_set_margin_right (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
-
-  if (info->margin.right == margin)
-    return;
-
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_RIGHT],
                                     info->margin.right,
                                     margin);

clutter/clutter/clutter-actor.h

@@ -236,9 +236,8 @@ struct _ClutterActorClass
   void (* pick)                 (ClutterActor          *actor,
                                  const ClutterColor    *color);
 
-  gboolean (* queue_redraw)     (ClutterActor          *actor,
-                                 ClutterActor          *leaf_that_queued,
-                                 ClutterPaintVolume    *paint_volume);
+  void (* queue_redraw)         (ClutterActor          *actor,
+                                 ClutterActor          *leaf_that_queued);
 
   /* size negotiation */
   void (* get_preferred_width)  (ClutterActor           *self,

clutter/clutter/clutter-animatable.c

@@ -30,7 +30,7 @@
  * to control how a #ClutterAnimation will animate a property.
  *
  * Each #ClutterAnimatable should implement the
- * #ClutterAnimatableInterface.interpolate_property() virtual function of the
+ * #ClutterAnimatableIface.interpolate_property() virtual function of the
  * interface to compute the animation state between two values of an interval
  * depending on a progress factor, expressed as a floating point value.
  *
@@ -57,6 +57,7 @@
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"
 
+typedef ClutterAnimatableIface  ClutterAnimatableInterface;
 G_DEFINE_INTERFACE (ClutterAnimatable, clutter_animatable, G_TYPE_OBJECT);
 
 static void
@@ -100,7 +101,7 @@ clutter_animatable_animate_property (ClutterAnimatable *animatable,
                                      gdouble            progress,
                                      GValue            *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
   gboolean res;
 
   g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
@@ -154,7 +155,7 @@ GParamSpec *
 clutter_animatable_find_property (ClutterAnimatable *animatable,
                                   const gchar       *property_name)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), NULL);
   g_return_val_if_fail (property_name != NULL, NULL);
@@ -184,7 +185,7 @@ clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                       const gchar       *property_name,
                                       GValue            *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
 
   g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
   g_return_if_fail (property_name != NULL);
@@ -213,7 +214,7 @@ clutter_animatable_set_final_state (ClutterAnimatable *animatable,
                                     const gchar       *property_name,
                                     const GValue      *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
 
   g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
   g_return_if_fail (property_name != NULL);
@@ -259,7 +260,7 @@ clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                       gdouble            progress,
                                       GValue            *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
   g_return_val_if_fail (property_name != NULL, FALSE);

clutter/clutter/clutter-animatable.h

@@ -33,15 +33,24 @@
 
 G_BEGIN_DECLS
 
-#define CLUTTER_TYPE_ANIMATABLE (clutter_animatable_get_type ())
+#define CLUTTER_TYPE_ANIMATABLE                 (clutter_animatable_get_type ())
+#define CLUTTER_ANIMATABLE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ANIMATABLE, ClutterAnimatable))
+#define CLUTTER_IS_ANIMATABLE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ANIMATABLE))
+#define CLUTTER_ANIMATABLE_GET_IFACE(obj)       (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_ANIMATABLE, ClutterAnimatableIface))
 
-CLUTTER_EXPORT
-G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
-                     CLUTTER, ANIMATABLE,
-                     GObject)
+typedef struct _ClutterAnimatableIface          ClutterAnimatableIface;
 
 /**
- * ClutterAnimatableInterface:
+ * ClutterAnimatable:
+ *
+ * #ClutterAnimatable is an opaque structure whose members cannot be directly
+ * accessed
+ *
+ * Since: 1.0
+ */
+
+/**
+ * ClutterAnimatableIface:
  * @animate_property: virtual function for custom interpolation of a
  *   property. This virtual function is deprecated
  * @find_property: virtual function for retrieving the #GParamSpec of
@@ -58,7 +67,7 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
  *
  * Since: 1.0
  */
-struct _ClutterAnimatableInterface
+struct _ClutterAnimatableIface
 {
   /*< private >*/
   GTypeInterface parent_iface;
@@ -86,6 +95,9 @@ struct _ClutterAnimatableInterface
                                      GValue            *value);
 };
 
+CLUTTER_EXPORT
+GType clutter_animatable_get_type (void) G_GNUC_CONST;
+
 CLUTTER_EXPORT
 GParamSpec *clutter_animatable_find_property     (ClutterAnimatable *animatable,
                                                   const gchar       *property_name);

clutter/clutter/clutter-autocleanups.h

@@ -34,6 +34,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActor, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActorMeta, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAlignConstraint, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAnimatable, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBackend, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBindConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBindingPool, g_object_unref)
@@ -48,6 +49,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterClone, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterColorizeEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterContainer, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterContent, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDeformEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDesaturateEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDeviceManager, g_object_unref)

clutter/clutter/clutter-backend-private.h

@@ -24,7 +24,6 @@
 
 #include <clutter/clutter-backend.h>
 #include <clutter/clutter-device-manager.h>
-#include <clutter/clutter-keymap.h>
 #include <clutter/clutter-stage-window.h>
 
 #include "clutter-event-translator.h"
@@ -61,8 +60,6 @@ struct _ClutterBackend
   GList *event_translators;
 
   ClutterInputMethod *input_method;
-
-  ClutterKeymap *keymap;
 };
 
 struct _ClutterBackendClass
@@ -107,8 +104,6 @@ struct _ClutterBackendClass
 
   void                  (* bell_notify)          (ClutterBackend   *backend);
 
-  ClutterKeymap *       (* get_keymap)           (ClutterBackend   *backend);
-
   /* signals */
   void (* resolution_changed) (ClutterBackend *backend);
   void (* font_changed)       (ClutterBackend *backend);

clutter/clutter/clutter-backend.c

@@ -53,6 +53,9 @@
 #include "clutter-stage-window.h"
 #include "clutter-device-manager-private.h"
 
+#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
+#include "deprecated/clutter-backend.h"
+
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include "wayland/clutter-wayland-compositor.h"
 #endif
@@ -427,7 +430,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");
@@ -574,18 +577,6 @@ clutter_backend_real_get_device_manager (ClutterBackend *backend)
   return backend->device_manager;
 }
 
-static ClutterKeymap *
-clutter_backend_real_get_keymap (ClutterBackend *backend)
-{
-  if (G_UNLIKELY (backend->keymap == NULL))
-    {
-      g_critical ("No keymap available, expect broken keyboard input");
-      return NULL;
-    }
-
-  return backend->keymap;
-}
-
 static gboolean
 clutter_backend_real_translate_event (ClutterBackend *backend,
                                       gpointer        native,
@@ -684,7 +675,6 @@ clutter_backend_class_init (ClutterBackendClass *klass)
   klass->translate_event = clutter_backend_real_translate_event;
   klass->create_context = clutter_backend_real_create_context;
   klass->get_features = clutter_backend_real_get_features;
-  klass->get_keymap = clutter_backend_real_get_keymap;
 }
 
 static void
@@ -900,6 +890,129 @@ clutter_get_default_backend (void)
   return clutter_context->backend;
 }
 
+/**
+ * clutter_backend_set_double_click_time:
+ * @backend: a #ClutterBackend
+ * @msec: milliseconds between two button press events
+ *
+ * Sets the maximum time between two button press events, used to
+ * verify whether it's a double click event or not.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
+ */
+void
+clutter_backend_set_double_click_time (ClutterBackend *backend,
+                                       guint           msec)
+{
+  ClutterSettings *settings = clutter_settings_get_default ();
+
+  g_object_set (settings, "double-click-time", msec, NULL);
+}
+
+/**
+ * clutter_backend_get_double_click_time:
+ * @backend: a #ClutterBackend
+ *
+ * Gets the maximum time between two button press events, as set
+ * by clutter_backend_set_double_click_time().
+ *
+ * Return value: a time in milliseconds
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
+ */
+guint
+clutter_backend_get_double_click_time (ClutterBackend *backend)
+{
+  ClutterSettings *settings = clutter_settings_get_default ();
+  gint retval;
+
+  g_object_get (settings, "double-click-time", &retval, NULL);
+
+  return retval;
+}
+
+/**
+ * clutter_backend_set_double_click_distance:
+ * @backend: a #ClutterBackend
+ * @distance: a distance, in pixels
+ *
+ * Sets the maximum distance used to verify a double click event.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
+ */
+void
+clutter_backend_set_double_click_distance (ClutterBackend *backend,
+                                           guint           distance)
+{
+  ClutterSettings *settings = clutter_settings_get_default ();
+
+  g_object_set (settings, "double-click-distance", distance, NULL);
+}
+
+/**
+ * clutter_backend_get_double_click_distance:
+ * @backend: a #ClutterBackend
+ *
+ * Retrieves the distance used to verify a double click event
+ *
+ * Return value: a distance, in pixels.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
+ */
+guint
+clutter_backend_get_double_click_distance (ClutterBackend *backend)
+{
+  ClutterSettings *settings = clutter_settings_get_default ();
+  gint retval;
+
+  g_object_get (settings, "double-click-distance", &retval, NULL);
+
+  return retval;
+}
+
+/**
+ * clutter_backend_set_resolution:
+ * @backend: a #ClutterBackend
+ * @dpi: the resolution in "dots per inch" (Physical inches aren't
+ *   actually involved; the terminology is conventional).
+ *
+ * Sets the resolution for font handling on the screen. This is a
+ * scale factor between points specified in a #PangoFontDescription
+ * and cairo units. The default value is 96, meaning that a 10 point
+ * font will be 13 units high. (10 * 96. / 72. = 13.3).
+ *
+ * Applications should never need to call this function.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:font-dpi instead
+ */
+void
+clutter_backend_set_resolution (ClutterBackend *backend,
+                                gdouble         dpi)
+{
+  ClutterSettings *settings;
+  gint resolution;
+
+  g_return_if_fail (CLUTTER_IS_BACKEND (backend));
+
+  if (dpi < 0)
+    resolution = -1;
+  else
+    resolution = dpi * 1024;
+
+  settings = clutter_settings_get_default ();
+  g_object_set (settings, "font-dpi", resolution, NULL);
+}
+
 /**
  * clutter_backend_get_resolution:
  * @backend: a #ClutterBackend
@@ -1005,6 +1118,61 @@ clutter_backend_get_font_options (ClutterBackend *backend)
   return backend->font_options;
 }
 
+/**
+ * clutter_backend_set_font_name:
+ * @backend: a #ClutterBackend
+ * @font_name: the name of the font
+ *
+ * Sets the default font to be used by Clutter. The @font_name string
+ * must either be %NULL, which means that the font name from the
+ * default #ClutterBackend will be used; or be something that can
+ * be parsed by the pango_font_description_from_string() function.
+ *
+ * Since: 1.0
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:font-name instead
+ */
+void
+clutter_backend_set_font_name (ClutterBackend *backend,
+                               const gchar    *font_name)
+{
+  ClutterSettings *settings = clutter_settings_get_default ();
+
+  g_object_set (settings, "font-name", font_name, NULL);
+}
+
+/**
+ * clutter_backend_get_font_name:
+ * @backend: a #ClutterBackend
+ *
+ * Retrieves the default font name as set by
+ * clutter_backend_set_font_name().
+ *
+ * Return value: the font name for the backend. The returned string is
+ *   owned by the #ClutterBackend and should never be modified or freed
+ *
+ * Since: 1.0
+ *
+ * Deprecated: 1.4: Use #ClutterSettings:font-name instead
+ */
+const gchar *
+clutter_backend_get_font_name (ClutterBackend *backend)
+{
+  ClutterSettings *settings;
+
+  g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
+
+  settings = clutter_settings_get_default ();
+
+  /* XXX yuck. but we return a const pointer, so we need to
+   * store it in the backend
+   */
+  g_free (backend->font_name);
+  g_object_get (settings, "font-name", &backend->font_name, NULL);
+
+  return backend->font_name;
+}
+
 gint32
 _clutter_backend_get_units_serial (ClutterBackend *backend)
 {
@@ -1231,17 +1399,3 @@ clutter_backend_set_input_method (ClutterBackend     *backend,
 {
   g_set_object (&backend->input_method, method);
 }
-
-/**
- * clutter_backend_get_keymap:
- * @backend: the #ClutterBackend
- *
- * Gets the keymap used by Clutter
- *
- * Returns: (transfer none): the keymap
- **/
-ClutterKeymap *
-clutter_backend_get_keymap (ClutterBackend *backend)
-{
-  return CLUTTER_BACKEND_GET_CLASS (backend)->get_keymap (backend);
-}

clutter/clutter/clutter-backend.h

@@ -34,7 +34,6 @@
 #include <cogl/cogl.h>
 
 #include <clutter/clutter-config.h>
-#include <clutter/clutter-keymap.h>
 #include <clutter/clutter-types.h>
 
 G_BEGIN_DECLS
@@ -84,9 +83,6 @@ ClutterInputMethod *            clutter_backend_get_input_method        (Clutter
 CLUTTER_EXPORT
 void                            clutter_backend_set_input_method        (ClutterBackend             *backend,
                                                                          ClutterInputMethod         *method);
-CLUTTER_EXPORT
-ClutterKeymap *                 clutter_backend_get_keymap              (ClutterBackend             *backend);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_BACKEND_H__ */

clutter/clutter/clutter-bezier.h

@@ -36,7 +36,7 @@ G_BEGIN_DECLS
 
 typedef struct _ClutterBezier ClutterBezier;
 
-ClutterBezier *_clutter_bezier_new (void);
+ClutterBezier *_clutter_bezier_new ();
 
 void           _clutter_bezier_free (ClutterBezier * b);
 

clutter/clutter/clutter-blur-effect.c

@@ -160,7 +160,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 +169,11 @@ clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
-                                   self->pipeline,
-                                   0, 0,
-                                   self->tex_width, self->tex_height);
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
+
+  cogl_pop_source ();
 }
 
 static gboolean

clutter/clutter/clutter-box-layout.c

@@ -150,9 +150,9 @@ typedef struct _RequestedSize
   gfloat natural_size;
 } RequestedSize;
 
-static float distribute_natural_allocation (float          extra_space,
-                                            unsigned int   n_requested_sizes,
-                                            RequestedSize *sizes);
+static gint distribute_natural_allocation (gint                  extra_space,
+					   guint                 n_requested_sizes,
+					   RequestedSize        *sizes);
 static void count_expand_children         (ClutterLayoutManager *layout,
 					   ClutterContainer     *container,
 					   gint                 *visible_children,
@@ -624,19 +624,7 @@ get_preferred_size_for_opposite_orientation (ClutterBoxLayout   *self,
   else
     {
       /* Bring children up to size first */
-      if (isnormal (size) || size == 0)
-        {
-          size = distribute_natural_allocation (MAX (0, size),
-                                                nvis_children,
-                                                sizes);
-        }
-      else
-        {
-          g_critical ("Actor %s (%p) received the invalid "
-                      "value %f as minimum/natural size\n",
-                       G_OBJECT_TYPE_NAME (container), container, size);
-          size = 0;
-        }
+      size = distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
 
       /* Calculate space which hasn't distributed yet,
        * and is available for expanding children.
@@ -891,18 +879,17 @@ compare_gap (gconstpointer p1,
  *
  * Pulled from gtksizerequest.c from Gtk+
  */
-static float
-distribute_natural_allocation (float          extra_space,
-                               unsigned int   n_requested_sizes,
+static gint
+distribute_natural_allocation (gint           extra_space,
+                               guint          n_requested_sizes,
                                RequestedSize *sizes)
 {
-  unsigned int *spreading;
-  int i;
+  guint *spreading;
+  gint   i;
 
-  g_return_val_if_fail (isnormal (extra_space) || extra_space == 0, 0);
   g_return_val_if_fail (extra_space >= 0, 0);
 
-  spreading = g_newa (unsigned int, n_requested_sizes);
+  spreading = g_newa (guint, n_requested_sizes);
 
   for (i = 0; i < n_requested_sizes; i++)
     spreading[i] = i;
@@ -926,7 +913,7 @@ distribute_natural_allocation (float          extra_space,
 
   /* Sort descending by gap and position. */
   g_qsort_with_data (spreading,
-                     n_requested_sizes, sizeof (unsigned int),
+                     n_requested_sizes, sizeof (guint),
                      compare_gap, sizes);
 
   /* Distribute available space.
@@ -938,11 +925,11 @@ distribute_natural_allocation (float          extra_space,
        * Sort order and reducing remaining space by assigned space
        * ensures that space is distributed equally.
        */
-      int glue = (extra_space + i) / (i + 1);
-      int gap = sizes[(spreading[i])].natural_size
-              - sizes[(spreading[i])].minimum_size;
+      gint glue = (extra_space + i) / (i + 1);
+      gint gap = sizes[(spreading[i])].natural_size
+               - sizes[(spreading[i])].minimum_size;
 
-      int extra = MIN (glue, gap);
+      gint extra = MIN (glue, gap);
 
       sizes[spreading[i]].minimum_size += extra;
 
@@ -1069,9 +1056,7 @@ clutter_box_layout_allocate (ClutterLayoutManager   *layout,
   else
     {
       /* Bring children up to size first */
-      size = (gint) distribute_natural_allocation (MAX (0, (float) size),
-                                                   nvis_children,
-                                                   sizes);
+      size = distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
 
       /* Calculate space which hasn't distributed yet,
        * and is available for expanding children.

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

@@ -178,7 +178,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 +189,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,
-                                   self->pipeline,
-                                   0, 0,
-                                   self->tex_width, self->tex_height);
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
+
+  cogl_pop_source ();
 }
 
 static void

clutter/clutter/clutter-canvas.c

@@ -97,7 +97,7 @@ enum
 
 static guint canvas_signals[LAST_SIGNAL] = { 0, };
 
-static void clutter_content_iface_init (ClutterContentInterface *iface);
+static void clutter_content_iface_init (ClutterContentIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (ClutterCanvas, clutter_canvas, G_TYPE_OBJECT,
                          G_ADD_PRIVATE (ClutterCanvas)
@@ -457,7 +457,7 @@ clutter_canvas_get_preferred_size (ClutterContent *content,
 }
 
 static void
-clutter_content_iface_init (ClutterContentInterface *iface)
+clutter_content_iface_init (ClutterContentIface *iface)
 {
   iface->invalidate = clutter_canvas_invalidate;
   iface->paint_content = clutter_canvas_paint_content;

clutter/clutter/clutter-colorize-effect.c

@@ -148,7 +148,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 +159,11 @@ clutter_colorize_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
-                                   self->pipeline,
-                                   0, 0,
-                                   self->tex_width, self->tex_height);
+  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
+
+  cogl_pop_source ();
 }
 
 static void

clutter/clutter/clutter-constraint.c

@@ -43,7 +43,7 @@
  *
  * Constraints can be used with fixed layout managers, like
  * #ClutterFixedLayout, or with actors implicitly using a fixed layout
- * manager, like #ClutterGroup and #ClutterStage.
+ * manager, like #ClutterStage.
  *
  * Constraints provide a way to build user interfaces by using
  * relations between #ClutterActors, without explicit fixed

clutter/clutter/clutter-content.c

@@ -38,13 +38,14 @@
 
 #include "clutter-build-config.h"
 
-#include "clutter-actor-private.h"
 #include "clutter-content-private.h"
 
 #include "clutter-debug.h"
 #include "clutter-marshal.h"
 #include "clutter-private.h"
 
+typedef struct _ClutterContentIface     ClutterContentInterface;
+
 enum
 {
   ATTACHED,
@@ -90,11 +91,6 @@ clutter_content_real_invalidate (ClutterContent *content)
 {
 }
 
-static void
-clutter_content_real_invalidate_size (ClutterContent *content)
-{
-}
-
 static void
 clutter_content_real_paint_content (ClutterContent   *content,
                                     ClutterActor     *actor,
@@ -112,7 +108,6 @@ clutter_content_default_init (ClutterContentInterface *iface)
   iface->attached = clutter_content_real_attached;
   iface->detached = clutter_content_real_detached;
   iface->invalidate = clutter_content_real_invalidate;
-  iface->invalidate_size = clutter_content_real_invalidate_size;
 
   /**
    * ClutterContent::attached:
@@ -128,7 +123,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
     g_signal_new (I_("attached"),
                   G_TYPE_FROM_INTERFACE (iface),
                   G_SIGNAL_RUN_FIRST,
-                  G_STRUCT_OFFSET (ClutterContentInterface, attached),
+                  G_STRUCT_OFFSET (ClutterContentIface, attached),
                   NULL, NULL,
                   _clutter_marshal_VOID__OBJECT,
                   G_TYPE_NONE, 1,
@@ -148,7 +143,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
     g_signal_new (I_("detached"),
                   G_TYPE_FROM_INTERFACE (iface),
                   G_SIGNAL_RUN_FIRST,
-                  G_STRUCT_OFFSET (ClutterContentInterface, detached),
+                  G_STRUCT_OFFSET (ClutterContentIface, detached),
                   NULL, NULL,
                   _clutter_marshal_VOID__OBJECT,
                   G_TYPE_NONE, 1,
@@ -193,45 +188,6 @@ clutter_content_invalidate (ClutterContent *content)
     }
 }
 
-/**
- * clutter_content_invalidate_size:
- * @content: a #ClutterContent
- *
- * Signals that @content's size changed. Attached actors with request mode
- * set to %CLUTTER_REQUEST_CONTENT_SIZE will have a relayout queued.
- *
- * Attached actors with other request modes are not redrawn. To redraw them
- * too, use clutter_content_invalidate().
- */
-void
-clutter_content_invalidate_size (ClutterContent *content)
-{
-  ClutterActor *actor;
-  GHashTable *actors;
-  GHashTableIter iter;
-
-  g_return_if_fail (CLUTTER_IS_CONTENT (content));
-
-  CLUTTER_CONTENT_GET_IFACE (content)->invalidate_size (content);
-
-  actors = g_object_get_qdata (G_OBJECT (content), quark_content_actors);
-  if (actors == NULL)
-    return;
-
-  g_hash_table_iter_init (&iter, actors);
-  while (g_hash_table_iter_next (&iter, (gpointer *) &actor, NULL))
-    {
-      ClutterRequestMode request_mode;
-
-      g_assert (actor != NULL);
-
-      request_mode = clutter_actor_get_request_mode (actor);
-
-      if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
-        _clutter_actor_queue_only_relayout (actor);
-    }
-}
-
 /*< private >
  * _clutter_content_attached:
  * @content: a #ClutterContent
@@ -243,7 +199,7 @@ clutter_content_invalidate_size (ClutterContent *content)
  * is associated to a #ClutterContent, to set up a backpointer from
  * the @content to the @actor.
  *
- * This function will invoke the #ClutterContentInterface.attached() virtual
+ * This function will invoke the #ClutterContentIface.attached() virtual
  * function.
  */
 void
@@ -277,7 +233,7 @@ _clutter_content_attached (ClutterContent *content,
  * This function should be used internally every time a #ClutterActor
  * removes the association with a #ClutterContent.
  *
- * This function will invoke the #ClutterContentInterface.detached() virtual
+ * This function will invoke the #ClutterContentIface.detached() virtual
  * function.
  */
 void
@@ -306,7 +262,7 @@ _clutter_content_detached (ClutterContent *content,
  *
  * Creates the render tree for the @content and @actor.
  *
- * This function will invoke the #ClutterContentInterface.paint_content()
+ * This function will invoke the #ClutterContentIface.paint_content()
  * virtual function.
  */
 void

clutter/clutter/clutter-content.h

@@ -33,13 +33,24 @@
 
 G_BEGIN_DECLS
 
-#define CLUTTER_TYPE_CONTENT (clutter_content_get_type ())
+#define CLUTTER_TYPE_CONTENT            (clutter_content_get_type ())
+#define CLUTTER_CONTENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CONTENT, ClutterContent))
+#define CLUTTER_IS_CONTENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CONTENT))
+#define CLUTTER_CONTENT_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_CONTENT, ClutterContentIface))
 
-CLUTTER_EXPORT
-G_DECLARE_INTERFACE (ClutterContent, clutter_content, CLUTTER, CONTENT, GObject)
+typedef struct _ClutterContentIface     ClutterContentIface;
 
 /**
- * ClutterContentInterface:
+ * ClutterContent:
+ *
+ * The #ClutterContent structure is an opaque type
+ * whose members cannot be acccessed directly.
+ *
+ * Since: 1.10
+ */
+
+/**
+ * ClutterContentIface:
  * @get_preferred_size: virtual function; should be overridden by subclasses
  *   of #ClutterContent that have a natural size
  * @paint_content: virtual function; called each time the content needs to
@@ -51,12 +62,12 @@ G_DECLARE_INTERFACE (ClutterContent, clutter_content, CLUTTER, CONTENT, GObject)
  * @invalidate: virtual function; called each time a #ClutterContent state
  *   is changed.
  *
- * The #ClutterContentInterface structure contains only
+ * The #ClutterContentIface structure contains only
  * private data.
  *
  * Since: 1.10
  */
-struct _ClutterContentInterface
+struct _ClutterContentIface
 {
   /*< private >*/
   GTypeInterface g_iface;
@@ -75,10 +86,11 @@ struct _ClutterContentInterface
                                          ClutterActor     *actor);
 
   void          (* invalidate)          (ClutterContent   *content);
-
-  void          (* invalidate_size)     (ClutterContent   *content);
 };
 
+CLUTTER_EXPORT
+GType clutter_content_get_type (void) G_GNUC_CONST;
+
 CLUTTER_EXPORT
 gboolean        clutter_content_get_preferred_size      (ClutterContent *content,
                                                          gfloat         *width,
@@ -86,9 +98,6 @@ gboolean        clutter_content_get_preferred_size      (ClutterContent *content
 CLUTTER_EXPORT
 void            clutter_content_invalidate              (ClutterContent *content);
 
-CLUTTER_EXPORT
-void            clutter_content_invalidate_size         (ClutterContent *content);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_CONTENT_H__ */

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_DAMAGE_REGION     = 1 << 8,
+  CLUTTER_DEBUG_PAINT_DEFORM_TILES      = 1 << 7
 } ClutterDrawDebugFlag;
 
 #ifdef CLUTTER_ENABLE_DEBUG
@@ -80,9 +79,9 @@ extern guint clutter_pick_debug_flags;
 extern guint clutter_paint_debug_flags;
 
 void    _clutter_debug_messagev         (const char *format,
-                                         va_list     var_args) G_GNUC_PRINTF (1, 0);
+                                         va_list     var_args);
 void    _clutter_debug_message          (const char *format,
-                                         ...) G_GNUC_PRINTF (1, 2);
+                                         ...);
 
 G_END_DECLS
 

clutter/clutter/clutter-deprecated.h

@@ -7,6 +7,7 @@
 #include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"
+#include "deprecated/clutter-backend.h"
 #include "deprecated/clutter-behaviour.h"
 #include "deprecated/clutter-behaviour-depth.h"
 #include "deprecated/clutter-behaviour-ellipse.h"
@@ -15,23 +16,17 @@
 #include "deprecated/clutter-behaviour-rotate.h"
 #include "deprecated/clutter-behaviour-scale.h"
 #include "deprecated/clutter-bin-layout.h"
-#include "deprecated/clutter-box.h"
 #include "deprecated/clutter-cairo-texture.h"
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-group.h"
 #include "deprecated/clutter-input-device.h"
 #include "deprecated/clutter-keysyms.h"
-#include "deprecated/clutter-list-model.h"
 #include "deprecated/clutter-main.h"
-#include "deprecated/clutter-model.h"
 #include "deprecated/clutter-rectangle.h"
-#include "deprecated/clutter-shader.h"
 #include "deprecated/clutter-stage-manager.h"
 #include "deprecated/clutter-stage.h"
-#include "deprecated/clutter-state.h"
-#include "deprecated/clutter-table-layout.h"
 #include "deprecated/clutter-texture.h"
 #include "deprecated/clutter-timeline.h"
+#include "deprecated/clutter-util.h"
 
 #undef __CLUTTER_DEPRECATED_H_INSIDE__
 

clutter/clutter/clutter-desaturate-effect.c

@@ -155,7 +155,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 +170,13 @@ clutter_desaturate_effect_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_push_source (self->pipeline);
 
-  cogl_framebuffer_draw_rectangle (framebuffer,
-                                   self->pipeline,
-                                   0, 0,
-                                   cogl_texture_get_width (texture),
-                                   cogl_texture_get_height (texture));
+  cogl_rectangle (0, 0,
+                  cogl_texture_get_width (texture),
+                  cogl_texture_get_height (texture));
+
+  cogl_pop_source ();
 }
 
 static void

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-enums.h

@@ -884,7 +884,7 @@ typedef enum {
 /**
  * ClutterFeatureFlags:
  * @CLUTTER_FEATURE_TEXTURE_NPOT: Set if NPOTS textures supported.
- * @CLUTTER_FEATURE_SWAP_THROTTLE: Set if backend throttles buffer swaps.
+ * @CLUTTER_FEATURE_SYNC_TO_VBLANK: Set if vblank syncing supported.
  * @CLUTTER_FEATURE_TEXTURE_YUV: Set if YUV based textures supported.
  * @CLUTTER_FEATURE_TEXTURE_READ_PIXELS: Set if texture pixels can be read.
  * @CLUTTER_FEATURE_STAGE_STATIC: Set if stage size if fixed (i.e framebuffer)
@@ -903,7 +903,7 @@ typedef enum {
 typedef enum
 {
   CLUTTER_FEATURE_TEXTURE_NPOT           = (1 << 2),
-  CLUTTER_FEATURE_SWAP_THROTTLE          = (1 << 3),
+  CLUTTER_FEATURE_SYNC_TO_VBLANK         = (1 << 3),
   CLUTTER_FEATURE_TEXTURE_YUV            = (1 << 4),
   CLUTTER_FEATURE_TEXTURE_READ_PIXELS    = (1 << 5),
   CLUTTER_FEATURE_STAGE_STATIC           = (1 << 6),

clutter/clutter/clutter-event.c

@@ -1093,7 +1093,7 @@ clutter_event_set_device (ClutterEvent       *event,
     {
       ClutterEventPrivate *real_event = (ClutterEventPrivate *) event;
 
-      g_set_object (&real_event->device, device);
+      real_event->device = device;
     }
 
   switch (event->type)
@@ -1362,8 +1362,8 @@ clutter_event_copy (const ClutterEvent *event)
     {
       ClutterEventPrivate *real_event = (ClutterEventPrivate *) event;
 
-      g_set_object (&new_real_event->device, real_event->device);
-      g_set_object (&new_real_event->source_device, real_event->source_device);
+      new_real_event->device = real_event->device;
+      new_real_event->source_device = real_event->source_device;
       new_real_event->delta_x = real_event->delta_x;
       new_real_event->delta_y = real_event->delta_y;
       new_real_event->is_pointer_emulated = real_event->is_pointer_emulated;
@@ -1433,14 +1433,6 @@ clutter_event_free (ClutterEvent *event)
     {
       _clutter_backend_free_event_data (clutter_get_default_backend (), event);
 
-      if (is_event_allocated (event))
-        {
-          ClutterEventPrivate *real_event = (ClutterEventPrivate *) event;
-
-          g_clear_object (&real_event->device);
-          g_clear_object (&real_event->source_device);
-        }
-
       switch (event->type)
         {
         case CLUTTER_BUTTON_PRESS:
@@ -1695,7 +1687,7 @@ clutter_event_set_source_device (ClutterEvent       *event,
     return;
 
   real_event = (ClutterEventPrivate *) event;
-  g_set_object (&real_event->source_device, device);
+  real_event->source_device = device;
 }
 
 /**

clutter/clutter/clutter-event.h

@@ -772,10 +772,7 @@ void                    clutter_event_get_gesture_motion_delta       (const Clut
                                                                       gdouble                *dx,
                                                                       gdouble                *dy);
 
-CLUTTER_EXPORT
 ClutterScrollSource      clutter_event_get_scroll_source             (const ClutterEvent     *event);
-
-CLUTTER_EXPORT
 ClutterScrollFinishFlags clutter_event_get_scroll_finish_flags       (const ClutterEvent     *event);
 
 CLUTTER_EXPORT

clutter/clutter/clutter-group.h

@@ -1,96 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *
- * Copyright (C) 2006 OpenedHand
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __CLUTTER_GROUP_H__
-#define __CLUTTER_GROUP_H__
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#include <glib-object.h>
-#include <clutter/clutter-types.h>
-#include <clutter/clutter-actor.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_GROUP              (clutter_group_get_type ())
-#define CLUTTER_GROUP(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GROUP, ClutterGroup))
-#define CLUTTER_GROUP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_GROUP, ClutterGroupClass))
-#define CLUTTER_IS_GROUP(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GROUP))
-#define CLUTTER_IS_GROUP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_GROUP))
-#define CLUTTER_GROUP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_GROUP, ClutterGroupClass))
-
-/* XXX - ClutterGroup is to be considered fully deprecated; the only
- * reason we keep this header is because ClutterStage inherits from
- * ClutterGroup, and thus we need to have a structure definition for
- * the Stage object to expand.
- */
-
-typedef struct _ClutterGroup            ClutterGroup;
-typedef struct _ClutterGroupClass       ClutterGroupClass;
-typedef struct _ClutterGroupPrivate     ClutterGroupPrivate;
-
-/**
- * ClutterGroup:
- *
- * The #ClutterGroup structure contains only private data
- * and should be accessed using the provided API
- *
- * Since: 0.2
- */
-struct _ClutterGroup
-{
-  /*< private >*/
-  ClutterActor parent_instance;
-
-  ClutterGroupPrivate *priv;
-};
-
-/**
- * ClutterGroupClass:
- *
- * The #ClutterGroupClass structure contains only private data
- *
- * Since: 0.2
- */
-struct _ClutterGroupClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-
-  /* padding for future expansion */
-  void (*_clutter_reserved1) (void);
-  void (*_clutter_reserved2) (void);
-  void (*_clutter_reserved3) (void);
-  void (*_clutter_reserved4) (void);
-  void (*_clutter_reserved5) (void);
-  void (*_clutter_reserved6) (void);
-};
-
-CLUTTER_EXPORT
-GType clutter_group_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-#endif /* __CLUTTER_GROUP_H__ */

clutter/clutter/clutter-image.c

@@ -53,11 +53,9 @@
 struct _ClutterImagePrivate
 {
   CoglTexture *texture;
-  gint width;
-  gint height;
 };
 
-static void clutter_content_iface_init (ClutterContentInterface *iface);
+static void clutter_content_iface_init (ClutterContentIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (ClutterImage, clutter_image, G_TYPE_OBJECT,
                          G_ADD_PRIVATE (ClutterImage)
@@ -70,27 +68,6 @@ clutter_image_error_quark (void)
   return g_quark_from_static_string ("clutter-image-error-quark");
 }
 
-static void
-update_image_size (ClutterImage *self)
-{
-  gint width, height;
-
-  if (self->priv->texture == NULL)
-    return;
-
-  width = cogl_texture_get_width (self->priv->texture);
-  height = cogl_texture_get_height (self->priv->texture);
-
-  if (self->priv->width == width &&
-      self->priv->height == height)
-    return;
-
-  self->priv->width = width;
-  self->priv->height = height;
-
-  clutter_content_invalidate_size (CLUTTER_CONTENT (self));
-}
-
 static void
 clutter_image_finalize (GObject *gobject)
 {
@@ -154,7 +131,7 @@ clutter_image_get_preferred_size (ClutterContent *content,
 }
 
 static void
-clutter_content_iface_init (ClutterContentInterface *iface)
+clutter_content_iface_init (ClutterContentIface *iface)
 {
   iface->get_preferred_size = clutter_image_get_preferred_size;
   iface->paint_content = clutter_image_paint_content;
@@ -261,7 +238,6 @@ clutter_image_set_data (ClutterImage     *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
-  update_image_size (image);
 
   return TRUE;
 }
@@ -330,7 +306,6 @@ clutter_image_set_bytes (ClutterImage     *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
-  update_image_size (image);
 
   return TRUE;
 }
@@ -424,7 +399,6 @@ clutter_image_set_area (ClutterImage                 *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
-  update_image_size (image);
 
   return TRUE;
 }

clutter/clutter/clutter-input-device.c

@@ -2284,15 +2284,3 @@ clutter_input_device_is_grouped (ClutterInputDevice *device,
 
   return CLUTTER_INPUT_DEVICE_GET_CLASS (device)->is_grouped (device, other_device);
 }
-
-gboolean
-clutter_input_device_get_physical_size (ClutterInputDevice *device,
-                                        gdouble            *width,
-                                        gdouble            *height)
-{
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
-
-  return CLUTTER_INPUT_DEVICE_GET_CLASS (device)->get_physical_size (device,
-                                                                     width,
-                                                                     height);
-}

clutter/clutter/clutter-input-device.h

@@ -171,10 +171,6 @@ void                      clutter_input_device_set_mapping_mode (ClutterInputDev
 CLUTTER_EXPORT
 gboolean                  clutter_input_device_is_grouped       (ClutterInputDevice *device,
                                                                  ClutterInputDevice *other_device);
-CLUTTER_EXPORT
-gboolean                  clutter_input_device_get_physical_size (ClutterInputDevice *device,
-								  gdouble            *width,
-								  gdouble            *height);
 
 G_END_DECLS
 

clutter/clutter/clutter-keymap.c

@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2018 Red Hat
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * Author: Carlos Garnacho <carlosg@gnome.org>
- */
-
-#include "clutter-build-config.h"
-
-#include "clutter-keymap.h"
-#include "clutter-private.h"
-
-G_DEFINE_ABSTRACT_TYPE (ClutterKeymap, clutter_keymap, G_TYPE_OBJECT)
-
-enum
-{
-  STATE_CHANGED,
-  N_SIGNALS
-};
-
-static guint signals[N_SIGNALS] = { 0, };
-
-static void
-clutter_keymap_class_init (ClutterKeymapClass *klass)
-{
-  signals[STATE_CHANGED] =
-    g_signal_new (I_("state-changed"),
-		  G_TYPE_FROM_CLASS (klass),
-		  G_SIGNAL_RUN_FIRST,
-		  0, NULL, NULL,
-                  g_cclosure_marshal_VOID__VOID,
-		  G_TYPE_NONE, 0);
-}
-
-static void
-clutter_keymap_init (ClutterKeymap *keymap)
-{
-}
-
-gboolean
-clutter_keymap_get_num_lock_state (ClutterKeymap *keymap)
-{
-  return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_num_lock_state (keymap);
-}
-
-gboolean
-clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap)
-{
-  return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_caps_lock_state (keymap);
-}

clutter/clutter/clutter-keymap.h

@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2018 Red Hat
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * Author: Carlos Garnacho <carlosg@gnome.org>
- */
-
-#ifndef CLUTTER_KEYMAP_H
-#define CLUTTER_KEYMAP_H
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#include <clutter/clutter-macros.h>
-
-#include <glib-object.h>
-
-typedef struct _ClutterKeymap ClutterKeymap;
-typedef struct _ClutterKeymapClass ClutterKeymapClass;
-
-struct _ClutterKeymapClass
-{
-  GObjectClass parent_class;
-
-  gboolean (* get_num_lock_state)  (ClutterKeymap *keymap);
-  gboolean (* get_caps_lock_state) (ClutterKeymap *keymap);
-};
-
-#define CLUTTER_TYPE_KEYMAP (clutter_keymap_get_type ())
-CLUTTER_EXPORT
-G_DECLARE_DERIVABLE_TYPE (ClutterKeymap, clutter_keymap,
-			  CLUTTER, KEYMAP,
-			  GObject)
-
-CLUTTER_EXPORT
-gboolean clutter_keymap_get_num_lock_state  (ClutterKeymap *keymap);
-
-CLUTTER_EXPORT
-gboolean clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap);
-
-#endif /* CLUTTER_KEYMAP_H */

clutter/clutter/clutter-main.c

@@ -142,7 +142,6 @@ static const GDebugKey clutter_paint_debug_keys[] = {
   { "disable-offscreen-redirect", CLUTTER_DEBUG_DISABLE_OFFSCREEN_REDIRECT },
   { "continuous-redraw", CLUTTER_DEBUG_CONTINUOUS_REDRAW },
   { "paint-deform-tiles", CLUTTER_DEBUG_PAINT_DEFORM_TILES },
-  { "damage-region", CLUTTER_DEBUG_PAINT_DAMAGE_REGION },
 };
 
 static void
@@ -255,6 +254,16 @@ clutter_config_read_from_key_file (GKeyFile *keyfile)
   else
     clutter_enable_accessibility = bool_value;
 
+  bool_value =
+    g_key_file_get_boolean (keyfile, ENVIRONMENT_GROUP,
+                            "SyncToVblank",
+                            &key_error);
+
+  if (key_error != NULL)
+    g_clear_error (&key_error);
+  else
+    clutter_sync_to_vblank = bool_value;
+
   int_value =
     g_key_file_get_integer (keyfile, ENVIRONMENT_GROUP,
                             "DefaultFps",
@@ -1356,9 +1365,6 @@ clutter_init_real (GError **error)
         CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS | CLUTTER_DEBUG_DISABLE_CULLING;
     }
 
-  if (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION)
-    g_message ("Enabling damaged region");
-
   /* this will take care of initializing Cogl's state and
    * query the GL machinery for features
    */
@@ -1481,6 +1487,10 @@ pre_parse_hook (GOptionContext  *context,
   if (env_string)
     clutter_use_fuzzy_picking = TRUE;
 
+  env_string = g_getenv ("CLUTTER_VBLANK");
+  if (g_strcmp0 (env_string, "none") == 0)
+    clutter_sync_to_vblank = FALSE;
+
   return _clutter_backend_pre_parse (backend, error);
 }
 
@@ -3621,6 +3631,12 @@ _clutter_set_sync_to_vblank (gboolean sync_to_vblank)
   clutter_sync_to_vblank = !!sync_to_vblank;
 }
 
+gboolean
+_clutter_get_sync_to_vblank (void)
+{
+  return clutter_sync_to_vblank;
+}
+
 void
 _clutter_debug_messagev (const char *format,
                          va_list     var_args)

clutter/clutter/clutter-marshal.list

@@ -1,7 +1,6 @@
 BOOLEAN:BOXED
 BOOLEAN:BOXED,INT,INT
 BOOLEAN:OBJECT,BOOLEAN
-BOOLEAN:OBJECT,BOXED
 BOOLEAN:OBJECT,BOXED,DOUBLE
 BOOLEAN:OBJECT,DOUBLE
 BOOLEAN:OBJECT,ENUM

clutter/clutter/clutter-master-clock-default.c

@@ -109,8 +109,7 @@ static GSourceFuncs clock_funcs = {
   NULL
 };
 
-static void
-clutter_master_clock_iface_init (ClutterMasterClockInterface *iface);
+static void clutter_master_clock_iface_init (ClutterMasterClockIface *iface);
 
 #define clutter_master_clock_default_get_type   _clutter_master_clock_default_get_type
 
@@ -299,10 +298,10 @@ master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
    * (NB: if there aren't even any timelines running then the master clock will
    * be completely stopped in master_clock_is_running())
    */
-  if (clutter_feature_available (CLUTTER_FEATURE_SWAP_THROTTLE) &&
+  if (clutter_feature_available (CLUTTER_FEATURE_SYNC_TO_VBLANK) &&
       !master_clock->idle)
     {
-      CLUTTER_NOTE (SCHEDULER, "swap throttling available and updated stages");
+      CLUTTER_NOTE (SCHEDULER, "vblank available and updated stages");
       return 0;
     }
 
@@ -690,7 +689,7 @@ clutter_master_clock_default_set_paused (ClutterMasterClock *clock,
 }
 
 static void
-clutter_master_clock_iface_init (ClutterMasterClockInterface *iface)
+clutter_master_clock_iface_init (ClutterMasterClockIface *iface)
 {
   iface->add_timeline = clutter_master_clock_default_add_timeline;
   iface->remove_timeline = clutter_master_clock_default_remove_timeline;

clutter/clutter/clutter-master-clock.c

@@ -37,6 +37,10 @@
 #include "clutter-master-clock-default.h"
 #include "clutter-private.h"
 
+#define clutter_master_clock_get_type   _clutter_master_clock_get_type
+
+typedef ClutterMasterClockIface ClutterMasterClockInterface;
+
 G_DEFINE_INTERFACE (ClutterMasterClock, clutter_master_clock, G_TYPE_OBJECT)
 
 static void

clutter/clutter/clutter-master-clock.h

@@ -28,12 +28,15 @@
 
 G_BEGIN_DECLS
 
-#define CLUTTER_TYPE_MASTER_CLOCK (clutter_master_clock_get_type ())
-G_DECLARE_INTERFACE (ClutterMasterClock, clutter_master_clock,
-                     CLUTTER, MASTER_CLOCK,
-                     GObject)
+#define CLUTTER_TYPE_MASTER_CLOCK               (_clutter_master_clock_get_type ())
+#define CLUTTER_MASTER_CLOCK(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClock))
+#define CLUTTER_IS_MASTER_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MASTER_CLOCK))
+#define CLUTTER_MASTER_CLOCK_GET_IFACE(obj)     (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockIface))
 
-struct _ClutterMasterClockInterface
+typedef struct _ClutterMasterClock      ClutterMasterClock; /* dummy */
+typedef struct _ClutterMasterClockIface ClutterMasterClockIface;
+
+struct _ClutterMasterClockIface
 {
   /*< private >*/
   GTypeInterface parent_iface;
@@ -48,6 +51,8 @@ struct _ClutterMasterClockInterface
                                    gboolean            paused);
 };
 
+GType _clutter_master_clock_get_type (void) G_GNUC_CONST;
+
 ClutterMasterClock *    _clutter_master_clock_get_default               (void);
 void                    _clutter_master_clock_add_timeline              (ClutterMasterClock *master_clock,
                                                                          ClutterTimeline    *timeline);

clutter/clutter/clutter-mutter.h

@@ -34,6 +34,9 @@
 CLUTTER_EXPORT
 void clutter_set_custom_backend_func (ClutterBackend *(* func) (void));
 
+CLUTTER_EXPORT
+gboolean        _clutter_get_sync_to_vblank     (void);
+
 CLUTTER_EXPORT
 int64_t clutter_stage_get_frame_counter (ClutterStage *stage);
 
@@ -49,9 +52,6 @@ void clutter_stage_freeze_updates (ClutterStage *stage);
 CLUTTER_EXPORT
 void clutter_stage_thaw_updates (ClutterStage *stage);
 
-CLUTTER_EXPORT
-gboolean clutter_actor_has_damage (ClutterActor *actor);
-
 #undef __CLUTTER_H_INSIDE__
 
 #endif /* __CLUTTER_MUTTER_H__ */

clutter/clutter/clutter-offscreen-effect.c

@@ -72,8 +72,6 @@
 #include "clutter-debug.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
-#include "clutter-paint-volume-private.h"
-#include "clutter-actor-box-private.h"
 
 struct _ClutterOffscreenEffectPrivate
 {
@@ -84,10 +82,8 @@ struct _ClutterOffscreenEffectPrivate
   ClutterActor *actor;
   ClutterActor *stage;
 
-  ClutterVertex position;
-
-  int fbo_offset_x;
-  int fbo_offset_y;
+  gfloat x_offset;
+  gfloat y_offset;
 
   /* This is the calculated size of the fbo before being passed
      through create_texture(). This needs to be tracked separately so
@@ -97,6 +93,16 @@ struct _ClutterOffscreenEffectPrivate
   int fbo_height;
 
   gint old_opacity_override;
+
+  /* The matrix that was current the last time the fbo was updated. We
+     need to keep track of this to detect when we can reuse the
+     contents of the fbo without redrawing the actor. We need the
+     actual matrix rather than just detecting queued redraws on the
+     actor because any change in the parent hierarchy (even just a
+     translation) could cause the actor to look completely different
+     and it won't cause a redraw to be queued on the parent's
+     children. */
+  CoglMatrix last_matrix_drawn;
 };
 
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterOffscreenEffect,
@@ -216,15 +222,15 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
-  ClutterActorBox raw_box, box;
+  ClutterActorBox box;
   ClutterActor *stage;
-  CoglMatrix projection, old_modelview, modelview;
-  const ClutterPaintVolume *volume;
+  CoglMatrix projection;
   CoglColor transparent;
   gfloat stage_width, stage_height;
   gfloat fbo_width = -1, fbo_height = -1;
-  ClutterVertex local_offset = { 0.f, 0.f, 0.f };
-  gfloat old_viewport[4];
+  gfloat width, height;
+  gfloat xexpand, yexpand;
+  int texture_width, texture_height;
 
   if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
     return FALSE;
@@ -235,82 +241,92 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
   stage = _clutter_actor_get_stage_internal (priv->actor);
   clutter_actor_get_size (stage, &stage_width, &stage_height);
 
-  /* Get the minimal bounding box for what we want to paint, relative to the
-   * parent of priv->actor. Note that we may actually be painting a clone of
-   * priv->actor so we need to be careful to avoid querying the transformation
-   * of priv->actor (like clutter_actor_get_paint_box would). Just stay in
-   * local coordinates for now...
-   */
-  volume = clutter_actor_get_paint_volume (priv->actor);
-  if (volume)
+  /* The paint box is the bounding box of the actor's paint volume in
+   * stage coordinates. This will give us the size for the framebuffer
+   * we need to redirect its rendering offscreen and its position will
+   * be used to setup an offset viewport */
+  if (clutter_actor_get_paint_box (priv->actor, &box))
     {
-      ClutterPaintVolume mutable_volume;
+      clutter_actor_box_get_size (&box, &fbo_width, &fbo_height);
+      clutter_actor_box_get_origin (&box, &priv->x_offset, &priv->y_offset);
 
-      _clutter_paint_volume_copy_static (volume, &mutable_volume);
-      _clutter_paint_volume_get_bounding_box (&mutable_volume, &raw_box);
-      clutter_paint_volume_free (&mutable_volume);
+      fbo_width = MIN (fbo_width, stage_width);
+      fbo_height = MIN (fbo_height, stage_height);
     }
   else
     {
-      clutter_actor_get_allocation_box (priv->actor, &raw_box);
+      fbo_width = stage_width;
+      fbo_height = stage_height;
     }
 
-  box = raw_box;
-  _clutter_actor_box_enlarge_for_effects (&box);
-
-  priv->fbo_offset_x = box.x1 - raw_box.x1;
-  priv->fbo_offset_y = box.y1 - raw_box.y1;
-
-  clutter_actor_box_get_size (&box, &fbo_width, &fbo_height);
+  if (fbo_width == stage_width)
+    priv->x_offset = 0.0f;
+  if (fbo_height == stage_height)
+    priv->y_offset = 0.0f;
 
   /* First assert that the framebuffer is the right size... */
   if (!update_fbo (effect, fbo_width, fbo_height))
     return FALSE;
 
-  cogl_get_modelview_matrix (&old_modelview);
+  texture_width = cogl_texture_get_width (priv->texture);
+  texture_height = cogl_texture_get_height (priv->texture);
+
+  /* get the current modelview matrix so that we can copy it to the
+   * framebuffer. We also store the matrix that was last used when we
+   * updated the FBO so that we can detect when we don't need to
+   * update the FBO to paint a second time */
+  cogl_get_modelview_matrix (&priv->last_matrix_drawn);
 
   /* let's draw offscreen */
   cogl_push_framebuffer (priv->offscreen);
 
-  /* We don't want the FBO contents to be transformed. That could waste memory
-   * (e.g. during zoom), or result in something that's not rectangular (clipped
-   * incorrectly). So drop the modelview matrix of the current paint chain.
-   * This is fine since paint_texture runs with the same modelview matrix,
-   * so it will come out correctly whenever that is used to put the FBO
-   * contents on screen...
-   */
-  clutter_actor_get_transform (priv->stage, &modelview);
-  cogl_set_modelview_matrix (&modelview);
+  /* Copy the modelview that would have been used if rendering onscreen */
+  cogl_set_modelview_matrix (&priv->last_matrix_drawn);
 
-  /* Save the original viewport for calculating priv->position */
-  _clutter_stage_get_viewport (CLUTTER_STAGE (priv->stage),
-                               &old_viewport[0],
-                               &old_viewport[1],
-                               &old_viewport[2],
-                               &old_viewport[3]);
+  /* Set up the viewport so that it has the same size as the stage,
+   * but offset it so that the actor of interest lands on our
+   * framebuffer. */
+  clutter_actor_get_size (priv->stage, &width, &height);
 
-  /* Set up the viewport so that it has the same size as the stage (avoid
-   * distortion), but translated to account for the FBO offset...
+  /* Expand the viewport if the actor is partially off-stage,
+   * otherwise the actor will end up clipped to the stage viewport
    */
-  cogl_set_viewport (-priv->fbo_offset_x,
-                     -priv->fbo_offset_y,
-                     stage_width,
-                     stage_height);
+  xexpand = 0.f;
+  if (priv->x_offset < 0.f)
+    xexpand = -priv->x_offset;
+  if (priv->x_offset + texture_width > width)
+    xexpand = MAX (xexpand, (priv->x_offset + texture_width) - width);
+
+  yexpand = 0.f;
+  if (priv->y_offset < 0.f)
+    yexpand = -priv->y_offset;
+  if (priv->y_offset + texture_height > height)
+    yexpand = MAX (yexpand, (priv->y_offset + texture_height) - height);
+
+  /* Set the viewport */
+  cogl_set_viewport (-(priv->x_offset + xexpand), -(priv->y_offset + yexpand),
+                     width + (2 * xexpand), height + (2 * yexpand));
 
   /* Copy the stage's projection matrix across to the framebuffer */
   _clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
                                         &projection);
 
-  /* Now save the global position of the effect (not just of the actor).
-   * It doesn't appear anyone actually uses this yet, but get_target_rect is
-   * documented as returning it. So we should...
+  /* If we've expanded the viewport, make sure to scale the projection
+   * matrix accordingly (as it's been initialised to work with the
+   * original viewport and not our expanded one).
    */
-  _clutter_util_fully_transform_vertices (&old_modelview,
-                                          &projection,
-                                          old_viewport,
-                                          &local_offset,
-                                          &priv->position,
-                                          1);
+  if (xexpand > 0.f || yexpand > 0.f)
+    {
+      gfloat new_width, new_height;
+
+      new_width = width + (2 * xexpand);
+      new_height = height + (2 * yexpand);
+
+      cogl_matrix_scale (&projection,
+                         width / new_width,
+                         height / new_height,
+                         1);
+    }
 
   cogl_set_projection_matrix (&projection);
 
@@ -336,7 +352,6 @@ static void
 clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect)
 {
   ClutterOffscreenEffectPrivate *priv = effect->priv;
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   guint8 paint_opacity;
 
   paint_opacity = clutter_actor_get_paint_opacity (priv->actor);
@@ -346,19 +361,18 @@ clutter_offscreen_effect_real_paint_target (ClutterOffscreenEffect *effect)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_set_source (priv->target);
 
   /* At this point we are in stage coordinates translated so if
    * we draw our texture using a textured quad the size of the paint
    * box then we will overlay where the actor would have drawn if it
    * hadn't been redirected offscreen.
    */
-  cogl_framebuffer_draw_textured_rectangle (framebuffer,
-                                            priv->target,
-                                            0, 0,
-                                            cogl_texture_get_width (priv->texture),
-                                            cogl_texture_get_height (priv->texture),
-                                            0.0, 0.0,
-                                            1.0, 1.0);
+  cogl_rectangle_with_texture_coords (0, 0,
+                                      cogl_texture_get_width (priv->texture),
+                                      cogl_texture_get_height (priv->texture),
+                                      0.0, 0.0,
+                                      1.0, 1.0);
 }
 
 static void
@@ -369,14 +383,13 @@ clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect)
 
   cogl_push_matrix ();
 
-  /* The current modelview matrix is *almost* perfect already. It's only
-   * missing a correction for the expanded FBO and offset rendering within...
-   */
-  cogl_get_modelview_matrix (&modelview);
-  cogl_matrix_translate (&modelview,
-                         priv->fbo_offset_x,
-                         priv->fbo_offset_y,
-                         0.0f);
+  /* Now reset the modelview to put us in stage coordinates so
+   * we can drawn the result of our offscreen render as a textured
+   * quad... */
+
+  cogl_matrix_init_identity (&modelview);
+  _clutter_actor_apply_modelview_transform (priv->stage, &modelview);
+  cogl_matrix_translate (&modelview, priv->x_offset, priv->y_offset, 0.0f);
   cogl_set_modelview_matrix (&modelview);
 
   /* paint the target material; this is virtualized for
@@ -413,11 +426,16 @@ clutter_offscreen_effect_paint (ClutterEffect           *effect,
 {
   ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
   ClutterOffscreenEffectPrivate *priv = self->priv;
+  CoglMatrix matrix;
 
-  /* If we've already got a cached image and the actor hasn't been redrawn
-   * then we can just use the cached image in the FBO.
-   */
-  if (priv->offscreen == NULL || (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY))
+  cogl_get_modelview_matrix (&matrix);
+
+  /* If we've already got a cached image for the same matrix and the
+     actor hasn't been redrawn then we can just use the cached image
+     in the fbo */
+  if (priv->offscreen == NULL ||
+      (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY) ||
+      !cogl_matrix_equal (&matrix, &priv->last_matrix_drawn))
     {
       /* Chain up to the parent paint method which will call the pre and
          post paint functions to update the image */
@@ -643,8 +661,8 @@ clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
     return FALSE;
 
   clutter_rect_init (rect,
-                     priv->position.x,
-                     priv->position.y,
+                     priv->x_offset,
+                     priv->y_offset,
                      cogl_texture_get_width (priv->texture),
                      cogl_texture_get_height (priv->texture));
 

clutter/clutter/clutter-paint-node-private.h

@@ -77,7 +77,6 @@ struct _ClutterPaintNodeClass
 typedef enum {
   PAINT_OP_INVALID = 0,
   PAINT_OP_TEX_RECT,
-  PAINT_OP_MULTITEX_RECT,
   PAINT_OP_PATH,
   PAINT_OP_PRIMITIVE
 } PaintOpCode;
@@ -86,8 +85,6 @@ struct _ClutterPaintOperation
 {
   PaintOpCode opcode;
 
-  GArray *multitex_coords;
-
   union {
     float texrect[8];
 
@@ -97,6 +94,7 @@ struct _ClutterPaintOperation
   } op;
 };
 
+GType _clutter_root_node_get_type (void) G_GNUC_CONST;
 GType _clutter_transform_node_get_type (void) G_GNUC_CONST;
 GType _clutter_dummy_node_get_type (void) G_GNUC_CONST;
 
@@ -109,9 +107,13 @@ void                    _clutter_paint_operation_paint_primitive        (const C
 void                    _clutter_paint_node_init_types                  (void);
 gpointer                _clutter_paint_node_create                      (GType gtype);
 
+ClutterPaintNode *      _clutter_root_node_new                          (CoglFramebuffer             *framebuffer,
+                                                                         const ClutterColor          *clear_color,
+                                                                         CoglBufferBit                clear_flags);
 ClutterPaintNode *      _clutter_transform_node_new                     (const CoglMatrix            *matrix);
 ClutterPaintNode *      _clutter_dummy_node_new                         (ClutterActor                *actor);
 
+void                    _clutter_paint_node_paint                       (ClutterPaintNode            *root);
 void                    _clutter_paint_node_dump_tree                   (ClutterPaintNode            *root);
 
 G_GNUC_INTERNAL

clutter/clutter/clutter-paint-node.c

@@ -761,11 +761,6 @@ clutter_paint_operation_clear (ClutterPaintOperation *op)
     case PAINT_OP_TEX_RECT:
       break;
 
-    case PAINT_OP_MULTITEX_RECT:
-      if (op->multitex_coords != NULL)
-        g_array_unref (op->multitex_coords);
-      break;
-
     case PAINT_OP_PATH:
       if (op->op.path != NULL)
         cogl_object_unref (op->op.path);
@@ -799,27 +794,6 @@ clutter_paint_op_init_tex_rect (ClutterPaintOperation *op,
   op->op.texrect[7] = y_2;
 }
 
-static inline void
-clutter_paint_op_init_multitex_rect (ClutterPaintOperation *op,
-                                     const ClutterActorBox *rect,
-                                     const float           *tex_coords,
-                                     unsigned int           tex_coords_len)
-{
-  clutter_paint_operation_clear (op);
-
-  op->opcode = PAINT_OP_MULTITEX_RECT;
-  op->multitex_coords = g_array_sized_new (FALSE, FALSE,
-                                           sizeof (float),
-                                           tex_coords_len);
-
-  g_array_append_vals (op->multitex_coords, tex_coords, tex_coords_len);
-
-  op->op.texrect[0] = rect->x1;
-  op->op.texrect[1] = rect->y1;
-  op->op.texrect[2] = rect->x2;
-  op->op.texrect[3] = rect->y2;
-}
-
 static inline void
 clutter_paint_op_init_path (ClutterPaintOperation *op,
                             CoglPath              *path)
@@ -907,33 +881,6 @@ clutter_paint_node_add_texture_rectangle (ClutterPaintNode      *node,
   g_array_append_val (node->operations, operation);
 }
 
-
-/**
- * clutter_paint_node_add_multitexture_rectangle:
- * @node: a #ClutterPaintNode
- * @rect: a #ClutterActorBox
- * @text_coords: array of multitexture values
- * @text_coords_len: number of items of @text_coords
- *
- * Adds a rectangle region to the @node, with multitexture coordinates.
- */
-void
-clutter_paint_node_add_multitexture_rectangle (ClutterPaintNode      *node,
-                                               const ClutterActorBox *rect,
-                                               const float           *text_coords,
-                                               unsigned int           text_coords_len)
-{
-  ClutterPaintOperation operation = PAINT_OP_INIT;
-
-  g_return_if_fail (CLUTTER_IS_PAINT_NODE (node));
-  g_return_if_fail (rect != NULL);
-
-  clutter_paint_node_maybe_init_operations (node);
-
-  clutter_paint_op_init_multitex_rect (&operation, rect, text_coords, text_coords_len);
-  g_array_append_val (node->operations, operation);
-}
-
 /**
  * clutter_paint_node_add_path: (skip)
  * @node: a #ClutterPaintNode
@@ -989,15 +936,15 @@ clutter_paint_node_add_primitive (ClutterPaintNode *node,
   g_array_append_val (node->operations, operation);
 }
 
-/**
- * clutter_paint_node_paint:
+/*< private >
+ * _clutter_paint_node_paint:
  * @node: a #ClutterPaintNode
  *
  * Paints the @node using the class implementation, traversing
  * its children, if any.
  */
 void
-clutter_paint_node_paint (ClutterPaintNode *node)
+_clutter_paint_node_paint (ClutterPaintNode *node)
 {
   ClutterPaintNodeClass *klass = CLUTTER_PAINT_NODE_GET_CLASS (node);
   ClutterPaintNode *iter;
@@ -1014,7 +961,7 @@ clutter_paint_node_paint (ClutterPaintNode *node)
        iter != NULL;
        iter = iter->next_sibling)
     {
-      clutter_paint_node_paint (iter);
+      _clutter_paint_node_paint (iter);
     }
 
   if (res)
@@ -1059,7 +1006,7 @@ clutter_paint_node_to_json (ClutterPaintNode *node)
 
   if (node->operations != NULL)
     {
-      guint i, j;
+      guint i;
 
       for (i = 0; i < node->operations->len; i++)
         {
@@ -1084,19 +1031,6 @@ clutter_paint_node_to_json (ClutterPaintNode *node)
               json_builder_end_array (builder);
               break;
 
-            case PAINT_OP_MULTITEX_RECT:
-              json_builder_set_member_name (builder, "texrect");
-              json_builder_begin_array (builder);
-
-              for (j = 0; i < op->multitex_coords->len; j++)
-                {
-                  float coord = g_array_index (op->multitex_coords, float, j);
-                  json_builder_add_double_value (builder, coord);
-                }
-
-              json_builder_end_array (builder);
-              break;
-
             case PAINT_OP_PATH:
               json_builder_set_member_name (builder, "path");
               json_builder_add_int_value (builder, (gint64) op->op.path);

clutter/clutter/clutter-paint-node.h

@@ -49,9 +49,6 @@ ClutterPaintNode *      clutter_paint_node_ref                          (Clutter
 CLUTTER_EXPORT
 void                    clutter_paint_node_unref                        (ClutterPaintNode      *node);
 
-CLUTTER_EXPORT
-void                    clutter_paint_node_paint                        (ClutterPaintNode      *node);
-
 CLUTTER_EXPORT
 void                    clutter_paint_node_set_name                     (ClutterPaintNode      *node,
                                                                          const char            *name);
@@ -70,12 +67,6 @@ void                    clutter_paint_node_add_texture_rectangle        (Clutter
                                                                          float                  x_2,
                                                                          float                  y_2);
 
-CLUTTER_EXPORT
-void                   clutter_paint_node_add_multitexture_rectangle   (ClutterPaintNode       *node,
-                                                                        const ClutterActorBox  *rect,
-                                                                        const float            *text_coords,
-                                                                        unsigned int            text_coords_len);
-
 CLUTTER_EXPORT
 void                    clutter_paint_node_add_path                     (ClutterPaintNode      *node,
                                                                          CoglPath              *path);

clutter/clutter/clutter-paint-nodes.c

@@ -83,13 +83,16 @@ _clutter_paint_node_init_types (void)
 }
 
 /*
- * Root node
+ * Root node, private
  *
  * any frame can only have a since RootNode instance for each
  * top-level actor.
  */
 
-#define clutter_root_node_get_type      clutter_root_node_get_type
+#define clutter_root_node_get_type      _clutter_root_node_get_type
+
+typedef struct _ClutterRootNode         ClutterRootNode;
+typedef struct _ClutterPaintNodeClass   ClutterRootNodeClass;
 
 struct _ClutterRootNode
 {
@@ -108,8 +111,6 @@ clutter_root_node_pre_draw (ClutterPaintNode *node)
 {
   ClutterRootNode *rnode = (ClutterRootNode *) node;
 
-  cogl_push_framebuffer (rnode->framebuffer);
-
   cogl_framebuffer_clear (rnode->framebuffer,
                           rnode->clear_flags,
                           &rnode->clear_color);
@@ -120,7 +121,6 @@ clutter_root_node_pre_draw (ClutterPaintNode *node)
 static void
 clutter_root_node_post_draw (ClutterPaintNode *node)
 {
-  cogl_pop_framebuffer ();
 }
 
 static void
@@ -158,13 +158,13 @@ clutter_root_node_init (ClutterRootNode *self)
 }
 
 ClutterPaintNode *
-clutter_root_node_new (CoglFramebuffer    *framebuffer,
-                       const ClutterColor *clear_color,
-                       CoglBufferBit       clear_flags)
+_clutter_root_node_new (CoglFramebuffer    *framebuffer,
+                        const ClutterColor *clear_color,
+                        CoglBufferBit       clear_flags)
 {
   ClutterRootNode *res;
 
-  res = _clutter_paint_node_create (CLUTTER_TYPE_ROOT_NODE);
+  res = _clutter_paint_node_create (_clutter_root_node_get_type ());
 
   cogl_color_init_from_4ub (&res->clear_color,
                             clear_color->red,
@@ -431,17 +431,6 @@ clutter_pipeline_node_draw (ClutterPaintNode *node)
                                               op->op.texrect[7]);
           break;
 
-        case PAINT_OP_MULTITEX_RECT:
-          cogl_framebuffer_draw_multitextured_rectangle (cogl_get_draw_framebuffer (),
-                                                         pnode->pipeline,
-                                                         op->op.texrect[0],
-                                                         op->op.texrect[1],
-                                                         op->op.texrect[2],
-                                                         op->op.texrect[3],
-                                                         (float*) op->multitex_coords->data,
-                                                         op->multitex_coords->len);
-          break;
-
         case PAINT_OP_PATH:
           cogl_path_fill (op->op.path);
           break;
@@ -838,7 +827,6 @@ clutter_text_node_draw (ClutterPaintNode *node)
             cogl_framebuffer_pop_clip (fb);
           break;
 
-        case PAINT_OP_MULTITEX_RECT:
         case PAINT_OP_PATH:
         case PAINT_OP_PRIMITIVE:
         case PAINT_OP_INVALID:
@@ -1004,7 +992,6 @@ clutter_clip_node_pre_draw (ClutterPaintNode *node)
           retval = TRUE;
           break;
 
-        case PAINT_OP_MULTITEX_RECT:
         case PAINT_OP_PRIMITIVE:
         case PAINT_OP_INVALID:
           break;
@@ -1038,7 +1025,6 @@ clutter_clip_node_post_draw (ClutterPaintNode *node)
           cogl_framebuffer_pop_clip (fb);
           break;
 
-        case PAINT_OP_MULTITEX_RECT:
         case PAINT_OP_PRIMITIVE:
         case PAINT_OP_INVALID:
           break;
@@ -1194,17 +1180,6 @@ clutter_layer_node_post_draw (ClutterPaintNode *node)
           cogl_pop_source ();
           break;
 
-        case PAINT_OP_MULTITEX_RECT:
-          cogl_framebuffer_draw_multitextured_rectangle (cogl_get_draw_framebuffer (),
-                                                         lnode->state,
-                                                         op->op.texrect[0],
-                                                         op->op.texrect[1],
-                                                         op->op.texrect[2],
-                                                         op->op.texrect[3],
-                                                         (float*) op->multitex_coords->data,
-                                                         op->multitex_coords->len);
-          break;
-
         case PAINT_OP_PATH:
           cogl_push_source (lnode->state);
           cogl_path_fill (op->op.path);

clutter/clutter/clutter-paint-nodes.h

@@ -143,26 +143,6 @@ CLUTTER_EXPORT
 ClutterPaintNode *      clutter_text_node_new           (PangoLayout           *layout,
                                                          const ClutterColor    *color);
 
-#define CLUTTER_TYPE_ROOT_NODE                  (clutter_root_node_get_type ())
-#define CLUTTER_ROOT_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ROOT_NODE, ClutterRootNode))
-#define CLUTTER_IS_ROOT_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ROOT_NODE))
-
-/**
- * ClutterRootNode:
- *
- * The #ClutterRootNode structure is an opaque
- * type whose members cannot be directly accessed.
- */
-typedef struct _ClutterRootNode                 ClutterRootNode;
-typedef struct _ClutterPaintNodeClass           ClutterRootNodeClass;
-
-CLUTTER_EXPORT
-GType clutter_root_node_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-ClutterPaintNode *      clutter_root_node_new           (CoglFramebuffer       *framebuffer,
-                                                         const ClutterColor    *clear_color,
-                                                         CoglBufferBit          clear_flags);
 G_END_DECLS
 
 #endif /* __CLUTTER_PAINT_NODES_H__ */

clutter/clutter/clutter-paint-volume.c

@@ -35,7 +35,6 @@
 #include "clutter-paint-volume-private.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
-#include "clutter-actor-box-private.h"
 
 G_DEFINE_BOXED_TYPE (ClutterPaintVolume, clutter_paint_volume,
                      clutter_paint_volume_copy,
@@ -1139,6 +1138,8 @@ _clutter_paint_volume_get_stage_paint_box (ClutterPaintVolume *pv,
   CoglMatrix modelview;
   CoglMatrix projection;
   float viewport[4];
+  float width;
+  float height;
 
   _clutter_paint_volume_copy_static (pv, &projected_pv);
 
@@ -1163,22 +1164,50 @@ _clutter_paint_volume_get_stage_paint_box (ClutterPaintVolume *pv,
 
   _clutter_paint_volume_get_bounding_box (&projected_pv, box);
 
-  if (pv->is_2d && pv->actor &&
-      clutter_actor_get_z_position (pv->actor) == 0)
-    {
-      /* If the volume/actor are perfectly 2D, take the bounding box as
-       * good. We won't need to add any extra room for sub-pixel positioning
-       * in this case.
-       */
-      clutter_paint_volume_free (&projected_pv);
-      box->x1 = CLUTTER_NEARBYINT (box->x1);
-      box->y1 = CLUTTER_NEARBYINT (box->y1);
-      box->x2 = CLUTTER_NEARBYINT (box->x2);
-      box->y2 = CLUTTER_NEARBYINT (box->y2);
-      return;
-    }
+  /* The aim here is that for a given rectangle defined with floating point
+   * coordinates we want to determine a stable quantized size in pixels
+   * that doesn't vary due to the original box's sub-pixel position.
+   *
+   * The reason this is important is because effects will use this
+   * API to determine the size of offscreen framebuffers and so for
+   * a fixed-size object that may be animated accross the screen we
+   * want to make sure that the stage paint-box has an equally stable
+   * size so that effects aren't made to continuously re-allocate
+   * a corresponding fbo.
+   *
+   * The other thing we consider is that the calculation of this box is
+   * subject to floating point precision issues that might be slightly
+   * different to the precision issues involved with actually painting the
+   * actor, which might result in painting slightly leaking outside the
+   * user's calculated paint-volume. For this we simply aim to pad out the
+   * paint-volume by at least half a pixel all the way around.
+   */
+  width = box->x2 - box->x1;
+  height = box->y2 - box->y1;
+  width = CLUTTER_NEARBYINT (width);
+  height = CLUTTER_NEARBYINT (height);
+  /* XXX: NB the width/height may now be up to 0.5px too small so we
+   * must also pad by 0.25px all around to account for this. In total we
+   * must padd by at least 0.75px around all sides. */
 
-  _clutter_actor_box_enlarge_for_effects (box);
+  /* XXX: The furthest that we can overshoot the bottom right corner by
+   * here is 1.75px in total if you consider that the 0.75 padding could
+   * just cross an integer boundary and so ceil will effectively add 1.
+   */
+  box->x2 = ceilf (box->x2 + 0.75);
+  box->y2 = ceilf (box->y2 + 0.75);
+
+  /* Now we redefine the top-left relative to the bottom right based on the
+   * rounded width/height determined above + a constant so that the overall
+   * size of the box will be stable and not dependant on the box's
+   * position.
+   *
+   * Adding 3px to the width/height will ensure we cover the maximum of
+   * 1.75px padding on the bottom/right and still ensure we have > 0.75px
+   * padding on the top/left.
+   */
+  box->x1 = box->x2 - width - 3;
+  box->y1 = box->y2 - height - 3;
 
   clutter_paint_volume_free (&projected_pv);
 }

clutter/clutter/clutter-pan-action.c

@@ -961,7 +961,6 @@ clutter_pan_action_get_motion_delta (ClutterPanAction *self,
       return clutter_pan_action_get_interpolated_delta (self, delta_x, delta_y);
     default:
       g_assert_not_reached ();
-      return 0.0f;
     }
 }
 

clutter/clutter/clutter-private.h

@@ -202,7 +202,7 @@ gboolean      _clutter_feature_init (GError **error);
 
 /* Diagnostic mode */
 gboolean        _clutter_diagnostic_enabled     (void);
-void            _clutter_diagnostic_message     (const char *fmt, ...) G_GNUC_PRINTF (1, 2);
+void            _clutter_diagnostic_message     (const char *fmt, ...);
 
 /* Picking code */
 guint           _clutter_pixel_to_id            (guchar        pixel[4]);

clutter/clutter/clutter-script.c

@@ -157,49 +157,6 @@
  * respectively) and the "object" string member for calling
  * g_signal_connect_object() instead of g_signal_connect().
  *
- * Signals can also be directly attached to a specific state defined
- * inside a #ClutterState instance, for instance:
- *
- * |[
- *   ...
- *   "signals" : [
- *     {
- *       "name" : "enter-event",
- *       "states" : "button-states",
- *       "target-state" : "hover"
- *     },
- *     {
- *       "name" : "leave-event",
- *       "states" : "button-states",
- *       "target-state" : "base"
- *     },
- *     {
- *       "name" : "button-press-event",
- *       "states" : "button-states",
- *       "target-state" : "active",
- *     },
- *     {
- *       "name" : "key-press-event",
- *       "states" : "button-states",
- *       "target-state" : "key-focus",
- *       "warp" : true
- *     }
- *   ],
- *   ...
- * ]|
- *
- * The "states" key defines the #ClutterState instance to be used to
- * resolve the "target-state" key; it can be either a script id for a
- * #ClutterState built by the same #ClutterScript instance, or to a
- * #ClutterState built in code and associated to the #ClutterScript
- * instance through the clutter_script_add_states() function. If no
- * "states" key is present, then the default #ClutterState associated to
- * the #ClutterScript instance will be used; the default #ClutterState
- * can be set using clutter_script_add_states() using a %NULL name. The
- * "warp" key can be used to warp to a specific state instead of
- * animating to it. State changes on signal emission will not affect
- * the signal emission chain.
- *
  * Clutter reserves the following names, so classes defining properties
  * through the usual GObject registration process should avoid using these
  * names to avoid collisions:
@@ -248,7 +205,6 @@
 #include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-behaviour.h"
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-state.h"
 
 enum
 {
@@ -274,8 +230,6 @@ struct _ClutterScriptPrivate
 
   ClutterScriptParser *parser;
 
-  GHashTable *states;
-
   gchar **search_paths;
 
   gchar *translation_domain;
@@ -328,7 +282,6 @@ signal_info_free (gpointer data)
       g_free (sinfo->name);
       g_free (sinfo->handler);
       g_free (sinfo->object);
-      g_free (sinfo->state);
       g_free (sinfo->target);
 
       g_slice_free (SignalInfo, sinfo);
@@ -386,7 +339,6 @@ clutter_script_finalize (GObject *gobject)
   g_hash_table_destroy (priv->objects);
   g_strfreev (priv->search_paths);
   g_free (priv->filename);
-  g_hash_table_destroy (priv->states);
   g_free (priv->translation_domain);
 
   G_OBJECT_CLASS (clutter_script_parent_class)->finalize (gobject);
@@ -521,9 +473,6 @@ clutter_script_init (ClutterScript *script)
   priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
                                          NULL,
                                          object_info_free);
-  priv->states = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                        g_free,
-                                        (GDestroyNotify) g_object_unref);
 }
 
 /**
@@ -1043,65 +992,12 @@ clutter_script_connect_signals (ClutterScript *script,
   g_free (cd);
 }
 
-typedef struct {
-  ClutterState *state;
-  GObject *emitter;
-  gchar *target;
-  gulong signal_id;
-  gulong hook_id;
-  gboolean warp_to;
-} HookData;
-
 typedef struct {
   ClutterScript *script;
   ClutterScriptConnectFunc func;
   gpointer user_data;
 } SignalConnectData;
 
-static void
-hook_data_free (gpointer data)
-{
-  if (G_LIKELY (data != NULL))
-    {
-      HookData *hook_data = data;
-
-      g_free (hook_data->target);
-      g_slice_free (HookData, hook_data);
-    }
-}
-
-static gboolean
-clutter_script_state_change_hook (GSignalInvocationHint *ihint,
-                                  guint                  n_params,
-                                  const GValue          *params,
-                                  gpointer               user_data)
-{
-  HookData *hook_data = user_data;
-  GObject *emitter;
-
-  emitter = g_value_get_object (&params[0]);
-
-  if (emitter == hook_data->emitter)
-    {
-      if (hook_data->warp_to)
-        clutter_state_warp_to_state (hook_data->state, hook_data->target);
-      else
-        clutter_state_set_state (hook_data->state, hook_data->target);
-    }
-
-  return TRUE;
-}
-
-static void
-clutter_script_remove_state_change_hook (gpointer  user_data,
-                                         GObject  *object_p)
-{
-  HookData *hook_data = user_data;
-
-  g_signal_remove_emission_hook (hook_data->signal_id,
-                                 hook_data->hook_id);
-}
-
 static void
 connect_each_object (gpointer key,
                      gpointer value,
@@ -1139,67 +1035,6 @@ connect_each_object (gpointer key,
                                   connect_data->user_data);
             }
         }
-      else
-        {
-          GObject *state_object = NULL;
-          const gchar *signal_name, *signal_detail;
-          gchar **components;
-          GQuark signal_quark;
-          guint signal_id;
-          HookData *hook_data;
-
-          if (sinfo->state == NULL)
-            state_object = (GObject *) clutter_script_get_states (script, NULL);
-          else
-            {
-              state_object = clutter_script_get_object (script, sinfo->state);
-              if (state_object == NULL)
-                state_object = (GObject *) clutter_script_get_states (script, sinfo->state);
-            }
-
-          if (state_object == NULL)
-            continue;
-
-          components = g_strsplit (sinfo->name, "::", 2);
-          if (g_strv_length (components) == 2)
-            {
-              signal_name = components[0];
-              signal_detail = components[1];
-            }
-          else
-            {
-              signal_name = components[0];
-              signal_detail = NULL;
-            }
-
-          signal_id = g_signal_lookup (signal_name, G_OBJECT_TYPE (object));
-          if (signal_id == 0)
-            {
-              g_strfreev (components);
-              continue;
-            }
-
-          if (signal_detail != NULL)
-            signal_quark = g_quark_from_string (signal_detail);
-          else
-            signal_quark = 0;
-
-          hook_data = g_slice_new (HookData);
-          hook_data->emitter = object;
-          hook_data->state = CLUTTER_STATE (state_object);
-          hook_data->target = g_strdup (sinfo->target);
-          hook_data->warp_to = sinfo->warp_to;
-          hook_data->signal_id = signal_id;
-          hook_data->hook_id =
-            g_signal_add_emission_hook (signal_id, signal_quark,
-                                        clutter_script_state_change_hook,
-                                        hook_data,
-                                        hook_data_free);
-
-          g_object_weak_ref (hook_data->emitter,
-                             clutter_script_remove_state_change_hook,
-                             hook_data);
-        }
 
       signal_info_free (sinfo);
     }
@@ -1423,72 +1258,6 @@ clutter_script_list_objects (ClutterScript *script)
   return retval;
 }
 
-/**
- * clutter_script_add_states:
- * @script: a #ClutterScript
- * @name: (allow-none): a name for the @state, or %NULL to
- *   set the default #ClutterState
- * @state: a #ClutterState
- *
- * Associates a #ClutterState to the #ClutterScript instance using the given
- * name.
- *
- * The #ClutterScript instance will use @state to resolve target states when
- * connecting signal handlers.
- *
- * The #ClutterScript instance will take a reference on the #ClutterState
- * passed to this function.
- *
- * Since: 1.8
- *
- * Deprecated: 1.12
- */
-void
-clutter_script_add_states (ClutterScript *script,
-                           const gchar   *name,
-                           ClutterState  *state)
-{
-  g_return_if_fail (CLUTTER_IS_SCRIPT (script));
-  g_return_if_fail (CLUTTER_IS_STATE (state));
-
-  if (name == NULL || *name == '\0')
-    name = "__clutter_script_default_state";
-
-  g_hash_table_replace (script->priv->states,
-                        g_strdup (name),
-                        g_object_ref (state));
-}
-
-/**
- * clutter_script_get_states:
- * @script: a #ClutterScript
- * @name: (allow-none): the name of the #ClutterState, or %NULL
- *
- * Retrieves the #ClutterState for the given @state_name.
- *
- * If @name is %NULL, this function will return the default
- * #ClutterState instance.
- *
- * Return value: (transfer none): a pointer to the #ClutterState for the
- *   given name. The #ClutterState is owned by the #ClutterScript instance
- *   and it should not be unreferenced
- *
- * Since: 1.8
- *
- * Deprecated: 1.12
- */
-ClutterState *
-clutter_script_get_states (ClutterScript *script,
-                           const gchar   *name)
-{
-  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), NULL);
-
-  if (name == NULL || *name == '\0')
-    name = "__clutter_script_default_state";
-
-  return g_hash_table_lookup (script->priv->states, name);
-}
-
 /**
  * clutter_script_set_translation_domain:
  * @script: a #ClutterScript

clutter/clutter/clutter-script.h

@@ -178,15 +178,6 @@ void            clutter_script_unmerge_objects          (ClutterScript
 CLUTTER_EXPORT
 void            clutter_script_ensure_objects           (ClutterScript             *script);
 
-CLUTTER_DEPRECATED
-void            clutter_script_add_states               (ClutterScript             *script,
-                                                         const gchar               *name,
-                                                         ClutterState              *state);
-
-CLUTTER_DEPRECATED
-ClutterState *  clutter_script_get_states               (ClutterScript             *script,
-                                                         const gchar               *name);
-
 CLUTTER_EXPORT
 void            clutter_script_connect_signals          (ClutterScript             *script,
                                                          gpointer                   user_data);

clutter/clutter/clutter-scroll-actor.c

@@ -84,9 +84,9 @@ enum
 static GParamSpec *obj_props[PROP_LAST] = { NULL, };
 static GParamSpec *animatable_props[ANIM_PROP_LAST] = { NULL, };
 
-static ClutterAnimatableInterface *parent_animatable_iface = NULL;
+static ClutterAnimatableIface *parent_animatable_iface = NULL;
 
-static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);
+static void     clutter_animatable_iface_init   (ClutterAnimatableIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (ClutterScrollActor, clutter_scroll_actor, CLUTTER_TYPE_ACTOR,
                          G_ADD_PRIVATE (ClutterScrollActor)
@@ -240,7 +240,7 @@ clutter_scroll_actor_get_initial_state (ClutterAnimatable *animatable,
 }
 
 static void
-clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
+clutter_animatable_iface_init (ClutterAnimatableIface *iface)
 {
   parent_animatable_iface = g_type_interface_peek_parent (iface);
 

clutter/clutter/clutter-shader-effect.c

@@ -333,7 +333,6 @@ clutter_shader_effect_create_shader (ClutterShaderEffect *self)
 
     default:
       g_assert_not_reached ();
-      return COGL_INVALID_HANDLE;
     }
 }
 

clutter/clutter/clutter-stage-private.h

@@ -87,7 +87,7 @@ const ClutterPlane *_clutter_stage_get_clip (ClutterStage *stage);
 ClutterStageQueueRedrawEntry *_clutter_stage_queue_actor_redraw            (ClutterStage                 *stage,
                                                                             ClutterStageQueueRedrawEntry *entry,
                                                                             ClutterActor                 *actor,
-                                                                            const ClutterPaintVolume     *clip);
+                                                                            ClutterPaintVolume           *clip);
 void                          _clutter_stage_queue_redraw_entry_invalidate (ClutterStageQueueRedrawEntry *entry);
 
 CoglFramebuffer *_clutter_stage_get_active_framebuffer (ClutterStage *stage);

clutter/clutter/clutter-stage-window.c

@@ -6,13 +6,9 @@
 #include "clutter-stage-window.h"
 #include "clutter-private.h"
 
-/**
- * SECTION:clutter-stage-window
- * @short_description: Handles the implementation for ClutterStage
- *
- * #ClutterStageWindow is an interface that provides the implementation for the
- * #ClutterStage actor, abstracting away the specifics of the windowing system.
- */
+#define clutter_stage_window_get_type   _clutter_stage_window_get_type
+
+typedef ClutterStageWindowIface ClutterStageWindowInterface;
 
 G_DEFINE_INTERFACE (ClutterStageWindow, clutter_stage_window, G_TYPE_OBJECT);
 
@@ -40,12 +36,6 @@ clutter_stage_window_default_init (ClutterStageWindowInterface *iface)
   g_object_interface_install_property (iface, pspec);
 }
 
-/**
- * _clutter_stage_window_get_wrapper:
- * @window: a #ClutterStageWindow object
- *
- * Returns the pointer to the #ClutterStage it's part of.
- */
 ClutterActor *
 _clutter_stage_window_get_wrapper (ClutterStageWindow *window)
 {
@@ -56,7 +46,7 @@ void
 _clutter_stage_window_set_title (ClutterStageWindow *window,
                                  const gchar        *title)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   if (iface->set_title)
     iface->set_title (window, title);
@@ -66,7 +56,7 @@ void
 _clutter_stage_window_set_fullscreen (ClutterStageWindow *window,
                                       gboolean            is_fullscreen)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   if (iface->set_fullscreen)
     iface->set_fullscreen (window, is_fullscreen);
@@ -76,7 +66,7 @@ void
 _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                           gboolean            is_visible)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   if (iface->set_cursor_visible)
     iface->set_cursor_visible (window, is_visible);
@@ -134,7 +124,7 @@ void
 _clutter_stage_window_schedule_update  (ClutterStageWindow *window,
                                         int                 sync_delay)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
 
@@ -148,18 +138,10 @@ _clutter_stage_window_schedule_update  (ClutterStageWindow *window,
   iface->schedule_update (window, sync_delay);
 }
 
-/**
- * _clutter_stage_window_get_update_time:
- * @window: a #ClutterStageWindow object
- *
- * See _clutter_stage_get_update_time() for more info.
- *
- * Returns: The timestamp of the update time
- */
 gint64
 _clutter_stage_window_get_update_time (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), 0);
 
@@ -173,16 +155,10 @@ _clutter_stage_window_get_update_time (ClutterStageWindow *window)
   return iface->get_update_time (window);
 }
 
-/**
- * _clutter_stage_window_clear_update_time:
- * @window: a #ClutterStageWindow object
- *
- * Clears the update time. See _clutter_stage_clear_update_time() for more info.
- */
 void
 _clutter_stage_window_clear_update_time (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
 
@@ -200,7 +176,7 @@ void
 _clutter_stage_window_add_redraw_clip (ClutterStageWindow    *window,
                                        cairo_rectangle_int_t *stage_clip)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
 
@@ -220,7 +196,7 @@ _clutter_stage_window_add_redraw_clip (ClutterStageWindow    *window,
 gboolean
 _clutter_stage_window_has_redraw_clips (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
 
@@ -242,7 +218,7 @@ _clutter_stage_window_has_redraw_clips (ClutterStageWindow *window)
 gboolean
 _clutter_stage_window_ignoring_redraw_clips (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
 
@@ -257,7 +233,7 @@ gboolean
 _clutter_stage_window_get_redraw_clip_bounds (ClutterStageWindow    *window,
                                               cairo_rectangle_int_t *stage_clip)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
 
@@ -272,7 +248,7 @@ void
 _clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
                                         gboolean            accept_focus)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
 
@@ -284,7 +260,7 @@ _clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
 void
 _clutter_stage_window_redraw (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));
 
@@ -299,7 +275,7 @@ _clutter_stage_window_get_dirty_pixel (ClutterStageWindow *window,
                                        ClutterStageView   *view,
                                        int *x, int *y)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   *x = 0;
   *y = 0;
@@ -314,7 +290,7 @@ _clutter_stage_window_get_dirty_pixel (ClutterStageWindow *window,
 gboolean
 _clutter_stage_window_can_clip_redraws (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface;
+  ClutterStageWindowIface *iface;
 
   g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);
 
@@ -328,7 +304,7 @@ _clutter_stage_window_can_clip_redraws (ClutterStageWindow *window)
 GList *
 _clutter_stage_window_get_views (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   return iface->get_views (window);
 }
@@ -336,7 +312,7 @@ _clutter_stage_window_get_views (ClutterStageWindow *window)
 void
 _clutter_stage_window_finish_frame (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   if (iface->finish_frame)
     iface->finish_frame (window);
@@ -345,7 +321,7 @@ _clutter_stage_window_finish_frame (ClutterStageWindow *window)
 int64_t
 _clutter_stage_window_get_frame_counter (ClutterStageWindow *window)
 {
-  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
 
   if (iface->get_frame_counter)
     return iface->get_frame_counter (window);

clutter/clutter/clutter-stage-window.h

@@ -7,21 +7,30 @@
 
 G_BEGIN_DECLS
 
-#define CLUTTER_TYPE_STAGE_WINDOW (clutter_stage_window_get_type ())
-
-CLUTTER_EXPORT
-G_DECLARE_INTERFACE (ClutterStageWindow, clutter_stage_window,
-                     CLUTTER, STAGE_WINDOW,
-                     GObject)
+#define CLUTTER_TYPE_STAGE_WINDOW               (_clutter_stage_window_get_type ())
+#define CLUTTER_STAGE_WINDOW(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE_WINDOW, ClutterStageWindow))
+#define CLUTTER_IS_STAGE_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE_WINDOW))
+#define CLUTTER_STAGE_WINDOW_GET_IFACE(obj)     (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_STAGE_WINDOW, ClutterStageWindowIface))
 
 /*
- * ClutterStageWindowInterface: (skip)
+ * ClutterStageWindow: (skip)
+ *
+ * #ClutterStageWindow is an opaque structure
+ * whose members should not be accessed directly
+ *
+ * Since: 0.8
+ */
+typedef struct _ClutterStageWindow      ClutterStageWindow; /* dummy */
+typedef struct _ClutterStageWindowIface ClutterStageWindowIface;
+
+/*
+ * ClutterStageWindowIface: (skip)
  *
  * The interface implemented by backends for stage windows
  *
  * Since: 0.8
  */
-struct _ClutterStageWindowInterface
+struct _ClutterStageWindowIface
 {
   /*< private >*/
   GTypeInterface parent_iface;
@@ -79,6 +88,9 @@ struct _ClutterStageWindowInterface
   void              (* finish_frame)            (ClutterStageWindow *stage_window);
 };
 
+CLUTTER_EXPORT
+GType _clutter_stage_window_get_type (void) G_GNUC_CONST;
+
 ClutterActor *    _clutter_stage_window_get_wrapper        (ClutterStageWindow *window);
 
 void              _clutter_stage_window_set_title          (ClutterStageWindow *window,

clutter/clutter/clutter-stage.c

@@ -36,10 +36,10 @@
  * using clutter_actor_destroy(), which will take care of destroying all the
  * actors contained inside them.
  *
- * #ClutterStage is a proxy actor, wrapping the backend-specific implementation
- * (a #StageWindow) of the windowing system. It is possible to subclass
- * #ClutterStage, as long as every overridden virtual function chains up to the
- * parent class corresponding function.
+ * #ClutterStage is a proxy actor, wrapping the backend-specific
+ * implementation of the windowing system. It is possible to subclass
+ * #ClutterStage, as long as every overridden virtual function chains up to
+ * the parent class corresponding function.
  */
 
 #include "clutter-build-config.h"
@@ -204,7 +204,7 @@ static void free_queue_redraw_entry (ClutterStageQueueRedrawEntry *entry);
 
 static void clutter_container_iface_init (ClutterContainerIface *iface);
 
-G_DEFINE_TYPE_WITH_CODE (ClutterStage, clutter_stage, CLUTTER_TYPE_GROUP,
+G_DEFINE_TYPE_WITH_CODE (ClutterStage, clutter_stage, CLUTTER_TYPE_ACTOR,
                          G_ADD_PRIVATE (ClutterStage)
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
                                                 clutter_container_iface_init))
@@ -685,10 +685,6 @@ _clutter_stage_paint_view (ClutterStage                *stage,
   g_signal_emit (stage, stage_signals[AFTER_PAINT], 0);
 }
 
-/* If we don't implement this here, we get the paint function
- * from the deprecated clutter-group class, which doesn't
- * respect the Z order as it uses our empty sort_depth_order.
- */
 static void
 clutter_stage_paint (ClutterActor *self)
 {
@@ -707,9 +703,9 @@ clutter_stage_pick (ClutterActor       *self,
   ClutterActorIter iter;
   ClutterActor *child;
 
-  /* Note: we don't chain up to our parent as we don't want any geometry
-   * emitted for the stage itself. The stage's pick id is effectively handled
-   * by the call to cogl_clear done in clutter-main.c:_clutter_do_pick_async()
+  /* Note: we don't want any geometry emitted for the stage itself. The stage's
+   * pick id is effectively handled by the call to cogl_clear done in
+   * clutter-main.c:_clutter_do_pick_async()
    */
   clutter_actor_iter_init (&iter, self);
   while (clutter_actor_iter_next (&iter, &child))
@@ -756,9 +752,6 @@ clutter_stage_show_all (ClutterActor *self)
   ClutterActorIter iter;
   ClutterActor *child;
 
-  /* we don't do a recursive show_all(), to maintain the old
-   * invariants from ClutterGroup
-   */
   clutter_actor_iter_init (&iter, self);
   while (clutter_actor_iter_next (&iter, &child))
     clutter_actor_show (child);
@@ -789,9 +782,6 @@ clutter_stage_hide_all (ClutterActor *self)
 
   clutter_actor_hide (self);
 
-  /* we don't do a recursive hide_all(), to maintain the old invariants
-   * from ClutterGroup
-   */
   clutter_actor_iter_init (&iter, self);
   while (clutter_actor_iter_next (&iter, &child))
     clutter_actor_hide (child);
@@ -1274,44 +1264,45 @@ clutter_stage_real_queue_relayout (ClutterActor *self)
   parent_class->queue_relayout (self);
 }
 
-static gboolean
-clutter_stage_real_queue_redraw (ClutterActor       *actor,
-                                 ClutterActor       *leaf,
-                                 ClutterPaintVolume *redraw_clip)
+static void
+clutter_stage_real_queue_redraw (ClutterActor *actor,
+                                 ClutterActor *leaf)
 {
   ClutterStage *stage = CLUTTER_STAGE (actor);
   ClutterStageWindow *stage_window;
+  ClutterPaintVolume *redraw_clip;
   ClutterActorBox bounding_box;
   ClutterActorBox intersection_box;
   cairo_rectangle_int_t geom, stage_clip;
 
   if (CLUTTER_ACTOR_IN_DESTRUCTION (actor))
-    return TRUE;
+    return;
 
   /* If the backend can't do anything with redraw clips (e.g. it already knows
    * it needs to redraw everything anyway) then don't spend time transforming
    * any clip volume into stage coordinates... */
   stage_window = _clutter_stage_get_window (stage);
   if (stage_window == NULL)
-    return TRUE;
+    return;
 
   if (_clutter_stage_window_ignoring_redraw_clips (stage_window))
     {
       _clutter_stage_window_add_redraw_clip (stage_window, NULL);
-      return FALSE;
+      return;
     }
 
   /* Convert the clip volume into stage coordinates and then into an
    * axis aligned stage coordinates bounding box...
    */
+  redraw_clip = _clutter_actor_get_queue_redraw_clip (leaf);
   if (redraw_clip == NULL)
     {
       _clutter_stage_window_add_redraw_clip (stage_window, NULL);
-      return FALSE;
+      return;
     }
 
   if (redraw_clip->is_empty)
-    return TRUE;
+    return;
 
   _clutter_paint_volume_get_stage_paint_box (redraw_clip,
                                              stage,
@@ -1327,7 +1318,7 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
   /* There is no need to track degenerate/empty redraw clips */
   if (intersection_box.x2 <= intersection_box.x1 ||
       intersection_box.y2 <= intersection_box.y1)
-    return TRUE;
+    return;
 
   /* when converting to integer coordinates make sure we round the edges of the
    * clip rectangle outwards... */
@@ -1337,7 +1328,6 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
   stage_clip.height = intersection_box.y2 - stage_clip.y;
 
   _clutter_stage_window_add_redraw_clip (stage_window, &stage_clip);
-  return FALSE;
 }
 
 gboolean
@@ -1391,12 +1381,11 @@ clutter_stage_get_redraw_clip_bounds (ClutterStage          *stage,
 }
 
 static void
-read_pixels_to_file (CoglFramebuffer *fb,
-                     char            *filename_stem,
-                     int              x,
-                     int              y,
-                     int              width,
-                     int              height)
+read_pixels_to_file (char *filename_stem,
+                     int   x,
+                     int   y,
+                     int   width,
+                     int   height)
 {
   guint8 *data;
   cairo_surface_t *surface;
@@ -1406,10 +1395,10 @@ read_pixels_to_file (CoglFramebuffer *fb,
                                     read_count);
 
   data = g_malloc (4 * width * height);
-  cogl_framebuffer_read_pixels (fb,
-                                x, y, width, height,
-                                CLUTTER_CAIRO_FORMAT_ARGB32,
-                                data);
+  cogl_read_pixels (x, y, width, height,
+                    COGL_READ_PIXELS_COLOR_BUFFER,
+                    CLUTTER_CAIRO_FORMAT_ARGB32,
+                    data);
 
   surface = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_RGB24,
                                                  width, height,
@@ -1474,8 +1463,8 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   if (G_LIKELY (!(clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS)))
     {
       CLUTTER_NOTE (PICK, "Pushing pick scissor clip x: %d, y: %d, 1x1",
-                    (int) (dirty_x * fb_scale),
-                    (int) (dirty_y * fb_scale));
+                    (int) dirty_x * fb_scale,
+                    (int) dirty_y * fb_scale);
       cogl_framebuffer_push_scissor_clip (fb, dirty_x * fb_scale, dirty_y * fb_scale, 1, 1);
     }
 
@@ -1495,13 +1484,13 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   read_x = dirty_x * fb_scale;
   read_y = dirty_y * fb_scale;
 
-  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %f",
+  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %d",
                 x, y,
                 view_layout.width, view_layout.height,
                 view_layout.x, view_layout.y, fb_scale);
 
   cogl_color_init_from_4ub (&stage_pick_id, 255, 255, 255, 255);
-  cogl_framebuffer_clear (fb, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH, &stage_pick_id);
+  cogl_clear (&stage_pick_id, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH);
 
   /* Disable dithering (if any) when doing the painting in pick mode */
   dither_enabled_save = cogl_framebuffer_get_dither_enabled (fb);
@@ -1511,8 +1500,7 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
    * are drawn offscreen (as we never swap buffers)
   */
   context->pick_mode = mode;
-
-  clutter_stage_do_paint_view (stage, view, NULL);
+  _clutter_stage_paint_view (stage, view, NULL);
   context->pick_mode = CLUTTER_PICK_NONE;
 
   /* Read the color of the screen co-ords pixel. RGBA_8888_PRE is used
@@ -1534,7 +1522,7 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
                          _clutter_actor_get_debug_name (actor),
                          view_layout.x);
 
-      read_pixels_to_file (fb, file_name, 0, 0, fb_width, fb_height);
+      read_pixels_to_file (file_name, 0, 0, fb_width, fb_height);
 
       g_free (file_name);
     }
@@ -2249,8 +2237,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
    * @stage: the stage that received the event
    * @frame_event: a #CoglFrameEvent
    * @frame_info: a #ClutterFrameInfo
-   *
-   * Signals that the #ClutterStage was presented on the screen to the user.
    */
   stage_signals[PRESENTED] =
     g_signal_new (I_("presented"),
@@ -2742,7 +2728,7 @@ clutter_stage_set_fullscreen (ClutterStage *stage,
   if (priv->is_fullscreen != fullscreen)
     {
       ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
+      ClutterStageWindowIface *iface;
 
       iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
 
@@ -2807,7 +2793,7 @@ clutter_stage_set_user_resizable (ClutterStage *stage,
       && priv->is_user_resizable != resizable)
     {
       ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
+      ClutterStageWindowIface *iface;
 
       iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
       if (iface->set_user_resizable)
@@ -2856,7 +2842,7 @@ clutter_stage_show_cursor (ClutterStage *stage)
   if (!priv->is_cursor_visible)
     {
       ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
+      ClutterStageWindowIface *iface;
 
       iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
       if (iface->set_cursor_visible)
@@ -2889,7 +2875,7 @@ clutter_stage_hide_cursor (ClutterStage *stage)
   if (priv->is_cursor_visible)
     {
       ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowInterface *iface;
+      ClutterStageWindowIface *iface;
 
       iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
       if (iface->set_cursor_visible)
@@ -3630,10 +3616,6 @@ _clutter_stage_maybe_setup_viewport (ClutterStage     *stage,
       float fb_scale;
       float viewport_offset_x;
       float viewport_offset_y;
-      float viewport_x;
-      float viewport_y;
-      float viewport_width;
-      float viewport_height;
       float z_2d;
 
       CLUTTER_NOTE (PAINT,
@@ -3646,13 +3628,11 @@ _clutter_stage_maybe_setup_viewport (ClutterStage     *stage,
 
       viewport_offset_x = view_layout.x * fb_scale;
       viewport_offset_y = view_layout.y * fb_scale;
-      viewport_x = roundf (priv->viewport[0] * fb_scale - viewport_offset_x);
-      viewport_y = roundf (priv->viewport[1] * fb_scale - viewport_offset_y);
-      viewport_width = roundf (priv->viewport[2] * fb_scale);
-      viewport_height = roundf (priv->viewport[3] * fb_scale);
       cogl_framebuffer_set_viewport (fb,
-                                     viewport_x, viewport_y,
-                                     viewport_width, viewport_height);
+                                     priv->viewport[0] * fb_scale - viewport_offset_x,
+                                     priv->viewport[1] * fb_scale - viewport_offset_y,
+                                     priv->viewport[2] * fb_scale,
+                                     priv->viewport[3] * fb_scale);
 
       perspective = priv->perspective;
 
@@ -3731,17 +3711,6 @@ clutter_stage_ensure_redraw (ClutterStage *stage)
   _clutter_master_clock_start_running (master_clock);
 }
 
-/**
- * clutter_stage_is_redraw_queued: (skip)
- */
-gboolean
-clutter_stage_is_redraw_queued (ClutterStage *stage)
-{
-  ClutterStagePrivate *priv = stage->priv;
-
-  return priv->redraw_pending;
-}
-
 /**
  * clutter_stage_queue_redraw:
  * @stage: the #ClutterStage
@@ -4002,12 +3971,6 @@ clutter_stage_get_minimum_size (ClutterStage *stage,
     *height_p = (guint) height;
 }
 
-/**
- * _clutter_stage_schedule_update:
- * @window: a #ClutterStage actor
- *
- * Schedules a redraw of the #ClutterStage at the next optimal timestamp.
- */
 void
 _clutter_stage_schedule_update (ClutterStage *stage)
 {
@@ -4024,18 +3987,7 @@ _clutter_stage_schedule_update (ClutterStage *stage)
                                                 stage->priv->sync_delay);
 }
 
-/**
- * _clutter_stage_get_update_time:
- * @stage: a #ClutterStage actor
- *
- * Returns the earliest time in which the stage is ready to update. The update
- * time is set when _clutter_stage_schedule_update() is called. This can then
- * be used by e.g. the #ClutterMasterClock to know when the stage needs to be
- * redrawn.
- *
- * Returns: -1 if no redraw is needed; 0 if the backend doesn't know, or the
- * timestamp (in microseconds) otherwise.
- */
+/* Returns the earliest time the stage is ready to update */
 gint64
 _clutter_stage_get_update_time (ClutterStage *stage)
 {
@@ -4051,13 +4003,6 @@ _clutter_stage_get_update_time (ClutterStage *stage)
   return _clutter_stage_window_get_update_time (stage_window);
 }
 
-/**
- * _clutter_stage_clear_update_time:
- * @stage: a #ClutterStage actor
- *
- * Resets the update time. Call this after a redraw, so that the update time
- * can again be updated.
- */
 void
 _clutter_stage_clear_update_time (ClutterStage *stage)
 {
@@ -4183,10 +4128,10 @@ _clutter_stage_get_clip (ClutterStage *stage)
  * didn't explicitly do so.
  */
 ClutterStageQueueRedrawEntry *
-_clutter_stage_queue_actor_redraw (ClutterStage                 *stage,
+_clutter_stage_queue_actor_redraw (ClutterStage *stage,
                                    ClutterStageQueueRedrawEntry *entry,
-                                   ClutterActor                 *actor,
-                                   const ClutterPaintVolume     *clip)
+                                   ClutterActor *actor,
+                                   ClutterPaintVolume *clip)
 {
   ClutterStagePrivate *priv = stage->priv;
 

clutter/clutter/clutter-stage.h

@@ -28,8 +28,8 @@
 #error "Only <clutter/clutter.h> can be included directly."
 #endif
 
+#include <clutter/clutter-actor-private.h>
 #include <clutter/clutter-types.h>
-#include <clutter/clutter-group.h>
 
 G_BEGIN_DECLS
 
@@ -55,10 +55,11 @@ typedef struct _ClutterStagePrivate ClutterStagePrivate;
 struct _ClutterStage
 {
   /*< private >*/
-  ClutterGroup parent_instance;
+  ClutterActor parent_instance;
 
   ClutterStagePrivate *priv;
 };
+
 /**
  * ClutterStageClass:
  * @fullscreen: handler for the #ClutterStage::fullscreen signal
@@ -75,7 +76,7 @@ struct _ClutterStage
 struct _ClutterStageClass
 {
   /*< private >*/
-  ClutterGroupClass parent_class;
+  ClutterActorClass parent_class;
 
   /*< public >*/
   /* signals */
@@ -250,9 +251,6 @@ void            clutter_stage_ensure_viewport                   (ClutterStage
 CLUTTER_EXPORT
 void            clutter_stage_ensure_redraw                     (ClutterStage          *stage);
 
-CLUTTER_EXPORT
-gboolean        clutter_stage_is_redraw_queued                  (ClutterStage          *stage);
-
 #ifdef CLUTTER_ENABLE_EXPERIMENTAL_API
 CLUTTER_EXPORT
 void            clutter_stage_set_sync_delay                    (ClutterStage          *stage,

clutter/clutter/clutter-text.c

@@ -277,9 +277,7 @@ static const ClutterColor default_selection_color = {   0,   0,   0, 255 };
 static const ClutterColor default_text_color      = {   0,   0,   0, 255 };
 static const ClutterColor default_selected_text_color = {   0,   0,   0, 255 };
 
-static CoglPipeline *default_color_pipeline = NULL;
-
-static ClutterAnimatableInterface *parent_animatable_iface = NULL;
+static ClutterAnimatableIface *parent_animatable_iface = NULL;
 static ClutterScriptableIface *parent_scriptable_iface = NULL;
 
 /* ClutterTextInputFocus */
@@ -389,7 +387,7 @@ clutter_text_input_focus_new (ClutterText *text)
 
 /* ClutterText */
 static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
-static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);
+static void clutter_animatable_iface_init (ClutterAnimatableIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (ClutterText,
                          clutter_text,
@@ -1746,8 +1744,7 @@ add_selection_rectangle_to_path (ClutterText           *text,
 
 /* Draws the selected text, its background, and the cursor */
 static void
-selection_paint (ClutterText     *self,
-                 CoglFramebuffer *fb)
+selection_paint (ClutterText *self)
 {
   ClutterTextPrivate *priv = self->priv;
   ClutterActor *actor = CLUTTER_ACTOR (self);
@@ -1759,30 +1756,21 @@ selection_paint (ClutterText     *self,
 
   if (priv->position == priv->selection_bound)
     {
-      CoglPipeline *color_pipeline = cogl_pipeline_copy (default_color_pipeline);
-      CoglColor cogl_color;
-
       /* No selection, just draw the cursor */
       if (priv->cursor_color_set)
         color = &priv->cursor_color;
       else
         color = &priv->text_color;
 
-
-      cogl_color_init_from_4ub (&cogl_color,
-                                color->red,
+      cogl_set_source_color4ub (color->red,
                                 color->green,
                                 color->blue,
                                 paint_opacity * color->alpha / 255);
-      cogl_color_premultiply (&cogl_color);
-      cogl_pipeline_set_color (color_pipeline, &cogl_color);
 
-      cogl_framebuffer_draw_rectangle (fb,
-                                       color_pipeline,
-                                       priv->cursor_rect.origin.x,
-                                       priv->cursor_rect.origin.y,
-                                       priv->cursor_rect.origin.x + priv->cursor_rect.size.width,
-                                       priv->cursor_rect.origin.y + priv->cursor_rect.size.height);
+      cogl_rectangle (priv->cursor_rect.origin.x,
+                      priv->cursor_rect.origin.y,
+                      priv->cursor_rect.origin.x + priv->cursor_rect.size.width,
+                      priv->cursor_rect.origin.y + priv->cursor_rect.size.height);
     }
   else
     {
@@ -1790,6 +1778,11 @@ selection_paint (ClutterText     *self,
       PangoLayout *layout = clutter_text_get_layout (self);
       CoglPath *selection_path = cogl_path_new ();
       CoglColor cogl_color = { 0, };
+      CoglFramebuffer *fb;
+
+      fb = cogl_get_draw_framebuffer ();
+      if (G_UNLIKELY (fb == NULL))
+        return;
 
       /* Paint selection background */
       if (priv->selection_color_set)
@@ -1799,6 +1792,11 @@ selection_paint (ClutterText     *self,
       else
         color = &priv->text_color;
 
+      cogl_set_source_color4ub (color->red,
+                                color->green,
+                                color->blue,
+                                paint_opacity * color->alpha / 255);
+
       clutter_text_foreach_selection_rectangle (self,
                                                 add_selection_rectangle_to_path,
                                                 selection_path);
@@ -2402,19 +2400,9 @@ clutter_text_paint (ClutterActor *self)
   alloc_width = alloc.x2 - alloc.x1;
   alloc_height = alloc.y2 - alloc.y1;
 
-  if (G_UNLIKELY (default_color_pipeline == NULL))
-    {
-      CoglContext *ctx =
-        clutter_backend_get_cogl_context (clutter_get_default_backend ());
-      default_color_pipeline = cogl_pipeline_new (ctx);
-    }
-
-  g_assert (default_color_pipeline != NULL);
-
   g_object_get (self, "background-color-set", &bg_color_set, NULL);
   if (bg_color_set)
     {
-      CoglPipeline *color_pipeline = cogl_pipeline_copy (default_color_pipeline);
       ClutterColor bg_color;
 
       clutter_actor_get_background_color (self, &bg_color);
@@ -2422,20 +2410,11 @@ clutter_text_paint (ClutterActor *self)
                      * bg_color.alpha
                      / 255;
 
-      cogl_color_init_from_4ub (&color,
-                                bg_color.red,
+      cogl_set_source_color4ub (bg_color.red,
                                 bg_color.green,
                                 bg_color.blue,
                                 bg_color.alpha);
-      cogl_color_premultiply (&color);
-      cogl_pipeline_set_color (color_pipeline, &color);
-
-      cogl_framebuffer_draw_rectangle (fb,
-                                       color_pipeline,
-                                       0, 0,
-                                       alloc_width, alloc_height);
-
-      cogl_object_unref (color_pipeline);
+      cogl_rectangle (0, 0, alloc_width, alloc_height);
     }
 
   /* don't bother painting an empty text actor, unless it's
@@ -2567,7 +2546,7 @@ clutter_text_paint (ClutterActor *self)
                             real_opacity);
   cogl_pango_render_layout (layout, priv->text_x, priv->text_y, &color, 0);
 
-  selection_paint (text, fb);
+  selection_paint (text);
 
   if (clip_set)
     cogl_framebuffer_pop_clip (fb);
@@ -3547,7 +3526,7 @@ clutter_text_set_final_state (ClutterAnimatable *animatable,
 }
 
 static void
-clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
+clutter_animatable_iface_init (ClutterAnimatableIface *iface)
 {
   parent_animatable_iface = g_type_interface_peek_parent (iface);
 

clutter/clutter/clutter-timeline.c

@@ -24,7 +24,7 @@
 /**
  * SECTION:clutter-timeline
  * @short_description: A class for time-based events
- * @see_also: #ClutterAnimation, #ClutterAnimator, #ClutterState
+ * @see_also: #ClutterAnimation
  *
  * #ClutterTimeline is a base class for managing time-based event that cause
  * Clutter to redraw a stage, such as animations.
@@ -71,7 +71,7 @@
  * when reaching completion by using the #ClutterTimeline:auto-reverse property.
  *
  * Timelines are used in the Clutter animation framework by classes like
- * #ClutterAnimation, #ClutterAnimator, and #ClutterState.
+ * #ClutterAnimation.
  *
  * ## Defining Timelines in ClutterScript
  *

clutter/clutter/clutter-types.h

@@ -90,7 +90,6 @@ typedef struct _ClutterVertex                   ClutterVertex;
 
 typedef struct _ClutterAlpha            	ClutterAlpha;
 typedef struct _ClutterAnimation                ClutterAnimation;
-typedef struct _ClutterState            	ClutterState;
 
 typedef struct _ClutterInputDeviceTool          ClutterInputDeviceTool;
 typedef struct _ClutterInputDevice              ClutterInputDevice;
@@ -115,7 +114,6 @@ typedef struct _ClutterEventSequence            ClutterEventSequence;
 
 typedef struct _ClutterFog                      ClutterFog; /* deprecated */
 typedef struct _ClutterBehaviour                ClutterBehaviour; /* deprecated */
-typedef struct _ClutterShader                   ClutterShader; /* deprecated */
 
 /**
  * ClutterPaintVolume:

clutter/clutter/clutter-util.c

@@ -39,6 +39,29 @@
 #include "clutter-interval.h"
 #include "clutter-private.h"
 
+#include "deprecated/clutter-util.h"
+
+/**
+ * clutter_util_next_p2:
+ * @a: Value to get the next power
+ *
+ * Calculates the nearest power of two, greater than or equal to @a.
+ *
+ * Return value: The nearest power of two, greater or equal to @a.
+ *
+ * Deprecated: 1.2
+ */
+gint
+clutter_util_next_p2 (gint a)
+{
+  int rval = 1;
+
+  while (rval < a)
+    rval <<= 1;
+
+  return rval;
+}
+
 /* Help macros to scale from OpenGL <-1,1> coordinates system to
  * window coordinates ranging [0,window-size]
  */

clutter/clutter/clutter.h

@@ -68,7 +68,6 @@
 #include "clutter-flow-layout.h"
 #include "clutter-gesture-action.h"
 #include "clutter-grid-layout.h"
-#include "clutter-group.h"
 #include "clutter-image.h"
 #include "clutter-input-device.h"
 #include "clutter-input-device-tool.h"
@@ -76,7 +75,6 @@
 #include "clutter-input-focus.h"
 #include "clutter-interval.h"
 #include "clutter-keyframe-transition.h"
-#include "clutter-keymap.h"
 #include "clutter-keysyms.h"
 #include "clutter-layout-manager.h"
 #include "clutter-layout-meta.h"

clutter/clutter/cogl/clutter-stage-cogl.c

@@ -60,8 +60,7 @@ typedef struct _ClutterStageViewCoglPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (ClutterStageViewCogl, clutter_stage_view_cogl,
                             CLUTTER_TYPE_STAGE_VIEW)
 
-static void
-clutter_stage_window_iface_init (ClutterStageWindowInterface *iface);
+static void clutter_stage_window_iface_init (ClutterStageWindowIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (ClutterStageCogl,
                          _clutter_stage_cogl,
@@ -352,58 +351,6 @@ valid_buffer_age (ClutterStageViewCogl *view_cogl,
   return age < MIN (view_priv->damage_index, DAMAGE_HISTORY_MAX);
 }
 
-static void
-paint_damage_region (ClutterStageWindow    *stage_window,
-                     ClutterStageView      *view,
-                     cairo_rectangle_int_t *swap_region)
-{
-  CoglFramebuffer *framebuffer = clutter_stage_view_get_onscreen (view);
-  CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
-  static CoglPipeline *overlay_blue = NULL;
-  ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window);
-  ClutterActor *actor = CLUTTER_ACTOR (stage_cogl->wrapper);
-  float x_1 = swap_region->x;
-  float x_2 = swap_region->x + swap_region->width;
-  float y_1 = swap_region->y;
-  float y_2 = swap_region->y + swap_region->height;
-  CoglMatrix modelview;
-
-  if (G_UNLIKELY (overlay_blue == NULL))
-    {
-      overlay_blue = cogl_pipeline_new (ctx);
-      cogl_pipeline_set_color4ub (overlay_blue, 0x00, 0x00, 0x33, 0x33);
-    }
-
-  cogl_framebuffer_push_matrix (framebuffer);
-  cogl_matrix_init_identity (&modelview);
-  _clutter_actor_apply_modelview_transform (actor, &modelview);
-  cogl_framebuffer_set_modelview_matrix (framebuffer, &modelview);
-
-  /* Blue for the swap region */
-  cogl_framebuffer_draw_rectangle (framebuffer, overlay_blue, x_1, y_1, x_2, y_2);
-
-  /* Red for the clip */
-  if (stage_cogl->initialized_redraw_clip)
-    {
-      static CoglPipeline *overlay_red = NULL;
-
-      if (G_UNLIKELY (overlay_red == NULL))
-        {
-          overlay_red = cogl_pipeline_new (ctx);
-          cogl_pipeline_set_color4ub (overlay_red, 0x33, 0x00, 0x00, 0x33);
-        }
-
-      x_1 = stage_cogl->bounding_redraw_clip.x;
-      x_2 = stage_cogl->bounding_redraw_clip.x + stage_cogl->bounding_redraw_clip.width;
-      y_1 = stage_cogl->bounding_redraw_clip.y;
-      y_2 = stage_cogl->bounding_redraw_clip.y + stage_cogl->bounding_redraw_clip.height;
-
-      cogl_framebuffer_draw_rectangle (framebuffer, overlay_red, x_1, y_1, x_2, y_2);
-    }
-
-  cogl_framebuffer_pop_matrix (framebuffer);
-}
-
 static gboolean
 swap_framebuffer (ClutterStageWindow    *stage_window,
                   ClutterStageView      *view,
@@ -423,9 +370,6 @@ swap_framebuffer (ClutterStageWindow    *stage_window,
   else
     ndamage = 0;
 
-  if (G_UNLIKELY ((clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION)))
-    paint_damage_region (stage_window, view, swap_region);
-
   if (cogl_is_onscreen (framebuffer))
     {
       CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
@@ -577,15 +521,6 @@ calculate_scissor_region (cairo_rectangle_int_t *fb_clip_region,
   };
 }
 
-static inline gboolean
-is_buffer_age_enabled (void)
-{
-  /* Buffer age is disabled when running with CLUTTER_PAINT=damage-region,
-   * to ensure the red damage represents the currently damaged area */
-  return !(clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DAMAGE_REGION) &&
-         cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE);
-}
-
 static gboolean
 clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
                                 ClutterStageView   *view)
@@ -623,7 +558,9 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
     cogl_is_onscreen (fb) &&
     cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION);
 
-  has_buffer_age = cogl_is_onscreen (fb) && is_buffer_age_enabled ();
+  has_buffer_age =
+    cogl_is_onscreen (fb) &&
+    cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE);
 
   /* NB: a zero width redraw clip == full stage redraw */
   if (stage_cogl->bounding_redraw_clip.width == 0)
@@ -954,7 +891,7 @@ clutter_stage_cogl_get_dirty_pixel (ClutterStageWindow *stage_window,
   CoglFramebuffer *framebuffer = clutter_stage_view_get_framebuffer (view);
   gboolean has_buffer_age =
     cogl_is_onscreen (framebuffer) &&
-    is_buffer_age_enabled ();
+    cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE);
   float fb_scale;
   gboolean scale_is_fractional;
 
@@ -995,7 +932,7 @@ clutter_stage_cogl_get_dirty_pixel (ClutterStageWindow *stage_window,
 }
 
 static void
-clutter_stage_window_iface_init (ClutterStageWindowInterface *iface)
+clutter_stage_window_iface_init (ClutterStageWindowIface *iface)
 {
   iface->realize = clutter_stage_cogl_realize;
   iface->unrealize = clutter_stage_cogl_unrealize;

clutter/clutter/deprecated/clutter-actor-deprecated.c

@@ -7,7 +7,63 @@
 
 #include "clutter-actor-private.h"
 #include "clutter-private.h"
-#include "clutter-shader.h"
+
+/**
+ * clutter_actor_set_geometry:
+ * @self: A #ClutterActor
+ * @geometry: A #ClutterGeometry
+ *
+ * Sets the actor's fixed position and forces its minimum and natural
+ * size, in pixels. This means the untransformed actor will have the
+ * given geometry. This is the same as calling clutter_actor_set_position()
+ * and clutter_actor_set_size().
+ *
+ * Deprecated: 1.10: Use clutter_actor_set_position() and
+ *   clutter_actor_set_size() instead.
+ */
+void
+clutter_actor_set_geometry (ClutterActor          *self,
+			    const ClutterGeometry *geometry)
+{
+  g_object_freeze_notify (G_OBJECT (self));
+
+  clutter_actor_set_position (self, geometry->x, geometry->y);
+  clutter_actor_set_size (self, geometry->width, geometry->height);
+
+  g_object_thaw_notify (G_OBJECT (self));
+}
+
+/**
+ * clutter_actor_get_geometry:
+ * @self: A #ClutterActor
+ * @geometry: (out caller-allocates): A location to store actors #ClutterGeometry
+ *
+ * Gets the size and position of an actor relative to its parent
+ * actor. This is the same as calling clutter_actor_get_position() and
+ * clutter_actor_get_size(). It tries to "do what you mean" and get the
+ * requested size and position if the actor's allocation is invalid.
+ *
+ * Deprecated: 1.10: Use clutter_actor_get_position() and
+ *   clutter_actor_get_size(), or clutter_actor_get_allocation_geometry()
+ *   instead.
+ */
+void
+clutter_actor_get_geometry (ClutterActor    *self,
+			    ClutterGeometry *geometry)
+{
+  gfloat x, y, width, height;
+
+  g_return_if_fail (CLUTTER_IS_ACTOR (self));
+  g_return_if_fail (geometry != NULL);
+
+  clutter_actor_get_position (self, &x, &y);
+  clutter_actor_get_size (self, &width, &height);
+
+  geometry->x = (int) x;
+  geometry->y = (int) y;
+  geometry->width = (int) width;
+  geometry->height = (int) height;
+}
 
 /**
  * clutter_actor_get_allocation_geometry:

clutter/clutter/deprecated/clutter-actor.h

@@ -33,6 +33,13 @@
 
 G_BEGIN_DECLS
 
+CLUTTER_DEPRECATED
+void            clutter_actor_set_geometry                      (ClutterActor          *self,
+                                                                 const ClutterGeometry *geometry);
+
+CLUTTER_DEPRECATED_FOR(clutter_actor_get_allocation_geometry)
+void            clutter_actor_get_geometry                      (ClutterActor          *self,
+                                                                 ClutterGeometry       *geometry);
 CLUTTER_DEPRECATED
 guint32         clutter_actor_get_gid                           (ClutterActor          *self);
 

clutter/clutter/deprecated/clutter-backend.h

@@ -0,0 +1,64 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
+ * Copyright (C) 2009, 2010 Intel Corp
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_BACKEND_DEPRECATED_H__
+#define __CLUTTER_BACKEND_DEPRECATED_H__
+
+#include <clutter/clutter-types.h>
+
+G_BEGIN_DECLS
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:font_dpi)
+void            clutter_backend_set_resolution                  (ClutterBackend *backend,
+                                                                 gdouble         dpi);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_time)
+void            clutter_backend_set_double_click_time           (ClutterBackend *backend,
+                                                                 guint           msec);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_time)
+guint           clutter_backend_get_double_click_time           (ClutterBackend *backend);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_distance)
+void            clutter_backend_set_double_click_distance       (ClutterBackend *backend,
+                                                                 guint           distance);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_distance)
+guint           clutter_backend_get_double_click_distance       (ClutterBackend *backend);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:font_name)
+void            clutter_backend_set_font_name                   (ClutterBackend *backend,
+                                                                 const gchar    *font_name);
+
+CLUTTER_DEPRECATED_FOR(ClutterSettings:font_name)
+const gchar *   clutter_backend_get_font_name                   (ClutterBackend *backend);
+
+
+G_END_DECLS
+
+#endif /* __CLUTTER_BACKEND_DEPRECATED_H__ */

clutter/clutter/deprecated/clutter-behaviour-depth.c

@@ -48,8 +48,7 @@
  * #ClutterBehaviourDepth is available since Clutter 0.4.
  *
  * Deprecated: 1.6: Use the #ClutterActor:depth property and
- *   clutter_actor_animate(), or #ClutterAnimator, or #ClutterState
- *   instead.
+ *   clutter_actor_animate() instead.
  */
 
 struct _ClutterBehaviourDepthPrivate

clutter/clutter/deprecated/clutter-behaviour-opacity.c

@@ -32,8 +32,7 @@
  * Since: 0.2
  *
  * Deprecated: 1.6: Use the #ClutterActor:opacity property and
- *   clutter_actor_animate(), or #ClutterAnimator, or #ClutterState
- *   instead.
+ *   clutter_actor_animate().
  */
 
 #include "clutter-build-config.h"

clutter/clutter/deprecated/clutter-behaviour-rotate.c

@@ -31,8 +31,7 @@
  * The #ClutterBehaviourRotate is available since version 0.4.
  *
  * Deprecated: 1.6: Use the #ClutterActor rotation properties and
- *   clutter_actor_animate(), or #ClutterAnimator, or #ClutterState
- *   instead.
+ *   clutter_actor_animate() instead.
  */
 
 #include "clutter-build-config.h"

clutter/clutter/deprecated/clutter-behaviour-scale.c

@@ -31,8 +31,7 @@
  * A #ClutterBehaviourScale interpolates actors size between two values.
  *
  * Deprecated: 1.6: Use the #ClutterActor:scale-x and #ClutterActor:scale-y
- *   properties, and clutter_actor_animate(), or #ClutterAnimator or
- *   #ClutterState instead.
+ *   properties, and clutter_actor_animate() instead.
  */
 
 #include "clutter-build-config.h"

clutter/clutter/deprecated/clutter-behaviour.c

@@ -25,8 +25,7 @@
  * SECTION:clutter-behaviour
  * @Title: ClutterBehaviour
  * @short_description: Class for providing behaviours to actors
- * @Deprecated: 1.6: Use clutter_actor_animate(), #ClutterAnimator or
- *   #ClutterState instead
+ * @Deprecated: 1.6: Use clutter_actor_animate() instead
  *
  * #ClutterBehaviour is the base class for implementing behaviours.  A
  * behaviour is a controller object for #ClutterActor<!-- -->s; you can

clutter/clutter/deprecated/clutter-box.c

@@ -1,745 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 2009,2010  Intel Corporation.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author:
- *      Emmanuele Bassi <ebassi@linux.intel.com>
- */
-
-/**
- * SECTION:clutter-box
- * @short_description: A Generic layout container
- *
- * #ClutterBox is a #ClutterActor sub-class implementing the #ClutterContainer
- * interface. A Box delegates the whole size requisition and size allocation to
- * a #ClutterLayoutManager instance.
- *
- * #ClutterBox is available since Clutter 1.2
- *
- * #ClutterBox is deprecated since Clutter 1.10; all its relevant API is provided
- * by #ClutterActor, via the #ClutterActor:layout-manager property.
- *
- * ## Using ClutterBox
- *
- * The following code shows how to create a #ClutterBox with
- * a #ClutterLayoutManager sub-class, and how to add children to
- * it via clutter_box_pack().
- *
- * |[<!-- language="C" -->
- *  ClutterActor *box;
- *  ClutterLayoutManager *layout;
- *
- *  // Create the layout manager first
- *  layout = clutter_box_layout_new ();
- *  clutter_box_layout_set_homogeneous (CLUTTER_BOX_LAYOUT (layout), TRUE);
- *  clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (layout), 12);
- *
- *  // Then create the ClutterBox actor. The Box will take
- *  // ownership of the ClutterLayoutManager instance by sinking
- *  // its floating reference
- *  box = clutter_box_new (layout);
- *
- *  // Now add children to the Box using the variadic arguments
- *  // function clutter_box_pack() to set layout properties
- *  clutter_box_pack (CLUTTER_BOX (box), actor,
- *                    "x-align", CLUTTER_BOX_ALIGNMENT_CENTER,
- *                    "y-align", CLUTTER_BOX_ALIGNMENT_END,
- *                    "expand", TRUE,
- *                    NULL);
- * ]|
- *
- * #ClutterBox's clutter_box_pack() wraps the generic
- * clutter_container_add_actor() function, but it also allows setting
- * layout properties while adding the new child to the box.
- */
-
-#include "clutter-build-config.h"
-
-#include <glib-object.h>
-#include <gobject/gvaluecollector.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "deprecated/clutter-container.h"
-
-#include "clutter-box.h"
-
-#include "clutter-actor-private.h"
-#include "clutter-color.h"
-#include "clutter-debug.h"
-#include "clutter-enum-types.h"
-#include "clutter-marshal.h"
-#include "clutter-private.h"
-
-struct _ClutterBoxPrivate
-{
-  ClutterLayoutManager *manager;
-
-  guint changed_id;
-};
-
-enum
-{
-  PROP_0,
-
-  PROP_COLOR,
-  PROP_COLOR_SET,
-
-  PROP_LAST
-};
-
-static GParamSpec *obj_props[PROP_LAST] = { NULL, };
-
-static const ClutterColor default_box_color = { 255, 255, 255, 255 };
-
-G_DEFINE_TYPE_WITH_PRIVATE (ClutterBox, clutter_box, CLUTTER_TYPE_ACTOR)
-
-static inline void
-clutter_box_set_color_internal (ClutterBox         *box,
-                                const ClutterColor *color)
-{
-  clutter_actor_set_background_color (CLUTTER_ACTOR (box), color);
-
-  g_object_notify_by_pspec (G_OBJECT (box), obj_props[PROP_COLOR_SET]);
-  g_object_notify_by_pspec (G_OBJECT (box), obj_props[PROP_COLOR]);
-}
-
-static gboolean
-clutter_box_real_get_paint_volume (ClutterActor       *actor,
-                                   ClutterPaintVolume *volume)
-{
-  gboolean retval = FALSE;
-  ClutterActorIter iter;
-  ClutterActor *child;
-
-  /* if we have a background color, and an allocation, then we need to
-   * set it as the base of our paint volume
-   */
-  retval = clutter_paint_volume_set_from_allocation (volume, actor);
-
-  /* bail out early if we don't have any child */
-  if (clutter_actor_get_n_children (actor) == 0)
-    return retval;
-
-  retval = TRUE;
-
-  /* otherwise, union the paint volumes of our children, in case
-   * any one of them decides to paint outside the parent's allocation
-   */
-  clutter_actor_iter_init (&iter, actor);
-  while (clutter_actor_iter_next (&iter, &child))
-    {
-      const ClutterPaintVolume *child_volume;
-
-      /* This gets the paint volume of the child transformed into the
-       * group's coordinate space... */
-      child_volume = clutter_actor_get_transformed_paint_volume (child, actor);
-      if (!child_volume)
-        return FALSE;
-
-      clutter_paint_volume_union (volume, child_volume);
-    }
-
-  return retval;
-}
-
-static void
-clutter_box_set_property (GObject      *gobject,
-                          guint         prop_id,
-                          const GValue *value,
-                          GParamSpec   *pspec)
-{
-  ClutterBox *self = CLUTTER_BOX (gobject);
-
-  switch (prop_id)
-    {
-    case PROP_COLOR:
-      clutter_box_set_color_internal (self, clutter_value_get_color (value));
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-clutter_box_get_property (GObject    *gobject,
-                          guint       prop_id,
-                          GValue     *value,
-                          GParamSpec *pspec)
-{
-  switch (prop_id)
-    {
-    case PROP_COLOR:
-      {
-        ClutterColor color;
-
-        clutter_actor_get_background_color (CLUTTER_ACTOR (gobject),
-                                            &color);
-        clutter_value_set_color (value, &color);
-      }
-      break;
-
-    case PROP_COLOR_SET:
-      {
-        gboolean color_set;
-
-        g_object_get (gobject, "background-color-set", &color_set, NULL);
-        g_value_set_boolean (value, color_set);
-      }
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-clutter_box_real_destroy (ClutterActor *actor)
-{
-  ClutterActor *iter;
-
-  iter = clutter_actor_get_first_child (actor);
-  while (iter != NULL)
-    {
-      ClutterActor *next = clutter_actor_get_next_sibling (iter);
-
-      clutter_actor_destroy (iter);
-
-      iter = next;
-    }
-}
-
-static void
-clutter_box_class_init (ClutterBoxClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
-
-  actor_class->destroy = clutter_box_real_destroy;
-  actor_class->get_paint_volume = clutter_box_real_get_paint_volume;
-
-  gobject_class->set_property = clutter_box_set_property;
-  gobject_class->get_property = clutter_box_get_property;
-
-  /**
-   * ClutterBox:color:
-   *
-   * The color to be used to paint the background of the
-   * #ClutterBox. Setting this property will set the
-   * #ClutterBox:color-set property as a side effect
-   *
-   * This property sets the #ClutterActor:background-color property
-   * internally.
-   *
-   * Since: 1.2
-   *
-   * Deprecated: 1.10: Use the #ClutterActor:background-color property
-   */
-  obj_props[PROP_COLOR] =
-    clutter_param_spec_color ("color",
-                              P_("Color"),
-                              P_("The background color of the box"),
-                              &default_box_color,
-                              CLUTTER_PARAM_READWRITE);
-
-  /**
-   * ClutterBox:color-set:
-   *
-   * Whether the #ClutterBox:color property has been set.
-   *
-   * This property reads the #ClutterActor:background-color-set property
-   * internally.
-   *
-   * Since: 1.2
-   *
-   * Deprecated: 1.10: Use the #ClutterActor:background-color-set property
-   */
-  obj_props[PROP_COLOR_SET] =
-    g_param_spec_boolean ("color-set",
-                          P_("Color Set"),
-                          P_("Whether the background color is set"),
-                          FALSE,
-                          CLUTTER_PARAM_READWRITE);
-
-  g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
-}
-
-static void
-clutter_box_init (ClutterBox *self)
-{
-  self->priv = clutter_box_get_instance_private (self);
-}
-
-/**
- * clutter_box_new:
- * @manager: a #ClutterLayoutManager
- *
- * Creates a new #ClutterBox. The children of the box will be layed
- * out by the passed @manager
- *
- * Return value: the newly created #ClutterBox actor
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_new() instead.
- */
-ClutterActor *
-clutter_box_new (ClutterLayoutManager *manager)
-{
-  g_return_val_if_fail (CLUTTER_IS_LAYOUT_MANAGER (manager), NULL);
-
-  return g_object_new (CLUTTER_TYPE_BOX,
-                       "layout-manager", manager,
-                       NULL);
-}
-
-/**
- * clutter_box_set_layout_manager:
- * @box: a #ClutterBox
- * @manager: a #ClutterLayoutManager
- *
- * Sets the #ClutterLayoutManager for @box
- *
- * A #ClutterLayoutManager is a delegate object that controls the
- * layout of the children of @box
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_set_layout_manager() instead.
- */
-void
-clutter_box_set_layout_manager (ClutterBox           *box,
-                                ClutterLayoutManager *manager)
-{
-  clutter_actor_set_layout_manager (CLUTTER_ACTOR (box), manager);
-}
-
-/**
- * clutter_box_get_layout_manager:
- * @box: a #ClutterBox
- *
- * Retrieves the #ClutterLayoutManager instance used by @box
- *
- * Return value: (transfer none): a #ClutterLayoutManager. The returned
- *   #ClutterLayoutManager is owned by the #ClutterBox and it should not
- *   be unreferenced
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_get_layout_manager() instead.
- */
-ClutterLayoutManager *
-clutter_box_get_layout_manager (ClutterBox *box)
-{
-  return clutter_actor_get_layout_manager (CLUTTER_ACTOR (box));
-}
-
-/**
- * clutter_box_packv:
- * @box: a #ClutterBox
- * @actor: a #ClutterActor
- * @n_properties: the number of properties to set
- * @properties: (array length=n_properties) (element-type utf8): a vector
- *   containing the property names to set
- * @values: (array length=n_properties): a vector containing the property
- *   values to set
- *
- * Vector-based variant of clutter_box_pack(), intended for language
- * bindings to use
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_add_child() instead. To set
- *   specific layout properties, use clutter_layout_manager_child_set()
- */
-void
-clutter_box_packv (ClutterBox          *box,
-                   ClutterActor        *actor,
-                   guint                n_properties,
-                   const gchar * const  properties[],
-                   const GValue        *values)
-{
-  ClutterLayoutManager *manager;
-  ClutterContainer *container;
-  ClutterLayoutMeta *meta;
-  GObjectClass *klass;
-  gint i;
-
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-
-  container = CLUTTER_CONTAINER (box);
-  clutter_container_add_actor (container, actor);
-
-  manager = clutter_actor_get_layout_manager (CLUTTER_ACTOR (box));
-  if (manager == NULL)
-    return;
-
-  meta = clutter_layout_manager_get_child_meta (manager,
-                                                container,
-                                                actor);
-
-  if (meta == NULL)
-    return;
-
-  klass = G_OBJECT_GET_CLASS (meta);
-
-  for (i = 0; i < n_properties; i++)
-    {
-      const gchar *pname = properties[i];
-      GParamSpec *pspec;
-
-      pspec = g_object_class_find_property (klass, pname);
-      if (pspec == NULL)
-        {
-          g_warning ("%s: the layout property '%s' for managers "
-                     "of type '%s' (meta type '%s') does not exist",
-                     G_STRLOC,
-                     pname,
-                     G_OBJECT_TYPE_NAME (manager),
-                     G_OBJECT_TYPE_NAME (meta));
-          break;
-        }
-
-      if (!(pspec->flags & G_PARAM_WRITABLE))
-        {
-          g_warning ("%s: the layout property '%s' for managers "
-                     "of type '%s' (meta type '%s') is not writable",
-                     G_STRLOC,
-                     pspec->name,
-                     G_OBJECT_TYPE_NAME (manager),
-                     G_OBJECT_TYPE_NAME (meta));
-          break;
-        }
-
-      clutter_layout_manager_child_set_property (manager,
-                                                 container, actor,
-                                                 pname, &values[i]);
-    }
-}
-
-static inline void
-clutter_box_set_property_valist (ClutterBox   *box,
-                                 ClutterActor *actor,
-                                 const gchar  *first_property,
-                                 va_list       var_args)
-{
-  ClutterContainer *container = CLUTTER_CONTAINER (box);
-  ClutterLayoutManager *manager;
-  ClutterLayoutMeta *meta;
-  GObjectClass *klass;
-  const gchar *pname;
-
-  manager = clutter_actor_get_layout_manager (CLUTTER_ACTOR (box));
-  if (manager == NULL)
-    return;
-
-  meta = clutter_layout_manager_get_child_meta (manager,
-                                                container,
-                                                actor);
-
-  if (meta == NULL)
-    return;
-
-  klass = G_OBJECT_GET_CLASS (meta);
-
-  pname = first_property;
-  while (pname)
-    {
-      GValue value = { 0, };
-      GParamSpec *pspec;
-      gchar *error;
-
-      pspec = g_object_class_find_property (klass, pname);
-      if (pspec == NULL)
-        {
-          g_warning ("%s: the layout property '%s' for managers "
-                     "of type '%s' (meta type '%s') does not exist",
-                     G_STRLOC,
-                     pname,
-                     G_OBJECT_TYPE_NAME (manager),
-                     G_OBJECT_TYPE_NAME (meta));
-          break;
-        }
-
-      if (!(pspec->flags & G_PARAM_WRITABLE))
-        {
-          g_warning ("%s: the layout property '%s' for managers "
-                     "of type '%s' (meta type '%s') is not writable",
-                     G_STRLOC,
-                     pspec->name,
-                     G_OBJECT_TYPE_NAME (manager),
-                     G_OBJECT_TYPE_NAME (meta));
-          break;
-        }
-
-      G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
-                            var_args, 0,
-                            &error);
-
-      if (error)
-        {
-          g_warning ("%s: %s", G_STRLOC, error);
-          g_free (error);
-          break;
-        }
-
-      clutter_layout_manager_child_set_property (manager,
-                                                 container, actor,
-                                                 pspec->name, &value);
-
-      g_value_unset (&value);
-
-      pname = va_arg (var_args, gchar*);
-    }
-}
-
-/**
- * clutter_box_pack:
- * @box: a #ClutterBox
- * @actor: a #ClutterActor
- * @first_property: the name of the first property to set, or %NULL
- * @...: a list of property name and value pairs, terminated by %NULL
- *
- * Adds @actor to @box and sets layout properties at the same time,
- * if the #ClutterLayoutManager used by @box has them
- *
- * This function is a wrapper around clutter_container_add_actor()
- * and clutter_layout_manager_child_set()
- *
- * Language bindings should use the vector-based clutter_box_packv()
- * variant instead
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_add_child() instead. To set
- *   specific layout properties, use clutter_layout_manager_child_set()
- */
-void
-clutter_box_pack (ClutterBox   *box,
-                  ClutterActor *actor,
-                  const gchar  *first_property,
-                  ...)
-{
-  va_list var_args;
-
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-
-  clutter_container_add_actor (CLUTTER_CONTAINER (box), actor);
-
-  if (first_property == NULL || *first_property == '\0')
-    return;
-
-  va_start (var_args, first_property);
-  clutter_box_set_property_valist (box, actor, first_property, var_args);
-  va_end (var_args);
-}
-
-/**
- * clutter_box_pack_after:
- * @box: a #ClutterBox
- * @actor: a #ClutterActor
- * @sibling: (allow-none): a #ClutterActor or %NULL
- * @first_property: the name of the first property to set, or %NULL
- * @...: a list of property name and value pairs, terminated by %NULL
- *
- * Adds @actor to @box, placing it after @sibling, and sets layout
- * properties at the same time, if the #ClutterLayoutManager used by
- * @box supports them
- *
- * If @sibling is %NULL then @actor is placed at the end of the
- * list of children, to be allocated and painted after every other child
- *
- * This function is a wrapper around clutter_container_add_actor(),
- * clutter_container_raise_child() and clutter_layout_manager_child_set()
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_insert_child_above() instead.
- *   To set specific layout properties, use clutter_layout_manager_child_set()
- */
-void
-clutter_box_pack_after (ClutterBox   *box,
-                        ClutterActor *actor,
-                        ClutterActor *sibling,
-                        const gchar  *first_property,
-                        ...)
-{
-  va_list var_args;
-
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-  g_return_if_fail (sibling == NULL || CLUTTER_IS_ACTOR (sibling));
-
-  clutter_container_add_actor (CLUTTER_CONTAINER (box), actor);
-  clutter_container_raise_child (CLUTTER_CONTAINER (box), actor, sibling);
-
-  if (first_property == NULL || *first_property == '\0')
-    return;
-
-  va_start (var_args, first_property);
-  clutter_box_set_property_valist (box, actor, first_property, var_args);
-  va_end (var_args);
-}
-
-/**
- * clutter_box_pack_before:
- * @box: a #ClutterBox
- * @actor: a #ClutterActor
- * @sibling: (allow-none): a #ClutterActor or %NULL
- * @first_property: the name of the first property to set, or %NULL
- * @...: a list of property name and value pairs, terminated by %NULL
- *
- * Adds @actor to @box, placing it before @sibling, and sets layout
- * properties at the same time, if the #ClutterLayoutManager used by
- * @box supports them
- *
- * If @sibling is %NULL then @actor is placed at the beginning of the
- * list of children, to be allocated and painted below every other child
- *
- * This function is a wrapper around clutter_container_add_actor(),
- * clutter_container_lower_child() and clutter_layout_manager_child_set()
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_insert_child_below() instead.
- *   To set specific layout properties, use clutter_layout_manager_child_set()
- */
-void
-clutter_box_pack_before (ClutterBox   *box,
-                         ClutterActor *actor,
-                         ClutterActor *sibling,
-                         const gchar  *first_property,
-                         ...)
-{
-  va_list var_args;
-
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-  g_return_if_fail (sibling == NULL || CLUTTER_IS_ACTOR (sibling));
-
-  clutter_container_add_actor (CLUTTER_CONTAINER (box), actor);
-  clutter_container_lower_child (CLUTTER_CONTAINER (box), actor, sibling);
-
-  if (first_property == NULL || *first_property == '\0')
-    return;
-
-  va_start (var_args, first_property);
-  clutter_box_set_property_valist (box, actor, first_property, var_args);
-  va_end (var_args);
-}
-
-/**
- * clutter_box_pack_at:
- * @box: a #ClutterBox
- * @actor: a #ClutterActor
- * @position: the position to insert the @actor at
- * @first_property: the name of the first property to set, or %NULL
- * @...: a list of property name and value pairs, terminated by %NULL
- *
- * Adds @actor to @box, placing it at @position, and sets layout
- * properties at the same time, if the #ClutterLayoutManager used by
- * @box supports them
- *
- * If @position is a negative number, or is larger than the number of
- * children of @box, the new child is added at the end of the list of
- * children
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_insert_child_at_index() instead.
- *   To set specific layout properties, use clutter_layout_manager_child_set()
- */
-void
-clutter_box_pack_at (ClutterBox   *box,
-                     ClutterActor *actor,
-                     gint          position,
-                     const gchar  *first_property,
-                     ...)
-{
-  va_list var_args;
-
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (CLUTTER_IS_ACTOR (actor));
-
-  clutter_actor_insert_child_at_index (CLUTTER_ACTOR (box),
-                                       actor,
-                                       position);
-
-  /* we need to explicitly call this, because we're not going through
-   * the default code paths provided by clutter_container_add()
-   */
-  clutter_container_create_child_meta (CLUTTER_CONTAINER (box), actor);
-
-  g_signal_emit_by_name (box, "actor-added", actor);
-
-  if (first_property == NULL || *first_property == '\0')
-    return;
-
-  va_start (var_args, first_property);
-  clutter_box_set_property_valist (box, actor, first_property, var_args);
-  va_end (var_args);
-}
-
-/**
- * clutter_box_set_color:
- * @box: a #ClutterBox
- * @color: (allow-none): the background color, or %NULL to unset
- *
- * Sets (or unsets) the background color for @box
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_set_background_color() instead.
- */
-void
-clutter_box_set_color (ClutterBox         *box,
-                       const ClutterColor *color)
-{
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-
-  clutter_box_set_color_internal (box, color);
-}
-
-/**
- * clutter_box_get_color:
- * @box: a #ClutterBox
- * @color: (out caller-allocates): return location for a #ClutterColor
- *
- * Retrieves the background color of @box
- *
- * If the #ClutterBox:color-set property is set to %FALSE the
- * returned #ClutterColor is undefined
- *
- * Since: 1.2
- *
- * Deprecated: 1.10: Use clutter_actor_get_background_color() instead.
- */
-void
-clutter_box_get_color (ClutterBox   *box,
-                       ClutterColor *color)
-{
-  g_return_if_fail (CLUTTER_IS_BOX (box));
-  g_return_if_fail (color != NULL);
-
-  clutter_actor_get_background_color (CLUTTER_ACTOR (box), color);
-}

clutter/clutter/deprecated/clutter-box.h

@@ -1,143 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 2009,2010  Intel Corporation.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author:
- *      Emmanuele Bassi <ebassi@linux.intel.com>
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_BOX_H__
-#define __CLUTTER_BOX_H__
-
-#include <clutter/clutter-actor.h>
-#include <clutter/clutter-container.h>
-#include <clutter/clutter-layout-manager.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_BOX                (clutter_box_get_type ())
-#define CLUTTER_BOX(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BOX, ClutterBox))
-#define CLUTTER_IS_BOX(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BOX))
-#define CLUTTER_BOX_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BOX, ClutterBoxClass))
-#define CLUTTER_IS_BOX_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BOX))
-#define CLUTTER_BOX_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BOX, ClutterBoxClass))
-
-typedef struct _ClutterBox              ClutterBox;
-typedef struct _ClutterBoxPrivate       ClutterBoxPrivate;
-typedef struct _ClutterBoxClass         ClutterBoxClass;
-
-/**
- * ClutterBox:
- *
- * The #ClutterBox structure contains only private data and should
- * be accessed using the provided API
- *
- * Since: 1.2
- */
-struct _ClutterBox
-{
-  /*< private >*/
-  ClutterActor parent_instance;
-
-  ClutterBoxPrivate *priv;
-};
-
-/**
- * ClutterBoxClass:
- *
- * The #ClutterBoxClass structure contains only private data
- *
- * Since: 1.2
- */
-struct _ClutterBoxClass
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-
-  /* padding, for future expansion */
-  void (*clutter_padding_1) (void);
-  void (*clutter_padding_2) (void);
-  void (*clutter_padding_3) (void);
-  void (*clutter_padding_4) (void);
-  void (*clutter_padding_5) (void);
-  void (*clutter_padding_6) (void);
-};
-
-CLUTTER_DEPRECATED
-GType clutter_box_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_new)
-ClutterActor *        clutter_box_new                (ClutterLayoutManager *manager);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_set_layout_manager)
-void                  clutter_box_set_layout_manager (ClutterBox           *box,
-                                                      ClutterLayoutManager *manager);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_layout_manager)
-ClutterLayoutManager *clutter_box_get_layout_manager (ClutterBox           *box);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_set_background_color)
-void                  clutter_box_set_color          (ClutterBox           *box,
-                                                      const ClutterColor   *color);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_background_color)
-void                  clutter_box_get_color          (ClutterBox           *box,
-                                                      ClutterColor         *color);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_add_child)
-void                  clutter_box_pack               (ClutterBox           *box,
-                                                      ClutterActor         *actor,
-                                                      const gchar          *first_property,
-                                                      ...);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_add_child)
-void                  clutter_box_packv              (ClutterBox           *box,
-                                                      ClutterActor         *actor,
-                                                      guint                 n_properties,
-                                                      const gchar * const   properties[],
-                                                      const GValue         *values);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_insert_child_above)
-void                  clutter_box_pack_after         (ClutterBox           *box,
-                                                      ClutterActor         *actor,
-                                                      ClutterActor         *sibling,
-                                                      const gchar          *first_property,
-                                                      ...);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_insert_child_below)
-void                  clutter_box_pack_before        (ClutterBox           *box,
-                                                      ClutterActor         *actor,
-                                                      ClutterActor         *sibling,
-                                                      const gchar          *first_property,
-                                                      ...);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_insert_child_at_index)
-void                  clutter_box_pack_at            (ClutterBox           *box,
-                                                      ClutterActor         *actor,
-                                                      gint                  position,
-                                                      const gchar          *first_property,
-                                                      ...);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_BOX_H__ */