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

@@ -17,4 +17,8 @@ test-mutter:
     - meson . build -Degl_device=true -Dwayland_eglstream=true
     - ninja -C build
     - glib-compile-schemas $PWD/build/data
-    - env XDG_RUNTIME_DIR=/tmp/ GSETTINGS_SCHEMA_DIR=$PWD/build/data dbus-run-session -- xvfb-run -s '+iglx -noreset' meson test -C build -t 10 --verbose --no-stdsplit --wrap catchsegv
+    - 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,11 +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/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
-
-    # Packages not yet in stable
-    dnf install -y https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-devel-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-libs-0.2.5-1.fc29.x86_64.rpm && \
-
     dnf install -y intltool redhat-rpm-config make && \
     dnf clean all

Makefile.am

@@ -0,0 +1,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,32 +1,3 @@
-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]

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

@@ -275,13 +275,13 @@ void                            _clutter_actor_set_enable_paint_unmapped
 void                            _clutter_actor_set_has_pointer                          (ClutterActor *self,
                                                                                          gboolean      has_pointer);
 
-void                            _clutter_actor_queue_redraw_with_clip                   (ClutterActor             *self,
-                                                                                         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,

clutter/clutter/clutter-actor.c

@@ -1108,7 +1108,6 @@ static void clutter_actor_pop_in_cloned_branch (ClutterActor *self,
   { _transform; }                                                      \
   cogl_matrix_translate ((m), -_tx, -_ty, -_tz);        } G_STMT_END
 
-static GQuark quark_shader_data = 0;
 static GQuark quark_actor_layout_info = 0;
 static GQuark quark_actor_transform_info = 0;
 static GQuark quark_actor_animation_info = 0;
@@ -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
@@ -3561,12 +3521,6 @@ _clutter_actor_update_last_paint_volume (ClutterActor *self)
   priv->last_paint_volume_valid = TRUE;
 }
 
-static inline gboolean
-actor_has_shader_data (ClutterActor *self)
-{
-  return g_object_get_qdata (G_OBJECT (self), quark_shader_data) != NULL;
-}
-
 guint32
 _clutter_actor_get_pick_id (ClutterActor *self)
 {
@@ -3808,7 +3762,6 @@ clutter_actor_paint (ClutterActor *self)
   ClutterActorPrivate *priv;
   ClutterPickMode pick_mode;
   gboolean clip_set = FALSE;
-  gboolean shader_applied = FALSE;
   ClutterStage *stage;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
@@ -3979,13 +3932,6 @@ clutter_actor_paint (ClutterActor *self)
 
   if (priv->effects == NULL)
     {
-      if (pick_mode == CLUTTER_PICK_NONE &&
-          actor_has_shader_data (self))
-        {
-          _clutter_actor_shader_pre_paint (self, FALSE);
-          shader_applied = TRUE;
-        }
-
       priv->next_effect_to_paint = NULL;
     }
   else
@@ -3994,9 +3940,6 @@ clutter_actor_paint (ClutterActor *self)
 
   clutter_actor_continue_paint (self);
 
-  if (shader_applied)
-    _clutter_actor_shader_post_paint (self);
-
   if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_VOLUMES &&
                   pick_mode == CLUTTER_PICK_NONE))
     _clutter_actor_draw_paint_volume (self);
@@ -4880,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
@@ -6337,7 +6279,6 @@ clutter_actor_class_init (ClutterActorClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  quark_shader_data = g_quark_from_static_string ("-clutter-actor-shader-data");
   quark_actor_layout_info = g_quark_from_static_string ("-clutter-actor-layout-info");
   quark_actor_transform_info = g_quark_from_static_string ("-clutter-actor-transform-info");
   quark_actor_animation_info = g_quark_from_static_string ("-clutter-actor-animation-info");
@@ -8763,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:
@@ -8912,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
@@ -9034,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 */
@@ -10313,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);
 }
 
 /**
@@ -13675,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);
 }
 
 /**
@@ -13722,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);
 }
 
 /**
@@ -15224,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);
 

clutter/clutter/clutter-backend.c

@@ -430,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");

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-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-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-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

clutter/clutter/clutter-deprecated.h

@@ -7,7 +7,6 @@
 #include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"
-#include "deprecated/clutter-animator.h"
 #include "deprecated/clutter-backend.h"
 #include "deprecated/clutter-behaviour.h"
 #include "deprecated/clutter-behaviour-depth.h"
@@ -17,26 +16,16 @@
 #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-frame-source.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-score.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-timeout-pool.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-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-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-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-master-clock-default.c

@@ -298,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;
     }
 

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);
 

clutter/clutter/clutter-offscreen-effect.c

@@ -352,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);
@@ -362,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

clutter/clutter/clutter-paint-volume.c

@@ -1164,21 +1164,6 @@ _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.

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-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,14 +6,6 @@
 #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;
@@ -44,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)
 {
@@ -152,14 +138,6 @@ _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)
 {
@@ -177,12 +155,6 @@ _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)
 {

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);
@@ -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,
@@ -1501,7 +1490,7 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
                 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"),
@@ -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,8 +277,6 @@ 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 ClutterAnimatableIface *parent_animatable_iface = NULL;
 static ClutterScriptableIface *parent_scriptable_iface = NULL;
 
@@ -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);

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,8 +90,6 @@ typedef struct _ClutterVertex                   ClutterVertex;
 
 typedef struct _ClutterAlpha            	ClutterAlpha;
 typedef struct _ClutterAnimation                ClutterAnimation;
-typedef struct _ClutterAnimator         	ClutterAnimator;
-typedef struct _ClutterState            	ClutterState;
 
 typedef struct _ClutterInputDeviceTool          ClutterInputDeviceTool;
 typedef struct _ClutterInputDevice              ClutterInputDevice;
@@ -116,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.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"

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

@@ -351,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,
@@ -422,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);
@@ -576,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)
@@ -622,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)
@@ -953,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;
 

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

@@ -7,314 +7,6 @@
 
 #include "clutter-actor-private.h"
 #include "clutter-private.h"
-#include "clutter-shader.h"
-
-typedef struct _ShaderData ShaderData;
-
-struct _ShaderData
-{
-  ClutterShader *shader;
-
-  /* back pointer to the actor */
-  ClutterActor *actor;
-
-  /* list of values that should be set on the shader
-   * before each paint cycle
-   */
-  GHashTable *value_hash;
-};
-
-static void
-shader_value_free (gpointer data)
-{
-  GValue *var = data;
-  g_value_unset (var);
-  g_slice_free (GValue, var);
-}
-
-static void
-destroy_shader_data (gpointer data)
-{
-  ShaderData *shader_data = data;
-
-  if (shader_data == NULL)
-    return;
-
-  if (shader_data->shader != NULL)
-    {
-      g_object_unref (shader_data->shader);
-      shader_data->shader = NULL;
-    }
-
-  if (shader_data->value_hash != NULL)
-    {
-      g_hash_table_destroy (shader_data->value_hash);
-      shader_data->value_hash = NULL;
-    }
-
-  g_slice_free (ShaderData, shader_data);
-}
-
-/**
- * clutter_actor_get_shader:
- * @self: a #ClutterActor
- *
- * Queries the currently set #ClutterShader on @self.
- *
- * Return value: (transfer none): The currently set #ClutterShader
- *   or %NULL if no shader is set.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use clutter_actor_get_effect() instead.
- */
-ClutterShader *
-clutter_actor_get_shader (ClutterActor *self)
-{
-  ShaderData *shader_data;
-
-  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data != NULL)
-    return shader_data->shader;
-
-  return NULL;
-}
-
-/**
- * clutter_actor_set_shader:
- * @self: a #ClutterActor
- * @shader: (allow-none): a #ClutterShader or %NULL to unset the shader.
- *
- * Sets the #ClutterShader to be used when rendering @self.
- *
- * If @shader is %NULL this function will unset any currently set shader
- * for the actor.
- *
- * Any #ClutterEffect applied to @self will take the precedence
- * over the #ClutterShader set using this function.
- *
- * Return value: %TRUE if the shader was successfully applied
- *   or removed
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect and
- *   clutter_actor_add_effect() instead.
- */
-gboolean
-clutter_actor_set_shader (ClutterActor  *self,
-                          ClutterShader *shader)
-{
-  ShaderData *shader_data;
-
-  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
-  g_return_val_if_fail (shader == NULL || CLUTTER_IS_SHADER (shader), FALSE);
-
-  if (shader != NULL)
-    g_object_ref (shader);
-  else
-    {
-      /* if shader passed in is NULL we destroy the shader */
-      g_object_set_data (G_OBJECT (self), "-clutter-actor-shader-data", NULL);
-      return TRUE;
-    }
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    {
-      shader_data = g_slice_new (ShaderData);
-      shader_data->actor = self;
-      shader_data->shader = NULL;
-      shader_data->value_hash =
-        g_hash_table_new_full (g_str_hash, g_str_equal,
-                               g_free,
-                               shader_value_free);
-
-      g_object_set_data_full (G_OBJECT (self), "-clutter-actor-shader-data",
-                              shader_data,
-                              destroy_shader_data);
-    }
-
-  if (shader_data->shader != NULL)
-    g_object_unref (shader_data->shader);
-
-  shader_data->shader = shader;
-
-  clutter_actor_queue_redraw (self);
-
-  return TRUE;
-}
-
-static void
-set_each_param (gpointer key,
-                gpointer value,
-                gpointer user_data)
-{
-  ClutterShader *shader = user_data;
-  const gchar *uniform = key;
-  GValue *var = value;
-
-  clutter_shader_set_uniform (shader, uniform, var);
-}
-
-void
-_clutter_actor_shader_pre_paint (ClutterActor *actor,
-                                 gboolean      repeat)
-{
-  ShaderData *shader_data;
-  ClutterShader *shader;
-
-  shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    return;
-
-  shader = shader_data->shader;
-  if (shader != NULL)
-    {
-      clutter_shader_set_is_enabled (shader, TRUE);
-
-      g_hash_table_foreach (shader_data->value_hash, set_each_param, shader);
-
-      if (!repeat)
-        _clutter_context_push_shader_stack (actor);
-    }
-}
-
-void
-_clutter_actor_shader_post_paint (ClutterActor *actor)
-{
-  ShaderData *shader_data;
-  ClutterShader *shader;
-
-  shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
-  if (G_LIKELY (shader_data == NULL))
-    return;
-
-  shader = shader_data->shader;
-  if (shader != NULL)
-    {
-      ClutterActor *head;
-
-      clutter_shader_set_is_enabled (shader, FALSE);
-
-      /* remove the actor from the shaders stack; if there is another
-       * actor inside it, then call pre-paint again to set its shader
-       * but this time with the second argument being TRUE, indicating
-       * that we are re-applying an existing shader and thus should it
-       * not be prepended to the stack
-       */
-      head = _clutter_context_pop_shader_stack (actor);
-      if (head != NULL)
-        _clutter_actor_shader_pre_paint (head, TRUE);
-    }
-}
-
-static inline void
-clutter_actor_set_shader_param_internal (ClutterActor *self,
-                                         const gchar  *param,
-                                         const GValue *value)
-{
-  ShaderData *shader_data;
-  GValue *var;
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    return;
-
-  var = g_slice_new0 (GValue);
-  g_value_init (var, G_VALUE_TYPE (value));
-  g_value_copy (value, var);
-  g_hash_table_insert (shader_data->value_hash, g_strdup (param), var);
-
-  clutter_actor_queue_redraw (self);
-}
-
-/**
- * clutter_actor_set_shader_param:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named parameter of the shader applied
- * to @actor.
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform_value() instead
- */
-void
-clutter_actor_set_shader_param (ClutterActor *self,
-                                const gchar  *param,
-                                const GValue *value)
-{
-  g_return_if_fail (CLUTTER_IS_ACTOR (self));
-  g_return_if_fail (param != NULL);
-  g_return_if_fail (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_INT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value) ||
-                    G_VALUE_HOLDS_FLOAT (value) ||
-                    G_VALUE_HOLDS_INT (value));
-
-  clutter_actor_set_shader_param_internal (self, param, value);
-}
-
-/**
- * clutter_actor_set_shader_param_float:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named float parameter of the shader applied
- * to @actor.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
- */
-void
-clutter_actor_set_shader_param_float (ClutterActor *self,
-                                      const gchar  *param,
-                                      gfloat        value)
-{
-  GValue var = { 0, };
-
-  g_value_init (&var, G_TYPE_FLOAT);
-  g_value_set_float (&var, value);
-
-  clutter_actor_set_shader_param_internal (self, param, &var);
-
-  g_value_unset (&var);
-}
-
-/**
- * clutter_actor_set_shader_param_int:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named int parameter of the shader applied to
- * @actor.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
- */
-void
-clutter_actor_set_shader_param_int (ClutterActor *self,
-                                    const gchar  *param,
-                                    gint          value)
-{
-  GValue var = { 0, };
-
-  g_value_init (&var, G_TYPE_INT);
-  g_value_set_int (&var, value);
-
-  clutter_actor_set_shader_param_internal (self, param, &var);
-
-  g_value_unset (&var);
-}
 
 /**
  * clutter_actor_set_geometry:

clutter/clutter/deprecated/clutter-animator.h

@@ -1,188 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 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:
- *   Øyvind Kolås <pippin@linux.intel.com>
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_ANIMATOR_H__
-#define __CLUTTER_ANIMATOR_H__
-
-#include <clutter/clutter-types.h>
-#include <clutter/clutter-timeline.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_ANIMATOR                   (clutter_animator_get_type ())
-#define CLUTTER_TYPE_ANIMATOR_KEY               (clutter_animator_key_get_type ())
-
-#define CLUTTER_ANIMATOR(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ANIMATOR, ClutterAnimator))
-#define CLUTTER_ANIMATOR_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ANIMATOR, ClutterAnimatorClass))
-#define CLUTTER_IS_ANIMATOR(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ANIMATOR))
-#define CLUTTER_IS_ANIMATOR_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ANIMATOR))
-#define CLUTTER_ANIMATOR_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ANIMATOR, ClutterAnimatorClass))
-
-/* ClutterAnimator is typedef in clutter-types.h */
-
-typedef struct _ClutterAnimatorClass   ClutterAnimatorClass;
-typedef struct _ClutterAnimatorPrivate ClutterAnimatorPrivate;
-
-/**
- * ClutterAnimatorKey:
- *
- * A key frame inside a #ClutterAnimator
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-typedef struct _ClutterAnimatorKey     ClutterAnimatorKey;
-
-/**
- * ClutterAnimator:
- *
- * The #ClutterAnimator structure contains only private data and
- * should be accessed using the provided API
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-struct _ClutterAnimator
-{
-  /*< private >*/
-  GObject parent_instance;
-
-  ClutterAnimatorPrivate *priv;
-};
-
-/**
- * ClutterAnimatorClass:
- *
- * The #ClutterAnimatorClass structure contains only private data
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-struct _ClutterAnimatorClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /* padding for future expansion */
-  gpointer _padding_dummy[16];
-};
-
-CLUTTER_DEPRECATED
-GType                clutter_animator_get_type                   (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterAnimator *    clutter_animator_new                        (void);
-CLUTTER_DEPRECATED
-ClutterAnimator *    clutter_animator_set_key                    (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  guint                 mode,
-                                                                  gdouble               progress,
-                                                                  const GValue         *value);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set                        (ClutterAnimator      *animator,
-                                                                  gpointer              first_object,
-                                                                  const gchar          *first_property_name,
-                                                                  guint                 first_mode,
-                                                                  gdouble               first_progress,
-                                                                  ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_DEPRECATED
-GList              * clutter_animator_get_keys                   (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress);
-
-CLUTTER_DEPRECATED
-void                 clutter_animator_remove_key                 (ClutterAnimator      *animator,
-                                                                  GObject              *object, 
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress);
-
-CLUTTER_DEPRECATED
-ClutterTimeline *    clutter_animator_start                      (ClutterAnimator      *animator);
-
-CLUTTER_DEPRECATED
-gboolean             clutter_animator_compute_value              (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress,
-                                                                  GValue               *value);
-
-CLUTTER_DEPRECATED
-ClutterTimeline *    clutter_animator_get_timeline               (ClutterAnimator      *animator);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set_timeline               (ClutterAnimator      *animator,
-                                                                  ClutterTimeline      *timeline);
-CLUTTER_DEPRECATED
-guint                clutter_animator_get_duration               (ClutterAnimator      *animator);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set_duration               (ClutterAnimator      *animator,
-                                                                  guint                 duration);
-
-CLUTTER_DEPRECATED
-gboolean             clutter_animator_property_get_ease_in       (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name);
-CLUTTER_DEPRECATED
-void                 clutter_animator_property_set_ease_in       (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gboolean              ease_in);
-
-CLUTTER_DEPRECATED
-ClutterInterpolation clutter_animator_property_get_interpolation (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name);
-CLUTTER_DEPRECATED
-void                 clutter_animator_property_set_interpolation (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  ClutterInterpolation  interpolation);
-
-CLUTTER_DEPRECATED
-GType           clutter_animator_key_get_type           (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-GObject *       clutter_animator_key_get_object         (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-const gchar *   clutter_animator_key_get_property_name  (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-GType           clutter_animator_key_get_property_type  (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gulong          clutter_animator_key_get_mode           (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gdouble         clutter_animator_key_get_progress       (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gboolean        clutter_animator_key_get_value          (const ClutterAnimatorKey *key,
-                                                         GValue                   *value);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ANIMATOR_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__ */

clutter/clutter/deprecated/clutter-frame-source.c

@@ -1,261 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Neil Roberts  <neil@linux.intel.com>
- *
- * Copyright (C) 2008 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/>.
- *
- *
- */
-
-#include "clutter-build-config.h"
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-
-#include "clutter-main.h"
-#include "clutter-private.h"
-
-#include "deprecated/clutter-frame-source.h"
-#include "deprecated/clutter-timeout-interval.h"
-
-typedef struct _ClutterFrameSource ClutterFrameSource;
-
-struct _ClutterFrameSource
-{
-  GSource source;
-
-  ClutterTimeoutInterval timeout;
-};
-
-static gboolean clutter_frame_source_prepare  (GSource     *source,
-                                               gint        *timeout);
-static gboolean clutter_frame_source_check    (GSource     *source);
-static gboolean clutter_frame_source_dispatch (GSource     *source,
-                                               GSourceFunc  callback,
-                                               gpointer     user_data);
-
-static GSourceFuncs clutter_frame_source_funcs =
-{
-  clutter_frame_source_prepare,
-  clutter_frame_source_check,
-  clutter_frame_source_dispatch,
-  NULL
-};
-
-/**
- * clutter_frame_source_add_full: (rename-to clutter_frame_source_add)
- * @priority: the priority of the frame source. Typically this will be in the
- *   range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
- * @fps: the number of times per second to call the function
- * @func: function to call
- * @data: data to pass to the function
- * @notify: function to call when the timeout source is removed
- *
- * Sets a function to be called at regular intervals with the given
- * priority.  The function is called repeatedly until it returns
- * %FALSE, at which point the timeout is automatically destroyed and
- * the function will not be called again.  The @notify function is
- * called when the timeout is destroyed.  The first call to the
- * function will be at the end of the first @interval.
- *
- * This function is similar to g_timeout_add_full() except that it
- * will try to compensate for delays. For example, if @func takes half
- * the interval time to execute then the function will be called again
- * half the interval time after it finished. In contrast
- * g_timeout_add_full() would not fire until a full interval after the
- * function completes so the delay between calls would be 1.0 / @fps *
- * 1.5. This function does not however try to invoke the function
- * multiple times to catch up missing frames if @func takes more than
- * @interval ms to execute.
- *
- * Return value: the ID (greater than 0) of the event source.
- *
- * Since: 0.8
- *
- * Deprecated: 1.6: There is no direct replacement for this API.
- */
-guint
-clutter_frame_source_add_full (gint           priority,
-			       guint          fps,
-			       GSourceFunc    func,
-			       gpointer       data,
-			       GDestroyNotify notify)
-{
-  guint ret;
-  GSource *source = g_source_new (&clutter_frame_source_funcs,
-				  sizeof (ClutterFrameSource));
-  ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
-
-  _clutter_timeout_interval_init (&frame_source->timeout, fps);
-
-  if (priority != G_PRIORITY_DEFAULT)
-    g_source_set_priority (source, priority);
-
-  g_source_set_name (source, "Clutter frame timeout");
-  g_source_set_callback (source, func, data, notify);
-
-  ret = g_source_attach (source, NULL);
-
-  g_source_unref (source);
-
-  return ret;
-}
-
-/**
- * clutter_frame_source_add: (skip)
- * @fps: the number of times per second to call the function
- * @func: function to call
- * @data: data to pass to the function
- *
- * Simple wrapper around clutter_frame_source_add_full().
- *
- * Return value: the ID (greater than 0) of the event source.
- *
- * Since: 0.8
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-guint
-clutter_frame_source_add (guint          fps,
-			  GSourceFunc    func,
-			  gpointer       data)
-{
-  return clutter_frame_source_add_full (G_PRIORITY_DEFAULT,
-					fps, func, data, NULL);
-}
-
-static gboolean
-clutter_frame_source_prepare (GSource *source,
-                              gint    *delay)
-{
-  ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
-  gint64 current_time;
-
-#if GLIB_CHECK_VERSION (2, 27, 3)
-  current_time = g_source_get_time (source) / 1000;
-#else
-  {
-    GTimeVal source_time;
-    g_source_get_current_time (source, &source_time);
-    current_time = source_time.tv_sec * 1000 + source_time.tv_usec / 1000;
-  }
-#endif
-
-  return _clutter_timeout_interval_prepare (current_time,
-                                            &frame_source->timeout,
-                                            delay);
-}
-
-static gboolean
-clutter_frame_source_check (GSource *source)
-{
-  return clutter_frame_source_prepare (source, NULL);
-}
-
-static gboolean
-clutter_frame_source_dispatch (GSource     *source,
-			       GSourceFunc  callback,
-			       gpointer     user_data)
-{
-  ClutterFrameSource *frame_source = (ClutterFrameSource *) source;
-
-  return _clutter_timeout_interval_dispatch (&frame_source->timeout,
-                                             callback, user_data);
-}
-
-/**
- * clutter_threads_add_frame_source_full: (rename-to clutter_threads_add_frame_source)
- * @priority: the priority of the frame source. Typically this will be in the
- *   range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
- * @fps: the number of times per second to call the function
- * @func: function to call
- * @data: data to pass to the function
- * @notify: function to call when the timeout source is removed
- *
- * Sets a function to be called at regular intervals holding the Clutter
- * threads lock, with the given priority. The function is called repeatedly
- * until it returns %FALSE, at which point the timeout is automatically
- * removed and the function will not be called again. The @notify function
- * is called when the timeout is removed.
- *
- * This function is similar to clutter_threads_add_timeout_full()
- * except that it will try to compensate for delays. For example, if
- * @func takes half the interval time to execute then the function
- * will be called again half the interval time after it finished. In
- * contrast clutter_threads_add_timeout_full() would not fire until a
- * full interval after the function completes so the delay between
- * calls would be @interval * 1.5. This function does not however try
- * to invoke the function multiple times to catch up missing frames if
- * @func takes more than @interval ms to execute.
- *
- * See also clutter_threads_add_idle_full().
- *
- * Return value: the ID (greater than 0) of the event source.
- *
- * Since: 0.8
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-guint
-clutter_threads_add_frame_source_full (gint           priority,
-                                       guint          fps,
-                                       GSourceFunc    func,
-                                       gpointer       data,
-                                       GDestroyNotify notify)
-{
-  ClutterThreadsDispatch *dispatch;
-
-  g_return_val_if_fail (func != NULL, 0);
-
-  dispatch = g_slice_new (ClutterThreadsDispatch);
-  dispatch->func = func;
-  dispatch->data = data;
-  dispatch->notify = notify;
-
-  return clutter_frame_source_add_full (priority,
-                                        fps,
-                                        _clutter_threads_dispatch, dispatch,
-                                        _clutter_threads_dispatch_free);
-}
-
-/**
- * clutter_threads_add_frame_source: (skip)
- * @fps: the number of times per second to call the function
- * @func: function to call
- * @data: data to pass to the function
- *
- * Simple wrapper around clutter_threads_add_frame_source_full().
- *
- * Return value: the ID (greater than 0) of the event source.
- *
- * Since: 0.8
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-guint
-clutter_threads_add_frame_source (guint       fps,
-                                  GSourceFunc func,
-                                  gpointer    data)
-{
-  g_return_val_if_fail (func != NULL, 0);
-
-  return clutter_threads_add_frame_source_full (G_PRIORITY_DEFAULT,
-                                                fps,
-                                                func, data,
-                                                NULL);
-}

clutter/clutter/deprecated/clutter-frame-source.h

@@ -1,49 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *
- * Copyright (C) 2008 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/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_FRAME_SOURCE_H__
-#define __CLUTTER_FRAME_SOURCE_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-CLUTTER_DEPRECATED
-guint clutter_frame_source_add (guint          fps,
-				GSourceFunc    func,
-				gpointer       data);
-
-CLUTTER_DEPRECATED
-guint clutter_frame_source_add_full (gint           priority,
-				     guint          fps,
-				     GSourceFunc    func,
-				     gpointer       data,
-				     GDestroyNotify notify);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_FRAME_SOURCE_H__ */

clutter/clutter/deprecated/clutter-group.c

@@ -1,562 +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/>.
- */
-
-/**
- * SECTION:clutter-group
- * @short_description: A fixed layout container
- *
- * A #ClutterGroup is an Actor which contains multiple child actors positioned
- * relative to the #ClutterGroup position. Other operations such as scaling,
- * rotating and clipping of the group will apply to the child actors.
- *
- * A #ClutterGroup's size is defined by the size and position of its children;
- * it will be the smallest non-negative size that covers the right and bottom
- * edges of all of its children.
- *
- * Setting the size on a Group using #ClutterActor methods like
- * clutter_actor_set_size() will override the natural size of the Group,
- * however this will not affect the size of the children and they may still
- * be painted outside of the allocation of the group. One way to constrain
- * the visible area of a #ClutterGroup to a specified allocation is to
- * explicitly set the size of the #ClutterGroup and then use the
- * #ClutterActor:clip-to-allocation property.
- *
- * #ClutterGroup as a concrete class has been superceded by #ClutterActor
- * since Clutter 1.10. The type itself is not deprecated as it is used by
- * #ClutterStage. You should instantiate #ClutterActor and use its API to
- * manage child actors.
- */
-
-#include "clutter-build-config.h"
-
-#include <stdarg.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "clutter-group.h"
-
-#include "clutter-actor.h"
-#include "clutter-actor-private.h"
-#include "clutter-container.h"
-#include "clutter-fixed-layout.h"
-#include "clutter-main.h"
-#include "clutter-debug.h"
-#include "clutter-enum-types.h"
-#include "clutter-marshal.h"
-#include "clutter-private.h"
-
-#include "cogl/cogl.h"
-
-struct _ClutterGroupPrivate
-{
-  GList *children;
-
-  ClutterLayoutManager *layout;
-};
-
-static void clutter_container_iface_init (ClutterContainerIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (ClutterGroup, clutter_group, CLUTTER_TYPE_ACTOR,
-                         G_ADD_PRIVATE (ClutterGroup)
-                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
-                                                clutter_container_iface_init));
-
-static gint
-sort_by_depth (gconstpointer a,
-               gconstpointer b)
-{
-  gfloat depth_a = clutter_actor_get_depth (CLUTTER_ACTOR(a));
-  gfloat depth_b = clutter_actor_get_depth (CLUTTER_ACTOR(b));
-
-  if (depth_a < depth_b)
-    return -1;
-
-  if (depth_a > depth_b)
-    return 1;
-
-  return 0;
-}
-
-static void
-clutter_group_real_add (ClutterContainer *container,
-                        ClutterActor     *actor)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  g_object_ref (actor);
-
-  priv->children = g_list_append (priv->children, actor);
-  clutter_actor_set_parent (actor, CLUTTER_ACTOR (container));
-
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
-
-  g_signal_emit_by_name (container, "actor-added", actor);
-
-  clutter_container_sort_depth_order (container);
-
-  g_object_unref (actor);
-}
-
-static void
-clutter_group_real_actor_added (ClutterContainer *container,
-                                ClutterActor     *actor)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  /* XXX - children added using clutter_actor_add_child() will
-   * cause actor-added to be emitted without going through the
-   * add() virtual function.
-   *
-   * if we get an actor-added for a child that is not in our
-   * list of children already, then we go in compatibility
-   * mode.
-   */
-  if (g_list_find (priv->children, actor) != NULL)
-    return;
-
-  priv->children = g_list_append (priv->children, actor);
-  clutter_container_sort_depth_order (container);
-}
-
-static void
-clutter_group_real_remove (ClutterContainer *container,
-                           ClutterActor     *actor)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  g_object_ref (actor);
-
-  priv->children = g_list_remove (priv->children, actor);
-  clutter_actor_unparent (actor);
-
-  clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
-
-  g_signal_emit_by_name (container, "actor-removed", actor);
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (container));
-
-  g_object_unref (actor);
-}
-
-static void
-clutter_group_real_actor_removed (ClutterContainer *container,
-                                  ClutterActor     *actor)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  /* XXX - same compatibility mode of the ::actor-added implementation */
-  if (g_list_find (priv->children, actor) == NULL)
-    return;
-
-  priv->children = g_list_remove (priv->children, actor);
-}
-
-static void
-clutter_group_real_foreach (ClutterContainer *container,
-                            ClutterCallback   callback,
-                            gpointer          user_data)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  /* Using g_list_foreach instead of iterating the list manually
-     because it has better protection against the current node being
-     removed. This will happen for example if someone calls
-     clutter_container_foreach(container, clutter_actor_destroy) */
-  g_list_foreach (priv->children, (GFunc) callback, user_data);
-}
-
-static void
-clutter_group_real_raise (ClutterContainer *container,
-                          ClutterActor     *actor,
-                          ClutterActor     *sibling)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  priv->children = g_list_remove (priv->children, actor);
-
-  /* Raise at the top */
-  if (!sibling)
-    {
-      GList *last_item;
-
-      last_item = g_list_last (priv->children);
-
-      if (last_item)
-	sibling = last_item->data;
-
-      priv->children = g_list_append (priv->children, actor);
-    }
-  else
-    {
-      gint index_ = g_list_index (priv->children, sibling) + 1;
-
-      priv->children = g_list_insert (priv->children, actor, index_);
-    }
-
-  /* set Z ordering a value below, this will then call sort
-   * as values are equal ordering shouldn't change but Z
-   * values will be correct.
-   *
-   * FIXME: get rid of this crap; this is so utterly broken and wrong on
-   * so many levels it's not even funny. sadly, we get to keep this until
-   * we can break API and remove Group for good.
-   */
-  if (sibling &&
-      clutter_actor_get_depth (sibling) != clutter_actor_get_depth (actor))
-    {
-      clutter_actor_set_depth (actor, clutter_actor_get_depth (sibling));
-    }
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (container));
-}
-
-static void
-clutter_group_real_lower (ClutterContainer *container,
-                          ClutterActor     *actor,
-                          ClutterActor     *sibling)
-{
-  ClutterGroup *self = CLUTTER_GROUP (container);
-  ClutterGroupPrivate *priv = self->priv;
-
-  priv->children = g_list_remove (priv->children, actor);
-
-  /* Push to bottom */
-  if (!sibling)
-    {
-      GList *last_item;
-
-      last_item = g_list_first (priv->children);
-
-      if (last_item)
-	sibling = last_item->data;
-
-      priv->children = g_list_prepend (priv->children, actor);
-    }
-  else
-    {
-      gint index_ = g_list_index (priv->children, sibling);
-
-      priv->children = g_list_insert (priv->children, actor, index_);
-    }
-
-  /* See comment in group_raise for this */
-  if (sibling &&
-      clutter_actor_get_depth (sibling) != clutter_actor_get_depth (actor))
-    {
-      clutter_actor_set_depth (actor, clutter_actor_get_depth (sibling));
-    }
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (container));
-}
-
-static void
-clutter_group_real_sort_depth_order (ClutterContainer *container)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (container)->priv;
-
-  priv->children = g_list_sort (priv->children, sort_by_depth);
-
-  clutter_actor_queue_redraw (CLUTTER_ACTOR (container));
-}
-
-static void
-clutter_container_iface_init (ClutterContainerIface *iface)
-{
-  iface->add = clutter_group_real_add;
-  iface->actor_added = clutter_group_real_actor_added;
-  iface->remove = clutter_group_real_remove;
-  iface->actor_removed = clutter_group_real_actor_removed;
-  iface->foreach = clutter_group_real_foreach;
-  iface->raise = clutter_group_real_raise;
-  iface->lower = clutter_group_real_lower;
-  iface->sort_depth_order = clutter_group_real_sort_depth_order;
-}
-
-static void
-clutter_group_real_paint (ClutterActor *actor)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-
-  CLUTTER_NOTE (PAINT, "ClutterGroup paint enter '%s'",
-                _clutter_actor_get_debug_name (actor));
-
-  g_list_foreach (priv->children, (GFunc) clutter_actor_paint, NULL);
-
-  CLUTTER_NOTE (PAINT, "ClutterGroup paint leave '%s'",
-                _clutter_actor_get_debug_name (actor));
-}
-
-static void
-clutter_group_real_pick (ClutterActor       *actor,
-                         const ClutterColor *pick)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-
-  /* Chain up so we get a bounding box pained (if we are reactive) */
-  CLUTTER_ACTOR_CLASS (clutter_group_parent_class)->pick (actor, pick);
-
-  g_list_foreach (priv->children, (GFunc) clutter_actor_paint, NULL);
-}
-
-static void
-clutter_group_real_get_preferred_width (ClutterActor *actor,
-                                        gfloat        for_height,
-                                        gfloat       *min_width,
-                                        gfloat       *natural_width)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-
-  clutter_layout_manager_get_preferred_width (priv->layout,
-                                              CLUTTER_CONTAINER (actor),
-                                              for_height,
-                                              min_width, natural_width);
-}
-
-static void
-clutter_group_real_get_preferred_height (ClutterActor *actor,
-                                         gfloat        for_width,
-                                         gfloat       *min_height,
-                                         gfloat       *natural_height)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-
-  clutter_layout_manager_get_preferred_height (priv->layout,
-                                               CLUTTER_CONTAINER (actor),
-                                               for_width,
-                                               min_height, natural_height);
-}
-
-static void
-clutter_group_real_allocate (ClutterActor           *actor,
-                             const ClutterActorBox  *allocation,
-                             ClutterAllocationFlags  flags)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-  ClutterActorClass *klass;
-
-  klass = CLUTTER_ACTOR_CLASS (clutter_group_parent_class);
-  klass->allocate (actor, allocation, flags);
-
-  if (priv->children == NULL)
-    return;
-
-  clutter_layout_manager_allocate (priv->layout,
-                                   CLUTTER_CONTAINER (actor),
-                                   allocation, flags);
-}
-
-static void
-clutter_group_dispose (GObject *object)
-{
-  ClutterGroup *self = CLUTTER_GROUP (object);
-  ClutterGroupPrivate *priv = self->priv;
-
-  /* Note: we are careful to consider that destroying children could
-   * have the side-effect of destroying other children so
-   * priv->children may be modified during clutter_actor_destroy. */
-  while (priv->children != NULL)
-    {
-      ClutterActor *child = priv->children->data;
-      priv->children = g_list_delete_link (priv->children, priv->children);
-      clutter_actor_destroy (child);
-    }
-
-  if (priv->layout)
-    {
-      clutter_layout_manager_set_container (priv->layout, NULL);
-      g_object_unref (priv->layout);
-      priv->layout = NULL;
-    }
-
-  G_OBJECT_CLASS (clutter_group_parent_class)->dispose (object);
-}
-
-static void
-clutter_group_real_show_all (ClutterActor *actor)
-{
-  clutter_container_foreach (CLUTTER_CONTAINER (actor),
-                             CLUTTER_CALLBACK (clutter_actor_show),
-                             NULL);
-  clutter_actor_show (actor);
-}
-
-static void
-clutter_group_real_hide_all (ClutterActor *actor)
-{
-  clutter_actor_hide (actor);
-  clutter_container_foreach (CLUTTER_CONTAINER (actor),
-                             CLUTTER_CALLBACK (clutter_actor_hide),
-                             NULL);
-}
-
-static gboolean
-clutter_group_real_get_paint_volume (ClutterActor       *actor,
-                                     ClutterPaintVolume *volume)
-{
-  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;
-  GList *l;
-
-  if (priv->children == NULL)
-    return TRUE;
-
-  for (l = priv->children; l != NULL; l = l->next)
-    {
-      ClutterActor *child = l->data;
-      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 TRUE;
-}
-
-static void
-clutter_group_class_init (ClutterGroupClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
-
-  actor_class->get_preferred_width = clutter_group_real_get_preferred_width;
-  actor_class->get_preferred_height = clutter_group_real_get_preferred_height;
-  actor_class->allocate = clutter_group_real_allocate;
-  actor_class->paint = clutter_group_real_paint;
-  actor_class->pick = clutter_group_real_pick;
-  actor_class->show_all = clutter_group_real_show_all;
-  actor_class->hide_all = clutter_group_real_hide_all;
-  actor_class->get_paint_volume = clutter_group_real_get_paint_volume;
-
-  gobject_class->dispose = clutter_group_dispose;
-}
-
-static void
-clutter_group_init (ClutterGroup *self)
-{
-  ClutterActor *actor = CLUTTER_ACTOR (self);
-
-  self->priv = clutter_group_get_instance_private (self);
-
-  /* turn on some optimization
-   *
-   * XXX - these so-called "optimizations" are insane and should have never
-   * been used. they introduce some weird behaviour that breaks invariants
-   * and have to be explicitly worked around.
-   *
-   * this flag was set by the ClutterFixedLayout, but since that layout
-   * manager is now the default for ClutterActor, we set the flag explicitly
-   * here, to avoid breaking perfectly working actors overriding the
-   * allocate() virtual function.
-   *
-   * also, we keep this flag here so that it can die once we get rid of
-   * ClutterGroup.
-   */
-  clutter_actor_set_flags (actor, CLUTTER_ACTOR_NO_LAYOUT);
-
-  self->priv->layout = clutter_fixed_layout_new ();
-  g_object_ref_sink (self->priv->layout);
-
-  clutter_actor_set_layout_manager (actor, self->priv->layout);
-}
-
-/**
- * clutter_group_new:
- *
- * Create a new  #ClutterGroup.
- *
- * Return value: the newly created #ClutterGroup actor
- *
- * Deprecated: 1.10: Use clutter_actor_new() instead.
- */
-ClutterActor *
-clutter_group_new (void)
-{
-  return g_object_new (CLUTTER_TYPE_GROUP, NULL);
-}
-
-/**
- * clutter_group_remove_all:
- * @self: A #ClutterGroup
- *
- * Removes all children actors from the #ClutterGroup.
- *
- * Deprecated: 1.10: Use clutter_actor_remove_all_children() instead.
- */
-void
-clutter_group_remove_all (ClutterGroup *self)
-{
-  g_return_if_fail (CLUTTER_IS_GROUP (self));
-
-  clutter_actor_remove_all_children (CLUTTER_ACTOR (self));
-}
-
-/**
- * clutter_group_get_n_children:
- * @self: A #ClutterGroup
- *
- * Gets the number of actors held in the group.
- *
- * Return value: The number of child actors held in the group.
- *
- * Since: 0.2
- *
- * Deprecated: 1.10: Use clutter_actor_get_n_children() instead.
- */
-gint
-clutter_group_get_n_children (ClutterGroup *self)
-{
-  g_return_val_if_fail (CLUTTER_IS_GROUP (self), 0);
-
-  return clutter_actor_get_n_children (CLUTTER_ACTOR (self));
-}
-
-/**
- * clutter_group_get_nth_child:
- * @self: A #ClutterGroup
- * @index_: the position of the requested actor.
- *
- * Gets a groups child held at @index_ in stack.
- *
- * Return value: (transfer none): A Clutter actor, or %NULL if
- *   @index_ is invalid.
- *
- * Since: 0.2
- *
- * Deprecated: 1.10: Use clutter_actor_get_child_at_index() instead.
- */
-ClutterActor *
-clutter_group_get_nth_child (ClutterGroup *self,
-			     gint          index_)
-{
-  ClutterActor *actor;
-
-  g_return_val_if_fail (CLUTTER_IS_GROUP (self), NULL);
-
-  actor = CLUTTER_ACTOR (self);
-  g_return_val_if_fail (index_ <= clutter_actor_get_n_children (actor), NULL);
-
-  return clutter_actor_get_child_at_index (actor, index_);
-}

clutter/clutter/deprecated/clutter-group.h

@@ -1,62 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 2011 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_GROUP_DEPRECATED_H__
-#define __CLUTTER_GROUP_DEPRECATED_H__
-
-#include <clutter/clutter-types.h>
-#include <clutter/clutter-group.h>
-
-G_BEGIN_DECLS
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_new)
-ClutterActor *  clutter_group_new               (void);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_child_at_index)
-ClutterActor *  clutter_group_get_nth_child     (ClutterGroup *self,
-                                                 gint          index_);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_n_children)
-gint            clutter_group_get_n_children    (ClutterGroup *self);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_remove_all_children)
-void            clutter_group_remove_all        (ClutterGroup *self);
-
-#ifndef CLUTTER_DISABLE_DEPRECATED
-
-/* for Mr. Mallum only */
-#define clutter_group_add(group,actor)                  G_STMT_START {  \
-  ClutterActor *_actor = (ClutterActor *) (actor);                      \
-  if (CLUTTER_IS_GROUP ((group)) && CLUTTER_IS_ACTOR ((_actor)))        \
-    {                                                                   \
-      ClutterContainer *_container = (ClutterContainer *) (group);      \
-      clutter_container_add_actor (_container, _actor);                 \
-    }                                                   } G_STMT_END
-
-#endif /* CLUTTER_DISABLE_DEPRECATED */
-
-G_END_DECLS
-
-#endif /* __CLUTTER_GROUP_DEPRECATED_H__ */

clutter/clutter/deprecated/clutter-list-model.c

@@ -1,834 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Neil Jagdish Patel <njp@o-hand.com>
- *             Emmanuele Bassi <ebassi@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/>.
- *
- *
- */
-
-/**
- * SECTION:clutter-list-model
- * @short_description: List model implementation
- *
- * #ClutterListModel is a #ClutterModel implementation provided by
- * Clutter. #ClutterListModel uses a #GSequence for storing the
- * values for each row, so it's optimized for insertion and look up
- * in sorted lists.
- *
- * #ClutterListModel is available since Clutter 0.6
- *
- * Deprecated: 1.24: Use a #GListStore instance containing a custom
- *   object type with properties for each column instead.
- */
-
-#include "clutter-build-config.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <glib-object.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "clutter-list-model.h"
-
-#include "clutter-model.h"
-#include "clutter-model-private.h"
-#include "clutter-private.h"
-#include "clutter-debug.h"
-
-#define CLUTTER_TYPE_LIST_MODEL_ITER                 \
-        (clutter_list_model_iter_get_type())
-#define CLUTTER_LIST_MODEL_ITER(obj)                 \
-        (G_TYPE_CHECK_INSTANCE_CAST((obj),           \
-         CLUTTER_TYPE_LIST_MODEL_ITER,               \
-         ClutterListModelIter))
-#define CLUTTER_IS_LIST_MODEL_ITER(obj)              \
-        (G_TYPE_CHECK_INSTANCE_TYPE((obj),           \
-         CLUTTER_TYPE_LIST_MODEL_ITER))
-#define CLUTTER_LIST_MODEL_ITER_CLASS(klass)         \
-        (G_TYPE_CHECK_CLASS_CAST ((klass),           \
-         CLUTTER_TYPE_LIST_MODEL_ITER,               \
-         ClutterListModelIterClass))
-#define CLUTTER_IS_LIST_MODEL_ITER_CLASS(klass)      \
-        (G_TYPE_CHECK_CLASS_TYPE ((klass),           \
-         CLUTTER_TYPE_LIST_MODEL_ITER))
-#define CLUTTER_LIST_MODEL_ITER_GET_CLASS(obj)       \
-        (G_TYPE_INSTANCE_GET_CLASS ((obj),           \
-         CLUTTER_TYPE_LIST_MODEL_ITER,               \
-         ClutterListModelIterClass))
-
-typedef struct _ClutterListModelIter    ClutterListModelIter;
-typedef struct _ClutterModelIterClass   ClutterListModelIterClass;
-
-struct _ClutterListModelPrivate
-{
-  GSequence *sequence;
-
-  ClutterModelIter *temp_iter;
-};
-
-struct _ClutterListModelIter
-{
-  ClutterModelIter parent_instance;
-
-  GSequenceIter *seq_iter;
-};
-
-
-
-GType clutter_list_model_iter_get_type (void);
-
-/*
- * ClutterListModel
- */
-
-G_DEFINE_TYPE (ClutterListModelIter,
-               clutter_list_model_iter,
-               CLUTTER_TYPE_MODEL_ITER)
-
-static void
-clutter_list_model_iter_get_value (ClutterModelIter *iter,
-                                   guint             column,
-                                   GValue           *value)
-{
-  ClutterListModelIter *iter_default;
-  GValue *values;
-  GValue *iter_value;
-  GValue real_value = G_VALUE_INIT;
-  gboolean converted = FALSE;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  values = g_sequence_get (iter_default->seq_iter);
-  iter_value = &values[column];
-  g_assert (iter_value != NULL);
-
-  if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
-    {
-      if (!g_value_type_compatible (G_VALUE_TYPE (value), 
-                                    G_VALUE_TYPE (iter_value)) &&
-          !g_value_type_compatible (G_VALUE_TYPE (iter_value), 
-                                    G_VALUE_TYPE (value)))
-        {
-          g_warning ("%s: Unable to convert from %s to %s",
-                     G_STRLOC,
-                     g_type_name (G_VALUE_TYPE (value)),
-                     g_type_name (G_VALUE_TYPE (iter_value)));
-          return;
-        }
-
-      if (!g_value_transform (iter_value, &real_value))
-        {
-          g_warning ("%s: Unable to make conversion from %s to %s",
-                     G_STRLOC, 
-                     g_type_name (G_VALUE_TYPE (value)),
-                     g_type_name (G_VALUE_TYPE (iter_value)));
-          g_value_unset (&real_value);
-        }
-
-      converted = TRUE;
-    }
-  
-  if (converted)
-    {
-      g_value_copy (&real_value, value);
-      g_value_unset (&real_value);
-    }
-  else
-    g_value_copy (iter_value, value);
-}
-
-static void
-clutter_list_model_iter_set_value (ClutterModelIter *iter,
-                                   guint             column,
-                                   const GValue     *value)
-{
-  ClutterListModelIter *iter_default;
-  GValue *values;
-  GValue *iter_value;
-  GValue real_value = G_VALUE_INIT;
-  gboolean converted = FALSE;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  values = g_sequence_get (iter_default->seq_iter);
-  iter_value = &values[column];
-  g_assert (iter_value != NULL);
-
-  if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
-    {
-      if (!g_value_type_compatible (G_VALUE_TYPE (value), 
-                                    G_VALUE_TYPE (iter_value)) &&
-          !g_value_type_compatible (G_VALUE_TYPE (iter_value), 
-                                    G_VALUE_TYPE (value)))
-        {
-          g_warning ("%s: Unable to convert from %s to %s\n",
-                     G_STRLOC,
-                     g_type_name (G_VALUE_TYPE (value)),
-                     g_type_name (G_VALUE_TYPE (iter_value)));
-          return;
-        }
-
-      if (!g_value_transform (value, &real_value))
-        {
-          g_warning ("%s: Unable to make conversion from %s to %s\n",
-                     G_STRLOC, 
-                     g_type_name (G_VALUE_TYPE (value)),
-                     g_type_name (G_VALUE_TYPE (iter_value)));
-          g_value_unset (&real_value);
-        }
-
-      converted = TRUE;
-    }
- 
-  if (converted)
-    {
-      g_value_copy (&real_value, iter_value);
-      g_value_unset (&real_value);
-    }
-  else
-    g_value_copy (value, iter_value);
-}
-
-static gboolean
-clutter_list_model_iter_is_first (ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  ClutterModel *model;
-  ClutterModelIter *temp_iter;
-  GSequence *sequence;
-  GSequenceIter *begin, *end;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  model = clutter_model_iter_get_model (iter);
-
-  sequence = CLUTTER_LIST_MODEL (model)->priv->sequence;
-
-  begin = g_sequence_get_begin_iter (sequence);
-  end   = iter_default->seq_iter;
-
-  temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
-
-  while (!g_sequence_iter_is_begin (begin))
-    {
-      CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = begin;
-
-      if (clutter_model_filter_iter (model, temp_iter))
-        {
-          end = begin;
-          break;
-        }
-
-      begin = g_sequence_iter_next (begin);
-    }
-
-  /* This is because the 'begin_iter' is always *before* the last valid
-   * iter, otherwise we'd have endless loops 
-   */
-  end = g_sequence_iter_prev (end);
-
-  return iter_default->seq_iter == end;
-}
-
-static gboolean
-clutter_list_model_iter_is_last (ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  ClutterModelIter *temp_iter;
-  ClutterModel *model;
-  GSequence *sequence;
-  GSequenceIter *begin, *end;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  if (g_sequence_iter_is_end (iter_default->seq_iter))
-    return TRUE;
-
-  model = clutter_model_iter_get_model (iter);
-
-  sequence = CLUTTER_LIST_MODEL (model)->priv->sequence;
-
-  begin = g_sequence_get_end_iter (sequence);
-  begin = g_sequence_iter_prev (begin);
-  end   = iter_default->seq_iter;
-
-  temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
-
-  while (!g_sequence_iter_is_begin (begin))
-    {
-      CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = begin;
-
-      if (clutter_model_filter_iter (model, temp_iter))
-        {
-          end = begin;
-          break;
-        }
-
-      begin = g_sequence_iter_prev (begin);
-    }
-
-  /* This is because the 'end_iter' is always *after* the last valid iter.
-   * Otherwise we'd have endless loops 
-   */
-  end = g_sequence_iter_next (end);
-
-  return iter_default->seq_iter == end;
-}
-
-static ClutterModelIter *
-clutter_list_model_iter_next (ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  ClutterModelIter *temp_iter;
-  ClutterModel *model = NULL;
-  GSequenceIter *filter_next;
-  guint row;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  model = clutter_model_iter_get_model (iter);
-  row   = clutter_model_iter_get_row (iter);
-
-  filter_next = g_sequence_iter_next (iter_default->seq_iter);
-  g_assert (filter_next != NULL);
-
-  temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
-
-  while (!g_sequence_iter_is_end (filter_next))
-    {
-      CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = filter_next;
-
-      if (clutter_model_filter_iter (model, temp_iter))
-        {
-          row += 1;
-          break;
-        }
-
-      filter_next = g_sequence_iter_next (filter_next);
-    }
-
-  if (g_sequence_iter_is_end (filter_next))
-    row += 1;
-
-  /* update the iterator and return it */
-  _clutter_model_iter_set_row (CLUTTER_MODEL_ITER (iter_default), row);
-  iter_default->seq_iter = filter_next;
-
-  return CLUTTER_MODEL_ITER (iter_default);
-}
-
-static ClutterModelIter *
-clutter_list_model_iter_prev (ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  ClutterModelIter *temp_iter;
-  ClutterModel *model;
-  GSequenceIter *filter_prev;
-  guint row;
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-  g_assert (iter_default->seq_iter != NULL);
-
-  model = clutter_model_iter_get_model (iter);
-  row   = clutter_model_iter_get_row (iter);
-
-  filter_prev = g_sequence_iter_prev (iter_default->seq_iter);
-  g_assert (filter_prev != NULL);
-
-  temp_iter = CLUTTER_LIST_MODEL (model)->priv->temp_iter;
-
-  while (!g_sequence_iter_is_begin (filter_prev))
-    {
-      CLUTTER_LIST_MODEL_ITER (temp_iter)->seq_iter = filter_prev;
-
-      if (clutter_model_filter_iter (model, temp_iter))
-        {
-          row -= 1;
-          break;
-        }
-
-      filter_prev = g_sequence_iter_prev (filter_prev);
-    }
-
-  if (g_sequence_iter_is_begin (filter_prev))
-    row -= 1;
-
-  /* update the iterator and return it */
-  _clutter_model_iter_set_row (CLUTTER_MODEL_ITER (iter_default), row);
-  iter_default->seq_iter = filter_prev;
-
-  return CLUTTER_MODEL_ITER (iter_default);
-}
-
-static ClutterModelIter *
-clutter_list_model_iter_copy (ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  ClutterListModelIter *iter_copy;
-  ClutterModel *model;
-  guint row;
- 
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-
-  model = clutter_model_iter_get_model (iter);
-  row   = clutter_model_iter_get_row (iter) - 1;
-
-  iter_copy = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
-                            "model", model,
-                            "row", row,
-                            NULL);
-
-  /* this is safe, because the seq_iter pointer on the passed
-   * iterator will be always be overwritten in ::next or ::prev
-   */
-  iter_copy->seq_iter = iter_default->seq_iter;
-
-  return CLUTTER_MODEL_ITER (iter_copy);
-}
-
-static void
-clutter_list_model_iter_class_init (ClutterListModelIterClass *klass)
-{
-  ClutterModelIterClass *iter_class = CLUTTER_MODEL_ITER_CLASS (klass);
-
-  iter_class->get_value = clutter_list_model_iter_get_value;
-  iter_class->set_value = clutter_list_model_iter_set_value;
-  iter_class->is_first  = clutter_list_model_iter_is_first;
-  iter_class->is_last   = clutter_list_model_iter_is_last;
-  iter_class->next      = clutter_list_model_iter_next;
-  iter_class->prev      = clutter_list_model_iter_prev;
-  iter_class->copy      = clutter_list_model_iter_copy;
-}
-
-static void
-clutter_list_model_iter_init (ClutterListModelIter *iter)
-{
-  iter->seq_iter = NULL;
-}
-
-/*
- * ClutterListModel
- */
-
-G_DEFINE_TYPE_WITH_PRIVATE (ClutterListModel, clutter_list_model, CLUTTER_TYPE_MODEL)
-
-static ClutterModelIter *
-clutter_list_model_get_iter_at_row (ClutterModel *model,
-                                    guint         row)
-{
-  ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
-  GSequence *sequence = model_default->priv->sequence;
-  GSequenceIter *filter_next;
-  gint seq_length = g_sequence_get_length (sequence);
-  ClutterListModelIter *retval;
-  gint count = -1;
-
-  if (row >= seq_length)
-    return NULL;
-
-  retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
-                         "model", model,
-                         "row", row,
-                         NULL);
-
-  /* short-circuit in case we don't have a filter in place */
-  if (!clutter_model_get_filter_set (model))
-    {
-      retval->seq_iter = g_sequence_get_iter_at_pos (sequence, row);
-
-      return CLUTTER_MODEL_ITER (retval);
-    }
-
-  filter_next = g_sequence_get_begin_iter (sequence);
-  g_assert (filter_next != NULL);
-
-  while (!g_sequence_iter_is_end (filter_next))
-    {
-      retval->seq_iter = filter_next;
-
-      if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval)))
-        {
-          /* We've found a row that is valid under the filter */
-          count++;
-          if (count == row)
-            break;
-        }
-
-      filter_next = g_sequence_iter_next (filter_next);
-    }
-
-  if (count != row)
-    {
-      g_object_unref (retval);
-      return NULL;
-    }
-  return CLUTTER_MODEL_ITER (retval);
-}
-
-static ClutterModelIter *
-clutter_list_model_insert_row (ClutterModel *model,
-                               gint          index_)
-{
-  ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
-  GSequence *sequence = model_default->priv->sequence;
-  ClutterListModelIter *retval;
-  guint n_columns, i, pos;
-  GValue *values;
-  GSequenceIter *seq_iter;
-
-  n_columns = clutter_model_get_n_columns (model);
-  values = g_new0 (GValue, n_columns);
-
-  for (i = 0; i < n_columns; i++)
-    g_value_init (&values[i], clutter_model_get_column_type (model, i));
-
-  if (index_ < 0)
-    {
-      seq_iter = g_sequence_append (sequence, values);
-      pos = g_sequence_get_length (sequence) - 1;
-    }
-  else if (index_ == 0)
-    {
-      seq_iter = g_sequence_prepend (sequence, values);
-      pos = 0;
-    }
-  else
-    {
-      seq_iter = g_sequence_get_iter_at_pos (sequence, index_);
-      seq_iter = g_sequence_insert_before (seq_iter, values);
-      pos = index_;
-    }
-
-  retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
-                         "model", model,
-                         "row", pos,
-                         NULL);
-  retval->seq_iter = seq_iter;
-
-  return CLUTTER_MODEL_ITER (retval);
-}
-
-static void
-clutter_list_model_remove_row (ClutterModel *model,
-                               guint         row)
-{
-  ClutterListModel *model_default = CLUTTER_LIST_MODEL (model);
-  GSequence *sequence = model_default->priv->sequence;
-  GSequenceIter *seq_iter;
-  guint pos = 0;
-
-  seq_iter = g_sequence_get_begin_iter (sequence);
-  while (!g_sequence_iter_is_end (seq_iter))
-    {
-      if (clutter_model_filter_row (model, pos))
-        {
-          if (pos == row)
-            {  
-              ClutterModelIter *iter;
-
-              iter = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
-                                   "model", model,
-                                   "row", pos,
-                                   NULL);
-              CLUTTER_LIST_MODEL_ITER (iter)->seq_iter = seq_iter;
-
-              /* the actual row is removed from the sequence inside
-               * the ::row-removed signal class handler, so that every
-               * handler connected to ::row-removed will still get
-               * a valid iterator, and every signal connected to
-               * ::row-removed with the AFTER flag will get an updated
-               * model
-               */
-              g_signal_emit_by_name (model, "row-removed", iter);
-
-              g_object_unref (iter);
-
-              break;
-            }
-        }
-
-      pos += 1;
-      seq_iter = g_sequence_iter_next (seq_iter);
-    }
-}
-
-typedef struct
-{
-  ClutterModel *model;
-  guint column;
-  ClutterModelSortFunc func;
-  gpointer data;
-} SortClosure;
-
-static gint
-sort_model_default (gconstpointer a,
-                    gconstpointer b,
-                    gpointer      data)
-{
-  const GValue *row_a = a;
-  const GValue *row_b = b;
-  SortClosure *clos = data;
-
-  return clos->func (clos->model,
-                     &row_a[clos->column],
-                     &row_b[clos->column],
-                     clos->data);
-}
-
-static void
-clutter_list_model_resort (ClutterModel         *model,
-                           ClutterModelSortFunc  func,
-                           gpointer              data)
-{
-  SortClosure sort_closure = { NULL, 0, NULL, NULL };
-
-  sort_closure.model  = model;
-  sort_closure.column = clutter_model_get_sorting_column (model);
-  sort_closure.func   = func;
-  sort_closure.data   = data;
-
-  g_sequence_sort (CLUTTER_LIST_MODEL (model)->priv->sequence,
-                   sort_model_default,
-                   &sort_closure);
-}
-
-static guint
-clutter_list_model_get_n_rows (ClutterModel *model)
-{
-  ClutterListModel *list_model = CLUTTER_LIST_MODEL (model);
-
-  /* short-circuit in case we don't have a filter in place */
-  if (!clutter_model_get_filter_set (model))
-    return g_sequence_get_length (list_model->priv->sequence);
-
-  return CLUTTER_MODEL_CLASS (clutter_list_model_parent_class)->get_n_rows (model);
-}
-
-static void
-clutter_list_model_row_removed (ClutterModel     *model,
-                                ClutterModelIter *iter)
-{
-  ClutterListModelIter *iter_default;
-  guint i, n_columns;
-  GValue *values;
-
-  n_columns = clutter_model_get_n_columns (model);
-
-  iter_default = CLUTTER_LIST_MODEL_ITER (iter);
-
-  values = g_sequence_get (iter_default->seq_iter);
-
-  for (i = 0; i < n_columns; i++)
-    g_value_unset (&values[i]);
-
-  g_free (values);
-
-  g_sequence_remove (iter_default->seq_iter);
-  iter_default->seq_iter = NULL;
-}
-
-static void
-clutter_list_model_finalize (GObject *gobject)
-{
-  ClutterListModel *model = CLUTTER_LIST_MODEL (gobject);
-  GSequence *sequence = model->priv->sequence;
-  GSequenceIter *iter;
-  guint n_columns, i;
-
-  n_columns = clutter_model_get_n_columns (CLUTTER_MODEL (gobject));
-
-  iter = g_sequence_get_begin_iter (sequence);
-  while (!g_sequence_iter_is_end (iter))
-    {
-      GValue *values = g_sequence_get (iter);
-
-      for (i = 0; i < n_columns; i++)
-        g_value_unset (&values[i]);
-
-      g_free (values);
-
-      iter = g_sequence_iter_next (iter);
-    }
-  g_sequence_free (sequence);
-
-  G_OBJECT_CLASS (clutter_list_model_parent_class)->finalize (gobject);
-}
-
-static void
-clutter_list_model_dispose (GObject *gobject)
-{
-  ClutterListModel *model = CLUTTER_LIST_MODEL (gobject);
-
-  if (model->priv->temp_iter)
-    {
-      g_object_unref (model->priv->temp_iter);
-      model->priv->temp_iter = NULL;
-    }
-
-  G_OBJECT_CLASS (clutter_list_model_parent_class)->dispose (gobject);
-}
-
-static void
-clutter_list_model_class_init (ClutterListModelClass *klass)
-{
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-  ClutterModelClass *model_class = CLUTTER_MODEL_CLASS (klass);
-
-  gobject_class->finalize = clutter_list_model_finalize;
-  gobject_class->dispose = clutter_list_model_dispose;
-
-  model_class->get_iter_at_row = clutter_list_model_get_iter_at_row;
-  model_class->insert_row = clutter_list_model_insert_row;
-  model_class->remove_row = clutter_list_model_remove_row;
-  model_class->resort = clutter_list_model_resort;
-  model_class->get_n_rows = clutter_list_model_get_n_rows;
-  model_class->row_removed = clutter_list_model_row_removed;
-}
-
-static void
-clutter_list_model_init (ClutterListModel *model)
-{
-  model->priv = clutter_list_model_get_instance_private (model);
-
-  model->priv->sequence = g_sequence_new (NULL);
-  model->priv->temp_iter = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER,
-                                         "model",
-                                         model,
-                                         NULL);
-}
-
-/**
- * clutter_list_model_new:
- * @n_columns: number of columns in the model
- * @...: @n_columns number of #GType and string pairs
- *
- * Creates a new default model with @n_columns columns with the types 
- * and names passed in.
- *
- * For example:
- * 
- * <informalexample><programlisting>
- * model = clutter_list_model_new (3,
- *                                 G_TYPE_INT,      "Score",
- *                                 G_TYPE_STRING,   "Team",
- *                                 GDK_TYPE_PIXBUF, "Logo");
- * </programlisting></informalexample>
- *
- * will create a new #ClutterModel with three columns of type int,
- * string and #GdkPixbuf respectively.
- *
- * Note that the name of the column can be set to %NULL, in which case
- * the canonical name of the type held by the column will be used as
- * the title.
- *
- * Return value: a new #ClutterListModel
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListStore instead
- */
-ClutterModel *
-clutter_list_model_new (guint n_columns,
-                        ...)
-{
-  ClutterModel *model;
-  va_list args;
-  gint i;
-
-  g_return_val_if_fail (n_columns > 0, NULL);
-
-  model = g_object_new (CLUTTER_TYPE_LIST_MODEL, NULL);
-  _clutter_model_set_n_columns (model, n_columns, TRUE, TRUE);
-
-  va_start (args, n_columns);
-
-  for (i = 0; i < n_columns; i++)
-    { 
-      GType type = va_arg (args, GType);
-      const gchar *name = va_arg (args, gchar*);
-
-      if (!_clutter_model_check_type (type))
-        {
-          g_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (type));
-          g_object_unref (model);
-          model = NULL;
-          goto out;
-        }
-
-      _clutter_model_set_column_type (model, i, type);
-      _clutter_model_set_column_name (model, i, name);
-    }
-
- out:
-  va_end (args);
-  return model;
-}
-
-/**
- * clutter_list_model_newv:
- * @n_columns: number of columns in the model
- * @types: (array length=n_columns): an array of #GType types for the columns, from first to last
- * @names: (array length=n_columns): an array of names for the columns, from first to last
- *
- * Non-vararg version of clutter_list_model_new(). This function is
- * useful for language bindings.
- *
- * Return value: (transfer full): a new default #ClutterModel
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListStore instead
- */
-ClutterModel *
-clutter_list_model_newv (guint                n_columns,
-                         GType               *types,
-                         const gchar * const  names[])
-{
-  ClutterModel *model;
-  gint i;
-
-  g_return_val_if_fail (n_columns > 0, NULL);
-
-  model = g_object_new (CLUTTER_TYPE_LIST_MODEL, NULL);
-  _clutter_model_set_n_columns (model, n_columns, TRUE, TRUE);
-
-  for (i = 0; i < n_columns; i++)
-    {
-      if (!_clutter_model_check_type (types[i]))
-        {
-          g_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (types[i]));
-          g_object_unref (model);
-          return NULL;
-        }
-
-      _clutter_model_set_column_type (model, i, types[i]);
-      _clutter_model_set_column_name (model, i, names[i]);
-    }
-
-  return model;
-}

clutter/clutter/deprecated/clutter-list-model.h

@@ -1,95 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Neil Jagdish Patel <njp@o-hand.com>
- *             Emmanuele Bassi <ebassi@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/>.
- *
- * NB: Inspiration for column storage taken from GtkListStore
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_LIST_MODEL_H__
-#define __CLUTTER_LIST_MODEL_H__
-
-#include <clutter/deprecated/clutter-model.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_LIST_MODEL                 (clutter_list_model_get_type ())
-#define CLUTTER_LIST_MODEL(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_LIST_MODEL, ClutterListModel))
-#define CLUTTER_IS_LIST_MODEL(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_LIST_MODEL))
-#define CLUTTER_LIST_MODEL_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_LIST_MODEL, ClutterListModeClass))
-#define CLUTTER_IS_LIST_MODEL_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_LIST_MODEL))
-#define CLUTTER_LIST_MODEL_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_LIST_MODEL, ClutterListModeClass))
-
-typedef struct _ClutterListModel                ClutterListModel;
-typedef struct _ClutterListModelPrivate         ClutterListModelPrivate;
-typedef struct _ClutterListModelClass           ClutterListModelClass;
-
-/**
- * ClutterListModel:
- *
- * The #ClutterListModel struct contains only private data.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListStore instead
- */
-struct _ClutterListModel
-{
-  /*< private >*/
-  ClutterModel parent_instance;
-
-  ClutterListModelPrivate *priv;
-};
-
-/**
- * ClutterListModelClass:
- *
- * The #ClutterListModelClass struct contains only private data.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListStore instead
- */
-struct _ClutterListModelClass
-{
-  /*< private >*/
-  ClutterModelClass parent_class;
-};
-
-CLUTTER_DEPRECATED_FOR(g_list_store_get_type)
-GType         clutter_list_model_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR(g_list_store_new)
-ClutterModel *clutter_list_model_new      (guint                n_columns,
-                                              ...);
-CLUTTER_DEPRECATED_FOR(g_list_store_new)
-ClutterModel *clutter_list_model_newv     (guint                n_columns,
-                                           GType               *types,
-                                           const gchar * const  names[]);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_LIST_MODEL_H__ */

clutter/clutter/deprecated/clutter-model-private.h

@@ -1,52 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Neil Jagdish Patel <njp@o-hand.com>
- *             Emmanuele Bassi <ebassi@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_MODEL_PRIVATE_H__
-#define __CLUTTER_MODEL_PRIVATE_H__
-
-#include "clutter-types.h"
-#include "clutter-model.h"
-
-G_BEGIN_DECLS
-
-void            _clutter_model_set_n_columns    (ClutterModel *model,
-                                                 gint          n_columns,
-                                                 gboolean      set_types,
-                                                 gboolean      set_names);
-gboolean        _clutter_model_check_type       (GType         gtype);
-
-void            _clutter_model_set_column_type  (ClutterModel *model,
-                                                 gint          column,
-                                                 GType         gtype);
-void            _clutter_model_set_column_name  (ClutterModel *model,
-                                                 gint          column,
-                                                 const gchar  *name);
-
-void            _clutter_model_iter_set_row     (ClutterModelIter *iter,
-                                                 guint             row);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_MODEL_PRIVATE_H__ */

clutter/clutter/deprecated/clutter-model.h

@@ -1,436 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Neil Jagdish Patel <njp@o-hand.com>
- *             Emmanuele Bassi <ebassi@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/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_MODEL_H__
-#define __CLUTTER_MODEL_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_MODEL              (clutter_model_get_type ())
-#define CLUTTER_MODEL(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MODEL, ClutterModel))
-#define CLUTTER_MODEL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MODEL, ClutterModelClass))
-#define CLUTTER_IS_MODEL(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MODEL))
-#define CLUTTER_IS_MODEL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MODEL))
-#define CLUTTER_MODEL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MODEL, ClutterModelClass))
-
-typedef struct _ClutterModel            ClutterModel;
-typedef struct _ClutterModelClass       ClutterModelClass;
-typedef struct _ClutterModelPrivate     ClutterModelPrivate;
-typedef struct _ClutterModelIter        ClutterModelIter;
-typedef struct _ClutterModelIterClass   ClutterModelIterClass;
-typedef struct _ClutterModelIterPrivate ClutterModelIterPrivate;
-
-
-/**
- * ClutterModelFilterFunc:
- * @model: a #ClutterModel
- * @iter: the iterator for the row
- * @user_data: data passed to clutter_model_set_filter()
- *
- * Filters the content of a row in the model.
- *
- * Return value: If the row should be displayed, return %TRUE
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Implement filters using a custom #GListModel instead
- */
-typedef gboolean (*ClutterModelFilterFunc) (ClutterModel     *model,
-                                            ClutterModelIter *iter,
-                                            gpointer          user_data);
-
-/**
- * ClutterModelSortFunc:
- * @model: a #ClutterModel
- * @a: a #GValue representing the contents of the row
- * @b: a #GValue representing the contents of the second row
- * @user_data: data passed to clutter_model_set_sort()
- *
- * Compares the content of two rows in the model.
- *
- * Return value: a positive integer if @a is after @b, a negative integer if
- *   @a is before @b, or 0 if the rows are the same
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Implement sorting using a custom #GListModel instead
- */
-typedef gint (*ClutterModelSortFunc) (ClutterModel *model,
-                                      const GValue *a,
-                                      const GValue *b,
-                                      gpointer      user_data);
-
-/**
- * ClutterModelForeachFunc:
- * @model: a #ClutterModel
- * @iter: the iterator for the row
- * @user_data: data passed to clutter_model_foreach()
- *
- * Iterates on the content of a row in the model
- *
- * Return value: %TRUE if the iteration should continue, %FALSE otherwise
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListModel
- */
-typedef gboolean (*ClutterModelForeachFunc) (ClutterModel     *model,
-                                             ClutterModelIter *iter,
-                                             gpointer          user_data);
-
-/**
- * ClutterModel:
- *
- * Base class for list models. The #ClutterModel structure contains
- * only private data and should be manipulated using the provided
- * API.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListModel instead
- */
-struct _ClutterModel
-{
-  /*< private >*/
-  GObject parent_instance;
-
-  ClutterModelPrivate *priv;
-};
-
-/**
- * ClutterModelClass:
- * @row_added: signal class handler for ClutterModel::row-added
- * @row_removed: signal class handler for ClutterModel::row-removed
- * @row_changed: signal class handler for ClutterModel::row-changed
- * @sort_changed: signal class handler for ClutterModel::sort-changed
- * @filter_changed: signal class handler for ClutterModel::filter-changed
- * @get_column_name: virtual function for returning the name of a column
- * @get_column_type: virtual function for returning the type of a column
- * @get_iter_at_row: virtual function for returning an iterator for the
- *   given row
- * @get_n_rows: virtual function for returning the number of rows
- *   of the model
- * @get_n_columns: virtual function for retuning the number of columns
- *   of the model
- * @resort: virtual function for sorting the model using the passed
- *   sorting function
- * @insert_row: virtual function for inserting a row at the given index
- *   and returning an iterator pointing to it; if the index is a negative
- *   integer, the row should be appended to the model
- * @remove_row: virtual function for removing a row at the given index
- *
- * Class for #ClutterModel instances.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use #GListModel instead
- */
-struct _ClutterModelClass 
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  /* vtable */
-  guint             (* get_n_rows)      (ClutterModel         *model);
-  guint             (* get_n_columns)   (ClutterModel         *model);
-  const gchar *     (* get_column_name) (ClutterModel         *model,
-                                         guint                 column);
-  GType             (* get_column_type) (ClutterModel         *model,
-                                         guint                 column);
-  ClutterModelIter *(* insert_row)      (ClutterModel         *model,
-                                         gint                  index_);
-  void              (* remove_row)      (ClutterModel         *model,
-                                         guint                 row);
-  ClutterModelIter *(* get_iter_at_row) (ClutterModel         *model,
-                                         guint                 row);
-  void              (* resort)          (ClutterModel         *model,
-                                         ClutterModelSortFunc  func,
-                                         gpointer              data);
-
-  /* signals */
-  void              (* row_added)       (ClutterModel     *model,
-                                         ClutterModelIter *iter);
-  void              (* row_removed)     (ClutterModel     *model,
-                                         ClutterModelIter *iter);
-  void              (* row_changed)     (ClutterModel     *model,
-                                         ClutterModelIter *iter);
-  void              (* sort_changed)    (ClutterModel     *model);
-  void              (* filter_changed)  (ClutterModel     *model);
-
-  /*< private >*/
-  /* padding for future expansion */
-  void (*_clutter_model_1) (void);
-  void (*_clutter_model_2) (void);
-  void (*_clutter_model_3) (void);
-  void (*_clutter_model_4) (void);
-  void (*_clutter_model_5) (void);
-  void (*_clutter_model_6) (void);
-  void (*_clutter_model_7) (void);
-  void (*_clutter_model_8) (void);
-};
-
-CLUTTER_DEPRECATED_FOR(g_list_model_get_type)
-GType                 clutter_model_get_type           (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_set_types          (ClutterModel     *model,
-                                                        guint             n_columns,
-                                                        GType            *types);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_set_names          (ClutterModel     *model,
-                                                        guint             n_columns,
-                                                        const gchar * const names[]);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_append             (ClutterModel     *model,
-                                                        ...);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_appendv            (ClutterModel     *model,
-                                                        guint             n_columns,
-                                                        guint            *columns,
-                                                        GValue           *values);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_prepend            (ClutterModel     *model,
-                                                        ...);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_prependv           (ClutterModel     *model,
-                                                        guint             n_columns,
-                                                        guint            *columns,
-                                                        GValue           *values);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_insert             (ClutterModel     *model,
-                                                        guint             row,
-                                                        ...);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_insertv            (ClutterModel     *model,
-                                                        guint             row,
-                                                        guint             n_columns,
-                                                        guint            *columns,
-                                                        GValue           *values);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_insert_value       (ClutterModel     *model,
-                                                        guint             row,
-                                                        guint             column,
-                                                        const GValue     *value);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_remove             (ClutterModel     *model,
-                                                        guint             row);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-guint                 clutter_model_get_n_rows         (ClutterModel     *model);
-CLUTTER_DEPRECATED_FOR(GListModel)
-guint                 clutter_model_get_n_columns      (ClutterModel     *model);
-CLUTTER_DEPRECATED_FOR(GListModel)
-const gchar *         clutter_model_get_column_name    (ClutterModel     *model,
-                                                        guint             column);
-CLUTTER_DEPRECATED_FOR(GListModel)
-GType                 clutter_model_get_column_type    (ClutterModel     *model,
-                                                        guint             column);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-ClutterModelIter *    clutter_model_get_first_iter     (ClutterModel     *model);
-CLUTTER_DEPRECATED_FOR(GListModel)
-ClutterModelIter *    clutter_model_get_last_iter      (ClutterModel     *model);
-CLUTTER_DEPRECATED_FOR(GListModel)
-ClutterModelIter *    clutter_model_get_iter_at_row    (ClutterModel     *model,
-                                                        guint             row);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_set_sorting_column (ClutterModel     *model,
-                                                        gint              column);
-CLUTTER_DEPRECATED_FOR(GListModel)
-gint                  clutter_model_get_sorting_column (ClutterModel     *model);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_foreach            (ClutterModel     *model,
-                                                        ClutterModelForeachFunc func, 
-                                                        gpointer          user_data);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_set_sort           (ClutterModel     *model, 
-                                                        gint              column,
-                                                        ClutterModelSortFunc func, 
-                                                        gpointer          user_data,
-                                                        GDestroyNotify    notify);
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_set_filter         (ClutterModel     *model, 
-                                                        ClutterModelFilterFunc func, 
-                                                        gpointer          user_data,
-                                                        GDestroyNotify    notify);
-CLUTTER_DEPRECATED_FOR(GListModel)
-gboolean              clutter_model_get_filter_set     (ClutterModel     *model);
-
-CLUTTER_DEPRECATED_FOR(GListModel)
-void                  clutter_model_resort             (ClutterModel     *model);
-CLUTTER_DEPRECATED_FOR(GListModel)
-gboolean              clutter_model_filter_row         (ClutterModel     *model,
-                                                        guint             row);
-CLUTTER_DEPRECATED_FOR(GListModel)
-gboolean              clutter_model_filter_iter        (ClutterModel     *model,
-                                                        ClutterModelIter *iter);
-
-/*
- * ClutterModelIter 
- */
-
-#define CLUTTER_TYPE_MODEL_ITER                 (clutter_model_iter_get_type ())
-#define CLUTTER_MODEL_ITER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MODEL_ITER, ClutterModelIter))
-#define CLUTTER_MODEL_ITER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MODEL_ITER, ClutterModelIterClass))
-#define CLUTTER_IS_MODEL_ITER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MODEL_ITER))
-#define CLUTTER_IS_MODEL_ITER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MODEL_ITER))
-#define CLUTTER_MODEL_ITER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MODEL_ITER, ClutterModelIterClass))
-
-/**
- * ClutterModelIter:
- *
- * Base class for list models iters. The #ClutterModelIter structure
- * contains only private data and should be manipulated using the
- * provided API.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use custom iterators for #GListModel
- */
-struct _ClutterModelIter
-{
-  /*< private >*/
-  GObject parent_instance;
-
-  ClutterModelIterPrivate *priv;
-};
-
-/**
- * ClutterModelIterClass:
- * @get_value: Virtual function for retrieving the value at the given
- *   column of the row pointed by the iterator
- * @set_value: Virtual function for setting the value at the given
- *   column of the row pointer by the iterator
- * @is_last: Virtual function for knowing whether the iterator points
- *   at the last row in the model
- * @is_first: Virtual function for knowing whether the iterator points
- *   at the first row in the model
- * @next: Virtual function for moving the iterator to the following
- *   row in the model
- * @prev: Virtual function for moving the iterator toe the previous
- *   row in the model
- * @get_model: Virtual function for getting the model to which the
- *   iterator belongs to
- * @get_row: Virtual function for getting the row to which the iterator
- *   points
- * @copy: Virtual function for copying a #ClutterModelIter.
- *
- * Class for #ClutterModelIter instances.
- *
- * Since: 0.6
- *
- * Deprecated: 1.24: Use custom iterators for #GListModel
- */
-struct _ClutterModelIterClass 
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  /* vtable not signals */
-  void              (* get_value) (ClutterModelIter *iter, 
-                                   guint             column, 
-                                   GValue           *value);
-  void              (* set_value) (ClutterModelIter *iter, 
-                                   guint             column, 
-                                   const GValue     *value);
-
-  gboolean          (* is_first)  (ClutterModelIter *iter);
-  gboolean          (* is_last)   (ClutterModelIter *iter);
-
-  ClutterModelIter *(* next)      (ClutterModelIter *iter);
-  ClutterModelIter *(* prev)      (ClutterModelIter *iter);
-
-  ClutterModel *    (* get_model) (ClutterModelIter *iter);
-  guint             (* get_row)   (ClutterModelIter *iter);
-
-  ClutterModelIter *(* copy)      (ClutterModelIter *iter);
-
-  /*< private >*/
-  /* padding for future expansion */
-  void (*_clutter_model_iter_1) (void);
-  void (*_clutter_model_iter_2) (void);
-  void (*_clutter_model_iter_3) (void);
-  void (*_clutter_model_iter_4) (void);
-  void (*_clutter_model_iter_5) (void);
-  void (*_clutter_model_iter_6) (void);
-  void (*_clutter_model_iter_7) (void);
-  void (*_clutter_model_iter_8) (void);
-};
-
-CLUTTER_DEPRECATED
-GType             clutter_model_iter_get_type   (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-void              clutter_model_iter_get        (ClutterModelIter *iter,
-                                                 ...);
-CLUTTER_DEPRECATED
-void              clutter_model_iter_get_valist (ClutterModelIter *iter,
-                                                 va_list          args);
-CLUTTER_DEPRECATED
-void              clutter_model_iter_get_value  (ClutterModelIter *iter,
-                                                 guint             column,
-                                                 GValue           *value);
-CLUTTER_DEPRECATED
-void              clutter_model_iter_set        (ClutterModelIter *iter,
-                                                 ...);
-CLUTTER_DEPRECATED
-void              clutter_model_iter_set_valist (ClutterModelIter *iter,
-                                                 va_list          args);
-CLUTTER_DEPRECATED
-void              clutter_model_iter_set_value  (ClutterModelIter *iter,
-                                                 guint             column,
-                                                 const GValue     *value);
-
-CLUTTER_DEPRECATED
-gboolean          clutter_model_iter_is_first   (ClutterModelIter *iter);
-CLUTTER_DEPRECATED
-gboolean          clutter_model_iter_is_last    (ClutterModelIter *iter);
-CLUTTER_DEPRECATED
-ClutterModelIter *clutter_model_iter_next       (ClutterModelIter *iter);
-CLUTTER_DEPRECATED
-ClutterModelIter *clutter_model_iter_prev       (ClutterModelIter *iter);
-
-CLUTTER_DEPRECATED
-ClutterModel *    clutter_model_iter_get_model  (ClutterModelIter *iter);
-CLUTTER_DEPRECATED
-guint             clutter_model_iter_get_row    (ClutterModelIter *iter);
-
-CLUTTER_DEPRECATED
-ClutterModelIter *clutter_model_iter_copy       (ClutterModelIter *iter);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_MODEL_H__ */

clutter/clutter/deprecated/clutter-rectangle.c

@@ -81,11 +81,7 @@ static void
 clutter_rectangle_paint (ClutterActor *self)
 {
   ClutterRectanglePrivate *priv = CLUTTER_RECTANGLE (self)->priv;
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
-  static CoglPipeline *default_color_pipeline = NULL;
-  CoglPipeline *content_pipeline;
   ClutterGeometry geom;
-  CoglColor color;
   guint8 tmp_alpha;
 
   CLUTTER_NOTE (PAINT,
@@ -94,86 +90,58 @@ clutter_rectangle_paint (ClutterActor *self)
                                               : "unknown");
   clutter_actor_get_allocation_geometry (self, &geom);
 
-  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);
-  content_pipeline = cogl_pipeline_copy (default_color_pipeline);
-
-  /* compute the composited opacity of the actor taking into
-   * account the opacity of the color set by the user
-   */
-  tmp_alpha = clutter_actor_get_paint_opacity (self)
-            * priv->color.alpha
-            / 255;
-
-  cogl_color_init_from_4ub (&color,
-                            priv->color.red,
-                            priv->color.green,
-                            priv->color.blue,
-                            tmp_alpha);
-  cogl_color_premultiply (&color);
-  cogl_pipeline_set_color (content_pipeline, &color);
-
   if (priv->has_border)
     {
-      CoglPipeline *border_pipeline;
-
-      border_pipeline = cogl_pipeline_copy (default_color_pipeline);
-
-      tmp_alpha = clutter_actor_get_paint_opacity (self)
-                * priv->border_color.alpha
-                / 255;
-
-      cogl_color_init_from_4ub (&color,
-                                priv->border_color.red,
-                                priv->border_color.green,
-                                priv->border_color.blue,
-                                tmp_alpha);
-      cogl_color_premultiply (&color);
-      cogl_pipeline_set_color (border_pipeline, &color);
-
       /* We paint the border and the content only if the rectangle
        * is big enough to show them
        */
       if ((priv->border_width * 2) < geom.width &&
           (priv->border_width * 2) < geom.height)
         {
-          /* paint the border. this sucks, but it's the only way to make a border */
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           border_pipeline,
-                                           priv->border_width, 0,
-                                           geom.width,
-                                           priv->border_width);
+          /* compute the composited opacity of the actor taking into
+           * account the opacity of the color set by the user
+           */
+          tmp_alpha = clutter_actor_get_paint_opacity (self)
+                    * priv->border_color.alpha
+                    / 255;
 
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           border_pipeline,
-                                           geom.width - priv->border_width,
-                                           priv->border_width,
-                                           geom.width, geom.height);
+          /* paint the border */
+          cogl_set_source_color4ub (priv->border_color.red,
+                                    priv->border_color.green,
+                                    priv->border_color.blue,
+                                    tmp_alpha);
 
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           border_pipeline,
-                                           0, geom.height - priv->border_width,
-                                           geom.width - priv->border_width,
-                                           geom.height);
+          /* this sucks, but it's the only way to make a border */
+          cogl_rectangle (priv->border_width, 0,
+                          geom.width,
+                          priv->border_width);
 
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           border_pipeline,
-                                           0, 0,
-                                           priv->border_width,
-                                           geom.height - priv->border_width);
+          cogl_rectangle (geom.width - priv->border_width,
+                          priv->border_width,
+                          geom.width,
+                          geom.height);
+
+          cogl_rectangle (0, geom.height - priv->border_width,
+                          geom.width - priv->border_width,
+                          geom.height);
+
+          cogl_rectangle (0, 0,
+                          priv->border_width,
+                          geom.height - priv->border_width);
+
+          tmp_alpha = clutter_actor_get_paint_opacity (self)
+                    * priv->color.alpha
+                    / 255;
 
           /* now paint the rectangle */
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           content_pipeline,
-                                           priv->border_width, priv->border_width,
-                                           geom.width - priv->border_width,
-                                           geom.height - priv->border_width);
+          cogl_set_source_color4ub (priv->color.red,
+                                    priv->color.green,
+                                    priv->color.blue,
+                                    tmp_alpha);
+
+          cogl_rectangle (priv->border_width, priv->border_width,
+                          geom.width - priv->border_width,
+                          geom.height - priv->border_width);
         }
       else
         {
@@ -181,21 +149,34 @@ clutter_rectangle_paint (ClutterActor *self)
            * as the border, since we can only fit that into the
            * allocation.
            */
-          cogl_framebuffer_draw_rectangle (framebuffer,
-                                           border_pipeline,
-                                           0, 0, geom.width, geom.height);
-        }
+          tmp_alpha = clutter_actor_get_paint_opacity (self)
+                    * priv->border_color.alpha
+                    / 255;
 
-      cogl_object_unref (border_pipeline);
+          cogl_set_source_color4ub (priv->border_color.red,
+                                    priv->border_color.green,
+                                    priv->border_color.blue,
+                                    tmp_alpha);
+
+          cogl_rectangle (0, 0, geom.width, geom.height);
+        }
     }
   else
     {
-      cogl_framebuffer_draw_rectangle (framebuffer,
-                                       content_pipeline,
-                                       0, 0, geom.width, geom.height);
-    }
+      /* compute the composited opacity of the actor taking into
+       * account the opacity of the color set by the user
+       */
+      tmp_alpha = clutter_actor_get_paint_opacity (self)
+                * priv->color.alpha
+                / 255;
 
-  cogl_object_unref (content_pipeline);
+      cogl_set_source_color4ub (priv->color.red,
+                                priv->color.green,
+                                priv->color.blue,
+                                tmp_alpha);
+
+      cogl_rectangle (0, 0, geom.width, geom.height);
+    }
 }
 
 static gboolean

clutter/clutter/deprecated/clutter-score.h

@@ -1,144 +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/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_SCORE_H__
-#define __CLUTTER_SCORE_H__
-
-#include <clutter/clutter-timeline.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_SCORE              (clutter_score_get_type ())
-
-#define CLUTTER_SCORE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SCORE, ClutterScore))
-#define CLUTTER_SCORE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_SCORE, ClutterScoreClass))
-#define CLUTTER_IS_SCORE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SCORE))
-#define CLUTTER_IS_SCORE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SCORE))
-#define CLUTTER_SCORE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SCORE, ClutterScoreClass))
-
-typedef struct _ClutterScore        ClutterScore;
-typedef struct _ClutterScorePrivate ClutterScorePrivate;
-typedef struct _ClutterScoreClass   ClutterScoreClass; 
-
-/**
- * ClutterScore:
- *
- * The #ClutterScore structure contains only private data
- * and should be accessed using the provided API
- *
- * Since: 0.6
- */
-struct _ClutterScore
-{
-  /*< private >*/
-  GObject                 parent;
-  ClutterScorePrivate    *priv;
-};
-
-/**
- * ClutterScoreClass:
- * @timeline_started: handler for the #ClutterScore::timeline-started signal
- * @timeline_completed: handler for the #ClutterScore::timeline-completed
- *   signal
- * @started: handler for the #ClutterScore::started signal
- * @completed: handler for the #ClutterScore::completed signal
- * @paused: handler for the #ClutterScore::paused signal
- *
- * The #ClutterScoreClass structure contains only private data
- *
- * Since: 0.6
- */
-struct _ClutterScoreClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  void (* timeline_started)   (ClutterScore    *score,
-                               ClutterTimeline *timeline);
-  void (* timeline_completed) (ClutterScore    *score,
-                               ClutterTimeline *timeline);
-
-  void (* started)            (ClutterScore    *score);
-  void (* completed)          (ClutterScore    *score);
-  void (* paused)             (ClutterScore    *score);
-
-  /*< private >*/
-  /* padding for future expansion */
-  void (*_clutter_score_1) (void);
-  void (*_clutter_score_2) (void);
-  void (*_clutter_score_3) (void);
-  void (*_clutter_score_4) (void);
-  void (*_clutter_score_5) (void);
-}; 
-
-CLUTTER_DEPRECATED
-GType clutter_score_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterScore *   clutter_score_new            (void);
-
-CLUTTER_DEPRECATED
-void             clutter_score_set_loop         (ClutterScore    *score,
-                                                 gboolean         loop);
-CLUTTER_DEPRECATED
-gboolean         clutter_score_get_loop         (ClutterScore    *score);
-
-CLUTTER_DEPRECATED
-gulong           clutter_score_append           (ClutterScore    *score,
-                                                 ClutterTimeline *parent,
-                                                 ClutterTimeline *timeline);
-CLUTTER_DEPRECATED
-gulong           clutter_score_append_at_marker (ClutterScore    *score,
-                                                 ClutterTimeline *parent,
-                                                 const gchar     *marker_name,
-                                                 ClutterTimeline *timeline);
-CLUTTER_DEPRECATED
-void             clutter_score_remove           (ClutterScore    *score,
-                                                 gulong           id_);
-CLUTTER_DEPRECATED
-void             clutter_score_remove_all       (ClutterScore    *score);
-CLUTTER_DEPRECATED
-ClutterTimeline *clutter_score_get_timeline     (ClutterScore    *score,
-                                                 gulong           id_);
-CLUTTER_DEPRECATED
-GSList *         clutter_score_list_timelines   (ClutterScore    *score);
-
-CLUTTER_DEPRECATED
-void             clutter_score_start            (ClutterScore    *score);
-CLUTTER_DEPRECATED
-void             clutter_score_stop             (ClutterScore    *score);
-CLUTTER_DEPRECATED
-void             clutter_score_pause            (ClutterScore    *score);
-CLUTTER_DEPRECATED
-void             clutter_score_rewind           (ClutterScore    *score);
-CLUTTER_DEPRECATED
-gboolean         clutter_score_is_playing       (ClutterScore    *score);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_SCORE_H__ */

clutter/clutter/deprecated/clutter-shader.c

@@ -1,907 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By: Matthew Allum   <mallum@openedhand.com>
- *              Øyvind Kolås    <pippin@o-hand.com>
- *              Emmanuele Bassi <ebassi@linux.intel.com>
- *
- * Copyright (C) 2007, 2008 OpenedHand
- * Copyright (C) 2009 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/>.
- *
- *
- */
-
-/**
- * SECTION:clutter-shader
- * @short_description: Programmable pipeline abstraction
- *
- * #ClutterShader is an object providing an abstraction over the
- * OpenGL programmable pipeline. By using #ClutterShader<!-- -->s is
- * possible to override the drawing pipeline by using small programs
- * also known as "shaders".
- *
- * #ClutterShader is available since Clutter 0.6.
- *
- * #ClutterShader is deprecated since Clutter 1.8; use #ClutterShaderEffect
- * in newly written code, instead.
- */
-
-#include "clutter-build-config.h"
-
-#include <string.h>
-#include <stdlib.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-
-#include <glib.h>
-
-#include <cogl/cogl.h>
-
-#include "clutter-shader.h"
-
-#include "clutter-debug.h"
-#include "clutter-private.h"
-
-/* global list of shaders */
-static GList *clutter_shaders_list = NULL;
-
-struct _ClutterShaderPrivate
-{
-  guint       compiled         : 1; /* Shader is bound to the GL context */
-  guint       is_enabled       : 1;
-
-  gchar      *vertex_source;        /* GLSL source for vertex shader */
-  gchar      *fragment_source;      /* GLSL source for fragment shader */
-
-  CoglHandle  program;
-
-  CoglHandle  vertex_shader;
-  CoglHandle  fragment_shader;
-};
-
-enum
-{
-  PROP_0,
-
-  PROP_VERTEX_SOURCE,
-  PROP_FRAGMENT_SOURCE,
-  PROP_COMPILED,
-  PROP_ENABLED,
-
-  PROP_LAST
-};
-
-static GParamSpec *obj_props[PROP_LAST];
-
-G_DEFINE_TYPE_WITH_PRIVATE (ClutterShader, clutter_shader, G_TYPE_OBJECT)
-
-static inline void
-clutter_shader_release_internal (ClutterShader *shader)
-{
-  ClutterShaderPrivate *priv = shader->priv;
-
-  if (!priv->compiled)
-    return;
-
-  g_assert (priv->program != COGL_INVALID_HANDLE);
-
-  if (priv->vertex_shader != COGL_INVALID_HANDLE)
-    cogl_handle_unref (priv->vertex_shader);
-
-  if (priv->fragment_shader != COGL_INVALID_HANDLE)
-    cogl_handle_unref (priv->fragment_shader);
-
-  if (priv->program != COGL_INVALID_HANDLE)
-    cogl_handle_unref (priv->program);
-
-  priv->vertex_shader = COGL_INVALID_HANDLE;
-  priv->fragment_shader = COGL_INVALID_HANDLE;
-  priv->program = COGL_INVALID_HANDLE;
-  priv->compiled = FALSE;
-}
-
-static void
-clutter_shader_finalize (GObject *object)
-{
-  ClutterShader        *shader;
-  ClutterShaderPrivate *priv;
-
-  shader = CLUTTER_SHADER (object);
-  priv   = shader->priv;
-
-  clutter_shaders_list = g_list_remove (clutter_shaders_list, object);
-
-  g_free (priv->fragment_source);
-  g_free (priv->vertex_source);
-
-  G_OBJECT_CLASS (clutter_shader_parent_class)->finalize (object);
-}
-
-static void
-clutter_shader_dispose (GObject *object)
-{
-  ClutterShader *shader = CLUTTER_SHADER (object);
-
-  clutter_shader_release_internal (shader);
-
-  G_OBJECT_CLASS (clutter_shader_parent_class)->finalize (object);
-}
-
-static void
-clutter_shader_set_property (GObject      *object,
-                             guint         prop_id,
-                             const GValue *value,
-                             GParamSpec   *pspec)
-{
-  ClutterShader *shader = CLUTTER_SHADER(object);
-
-  switch (prop_id)
-    {
-    case PROP_VERTEX_SOURCE:
-      clutter_shader_set_vertex_source (shader,
-					g_value_get_string (value), -1);
-      break;
-    case PROP_FRAGMENT_SOURCE:
-      clutter_shader_set_fragment_source (shader,
-					  g_value_get_string (value), -1);
-      break;
-    case PROP_ENABLED:
-      clutter_shader_set_is_enabled (shader, g_value_get_boolean (value));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-clutter_shader_get_property (GObject    *object,
-                             guint       prop_id,
-                             GValue     *value,
-                             GParamSpec *pspec)
-{
-  ClutterShader        *shader;
-  ClutterShaderPrivate *priv;
-
-  shader = CLUTTER_SHADER(object);
-  priv = shader->priv;
-
-  switch (prop_id)
-    {
-    case PROP_VERTEX_SOURCE:
-      g_value_set_string (value, priv->vertex_source);
-      break;
-    case PROP_FRAGMENT_SOURCE:
-      g_value_set_string (value, priv->fragment_source);
-      break;
-    case PROP_COMPILED:
-      g_value_set_boolean (value, priv->compiled);
-      break;
-    case PROP_ENABLED:
-      g_value_set_boolean (value, priv->is_enabled);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static GObject *
-clutter_shader_constructor (GType                  type,
-                            guint                  n_params,
-                            GObjectConstructParam *params)
-{
-  GObjectClass *parent_class;
-  GObject *object;
-
-  parent_class = G_OBJECT_CLASS (clutter_shader_parent_class);
-  object = parent_class->constructor (type, n_params, params);
-
-  /* add this instance to the global list of shaders */
-  clutter_shaders_list = g_list_prepend (clutter_shaders_list, object);
-
-  return object;
-}
-
-static void
-clutter_shader_class_init (ClutterShaderClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GParamSpec *pspec = NULL;
-
-  object_class->finalize      = clutter_shader_finalize;
-  object_class->dispose       = clutter_shader_dispose;
-  object_class->set_property  = clutter_shader_set_property;
-  object_class->get_property  = clutter_shader_get_property;
-  object_class->constructor   = clutter_shader_constructor;
-
-  /**
-   * ClutterShader:vertex-source:
-   *
-   * GLSL source code for the vertex shader part of the shader
-   * program, if any
-   *
-   * Since: 0.6
-   *
-   * Deprecated: 1.8: Use #ClutterShaderEffect instead.
-   */
-  pspec = g_param_spec_string ("vertex-source",
-                               P_("Vertex Source"),
-                               P_("Source of vertex shader"),
-                               NULL,
-                               CLUTTER_PARAM_READWRITE);
-  obj_props[PROP_VERTEX_SOURCE] = pspec;
-  g_object_class_install_property (object_class, PROP_VERTEX_SOURCE, pspec);
-
-  /**
-   * ClutterShader:fragment-source:
-   *
-   * GLSL source code for the fragment shader part of the shader program.
-   *
-   * Since: 0.6
-   *
-   * Deprecated: 1.8: Use #ClutterShaderEffect instead.
-   */
-  pspec = g_param_spec_string ("fragment-source",
-                               P_("Fragment Source"),
-                               P_("Source of fragment shader"),
-                               NULL,
-                               CLUTTER_PARAM_READWRITE);
-  obj_props[PROP_FRAGMENT_SOURCE] = pspec;
-  g_object_class_install_property (object_class, PROP_FRAGMENT_SOURCE, pspec);
-
-  /**
-   * ClutterShader:compiled:
-   *
-   * Whether the shader is compiled and linked, ready for use
-   * in the GL context.
-   *
-   * Since: 0.8
-   *
-   * Deprecated: 1.8: Use #ClutterShaderEffect instead.
-   */
-  pspec = g_param_spec_boolean ("compiled",
-                                P_("Compiled"),
-                                P_("Whether the shader is compiled and linked"),
-                                FALSE,
-                                CLUTTER_PARAM_READABLE);
-  obj_props[PROP_COMPILED] = pspec;
-  g_object_class_install_property (object_class, PROP_COMPILED, pspec);
-
-  /**
-   * ClutterShader:enabled:
-   *
-   * Whether the shader is currently used in the GL rendering pipeline.
-   *
-   * Since: 0.6
-   *
-   * Deprecated: 1.8: Use #ClutterShaderEffect instead.
-   */
-  pspec = g_param_spec_boolean ("enabled",
-                                P_("Enabled"),
-                                P_("Whether the shader is enabled"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE);
-  obj_props[PROP_ENABLED] = pspec;
-  g_object_class_install_property (object_class, PROP_ENABLED, pspec);
-}
-
-static void
-clutter_shader_init (ClutterShader *self)
-{
-  ClutterShaderPrivate *priv;
-
-  priv = self->priv = clutter_shader_get_instance_private (self);
-
-  priv->compiled = FALSE;
-
-  priv->vertex_source = NULL;
-  priv->fragment_source = NULL;
-
-  priv->program = COGL_INVALID_HANDLE;
-  priv->vertex_shader = COGL_INVALID_HANDLE;
-  priv->fragment_shader = COGL_INVALID_HANDLE;
-}
-
-/**
- * clutter_shader_new:
- *
- * Create a new #ClutterShader instance.
- *
- * Return value: a new #ClutterShader.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-ClutterShader *
-clutter_shader_new (void)
-{
-  return g_object_new (CLUTTER_TYPE_SHADER, NULL);
-}
-
-static inline void
-clutter_shader_set_source (ClutterShader     *shader,
-                           ClutterShaderType  shader_type,
-                           const gchar       *data,
-                           gssize             length)
-{
-  ClutterShaderPrivate *priv = shader->priv;
-
-  if (length < 0)
-    length = strlen (data);
-
-  g_object_freeze_notify (G_OBJECT (shader));
-
-  /* release shader if bound when changing the source, the shader will
-   * automatically be rebound on the next use.
-   */
-  if (clutter_shader_is_compiled (shader))
-    clutter_shader_release (shader);
-
-  CLUTTER_NOTE (SHADER,
-                "setting %s shader (len:%" G_GSSIZE_FORMAT ")",
-                shader_type == CLUTTER_VERTEX_SHADER ? "vertex" : "fragment",
-                length);
-
-  switch (shader_type)
-    {
-    case CLUTTER_FRAGMENT_SHADER:
-      g_free (priv->fragment_source);
-
-      priv->fragment_source = g_strndup (data, length);
-      g_object_notify_by_pspec (G_OBJECT (shader), obj_props[PROP_FRAGMENT_SOURCE]);
-      break;
-
-    case CLUTTER_VERTEX_SHADER:
-      g_free (priv->vertex_source);
-
-      priv->vertex_source = g_strndup (data, length);
-      g_object_notify_by_pspec (G_OBJECT (shader), obj_props[PROP_VERTEX_SOURCE]);
-      break;
-    }
-
-  g_object_thaw_notify (G_OBJECT (shader));
-}
-
-/**
- * clutter_shader_set_fragment_source:
- * @shader: a #ClutterShader
- * @data: GLSL source code.
- * @length: length of source buffer (currently ignored)
- *
- * Sets the GLSL source code to be used by a #ClutterShader for the fragment
- * program.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-void
-clutter_shader_set_fragment_source (ClutterShader      *shader,
-                                    const gchar        *data,
-                                    gssize              length)
-{
-  g_return_if_fail (CLUTTER_IS_SHADER (shader));
-  g_return_if_fail (data != NULL);
-
-  clutter_shader_set_source (shader, CLUTTER_FRAGMENT_SHADER, data, length);
-}
-
-/**
- * clutter_shader_set_vertex_source:
- * @shader: a #ClutterShader
- * @data: GLSL source code.
- * @length: length of source buffer (currently ignored)
- *
- * Sets the GLSL source code to be used by a #ClutterShader for the vertex
- * program.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-void
-clutter_shader_set_vertex_source (ClutterShader      *shader,
-                                  const gchar        *data,
-                                  gssize              length)
-{
-  g_return_if_fail (CLUTTER_IS_SHADER (shader));
-  g_return_if_fail (data != NULL);
-
-  clutter_shader_set_source (shader, CLUTTER_VERTEX_SHADER, data, length);
-}
-
-static const gchar *
-clutter_shader_get_source (ClutterShader     *shader,
-                           ClutterShaderType  shader_type)
-{
-  switch (shader_type)
-    {
-    case CLUTTER_FRAGMENT_SHADER:
-      return shader->priv->fragment_source;
-
-    case CLUTTER_VERTEX_SHADER:
-      return shader->priv->vertex_source;
-    }
-
-  return NULL;
-}
-
-static CoglHandle
-clutter_shader_get_cogl_shader (ClutterShader     *shader,
-                                ClutterShaderType  shader_type)
-{
-  switch (shader_type)
-    {
-    case CLUTTER_FRAGMENT_SHADER:
-      return shader->priv->fragment_shader;
-
-    case CLUTTER_VERTEX_SHADER:
-      return shader->priv->vertex_shader;
-    }
-
-  return COGL_INVALID_HANDLE;
-}
-
-static gboolean
-clutter_shader_glsl_bind (ClutterShader      *self,
-                          ClutterShaderType   shader_type,
-                          GError            **error)
-{
-  ClutterShaderPrivate *priv = self->priv;
-  CoglHandle shader = COGL_INVALID_HANDLE;
-
-  switch (shader_type)
-    {
-    case CLUTTER_VERTEX_SHADER:
-      shader = cogl_create_shader (COGL_SHADER_TYPE_VERTEX);
-      cogl_shader_source (shader, priv->vertex_source);
-
-      priv->vertex_shader = shader;
-      break;
-
-    case CLUTTER_FRAGMENT_SHADER:
-      shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
-      cogl_shader_source (shader, priv->fragment_source);
-
-      priv->fragment_shader = shader;
-      break;
-    }
-
-  g_assert (shader != COGL_INVALID_HANDLE);
-
-  cogl_shader_compile (shader);
-  if (!cogl_shader_is_compiled (shader))
-    {
-      gchar *log_buf;
-
-      log_buf = cogl_shader_get_info_log (shader);
-
-      /* translators: the first %s is the type of the shader, either
-       * Vertex shader or Fragment shader; the second %s is the actual
-       * error as reported by COGL
-       */
-      g_set_error (error, CLUTTER_SHADER_ERROR,
-                   CLUTTER_SHADER_ERROR_COMPILE,
-                   _("%s compilation failed: %s"),
-                   shader_type == CLUTTER_VERTEX_SHADER ? _("Vertex shader")
-                                                        : _("Fragment shader"),
-                   log_buf);
-
-      g_free (log_buf);
-
-      return FALSE;
-    }
-
-  cogl_program_attach_shader (priv->program, shader);
-
-  return TRUE;
-}
-
-static gboolean
-bind_glsl_shader (ClutterShader  *self,
-                  GError        **error)
-{
-  ClutterShaderPrivate *priv = self->priv;
-  GError *bind_error = NULL;
-  gboolean res;
-
-  priv->program = cogl_create_program ();
-
-  if (priv->vertex_source != COGL_INVALID_HANDLE)
-    {
-      res = clutter_shader_glsl_bind (self,
-                                      CLUTTER_VERTEX_SHADER,
-                                      &bind_error);
-
-      if (!res)
-        {
-          g_propagate_error (error, bind_error);
-          return FALSE;
-        }
-    }
-
-  if (priv->fragment_source != COGL_INVALID_HANDLE)
-    {
-      res = clutter_shader_glsl_bind (self,
-                                      CLUTTER_FRAGMENT_SHADER,
-                                      &bind_error);
-
-      if (!res)
-        {
-          g_propagate_error (error, bind_error);
-          return FALSE;
-        }
-    }
-
-  cogl_program_link (priv->program);
-
-  return TRUE;
-}
-
-/**
- * clutter_shader_compile:
- * @shader: a #ClutterShader
- * @error: return location for a #GError, or %NULL
- *
- * Compiles and links GLSL sources set for vertex and fragment shaders for
- * a #ClutterShader. If the compilation fails and a #GError return location is
- * provided the error will contain the errors from the compiler, if any.
- *
- * Return value: returns TRUE if the shader was succesfully compiled.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-gboolean
-clutter_shader_compile (ClutterShader  *shader,
-                        GError        **error)
-{
-  ClutterShaderPrivate *priv;
-
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), FALSE);
-
-  priv = shader->priv;
-
-  if (priv->compiled)
-    return priv->compiled;
-
-  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
-    {
-      g_set_error (error, CLUTTER_SHADER_ERROR,
-                   CLUTTER_SHADER_ERROR_NO_GLSL,
-                   "GLSL shaders not supported");
-      priv->compiled = FALSE;
-      return priv->compiled;
-    }
-
-  priv->compiled = bind_glsl_shader (shader, error);
-  g_object_notify_by_pspec (G_OBJECT (shader), obj_props[PROP_COMPILED]);
-
-  return priv->compiled;
-}
-
-/**
- * clutter_shader_release:
- * @shader: a #ClutterShader
- *
- * Frees up any GL context resources held by the shader.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-void
-clutter_shader_release (ClutterShader *shader)
-{
-  g_return_if_fail (CLUTTER_IS_SHADER (shader));
-
-  clutter_shader_release_internal (shader);
-
-  g_object_notify_by_pspec (G_OBJECT (shader), obj_props[PROP_COMPILED]);
-}
-
-/**
- * clutter_shader_is_compiled:
- * @shader: a #ClutterShader
- *
- * Checks whether @shader is is currently compiled, linked and bound
- * to the GL context.
- *
- * Return value: %TRUE if the shader is compiled, linked and ready for use.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-gboolean
-clutter_shader_is_compiled (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), FALSE);
-
-  return shader->priv->compiled;
-}
-
-/**
- * clutter_shader_set_is_enabled:
- * @shader: a #ClutterShader
- * @enabled: The new state of the shader.
- *
- * Enables a shader. This function will attempt to compile and link
- * the shader, if it isn't already.
- *
- * When @enabled is %FALSE the default state of the GL pipeline will be
- * used instead.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-void
-clutter_shader_set_is_enabled (ClutterShader *shader,
-                               gboolean       enabled)
-{
-  ClutterShaderPrivate *priv;
-
-  g_return_if_fail (CLUTTER_IS_SHADER (shader));
-
-  priv = shader->priv;
-
-  if (priv->is_enabled != enabled)
-    {
-      GError *error = NULL;
-      gboolean res;
-
-      res = clutter_shader_compile (shader, &error);
-      if (!res)
-        {
-          g_warning ("Unable to bind the shader: %s",
-                     error ? error->message : "unknown error");
-          if (error)
-            g_error_free (error);
-
-          return;
-        }
-
-      priv->is_enabled = enabled;
-
-      if (priv->is_enabled)
-        cogl_program_use (priv->program);
-      else
-        cogl_program_use (COGL_INVALID_HANDLE);
-
-      g_object_notify_by_pspec (G_OBJECT (shader), obj_props[PROP_ENABLED]);
-    }
-}
-
-/**
- * clutter_shader_get_is_enabled:
- * @shader: a #ClutterShader
- *
- * Checks whether @shader is enabled.
- *
- * Return value: %TRUE if the shader is enabled.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-gboolean
-clutter_shader_get_is_enabled (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), FALSE);
-
-  return shader->priv->is_enabled;
-}
-
-/**
- * clutter_shader_set_uniform:
- * @shader: a #ClutterShader.
- * @name: name of uniform in GLSL shader program to set.
- * @value: a #ClutterShaderFloat, #ClutterShaderInt or #ClutterShaderMatrix
- *         #GValue.
- *
- * Sets a user configurable variable in the GLSL shader programs attached to
- * a #ClutterShader.
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-void
-clutter_shader_set_uniform (ClutterShader *shader,
-                            const gchar   *name,
-                            const GValue  *value)
-{
-  ClutterShaderPrivate *priv;
-  int                   location = 0;
-  gsize                 size;
-
-  g_return_if_fail (CLUTTER_IS_SHADER (shader));
-  g_return_if_fail (name != NULL);
-  g_return_if_fail (value != NULL);
-  g_return_if_fail (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_INT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value) ||
-                    G_VALUE_HOLDS_FLOAT (value) ||
-                    G_VALUE_HOLDS_INT (value));
-
-  priv = shader->priv;
-  g_return_if_fail (priv->program != COGL_INVALID_HANDLE);
-
-  location = cogl_program_get_uniform_location (priv->program, name);
-
-  if (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value))
-    {
-      const float *floats;
-
-      floats = clutter_value_get_shader_float (value, &size);
-      cogl_program_set_uniform_float (priv->program,
-                                      location, size, 1, floats);
-    }
-  else if (CLUTTER_VALUE_HOLDS_SHADER_INT (value))
-    {
-      const int *ints;
-
-      ints = clutter_value_get_shader_int (value, &size);
-      cogl_program_set_uniform_int (priv->program,
-                                    location, size, 1, ints);
-    }
-  else if (CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value))
-    {
-      const float *matrix;
-
-      matrix = clutter_value_get_shader_matrix (value, &size);
-      cogl_program_set_uniform_matrix (priv->program,
-                                       location, size, 1, FALSE, matrix);
-    }
-  else if (G_VALUE_HOLDS_FLOAT (value))
-    {
-      float float_val = g_value_get_float (value);
-
-      cogl_program_set_uniform_float (priv->program,
-                                      location, 1, 1, &float_val);
-    }
-  else if (G_VALUE_HOLDS_INT (value))
-    {
-      int int_val = g_value_get_int (value);
-
-      cogl_program_set_uniform_int (priv->program,
-                                    location, 1, 1, &int_val);
-    }
-  else
-    g_assert_not_reached ();
-}
-
-/**
- * clutter_shader_get_fragment_source:
- * @shader: a #ClutterShader
- *
- * Query the current GLSL fragment source set on @shader.
- *
- * Return value: the source of the fragment shader for this
- * ClutterShader object or %NULL. The returned string is owned by the
- * shader object and should never be modified or freed
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-const gchar *
-clutter_shader_get_fragment_source (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), NULL);
-
-  return clutter_shader_get_source (shader, CLUTTER_FRAGMENT_SHADER);
-}
-
-/**
- * clutter_shader_get_vertex_source:
- * @shader: a #ClutterShader
- *
- * Query the current GLSL vertex source set on @shader.
- *
- * Return value: the source of the vertex shader for this
- * ClutterShader object or %NULL. The returned string is owned by the
- * shader object and should never be modified or freed
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-const gchar *
-clutter_shader_get_vertex_source (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), NULL);
-
-  return clutter_shader_get_source (shader, CLUTTER_VERTEX_SHADER);
-}
-
-/**
- * clutter_shader_get_cogl_program:
- * @shader: a #ClutterShader
- *
- * Retrieves the underlying #CoglHandle for the shader program.
- *
- * Return value: (transfer none): A #CoglHandle for the shader program,
- *   or %NULL. The handle is owned by the #ClutterShader and it should
- *   not be unreferenced
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-CoglHandle
-clutter_shader_get_cogl_program (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), NULL);
-
-  return shader->priv->program;
-}
-
-/**
- * clutter_shader_get_cogl_fragment_shader:
- * @shader: a #ClutterShader
- *
- * Retrieves the underlying #CoglHandle for the fragment shader.
- *
- * Return value: (transfer none): A #CoglHandle for the fragment
- *   shader, or %NULL. The handle is owned by the #ClutterShader
- *   and it should not be unreferenced
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-CoglHandle
-clutter_shader_get_cogl_fragment_shader (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), NULL);
-
-  return clutter_shader_get_cogl_shader (shader, CLUTTER_FRAGMENT_SHADER);
-}
-
-/**
- * clutter_shader_get_cogl_vertex_shader:
- * @shader: a #ClutterShader
- *
- * Retrieves the underlying #CoglHandle for the vertex shader.
- *
- * Return value: (transfer none): A #CoglHandle for the vertex
- *   shader, or %NULL. The handle is owned by the #ClutterShader
- *   and it should not be unreferenced
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead.
- */
-CoglHandle
-clutter_shader_get_cogl_vertex_shader (ClutterShader *shader)
-{
-  g_return_val_if_fail (CLUTTER_IS_SHADER (shader), NULL);
-
-  return clutter_shader_get_cogl_shader (shader, CLUTTER_VERTEX_SHADER);
-}
-
-GQuark
-clutter_shader_error_quark (void)
-{
-  return g_quark_from_static_string ("clutter-shader-error");
-}

clutter/clutter/deprecated/clutter-shader.h

@@ -1,182 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Øyvind Kolås   <pippin@o-hand.com>
- *
- * Copyright (C) 2007 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/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_SHADER_H__
-#define __CLUTTER_SHADER_H__
-
-#include <clutter/clutter-types.h>
-#include <clutter/clutter-shader-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_SHADER         (clutter_shader_get_type ())
-#define CLUTTER_SHADER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), CLUTTER_TYPE_SHADER, ClutterShader))
-#define CLUTTER_SHADER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), CLUTTER_TYPE_SHADER, ClutterShaderClass))
-#define CLUTTER_IS_SHADER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), CLUTTER_TYPE_SHADER))
-#define CLUTTER_IS_SHADER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), CLUTTER_TYPE_SHADER))
-#define CLUTTER_SHADER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), CLUTTER_TYPE_SHADER, ClutterShaderClass))
-
-/**
- * CLUTTER_SHADER_ERROR:
- *
- * Error domain for #ClutterShader errors
- *
- * Since: 0.6
- *
- * Deprecated: 1.8
- */
-#define CLUTTER_SHADER_ERROR        (clutter_shader_error_quark ())
-
-/**
- * ClutterShaderError:
- * @CLUTTER_SHADER_ERROR_NO_ASM: No ASM shaders support
- * @CLUTTER_SHADER_ERROR_NO_GLSL: No GLSL shaders support
- * @CLUTTER_SHADER_ERROR_COMPILE: Compilation error
- *
- * #ClutterShader error enumeration
- *
- * Since: 0.6
- *
- * Deprecated: 1.8
- */
-typedef enum {
-  CLUTTER_SHADER_ERROR_NO_ASM,
-  CLUTTER_SHADER_ERROR_NO_GLSL,
-  CLUTTER_SHADER_ERROR_COMPILE
-} ClutterShaderError;
-
-typedef struct _ClutterShaderPrivate ClutterShaderPrivate;
-typedef struct _ClutterShaderClass   ClutterShaderClass;
-
-/**
- * ClutterShader:
- *
- * The #ClutterShader structure contains only private data
- * and should be accessed using the provided API
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect instead
- */
-struct _ClutterShader
-{
-  /*< private >*/
-  GObject               parent;
-  ClutterShaderPrivate *priv;
-};
-
-/**
- * ClutterShaderClass:
- *
- * The #ClutterShaderClass structure contains only private data
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffectClass instead
- */
-struct _ClutterShaderClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-};
-
-CLUTTER_DEPRECATED
-GQuark clutter_shader_error_quark (void);
-
-CLUTTER_DEPRECATED
-GType clutter_shader_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-ClutterShader *       clutter_shader_new                      (void);
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-void                  clutter_shader_set_is_enabled           (ClutterShader      *shader,
-                                                               gboolean            enabled);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-gboolean              clutter_shader_get_is_enabled           (ClutterShader      *shader);
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-gboolean              clutter_shader_compile                  (ClutterShader      *shader,
-                                                               GError            **error);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-void                  clutter_shader_release                  (ClutterShader      *shader);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-gboolean              clutter_shader_is_compiled              (ClutterShader      *shader);
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-void                  clutter_shader_set_vertex_source        (ClutterShader      *shader,
-                                                               const gchar        *data,
-                                                               gssize              length);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-void                  clutter_shader_set_fragment_source      (ClutterShader      *shader,
-                                                               const gchar        *data,
-                                                               gssize              length);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-const gchar *         clutter_shader_get_vertex_source        (ClutterShader      *shader);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-const gchar *         clutter_shader_get_fragment_source      (ClutterShader      *shader);
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-void                  clutter_shader_set_uniform              (ClutterShader      *shader,
-                                                               const gchar        *name,
-                                                               const GValue       *value);
-
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-CoglHandle            clutter_shader_get_cogl_program         (ClutterShader      *shader);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-CoglHandle            clutter_shader_get_cogl_fragment_shader (ClutterShader      *shader);
-CLUTTER_DEPRECATED_FOR(ClutterShaderEffect)
-CoglHandle            clutter_shader_get_cogl_vertex_shader   (ClutterShader      *shader);
-
-/* ClutterActor methods */
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_add_effect)
-gboolean              clutter_actor_set_shader                (ClutterActor       *self,
-                                                               ClutterShader      *shader);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_effect)
-ClutterShader *       clutter_actor_get_shader                (ClutterActor       *self);
-
-CLUTTER_DEPRECATED_FOR(clutter_shader_effect_set_uniform_value)
-void                  clutter_actor_set_shader_param          (ClutterActor       *self,
-                                                               const gchar        *param,
-                                                               const GValue       *value);
-
-CLUTTER_DEPRECATED_FOR(clutter_shader_effect_set_uniform)
-void                  clutter_actor_set_shader_param_int      (ClutterActor       *self,
-                                                               const gchar        *param,
-                                                               gint                value);
-
-CLUTTER_DEPRECATED_FOR(clutter_shader_effect_set_uniform)
-void                  clutter_actor_set_shader_param_float    (ClutterActor       *self,
-                                                               const gchar        *param,
-                                                               gfloat              value);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_SHADER_H__ */

clutter/clutter/deprecated/clutter-state.h

@@ -1,187 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Øyvind Kolås <pippin@linux.intel.com>
- *
- * Copyright (C) 2009 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/>.
- */
-
-#ifndef __CLUTTER_STATE_H__
-#define __CLUTTER_STATE_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_STATE_KEY          (clutter_state_key_get_type ())
-#define CLUTTER_TYPE_STATE              (clutter_state_get_type ())
-#define CLUTTER_STATE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STATE, ClutterState))
-#define CLUTTER_STATE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STATE, ClutterStateClass))
-#define CLUTTER_IS_STATE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STATE))
-#define CLUTTER_IS_STATE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STATE))
-#define CLUTTER_STATE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STATE, ClutterStateClass))
-
-typedef struct _ClutterStatePrivate ClutterStatePrivate;
-typedef struct _ClutterStateClass   ClutterStateClass;
-
-/**
- * ClutterStateKey:
- *
- * #ClutterStateKey is an opaque structure whose
- * members cannot be accessed directly
- *
- * Since: 1.4
- */
-typedef struct _ClutterStateKey     ClutterStateKey;
-
-/**
- * ClutterState:
- *
- * The #ClutterState structure contains only
- * private data and should be accessed using the provided API
- *
- * Since: 1.4
- */
-struct _ClutterState
-{
-  /*< private >*/
-  GObject        parent;
-  ClutterStatePrivate *priv;
-};
-
-/**
- * ClutterStateClass:
- * @completed: class handler for the #ClutterState::completed signal
- *
- * The #ClutterStateClass structure contains
- * only private data
- *
- * Since: 1.4
- *
- * Deprecated: 1.12
- */
-struct _ClutterStateClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /*< public >*/
-  void (* completed) (ClutterState *state);
-
-  /*< private >*/
-  /* padding for future expansion */
-  gpointer _padding_dummy[8];
-};
-
-CLUTTER_DEPRECATED
-GType clutter_state_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterState    *clutter_state_new            (void);
-
-
-CLUTTER_DEPRECATED
-ClutterTimeline * clutter_state_set_state     (ClutterState    *state,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-ClutterTimeline * clutter_state_warp_to_state (ClutterState    *state,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-ClutterState *    clutter_state_set_key       (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               GObject         *object,
-                                               const gchar     *property_name,
-                                               guint            mode,
-                                               const GValue    *value,
-                                               gdouble          pre_delay,
-                                               gdouble          post_delay);
-CLUTTER_DEPRECATED
-void              clutter_state_set_duration  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               guint            duration);
-CLUTTER_DEPRECATED
-guint             clutter_state_get_duration  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-void              clutter_state_set           (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               gpointer         first_object,
-                                               const gchar     *first_property_name,
-                                               gulong           first_mode,
-                                                ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_DEPRECATED
-GList           * clutter_state_get_states    (ClutterState    *state);
-CLUTTER_DEPRECATED
-GList           * clutter_state_get_keys      (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               GObject         *object,
-                                               const gchar     *property_name);
-CLUTTER_DEPRECATED
-void              clutter_state_remove_key    (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               GObject         *object,
-                                               const gchar     *property_name);
-CLUTTER_DEPRECATED
-ClutterTimeline * clutter_state_get_timeline  (ClutterState    *state);
-CLUTTER_DEPRECATED
-void              clutter_state_set_animator  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name,
-                                               ClutterAnimator *animator);
-CLUTTER_DEPRECATED
-ClutterAnimator * clutter_state_get_animator  (ClutterState    *state,
-                                               const gchar     *source_state_name,
-                                               const gchar     *target_state_name);
-CLUTTER_DEPRECATED
-const gchar *     clutter_state_get_state     (ClutterState    *state);
-
-/*
- * ClutterStateKey
- */
-
-CLUTTER_DEPRECATED
-GType                 clutter_state_key_get_type              (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-gdouble               clutter_state_key_get_pre_delay         (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-gdouble               clutter_state_key_get_post_delay        (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-gulong                clutter_state_key_get_mode              (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-gboolean              clutter_state_key_get_value             (const ClutterStateKey *state_key,
-                                                               GValue                *value);
-CLUTTER_DEPRECATED
-GType                 clutter_state_key_get_property_type     (const ClutterStateKey *key);
-CLUTTER_DEPRECATED
-GObject *             clutter_state_key_get_object            (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-const gchar *         clutter_state_key_get_property_name     (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-const gchar *         clutter_state_key_get_source_state_name (const ClutterStateKey *state_key);
-CLUTTER_DEPRECATED
-const gchar *         clutter_state_key_get_target_state_name (const ClutterStateKey *state_key);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_STATE_H__ */

clutter/clutter/deprecated/clutter-table-layout.h

@@ -1,172 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 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:
- *   Jose Dapena Paz <jdapena@igalia.com>
- *
- * Based on the MX MxTable actor by:
- *   Thomas Wood <thomas.wood@intel.com>
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_TABLE_LAYOUT_H__
-#define __CLUTTER_TABLE_LAYOUT_H__
-
-#include <clutter/clutter-layout-manager.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_TABLE_LAYOUT                 (clutter_table_layout_get_type ())
-#define CLUTTER_TABLE_LAYOUT(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayout))
-#define CLUTTER_IS_TABLE_LAYOUT(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TABLE_LAYOUT))
-#define CLUTTER_TABLE_LAYOUT_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayoutClass))
-#define CLUTTER_IS_TABLE_LAYOUT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TABLE_LAYOUT))
-#define CLUTTER_TABLE_LAYOUT_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayoutClass))
-
-typedef struct _ClutterTableLayout                ClutterTableLayout;
-typedef struct _ClutterTableLayoutPrivate         ClutterTableLayoutPrivate;
-typedef struct _ClutterTableLayoutClass           ClutterTableLayoutClass;
-
-/**
- * ClutterTableLayout:
- *
- * The #ClutterTableLayout structure contains only private data
- * and should be accessed using the provided API
- *
- * Since: 1.4
- *
- * Deprecated: 1.18: Use #ClutterGridLayout instead
- */
-struct _ClutterTableLayout
-{
-  /*< private >*/
-  ClutterLayoutManager parent_instance;
-
-  ClutterTableLayoutPrivate *priv;
-};
-
-/**
- * ClutterTableLayoutClass:
- *
- * The #ClutterTableLayoutClass structure contains only private
- * data and should be accessed using the provided API
- *
- * Since: 1.4
- *
- * Deprecated: 1.18: Use #ClutterGridLayout instead
- */
-struct _ClutterTableLayoutClass
-{
-  /*< private >*/
-  ClutterLayoutManagerClass parent_class;
-};
-
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_get_type)
-GType clutter_table_layout_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_new)
-ClutterLayoutManager *clutter_table_layout_new                 (void);
-
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_attach)
-void                  clutter_table_layout_pack                (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gint                   column,
-                                                                gint                   row);
-
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_set_column_spacing)
-void                  clutter_table_layout_set_column_spacing  (ClutterTableLayout    *layout,
-                                                                guint                  spacing);
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_set_row_spacing)
-void                  clutter_table_layout_set_row_spacing     (ClutterTableLayout    *layout,
-                                                                guint                  spacing);
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_get_column_spacing)
-guint                 clutter_table_layout_get_column_spacing  (ClutterTableLayout    *layout);
-CLUTTER_DEPRECATED_FOR (clutter_grid_layout_get_row_spacing)
-guint                 clutter_table_layout_get_row_spacing     (ClutterTableLayout    *layout);
-
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_span            (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gint                   column_span,
-                                                                gint                   row_span);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_get_span            (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gint                  *column_span,
-                                                                gint                  *row_span);
-
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_alignment       (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                ClutterTableAlignment  x_align,
-                                                                ClutterTableAlignment  y_align);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_get_alignment       (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                ClutterTableAlignment *x_align,
-                                                                ClutterTableAlignment *y_align);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_fill            (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gboolean               x_fill,
-                                                                gboolean               y_fill);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_get_fill            (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gboolean              *x_fill,
-                                                                gboolean              *y_fill);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_expand          (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gboolean               x_expand,
-                                                                gboolean               y_expand);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_get_expand          (ClutterTableLayout    *layout,
-                                                                ClutterActor          *actor,
-                                                                gboolean              *x_expand,
-                                                                gboolean              *y_expand);
-
-CLUTTER_DEPRECATED
-gint                  clutter_table_layout_get_row_count       (ClutterTableLayout    *layout);
-CLUTTER_DEPRECATED
-gint                  clutter_table_layout_get_column_count    (ClutterTableLayout    *layout);
-
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_use_animations  (ClutterTableLayout    *layout,
-                                                                gboolean               animate);
-CLUTTER_DEPRECATED
-gboolean              clutter_table_layout_get_use_animations  (ClutterTableLayout    *layout);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_easing_mode     (ClutterTableLayout    *layout,
-                                                                gulong                 mode);
-CLUTTER_DEPRECATED
-gulong                clutter_table_layout_get_easing_mode     (ClutterTableLayout    *layout);
-CLUTTER_DEPRECATED
-void                  clutter_table_layout_set_easing_duration (ClutterTableLayout    *layout,
-                                                                guint                  msecs);
-CLUTTER_DEPRECATED
-guint                 clutter_table_layout_get_easing_duration (ClutterTableLayout    *layout);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_TABLE_LAYOUT_H__ */

clutter/clutter/deprecated/clutter-texture.c

@@ -45,9 +45,6 @@
 
 #include "clutter-build-config.h"
 
-/* sadly, we are still using ClutterShader internally */
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-
 #include <cogl/cogl.h>
 
 #include "clutter-texture.h"
@@ -64,7 +61,6 @@
 #include "clutter-stage-private.h"
 #include "clutter-backend.h"
 
-#include "deprecated/clutter-shader.h"
 #include "deprecated/clutter-texture.h"
 #include "deprecated/clutter-util.h"
 
@@ -480,22 +476,10 @@ update_fbo (ClutterActor *self)
 {
   ClutterTexture        *texture = CLUTTER_TEXTURE (self);
   ClutterTexturePrivate *priv = texture->priv;
-  ClutterActor          *head;
-  ClutterShader         *shader = NULL;
   ClutterActor          *stage = NULL;
   CoglMatrix             projection;
   CoglColor              transparent_col;
 
-  head = _clutter_context_peek_shader_stack ();
-  if (head != NULL)
-    shader = clutter_actor_get_shader (head);
-
-  /* Temporarily turn off the shader on the top of the context's
-   * shader stack, to restore the GL pipeline to it's natural state.
-   */
-  if (shader != NULL)
-    clutter_shader_set_is_enabled (shader, FALSE);
-
   /* Redirect drawing to the fbo */
   cogl_push_framebuffer (priv->fbo_handle);
 
@@ -554,16 +538,10 @@ update_fbo (ClutterActor *self)
 
   /* Restore drawing to the previous framebuffer */
   cogl_pop_framebuffer ();
-
-  /* If there is a shader on top of the shader stack, turn it back on. */
-  if (shader != NULL)
-    clutter_shader_set_is_enabled (shader, TRUE);
 }
 
 static void
-gen_texcoords_and_draw_cogl_rectangle (ClutterActor    *self,
-                                       CoglPipeline    *pipeline,
-                                       CoglFramebuffer *framebuffer)
+gen_texcoords_and_draw_cogl_rectangle (ClutterActor *self)
 {
   ClutterTexture *texture = CLUTTER_TEXTURE (self);
   ClutterTexturePrivate *priv = texture->priv;
@@ -582,12 +560,10 @@ gen_texcoords_and_draw_cogl_rectangle (ClutterActor    *self,
   else
     t_h = 1.0;
 
-  cogl_framebuffer_draw_textured_rectangle (framebuffer,
-                                            pipeline,
-                                            0, 0,
-                                            box.x2 - box.x1,
-                                            box.y2 - box.y1,
-                                            0, 0, t_w, t_h);
+  cogl_rectangle_with_texture_coords (0, 0,
+			              box.x2 - box.x1,
+                                      box.y2 - box.y1,
+			              0, 0, t_w, t_h);
 }
 
 static CoglPipeline *
@@ -629,7 +605,6 @@ clutter_texture_pick (ClutterActor       *self,
 {
   ClutterTexture *texture = CLUTTER_TEXTURE (self);
   ClutterTexturePrivate *priv = texture->priv;
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
 
   if (!clutter_actor_should_pick_paint (self))
     return;
@@ -661,7 +636,8 @@ clutter_texture_pick (ClutterActor       *self,
                                                 0, &pick_color);
       cogl_pipeline_set_layer_texture (priv->pick_pipeline, 0,
                                        clutter_texture_get_cogl_texture (texture));
-      gen_texcoords_and_draw_cogl_rectangle (self, priv->pick_pipeline, framebuffer);
+      cogl_set_source (priv->pick_pipeline);
+      gen_texcoords_and_draw_cogl_rectangle (self);
     }
   else
     CLUTTER_ACTOR_CLASS (clutter_texture_parent_class)->pick (self, color);
@@ -673,7 +649,6 @@ clutter_texture_paint (ClutterActor *self)
   ClutterTexture *texture = CLUTTER_TEXTURE (self);
   ClutterTexturePrivate *priv = texture->priv;
   guint8 paint_opacity = clutter_actor_get_paint_opacity (self);
-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
 
   CLUTTER_NOTE (PAINT,
                 "painting texture '%s'",
@@ -688,8 +663,9 @@ clutter_texture_paint (ClutterActor *self)
                               paint_opacity,
                               paint_opacity,
                               paint_opacity);
+  cogl_set_source (priv->pipeline);
 
-  gen_texcoords_and_draw_cogl_rectangle (self, priv->pipeline, framebuffer);
+  gen_texcoords_and_draw_cogl_rectangle (self);
 }
 
 static gboolean

clutter/clutter/deprecated/clutter-timeout-interval.c

@@ -1,140 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Neil Roberts  <neil@linux.intel.com>
- *
- * Copyright (C) 2009  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/>.
- */
-
-#include "clutter-build-config.h"
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-
-/* This file contains the common code to check whether an interval has
-   expired used in clutter-frame-source and clutter-timeout-pool. */
-
-#include "clutter-timeout-interval.h"
-
-void
-_clutter_timeout_interval_init (ClutterTimeoutInterval *interval,
-                                guint                   fps)
-{
-#if GLIB_CHECK_VERSION (2, 27, 3)
-  interval->start_time = g_get_monotonic_time () / 1000;
-#else
-  {
-    GTimeVal start_time;
-    g_get_current_time (&start_time);
-    interval->start_time = start_time.tv_sec * 1000
-                         + start_time.tv_usec / 1000;
-  }
-#endif
-
-  interval->fps = fps;
-  interval->frame_count = 0;
-}
-
-static gint64
-_clutter_timeout_interval_get_ticks (gint64                  current_time,
-                                     ClutterTimeoutInterval *interval)
-{
-  return MAX (current_time - interval->start_time, 0);
-}
-
-gboolean
-_clutter_timeout_interval_prepare (gint64                  current_time,
-                                   ClutterTimeoutInterval *interval,
-                                   gint                   *delay)
-{
-  gint elapsed_time, new_frame_num;
-
-  elapsed_time = _clutter_timeout_interval_get_ticks (current_time, interval);
-  new_frame_num = elapsed_time * interval->fps / 1000;
-
-  /* If time has gone backwards or the time since the last frame is
-     greater than the two frames worth then reset the time and do a
-     frame now */
-  if (new_frame_num < interval->frame_count ||
-      new_frame_num - interval->frame_count > 2)
-    {
-      /* Get the frame time rounded up to the nearest ms */
-      guint frame_time = (1000 + interval->fps - 1) / interval->fps;
-
-      /* Reset the start time */
-      interval->start_time = current_time;
-
-      /* Move the start time as if one whole frame has elapsed */
-      interval->start_time -= frame_time;
-
-      interval->frame_count = 0;
-
-      if (delay)
-	*delay = 0;
-
-      return TRUE;
-    }
-  else if (new_frame_num > interval->frame_count)
-    {
-      if (delay)
-	*delay = 0;
-
-      return TRUE;
-    }
-  else
-    {
-      if (delay)
-	*delay = ((interval->frame_count + 1) * 1000 / interval->fps
-               - elapsed_time);
-
-      return FALSE;
-    }
-}
-
-gboolean
-_clutter_timeout_interval_dispatch (ClutterTimeoutInterval *interval,
-                                    GSourceFunc             callback,
-                                    gpointer                user_data)
-{
-  if ((* callback) (user_data))
-    {
-      interval->frame_count++;
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-gint
-_clutter_timeout_interval_compare_expiration (const ClutterTimeoutInterval *a,
-                                              const ClutterTimeoutInterval *b)
-{
-  guint a_delay = 1000 / a->fps;
-  guint b_delay = 1000 / b->fps;
-  gint64 b_difference;
-  gint comparison;
-
-  b_difference = a->start_time - b->start_time;
-
-  comparison = ((gint) ((a->frame_count + 1) * a_delay)
-             - (gint) ((b->frame_count + 1) * b_delay + b_difference));
-
-  return (comparison < 0 ? -1
-                         : comparison > 0 ? 1
-                                          : 0);
-}

clutter/clutter/deprecated/clutter-timeout-interval.h

@@ -1,58 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Neil Roberts  <neil@linux.intel.com>
- *
- * Copyright (C) 2009  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/>.
- */
-
-#ifndef __CLUTTER_TIMEOUT_INTERVAL_H__
-#define __CLUTTER_TIMEOUT_INTERVAL_H__
-
-#include <glib.h>
-
-G_BEGIN_DECLS
-
-typedef struct _ClutterTimeoutInterval ClutterTimeoutInterval;
-
-struct _ClutterTimeoutInterval
-{
-  /* milliseconds */
-  gint64 start_time;
-
-  guint frame_count;
-  guint fps;
-};
-
-void     _clutter_timeout_interval_init               (ClutterTimeoutInterval       *interval,
-                                                       guint                         fps);
-
-gboolean _clutter_timeout_interval_prepare            (gint64 current_time,
-                                                       ClutterTimeoutInterval       *interval,
-                                                       gint                         *delay);
-
-gboolean _clutter_timeout_interval_dispatch           (ClutterTimeoutInterval       *interval,
-                                                       GSourceFunc                   callback,
-                                                       gpointer                      user_data);
-
-gint     _clutter_timeout_interval_compare_expiration (const ClutterTimeoutInterval *a,
-                                                       const ClutterTimeoutInterval *b);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_TIMEOUT_INTERVAL_H__ */

clutter/clutter/deprecated/clutter-timeout-pool.c

@@ -1,498 +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/>.
- *
- *
- *
- * ClutterTimeoutPool: pool of timeout functions using the same slice of
- *                     the GLib main loop
- *
- * Author: Emmanuele Bassi <ebassi@openedhand.com>
- *
- * Based on similar code by Tristan van Berkom
- */
-
-#include "clutter-build-config.h"
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "deprecated/clutter-main.h"
-
-#include "clutter-timeout-pool.h"
-
-#include "clutter-debug.h"
-#include "clutter-timeout-interval.h"
-
-typedef struct _ClutterTimeout  ClutterTimeout;
-typedef enum {
-  CLUTTER_TIMEOUT_NONE   = 0,
-  CLUTTER_TIMEOUT_READY  = 1 << 1
-} ClutterTimeoutFlags;
-
-struct _ClutterTimeout
-{
-  guint id;
-  ClutterTimeoutFlags flags;
-  gint refcount;
-
-  ClutterTimeoutInterval interval;
-
-  GSourceFunc func;
-  gpointer data;
-  GDestroyNotify notify;
-};
-
-struct _ClutterTimeoutPool
-{
-  GSource source;
-
-  guint next_id;
-
-  GList *timeouts;
-  GList *dispatched_timeouts;
-
-  gint ready;
-
-  guint id;
-};
-
-#define TIMEOUT_READY(timeout)   (timeout->flags & CLUTTER_TIMEOUT_READY)
-
-static gboolean clutter_timeout_pool_prepare  (GSource     *source,
-                                               gint        *next_timeout);
-static gboolean clutter_timeout_pool_check    (GSource     *source);
-static gboolean clutter_timeout_pool_dispatch (GSource     *source,
-                                               GSourceFunc  callback,
-                                               gpointer     data);
-static void clutter_timeout_pool_finalize     (GSource     *source);
-
-static GSourceFuncs clutter_timeout_pool_funcs =
-{
-  clutter_timeout_pool_prepare,
-  clutter_timeout_pool_check,
-  clutter_timeout_pool_dispatch,
-  clutter_timeout_pool_finalize
-};
-
-static gint
-clutter_timeout_sort (gconstpointer a,
-                      gconstpointer b)
-{
-  const ClutterTimeout *t_a = a;
-  const ClutterTimeout *t_b = b;
-
-  /* Keep 'ready' timeouts at the front */
-  if (TIMEOUT_READY (t_a))
-    return -1;
-
-  if (TIMEOUT_READY (t_b))
-    return 1;
-
-  return _clutter_timeout_interval_compare_expiration (&t_a->interval,
-                                                       &t_b->interval);
-}
-
-static gint
-clutter_timeout_find_by_id (gconstpointer a,
-                            gconstpointer b)
-{
-  const ClutterTimeout *t_a = a;
-
-  return t_a->id == GPOINTER_TO_UINT (b) ? 0 : 1;
-}
-
-static ClutterTimeout *
-clutter_timeout_new (guint fps)
-{
-  ClutterTimeout *timeout;
-
-  timeout = g_slice_new0 (ClutterTimeout);
-  _clutter_timeout_interval_init (&timeout->interval, fps);
-  timeout->flags = CLUTTER_TIMEOUT_NONE;
-  timeout->refcount = 1;
-
-  return timeout;
-}
-
-static gboolean
-clutter_timeout_prepare (ClutterTimeoutPool *pool,
-                         ClutterTimeout     *timeout,
-                         gint               *next_timeout)
-{
-  GSource *source = (GSource *) pool;
-  gint64 now;
-
-#if GLIB_CHECK_VERSION (2, 27, 3)
-  now = g_source_get_time (source) / 1000;
-#else
-  {
-    GTimeVal source_time;
-    g_source_get_current_time (source, &source_time);
-    now = source_time.tv_sec * 1000 + source_time.tv_usec / 1000;
-  }
-#endif
-
-  return _clutter_timeout_interval_prepare (now,
-                                            &timeout->interval,
-                                            next_timeout);
-}
-
-/* ref and unref are always called under the main Clutter lock, so there
- * is not need for us to use g_atomic_int_* API.
- */
-
-static ClutterTimeout *
-clutter_timeout_ref (ClutterTimeout *timeout)
-{
-  g_return_val_if_fail (timeout != NULL, timeout);
-  g_return_val_if_fail (timeout->refcount > 0, timeout);
-
-  timeout->refcount += 1;
-
-  return timeout;
-}
-
-static void
-clutter_timeout_unref (ClutterTimeout *timeout)
-{
-  g_return_if_fail (timeout != NULL);
-  g_return_if_fail (timeout->refcount > 0);
-
-  timeout->refcount -= 1;
-
-  if (timeout->refcount == 0)
-    {
-      if (timeout->notify)
-        timeout->notify (timeout->data);
-
-      g_slice_free (ClutterTimeout, timeout);
-    }
-}
-
-static void
-clutter_timeout_free (ClutterTimeout *timeout)
-{
-  if (G_LIKELY (timeout))
-    {
-      if (timeout->notify)
-        timeout->notify (timeout->data);
-
-      g_slice_free (ClutterTimeout, timeout);
-    }
-}
-
-static gboolean
-clutter_timeout_pool_prepare (GSource *source,
-                              gint    *next_timeout)
-{
-  ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
-  GList *l = pool->timeouts;
-
-  /* the pool is ready if the first timeout is ready */
-  if (l && l->data)
-    {
-      ClutterTimeout *timeout = l->data;
-      return clutter_timeout_prepare (pool, timeout, next_timeout);
-    }
-  else
-    {
-      *next_timeout = -1;
-      return FALSE;
-    }
-}
-
-static gboolean
-clutter_timeout_pool_check (GSource *source)
-{
-  ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
-  GList *l;
-
-  clutter_threads_enter ();
-
-  for (l = pool->timeouts; l; l = l->next)
-    {
-      ClutterTimeout *timeout = l->data;
-
-      /* since the timeouts are sorted by expiration, as soon
-       * as we get a check returning FALSE we know that the
-       * following timeouts are not expiring, so we break as
-       * soon as possible
-       */
-      if (clutter_timeout_prepare (pool, timeout, NULL))
-        {
-          timeout->flags |= CLUTTER_TIMEOUT_READY;
-          pool->ready += 1;
-        }
-      else
-        break;
-    }
-
-  clutter_threads_leave ();
-
-  return (pool->ready > 0);
-}
-
-static gboolean
-clutter_timeout_pool_dispatch (GSource     *source,
-                               GSourceFunc  func,
-                               gpointer     data)
-{
-  ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
-  GList *dispatched_timeouts;
-
-  /* the main loop might have predicted this, so we repeat the
-   * check for ready timeouts.
-   */
-  if (!pool->ready)
-    clutter_timeout_pool_check (source);
-
-  clutter_threads_enter ();
-
-  /* Iterate by moving the actual start of the list along so that it
-   * can cope with adds and removes while a timeout is being dispatched
-   */
-  while (pool->timeouts && pool->timeouts->data && pool->ready-- > 0)
-    {
-      ClutterTimeout *timeout = pool->timeouts->data;
-      GList *l;
-
-      /* One of the ready timeouts may have been removed during dispatch,
-       * in which case pool->ready will be wrong, but the ready timeouts
-       * are always kept at the start of the list so we can stop once
-       * we've reached the first non-ready timeout
-       */
-      if (!(TIMEOUT_READY (timeout)))
-	break;
-
-      /* Add a reference to the timeout so it can't disappear
-       * while it's being dispatched
-       */
-      clutter_timeout_ref (timeout);
-
-      timeout->flags &= ~CLUTTER_TIMEOUT_READY;
-
-      /* Move the list node to a list of dispatched timeouts */
-      l = pool->timeouts;
-      if (l->next)
-	l->next->prev = NULL;
-
-      pool->timeouts = l->next;
-
-      if (pool->dispatched_timeouts)
-	pool->dispatched_timeouts->prev = l;
-
-      l->prev = NULL;
-      l->next = pool->dispatched_timeouts;
-      pool->dispatched_timeouts = l;
-
-      if (!_clutter_timeout_interval_dispatch (&timeout->interval,
-                                               timeout->func, timeout->data))
-	{
-	  /* The timeout may have already been removed, but nothing
-           * can be added to the dispatched_timeout list except in this
-           * function so it will always either be at the head of the
-           * dispatched list or have been removed
-           */
-          if (pool->dispatched_timeouts &&
-              pool->dispatched_timeouts->data == timeout)
-	    {
-	      pool->dispatched_timeouts =
-                g_list_delete_link (pool->dispatched_timeouts,
-                                    pool->dispatched_timeouts);
-
-	      /* Remove the reference that was held by it being in the list */
-	      clutter_timeout_unref (timeout);
-	    }
-	}
-
-      clutter_timeout_unref (timeout);
-    }
-
-  /* Re-insert the dispatched timeouts in sorted order */
-  dispatched_timeouts = pool->dispatched_timeouts;
-  while (dispatched_timeouts)
-    {
-      ClutterTimeout *timeout = dispatched_timeouts->data;
-      GList *next = dispatched_timeouts->next;
-
-      if (timeout)
-        pool->timeouts = g_list_insert_sorted (pool->timeouts, timeout,
-                                               clutter_timeout_sort);
-
-      dispatched_timeouts = next;
-    }
-
-  g_list_free (pool->dispatched_timeouts);
-  pool->dispatched_timeouts = NULL;
-
-  pool->ready = 0;
-
-  clutter_threads_leave ();
-
-  return TRUE;
-}
-
-static void
-clutter_timeout_pool_finalize (GSource *source)
-{
-  ClutterTimeoutPool *pool = (ClutterTimeoutPool *) source;
-
-  /* force destruction */
-  g_list_foreach (pool->timeouts, (GFunc) clutter_timeout_free, NULL);
-  g_list_free (pool->timeouts);
-}
-
-/**
- * clutter_timeout_pool_new:
- * @priority: the priority of the timeout pool. Typically this will
- *   be #G_PRIORITY_DEFAULT
- *
- * Creates a new timeout pool source. A timeout pool should be used when
- * multiple timeout functions, running at the same priority, are needed and
- * the g_timeout_add() API might lead to starvation of the time slice of
- * the main loop. A timeout pool allocates a single time slice of the main
- * loop and runs every timeout function inside it. The timeout pool is
- * always sorted, so that the extraction of the next timeout function is
- * a constant time operation.
- *
- * Return value: the newly created #ClutterTimeoutPool. The created pool
- *   is owned by the GLib default context and will be automatically
- *   destroyed when the context is destroyed. It is possible to force
- *   the destruction of the timeout pool using g_source_destroy()
- *
- * Since: 0.4
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-ClutterTimeoutPool *
-clutter_timeout_pool_new (gint priority)
-{
-  ClutterTimeoutPool *pool;
-  GSource *source;
-
-  source = g_source_new (&clutter_timeout_pool_funcs,
-                         sizeof (ClutterTimeoutPool));
-  if (!source)
-    return NULL;
-
-  g_source_set_name (source, "Clutter timeout pool");
-
-  if (priority != G_PRIORITY_DEFAULT)
-    g_source_set_priority (source, priority);
-
-  pool = (ClutterTimeoutPool *) source;
-  pool->next_id = 1;
-  pool->id = g_source_attach (source, NULL);
-
-  /* let the default GLib context manage the pool */
-  g_source_unref (source);
-
-  return pool;
-}
-
-/**
- * clutter_timeout_pool_add:
- * @pool: a #ClutterTimeoutPool
- * @fps: the time between calls to the function, in frames per second
- * @func: function to call
- * @data: (closure): data to pass to the function, or %NULL
- * @notify: function to call when the timeout is removed, or %NULL
- *
- * Sets a function to be called at regular intervals, and puts it inside
- * the @pool. The function is repeatedly called until it returns %FALSE,
- * at which point the timeout is automatically destroyed and the function
- * won't be called again. If @notify is not %NULL, the @notify function
- * will be called. The first call to @func will be at the end of @interval.
- *
- * Since Clutter 0.8 this will try to compensate for delays. For
- * example, if @func takes half the interval time to execute then the
- * function will be called again half the interval time after it
- * finished. Before version 0.8 it would not fire until a full
- * interval after the function completes so the delay between calls
- * would be @interval * 1.5. This function does not however try to
- * invoke the function multiple times to catch up missing frames if
- * @func takes more than @interval ms to execute.
- *
- * Return value: the ID (greater than 0) of the timeout inside the pool.
- *   Use clutter_timeout_pool_remove() to stop the timeout.
- *
- * Since: 0.4
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-guint
-clutter_timeout_pool_add (ClutterTimeoutPool *pool,
-                          guint               fps,
-                          GSourceFunc         func,
-                          gpointer            data,
-                          GDestroyNotify      notify)
-{
-  ClutterTimeout *timeout;
-  guint retval = 0;
-
-  timeout = clutter_timeout_new (fps);
-
-  retval = timeout->id = pool->next_id++;
-
-  timeout->func = func;
-  timeout->data = data;
-  timeout->notify = notify;
-
-  pool->timeouts = g_list_insert_sorted (pool->timeouts, timeout,
-                                         clutter_timeout_sort);
-
-  return retval;
-}
-
-/**
- * clutter_timeout_pool_remove:
- * @pool: a #ClutterTimeoutPool
- * @id_: the id of the timeout to remove
- *
- * Removes a timeout function with @id_ from the timeout pool. The id
- * is the same returned when adding a function to the timeout pool with
- * clutter_timeout_pool_add().
- *
- * Since: 0.4
- *
- * Deprecated: 1.6: There is no direct replacement for this API
- */
-void
-clutter_timeout_pool_remove (ClutterTimeoutPool *pool,
-                             guint               id_)
-{
-  GList *l;
-
-  if ((l = g_list_find_custom (pool->timeouts, GUINT_TO_POINTER (id_),
-			       clutter_timeout_find_by_id)))
-    {
-      clutter_timeout_unref (l->data);
-      pool->timeouts = g_list_delete_link (pool->timeouts, l);
-    }
-  else if ((l = g_list_find_custom (pool->dispatched_timeouts,
-				    GUINT_TO_POINTER (id_),
-				    clutter_timeout_find_by_id)))
-    {
-      clutter_timeout_unref (l->data);
-
-      pool->dispatched_timeouts =
-        g_list_delete_link (pool->dispatched_timeouts, l);
-    }
-}

clutter/clutter/deprecated/clutter-timeout-pool.h

@@ -1,69 +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/>.
- *
- * ClutterTimeoutPool: pool of timeout functions using the same slice of
- *                     the GLib main loop
- *
- * Author: Emmanuele Bassi <ebassi@openedhand.com>
- *
- * Based on similar code by Tristan van Berkom
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_TIMEOUT_POOL_H__
-#define __CLUTTER_TIMEOUT_POOL_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-/**
- * ClutterTimeoutPool: (skip)
- *
- * #ClutterTimeoutPool is an opaque structure
- * whose members cannot be directly accessed.
- *
- * Since: 0.6
- *
- * Deprecated: 1.6
- */
-typedef struct _ClutterTimeoutPool    ClutterTimeoutPool;
-
-CLUTTER_DEPRECATED
-ClutterTimeoutPool *clutter_timeout_pool_new    (gint                priority);
-
-CLUTTER_DEPRECATED
-guint               clutter_timeout_pool_add    (ClutterTimeoutPool *pool,
-                                                 guint               fps,
-                                                 GSourceFunc         func,
-                                                 gpointer            data,
-                                                 GDestroyNotify      notify);
-CLUTTER_DEPRECATED
-void                clutter_timeout_pool_remove (ClutterTimeoutPool *pool,
-                                                 guint               id_);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_TIMEOUT_POOL_H__ */

clutter/clutter/egl/clutter-backend-eglnative.h

@@ -27,6 +27,7 @@
 #define __CLUTTER_BACKEND_EGL_NATIVE_H__
 
 #include <glib-object.h>
+#include <gio/gio.h>
 #include <cogl/cogl.h>
 #include <cogl/cogl-egl.h>
 #include <clutter/clutter-event.h>

clutter/clutter/evdev/clutter-device-manager-evdev.c

@@ -322,6 +322,7 @@ new_absolute_motion_event (ClutterInputDevice *input_device,
   _clutter_evdev_event_set_time_usec (event, time_us);
   event->motion.time = us2ms (time_us);
   event->motion.stage = stage;
+  event->motion.device = seat->core_pointer;
   _clutter_xkb_translate_state (event, seat->xkb, seat->button_state);
   event->motion.x = x;
   event->motion.y = y;
@@ -329,7 +330,6 @@ new_absolute_motion_event (ClutterInputDevice *input_device,
                                                     &event->motion.x,
                                                     &event->motion.y);
   event->motion.axes = axes;
-  clutter_event_set_device (event, seat->core_pointer);
   clutter_event_set_source_device (event, input_device);
 
   if (clutter_input_device_get_device_type (input_device) == CLUTTER_TABLET_DEVICE)
@@ -517,6 +517,7 @@ notify_proximity (ClutterInputDevice *input_device,
 
   event->proximity.time = us2ms (time_us);
   event->proximity.stage = CLUTTER_STAGE (stage);
+  event->proximity.device = seat->core_pointer;
   clutter_event_set_device_tool (event, device_evdev->last_tool);
   clutter_event_set_device (event, seat->core_pointer);
   clutter_event_set_source_device (event, input_device);

clutter/clutter/evdev/clutter-input-device-evdev.c

@@ -1265,18 +1265,6 @@ clutter_input_device_evdev_release_touch_state (ClutterInputDeviceEvdev *device,
                        GINT_TO_POINTER (touch_state->device_slot));
 }
 
-static gboolean
-clutter_input_device_evdev_get_physical_size (ClutterInputDevice *device,
-                                              gdouble            *width,
-                                              gdouble            *height)
-{
-  struct libinput_device *libinput_device;
-
-  libinput_device = clutter_evdev_input_device_get_libinput_device (device);
-
-  return libinput_device_get_size (libinput_device, width, height) == 0;
-}
-
 static void
 clutter_input_device_evdev_class_init (ClutterInputDeviceEvdevClass *klass)
 {
@@ -1292,7 +1280,6 @@ clutter_input_device_evdev_class_init (ClutterInputDeviceEvdevClass *klass)
   klass->get_group_n_modes = clutter_input_device_evdev_get_group_n_modes;
   klass->is_grouped = clutter_input_device_evdev_is_grouped;
   klass->process_kbd_a11y_event = clutter_input_device_evdev_process_kbd_a11y_event;
-  klass->get_physical_size = clutter_input_device_evdev_get_physical_size;
 
   obj_props[PROP_DEVICE_MATRIX] =
     g_param_spec_boxed ("device-matrix",

clutter/clutter/evdev/clutter-seat-evdev.c

@@ -385,6 +385,7 @@ new_absolute_motion_event (ClutterSeatEvdev   *seat,
   _clutter_evdev_event_set_time_usec (event, time_us);
   event->motion.time = us2ms (time_us);
   event->motion.stage = stage;
+  event->motion.device = seat->core_pointer;
   _clutter_xkb_translate_state (event, seat->xkb, seat->button_state);
   event->motion.x = x;
   event->motion.y = y;
@@ -630,6 +631,7 @@ notify_scroll (ClutterInputDevice       *input_device,
   _clutter_evdev_event_set_time_usec (event, time_us);
   event->scroll.time = us2ms (time_us);
   event->scroll.stage = CLUTTER_STAGE (stage);
+  event->scroll.device = seat->core_pointer;
   _clutter_xkb_translate_state (event, seat->xkb, seat->button_state);
 
   /* libinput pointer axis events are in pointer motion coordinate space.
@@ -682,6 +684,7 @@ notify_discrete_scroll (ClutterInputDevice     *input_device,
   _clutter_evdev_event_set_time_usec (event, time_us);
   event->scroll.time = us2ms (time_us);
   event->scroll.stage = CLUTTER_STAGE (stage);
+  event->scroll.device = seat->core_pointer;
   _clutter_xkb_translate_state (event, seat->xkb, seat->button_state);
 
   event->scroll.direction = direction;
@@ -810,6 +813,7 @@ clutter_seat_evdev_notify_touch_event (ClutterSeatEvdev   *seat,
   _clutter_evdev_event_set_time_usec (event, time_us);
   event->touch.time = us2ms (time_us);
   event->touch.stage = CLUTTER_STAGE (stage);
+  event->touch.device = seat->core_pointer;
   event->touch.x = x;
   event->touch.y = y;
   clutter_input_device_evdev_translate_coordinates (input_device, stage,

clutter/clutter/evdev/clutter-xkb-utils.c

@@ -76,12 +76,12 @@ _clutter_key_event_new_from_evdev (ClutterInputDevice *device,
   else
     sym = XKB_KEY_NoSymbol;
 
+  event->key.device = core_device;
   event->key.stage = stage;
   event->key.time = _time;
   _clutter_xkb_translate_state (event, xkb_state, button_state);
   event->key.hardware_keycode = key;
   event->key.keyval = sym;
-  clutter_event_set_device (event, core_device);
   clutter_event_set_source_device (event, device);
 
   n = xkb_keysym_to_utf8 (sym, buffer, sizeof (buffer));

clutter/clutter/meson.build

@@ -40,7 +40,6 @@ clutter_headers = [
   'clutter-flow-layout.h',
   'clutter-gesture-action.h',
   'clutter-grid-layout.h',
-  'clutter-group.h',
   'clutter-image.h',
   'clutter-input-device.h',
   'clutter-input-device-tool.h',
@@ -218,7 +217,6 @@ clutter_deprecated_headers = [
   'deprecated/clutter-alpha.h',
   'deprecated/clutter-animatable.h',
   'deprecated/clutter-animation.h',
-  'deprecated/clutter-animator.h',
   'deprecated/clutter-backend.h',
   'deprecated/clutter-behaviour.h',
   'deprecated/clutter-behaviour-depth.h',
@@ -228,26 +226,16 @@ clutter_deprecated_headers = [
   'deprecated/clutter-behaviour-rotate.h',
   'deprecated/clutter-behaviour-scale.h',
   'deprecated/clutter-bin-layout.h',
-  'deprecated/clutter-box.h',
   'deprecated/clutter-cairo-texture.h',
   'deprecated/clutter-container.h',
-  'deprecated/clutter-frame-source.h',
-  'deprecated/clutter-group.h',
   'deprecated/clutter-input-device.h',
   'deprecated/clutter-keysyms.h',
-  'deprecated/clutter-list-model.h',
   'deprecated/clutter-main.h',
-  'deprecated/clutter-model.h',
   'deprecated/clutter-rectangle.h',
-  'deprecated/clutter-score.h',
-  'deprecated/clutter-shader.h',
   'deprecated/clutter-stage-manager.h',
   'deprecated/clutter-stage.h',
-  'deprecated/clutter-state.h',
-  'deprecated/clutter-table-layout.h',
   'deprecated/clutter-texture.h',
   'deprecated/clutter-timeline.h',
-  'deprecated/clutter-timeout-pool.h',
   'deprecated/clutter-util.h',
 ]
 
@@ -255,7 +243,6 @@ clutter_deprecated_sources = [
   'deprecated/clutter-actor-deprecated.c',
   'deprecated/clutter-alpha.c',
   'deprecated/clutter-animation.c',
-  'deprecated/clutter-animator.c',
   'deprecated/clutter-behaviour.c',
   'deprecated/clutter-behaviour-depth.c',
   'deprecated/clutter-behaviour-ellipse.c',
@@ -263,30 +250,11 @@ clutter_deprecated_sources = [
   'deprecated/clutter-behaviour-path.c',
   'deprecated/clutter-behaviour-rotate.c',
   'deprecated/clutter-behaviour-scale.c',
-  'deprecated/clutter-box.c',
   'deprecated/clutter-cairo-texture.c',
-  'deprecated/clutter-frame-source.c',
-  'deprecated/clutter-group.c',
   'deprecated/clutter-input-device-deprecated.c',
   'deprecated/clutter-layout-manager-deprecated.c',
-  'deprecated/clutter-list-model.c',
-  'deprecated/clutter-model.c',
   'deprecated/clutter-rectangle.c',
-  'deprecated/clutter-score.c',
-  'deprecated/clutter-shader.c',
-  'deprecated/clutter-state.c',
-  'deprecated/clutter-table-layout.c',
   'deprecated/clutter-texture.c',
-  'deprecated/clutter-timeout-pool.c',
-]
-
-clutter_deprecated_private_headers = [
-  'deprecated/clutter-model-private.h',
-  'deprecated/clutter-timeout-interval.h',
-]
-
-clutter_deprecated_nonintrospected_sources = [
-  'deprecated/clutter-timeout-interval.c',
 ]
 
 clutter_backend_sources = []
@@ -391,7 +359,6 @@ cally_headers = [
     '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',
@@ -406,7 +373,6 @@ cally_sources = [
     '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',
@@ -491,7 +457,7 @@ clutter_marshal = gnome.genmarshal('clutter-marshal',
   prefix: '_clutter_marshal',
   sources: 'clutter-marshal.list',
   valist_marshallers: true,
-  extra_args: ['--prototypes', '--quiet'],
+  extra_args: ['--prototypes'],
   install_dir: clutter_clutter_includedir,
   install_header: true,
 )
@@ -506,9 +472,7 @@ libmutter_clutter = shared_library(libmutter_clutter_name,
     clutter_private_headers,
     clutter_nonintrospected_sources,
     clutter_deprecated_sources,
-    clutter_deprecated_nonintrospected_sources,
     clutter_deprecated_headers,
-    clutter_deprecated_private_headers,
     clutter_backend_sources,
     clutter_backend_nonintrospected_sources,
     clutter_backend_headers,
@@ -538,7 +502,10 @@ libmutter_clutter_dep = declare_dependency(
 )
 
 if have_introspection
-  clutter_introspection_args = introspection_args + clutter_c_args
+  clutter_introspection_args = clutter_c_args + [
+    '-U_GNU_SOURCE', # _GNU_SOURCE triggers warnings in g-ir-scanner
+    '--quiet',
+  ]
 
   libmutter_clutter_gir = gnome.generate_gir(libmutter_clutter,
     sources: [
@@ -623,30 +590,28 @@ install_headers(clutter_deprecated_headers,
 install_headers(clutter_x11_headers,
   subdir: join_paths(clutter_clutter_includedir, 'x11'))
 
-pkg.generate(libmutter_clutter,
+pkg.generate(
   name: 'Mutters Clutter',
   filebase: libmutter_clutter_name,
   description: 'Mutters Clutter Private Library',
-  libraries: [m_dep],
+  libraries: [libmutter_clutter, m_dep],
   subdirs: join_paths(pkgname, 'clutter'),
   requires: [clutter_pkg_deps, libmutter_cogl_name],
   version: meson.project_version(),
   variables: [
     'apiversion=' + libmutter_api_version,
   ],
-  install_dir: pcdir,
 )
 
-pkg.generate(libmutter_clutter,
+pkg.generate(
   name: 'Mutters ClutterX11',
   filebase: 'mutter-clutter-x11-' + libmutter_api_version,
   description: 'Mutters ClutterX11 Private Library',
-  libraries: [m_dep],
+  libraries: [libmutter_clutter, m_dep],
   subdirs: join_paths(pkgname, 'clutter'),
   requires: [clutter_pkg_deps, libmutter_cogl_name],
   version: meson.project_version(),
   variables: [
     'apiversion=' + libmutter_api_version,
   ],
-  install_dir: pcdir,
 )

clutter/clutter/wayland/clutter-wayland-surface.c

@@ -321,13 +321,11 @@ static void
 clutter_wayland_surface_paint (ClutterActor *self)
 {
   ClutterWaylandSurfacePrivate *priv;
-  CoglFramebuffer *framebuffer;
   ClutterActorBox box;
 
   g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
 
   priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
-  framebuffer = cogl_get_draw_framebuffer ();
 
   if (G_UNLIKELY (priv->pipeline == NULL))
     {
@@ -345,11 +343,9 @@ clutter_wayland_surface_paint (ClutterActor *self)
                                        COGL_TEXTURE (priv->buffer));
     }
 
+  cogl_set_source (priv->pipeline);
   clutter_actor_get_allocation_box (self, &box);
-  cogl_framebuffer_draw_rectangle (framebuffer,
-                                   priv->pipeline,
-                                   0, 0,
-                                   box.x2 - box.x1, box.y2 - box.y1);
+  cogl_rectangle (0, 0, box.x2 - box.x1, box.y2 - box.y1);
 }
 
 static void

clutter/clutter/x11/clutter-device-manager-xi2.c

@@ -67,23 +67,6 @@ static const char *clutter_input_axis_atom_names[] = {
 
 #define N_AXIS_ATOMS    G_N_ELEMENTS (clutter_input_axis_atom_names)
 
-static const char *wacom_type_atoms[] = {
-    "STYLUS",
-    "CURSOR",
-    "ERASER",
-    "PAD",
-    "TOUCH"
-};
-#define N_WACOM_TYPE_ATOMS G_N_ELEMENTS (wacom_type_atoms)
-
-enum {
-    WACOM_TYPE_STYLUS,
-    WACOM_TYPE_CURSOR,
-    WACOM_TYPE_ERASER,
-    WACOM_TYPE_PAD,
-    WACOM_TYPE_TOUCH,
-};
-
 enum {
   PAD_AXIS_FIRST  = 3, /* First axes are always x/y/pressure, ignored in pads */
   PAD_AXIS_STRIP1 = PAD_AXIS_FIRST,
@@ -411,86 +394,6 @@ get_pad_features (XIDeviceInfo *info,
   *n_strips = strips;
 }
 
-/* The Wacom driver exports the tool type as property. Use that over
-   guessing based on the device name */
-static gboolean
-guess_source_from_wacom_type (ClutterBackendX11       *backend_x11,
-                              XIDeviceInfo            *info,
-                              ClutterInputDeviceType  *source_out)
-{
-  gulong nitems, bytes_after;
-  guint32 *data = NULL;
-  int rc, format;
-  Atom type;
-  Atom prop;
-  Atom device_type;
-  Atom types[N_WACOM_TYPE_ATOMS];
-
-  prop = XInternAtom (backend_x11->xdpy, "Wacom Tool Type", True);
-  if (prop == None)
-    return FALSE;
-
-  clutter_x11_trap_x_errors ();
-  rc = XIGetProperty (backend_x11->xdpy,
-                      info->deviceid,
-                      prop,
-                      0, 1, False, XA_ATOM, &type, &format, &nitems, &bytes_after,
-                      (guchar **) &data);
-  clutter_x11_untrap_x_errors ();
-
-
-  if (rc != Success || type != XA_ATOM || format != 32 || nitems != 1)
-    {
-      XFree (data);
-      return FALSE;
-    }
-
-  device_type = *data;
-  XFree (data);
-
-  if (device_type == 0)
-      return FALSE;
-
-  rc = XInternAtoms (backend_x11->xdpy,
-                     (char **)wacom_type_atoms,
-                     N_WACOM_TYPE_ATOMS,
-                     False,
-                     types);
-  if (rc == 0)
-      return FALSE;
-
-  if (device_type == types[WACOM_TYPE_STYLUS])
-    {
-      *source_out = CLUTTER_PEN_DEVICE;
-    }
-  else if (device_type == types[WACOM_TYPE_CURSOR])
-    {
-      *source_out = CLUTTER_CURSOR_DEVICE;
-    }
-  else if (device_type == types[WACOM_TYPE_ERASER])
-    {
-      *source_out = CLUTTER_ERASER_DEVICE;
-    }
-  else if (device_type == types[WACOM_TYPE_PAD])
-    {
-      *source_out = CLUTTER_PAD_DEVICE;
-    }
-  else if (device_type == types[WACOM_TYPE_TOUCH])
-    {
-        guint num_touches = 0;
-
-        if (!is_touch_device (info->classes, info->num_classes,
-                              source_out, &num_touches))
-            *source_out = CLUTTER_TOUCHSCREEN_DEVICE;
-    }
-  else
-    {
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
 static ClutterInputDevice *
 create_device (ClutterDeviceManagerXI2 *manager_xi2,
                ClutterBackendX11       *backend_x11,
@@ -518,7 +421,7 @@ create_device (ClutterDeviceManagerXI2 *manager_xi2,
     {
       source = touch_source;
     }
-  else if (!guess_source_from_wacom_type (backend_x11, info, &source))
+  else
     {
       gchar *name;
 

clutter/clutter/x11/clutter-input-device-xi2.c

@@ -180,56 +180,6 @@ clutter_input_device_xi2_is_mode_switch_button (ClutterInputDevice *device,
   return button_group == (int) group;
 }
 
-static gboolean
-clutter_input_device_xi2_get_physical_size (ClutterInputDevice *device,
-                                            gdouble            *width,
-                                            gdouble            *height)
-{
-  Display *xdisplay;
-  XIDeviceInfo *dev_info;
-  gdouble w = 0, h = 0;
-  int i, n_info, device_id;
-
-  xdisplay = clutter_x11_get_default_display ();
-  device_id = clutter_input_device_get_device_id (device);
-
-  clutter_x11_trap_x_errors ();
-  dev_info = XIQueryDevice (xdisplay, device_id, &n_info);
-  if (clutter_x11_untrap_x_errors ())
-    return FALSE;
-
-  if (!dev_info)
-    return FALSE;
-
-  for (i = 0; i < dev_info->num_classes; i++)
-    {
-      XIValuatorClassInfo *valuator;
-      gdouble *value;
-
-      if (dev_info->classes[i]->type != XIValuatorClass)
-        continue;
-
-      valuator = (XIValuatorClassInfo *) dev_info->classes[i];
-
-      if (valuator->label == XInternAtom (xdisplay, "Abs X", True) ||
-          valuator->label == XInternAtom (xdisplay, "Abs MT Position X", True))
-        value = &w;
-      else if (valuator->label == XInternAtom (xdisplay, "Abs Y", True) ||
-               valuator->label == XInternAtom (xdisplay, "Abs MT Position Y", True))
-        value = &h;
-      else
-        continue;
-
-      *value = (valuator->max -  valuator->min) * 1000 / valuator->resolution;
-    }
-
-  XIFreeDeviceInfo (dev_info);
-  *width = w;
-  *height = h;
-
-  return (w > 0 && h > 0);
-}
-
 static void
 clutter_input_device_xi2_class_init (ClutterInputDeviceXI2Class *klass)
 {
@@ -243,7 +193,6 @@ clutter_input_device_xi2_class_init (ClutterInputDeviceXI2Class *klass)
   device_class->is_grouped = clutter_input_device_xi2_is_grouped;
   device_class->get_group_n_modes = clutter_input_device_xi2_get_group_n_modes;
   device_class->is_mode_switch_button = clutter_input_device_xi2_is_mode_switch_button;
-  device_class->get_physical_size = clutter_input_device_xi2_get_physical_size;
 }
 
 static void

clutter/clutter/x11/clutter-keymap-x11.c

@@ -76,9 +76,6 @@ struct _ClutterKeymapX11
   DirectionCacheEntry group_direction_cache[4];
   int current_group;
 
-  GHashTable *reserved_keycodes;
-  GQueue *available_keycodes;
-
   guint caps_lock_state : 1;
   guint num_lock_state  : 1;
   guint has_direction   : 1;
@@ -425,97 +422,15 @@ clutter_keymap_x11_set_property (GObject      *gobject,
     }
 }
 
-static void
-clutter_keymap_x11_refresh_reserved_keycodes (ClutterKeymapX11 *keymap_x11)
-{
-  Display *dpy = clutter_x11_get_default_display ();
-  GHashTableIter iter;
-  gpointer key, value;
-
-  g_hash_table_iter_init (&iter, keymap_x11->reserved_keycodes);
-  while (g_hash_table_iter_next (&iter, &key, &value))
-    {
-      guint reserved_keycode = GPOINTER_TO_UINT (key);
-      guint reserved_keysym = GPOINTER_TO_UINT (value);
-      guint actual_keysym = XkbKeycodeToKeysym (dpy, reserved_keycode, 0, 0);
-
-      /* If an available keycode is no longer mapped to the stored keysym, then
-       * the keycode should not be considered available anymore and should be
-       * removed both from the list of available and reserved keycodes.
-       */
-      if (reserved_keysym != actual_keysym)
-        {
-          g_hash_table_iter_remove (&iter);
-          g_queue_remove (keymap_x11->available_keycodes, key);
-        }
-    }
-}
-
-static gboolean
-clutter_keymap_x11_replace_keycode (ClutterKeymapX11 *keymap_x11,
-                                    KeyCode           keycode,
-                                    KeySym            keysym)
-{
-  if (CLUTTER_BACKEND_X11 (keymap_x11->backend)->use_xkb)
-    {
-      Display *dpy = clutter_x11_get_default_display ();
-      XkbDescPtr xkb = get_xkb (keymap_x11);
-      XkbMapChangesRec changes;
-
-      XFlush (dpy);
-
-      xkb->device_spec = XkbUseCoreKbd;
-      memset (&changes, 0, sizeof(changes));
-
-      if (keysym != NoSymbol)
-        {
-          int types[XkbNumKbdGroups] = { XkbOneLevelIndex };
-          XkbChangeTypesOfKey (xkb, keycode, 1, XkbGroup1Mask, types, &changes);
-          XkbKeySymEntry (xkb, keycode, 0, 0) = keysym;
-        }
-      else
-        {
-          /* Reset to NoSymbol */
-          XkbChangeTypesOfKey (xkb, keycode, 0, XkbGroup1Mask, NULL, &changes);
-        }
-
-      changes.changed = XkbKeySymsMask | XkbKeyTypesMask;
-      changes.first_key_sym = keycode;
-      changes.num_key_syms = 1;
-      changes.first_type = 0;
-      changes.num_types = xkb->map->num_types;
-      XkbChangeMap (dpy, xkb, &changes);
-
-      XFlush (dpy);
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
 static void
 clutter_keymap_x11_finalize (GObject *gobject)
 {
   ClutterKeymapX11 *keymap;
   ClutterEventTranslator *translator;
-  GHashTableIter iter;
-  gpointer key, value;
 
   keymap = CLUTTER_KEYMAP_X11 (gobject);
   translator = CLUTTER_EVENT_TRANSLATOR (keymap);
 
-  clutter_keymap_x11_refresh_reserved_keycodes (keymap);
-  g_hash_table_iter_init (&iter, keymap->reserved_keycodes);
-  while (g_hash_table_iter_next (&iter, &key, &value))
-    {
-      guint keycode = GPOINTER_TO_UINT (key);
-      clutter_keymap_x11_replace_keycode (keymap, keycode, NoSymbol);
-    }
-
-  g_hash_table_destroy (keymap->reserved_keycodes);
-  g_queue_free (keymap->available_keycodes);
-
   _clutter_backend_remove_event_translator (keymap->backend, translator);
 
   if (keymap->xkb_desc != NULL)
@@ -547,8 +462,6 @@ clutter_keymap_x11_init (ClutterKeymapX11 *keymap)
 {
   keymap->current_direction = PANGO_DIRECTION_NEUTRAL;
   keymap->current_group = -1;
-  keymap->reserved_keycodes = g_hash_table_new (NULL, NULL);
-  keymap->available_keycodes = g_queue_new ();
 }
 
 static ClutterTranslateReturn
@@ -818,72 +731,6 @@ clutter_keymap_x11_get_entries_for_keyval (ClutterKeymapX11  *keymap_x11,
     }
 }
 
-static guint
-clutter_keymap_x11_get_available_keycode (ClutterKeymapX11 *keymap_x11)
-{
-  if (CLUTTER_BACKEND_X11 (keymap_x11->backend)->use_xkb)
-    {
-      clutter_keymap_x11_refresh_reserved_keycodes (keymap_x11);
-
-      if (g_hash_table_size (keymap_x11->reserved_keycodes) < 5)
-        {
-          Display *dpy = clutter_x11_get_default_display ();
-          XkbDescPtr xkb = get_xkb (keymap_x11);
-          guint i;
-
-          for (i = xkb->max_key_code; i >= xkb->min_key_code; --i)
-            {
-              if (XkbKeycodeToKeysym (dpy, i, 0, 0) == NoSymbol)
-                return i;
-            }
-        }
-
-      return GPOINTER_TO_UINT (g_queue_pop_head (keymap_x11->available_keycodes));
-    }
-
-  return 0;
-}
-
-gboolean clutter_keymap_x11_reserve_keycode (ClutterKeymapX11 *keymap_x11,
-                                             guint             keyval,
-                                             guint            *keycode_out)
-{
-  g_return_val_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap_x11), FALSE);
-  g_return_val_if_fail (keyval != 0, FALSE);
-  g_return_val_if_fail (keycode_out != NULL, FALSE);
-
-  *keycode_out = clutter_keymap_x11_get_available_keycode (keymap_x11);
-
-  if (*keycode_out == NoSymbol)
-    {
-      g_warning ("Cannot reserve a keycode for keyval %d: no available keycode", keyval);
-      return FALSE;
-    }
-
-  if (!clutter_keymap_x11_replace_keycode (keymap_x11, *keycode_out, keyval))
-    {
-      g_warning ("Failed to remap keycode %d to keyval %d", *keycode_out, keyval);
-      return FALSE;
-    }
-
-  g_hash_table_insert (keymap_x11->reserved_keycodes, GUINT_TO_POINTER (*keycode_out), GUINT_TO_POINTER (keyval));
-  g_queue_remove (keymap_x11->available_keycodes, GUINT_TO_POINTER (*keycode_out));
-
-  return TRUE;
-}
-
-void clutter_keymap_x11_release_keycode_if_needed (ClutterKeymapX11 *keymap_x11,
-                                                   guint             keycode)
-{
-  g_return_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap_x11));
-
-  if (!g_hash_table_contains (keymap_x11->reserved_keycodes, GUINT_TO_POINTER (keycode)) ||
-      g_queue_index (keymap_x11->available_keycodes, GUINT_TO_POINTER (keycode)) != -1)
-    return;
-
-  g_queue_push_tail (keymap_x11->available_keycodes, GUINT_TO_POINTER (keycode));
-}
-
 void
 clutter_keymap_x11_latch_modifiers (ClutterKeymapX11 *keymap_x11,
                                     uint32_t          level,