MetaShapedTexture: save and restore textures on suspend

The proprietary nvidia driver garbles GPU memory on suspend. In order to workaround that limitation, this commit copies all textures to host memory on suspend and restores them on resume. One complication comes from external textures (such as those given to us by Xwayland for X clients). We can't just restore those textures, since they aren't writable. This commit addresses that complication by keeping a local texture around for those external textures, and using it instead for parts of the window that haven't been redrawn since resume.
background: purge all background textures on suspend
2019-01-15 11:54:58 -05:00 · 2019-01-15 11:37:54 -05:00 · 2019-01-15 11:37:54 -05:00 · 2019-01-15 11:37:53 -05:00 · 2019-01-15 11:37:39 -05:00 · 2019-01-15 11:37:08 -05:00
1871 changed files with 227722 additions and 184215 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,9 +1,25 @@
 Makefile
 Makefile.in
 Makefile.in.in
 aclocal.m4
 autom4te.cache
 build-aux
 compile
 config.guess
 config.h
 config.h.in
 config.log
 config.status
 config.sub
 configure
 depcomp
 install-sh
 intltool-extract.in
 intltool-merge.in
 libtool
 ltmain.sh
 missing
 .deps
 50-mutter-navigation.xml
 50-mutter-system.xml
 50-mutter-windows.xml
@ -17,11 +33,15 @@ mutter-wayland.desktop
 *.swp
 *.gir
 *.typelib
 stamp-h1
 *.gmo
 *.make
 *.log
 *.trs
 *~
 stamp-it
 .intltool-merge-cache
 ABOUT-NLS
 POTFILES
 Makevars.template
 po/*.header
@ -44,7 +64,9 @@ org.gnome.mutter.wayland.gschema.xml
 testasyncgetprop
 testboxes
 testgradient
 m4/*
 INSTALL
 mkinstalldirs
 meta-enum-types.[ch]
 src/stamp-meta-enum-types.h
 src/meta-dbus-display-config.[ch]
@ -72,15 +94,12 @@ src/xwayland-keyboard-grab-unstable-v1-protocol.c
 src/xwayland-keyboard-grab-unstable-v1-server-protocol.h
 src/tablet-unstable-v*-protocol.c
 src/tablet-unstable-v*-server-protocol.h
 src/text-input-unstable-v*-protocol.c
 src/text-input-unstable-v*-server-protocol.h
 src/keyboard-shortcuts-inhibit-unstable-v*-protocol.c
 src/keyboard-shortcuts-inhibit-unstable-v*-server-protocol.h
 src/linux-dmabuf-unstable-v*-protocol.c
 src/linux-dmabuf-unstable-v*-server-protocol.h
 src/xdg-shell-protocol.c
 src/xdg-shell-server-protocol.h
 src/wayland-eglstream-controller-server-protocol.h
 src/meta/meta-version.h
 src/libmutter-*.pc
 doc/reference/*.args
@ -100,7 +119,12 @@ doc/reference/meta-undocumented.txt
 doc/reference/meta-unused.txt
 doc/reference/meta-docs.sgml
 doc/reference/meta.types
 gtk-doc.m4
 intltool.m4
 libtool.m4
 ltoptions.m4
 ltsugar.m4
 ltversion.m4
 lt~obsolete.m4
 .dirstamp
 **/tags.*
 build/
 subprojects/sysprof/
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,372 +0,0 @@
 include:
  - remote: 'https://gitlab.freedesktop.org/freedesktop/ci-templates/-/raw/bbe5232986c9b98eb1efe62484e07216f7d1a4df/templates/fedora.yml'
  - remote: 'https://gitlab.freedesktop.org/freedesktop/ci-templates/-/raw/bbe5232986c9b98eb1efe62484e07216f7d1a4df/templates/ci-fairy.yml'
 stages:
 - review
 - prepare
 - code-review
 - build
 - test
 - analyze
 - deploy
 variables:
  FDO_UPSTREAM_REPO: GNOME/mutter
 .mutter.fedora:34@common:
  variables:
    FDO_DISTRIBUTION_VERSION: 34
    BASE_TAG: '2021-09-04.1'
    FDO_DISTRIBUTION_PACKAGES:
      asciidoc
      clang
      gcovr
      gdm
      gnome-shell
      python3-dbusmock
      sassc
      uncrustify
      xorg-x11-server-Xvfb
    FDO_DISTRIBUTION_EXEC: |
      dnf install -y 'dnf-command(builddep)' &&
      dnf builddep -y mutter --setopt=install_weak_deps=False &&
      dnf builddep -y gnome-shell --setopt=install_weak_deps=False &&
      ./.gitlab-ci/install-meson-project.sh \
        https://gitlab.gnome.org/GNOME/glib.git \
        main . 02742ef957b532789c003eef80ec7f51c370e3d5 &&
      ./.gitlab-ci/install-meson-project.sh \
        https://gitlab.gnome.org/GNOME/gsettings-desktop-schemas.git \
        41.alpha . &&
      ./.gitlab-ci/install-meson-project.sh \
        https://gitlab.gnome.org/GNOME/gjs.git \
        1.69.2 . &&
      rpm -e --nodeps gnome-bluetooth-libs-devel \
                      mutter mutter-devel \
                      gnome-shell &&
      dnf clean all
 default:
  # Cancel jobs if newer commits are pushed to the branch
  interruptible: true
  # Auto-retry jobs in case of infra failures
  retry:
    max: 1
    when:
      - 'runner_system_failure'
      - 'stuck_or_timeout_failure'
      - 'scheduler_failure'
      - 'api_failure'
 .mutter.fedora:34@x86_64:
  extends: .mutter.fedora:34@common
  variables:
    FDO_DISTRIBUTION_TAG: "x86_64-${BASE_TAG}"
 .mutter.fedora:34@aarch64:
  extends: .mutter.fedora:34@common
  variables:
    FDO_DISTRIBUTION_TAG: "aarch64-${BASE_TAG}"
  tags:
    - aarch64
 workflow:
  rules:
    - if: '$CI_MERGE_REQUEST_IID'
    - if: '$CI_COMMIT_TAG'
    - if: '$CI_COMMIT_BRANCH'
 .pipline-guard: &pipline-guard
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
    - if: '$CI_COMMIT_TAG'
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
    - if: '$CI_COMMIT_BRANCH =~ /^gnome-[0-9-]+$/'
    - when: 'manual'
 check-commit-log:
  extends:
    - .fdo.ci-fairy
  stage: review
  variables:
    GIT_DEPTH: "100"
  script:
    - if [[ x"$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" != "x" ]] ;
      then
        ci-fairy check-commits --junit-xml=commit-message-junit-report.xml ;
      else
        echo "Not a merge request" ;
      fi
  artifacts:
    expire_in: 1 week
    paths:
      - commit-message-junit-report.xml
    reports:
      junit: commit-message-junit-report.xml
  <<: *pipline-guard
 check-merge-request:
  extends:
    - .fdo.ci-fairy
  stage: review
  variables:
    GIT_STRATEGY: none
  script:
    - if [[ x"$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" != "x" ]] ;
      then
        ci-fairy check-merge-request --require-allow-collaboration --junit-xml=check-merge-request-report.xml ;
      else
        echo "Not a merge request" ;
      fi
  artifacts:
    expire_in: 1 week
    paths:
      - check-merge-request-report.xml
    reports:
      junit: check-merge-request-report.xml
  <<: *pipline-guard
 build-fedora-container@x86_64:
  extends:
    - .fdo.container-build@fedora@x86_64
    - .mutter.fedora:34@x86_64
  stage: prepare
  needs:
    - check-commit-log
    - check-merge-request
  variables:
    GIT_STRATEGY: none
 build-fedora-container@aarch64:
  extends:
    - .fdo.container-build@fedora@aarch64
    - .mutter.fedora:34@aarch64
  stage: prepare
  needs:
    - check-commit-log
    - check-merge-request
  variables:
    GIT_STRATEGY: none
 check-code-style:
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  stage: code-review
  needs:
    - build-fedora-container@x86_64
  script:
    - if [[ x"$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" != "x" ]] ;
      then
        git remote add target $CI_MERGE_REQUEST_PROJECT_URL.git ;
        git fetch target $CI_MERGE_REQUEST_TARGET_BRANCH_NAME ;
        export common_parent_sha=$(diff --old-line-format='' --new-line-format='' <(git rev-list --first-parent "target/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME") <(git rev-list --first-parent HEAD) | head -1) ;
        python3 -u ./check-style.py --dry-run --sha $common_parent_sha ;
      else
        echo "Not a merge request" ;
      fi
  allow_failure: true
 .build-mutter:
  extends:
    - .fdo.distribution-image@fedora
  stage: build
  script:
    - meson . build -Dbuildtype=debugoptimized -Db_coverage=true -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
    - meson compile -C build
    - meson install -C build
  artifacts:
    expire_in: 1 day
    paths:
      - build
 build-mutter@x86_64:
  extends:
    - .build-mutter
    - .mutter.fedora:34@x86_64
  needs:
    - build-fedora-container@x86_64
 build-mutter@aarch64:
  extends:
    - .build-mutter
    - .mutter.fedora:34@aarch64
  needs:
    - build-fedora-container@aarch64
 build-without-opengl-and-glx@x86_64:
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  stage: build
  needs:
    - build-fedora-container@x86_64
  script:
    - meson . build -Dbuildtype=debugoptimized -Dopengl=false -Dglx=false -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
    - meson compile -C build
    - meson install -C build
  artifacts:
    paths:
      - build/meson-logs
 build-without-native-backend-and-wayland@x86_64:
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  stage: build
  needs:
    - build-fedora-container@x86_64
  script:
    - meson . build -Dbuildtype=debugoptimized -Dnative_backend=false -Dudev=false -Dwayland=false -Dcore_tests=false -Dnative_tests=false --werror --prefix /usr
    - meson compile -C build
    - meson install -C build
  artifacts:
    paths:
      - build/meson-logs
 .test-setup: &test-setup
  variables:
    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
    MUTTER_DEBUG_DUMMY_MODE_SPECS: "800x600@10.0"
    PIPEWIRE_DEBUG: 2
    PIPEWIRE_LOG: "$CI_PROJECT_DIR/build/meson-logs/pipewire.log"
    XVFB_SERVER_ARGS: "+iglx -noreset"
    G_SLICE: "always-malloc"
    MALLOC_CHECK_: "3"
    NO_AT_BRIDGE: "1"
  before_script:
    - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
    # Disable e.g. audio support to not dead lock screen cast tests
    - rm -f /usr/share/pipewire/media-session.d/with-*
    - mkdir -m 700 $XDG_RUNTIME_DIR
    - pipewire & sleep 2
 .test-mutter:
  extends:
    - .fdo.distribution-image@fedora
  <<: *test-setup
  stage: test
  script:
    - dbus-run-session -- xvfb-run -a -s "$XVFB_SERVER_ARGS"
        catchsegv meson test -C build --no-rebuild -t 10
  artifacts:
    expire_in: 1 day
    reports:
      junit: "build/meson-logs/testlog-catchsegv.junit.xml"
    name: "mutter-${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}"
    when: always
    paths:
      - build
 test-mutter@x86_64:
  extends:
    - .test-mutter
    - .mutter.fedora:34@x86_64
  needs:
    - build-mutter@x86_64
 test-mutter@aarch64:
  extends:
    - .test-mutter
    - .mutter.fedora:34@aarch64
  needs:
    - build-mutter@aarch64
 .test-mutter-coverage:
  extends:
    - .fdo.distribution-image@fedora
  stage: analyze
  script:
    - ninja -C build coverage
    - cat build/meson-logs/coverage.txt
  artifacts:
    paths:
      - build/meson-logs/coveragereport
  coverage: '/^TOTAL.*\s+(\d+\%)$/'
 test-mutter-coverage@x86_64:
  extends:
    - .test-mutter-coverage
    - .mutter.fedora:34@x86_64
  needs:
    - test-mutter@x86_64
 test-mutter-coverage@aarch64:
  extends:
    - .test-mutter-coverage
    - .mutter.fedora:34@aarch64
  needs:
    - test-mutter@aarch64
 can-build-gnome-shell@x86_64:
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  stage: test
  needs:
    - build-mutter@x86_64
  before_script:
    - meson install --no-rebuild -C build
  script:
    - .gitlab-ci/checkout-gnome-shell.sh
    - meson gnome-shell gnome-shell/build --prefix /usr -Dman=false
    - meson install -C gnome-shell/build
 test-mutter-coverity:
  rules:
    - if: '$CI_PIPELINE_SOURCE == "schedule" && $MUTTER_SCHEDULED_JOB == "coverity"'
      when: always
    - when: manual
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  needs:
    - build-fedora-container@x86_64
  stage: analyze
  allow_failure: true
  script:
    - .gitlab-ci/download-coverity-tarball.sh
    - CC=clang meson coverity-build -Dprofiler=false
    - ./coverity/cov-analysis-linux64-*/bin/cov-build --dir cov-int meson compile -C coverity-build
    - tar czf cov-int.tar.gz cov-int
    - curl https://scan.coverity.com/builds?project=mutter
      --form token=$COVERITY_TOKEN --form email=carlosg@gnome.org
      --form file=@cov-int.tar.gz --form version="`git describe --tags`"
      --form description="GitLab CI build"
  cache:
    key: coverity-tarball
    paths:
      - coverity
 dist-mutter:
  extends:
    - .fdo.distribution-image@fedora
    - .mutter.fedora:34@x86_64
  <<: *test-setup
  stage: deploy
  needs:
    - build-mutter@x86_64
  script:
    - dbus-run-session -- xvfb-run -a -s "$XVFB_SERVER_ARGS" meson dist -C build
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
      changes:
        - "**/meson.build"
        - meson/*
 dist-mutter-tarball:
  extends: dist-mutter
  artifacts:
    expose_as: 'Get tarball here'
    paths:
      - build/meson-dist/$CI_PROJECT_NAME-$CI_COMMIT_TAG.tar.xz
  rules:
    - if: '$CI_COMMIT_TAG'
--- a/.gitlab-ci/checkout-gnome-shell.sh
+++ b/.gitlab-ci/checkout-gnome-shell.sh
@ -1,55 +0,0 @@
 #!/usr/bin/bash
 fetch() {
  local remote=$1
  local ref=$2
  git fetch --quiet --depth=1 $remote $ref 2>/dev/null
 }
 gnome_shell_target=
 echo -n Cloning into gnome-shell ...
 if git clone --quiet --depth=1 https://gitlab.gnome.org/GNOME/gnome-shell.git; then
  echo \ done
 else
  echo \ failed
  exit 1
 fi
 cd gnome-shell
 if [ "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" ]; then
  merge_request_remote=${CI_MERGE_REQUEST_SOURCE_PROJECT_URL//mutter/gnome-shell}
  merge_request_branch=$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME
  echo -n Looking for $merge_request_branch on remote ...
  if fetch $merge_request_remote $merge_request_branch; then
    echo \ found
    gnome_shell_target=FETCH_HEAD
  else
    echo \ not found
    echo -n Looking for $CI_MERGE_REQUEST_TARGET_BRANCH_NAME instead ...
    if fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME; then
      echo \ found
      gnome_shell_target=FETCH_HEAD
    else
      echo \ not found
    fi
  fi
 fi
 if [ -z "$gnome_shell_target" ]; then
  echo -n Looking for $CI_COMMIT_REF_NAME on remote ...
  if fetch origin $CI_COMMIT_REF_NAME; then
    echo \ found
    gnome_shell_target=FETCH_HEAD
  else
    echo \ not found
    gnome_shell_target=HEAD
    echo Using $gnome_shell_target instead
  fi
 fi
 git checkout -q $gnome_shell_target
--- a/.gitlab-ci/commit-rules.yml
+++ b/.gitlab-ci/commit-rules.yml
@ -1,19 +0,0 @@
 patterns:
  deny:
    - regex: '^$CI_MERGE_REQUEST_PROJECT_URL/(-/)?merge_requests/$CI_MERGE_REQUEST_IID$'
      message: Commit message must not contain a link to its own merge request
    - regex: '^(meta-|Meta)'
      message: Commit message subject should not be prefixed with 'meta-' or 'Meta'
      where: subject
    - regex: '^(clutter-|Clutter)'
      message: Commit message subject should not be prefixed with 'clutter-' or 'Clutter', use 'clutter/' instead
      where: subject
    - regex: '^(cogl-|Cogl)'
      message: Commit message subject should not be prefixed with 'cogl-' or 'Cogl', use 'cogl/' instead
      where: subject
    - regex: '^[^:]+: [a-z]'
      message: "Commit message subject should be properly Capitalized. E.g.  'window: Marginalize extradicity'"
      where: subject
    - regex: '^\S*\.[ch]:'
      message: Commit message subject prefix should not include .c, .h, etc.
      where: subject
--- a/.gitlab-ci/download-coverity-tarball.sh
+++ b/.gitlab-ci/download-coverity-tarball.sh
@ -1,38 +0,0 @@
 #!/usr/bin/bash
 # We need a coverity token to fetch the tarball
 if [ -x $COVERITY_TOKEN ]
 then
  echo "No coverity token. Run this job from a protected branch."
  exit -1
 fi
 mkdir -p coverity
 # Download and check MD5 first
 curl https://scan.coverity.com/download/linux64 \
  --data "token=$COVERITY_TOKEN&project=mutter&md5=1" \
  --output /tmp/coverity_tool.md5
 diff /tmp/coverity_tool.md5 coverity/coverity_tool.md5 >/dev/null 2>&1
 if [ $? -eq 0 -a -d coverity/cov-analysis* ]
 then
  echo "Coverity tarball is up-to-date"
  exit 0
 fi
 # Download and extract coverity tarball
 curl https://scan.coverity.com/download/linux64 \
  --data "token=$COVERITY_TOKEN&project=mutter" \
  --output /tmp/coverity_tool.tgz
 rm -rf ./coverity/cov-analysis*
 tar zxf /tmp/coverity_tool.tgz -C coverity/
 if [ $? -eq 0 ]
 then
  mv /tmp/coverity_tool.md5 coverity/
 fi
 rm /tmp/coverity_tool.tgz
--- a/.gitlab-ci/install-meson-project.sh
+++ b/.gitlab-ci/install-meson-project.sh
@ -1,39 +0,0 @@
 #!/bin/bash
 set -e
 if [[ $# -lt 3 ]]; then
  echo Usage: $0 [options] [repo-url] [commit] [subdir]
  echo  Options:
  echo    -Dkey=val
  exit 1
 fi
 MESON_OPTIONS=()
 while [[ $1 =~ ^-D ]]; do
  MESON_OPTIONS+=( "$1" )
  shift
 done
 REPO_URL="$1"
 TAG_OR_BRANCH="$2"
 SUBDIR="$3"
 COMMIT="$4"
 REPO_DIR="$(basename ${REPO_URL%.git})"
 git clone --depth 1 "$REPO_URL" -b "$TAG_OR_BRANCH"
 pushd "$REPO_DIR"
 pushd "$SUBDIR"
 if [ ! -z "$COMMIT" ]; then
  git fetch origin "$COMMIT"
  git checkout "$COMMIT"
 fi
 meson --prefix=/usr _build "${MESON_OPTIONS[@]}"
 meson install -C _build
 popd
 popd
 rm -rf "$REPO_DIR"
--- a/.gitlab/issue_templates/Bug.md
+++ b/.gitlab/issue_templates/Bug.md
@ -1,55 +0,0 @@
 <!-- 
 Please read https://wiki.gnome.org/Community/GettingInTouch/BugReportingGuidelines
 first to ensure that you create a clear and specific issue.
 -->
 ### Affected version
 <!--
 Provide at least the following information:
 * Your OS and version
 * Affected Mutter version
 * Does this issue appear in XOrg and/or Wayland
 -->
 ### Bug summary
 <!-- 
 Provide a short summary of the bug you encountered.
 -->
 ### Steps to reproduce
 <!-- 
 1. Step one
 2. Step two
 3. ...
 -->
 ### What happened
 <!-- 
 What did Mutter do that was unexpected?
 -->
 ### What did you expect to happen
 <!-- 
 What did you expect Mutter to do?
 -->
 ### Relevant logs, screenshots, screencasts etc.
 <!-- 
 If you have further information, such as technical documentation, logs,
 screenshots or screencasts related, please provide them here.
 If the bug is a crash, please obtain a stack trace with installed debug
 symbols (at least for GNOME Shell and Mutter) and attach it to
 this issue following the instructions on
 https://wiki.gnome.org/Community/GettingInTouch/Bugzilla/GettingTraces.
 -->
 <!-- Do not remove the following line. -->
 /label ~"1. Bug"
--- a/.gitlab/issue_templates/Feature.md
+++ b/.gitlab/issue_templates/Feature.md
@ -1,30 +0,0 @@
 <!-- 
 Please read https://wiki.gnome.org/Community/GettingInTouch/BugReportingGuidelines
 first to ensure that you create a clear and specific issue.
 -->
 ### Feature summary
 <!-- 
 Describe what you would like to be able to do with Mutter
 that you currently cannot do.
 -->
 ### How would you like it to work
 <!-- 
 If you can think of a way Mutter might be able to do this,
 let us know here.
 -->
 ### Relevant links, screenshots, screencasts etc.
 <!-- 
 If you have further information, such as technical documentation,
 code, mockups or a similar feature in another window managers,
 please provide them here.
 -->
 <!-- Do not remove the following line. -->
 /label ~"1. Feature"
--- a/HACKING.md
+++ b/HACKING.md
@ -1,286 +0,0 @@
 # Style
 The coding style used is primarily the GNU flavor of the [GNOME coding
 style][gnome-coding-style], with some additions described below.
 ## General
 * Use this code style on new code. When changing old code with a different
   code style, feel free to also adjust it to use this code style.
 * Use regular C types and `stdint.h` types instead of GLib fundamental
   types, except for `gboolean`, and `guint`/`gulong` for GSource IDs and
   signal handler IDs. That means e.g. `uint64_t` instead of `guint64`, `int`
   instead of `gint`, `unsigned int` instead of `guint` if unsignedness
   is of importance, `uint8_t` instead of `guchar`, and so on.
 * Try to to limit line length to 80 characters, although it's not a
   strict limit.
 * Usage of `g_autofree` and `g_autoptr` is encouraged. The style to use is
    ```c
    g_autofree char *text = NULL;
    g_autoptr (MetaSomeThing) thing = NULL;
    text = g_strdup_printf ("The text: %d", a_number);
    thing = g_object_new (META_TYPE_SOME_THING,
                          "text", text,
                          NULL);
    thinger_use_thing (rocket, thing);
    ```
 * Declare variables at the top of the block they are used, but avoid
   non-trivial logic among variable declarations. Non-trivial logic can be
   getting a pointer that may be `NULL`, any kind of math, or anything
   that may have side effects.
 * Instead of boolean arguments in functions, prefer enums or flags when
   they're more expressive. The naming convention for flags is
    ```c
    typedef _MetaSomeThingFlags
    {
      META_SOME_THING_FLAG_NONE = 0,
      META_SOME_THING_FLAG_ALTER_REALITY = 1 << 0,
      META_SOME_THING_FLAG_MANIPULATE_PERCEPTION = 1 << 1,
    } MetaSomeThingFlags;
    ```
 * Use `g_new0 ()` etc. instead of `g_slice_new0 ()`.
 * Initialize and assign floating point variables (i.e. `float` or
   `double`) using the form `floating_point = 3.14159` or `ratio = 2.0`.
 ## Header (.h) files
 * The return type and `*` are separated by a space.
 * Function name starts one space after the last `*`.
 * Parenthesis comes one space after the function name.
 As an example, this is how functions in a header file should look like:
 ```c
 gboolean meta_udev_is_drm_device (MetaUdev    *udev,
                                  GUdevDevice *device);
 GList * meta_udev_list_drm_devices (MetaUdev  *udev,
                                    GError   **error);
 MetaUdev * meta_udev_new (MetaBackendNative *backend_native);
 ```
 ## Source code
 Keep functions in the following order in source files:
  1. GPL header
  2. Enums
  3. Structures
  4. Function prototypes
  5. `G_DEFINE_TYPE()`
  6. Static variables
  7. Auxiliary functions
  8. Callbacks
  9. Interface implementations
  10. Parent vfunc overrides
  11. class_init and init
  12. Public API
 ### Structures
 Each structure field has a space after their type name. Structure fields aren't
 aligned. For example:
 ```c
 struct _MetaFooBar
 {
  MetaFoo parent;
  MetaBar *bar;
  MetaSomething *something;
 };
 ```
 ### Function Prototypes
 Function prototypes must be formatted just like in header files.
 ### Overrides
 When overriding parent class vfuncs, or implementing an interface, vfunc
 overrides should be named as a composition of the current class prefix,
 followed by the vfunc name. For example:
 ```c
 static void
 meta_bar_spawn_unicorn (MetaParent *parent)
 {
  /* ... */
 }
 static void
 meta_bar_dispose (GObject *object)
 {
  /* ... */
 }
 static void
 meta_bar_finalize (GObject *object)
 {
  /* ... */
 }
 static void
 meta_bar_class_init (MetaBarClass *klass)
 {
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  MetaParentClass *parent_class = META_PARENT_CLASS (klass);
  object_class->dispose = meta_bar_dispose;
  object_class->finalize = meta_bar_finalize;
  parent_class->spawn_unicorn = meta_bar_spawn_unicorn;
 }
 ```
 ### Interface Implementations
 When implementing interfaces, two groups of functions are involved: the init
 function, and the overrides.
 The interface init function is named after the interface type in snake case,
 followed by the `_iface_init` suffix. For example:
 ```c
 static void meta_foo_iface_init (MetaFooInterface *foo_iface);
 G_DEFINE_TYPE_WITH_CODE (MetaBar, meta_bar, G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE (META_TYPE_FOO,
                                                meta_foo_iface_init));
 ```
 Then, when implementing each vfunc of the interface, follow the same pattern
 of the [Overrides](###Overrides) section. Here's an example:
 ```c
 static void
 meta_bar_do_something (MetaFoo *foo)
 {
  /* ... */
 }
 static void
 meta_foo_iface_init (MetaFooInterface *foo_iface)
 {
  foo_iface->do_something = meta_bar_do_something;
 }
 ```
 ### Auxiliary Functions
 Auxiliary functions are above every other functions to minimize the number of
 function prototypes in the file. These functions often grow when factoring out
 the same code between two or more functions:
 ```c
 static void
 do_something_on_data (Foo *data,
                      Bar *bar)
 {
  /* ... */
 }
 static void
 random_function (Foo *foo)
 {
  do_something_on_data (foo, bar);
 }
 static void
 another_random_function (Foo *foo)
 {
  do_something_on_data (foo, bar);
 }
 ```
 Sometimes, however, auxiliary functions are created to break down otherwise
 large functions - in this case, it is appropriate to keep these auxiliary
 functions close to the function they are tightly related to.
 Auxiliary function names must have a verb in the imperative form, and should
 always perform an action over something. They usually don't have the class
 prefix (`meta_`, `clutter_`, or `cogl_`). For example:
 ```c
 static void
 do_something_on_data (Foo *data,
                      Bar *bar)
 {
  /* ... */
 }
 ```
 Exceptionally, when converting between types, auxiliary function names may
 have the class prefix to this rule. For example:
 ```c
 static MetaFoo *
 meta_foo_from_bar (Bar *bar)
 {
  /* ... */
 }
 ```
 ### Callback Functions
 Callback function names should have the name of the action in imperative
 form. They don't have any prefix, but have a `_func` suffix. For example:
 ```c
 static void
 filter_something_func (Foo      *foo,
                       Bar      *bar,
                       gpointer  user_data)
 {
  /* ... */
 }
 ```
 ### Signal Callbacks
 Signal callbacks generally have the signal name. They should be prefixed with
 `on_`, or suffixed with `_cb`, but not both. For example:
 ```c
 static void
 on_realize (ClutterActor *actor,
            gpointer      user_data)
 {
  /* ... */
 }
 static void
 destroy_cb (ClutterActor *actor,
            gpointer      user_data)
 {
  /* ... */
 }
 ```
 When the callback is named after the object that generated it, and the signal,
 then passive voice is used. For example:
 ```c
 static void
 click_action_clicked_cb (ClutterClickAction *click_action,
                         ClutterActor       *actor,
                         gpointer            user_data)
 {
  /* ... */
 }
 ```
 [gnome-coding-style]: https://developer.gnome.org/programming-guidelines/stable/c-coding-style.html.en
--- a/Makefile.am
+++ b/Makefile.am
@ -0,0 +1,11 @@
 SUBDIRS = cogl clutter data src po doc
 ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
 DISTCLEANFILES = \
 	intltool-extract \
 	intltool-merge \
 	intltool-update \
 	po/stamp-it \
 	po/.intltool-merge-cache
--- a/1277
+++ b/1277
--- a/README.md
+++ b/README.md
@ -1,64 +0,0 @@
 # Mutter
 Mutter is a Wayland display server and X11 window manager and compositor library.
 When used as a Wayland display server, it runs on top of KMS and libinput. It
 implements the compositor side of the Wayland core protocol as well as various
 protocol extensions. It also has functionality related to running X11
 applications using Xwayland.
 When used on top of Xorg it acts as a X11 window manager and compositing manager.
 It contains functionality related to, among other things, window management,
 window compositing, focus tracking, workspace management, keybindings and
 monitor configuration.
 Internally it uses a fork of Cogl, a hardware acceleration abstraction library
 used to simplify usage of OpenGL pipelines, as well as a fork af Clutter, a
 scene graph and user interface toolkit.
 Mutter is used by, for example, GNOME Shell, the GNOME core user interface, and
 by  Gala, elementary OS's window manager. It can also be run standalone, using
 the  command "mutter", but just running plain mutter is only intended for
 debugging purposes.
 ## Contributing
 To contribute, open merge requests at https://gitlab.gnome.org/GNOME/mutter.
 It can be useful to look at the documentation available at the
 [Wiki](https://gitlab.gnome.org/GNOME/mutter/-/wikis/home).
 ## Coding style and conventions
 See [HACKING.md](./HACKING.md).
 ## Git messages
 Commit messages should follow the [GNOME commit message
 guidelines](https://wiki.gnome.org/Git/CommitMessages). We require an URL
 to either an issue or a merge request in each commit. Try to always prefix
 commit subjects with a relevant topic, such as `compositor:` or
 `clutter/actor:`, and it's always better to write too much in the commit
 message body than too little.
 ## Default branch
 The default development branch is `main`. If you still have a local
 checkout under the old name, use:
 ```sh
 git checkout master
 git branch -m master main
 git fetch
 git branch --unset-upstream
 git branch -u origin/main
 git symbolic-ref refs/remotes/origin/HEAD refs/remotes/origin/main
 ```
 ## License
 Mutter is distributed under the terms of the GNU General Public License,
 version 2 or later. See the [COPYING][license] file for detalis.
 [bug-tracker]: https://gitlab.gnome.org/GNOME/mutter/issues
 [license]: COPYING
--- a/autogen.sh
+++ b/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
--- a/check-style.py
+++ b/check-style.py
@ -1,138 +0,0 @@
 #!/bin/env python3
 import argparse
 import os
 import re
 import subprocess
 import sys
 import tempfile
 # Path relative to this script
 uncrustify_cfg = 'tools/uncrustify.cfg'
 def run_diff(sha):
    proc = subprocess.Popen(["git", "diff", "-U0", "--function-context", sha, "HEAD"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    files = proc.stdout.read().strip().decode('utf-8')
    return files.split('\n')
 def find_chunks(diff):
    file_entry_re = re.compile('^\+\+\+ b/(.*)$')
    diff_chunk_re = re.compile('^@@ -\d+,\d+ \+(\d+),(\d+)')
    file = None
    chunks = []
    for line in diff:
        match = file_entry_re.match(line)
        if match:
            file = match.group(1)
        match = diff_chunk_re.match(line)
        if match:
            start = int(match.group(1))
            len = int(match.group(2))
            end = start + len
            if len > 0 and (file.endswith('.c') or file.endswith('.h') or file.endswith('.vala')):
                chunks.append({ 'file': file, 'start': start, 'end': end })
    return chunks
 def reformat_chunks(chunks, rewrite):
    # Creates temp file with INDENT-ON/OFF comments
    def create_temp_file(file, start, end):
        with open(file) as f:
            tmp = tempfile.NamedTemporaryFile()
            tmp.write(b'/** *INDENT-OFF* **/\n')
            for i, line in enumerate(f):
                if i == start - 2:
                    tmp.write(b'/** *INDENT-ON* **/\n')
                tmp.write(bytes(line, 'utf-8'))
                if i == end - 2:
                    tmp.write(b'/** *INDENT-OFF* **/\n')
            tmp.seek(0)
        return tmp
    # Removes uncrustify INDENT-ON/OFF helper comments
    def remove_indent_comments(output):
        tmp = tempfile.NamedTemporaryFile()
        for line in output:
            if line != b'/** *INDENT-OFF* **/\n' and line != b'/** *INDENT-ON* **/\n':
                tmp.write(line)
        tmp.seek(0)
        return tmp
    changed = None
    for chunk in chunks:
        # Add INDENT-ON/OFF comments
        tmp = create_temp_file(chunk['file'], chunk['start'], chunk['end'])
        # uncrustify chunk
        proc = subprocess.Popen(["uncrustify", "-c", uncrustify_cfg, "-f", tmp.name], stdout=subprocess.PIPE)
        reindented = proc.stdout.readlines()
        proc.wait()
        if proc.returncode != 0:
            continue
        tmp.close()
        # Remove INDENT-ON/OFF comments
        formatted = remove_indent_comments(reindented)
        if dry_run is True:
            # Show changes
            proc = subprocess.Popen(["diff", "-up", "--color=always", chunk['file'], formatted.name], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
            diff = proc.stdout.read().decode('utf-8')
            if diff != '':
                output = re.sub('\t', '↦\t', diff)
                print(output)
                changed = True
        else:
            # Apply changes
            diff = subprocess.Popen(["diff", "-up", chunk['file'], formatted.name], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
            patch = subprocess.Popen(["patch", chunk['file']], stdin=diff.stdout)
            diff.stdout.close()
            patch.communicate()
        formatted.close()
    return changed
 parser = argparse.ArgumentParser(description='Check code style.')
 parser.add_argument('--sha', metavar='SHA', type=str,
                    help='SHA for the commit to compare HEAD with')
 parser.add_argument('--dry-run', '-d', type=bool,
                    action=argparse.BooleanOptionalAction,
                    help='Only print changes to stdout, do not change code')
 parser.add_argument('--rewrite', '-r', type=bool,
                    action=argparse.BooleanOptionalAction,
                    help='Whether to amend the result to the last commit (e.g. \'git rebase --exec "%(prog)s -r"\')')
 # Change CWD to script location, necessary for always locating the configuration file
 os.chdir(os.path.dirname(os.path.abspath(sys.argv[0])))
 args = parser.parse_args()
 sha = args.sha or 'HEAD^'
 rewrite = args.rewrite
 dry_run = args.dry_run
 diff = run_diff(sha)
 chunks = find_chunks(diff)
 changed = reformat_chunks(chunks, rewrite)
 if dry_run is not True and rewrite is True:
    proc = subprocess.Popen(["git", "commit", "--all", "--amend", "-C", "HEAD"], stdout=subprocess.DEVNULL)
    os._exit(0)
 elif dry_run is True and changed is True:
    print ("\nIssue the following command in your local tree to apply the suggested changes (needs uncrustify installed):\n\n $ git rebase origin/main --exec \"./check-style.py -r\" \n")
    os._exit(-1)
 os._exit(0)
--- a/clutter/.gitignore
+++ b/clutter/.gitignore
@ -23,6 +23,7 @@ clutter-build-config.h.in
 clutter-config.h
 clutter-enum-types.[ch]
 clutter-marshal.[ch]
 clutter-version.h
 gcov-report.txt
 clutter-json.h
 clutter-lcov.info
--- a/clutter/Makefile.am
+++ b/clutter/Makefile.am
@ -0,0 +1,53 @@
 NULL =
 SUBDIRS = build clutter tests
 if BUILD_EXAMPLES
 SUBDIRS += examples
 endif
 DIST_SUBDIRS = clutter tests examples build
 # XXX - this is a massive hack to make autoreconf honour the ACLOCAL_FLAGS
 # that jhbuild sets while still retaining build/autotools as the authoritative
 # source for m4 macros
 ACLOCAL_AMFLAGS = -I build/autotools ${ACLOCAL_FLAGS}
 CLEANFILES = $(pcfiles)
 DISTCLEANFILES =
 DISTCHECK_CONFIGURE_FLAGS = --enable-maintainer-flags
 # proxy rules for tests
 test-report full-report:
 	$(MAKE) -C tests/conform $(@)
 perf-report:
 	$(MAKE) -C tests/performance $(@)
 if ENABLE_GCOV
 # use recursive makes in order to ignore errors during check/perf
 lcov:
 	-$(MAKE) $(AM_MAKEFLAGS) -C clutter check
 	-$(MAKE) $(AM_MAKEFLAGS) -C tests/conform test
 	$(MAKE) $(AM_MAKEFLAGS) genlcov
 # we have to massage the lcov.info file slightly to hide the effect of libtool
 # placing the objects files in the .libs/ directory separate from the *.c
 genlcov:
 	$(LTP) --directory $(top_builddir) --capture --output-file clutter-lcov.info --test-name CLUTTER_TEST --no-checksum
 	$(SED) -e 's#.libs/##' < clutter-lcov.info > clutter-lcov.info.tmp
 	LANG=C $(LTP_GENHTML) --prefix $(top_builddir) --output-directory clutter-lcov --title "Clutter Code Coverage" --show-details clutter-lcov.info.tmp
 	rm -f clutter-lcov.info.tmp
 lcov-clean:
 	-$(LTP) --directory $(top_builddir) -z
 	-$(RM) -rf clutter-lcov.info clutter-lcov
 else
 lcov genlcov lcov-clean:
 	@echo You need to configure Clutter with support for gcov enabled.
 	@echo e.g., ./configure --enable-gcov
 endif
 .PHONY: test-report full-report perf-report lcov genlcov lcov-clean
--- a/clutter/build/Makefile.am
+++ b/clutter/build/Makefile.am
@ -0,0 +1 @@
 SUBDIRS = autotools
--- a/clutter/build/autotools/.gitignore
+++ b/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
--- a/clutter/build/autotools/Makefile.am
+++ b/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)
--- a/clutter/build/autotools/as-compiler-flag.m4
+++ b/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"
 ])
--- a/clutter/build/autotools/glib-tap.mk
+++ b/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
--- a/clutter/build/autotools/glibtests.m4
+++ b/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
 ])
--- a/clutter/build/autotools/introspection.m4
+++ b/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])
 ])
--- a/clutter/build/autotools/tap-driver.sh
+++ b/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"]="[0;31m" # Red.
    color_map["grn"]="[0;32m" # Green.
    color_map["lgn"]="[1;32m" # Light green.
    color_map["blu"]="[1;34m" # Blue.
    color_map["mgn"]="[0;35m" # Magenta.
    color_map["std"]="[m"     # 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:
--- a/clutter/build/autotools/tap-test
+++ b/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
--- a/clutter/clutter/Makefile.am
+++ b/clutter/clutter/Makefile.am
@ -0,0 +1,727 @@
 AUTOMAKE_OPTIONS = subdir-objects
 # preamble
 NULL =
 # common definitions
 CLEANFILES =
 DISTCLEANFILES =
 EXTRA_DIST =
 BUILT_SOURCES =
 AM_CPPFLAGS = \
 	-DCLUTTER_PREFIX=\""$(prefix)"\"	\
 	-DCLUTTER_LIBDIR=\""$(libdir)"\"	\
 	-DCLUTTER_DATADIR=\""$(datadir)"\"	\
 	-DCLUTTER_LOCALEDIR=\""$(localedir)"\"	\
 	-DCLUTTER_SYSCONFDIR=\""$(sysconfdir)"\" \
 	-DCLUTTER_COMPILATION=1			\
 	-DCOGL_DISABLE_DEPRECATION_WARNINGS	\
 	-DG_LOG_DOMAIN=\"Clutter\" 		\
 	-I$(top_srcdir) 			\
 	-I$(top_srcdir)/clutter			\
 	-I$(top_srcdir)/clutter/cally		\
 	-I$(top_builddir)			\
 	-I$(top_builddir)/clutter		\
 	-I$(top_srcdir)/../cogl			\
 	-I$(top_builddir)/../cogl		\
 	-I$(top_builddir)/../cogl/cogl		\
 	$(CLUTTER_DEPRECATED_CFLAGS)		\
 	$(CLUTTER_DEBUG_CFLAGS)			\
 	$(CLUTTER_HIDDEN_VISIBILITY_CFLAGS)	\
 	$(NULL)
 AM_CFLAGS = $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
 # these are the gir files we generate using g-ir-scanner
 INTROSPECTION_GIRS =
 # the base include path for headers
 clutter_base_includedir = $(includedir)/mutter/clutter-$(LIBMUTTER_API_VERSION)
 clutter_includedir = $(clutter_base_includedir)/clutter
 clutter_deprecateddir = $(clutter_base_includedir)/clutter/deprecated
 # pkg-config files
 pc_files =
 # common sources - please, keep these sorted alphabetically
 source_h =					\
 	clutter-action.h		\
 	clutter-actor-meta.h		\
 	clutter-actor.h		\
 	clutter-align-constraint.h	\
 	clutter-animatable.h          \
 	clutter-backend.h		\
 	clutter-bind-constraint.h	\
 	clutter-binding-pool.h 	\
 	clutter-bin-layout.h		\
 	clutter-blur-effect.h		\
 	clutter-box-layout.h		\
 	clutter-brightness-contrast-effect.h	\
 	clutter-cairo.h		\
 	clutter-canvas.h		\
 	clutter-child-meta.h		\
 	clutter-click-action.h	\
 	clutter-clone.h		\
 	clutter-color-static.h	\
 	clutter-color.h		\
 	clutter-colorize-effect.h	\
 	clutter-constraint.h		\
 	clutter-container.h		\
 	clutter-content.h		\
 	clutter-deform-effect.h	\
 	clutter-deprecated.h		\
 	clutter-desaturate-effect.h	\
 	clutter-device-manager.h	\
 	clutter-drag-action.h		\
 	clutter-drop-action.h		\
 	clutter-effect.h		\
 	clutter-enums.h		\
 	clutter-event.h 		\
 	clutter-feature.h 		\
 	clutter-fixed-layout.h	\
 	clutter-flow-layout.h		\
 	clutter-gesture-action.h 	\
 	clutter-grid-layout.h 	\
 	clutter-group.h 		\
 	clutter-image.h		\
 	clutter-input-device.h	\
 	clutter-input-device-tool.h	\
 	clutter-input-focus.h	\
 	clutter-input-method.h	\
        clutter-interval.h            \
 	clutter-keyframe-transition.h	\
 	clutter-keysyms.h 		\
 	clutter-layout-manager.h	\
 	clutter-layout-meta.h		\
 	clutter-macros.h		\
 	clutter-main.h		\
 	clutter-offscreen-effect.h	\
 	clutter-page-turn-effect.h	\
 	clutter-paint-nodes.h		\
 	clutter-paint-node.h		\
 	clutter-pan-action.h		\
 	clutter-path-constraint.h	\
 	clutter-path.h		\
 	clutter-property-transition.h	\
 	clutter-rotate-action.h	\
 	clutter-script.h		\
 	clutter-scriptable.h		\
 	clutter-scroll-actor.h	\
 	clutter-settings.h		\
 	clutter-shader-effect.h	\
 	clutter-shader-types.h	\
 	clutter-swipe-action.h	\
 	clutter-snap-constraint.h	\
 	clutter-stage.h 		\
 	clutter-stage-manager.h	\
 	clutter-tap-action.h		\
 	clutter-test-utils.h		\
 	clutter-texture.h 		\
 	clutter-text.h		\
 	clutter-text-buffer.h		\
 	clutter-timeline.h 		\
 	clutter-transition-group.h	\
 	clutter-transition.h		\
 	clutter-types.h		\
 	clutter-units.h 		\
 	clutter-virtual-input-device.h	\
 	clutter-zoom-action.h		\
 	$(NULL)
 source_c = \
 	clutter-action.c		\
 	clutter-actor-box.c		\
 	clutter-actor-meta.c		\
 	clutter-actor.c		\
 	clutter-align-constraint.c	\
 	clutter-animatable.c		\
 	clutter-backend.c		\
 	clutter-base-types.c		\
 	clutter-bezier.c		\
 	clutter-bind-constraint.c	\
 	clutter-binding-pool.c	\
 	clutter-bin-layout.c		\
 	clutter-blur-effect.c		\
 	clutter-box-layout.c		\
 	clutter-brightness-contrast-effect.c	\
 	clutter-cairo.c		\
 	clutter-canvas.c		\
 	clutter-child-meta.c		\
 	clutter-click-action.c	\
 	clutter-clone.c		\
 	clutter-color.c 		\
 	clutter-colorize-effect.c	\
 	clutter-constraint.c		\
 	clutter-container.c		\
 	clutter-content.c		\
 	clutter-deform-effect.c	\
 	clutter-desaturate-effect.c	\
 	clutter-device-manager.c	\
 	clutter-drag-action.c		\
 	clutter-drop-action.c		\
 	clutter-effect.c		\
 	clutter-event.c 		\
 	clutter-feature.c 		\
 	clutter-fixed-layout.c	\
 	clutter-flatten-effect.c	\
 	clutter-flow-layout.c		\
 	clutter-gesture-action.c 	\
 	clutter-grid-layout.c 	\
 	clutter-image.c		\
 	clutter-input-device.c	\
 	clutter-input-device-tool.c	\
 	clutter-input-focus.c	\
 	clutter-input-method.c	\
 	clutter-virtual-input-device.c	\
 	clutter-interval.c            \
 	clutter-keyframe-transition.c	\
 	clutter-keysyms-table.c	\
 	clutter-layout-manager.c	\
 	clutter-layout-meta.c		\
 	clutter-main.c 		\
 	clutter-master-clock.c	\
 	clutter-master-clock-default.c	\
 	clutter-offscreen-effect.c	\
 	clutter-page-turn-effect.c	\
 	clutter-paint-nodes.c		\
 	clutter-paint-node.c		\
 	clutter-pan-action.c		\
 	clutter-path-constraint.c	\
 	clutter-path.c		\
 	clutter-property-transition.c	\
 	clutter-rotate-action.c	\
 	clutter-script.c		\
 	clutter-script-parser.c	\
 	clutter-scriptable.c		\
 	clutter-scroll-actor.c	\
 	clutter-settings.c		\
 	clutter-shader-effect.c	\
 	clutter-shader-types.c	\
 	clutter-swipe-action.c	\
 	clutter-snap-constraint.c	\
 	clutter-stage.c		\
 	clutter-stage-manager.c	\
 	clutter-stage-window.c	\
 	clutter-tap-action.c		\
 	clutter-test-utils.c		\
 	clutter-text.c		\
 	clutter-text-buffer.c		\
 	clutter-transition-group.c	\
 	clutter-transition.c		\
 	clutter-timeline.c 		\
 	clutter-units.c		\
 	clutter-util.c 		\
 	clutter-paint-volume.c 	\
 	clutter-zoom-action.c 	\
 	$(NULL)
 # private headers; these should not be distributed or introspected
 source_h_priv = \
 	clutter-actor-meta-private.h		\
 	clutter-actor-private.h			\
 	clutter-backend-private.h		\
 	clutter-bezier.h			\
 	clutter-constraint-private.h		\
 	clutter-content-private.h		\
 	clutter-debug.h 			\
 	clutter-device-manager-private.h	\
 	clutter-easing.h			\
 	clutter-effect-private.h		\
 	clutter-event-translator.h		\
 	clutter-event-private.h			\
 	clutter-flatten-effect.h		\
 	clutter-gesture-action-private.h	\
 	clutter-id-pool.h 			\
 	clutter-input-focus-private.h		\
 	clutter-input-method-private.h		\
 	clutter-master-clock.h			\
 	clutter-master-clock-default.h		\
 	clutter-offscreen-effect-private.h	\
 	clutter-paint-node-private.h		\
 	clutter-paint-volume-private.h		\
 	clutter-private.h 			\
 	clutter-script-private.h		\
 	clutter-settings-private.h		\
 	clutter-stage-manager-private.h		\
 	clutter-stage-private.h			\
 	clutter-stage-view.h			\
 	clutter-stage-window.h			\
 	$(NULL)
 # private source code; these should not be introspected
 source_c_priv = \
 	clutter-easing.c		\
 	clutter-event-translator.c	\
 	clutter-id-pool.c 		\
 	clutter-stage-view.c		\
 	$(NULL)
 # deprecated installed headers
 deprecated_h = \
 	deprecated/clutter-actor.h			\
 	deprecated/clutter-alpha.h 			\
 	deprecated/clutter-animatable.h		\
 	deprecated/clutter-animation.h		\
 	deprecated/clutter-animator.h			\
 	deprecated/clutter-backend.h			\
 	deprecated/clutter-behaviour.h 		\
 	deprecated/clutter-behaviour-depth.h 		\
 	deprecated/clutter-behaviour-ellipse.h	\
 	deprecated/clutter-behaviour-opacity.h 	\
 	deprecated/clutter-behaviour-path.h 		\
 	deprecated/clutter-behaviour-rotate.h 	\
 	deprecated/clutter-behaviour-scale.h 		\
 	deprecated/clutter-bin-layout.h		\
 	deprecated/clutter-box.h			\
 	deprecated/clutter-cairo-texture.h		\
 	deprecated/clutter-container.h		\
 	deprecated/clutter-frame-source.h		\
 	deprecated/clutter-group.h			\
 	deprecated/clutter-input-device.h		\
 	deprecated/clutter-keysyms.h			\
 	deprecated/clutter-list-model.h			\
 	deprecated/clutter-main.h			\
 	deprecated/clutter-media.h			\
 	deprecated/clutter-model.h			\
 	deprecated/clutter-rectangle.h		\
 	deprecated/clutter-score.h 			\
 	deprecated/clutter-shader.h 			\
 	deprecated/clutter-stage-manager.h		\
 	deprecated/clutter-stage.h			\
 	deprecated/clutter-state.h			\
 	deprecated/clutter-table-layout.h		\
 	deprecated/clutter-texture.h			\
 	deprecated/clutter-timeline.h 		\
 	deprecated/clutter-timeout-pool.h 		\
 	deprecated/clutter-util.h 			\
 	$(NULL)
 # deprecated source code
 deprecated_c = \
 	deprecated/clutter-actor-deprecated.c		\
 	deprecated/clutter-alpha.c 			\
 	deprecated/clutter-animation.c		\
 	deprecated/clutter-animator.c			\
 	deprecated/clutter-behaviour.c 		\
 	deprecated/clutter-behaviour-depth.c		\
 	deprecated/clutter-behaviour-ellipse.c	\
 	deprecated/clutter-behaviour-opacity.c	\
 	deprecated/clutter-behaviour-path.c		\
 	deprecated/clutter-behaviour-rotate.c		\
 	deprecated/clutter-behaviour-scale.c		\
 	deprecated/clutter-box.c			\
 	deprecated/clutter-cairo-texture.c		\
 	deprecated/clutter-frame-source.c		\
 	deprecated/clutter-group.c 			\
 	deprecated/clutter-input-device-deprecated.c	\
 	deprecated/clutter-layout-manager-deprecated.c \
 	deprecated/clutter-list-model.c			\
 	deprecated/clutter-media.c			\
 	deprecated/clutter-model.c			\
 	deprecated/clutter-rectangle.c 		\
 	deprecated/clutter-score.c 			\
 	deprecated/clutter-shader.c 			\
 	deprecated/clutter-state.c			\
 	deprecated/clutter-table-layout.c		\
 	deprecated/clutter-texture.c 			\
 	deprecated/clutter-timeout-pool.c		\
 	$(NULL)
 # deprecated private headers; these should not be installed
 deprecated_h_priv = \
 	deprecated/clutter-model-private.h	\
 	deprecated/clutter-timeout-interval.h	\
 	$(NULL)
 # deprecated private source code; these should not be introspected
 deprecated_c_priv = \
 	deprecated/clutter-timeout-interval.c	\
 	$(NULL)
 # built sources
 built_source_c = \
 	clutter-enum-types.c			\
 	clutter-marshal.c			\
 	$(NULL)
 # built headers
 built_source_h = \
 	clutter-enum-types.h			\
 	clutter-marshal.h			\
 	$(NULL)
 # config header
 DISTCLEANFILES += clutter-config.h
 EXTRA_DIST += clutter-config.h.in
 # version header
 DISTCLEANFILES += clutter-version.h
 EXTRA_DIST += clutter-version.h.in clutter-version.h
 # key symbol update script
 EXTRA_DIST += clutter-keysyms-update.pl
 pc_files += mutter-clutter-$(LIBMUTTER_API_VERSION).pc
 # in order to be compatible with Clutter < 1.10, when we shipped a single
 # shared library whose name was determined by the single backend it
 # supported, we need to install symbolic links so that existing applications
 # using Clutter won't break in the Brave New World of multi-backend support
 # in the same shared object.
 compat_libs =
 # backends source listings
 #
 #   backend_source_c := source code
 #   backend_source_h := installed public headers
 #   backend_source_c_priv := source that should not be scanned by g-i
 #   backend_source_h_priv := private headers
 #   backend_source_built := built sources
 #
 backend_source_c =
 backend_source_h =
 backend_source_c_priv =
 backend_source_h_priv =
 backend_source_built =
 # X11 backend rules
 x11_source_c = \
 	x11/clutter-backend-x11.c		\
 	x11/clutter-device-manager-core-x11.c	\
 	x11/clutter-event-x11.c		\
 	x11/clutter-input-device-core-x11.c	\
 	x11/clutter-keymap-x11.c		\
 	x11/clutter-stage-x11.c		\
 	x11/clutter-x11-texture-pixmap.c	\
 	x11/clutter-xkb-a11y-x11.c		\
 	$(NULL)
 x11_source_h = \
 	x11/clutter-x11.h			\
 	x11/clutter-x11-texture-pixmap.h	\
 	$(NULL)
 x11_source_h_priv = \
 	x11/clutter-backend-x11.h		\
 	x11/clutter-device-manager-core-x11.h	\
 	x11/clutter-input-device-core-x11.h	\
 	x11/clutter-keymap-x11.h		\
 	x11/clutter-settings-x11.h		\
 	x11/clutter-stage-x11.h		\
 	x11/clutter-xkb-a11y-x11.h		\
 	$(NULL)
 x11_source_c_priv = \
 	x11/xsettings/xsettings-client.c	\
 	x11/xsettings/xsettings-client.h	\
 	x11/xsettings/xsettings-common.c	\
 	x11/xsettings/xsettings-common.h	\
 	$(NULL)
 x11_source_c += \
 	x11/clutter-device-manager-xi2.c	\
 	x11/clutter-input-device-xi2.c	\
 	x11/clutter-input-device-tool-xi2.c \
 	$(NULL)
 x11_source_h_priv += \
 	x11/clutter-device-manager-xi2.h	\
 	x11/clutter-input-device-xi2.h	\
 	x11/clutter-input-device-tool-xi2.h \
 	$(NULL)
 x11_source_c += \
 	x11/clutter-virtual-input-device-x11.c	\
 	$(NULL)
 x11_source_h_priv += \
 	x11/clutter-virtual-input-device-x11.h	\
 	$(NULL)
 backend_source_h += $(x11_source_h)
 backend_source_c += $(x11_source_c)
 backend_source_h_priv += $(x11_source_h_priv)
 backend_source_c_priv += $(x11_source_c_priv)
 # the list of files we want to introspect on X11
 x11_introspection = $(x11_source_c) $(x11_source_h)
 clutterx11_includedir = $(clutter_includedir)/x11
 clutterx11_include_HEADERS = $(x11_source_h)
 mutter-clutter-x11-@LIBMUTTER_API_VERSION@.pc: mutter-clutter-$(LIBMUTTER_API_VERSION).pc
 	$(QUIET_GEN)cp -f $< $(@F)
 pc_files += mutter-clutter-x11-$(LIBMUTTER_API_VERSION).pc
 # Shared cogl backend files
 cogl_source_h =
 cogl_source_c = \
 	cogl/clutter-stage-cogl.c	\
 	$(NULL)
 cogl_source_h_priv = \
 	cogl/clutter-stage-cogl.h	\
 	$(NULL)
 cogl_source_c_priv =
 backend_source_h += $(cogl_source_h)
 backend_source_c += $(cogl_source_c)
 backend_source_h_priv += $(cogl_source_h_priv)
 backend_source_c_priv += $(cogl_source_c_priv)
 backend_source_h += $(glx_source_h)
 backend_source_c += $(glx_source_c)
 evdev_c_priv = \
 	evdev/clutter-device-manager-evdev.c	\
 	evdev/clutter-input-device-evdev.c	\
 	evdev/clutter-seat-evdev.c		\
 	evdev/clutter-virtual-input-device-evdev.c	\
 	evdev/clutter-event-evdev.c		\
 	evdev/clutter-input-device-tool-evdev.c	\
 	$(NULL)
 evdev_h_priv = \
 	evdev/clutter-device-manager-evdev.h	\
 	evdev/clutter-input-device-evdev.h	\
 	evdev/clutter-seat-evdev.h		\
 	evdev/clutter-input-device-tool-evdev.h	\
 	evdev/clutter-virtual-input-device-evdev.h	\
 	$(NULL)
 evdev_h = evdev/clutter-evdev.h
 if SUPPORT_WAYLAND
 backend_source_c_priv += $(evdev_c_priv)
 backend_source_h_priv += $(evdev_h_priv)
 backend_source_h += $(evdev_h)
 clutterevdev_includedir = $(clutter_includedir)/evdev
 clutterevdev_include_HEADERS = $(evdev_h)
 backend_source_c += evdev/clutter-xkb-utils.c
 backend_source_h_priv += evdev/clutter-xkb-utils.h
 # EGL backend rules
 egl_source_h = \
 	egl/clutter-egl-headers.h	\
 	egl/clutter-egl.h		\
 	$(NULL)
 egl_source_h_priv = egl/clutter-backend-eglnative.h
 egl_source_c = egl/clutter-backend-eglnative.c
 wayland_compositor_source_h = \
 	wayland/clutter-wayland-compositor.h		\
 	wayland/clutter-wayland-surface.h
 backend_source_h += $(wayland_compositor_source_h)
 backend_source_c += \
 	wayland/clutter-wayland-surface.c
 wayland_compositor_includedir = $(clutter_includedir)/wayland
 wayland_compositor_include_HEADERS = $(wayland_compositor_source_h)
 backend_source_h += $(egl_source_h)
 backend_source_c += $(egl_source_c)
 backend_source_h_priv += $(egl_source_h_priv)
 clutteregl_includedir = $(clutter_includedir)/egl
 clutteregl_include_HEADERS = $(egl_source_h)
 endif # SUPPORT_WAYLAND
 # cally
 cally_sources_h = \
 	cally/cally-actor.h		\
 	cally/cally-clone.h		\
 	cally/cally-factory.h		\
 	cally/cally-group.h		\
 	cally/cally.h			\
 	cally/cally-main.h		\
 	cally/cally-rectangle.h	\
 	cally/cally-root.h		\
 	cally/cally-stage.h		\
 	cally/cally-text.h		\
 	cally/cally-texture.h		\
 	cally/cally-util.h		\
 	$(NULL)
 cally_sources_c = \
 	cally/cally-actor.c		\
 	cally/cally.c			\
 	cally/cally-clone.c		\
 	cally/cally-group.c		\
 	cally/cally-rectangle.c	\
 	cally/cally-root.c		\
 	cally/cally-stage.c		\
 	cally/cally-text.c		\
 	cally/cally-texture.c		\
 	cally/cally-util.c		\
 	$(NULL)
 cally_sources_private = \
 	cally/cally-actor-private.h	\
 	$(NULL)
 cally_includedir = $(clutter_base_includedir)/cally
 cally_include_HEADERS = $(cally_sources_h)
 # general build rules:
 # you should not need to modify anything below this point
 # glib-genmarshal rules
 glib_marshal_list = clutter-marshal.list
 glib_marshal_prefix = _clutter_marshal
 include $(srcdir)/Makefile.am.marshal
 # glib-mkenums rules
 glib_enum_h = clutter-enum-types.h
 glib_enum_c = clutter-enum-types.c
 glib_enum_headers = $(source_h) $(deprecated_h)
 include $(srcdir)/Makefile.am.enums
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = $(pc_files)
 DISTCLEANFILES += $(pc_files)
 clutter_include_HEADERS = $(source_h) clutter.h clutter-version.h clutter-autocleanups.h clutter-mutter.h
 nodist_clutter_include_HEADERS = clutter-config.h $(built_source_h)
 clutter_deprecated_HEADERS = $(deprecated_h)
 mutterlibdir = $(libdir)/mutter
 mutterlib_LTLIBRARIES = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
 libmutter_clutter_@LIBMUTTER_API_VERSION@_la_LIBADD = \
 	$(LIBM) \
 	$(CLUTTER_LIBS) \
 	$(top_builddir)/../cogl/cogl/libmutter-cogl-$(LIBMUTTER_API_VERSION).la \
 	$(top_builddir)/../cogl/cogl-pango/libmutter-cogl-pango-$(LIBMUTTER_API_VERSION).la \
 	$(top_builddir)/../cogl/cogl-path/libmutter-cogl-path-$(LIBMUTTER_API_VERSION).la \
 	$(NULL)
 libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
 	$(backend_source_c) \
 	$(backend_source_h) \
 	$(backend_source_c_priv) \
 	$(backend_source_h_priv) \
 	$(source_c) \
 	$(source_h) \
 	$(source_c_priv) \
 	$(source_h_priv) \
 	$(deprecated_c) \
 	$(deprecated_h) \
 	$(deprecated_c_priv) \
 	$(deprecated_h_priv) \
 	$(cally_sources_c) \
 	$(cally_sources_h) \
 	$(cally_sources_private) \
 	$(NULL)
 nodist_libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
 	$(backend_source_built) \
 	$(built_source_c) \
 	$(built_source_h)
 libmutter_clutter_@LIBMUTTER_API_VERSION@_la_LDFLAGS = \
 	$(CLUTTER_LINK_FLAGS) \
 	$(CLUTTER_LT_LDFLAGS) \
 	-export-dynamic \
 	-rpath $(mutterlibdir) \
 	$(NULL)
 install-exec-local:
 	test -z "$(mutterlibdir)" || $(MKDIR_P) "$(DESTDIR)$(mutterlibdir)"
 	for lib in `echo $(compat_libs)`; do \
 	  (cd $(DESTDIR)$(mutterlibdir) && \
 	    rm -f $$lib.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION); \
 	  ) ; \
 	  (cd $(DESTDIR)$(mutterlibdir) && \
 	    { ln -s -f libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib.0 || \
 	      { rm -f $$lib.0 && ln -s libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib.0; }; \
 	    } \
 	  ) ; \
 	  (cd $(DESTDIR)$(mutterlibdir) && \
 	    { ln -s -f libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib || \
 	      { rm -f $$lib && ln -s libmutter-clutter-$(LIBMUTTER_API_VERSION).so.0.$(CLUTTER_LT_CURRENT).$(CLUTTER_LT_REVISION) $$lib; }; \
 	    } \
 	  ) ; \
 	done
 # gobject-introspection rules
 -include $(INTROSPECTION_MAKEFILE)
 INTROSPECTION_SCANNER_ARGS = \
 	--add-include-path=$(top_builddir)/../cogl/cogl \
 	--add-include-path=$(top_builddir)/../cogl/cogl-pango
 INTROSPECTION_COMPILER_ARGS = \
 	--includedir=$(top_builddir)/../cogl/cogl \
 	--includedir=$(top_builddir)/../cogl/cogl-pango
 INTROSPECTION_SCANNER_ENV = \
 	PKG_CONFIG_PATH=$(top_builddir)/../cogl/cogl/:$(top_builddir)/../cogl/cogl-pango/:$${PKG_CONFIG_PATH}
 Clutter-@LIBMUTTER_API_VERSION@.gir: libmutter-clutter-@LIBMUTTER_API_VERSION@.la Makefile
 Clutter_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = Clutter
 Clutter_@LIBMUTTER_API_VERSION@_gir_VERSION = @LIBMUTTER_API_VERSION@
 Clutter_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
 Clutter_@LIBMUTTER_API_VERSION@_gir_FILES = \
 	$(clutter_include_HEADERS) \
 	$(clutter_deprecated_HEADERS) \
 	$(nodist_clutter_include_HEADERS) \
 	$(source_c) \
 	$(deprecated_c) \
 	$(built_source_c)
 Clutter_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
 Clutter_@LIBMUTTER_API_VERSION@_gir_INCLUDES = GL-1.0 GObject-2.0 cairo-1.0 Cogl-@LIBMUTTER_API_VERSION@ CoglPango-@LIBMUTTER_API_VERSION@ Atk-1.0 Json-1.0
 Clutter_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
 	--warn-all \
 	--c-include='clutter/clutter.h' \
 	--pkg-export=mutter-clutter-@LIBMUTTER_API_VERSION@
 INTROSPECTION_GIRS += Clutter-@LIBMUTTER_API_VERSION@.gir
 Cally-@LIBMUTTER_API_VERSION@.gir: Makefile Clutter-@LIBMUTTER_API_VERSION@.gir
 Cally_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = Cally
 Cally_@LIBMUTTER_API_VERSION@_gir_VERSION = @LIBMUTTER_API_VERSION@
 Cally_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
 Cally_@LIBMUTTER_API_VERSION@_gir_FILES = $(cally_sources_h) $(cally_sources_c)
 Cally_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
 Cally_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
 	--warn-all \
 	--c-include='cally/cally.h' \
 	--pkg-export=mutter-clutter-@LIBMUTTER_API_VERSION@ \
 	--include-uninstalled=$(top_builddir)/clutter/Clutter-@LIBMUTTER_API_VERSION@.gir
 INTROSPECTION_GIRS += Cally-@LIBMUTTER_API_VERSION@.gir
 ClutterX11-@LIBMUTTER_API_VERSION@.gir: Makefile Clutter-@LIBMUTTER_API_VERSION@.gir
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_NAMESPACE = ClutterX11
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_INCLUDES = xlib-2.0
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_LIBS = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_FILES = $(x11_introspection)
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS)
 ClutterX11_@LIBMUTTER_API_VERSION@_gir_SCANNERFLAGS = \
 	--warn-all \
 	--c-include='clutter/x11/clutter-x11.h' \
 	--pkg-export=mutter-clutter-x11-@LIBMUTTER_API_VERSION@ \
 	--include-uninstalled=$(top_builddir)/clutter/Clutter-@LIBMUTTER_API_VERSION@.gir
 INTROSPECTION_GIRS += ClutterX11-@LIBMUTTER_API_VERSION@.gir
 # INTROSPECTION_GIRDIR/INTROSPECTION_TYPELIBDIR aren't the right place to
 # install anything - we need to install inside our prefix.
 girdir = $(mutterlibdir)
 gir_DATA = $(INTROSPECTION_GIRS)
 typelibdir = $(mutterlibdir)
 typelib_DATA = $(INTROSPECTION_GIRS:.gir=.typelib)
 EXTRA_DIST += \
 	Makefile.am.marshal	\
 	Makefile.am.enums
 CLEANFILES += $(gir_DATA) $(typelib_DATA)
--- a/clutter/clutter/Makefile.am.enums
+++ b/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
--- a/clutter/clutter/Makefile.am.marshal
+++ b/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
--- a/clutter/clutter/cally/cally-actor-private.h
+++ b/clutter/clutter/cally/cally-actor-private.h
@ -28,7 +28,7 @@
 #include "cally-actor.h"
 /*
- * Auxiliary define, in order to get the clutter actor from the AtkObject using
+ * Auxiliar define, in order to get the clutter actor from the AtkObject using
 * AtkGObject methods
 *
 */
--- a/clutter/clutter/cally/cally-actor.c
+++ b/clutter/clutter/cally/cally-actor.c
@ -67,12 +67,16 @@
 *
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <glib.h>
 #include <clutter/clutter.h>
-#include "clutter/clutter-actor-private.h"
+#ifdef CLUTTER_WINDOWING_X11
 #include <clutter/x11/clutter-x11.h>
 #endif
 #include <math.h>
@ -308,7 +312,11 @@ cally_actor_finalize (GObject *obj)
  _cally_actor_clean_action_list (cally_actor);
-  g_clear_handle_id (&priv->action_idle_handler, g_source_remove);
+  if (priv->action_idle_handler)
    {
      g_source_remove (priv->action_idle_handler);
      priv->action_idle_handler = 0;
    }
  if (priv->action_queue)
    {
@ -598,11 +606,10 @@ cally_actor_real_remove_actor (ClutterActor *container,
  g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), 0);
  atk_parent = ATK_OBJECT (data);
  atk_child = clutter_actor_get_accessible (actor);
-  if (clutter_actor_has_accessible (actor))
+  if (atk_child)
    {
      atk_child = clutter_actor_get_accessible (actor);
      g_value_init (&values.old_value, G_TYPE_POINTER);
      g_value_set_pointer (&values.old_value, atk_parent);
@ -652,7 +659,7 @@ cally_actor_get_extents (AtkComponent *component,
  ClutterActor *actor      = NULL;
  gint          top_level_x, top_level_y;
  gfloat        f_width, f_height;
-  graphene_point3d_t verts[4];
+  ClutterVertex verts[4];
  ClutterActor  *stage = NULL;
  g_return_if_fail (CALLY_IS_ACTOR (component));
@ -732,7 +739,11 @@ cally_actor_grab_focus (AtkComponent    *component)
 *
 * This gets the top level origin, it is, the position of the stage in
 * the global screen. You can see it as the absolute display position
- * of the stage. This is 0,0 for a compositor.
+ * of the stage.
 *
 * FIXME: only the case with x11 is implemented, other backends are
 * required
 *
 */
 void
 _cally_actor_get_top_level_origin (ClutterActor *actor,
@ -740,11 +751,54 @@ _cally_actor_get_top_level_origin (ClutterActor *actor,
                                   gint         *yp)
 {
  /* default values */
  gint x = 0;
  gint y = 0;
 #ifdef CLUTTER_WINDOWING_X11
  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
    {
      ClutterActor *stage      = NULL;
      Display *display    = NULL;
      Window root_window;
      Window stage_window;
      Window child;
      gint return_val = 0;
      stage = clutter_actor_get_stage (actor);
      /* FIXME: what happens if you use another display with
         clutter_backend_x11_set_display ?*/
      display = clutter_x11_get_default_display ();
      root_window = clutter_x11_get_root_window ();
      stage_window = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));
      return_val = XTranslateCoordinates (display, stage_window, root_window,
                                          0, 0, &x, &y,
                                          &child);
      if (!return_val)
        g_warning ("[x11] We were not able to get proper absolute "
                   "position of the stage");
    }
  else
 #endif
    {
      static gboolean yet_warned = FALSE;
      if (!yet_warned)
        {
          yet_warned = TRUE;
          g_warning ("The current Clutter backend does not support using "
                     "atk_component_get_extents() with ATK_XY_SCREEN.");
        }
    }
  if (xp)
-    *xp = 0;
+    *xp = x;
  if (yp)
-    *yp = 0;
+    *yp = y;
 }
 /* AtkAction implementation */
@ -765,11 +819,10 @@ static gboolean
 cally_actor_action_do_action (AtkAction *action,
                             gint       index)
 {
-  CallyActor *cally_actor = NULL;
+  CallyActor           *cally_actor = NULL;
-  AtkStateSet *set = NULL;
+  AtkStateSet          *set         = NULL;
-  CallyActorPrivate *priv = NULL;
+  CallyActorPrivate    *priv        = NULL;
-  CallyActorActionInfo *info = NULL;
+  CallyActorActionInfo *info        = NULL;
  gboolean did_action = FALSE;
  cally_actor = CALLY_ACTOR (action);
  priv = cally_actor->priv;
@ -777,19 +830,21 @@ cally_actor_action_do_action (AtkAction *action,
  set = atk_object_ref_state_set (ATK_OBJECT (cally_actor));
  if (atk_state_set_contains_state (set, ATK_STATE_DEFUNCT))
-    goto out;
+    return FALSE;
  if (!atk_state_set_contains_state (set, ATK_STATE_SENSITIVE) ||
      !atk_state_set_contains_state (set, ATK_STATE_SHOWING))
-    goto out;
+    return FALSE;
  g_object_unref (set);
  info = _cally_actor_get_action_info (cally_actor, index);
  if (info == NULL)
-    goto out;
+    return FALSE;
  if (info->do_action_func == NULL)
-    goto out;
+    return FALSE;
  if (!priv->action_queue)
    priv->action_queue = g_queue_new ();
@ -799,12 +854,7 @@ cally_actor_action_do_action (AtkAction *action,
  if (!priv->action_idle_handler)
    priv->action_idle_handler = g_idle_add (idle_do_action, cally_actor);
-  did_action = TRUE;
+  return TRUE;
 out:
  g_clear_object (&set);
  return did_action;
 }
 static gboolean
@ -970,7 +1020,7 @@ cally_actor_real_notify_clutter (GObject    *obj,
       * paint it; we don't want this to generate an ATK
       * state change
       */
-      if (clutter_actor_is_painting_unmapped (actor))
+      if (clutter_actor_is_in_clone_paint (actor))
        return;
      state = ATK_STATE_SHOWING;
@ -996,8 +1046,10 @@ _cally_actor_clean_action_list (CallyActor *cally_actor)
  if (priv->action_list)
    {
-      g_list_free_full (priv->action_list,
+      g_list_foreach (priv->action_list,
-                        (GDestroyNotify) _cally_actor_destroy_action_info);
+                      (GFunc) _cally_actor_destroy_action_info,
                      NULL);
      g_list_free (priv->action_list);
      priv->action_list = NULL;
    }
 }
@ -1086,7 +1138,7 @@ cally_actor_add_action_full (CallyActor          *cally_actor,
  priv = cally_actor->priv;
-  info = g_new0 (CallyActorActionInfo, 1);
+  info = g_slice_new (CallyActorActionInfo);
  info->name = g_strdup (action_name);
  info->description = g_strdup (action_description);
  info->keybinding = g_strdup (action_keybinding);
@ -1106,7 +1158,7 @@ cally_actor_add_action_full (CallyActor          *cally_actor,
 *
 * Removes a action, using the @action_id returned by cally_actor_add_action()
 *
- * Return value: %TRUE if the operation was successful, %FALSE otherwise
+ * Return value: %TRUE if the operation was succesful, %FALSE otherwise
 *
 * Since: 1.4
 */
@ -1140,7 +1192,7 @@ cally_actor_remove_action (CallyActor *cally_actor,
 * Removes an action, using the @action_name used when the action was added
 * with cally_actor_add_action()
 *
- * Return value: %TRUE if the operation was successful, %FALSE otherwise
+ * Return value: %TRUE if the operation was succesful, %FALSE otherwise
 *
 * Since: 1.4
 */
@ -1191,5 +1243,5 @@ _cally_actor_destroy_action_info (gpointer action_info,
  if (info->notify)
    info->notify (info->user_data);
-  g_free (info);
+  g_slice_free (CallyActorActionInfo, info);
 }
--- a/clutter/clutter/cally/cally-actor.h
+++ b/clutter/clutter/cally/cally-actor.h
@ -126,19 +126,19 @@ struct _CallyActorClass
  gpointer _padding_dummy[32];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_actor_get_type              (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_actor_new                   (ClutterActor        *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 guint      cally_actor_add_action            (CallyActor          *cally_actor,
                                              const gchar         *action_name,
                                              const gchar         *action_description,
                                              const gchar         *action_keybinding,
                                              CallyActionFunc      action_func);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 guint      cally_actor_add_action_full       (CallyActor          *cally_actor,
                                              const gchar         *action_name,
                                              const gchar         *action_description,
@ -147,11 +147,11 @@ guint      cally_actor_add_action_full       (CallyActor          *cally_actor,
                                              gpointer             user_data,
                                              GDestroyNotify       notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean   cally_actor_remove_action         (CallyActor          *cally_actor,
                                              gint                 action_id);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean   cally_actor_remove_action_by_name (CallyActor          *cally_actor,
                                              const gchar         *action_name);
--- a/clutter/clutter/cally/cally-clone.h
+++ b/clutter/clutter/cally/cally-clone.h
@ -74,9 +74,9 @@ struct _CallyCloneClass
  gpointer _padding_dummy[8];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_clone_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_clone_new      (ClutterActor *actor);
 G_END_DECLS
--- a/clutter/clutter/cally/cally-group.c
+++ b/clutter/clutter/cally/cally-group.c
@ -0,0 +1,147 @@
 /* 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;
 }
--- a/clutter/clutter/cally/cally-group.h
+++ b/clutter/clutter/cally/cally-group.h
@ -0,0 +1,87 @@
 /* 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_AVAILABLE_IN_1_4
 GType      cally_group_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_group_new      (ClutterActor *actor);
 G_END_DECLS
 #endif /* __CALLY_GROUP_H__ */
--- a/clutter/clutter/cally/cally-main.h
+++ b/clutter/clutter/cally/cally-main.h
@ -34,9 +34,9 @@
 G_BEGIN_DECLS
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean cally_get_cally_initialized (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean cally_accessibility_init    (void);
 G_END_DECLS
--- a/clutter/clutter/cally/cally-rectangle.c
+++ b/clutter/clutter/cally/cally-rectangle.c
@ -0,0 +1,98 @@
 /* CALLY - The Clutter Accessibility Implementation Library
 *
 * Copyright (C) 2009 Igalia, S.L.
 *
 * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
 *
 * 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-rectangle
 * @short_description: Implementation of the ATK interfaces for a #ClutterRectangle
 * @see_also: #ClutterRectangle
 *
 * #CallyRectangle implements the required ATK interfaces of #ClutterRectangle
 *
 * In particular it sets a proper role for the rectangle.
 */
 #include "clutter-build-config.h"
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "cally-rectangle.h"
 #include "cally-actor-private.h"
 #include "clutter-color.h"
 #include "deprecated/clutter-rectangle.h"
 /* AtkObject */
 static void                  cally_rectangle_real_initialize (AtkObject *obj,
                                                              gpointer   data);
 G_DEFINE_TYPE (CallyRectangle, cally_rectangle, CALLY_TYPE_ACTOR)
 static void
 cally_rectangle_class_init (CallyRectangleClass *klass)
 {
 /*   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass); */
  AtkObjectClass *class         = ATK_OBJECT_CLASS (klass);
  class->initialize      = cally_rectangle_real_initialize;
 }
 static void
 cally_rectangle_init (CallyRectangle *rectangle)
 {
  /* nothing to do yet */
 }
 /**
 * cally_rectangle_new:
 * @actor: a #ClutterActor
 *
 * Creates a new #CallyRectangle for the given @actor. @actor must be
 * a #ClutterRectangle.
 *
 * Return value: the newly created #AtkObject
 *
 * Since: 1.4
 */
 AtkObject*
 cally_rectangle_new (ClutterActor *actor)
 {
  GObject   *object     = NULL;
  AtkObject *accessible = NULL;
  g_return_val_if_fail (CLUTTER_IS_RECTANGLE (actor), NULL);
  object = g_object_new (CALLY_TYPE_RECTANGLE, NULL);
  accessible = ATK_OBJECT (object);
  atk_object_initialize (accessible, actor);
  return accessible;
 }
 static void
 cally_rectangle_real_initialize (AtkObject *obj,
                                 gpointer   data)
 {
  ATK_OBJECT_CLASS (cally_rectangle_parent_class)->initialize (obj, data);
  obj->role = ATK_ROLE_IMAGE;
 }
--- a/clutter/clutter/cally/cally-rectangle.h
+++ b/clutter/clutter/cally/cally-rectangle.h
@ -0,0 +1,84 @@
 /* CALLY - The Clutter Accessibility Implementation Library
 *
 * Copyright (C) 2009 Igalia, S.L.
 *
 * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
 *
 * 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_RECTANGLE_H__
 #define __CALLY_RECTANGLE_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_RECTANGLE            (cally_rectangle_get_type ())
 #define CALLY_RECTANGLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_RECTANGLE, CallyRectangle))
 #define CALLY_RECTANGLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_RECTANGLE, CallyRectangleClass))
 #define CALLY_IS_RECTANGLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_RECTANGLE))
 #define CALLY_IS_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_RECTANGLE))
 #define CALLY_RECTANGLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_RECTANGLE, CallyRectangleClass))
 typedef struct _CallyRectangle         CallyRectangle;
 typedef struct _CallyRectangleClass    CallyRectangleClass;
 typedef struct _CallyRectanglePrivate  CallyRectanglePrivate;
 /**
 * CallyRectangle:
 *
 * The <structname>CallyRectangle</structname> structure contains only private
 * data and should be accessed using the provided API
 *
 * Since: 1.4
 */
 struct _CallyRectangle
 {
  /*< private >*/
  CallyActor parent;
  CallyRectanglePrivate *priv;
 };
 /**
 * CallyRectangleClass:
 *
 * The <structname>CallyRectangleClass</structname> structure contains
 * only private data
 *
 * Since: 1.4
 */
 struct _CallyRectangleClass
 {
  /*< private >*/
  CallyActorClass parent_class;
  /* padding for future expansion */
  gpointer _padding_dummy[8];
 };
 CLUTTER_AVAILABLE_IN_1_4
 GType      cally_rectangle_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_rectangle_new      (ClutterActor *actor);
 G_END_DECLS
 #endif /* __CALLY_RECTANGLE_H__ */
--- a/clutter/clutter/cally/cally-root.c
+++ b/clutter/clutter/cally/cally-root.c
@ -75,8 +75,8 @@ struct _CallyRootPrivate
  GSList *stage_list;
  /* signals id */
-  gulong stage_added_id;
+  guint stage_added_id;
-  gulong stage_removed_id;
+  guint stage_removed_id;
 };
 G_DEFINE_TYPE_WITH_PRIVATE (CallyRoot, cally_root,  ATK_TYPE_GOBJECT_ACCESSIBLE)
@ -149,9 +149,11 @@ cally_root_finalize (GObject *object)
  stage_manager = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (root));
-  g_clear_signal_handler (&root->priv->stage_added_id, stage_manager);
+  g_signal_handler_disconnect (stage_manager,
                               root->priv->stage_added_id);
-  g_clear_signal_handler (&root->priv->stage_removed_id, stage_manager);
+  g_signal_handler_disconnect (stage_manager,
                               root->priv->stage_added_id);
  G_OBJECT_CLASS (cally_root_parent_class)->finalize (object);
 }
--- a/clutter/clutter/cally/cally-root.h
+++ b/clutter/clutter/cally/cally-root.h
@ -74,9 +74,9 @@ struct _CallyRootClass
  gpointer _padding_dummy[16];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_root_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_root_new      (void);
 G_END_DECLS
--- a/clutter/clutter/cally/cally-stage.c
+++ b/clutter/clutter/cally/cally-stage.c
@ -47,7 +47,7 @@ static AtkStateSet*          cally_stage_ref_state_set   (AtkObject *obj);
 /* AtkWindow */
 static void                  cally_stage_window_interface_init (AtkWindowIface *iface);
-/* Auxiliary */
+/* Auxiliar */
 static void                  cally_stage_activate_cb     (ClutterStage *stage,
                                                          gpointer      data);
 static void                  cally_stage_deactivate_cb   (ClutterStage *stage,
@ -63,7 +63,7 @@ struct _CallyStagePrivate
 G_DEFINE_TYPE_WITH_CODE (CallyStage,
                         cally_stage,
-                         CALLY_TYPE_ACTOR,
+                         CALLY_TYPE_GROUP,
                         G_ADD_PRIVATE (CallyStage)
                         G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
                                                cally_stage_window_interface_init));
@ -134,11 +134,8 @@ cally_stage_notify_key_focus_cb (ClutterStage *stage,
      if (self->priv->key_focus != NULL)
        {
-          if (self->priv->key_focus != CLUTTER_ACTOR (stage))
+          g_object_remove_weak_pointer (G_OBJECT (self->priv->key_focus),
-            {
+                                        (gpointer *) &self->priv->key_focus);
              g_object_remove_weak_pointer (G_OBJECT (self->priv->key_focus),
                                            (gpointer *) &self->priv->key_focus);
            }
          old = clutter_actor_get_accessible (self->priv->key_focus);
        }
      else
@ -163,11 +160,8 @@ cally_stage_notify_key_focus_cb (ClutterStage *stage,
       *
       * we remove the weak pointer above.
       */
-      if (key_focus != CLUTTER_ACTOR (stage))
+      g_object_add_weak_pointer (G_OBJECT (self->priv->key_focus),
-        {
+                                 (gpointer *) &self->priv->key_focus);
          g_object_add_weak_pointer (G_OBJECT (self->priv->key_focus),
                                     (gpointer *) &self->priv->key_focus);
        }
      new = clutter_actor_get_accessible (key_focus);
    }
@ -228,7 +222,7 @@ cally_stage_window_interface_init (AtkWindowIface *iface)
  /* At this moment AtkWindow is just about signals */
 }
-/* Auxiliary */
+/* Auxiliar */
 static void
 cally_stage_activate_cb     (ClutterStage *stage,
                             gpointer      data)
--- a/clutter/clutter/cally/cally-stage.h
+++ b/clutter/clutter/cally/cally-stage.h
@ -25,7 +25,7 @@
 #error "Only <cally/cally.h> can be included directly."
 #endif
-#include <cally/cally-actor.h>
+#include <cally/cally-group.h>
 #include <clutter/clutter.h>
 G_BEGIN_DECLS
@ -52,7 +52,7 @@ typedef struct _CallyStagePrivate CallyStagePrivate;
 struct _CallyStage
 {
  /*< private >*/
-  CallyActor parent;
+  CallyGroup parent;
  CallyStagePrivate *priv;
 };
@ -68,15 +68,15 @@ struct _CallyStage
 struct _CallyStageClass
 {
  /*< private >*/
-  CallyActorClass parent_class;
+  CallyGroupClass parent_class;
  /* padding for future expansion */
  gpointer _padding_dummy[16];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_stage_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_stage_new      (ClutterActor *actor);
 G_END_DECLS
--- a/clutter/clutter/cally/cally-text.c
+++ b/clutter/clutter/cally/cally-text.c
@ -39,7 +39,9 @@
 *
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "cally-text.h"
 #include "cally-actor-private.h"
@ -247,7 +249,11 @@ cally_text_finalize   (GObject *obj)
 /*   g_object_unref (cally_text->priv->textutil); */
 /*   cally_text->priv->textutil = NULL; */
-  g_clear_handle_id (&cally_text->priv->insert_idle_handler, g_source_remove);
+  if (cally_text->priv->insert_idle_handler)
    {
      g_source_remove (cally_text->priv->insert_idle_handler);
      cally_text->priv->insert_idle_handler = 0;
    }
  G_OBJECT_CLASS (cally_text_parent_class)->finalize (obj);
 }
@ -1434,7 +1440,7 @@ static void cally_text_get_character_extents (AtkText *text,
  PangoLayout *layout;
  PangoRectangle extents;
  const gchar *text_value;
-  graphene_point3d_t verts[4];
+  ClutterVertex verts[4];
  actor = CALLY_GET_CLUTTER_ACTOR (text);
  if (actor == NULL) /* State is defunct */
@ -1513,7 +1519,7 @@ cally_text_get_offset_at_point (AtkText *text,
 }
-/******** Auxiliary private methods ******/
+/******** Auxiliar private methods ******/
 /* ClutterText only maintains the current cursor position and a extra selection
   bound, but this could be before or after the cursor. This method returns
@ -1552,7 +1558,7 @@ _cally_text_delete_text_cb (ClutterText *clutter_text,
  g_return_if_fail (CALLY_IS_TEXT (data));
-  /* Ignore zero length deletions */
+  /* Ignore zero lengh deletions */
  if (end_pos - start_pos == 0)
    return;
@ -1653,7 +1659,7 @@ cally_text_insert_text (AtkEditableText *text,
  clutter_text_insert_text (CLUTTER_TEXT (actor),
                            string, *position);
-  /* we suppose that the text insertion will be successful,
+  /* we suppose that the text insertion will be succesful,
     clutter-text doesn't warn about it. A option would be search for
     the text, but it seems not really required */
  *position += length;
@ -1866,7 +1872,7 @@ static gint
 _cally_atk_attribute_lookup_func (gconstpointer data,
                                  gconstpointer user_data)
 {
-    AtkTextAttribute attr = (AtkTextAttribute) GPOINTER_TO_INT (user_data);
+    AtkTextAttribute attr = (AtkTextAttribute) user_data;
    AtkAttribute *at = (AtkAttribute *) data;
    if (!g_strcmp0 (at->name, atk_text_attribute_get_name (attr)))
        return 0;
@ -2290,7 +2296,7 @@ _cally_misc_get_index_at_point (ClutterText *clutter_text,
  gint index, x_window, y_window, x_toplevel, y_toplevel;
  gint x_temp, y_temp;
  gboolean ret;
-  graphene_point3d_t verts[4];
+  ClutterVertex verts[4];
  PangoLayout *layout;
  gint x_layout, y_layout;
--- a/clutter/clutter/cally/cally-text.h
+++ b/clutter/clutter/cally/cally-text.h
@ -74,9 +74,9 @@ struct _CallyTextClass
  gpointer _padding_dummy[8];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType      cally_text_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 AtkObject* cally_text_new      (ClutterActor *actor);
 G_END_DECLS
--- a/clutter/clutter/cally/cally-texture.c
+++ b/clutter/clutter/cally/cally-texture.c
@ -0,0 +1,98 @@
 /* CALLY - The Clutter Accessibility Implementation Library
 *
 * Copyright (C) 2009 Igalia, S.L.
 *
 * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
 *
 * 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-texture
 * @Title: CallyTexture
 * @short_description: Implementation of the ATK interfaces for a #ClutterTexture
 * @see_also: #ClutterTexture
 *
 * #CallyTexture implements the required ATK interfaces of #ClutterTexture
 *
 * In particular it sets a proper role for the texture.
 */
 #include "clutter-build-config.h"
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "cally-texture.h"
 #include "cally-actor-private.h"
 #include "deprecated/clutter-texture.h"
 /* AtkObject */
 static void                  cally_texture_real_initialize (AtkObject *obj,
                                                           gpointer   data);
 G_DEFINE_TYPE (CallyTexture, cally_texture, CALLY_TYPE_ACTOR)
 static void
 cally_texture_class_init (CallyTextureClass *klass)
 {
 /*   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass); */
  AtkObjectClass *class         = ATK_OBJECT_CLASS (klass);
  class->initialize      = cally_texture_real_initialize;
 }
 static void
 cally_texture_init (CallyTexture *texture)
 {
  /* nothing to do yet */
 }
 /**
 * cally_texture_new:
 * @actor: a #ClutterActor
 *
 * Creates a new #CallyTexture for the given @actor. @actor must be
 * a #ClutterTexture.
 *
 * Return value: the newly created #AtkObject
 *
 * Since: 1.4
 */
 AtkObject*
 cally_texture_new (ClutterActor *actor)
 {
  GObject   *object     = NULL;
  AtkObject *accessible = NULL;
  g_return_val_if_fail (CLUTTER_IS_TEXTURE (actor), NULL);
  object = g_object_new (CALLY_TYPE_TEXTURE, NULL);
  accessible = ATK_OBJECT (object);
  atk_object_initialize (accessible, actor);
  return accessible;
 }
 static void
 cally_texture_real_initialize (AtkObject *obj,
                              gpointer   data)
 {
  ATK_OBJECT_CLASS (cally_texture_parent_class)->initialize (obj, data);
  /* default role */
  obj->role = ATK_ROLE_IMAGE;
 }
--- a/clutter/clutter/cally/cally-texture.h
+++ b/clutter/clutter/cally/cally-texture.h
@ -0,0 +1,84 @@
 /* CALLY - The Clutter Accessibility Implementation Library
 *
 * Copyright (C) 2009 Igalia, S.L.
 *
 * Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
 *
 * 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_TEXTURE_H__
 #define __CALLY_TEXTURE_H__
 #if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
 #error "Only <cally/cally.h> can be included directly."
 #endif
 #include <clutter/clutter.h>
 #include <cally/cally-actor.h>
 G_BEGIN_DECLS
 #define CALLY_TYPE_TEXTURE            (cally_texture_get_type ())
 #define CALLY_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_TEXTURE, CallyTexture))
 #define CALLY_TEXTURE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_TEXTURE, CallyTextureClass))
 #define CALLY_IS_TEXTURE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_TEXTURE))
 #define CALLY_IS_TEXTURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_TEXTURE))
 #define CALLY_TEXTURE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_TEXTURE, CallyTextureClass))
 typedef struct _CallyTexture        CallyTexture;
 typedef struct _CallyTextureClass   CallyTextureClass;
 typedef struct _CallyTexturePrivate CallyTexturePrivate;
 /**
 * CallyTexture:
 *
 * The <structname>CallyTexture</structname> structure contains only
 * private data and should be accessed using the provided API
 *
 * Since: 1.4
 */
 struct _CallyTexture
 {
  /*< private >*/
  CallyActor parent;
  CallyTexturePrivate *priv;
 };
 /**
 * CallyTextureClass:
 *
 * The <structname>CallyTextureClass</structname> structure contains
 * only private data
 *
 * Since: 1.4
 */
 struct _CallyTextureClass
 {
  /*< private >*/
  CallyActorClass parent_class;
  /* padding for future expansion */
  gpointer _padding_dummy[8];
 };
 CLUTTER_AVAILABLE_IN_1_4
 GType      cally_texture_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_4
 AtkObject *cally_texture_new      (ClutterActor *actor);
 G_END_DECLS
 #endif /* __CALLY_TEXTURE_H__ */
--- a/clutter/clutter/cally/cally-util.c
+++ b/clutter/clutter/cally/cally-util.c
@ -38,7 +38,9 @@
 * available any accessible object.
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <stdlib.h>
 #include <string.h>
@ -142,7 +144,7 @@ cally_util_get_toolkit_name (void)
 static const gchar *
 cally_util_get_toolkit_version (void)
 {
-  return MUTTER_VERSION;
+  return CLUTTER_VERSION_S;
 }
 static guint
@ -212,8 +214,6 @@ cally_util_simulate_snooper_install (void)
                    G_CALLBACK (cally_util_stage_added_cb), cally_key_snooper);
  g_signal_connect (G_OBJECT (stage_manager), "stage-removed",
                    G_CALLBACK (cally_util_stage_removed_cb), cally_key_snooper);
  g_slist_free (stage_list);
 }
 static void
--- a/clutter/clutter/cally/cally-util.h
+++ b/clutter/clutter/cally/cally-util.h
@ -74,7 +74,7 @@ struct _CallyUtilClass
  gpointer _padding_dummy[8];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType cally_util_get_type (void) G_GNUC_CONST;
 void _cally_util_override_atk_util (void);
--- a/clutter/clutter/cally/cally.c
+++ b/clutter/clutter/cally/cally.c
@ -29,15 +29,20 @@
 *
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "cally.h"
 #include "cally-actor.h"
 #include "cally-group.h"
 #include "cally-stage.h"
 #include "cally-text.h"
 #include "cally-texture.h"
 #include "cally-rectangle.h"
 #include "cally-clone.h"
 #include "cally-factory.h"
@ -50,8 +55,11 @@
 /* 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)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_RECTANGLE, cally_rectangle, cally_rectangle_new)
 CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_CLONE, cally_clone, cally_clone_new)
 /**
@ -69,8 +77,11 @@ 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);
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_RECTANGLE, cally_rectangle);
  CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_CLONE, cally_clone);
  /* Initialize the CallyUtility class */
--- a/clutter/clutter/cally/cally.h
+++ b/clutter/clutter/cally/cally.h
@ -26,10 +26,13 @@
 #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"
 #include "cally-stage.h"
 #include "cally-text.h"
 #include "cally-texture.h"
 #include "cally-util.h"
 #undef __CALLY_H_INSIDE__
--- a/clutter/clutter/clutter-action.c
+++ b/clutter/clutter/clutter-action.c
@ -41,7 +41,9 @@
 * #ClutterAction is available since Clutter 1.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-action.h"
--- a/clutter/clutter/clutter-action.h
+++ b/clutter/clutter/clutter-action.h
@ -33,11 +33,28 @@
 G_BEGIN_DECLS
-#define CLUTTER_TYPE_ACTION (clutter_action_get_type ())
+#define CLUTTER_TYPE_ACTION             (clutter_action_get_type ())
 #define CLUTTER_ACTION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTION, ClutterAction))
 #define CLUTTER_IS_ACTION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTION))
 #define CLUTTER_ACTION_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ACTION, ClutterActionClass))
 #define CLUTTER_IS_ACTION_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ACTION))
 #define CLUTTER_ACTION_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ACTION, ClutterActionClass))
-CLUTTER_EXPORT
+typedef struct _ClutterActionClass      ClutterActionClass;
-G_DECLARE_DERIVABLE_TYPE (ClutterAction, clutter_action,
+
-                          CLUTTER, ACTION, ClutterActorMeta);
+/**
 * ClutterAction:
 *
 * The #ClutterAction structure contains only private data and
 * should be accessed using the provided API.
 *
 * Since: 1.4
 */
 struct _ClutterAction
 {
  /*< private >*/
  ClutterActorMeta parent_instance;
 };
 /**
 * ClutterActionClass:
@ -61,29 +78,32 @@ struct _ClutterActionClass
  void (* _clutter_action8) (void);
 };
 CLUTTER_AVAILABLE_IN_1_4
 GType clutter_action_get_type (void) G_GNUC_CONST;
 /* ClutterActor API */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action            (ClutterActor  *self,
                                                    ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action_with_name  (ClutterActor  *self,
                                                    const gchar   *name,
                                                    ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action         (ClutterActor  *self,
                                                    ClutterAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action_by_name (ClutterActor  *self,
                                                    const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *clutter_actor_get_action            (ClutterActor  *self,
                                                    const gchar   *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GList *        clutter_actor_get_actions           (ClutterActor  *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_clear_actions         (ClutterActor  *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean       clutter_actor_has_actions           (ClutterActor  *self);
 G_END_DECLS
--- a/clutter/clutter/clutter-actor-box-private.h
+++ b/clutter/clutter/clutter-actor-box-private.h
@ -1,12 +0,0 @@
 #ifndef __CLUTTER_ACTOR_BOX_PRIVATE_H__
 #define __CLUTTER_ACTOR_BOX_PRIVATE_H__
 #include <clutter/clutter-types.h>
 G_BEGIN_DECLS
 void _clutter_actor_box_enlarge_for_effects (ClutterActorBox *box);
 G_END_DECLS
 #endif /* __CLUTTER_ACTOR_BOX_PRIVATE_H__ */
--- a/clutter/clutter/clutter-actor-box.c
+++ b/clutter/clutter/clutter-actor-box.c
@ -1,11 +1,12 @@
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
 #include "clutter-types.h"
 #include "clutter-interval.h"
 #include "clutter-private.h"
 #include "clutter-actor-box-private.h"
 /**
 * clutter_actor_box_new:
@ -54,7 +55,7 @@ clutter_actor_box_new (gfloat x_1,
 ClutterActorBox *
 clutter_actor_box_alloc (void)
 {
-  return g_new0 (ClutterActorBox, 1);
+  return g_slice_new0 (ClutterActorBox);
 }
 /**
@ -130,7 +131,7 @@ ClutterActorBox *
 clutter_actor_box_copy (const ClutterActorBox *box)
 {
  if (G_LIKELY (box != NULL))
-    return g_memdup2 (box, sizeof (ClutterActorBox));
+    return g_slice_dup (ClutterActorBox, box);
  return NULL;
 }
@ -148,7 +149,7 @@ void
 clutter_actor_box_free (ClutterActorBox *box)
 {
  if (G_LIKELY (box != NULL))
-    g_free (box);
+    g_slice_free (ClutterActorBox, box);
 }
 /**
@ -320,7 +321,7 @@ clutter_actor_box_get_area (const ClutterActorBox *box)
 * @y: Y coordinate of the point
 *
 * Checks whether a point with @x, @y coordinates is contained
- * within @box
+ * withing @box
 *
 * Return value: %TRUE if the point is contained by the #ClutterActorBox
 *
@ -340,7 +341,7 @@ clutter_actor_box_contains (const ClutterActorBox *box,
 /**
 * clutter_actor_box_from_vertices:
 * @box: a #ClutterActorBox
- * @verts: (array fixed-size=4): array of four #graphene_point3d_t
+ * @verts: (array fixed-size=4): array of four #ClutterVertex
 *
 * Calculates the bounding box represented by the four vertices; for details
 * of the vertex array see clutter_actor_get_abs_allocation_vertices().
@ -348,8 +349,8 @@ clutter_actor_box_contains (const ClutterActorBox *box,
 * Since: 1.0
 */
 void
-clutter_actor_box_from_vertices (ClutterActorBox          *box,
+clutter_actor_box_from_vertices (ClutterActorBox     *box,
-                                 const graphene_point3d_t  verts[])
+                                 const ClutterVertex  verts[])
 {
  gfloat x_1, x_2, y_1, y_2;
@ -543,104 +544,6 @@ clutter_actor_box_set_size (ClutterActorBox *box,
  box->y2 = box->y1 + height;
 }
 void
 _clutter_actor_box_enlarge_for_effects (ClutterActorBox *box)
 {
  float width, height;
  /* The aim here is that for a given rectangle defined with floating point
   * coordinates we want to determine a stable quantized size in pixels
   * that doesn't vary due to the original box's sub-pixel position.
   *
   * The reason this is important is because effects will use this
   * API to determine the size of offscreen framebuffers and so for
   * a fixed-size object that may be animated across the screen we
   * want to make sure that the stage paint-box has an equally stable
   * size so that effects aren't made to continuously re-allocate
   * a corresponding fbo.
   *
   * The other thing we consider is that the calculation of this box is
   * subject to floating point precision issues that might be slightly
   * different to the precision issues involved with actually painting the
   * actor, which might result in painting slightly leaking outside the
   * user's calculated paint-volume. For this we simply aim to pad out the
   * paint-volume by at least half a pixel all the way around.
   */
  width = box->x2 - box->x1;
  height = box->y2 - box->y1;
  width = CLUTTER_NEARBYINT (width);
  height = CLUTTER_NEARBYINT (height);
  /* XXX: NB the width/height may now be up to 0.5px too small so we
   * must also pad by 0.25px all around to account for this. In total we
   * must padd by at least 0.75px around all sides. */
  /* XXX: The furthest that we can overshoot the bottom right corner by
   * here is 1.75px in total if you consider that the 0.75 padding could
   * just cross an integer boundary and so ceil will effectively add 1.
   */
  box->x2 = ceilf (box->x2 + 0.75);
  box->y2 = ceilf (box->y2 + 0.75);
  /* Now we redefine the top-left relative to the bottom right based on the
   * rounded width/height determined above + a constant so that the overall
   * size of the box will be stable and not dependent on the box's
   * position.
   *
   * Adding 3px to the width/height will ensure we cover the maximum of
   * 1.75px padding on the bottom/right and still ensure we have > 0.75px
   * padding on the top/left.
   */
  box->x1 = box->x2 - width - 3;
  box->y1 = box->y2 - height - 3;
 }
 /**
 * clutter_actor_box_scale:
 * @box: a #ClutterActorBox
 * @scale: scale factor for resizing this box
 *
 * Rescale the @box by provided @scale factor.
 *
 * Since: 1.6
 */
 void
 clutter_actor_box_scale (ClutterActorBox *box,
                         gfloat           scale)
 {
  g_return_if_fail (box != NULL);
  box->x1 *= scale;
  box->x2 *= scale;
  box->y1 *= scale;
  box->y2 *= scale;
 }
 /**
 * clutter_actor_box_is_initialized:
 * @box: a #ClutterActorBox
 *
 * Checks if @box has been initialized, a #ClutterActorBox is uninitialized
 * if it has a size of -1 at an origin of 0, 0.
 *
 * Returns: %TRUE if the box is uninitialized, %FALSE if it isn't
 */
 gboolean
 clutter_actor_box_is_initialized (ClutterActorBox *box)
 {
  gboolean x1_uninitialized, x2_uninitialized;
  gboolean y1_uninitialized, y2_uninitialized;
  g_return_val_if_fail (box != NULL, TRUE);
  x1_uninitialized = isinf (box->x1);
  x2_uninitialized = isinf (box->x2) && signbit (box->x2);
  y1_uninitialized = isinf (box->y1);
  y2_uninitialized = isinf (box->y2) && signbit (box->y2);
  return !x1_uninitialized || !x2_uninitialized ||
         !y1_uninitialized || !y2_uninitialized;
 }
 G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterActorBox, clutter_actor_box,
                               clutter_actor_box_copy,
                               clutter_actor_box_free,
--- a/clutter/clutter/clutter-actor-meta.c
+++ b/clutter/clutter/clutter-actor-meta.c
@ -41,7 +41,9 @@
 * #ClutterActorMeta is available since Clutter 1.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-actor-meta-private.h"
@ -51,7 +53,7 @@
 struct _ClutterActorMetaPrivate
 {
  ClutterActor *actor;
-  gulong destroy_id;
+  guint destroy_id;
  gchar *name;
@ -81,49 +83,28 @@ static void
 on_actor_destroy (ClutterActor     *actor,
                  ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
+  meta->priv->actor = NULL;
    clutter_actor_meta_get_instance_private (meta);
  priv->actor = NULL;
 }
 static void
 clutter_actor_meta_real_set_actor (ClutterActorMeta *meta,
                                   ClutterActor     *actor)
 {
-  ClutterActorMetaPrivate *priv =
+  if (meta->priv->actor == actor)
    clutter_actor_meta_get_instance_private (meta);
  g_warn_if_fail (!priv->actor ||
                  !CLUTTER_ACTOR_IN_PAINT (priv->actor));
  g_warn_if_fail (!actor || !CLUTTER_ACTOR_IN_PAINT (actor));
  if (priv->actor == actor)
    return;
-  g_clear_signal_handler (&priv->destroy_id, priv->actor);
+  if (meta->priv->destroy_id != 0)
    {
      g_signal_handler_disconnect (meta->priv->actor, meta->priv->destroy_id);
      meta->priv->destroy_id = 0;
    }
-  priv->actor = actor;
+  meta->priv->actor = actor;
-  if (priv->actor != NULL)
+  if (meta->priv->actor != NULL)
-    priv->destroy_id = g_signal_connect (priv->actor, "destroy",
+    meta->priv->destroy_id = g_signal_connect (meta->priv->actor, "destroy",
-                                         G_CALLBACK (on_actor_destroy),
+                                               G_CALLBACK (on_actor_destroy),
-                                         meta);
+                                               meta);
 }
 static void
 clutter_actor_meta_real_set_enabled (ClutterActorMeta *meta,
                                     gboolean          is_enabled)
 {
  ClutterActorMetaPrivate *priv =
    clutter_actor_meta_get_instance_private (meta);
  g_warn_if_fail (!priv->actor ||
                  !CLUTTER_ACTOR_IN_PAINT (priv->actor));
  priv->is_enabled = is_enabled;
  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_ENABLED]);
 }
 static void
@ -156,21 +137,20 @@ clutter_actor_meta_get_property (GObject    *gobject,
                                 GValue     *value,
                                 GParamSpec *pspec)
 {
-  ClutterActorMetaPrivate *priv =
+  ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
  switch (prop_id)
    {
    case PROP_ACTOR:
-      g_value_set_object (value, priv->actor);
+      g_value_set_object (value, meta->priv->actor);
      break;
    case PROP_NAME:
-      g_value_set_string (value, priv->name);
+      g_value_set_string (value, meta->priv->name);
      break;
    case PROP_ENABLED:
-      g_value_set_boolean (value, priv->is_enabled);
+      g_value_set_boolean (value, meta->priv->is_enabled);
      break;
    default:
@ -182,11 +162,10 @@ clutter_actor_meta_get_property (GObject    *gobject,
 static void
 clutter_actor_meta_finalize (GObject *gobject)
 {
-  ClutterActorMetaPrivate *priv =
+  ClutterActorMetaPrivate *priv = CLUTTER_ACTOR_META (gobject)->priv;
    clutter_actor_meta_get_instance_private (CLUTTER_ACTOR_META (gobject));
-  if (priv->actor != NULL)
+  if (priv->destroy_id != 0 && priv->actor != NULL)
-    g_clear_signal_handler (&priv->destroy_id, priv->actor);
+    g_signal_handler_disconnect (priv->actor, priv->destroy_id);
  g_free (priv->name);
@ -199,7 +178,6 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  klass->set_actor = clutter_actor_meta_real_set_actor;
  klass->set_enabled = clutter_actor_meta_real_set_enabled;
  /**
   * ClutterActorMeta:actor:
@ -254,11 +232,9 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
 void
 clutter_actor_meta_init (ClutterActorMeta *self)
 {
-  ClutterActorMetaPrivate *priv =
+  self->priv = clutter_actor_meta_get_instance_private (self);
-    clutter_actor_meta_get_instance_private (self);
+  self->priv->is_enabled = TRUE;
-
+  self->priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
  priv->is_enabled = TRUE;
  priv->priority = CLUTTER_ACTOR_META_PRIORITY_DEFAULT;
 }
 /**
@ -276,17 +252,13 @@ void
 clutter_actor_meta_set_name (ClutterActorMeta *meta,
                             const gchar      *name)
 {
  ClutterActorMetaPrivate *priv;
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));
-  priv = clutter_actor_meta_get_instance_private (meta);
+  if (g_strcmp0 (meta->priv->name, name) == 0)
  if (g_strcmp0 (priv->name, name) == 0)
    return;
-  g_free (priv->name);
+  g_free (meta->priv->name);
-  priv->name = g_strdup (name);
+  meta->priv->name = g_strdup (name);
  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_NAME]);
 }
@ -307,13 +279,9 @@ clutter_actor_meta_set_name (ClutterActorMeta *meta,
 const gchar *
 clutter_actor_meta_get_name (ClutterActorMeta *meta)
 {
  ClutterActorMetaPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), NULL);
-  priv = clutter_actor_meta_get_instance_private (meta);
+  return meta->priv->name;
  return priv->name;
 }
 /**
@ -329,17 +297,16 @@ void
 clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
                                gboolean          is_enabled)
 {
  ClutterActorMetaPrivate *priv;
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));
  priv = clutter_actor_meta_get_instance_private (meta);
  is_enabled = !!is_enabled;
-  if (priv->is_enabled == is_enabled)
+  if (meta->priv->is_enabled == is_enabled)
    return;
-  CLUTTER_ACTOR_META_GET_CLASS (meta)->set_enabled (meta, is_enabled);
+  meta->priv->is_enabled = is_enabled;
  g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_ENABLED]);
 }
 /**
@ -355,13 +322,9 @@ clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
 gboolean
 clutter_actor_meta_get_enabled (ClutterActorMeta *meta)
 {
  ClutterActorMetaPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), FALSE);
-  priv = clutter_actor_meta_get_instance_private (meta);
+  return meta->priv->is_enabled;
  return priv->is_enabled;
 }
 /*
@ -397,54 +360,40 @@ _clutter_actor_meta_set_actor (ClutterActorMeta *meta,
 ClutterActor *
 clutter_actor_meta_get_actor (ClutterActorMeta *meta)
 {
  ClutterActorMetaPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), NULL);
-  priv = clutter_actor_meta_get_instance_private (meta);
+  return meta->priv->actor;
  return priv->actor;
 }
 void
 _clutter_actor_meta_set_priority (ClutterActorMeta *meta,
                                  gint priority)
 {
  ClutterActorMetaPrivate *priv;
  g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));
  priv = clutter_actor_meta_get_instance_private (meta);
  /* This property shouldn't be modified after the actor meta is in
     use because ClutterMetaGroup doesn't resort the list when it
     changes. If we made the priority public then we could either make
     the priority a construct-only property or listen for
     notifications on the property from the ClutterMetaGroup and
     resort. */
-  g_return_if_fail (priv->actor == NULL);
+  g_return_if_fail (meta->priv->actor == NULL);
-  priv->priority = priority;
+  meta->priv->priority = priority;
 }
 gint
 _clutter_actor_meta_get_priority (ClutterActorMeta *meta)
 {
  ClutterActorMetaPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_ACTOR_META (meta), 0);
-  priv = clutter_actor_meta_get_instance_private (meta);
+  return meta->priv->priority;
  return priv->priority;
 }
 gboolean
 _clutter_actor_meta_is_internal (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
+  gint priority = meta->priv->priority;
    clutter_actor_meta_get_instance_private (meta);
  gint priority = priv->priority;
  return (priority <= CLUTTER_ACTOR_META_PRIORITY_INTERNAL_LOW ||
          priority >= CLUTTER_ACTOR_META_PRIORITY_INTERNAL_HIGH);
@ -491,21 +440,19 @@ void
 _clutter_meta_group_add_meta (ClutterMetaGroup *group,
                              ClutterActorMeta *meta)
 {
  ClutterActorMetaPrivate *priv =
    clutter_actor_meta_get_instance_private (meta);
  GList *prev = NULL, *l;
-  if (priv->actor != NULL)
+  if (meta->priv->actor != NULL)
    {
      g_warning ("The meta of type '%s' with name '%s' is "
                 "already attached to actor '%s'",
                 G_OBJECT_TYPE_NAME (meta),
-                 priv->name != NULL
+                 meta->priv->name != NULL
-                   ? priv->name
+                   ? meta->priv->name
                   : "<unknown>",
-                 clutter_actor_get_name (priv->actor) != NULL
+                 clutter_actor_get_name (meta->priv->actor) != NULL
-                   ? clutter_actor_get_name (priv->actor)
+                   ? clutter_actor_get_name (meta->priv->actor)
-                   : G_OBJECT_TYPE_NAME (priv->actor));
+                   : G_OBJECT_TYPE_NAME (meta->priv->actor));
      return;
    }
@ -541,16 +488,13 @@ void
 _clutter_meta_group_remove_meta (ClutterMetaGroup *group,
                                 ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
+  if (meta->priv->actor != group->actor)
    clutter_actor_meta_get_instance_private (meta);
  if (priv->actor != group->actor)
    {
      g_warning ("The meta of type '%s' with name '%s' is not "
                 "attached to the actor '%s'",
                 G_OBJECT_TYPE_NAME (meta),
-                 priv->name != NULL
+                 meta->priv->name != NULL
-                   ? priv->name
+                   ? meta->priv->name
                   : "<unknown>",
                 clutter_actor_get_name (group->actor) != NULL
                   ? clutter_actor_get_name (group->actor)
@ -635,7 +579,8 @@ _clutter_meta_group_clear_metas (ClutterMetaGroup *group)
 {
  g_list_foreach (group->meta, (GFunc) _clutter_actor_meta_set_actor, NULL);
-  g_list_free_full (group->meta, g_object_unref);
+  g_list_foreach (group->meta, (GFunc) g_object_unref, NULL);
  g_list_free (group->meta);
  group->meta = NULL;
 }
@ -693,10 +638,8 @@ _clutter_meta_group_get_meta (ClutterMetaGroup *group,
  for (l = group->meta; l != NULL; l = l->next)
    {
      ClutterActorMeta *meta = l->data;
      ClutterActorMetaPrivate *priv =
        clutter_actor_meta_get_instance_private (meta);
-      if (g_strcmp0 (priv->name, name) == 0)
+      if (g_strcmp0 (meta->priv->name, name) == 0)
        return meta;
    }
@ -716,8 +659,6 @@ _clutter_meta_group_get_meta (ClutterMetaGroup *group,
 const gchar *
 _clutter_actor_meta_get_debug_name (ClutterActorMeta *meta)
 {
-  ClutterActorMetaPrivate *priv =
+  return meta->priv->name != NULL ? meta->priv->name
-    clutter_actor_meta_get_instance_private (meta);
+                                  : G_OBJECT_TYPE_NAME (meta);
  return priv->name != NULL ? priv->name : G_OBJECT_TYPE_NAME (meta);
 }
--- a/clutter/clutter/clutter-actor-meta.h
+++ b/clutter/clutter/clutter-actor-meta.h
@ -33,13 +33,31 @@
 G_BEGIN_DECLS
-#define CLUTTER_TYPE_ACTOR_META (clutter_actor_meta_get_type ())
+#define CLUTTER_TYPE_ACTOR_META                 (clutter_actor_meta_get_type ())
 #define CLUTTER_ACTOR_META(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMeta))
 #define CLUTTER_IS_ACTOR_META(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTOR_META))
 #define CLUTTER_ACTOR_META_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))
 #define CLUTTER_IS_ACTOR_META_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ACTOR_META))
 #define CLUTTER_ACTOR_META_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))
-CLUTTER_EXPORT
+typedef struct _ClutterActorMetaPrivate         ClutterActorMetaPrivate;
-G_DECLARE_DERIVABLE_TYPE (ClutterActorMeta, clutter_actor_meta,
+typedef struct _ClutterActorMetaClass           ClutterActorMetaClass;
                          CLUTTER, ACTOR_META, GInitiallyUnowned);
-typedef struct _ClutterActorMetaPrivate ClutterActorMetaPrivate;
+/**
 * ClutterActorMeta:
 *
 * The #ClutterActorMeta structure contains only
 * private data and should be accessed using the provided API
 *
 * Since: 1.4
 */
 struct _ClutterActorMeta
 {
  /*< private >*/
  GInitiallyUnowned parent_instance;
  ClutterActorMetaPrivate *priv;
 };
 /**
 * ClutterActorMetaClass:
@ -69,9 +87,6 @@ struct _ClutterActorMetaClass
  void (* set_actor) (ClutterActorMeta *meta,
                      ClutterActor     *actor);
  void (* set_enabled) (ClutterActorMeta *meta,
                        gboolean          is_enabled);
  /*< private >*/
  void (* _clutter_meta1) (void);
  void (* _clutter_meta2) (void);
@ -79,20 +94,24 @@ struct _ClutterActorMetaClass
  void (* _clutter_meta4) (void);
  void (* _clutter_meta5) (void);
  void (* _clutter_meta6) (void);
  void (* _clutter_meta7) (void);
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_name     (ClutterActorMeta *meta,
                                                 const gchar      *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 const gchar *   clutter_actor_meta_get_name     (ClutterActorMeta *meta);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_enabled  (ClutterActorMeta *meta,
                                                 gboolean          is_enabled);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean        clutter_actor_meta_get_enabled  (ClutterActorMeta *meta);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *  clutter_actor_meta_get_actor    (ClutterActorMeta *meta);
 G_END_DECLS
--- a/clutter/clutter/clutter-actor-private.h
+++ b/clutter/clutter/clutter-actor-private.h
@ -26,6 +26,23 @@
 G_BEGIN_DECLS
 /*< private >
 * ClutterRedrawFlags:
 * @CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION: Tells clutter the maximum
 *   extents of what needs to be redrawn lies within the actors
 *   current allocation. (Only use this for 2D actors though because
 *   any actor with depth may be projected outside of its allocation)
 *
 * Flags passed to the clutter_actor_queue_redraw_with_clip ()
 * function
 *
 * Since: 1.6
 */
 typedef enum
 {
  CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION  = 1 << 0
 } ClutterRedrawFlags;
 /*< private >
 * ClutterActorTraverseFlags:
 * CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST: Traverse the graph in
@ -36,8 +53,7 @@ G_BEGIN_DECLS
 * Controls some options for how clutter_actor_traverse() iterates
 * through the graph.
 */
-typedef enum
+typedef enum {
 {
  CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST   = 1L<<0,
  CLUTTER_ACTOR_TRAVERSE_BREADTH_FIRST = 1L<<1
 } ClutterActorTraverseFlags;
@ -58,8 +74,7 @@ typedef enum
 * the continuing traversal. It may stop traversal completely, just
 * skip over children for the current actor or continue as normal.
 */
-typedef enum
+typedef enum {
 {
  CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE       = 1L<<0,
  CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN  = 1L<<1,
  CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK          = 1L<<2
@ -93,12 +108,35 @@ typedef ClutterActorTraverseVisitFlags (*ClutterTraverseCallback) (ClutterActor
 typedef gboolean (*ClutterForeachCallback) (ClutterActor *actor,
                                            gpointer      user_data);
 typedef struct _AnchorCoord             AnchorCoord;
 typedef struct _SizeRequest             SizeRequest;
 typedef struct _ClutterLayoutInfo       ClutterLayoutInfo;
 typedef struct _ClutterTransformInfo    ClutterTransformInfo;
 typedef struct _ClutterAnimationInfo    ClutterAnimationInfo;
 /* Internal helper struct to represent a point that can be stored in
   either direct pixel coordinates or as a fraction of the actor's
   size. It is used for the anchor point, scale center and rotation
   centers. */
 struct _AnchorCoord
 {
  gboolean is_fractional;
  union
  {
    /* Used when is_fractional == TRUE */
    struct
    {
      gdouble x;
      gdouble y;
    } fraction;
    /* Use when is_fractional == FALSE */
    ClutterVertex units;
  } v;
 };
 struct _SizeRequest
 {
  guint  age;
@ -123,7 +161,7 @@ struct _SizeRequest
 struct _ClutterLayoutInfo
 {
  /* fixed position coordinates */
-  graphene_point_t fixed_pos;
+  ClutterPoint fixed_pos;
  ClutterMargin margin;
@ -133,8 +171,8 @@ struct _ClutterLayoutInfo
  guint x_expand : 1;
  guint y_expand : 1;
-  graphene_size_t minimum;
+  ClutterSize minimum;
-  graphene_size_t natural;
+  ClutterSize natural;
 };
 const ClutterLayoutInfo *       _clutter_actor_get_layout_info_or_defaults      (ClutterActor *self);
@ -143,30 +181,39 @@ ClutterLayoutInfo *             _clutter_actor_peek_layout_info
 struct _ClutterTransformInfo
 {
-  /* rotation */
+  /* rotation (angle and center) */
  gdouble rx_angle;
  AnchorCoord rx_center;
  gdouble ry_angle;
  AnchorCoord ry_center;
  gdouble rz_angle;
  AnchorCoord rz_center;
  /* scaling */
  gdouble scale_x;
  gdouble scale_y;
  gdouble scale_z;
  AnchorCoord scale_center;
  /* anchor point */
  AnchorCoord anchor;
  /* translation */
-  graphene_point3d_t translation;
+  ClutterVertex translation;
  /* z_position */
  gfloat z_position;
  /* transformation center */
-  graphene_point_t pivot;
+  ClutterPoint pivot;
  gfloat pivot_z;
-  graphene_matrix_t transform;
+  CoglMatrix transform;
  guint transform_set : 1;
-  graphene_matrix_t child_transform;
+  CoglMatrix child_transform;
  guint child_transform_set : 1;
 };
@ -193,6 +240,9 @@ ClutterAnimationInfo *          _clutter_actor_get_animation_info
 ClutterTransition *             _clutter_actor_create_transition                        (ClutterActor *self,
                                                                                         GParamSpec   *pspec,
                                                                                         ...);
 ClutterTransition *             _clutter_actor_get_transition                           (ClutterActor *self,
                                                                                         GParamSpec   *pspec);
 gboolean                        _clutter_actor_foreach_child                            (ClutterActor *self,
                                                                                         ClutterForeachCallback callback,
                                                                                         gpointer user_data);
@ -203,11 +253,11 @@ void                            _clutter_actor_traverse
                                                                                         gpointer user_data);
 ClutterActor *                  _clutter_actor_get_stage_internal                       (ClutterActor *actor);
-void                            _clutter_actor_apply_modelview_transform                (ClutterActor      *self,
+void                            _clutter_actor_apply_modelview_transform                (ClutterActor *self,
-                                                                                         graphene_matrix_t *matrix);
+                                                                                         CoglMatrix   *matrix);
-void                            _clutter_actor_apply_relative_transformation_matrix     (ClutterActor      *self,
+void                            _clutter_actor_apply_relative_transformation_matrix     (ClutterActor *self,
-                                                                                         ClutterActor      *ancestor,
+                                                                                         ClutterActor *ancestor,
-                                                                                         graphene_matrix_t *matrix);
+                                                                                         CoglMatrix   *matrix);
 void                            _clutter_actor_rerealize                                (ClutterActor    *self,
                                                                                         ClutterCallback  callback,
@ -225,24 +275,35 @@ void                            _clutter_actor_set_enable_paint_unmapped
 void                            _clutter_actor_set_has_pointer                          (ClutterActor *self,
                                                                                         gboolean      has_pointer);
-void                            _clutter_actor_set_has_key_focus                        (ClutterActor *self,
+void                            _clutter_actor_queue_redraw_with_clip                   (ClutterActor       *self,
-                                                                                         gboolean      has_key_focus);
+                                                                                         ClutterRedrawFlags  flags,
                                                                                         ClutterPaintVolume *clip_volume);
 void                            _clutter_actor_queue_redraw_full                        (ClutterActor       *self,
                                                                                         ClutterRedrawFlags  flags,
                                                                                         ClutterPaintVolume *volume,
                                                                                         ClutterEffect      *effect);
-void                            _clutter_actor_queue_redraw_full                        (ClutterActor             *self,
+ClutterPaintVolume *            _clutter_actor_get_queue_redraw_clip                    (ClutterActor       *self);
-                                                                                         const ClutterPaintVolume *volume,
+void                            _clutter_actor_set_queue_redraw_clip                    (ClutterActor       *self,
-                                                                                         ClutterEffect            *effect);
+                                                                                         ClutterPaintVolume *clip_volume);
-
+void                            _clutter_actor_finish_queue_redraw                      (ClutterActor       *self,
-void                            _clutter_actor_finish_queue_redraw                      (ClutterActor *self);
+                                                                                         ClutterPaintVolume *clip);
 gboolean                        _clutter_actor_set_default_paint_volume                 (ClutterActor       *self,
                                                                                         GType               check_gtype,
                                                                                         ClutterPaintVolume *volume);
-const char *                    _clutter_actor_get_debug_name                           (ClutterActor *self);
+const gchar *                   _clutter_actor_get_debug_name                           (ClutterActor *self);
 void                            _clutter_actor_push_clone_paint                         (void);
 void                            _clutter_actor_pop_clone_paint                          (void);
 guint32                         _clutter_actor_get_pick_id                              (ClutterActor *self);
 void                            _clutter_actor_shader_pre_paint                         (ClutterActor *actor,
                                                                                         gboolean      repeat);
 void                            _clutter_actor_shader_post_paint                        (ClutterActor *actor);
 ClutterActorAlign               _clutter_actor_get_effective_x_align                    (ClutterActor *self);
 void                            _clutter_actor_handle_event                             (ClutterActor       *actor,
@ -252,25 +313,15 @@ void                            _clutter_actor_attach_clone
                                                                                         ClutterActor *clone);
 void                            _clutter_actor_detach_clone                             (ClutterActor *actor,
                                                                                         ClutterActor *clone);
 void                            _clutter_actor_queue_redraw_on_clones                   (ClutterActor *actor);
 void                            _clutter_actor_queue_relayout_on_clones                 (ClutterActor *actor);
 void                            _clutter_actor_queue_only_relayout                      (ClutterActor *actor);
 void                            clutter_actor_clear_stage_views_recursive               (ClutterActor *actor);
-float                           clutter_actor_get_real_resource_scale                   (ClutterActor *actor);
+CoglFramebuffer *               _clutter_actor_get_active_framebuffer                   (ClutterActor *actor);
 ClutterPaintNode *              clutter_actor_create_texture_paint_node                 (ClutterActor *self,
                                                                                         CoglTexture  *texture);
 void clutter_actor_finish_layout (ClutterActor *self,
                                  int           phase);
 void clutter_actor_queue_immediate_relayout (ClutterActor *self);
 gboolean clutter_actor_is_painting_unmapped (ClutterActor *self);
 gboolean clutter_actor_get_redraw_clip (ClutterActor       *self,
                                        ClutterPaintVolume *dst_old_pv,
                                        ClutterPaintVolume *dst_new_pv);
 G_END_DECLS
 #endif /* __CLUTTER_ACTOR_PRIVATE_H__ */
--- a/clutter/clutter/clutter-actor.c
+++ b/clutter/clutter/clutter-actor.c
--- a/clutter/clutter/clutter-actor.h
+++ b/clutter/clutter/clutter-actor.h
@ -39,8 +39,6 @@
 #include <clutter/clutter-types.h>
 #include <clutter/clutter-event.h>
 #include <clutter/clutter-paint-context.h>
 #include <clutter/clutter-pick-context.h>
 G_BEGIN_DECLS
@ -63,7 +61,7 @@ G_BEGIN_DECLS
 *   internal state.
 */
 #define CLUTTER_ACTOR_SET_FLAGS(a,f) \
-  CLUTTER_MACRO_DEPRECATED \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24 \
  (((ClutterActor*)(a))->flags |= (f))
 /**
@ -78,23 +76,23 @@ G_BEGIN_DECLS
 *   internal state.
 */
 #define CLUTTER_ACTOR_UNSET_FLAGS(a,f) \
-  CLUTTER_MACRO_DEPRECATED \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24 \
  (((ClutterActor*)(a))->flags &= ~(f))
 #define CLUTTER_ACTOR_IS_MAPPED(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
  ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_MAPPED) != FALSE)
 #define CLUTTER_ACTOR_IS_REALIZED(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
  ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REALIZED) != FALSE)
 #define CLUTTER_ACTOR_IS_VISIBLE(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
  ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_VISIBLE) != FALSE)
 #define CLUTTER_ACTOR_IS_REACTIVE(a) \
-  CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
+  CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
  ((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REACTIVE) != FALSE)
 typedef struct _ClutterActorClass    ClutterActorClass;
@ -142,6 +140,11 @@ struct _ClutterActor
 * ClutterActorClass:
 * @show: signal class handler for #ClutterActor::show; it must chain
 *   up to the parent's implementation
 * @show_all: virtual function for containers and composite actors, to
 *   determine which children should be shown when calling
 *   clutter_actor_show_all() on the actor. Defaults to calling
 *   clutter_actor_show(). This virtual function is deprecated and it
 *   should not be overridden.
 * @hide: signal class handler for #ClutterActor::hide; it must chain
 *   up to the parent's implementation
 * @hide_all: virtual function for containers and composite actors, to
@ -170,23 +173,18 @@ struct _ClutterActor
 * @get_preferred_height: virtual function, used when querying the minimum
 *   and natural heights of an actor for a given width; it is used by
 *   clutter_actor_get_preferred_height()
- * @allocate: virtual function, used when setting the coordinates of an
+ * @allocate: virtual function, used when settings the coordinates of an
- *   actor; it is used by clutter_actor_allocate(); when overriding this
+ *   actor; it is used by clutter_actor_allocate(); it must chain up to
- *   function without chaining up, clutter_actor_set_allocation() must be
+ *   the parent's implementation, or call clutter_actor_set_allocation()
 *   called and children must be allocated by the implementation, when
 *   chaining up though, those things will be done by the parent's
 *   implementation.
 * @apply_transform: virtual function, used when applying the transformations
 *   to an actor before painting it or when transforming coordinates or
- *   the allocation; if the transformation calculated by this function may
+ *   the allocation; it must chain up to the parent's implementation
 *   have changed, the cached transformation must be invalidated by calling
 *   clutter_actor_invalidate_transform(); it must chain up to the parent's
 *   implementation
 * @parent_set: signal class handler for the #ClutterActor::parent-set
 * @destroy: signal class handler for #ClutterActor::destroy. It must
 *   chain up to the parent's implementation
 * @pick: virtual function, used to draw an outline of the actor with
 *   the given color
 * @queue_redraw: class handler for #ClutterActor::queue-redraw
 * @event: class handler for #ClutterActor::event
 * @button_press_event: class handler for #ClutterActor::button-press-event
 * @button_release_event: class handler for
@ -223,20 +221,23 @@ struct _ClutterActorClass
  /*< public >*/
  void (* show)                 (ClutterActor          *self);
  void (* show_all)             (ClutterActor          *self);
  void (* hide)                 (ClutterActor          *self);
  void (* hide_all)             (ClutterActor          *self);
  void (* realize)              (ClutterActor          *self);
  void (* unrealize)            (ClutterActor          *self);
  void (* map)                  (ClutterActor          *self);
  void (* unmap)                (ClutterActor          *self);
-  void (* paint)                (ClutterActor          *self,
+  void (* paint)                (ClutterActor          *self);
                                 ClutterPaintContext   *paint_context);
  void (* parent_set)           (ClutterActor          *actor,
                                 ClutterActor          *old_parent);
  void (* destroy)              (ClutterActor          *self);
  void (* pick)                 (ClutterActor          *actor,
-                                 ClutterPickContext    *pick_context);
+                                 const ClutterColor    *color);
  void (* queue_redraw)         (ClutterActor          *actor,
                                 ClutterActor          *leaf_that_queued);
  /* size negotiation */
  void (* get_preferred_width)  (ClutterActor           *self,
@ -248,11 +249,12 @@ struct _ClutterActorClass
                                 gfloat                 *min_height_p,
                                 gfloat                 *natural_height_p);
  void (* allocate)             (ClutterActor           *self,
-                                 const ClutterActorBox  *box);
+                                 const ClutterActorBox  *box,
                                 ClutterAllocationFlags  flags);
  /* transformations */
  void (* apply_transform)      (ClutterActor           *actor,
-                                 graphene_matrix_t      *matrix);
+                                 ClutterMatrix          *matrix);
  /* event signals */
  gboolean (* event)                (ClutterActor         *actor,
@ -293,14 +295,10 @@ struct _ClutterActorClass
  gboolean (* touch_event)          (ClutterActor         *self,
                                     ClutterTouchEvent    *event);
  gboolean (* has_accessible)       (ClutterActor         *self);
  void     (* resource_scale_changed) (ClutterActor *self);
  float    (* calculate_resource_scale) (ClutterActor *self,
                                         int           phase);
  /*< private >*/
  /* padding for future expansion */
-  gpointer _padding_dummy[25];
+  gpointer _padding_dummy[26];
 };
 /**
@ -324,570 +322,548 @@ struct _ClutterActorIter
  gpointer CLUTTER_PRIVATE_FIELD (dummy5);
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_actor_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_new                               (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_flags                         (ClutterActor                *self,
                                                                                 ClutterActorFlags            flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unset_flags                       (ClutterActor                *self,
                                                                                 ClutterActorFlags            flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorFlags               clutter_actor_get_flags                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_show                              (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_hide                              (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_realize                           (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unrealize                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_map                               (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unmap                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
-void                            clutter_actor_paint                             (ClutterActor                *self,
+void                            clutter_actor_paint                             (ClutterActor                *self);
-                                                                                 ClutterPaintContext         *paint_context);
+CLUTTER_AVAILABLE_IN_ALL
-CLUTTER_EXPORT
+void                            clutter_actor_continue_paint                    (ClutterActor                *self);
-void                            clutter_actor_continue_paint                    (ClutterActor                *self,
+CLUTTER_AVAILABLE_IN_ALL
                                                                                 ClutterPaintContext         *paint_context);
 CLUTTER_EXPORT
 void                            clutter_actor_pick                              (ClutterActor                *actor,
                                                                                 ClutterPickContext          *pick_context);
 CLUTTER_EXPORT
 void                            clutter_actor_continue_pick                     (ClutterActor                *actor,
                                                                                 ClutterPickContext          *pick_context);
 CLUTTER_EXPORT
 void                            clutter_actor_queue_redraw                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_queue_redraw_with_clip            (ClutterActor                *self,
                                                                                 const cairo_rectangle_int_t *clip);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_queue_relayout                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_destroy                           (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_name                          (ClutterActor                *self,
                                                                                 const gchar                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *                   clutter_actor_get_name                          (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 AtkObject *                     clutter_actor_get_accessible                    (ClutterActor                *self);
 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_accessible                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_visible                        (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_mapped                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 gboolean                        clutter_actor_is_realized                       (ClutterActor                *self);
 /* Size negotiation */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_request_mode                  (ClutterActor                *self,
                                                                                 ClutterRequestMode           mode);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterRequestMode              clutter_actor_get_request_mode                  (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_width               (ClutterActor                *self,
                                                                                 gfloat                       for_height,
                                                                                 gfloat                      *min_width_p,
                                                                                 gfloat                      *natural_width_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_height              (ClutterActor                *self,
                                                                                 gfloat                       for_width,
                                                                                 gfloat                      *min_height_p,
                                                                                 gfloat                      *natural_height_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_size                (ClutterActor                *self,
                                                                                 gfloat                      *min_width_p,
                                                                                 gfloat                      *min_height_p,
                                                                                 gfloat                      *natural_width_p,
                                                                                 gfloat                      *natural_height_p);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate                          (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box);
+                                                                                 const ClutterActorBox       *box,
-CLUTTER_EXPORT
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_preferred_size           (ClutterActor                *self,
-                                                                                 float                        x,
+                                                                                 ClutterAllocationFlags       flags);
-                                                                                 float                        y);
+CLUTTER_AVAILABLE_IN_ALL
 CLUTTER_EXPORT
 void                            clutter_actor_allocate_available_size           (ClutterActor                *self,
                                                                                 gfloat                       x,
                                                                                 gfloat                       y,
                                                                                 gfloat                       available_width,
-                                                                                 gfloat                       available_height);
+                                                                                 gfloat                       available_height,
-CLUTTER_EXPORT
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_align_fill               (ClutterActor                *self,
                                                                                 const ClutterActorBox       *box,
                                                                                 gdouble                      x_align,
                                                                                 gdouble                      y_align,
                                                                                 gboolean                     x_fill,
-                                                                                 gboolean                     y_fill);
+                                                                                 gboolean                     y_fill,
-CLUTTER_EXPORT
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_allocation                    (ClutterActor                *self,
-                                                                                 const ClutterActorBox       *box);
+                                                                                 const ClutterActorBox       *box,
-CLUTTER_EXPORT
+                                                                                 ClutterAllocationFlags       flags);
 CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_box                (ClutterActor                *self,
                                                                                 ClutterActorBox             *box);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
                                                                                 ClutterActor                *ancestor,
                                                                                 ClutterVertex                verts[]);
 CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_size                          (ClutterActor                *self,
                                                                                 gfloat                       width,
                                                                                 gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_size                          (ClutterActor                *self,
                                                                                 gfloat                      *width,
                                                                                 gfloat                      *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_position                      (ClutterActor                *self,
                                                                                 gfloat                       x,
                                                                                 gfloat                       y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean clutter_actor_get_fixed_position (ClutterActor *self,
                                           float        *x,
                                           float        *y);
 CLUTTER_EXPORT
 void                            clutter_actor_get_position                      (ClutterActor                *self,
                                                                                 gfloat                      *x,
                                                                                 gfloat                      *y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_fixed_position_set            (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_fixed_position_set            (ClutterActor                *self,
                                                                                 gboolean                     is_set);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_move_by                           (ClutterActor                *self,
                                                                                 gfloat                       dx,
                                                                                 gfloat                       dy);
 /* Actor geometry */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_width                         (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_height                        (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_width                         (ClutterActor                *self,
                                                                                 gfloat                       width);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_height                        (ClutterActor                *self,
                                                                                 gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_x                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_y                             (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_x                             (ClutterActor                *self,
                                                                                 gfloat                       x);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_y                             (ClutterActor                *self,
                                                                                 gfloat                       y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_z_position                    (ClutterActor                *self,
                                                                                 gfloat                       z_position);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gfloat                          clutter_actor_get_z_position                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_layout_manager                (ClutterActor                *self,
                                                                                 ClutterLayoutManager        *manager);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterLayoutManager *          clutter_actor_get_layout_manager                (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_x_align                       (ClutterActor                *self,
                                                                                 ClutterActorAlign            x_align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActorAlign               clutter_actor_get_x_align                       (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_y_align                       (ClutterActor                *self,
                                                                                 ClutterActorAlign            y_align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActorAlign               clutter_actor_get_y_align                       (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_top                    (ClutterActor                *self,
                                                                                 gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_top                    (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_bottom                 (ClutterActor                *self,
                                                                                 gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_bottom                 (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_left                   (ClutterActor                *self,
                                                                                 gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_left                   (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin_right                  (ClutterActor                *self,
                                                                                 gfloat                       margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gfloat                          clutter_actor_get_margin_right                  (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_margin                        (ClutterActor                *self,
                                                                                 const ClutterMargin         *margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_margin                        (ClutterActor                *self,
                                                                                 ClutterMargin               *margin);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_x_expand                      (ClutterActor                *self,
                                                                                 gboolean                     expand);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_get_x_expand                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_y_expand                      (ClutterActor                *self,
                                                                                 gboolean                     expand);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_get_y_expand                      (ClutterActor                *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_needs_expand                      (ClutterActor                *self,
                                                                                 ClutterOrientation           orientation);
 /* Paint */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip                          (ClutterActor                *self,
                                                                                 gfloat                       xoff,
                                                                                 gfloat                       yoff,
                                                                                 gfloat                       width,
                                                                                 gfloat                       height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_remove_clip                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_clip                          (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_clip                          (ClutterActor               *self,
                                                                                 gfloat                     *xoff,
                                                                                 gfloat                     *yoff,
                                                                                 gfloat                     *width,
                                                                                 gfloat                     *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip_to_allocation            (ClutterActor               *self,
                                                                                 gboolean                    clip_set);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_clip_to_allocation            (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_opacity                       (ClutterActor               *self,
                                                                                 guint8                      opacity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_opacity                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_paint_opacity                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_visibility              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 void                            clutter_actor_set_offscreen_redirect            (ClutterActor               *self,
                                                                                 ClutterOffscreenRedirect    redirect);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 ClutterOffscreenRedirect        clutter_actor_get_offscreen_redirect            (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
-gboolean                        clutter_actor_should_pick                       (ClutterActor               *self,
+gboolean                        clutter_actor_should_pick_paint                 (ClutterActor               *self);
-                                                                                 ClutterPickContext         *pick_context);
+CLUTTER_AVAILABLE_IN_ALL
 CLUTTER_EXPORT
 gboolean                        clutter_actor_is_in_clone_paint                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_box                     (ClutterActor               *self,
                                                                                 ClutterActorBox            *box);
-
+CLUTTER_AVAILABLE_IN_1_8
 CLUTTER_EXPORT
 float                           clutter_actor_get_resource_scale                (ClutterActor *self);
 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_overlaps                      (ClutterActor               *self);
 /* Content */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content                       (ClutterActor               *self,
                                                                                 ClutterContent             *content);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContent *                clutter_actor_get_content                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content_gravity               (ClutterActor               *self,
                                                                                 ClutterContentGravity       gravity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContentGravity           clutter_actor_get_content_gravity               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_content_scaling_filters       (ClutterActor               *self,
                                                                                 ClutterScalingFilter        min_filter,
                                                                                 ClutterScalingFilter        mag_filter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_content_scaling_filters       (ClutterActor               *self,
                                                                                 ClutterScalingFilter       *min_filter,
                                                                                 ClutterScalingFilter       *mag_filter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_content_repeat                (ClutterActor               *self,
                                                                                 ClutterContentRepeat        repeat);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterContentRepeat            clutter_actor_get_content_repeat                (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_content_box                   (ClutterActor               *self,
                                                                                 ClutterActorBox            *box);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_background_color              (ClutterActor               *self,
                                                                                 const ClutterColor         *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_background_color              (ClutterActor               *self,
                                                                                 ClutterColor               *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_paint_volume                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_transformed_paint_volume      (ClutterActor               *self,
                                                                                 ClutterActor               *relative_to_ancestor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 const ClutterPaintVolume *      clutter_actor_get_default_paint_volume          (ClutterActor               *self);
 /* Events */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_reactive                      (ClutterActor               *actor,
                                                                                 gboolean                    reactive);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_reactive                      (ClutterActor               *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_key_focus                     (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_grab_key_focus                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_event                             (ClutterActor               *actor,
                                                                                 const ClutterEvent         *event,
                                                                                 gboolean                    capture);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_pointer                       (ClutterActor               *self);
 /* Text */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_get_pango_context                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_create_pango_context              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 PangoLayout *                   clutter_actor_create_pango_layout               (ClutterActor               *self,
                                                                                 const gchar                *text);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_text_direction                (ClutterActor               *self,
                                                                                 ClutterTextDirection        text_dir);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTextDirection            clutter_actor_get_text_direction                (ClutterActor               *self);
 /* Actor hierarchy */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_add_child                         (ClutterActor               *self,
                                                                                 ClutterActor               *child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_at_index             (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_above                (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_insert_child_below                (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_replace_child                     (ClutterActor               *self,
                                                                                 ClutterActor               *old_child,
                                                                                 ClutterActor               *new_child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_child                      (ClutterActor               *self,
                                                                                 ClutterActor               *child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_all_children               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_destroy_all_children              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GList *                         clutter_actor_get_children                      (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gint                            clutter_actor_get_n_children                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_child_at_index                (ClutterActor               *self,
                                                                                 gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_previous_sibling              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_next_sibling                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_first_child                   (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_last_child                    (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *                  clutter_actor_get_parent                        (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gboolean                        clutter_actor_contains                          (ClutterActor               *self,
                                                                                 ClutterActor               *descendant);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor*                   clutter_actor_get_stage                         (ClutterActor               *actor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_below_sibling           (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_above_sibling           (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 ClutterActor               *sibling);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_at_index                (ClutterActor               *self,
                                                                                 ClutterActor               *child,
                                                                                 gint                        index_);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_init                         (ClutterActorIter           *iter,
                                                                                 ClutterActor               *root);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                        clutter_actor_iter_next                         (ClutterActorIter           *iter,
                                                                                 ClutterActor              **child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                        clutter_actor_iter_prev                         (ClutterActorIter           *iter,
                                                                                 ClutterActor              **child);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_remove                       (ClutterActorIter           *iter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_iter_destroy                      (ClutterActorIter           *iter);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_iter_is_valid                     (const ClutterActorIter     *iter);
 /* Transformations */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_rotated                        (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_scaled                         (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_pivot_point                   (ClutterActor               *self,
                                                                                 gfloat                      pivot_x,
                                                                                 gfloat                      pivot_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_pivot_point                   (ClutterActor               *self,
                                                                                 gfloat                     *pivot_x,
                                                                                 gfloat                     *pivot_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_pivot_point_z                 (ClutterActor               *self,
                                                                                 gfloat                      pivot_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gfloat                          clutter_actor_get_pivot_point_z                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_rotation_angle                (ClutterActor               *self,
                                                                                 ClutterRotateAxis           axis,
                                                                                 gdouble                     angle);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gdouble                         clutter_actor_get_rotation_angle                (ClutterActor               *self,
                                                                                 ClutterRotateAxis           axis);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_scale                         (ClutterActor               *self,
                                                                                 gdouble                     scale_x,
                                                                                 gdouble                     scale_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_scale                         (ClutterActor               *self,
                                                                                 gdouble                    *scale_x,
                                                                                 gdouble                    *scale_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_scale_z                       (ClutterActor               *self,
                                                                                 gdouble                     scale_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 gdouble                         clutter_actor_get_scale_z                       (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_translation                   (ClutterActor               *self,
                                                                                 gfloat                      translate_x,
                                                                                 gfloat                      translate_y,
                                                                                 gfloat                      translate_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_translation                   (ClutterActor               *self,
                                                                                 gfloat                     *translate_x,
                                                                                 gfloat                     *translate_y,
                                                                                 gfloat                     *translate_z);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_transform                     (ClutterActor               *self,
-                                                                                 const graphene_matrix_t    *transform);
+                                                                                 const ClutterMatrix        *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_transform                     (ClutterActor               *self,
-                                                                                 graphene_matrix_t          *transform);
+                                                                                 ClutterMatrix              *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_child_transform               (ClutterActor               *self,
-                                                                                 const graphene_matrix_t    *transform);
+                                                                                 const ClutterMatrix        *transform);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_child_transform               (ClutterActor               *self,
-                                                                                 graphene_matrix_t          *transform);
+                                                                                 ClutterMatrix              *transform);
-
+CLUTTER_AVAILABLE_IN_ALL
 CLUTTER_EXPORT
 void                            clutter_actor_get_transformed_extents          (ClutterActor               *self,
                                                                                graphene_rect_t            *rect);
 CLUTTER_EXPORT
 void                            clutter_actor_get_transformed_position          (ClutterActor               *self,
                                                                                 gfloat                     *x,
                                                                                 gfloat                     *y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_transformed_size              (ClutterActor               *self,
                                                                                 gfloat                     *width,
                                                                                 gfloat                     *height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_transform_stage_point             (ClutterActor               *self,
                                                                                 gfloat                      x,
                                                                                 gfloat                      y,
                                                                                 gfloat                     *x_out,
                                                                                 gfloat                     *y_out);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_abs_allocation_vertices       (ClutterActor               *self,
-                                                                                 graphene_point3d_t         *verts);
+                                                                                 ClutterVertex               verts[]);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_transform_to_point          (ClutterActor               *self,
-                                                                                 const graphene_point3d_t   *point,
+                                                                                 const ClutterVertex        *point,
-                                                                                 graphene_point3d_t         *vertex);
+                                                                                 ClutterVertex              *vertex);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_relative_transform_to_point (ClutterActor               *self,
                                                                                 ClutterActor               *ancestor,
-                                                                                 const graphene_point3d_t   *point,
+                                                                                 const ClutterVertex        *point,
-                                                                                 graphene_point3d_t         *vertex);
+                                                                                 ClutterVertex              *vertex);
 /* Implicit animations */
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_save_easing_state                 (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_restore_easing_state              (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_mode                   (ClutterActor               *self,
                                                                                 ClutterAnimationMode        mode);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterAnimationMode            clutter_actor_get_easing_mode                   (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_duration               (ClutterActor               *self,
                                                                                 guint                       msecs);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 guint                           clutter_actor_get_easing_duration               (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_easing_delay                  (ClutterActor               *self,
                                                                                 guint                       msecs);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 guint                           clutter_actor_get_easing_delay                  (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterTransition *             clutter_actor_get_transition                    (ClutterActor               *self,
                                                                                 const char                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_add_transition                    (ClutterActor               *self,
                                                                                 const char                 *name,
                                                                                 ClutterTransition          *transition);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_transition                 (ClutterActor               *self,
                                                                                 const char                 *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_remove_all_transitions            (ClutterActor               *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_16
 gboolean                        clutter_actor_has_mapped_clones                 (ClutterActor *self);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_22
 void                            clutter_actor_set_opacity_override              (ClutterActor               *self,
                                                                                 gint                        opacity);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_22
 gint                            clutter_actor_get_opacity_override              (ClutterActor               *self);
 CLUTTER_EXPORT
 void                            clutter_actor_inhibit_culling                   (ClutterActor               *actor);
 CLUTTER_EXPORT
 void                            clutter_actor_uninhibit_culling                 (ClutterActor               *actor);
 /**
 * ClutterActorCreateChildFunc:
 * @item: (type GObject): the item in the model
@ -907,33 +883,19 @@ void                            clutter_actor_uninhibit_culling
 typedef ClutterActor * (* ClutterActorCreateChildFunc) (gpointer item,
                                                        gpointer user_data);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 void                            clutter_actor_bind_model                        (ClutterActor               *self,
                                                                                 GListModel                 *model,
                                                                                 ClutterActorCreateChildFunc create_child_func,
                                                                                 gpointer                    user_data,
                                                                                 GDestroyNotify              notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_24
 void                            clutter_actor_bind_model_with_properties        (ClutterActor               *self,
                                                                                 GListModel                 *model,
                                                                                 GType                       child_type,
                                                                                 const char                 *first_model_property,
                                                                                 ...);
 CLUTTER_EXPORT
 void clutter_actor_pick_box (ClutterActor          *self,
                             ClutterPickContext    *pick_context,
                             const ClutterActorBox *box);
 CLUTTER_EXPORT
 GList * clutter_actor_peek_stage_views (ClutterActor *self);
 CLUTTER_EXPORT
 void clutter_actor_invalidate_transform (ClutterActor *self);
 CLUTTER_EXPORT
 void clutter_actor_invalidate_paint_volume (ClutterActor *self);
 G_END_DECLS
 #endif /* __CLUTTER_ACTOR_H__ */
--- a/clutter/clutter/clutter-align-constraint.c
+++ b/clutter/clutter/clutter-align-constraint.c
@ -34,7 +34,9 @@
 * #ClutterAlignConstraint is available since Clutter 1.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-align-constraint.h"
@ -58,7 +60,6 @@ struct _ClutterAlignConstraint
  ClutterActor *actor;
  ClutterActor *source;
  ClutterAlignAxis align_axis;
  graphene_point_t pivot;
  gfloat factor;
 };
@ -73,7 +74,6 @@ enum
  PROP_SOURCE,
  PROP_ALIGN_AXIS,
  PROP_PIVOT_POINT,
  PROP_FACTOR,
  PROP_LAST
@ -86,11 +86,13 @@ G_DEFINE_TYPE (ClutterAlignConstraint,
               CLUTTER_TYPE_CONSTRAINT);
 static void
-source_queue_relayout (ClutterActor           *actor,
+source_position_changed (ClutterActor           *actor,
-                       ClutterAlignConstraint *align)
+                         const ClutterActorBox  *allocation,
                         ClutterAllocationFlags  flags,
                         ClutterAlignConstraint *align)
 {
  if (align->actor != NULL)
-    _clutter_actor_queue_only_relayout (align->actor);
+    clutter_actor_queue_relayout (align->actor);
 }
 static void
@ -135,41 +137,35 @@ clutter_align_constraint_update_allocation (ClutterConstraint *constraint,
  ClutterAlignConstraint *align = CLUTTER_ALIGN_CONSTRAINT (constraint);
  gfloat source_width, source_height;
  gfloat actor_width, actor_height;
-  gfloat offset_x_start, offset_y_start;
+  gfloat source_x, source_y;
  gfloat pivot_x, pivot_y;
  if (align->source == NULL)
    return;
  clutter_actor_box_get_size (allocation, &actor_width, &actor_height);
  clutter_actor_get_position (align->source, &source_x, &source_y);
  clutter_actor_get_size (align->source, &source_width, &source_height);
  pivot_x = align->pivot.x == -1.f
    ? align->factor
    : align->pivot.x;
  pivot_y = align->pivot.y == -1.f
    ? align->factor
    : align->pivot.y;
  offset_x_start = pivot_x * -actor_width;
  offset_y_start = pivot_y * -actor_height;
  switch (align->align_axis)
    {
    case CLUTTER_ALIGN_X_AXIS:
-      allocation->x1 += offset_x_start + (source_width * align->factor);
+      allocation->x1 = ((source_width - actor_width) * align->factor)
                     + source_x;
      allocation->x2 = allocation->x1 + actor_width;
      break;
    case CLUTTER_ALIGN_Y_AXIS:
-      allocation->y1 += offset_y_start + (source_height * align->factor);
+      allocation->y1 = ((source_height - actor_height) * align->factor)
                     + source_y;
      allocation->y2 = allocation->y1 + actor_height;
      break;
    case CLUTTER_ALIGN_BOTH:
-      allocation->x1 += offset_x_start + (source_width * align->factor);
+      allocation->x1 = ((source_width - actor_width) * align->factor)
-      allocation->y1 += offset_y_start + (source_height * align->factor);
+                     + source_x;
      allocation->y1 = ((source_height - actor_height) * align->factor)
                     + source_y;
      allocation->x2 = allocation->x1 + actor_width;
      allocation->y2 = allocation->y1 + actor_height;
      break;
@ -193,7 +189,7 @@ clutter_align_constraint_dispose (GObject *gobject)
                                            G_CALLBACK (source_destroyed),
                                            align);
      g_signal_handlers_disconnect_by_func (align->source,
-                                            G_CALLBACK (source_queue_relayout),
+                                            G_CALLBACK (source_position_changed),
                                            align);
      align->source = NULL;
    }
@ -219,10 +215,6 @@ clutter_align_constraint_set_property (GObject      *gobject,
      clutter_align_constraint_set_align_axis (align, g_value_get_enum (value));
      break;
    case PROP_PIVOT_POINT:
      clutter_align_constraint_set_pivot_point (align, g_value_get_boxed (value));
      break;
    case PROP_FACTOR:
      clutter_align_constraint_set_factor (align, g_value_get_float (value));
      break;
@ -251,16 +243,6 @@ clutter_align_constraint_get_property (GObject    *gobject,
      g_value_set_enum (value, align->align_axis);
      break;
    case PROP_PIVOT_POINT:
      {
        graphene_point_t point;
        clutter_align_constraint_get_pivot_point (align, &point);
        g_value_set_boxed (value, &point);
      }
      break;
    case PROP_FACTOR:
      g_value_set_float (value, align->factor);
      break;
@ -314,30 +296,6 @@ clutter_align_constraint_class_init (ClutterAlignConstraintClass *klass)
                       CLUTTER_ALIGN_X_AXIS,
                       CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
  /**
   * ClutterAlignConstraint:pivot-point:
   *
   * The pivot point used by the constraint. The pivot point is the
   * point in the constraint actor around which the aligning is applied,
   * with (0, 0) being the top left corner of the actor and (1, 1) the
   * bottom right corner of the actor.
   *
   * For example, setting the pivot point to (0.5, 0.5) and using a factor
   * of 1 for both axes will align the actors horizontal and vertical
   * center point with the bottom right corner of the source actor.
   *
   * By default, the pivot point is set to (-1, -1), which means it's not
   * used and the constrained actor will be aligned to always stay inside
   * the source actor.
   */
  obj_props[PROP_PIVOT_POINT] =
    g_param_spec_boxed ("pivot-point",
                       P_("Pivot point"),
                       P_("The pivot point"),
                       GRAPHENE_TYPE_POINT,
                       G_PARAM_READWRITE |
                       G_PARAM_STATIC_STRINGS);
  /**
   * ClutterAlignConstraint:factor:
   *
@ -370,8 +328,6 @@ clutter_align_constraint_init (ClutterAlignConstraint *self)
  self->actor = NULL;
  self->source = NULL;
  self->align_axis = CLUTTER_ALIGN_X_AXIS;
  self->pivot.x = -1.f;
  self->pivot.y = -1.f;
  self->factor = 0.0f;
 }
@ -449,15 +405,15 @@ clutter_align_constraint_set_source (ClutterAlignConstraint *align,
                                            G_CALLBACK (source_destroyed),
                                            align);
      g_signal_handlers_disconnect_by_func (old_source,
-                                            G_CALLBACK (source_queue_relayout),
+                                            G_CALLBACK (source_position_changed),
                                            align);
    }
  align->source = source;
  if (align->source != NULL)
    {
-      g_signal_connect (align->source, "queue-relayout",
+      g_signal_connect (align->source, "allocation-changed",
-                        G_CALLBACK (source_queue_relayout),
+                        G_CALLBACK (source_position_changed),
                        align);
      g_signal_connect (align->source, "destroy",
                        G_CALLBACK (source_destroyed),
@ -534,60 +490,6 @@ clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align)
  return align->align_axis;
 }
 /**
 * clutter_align_constraint_set_pivot_point:
 * @align: a #ClutterAlignConstraint
 * @pivot_point: A #GraphenePoint
 *
 * Sets the pivot point used by the constraint, the pivot point is the
 * point in the constraint actor around which the aligning is applied,
 * with (0, 0) being the top left corner of the actor and (1, 1) the
 * bottom right corner of the actor.
 *
 * If -1 is used, the pivot point is unset and the constrained actor
 * will be aligned to always stay inside the source actor.
 */
 void
 clutter_align_constraint_set_pivot_point (ClutterAlignConstraint *align,
                                          const graphene_point_t *pivot_point)
 {
  g_return_if_fail (CLUTTER_IS_ALIGN_CONSTRAINT (align));
  g_return_if_fail (pivot_point != NULL);
  g_return_if_fail (pivot_point->x == -1.f ||
                    (pivot_point->x >= 0.f && pivot_point->x <= 1.f));
  g_return_if_fail (pivot_point->y == -1.f ||
                    (pivot_point->y >= 0.f && pivot_point->y <= 1.f));
  if (graphene_point_equal (&align->pivot, pivot_point))
    return;
  align->pivot = *pivot_point;
  if (align->actor != NULL)
    clutter_actor_queue_relayout (align->actor);
  g_object_notify_by_pspec (G_OBJECT (align), obj_props[PROP_PIVOT_POINT]);
 }
 /**
 * clutter_align_constraint_get_pivot_point
 * @align: a #ClutterAlignConstraint
 * @pivot_point: (out caller-allocates): return location for a #GraphenePoint
 *
 * Gets the pivot point used by the constraint set with
 * clutter_align_constraint_set_pivot_point(). If no custom pivot
 * point is set, -1 is set.
 */
 void
 clutter_align_constraint_get_pivot_point (ClutterAlignConstraint *align,
                                          graphene_point_t       *pivot_point)
 {
  g_return_if_fail (CLUTTER_IS_ALIGN_CONSTRAINT (align));
  g_return_if_fail (pivot_point != NULL);
  *pivot_point = align->pivot;
 }
 /**
 * clutter_align_constraint_set_factor:
 * @align: a #ClutterAlignConstraint
--- a/clutter/clutter/clutter-align-constraint.h
+++ b/clutter/clutter/clutter-align-constraint.h
@ -48,34 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterAlignConstraint          ClutterAlignConstraint;
 typedef struct _ClutterAlignConstraintClass     ClutterAlignConstraintClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_align_constraint_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *clutter_align_constraint_new            (ClutterActor           *source,
                                                            ClutterAlignAxis        axis,
                                                            gfloat                  factor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_source     (ClutterAlignConstraint *align,
                                                            ClutterActor           *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *     clutter_align_constraint_get_source     (ClutterAlignConstraint *align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
                                                            ClutterAlignAxis        axis);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAlignAxis   clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_pivot_point (ClutterAlignConstraint *align,
                                                             const graphene_point_t *pivot_point);
 CLUTTER_EXPORT
 void               clutter_align_constraint_get_pivot_point (ClutterAlignConstraint *align,
                                                             graphene_point_t       *pivot_point);
 CLUTTER_EXPORT
 void               clutter_align_constraint_set_factor     (ClutterAlignConstraint *align,
                                                            gfloat                  factor);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gfloat             clutter_align_constraint_get_factor     (ClutterAlignConstraint *align);
 G_END_DECLS
--- a/clutter/clutter/clutter-animatable.c
+++ b/clutter/clutter/clutter-animatable.c
@ -27,23 +27,39 @@
 * @short_description: Interface for animatable classes
 *
 * #ClutterAnimatable is an interface that allows a #GObject class
- * to control how an actor will animate a property.
+ * to control how a #ClutterAnimation will animate a property.
 *
 * Each #ClutterAnimatable should implement the
- * #ClutterAnimatableInterface.interpolate_property() virtual function of the
+ * #ClutterAnimatableIface.interpolate_property() virtual function of the
 * interface to compute the animation state between two values of an interval
 * depending on a progress factor, expressed as a floating point value.
 *
 * If a #ClutterAnimatable is animated by a #ClutterAnimation
 * instance, the #ClutterAnimation will call
 * clutter_animatable_interpolate_property() passing the name of the
 * currently animated property; the values interval; and the progress factor.
 * The #ClutterAnimatable implementation should return the computed value for
 * the animated
 * property.
 *
 * #ClutterAnimatable is available since Clutter 1.0
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "clutter-animatable.h"
 #include "clutter-interval.h"
 #include "clutter-debug.h"
 #include "clutter-private.h"
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"
 typedef ClutterAnimatableIface  ClutterAnimatableInterface;
 G_DEFINE_INTERFACE (ClutterAnimatable, clutter_animatable, G_TYPE_OBJECT);
 static void
@ -51,6 +67,80 @@ clutter_animatable_default_init (ClutterAnimatableInterface *iface)
 {
 }
 /**
 * clutter_animatable_animate_property:
 * @animatable: a #ClutterAnimatable
 * @animation: a #ClutterAnimation
 * @property_name: the name of the animated property
 * @initial_value: the initial value of the animation interval
 * @final_value: the final value of the animation interval
 * @progress: the progress factor
 * @value: return location for the animation value
 *
 * Calls the animate_property() virtual function for @animatable.
 *
 * The @initial_value and @final_value #GValue<!-- -->s must contain
 * the same type; @value must have been initialized to the same
 * type of @initial_value and @final_value.
 *
 * All implementation of the #ClutterAnimatable interface must
 * implement this function.
 *
 * Return value: %TRUE if the value has been validated and can
 *   be applied to the #ClutterAnimatable, and %FALSE otherwise
 *
 * Since: 1.0
 *
 * Deprecated: 1.8: Use clutter_animatable_interpolate_value()
 *   instead
 */
 gboolean
 clutter_animatable_animate_property (ClutterAnimatable *animatable,
                                     ClutterAnimation  *animation,
                                     const gchar       *property_name,
                                     const GValue      *initial_value,
                                     const GValue      *final_value,
                                     gdouble            progress,
                                     GValue            *value)
 {
  ClutterAnimatableIface *iface;
  gboolean res;
  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
  g_return_val_if_fail (CLUTTER_IS_ANIMATION (animation), FALSE);
  g_return_val_if_fail (property_name != NULL, FALSE);
  g_return_val_if_fail (initial_value != NULL && final_value != NULL, FALSE);
  g_return_val_if_fail (G_VALUE_TYPE (initial_value) != G_TYPE_INVALID, FALSE);
  g_return_val_if_fail (G_VALUE_TYPE (final_value) != G_TYPE_INVALID, FALSE);
  g_return_val_if_fail (value != NULL, FALSE);
  g_return_val_if_fail (G_VALUE_TYPE (value) == G_VALUE_TYPE (initial_value) &&
                        G_VALUE_TYPE (value) == G_VALUE_TYPE (final_value),
                        FALSE);
  iface = CLUTTER_ANIMATABLE_GET_IFACE (animatable);
  if (iface->animate_property == NULL)
    {
      ClutterInterval *interval;
      interval = clutter_animation_get_interval (animation, property_name);
      if (interval == NULL)
        return FALSE;
      res = clutter_animatable_interpolate_value (animatable, property_name,
                                                  interval,
                                                  progress,
                                                  value);
    }
  else
    res = iface->animate_property (animatable, animation,
                                   property_name,
                                   initial_value, final_value,
                                   progress,
                                   value);
  return res;
 }
 /**
 * clutter_animatable_find_property:
 * @animatable: a #ClutterAnimatable
@ -67,7 +157,7 @@ GParamSpec *
 clutter_animatable_find_property (ClutterAnimatable *animatable,
                                  const gchar       *property_name)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), NULL);
  g_return_val_if_fail (property_name != NULL, NULL);
@ -97,7 +187,7 @@ clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                      const gchar       *property_name,
                                      GValue            *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
  g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
  g_return_if_fail (property_name != NULL);
@ -126,7 +216,7 @@ clutter_animatable_set_final_state (ClutterAnimatable *animatable,
                                    const gchar       *property_name,
                                    const GValue      *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
  g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
  g_return_if_fail (property_name != NULL);
@ -172,7 +262,7 @@ clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                      gdouble            progress,
                                      GValue            *value)
 {
-  ClutterAnimatableInterface *iface;
+  ClutterAnimatableIface *iface;
  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
  g_return_val_if_fail (property_name != NULL, FALSE);
@ -194,25 +284,3 @@ clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
  else
    return clutter_interval_compute_value (interval, progress, value);
 }
 /**
 * clutter_animatable_get_actor:
 * @animatable: a #ClutterAnimatable
 *
 * Get animated actor.
 *
 * Return value: (transfer none): a #ClutterActor
 */
 ClutterActor *
 clutter_animatable_get_actor (ClutterAnimatable *animatable)
 {
  ClutterAnimatableInterface *iface;
  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), NULL);
  iface = CLUTTER_ANIMATABLE_GET_IFACE (animatable);
  g_return_val_if_fail (iface->get_actor, NULL);
  return iface->get_actor (animatable);
 }
--- a/clutter/clutter/clutter-animatable.h
+++ b/clutter/clutter/clutter-animatable.h
@ -33,15 +33,26 @@
 G_BEGIN_DECLS
-#define CLUTTER_TYPE_ANIMATABLE (clutter_animatable_get_type ())
+#define CLUTTER_TYPE_ANIMATABLE                 (clutter_animatable_get_type ())
 #define CLUTTER_ANIMATABLE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ANIMATABLE, ClutterAnimatable))
 #define CLUTTER_IS_ANIMATABLE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ANIMATABLE))
 #define CLUTTER_ANIMATABLE_GET_IFACE(obj)       (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_ANIMATABLE, ClutterAnimatableIface))
-CLUTTER_EXPORT
+typedef struct _ClutterAnimatableIface          ClutterAnimatableIface;
 G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
                     CLUTTER, ANIMATABLE,
                     GObject)
 /**
- * ClutterAnimatableInterface:
+ * ClutterAnimatable:
 *
 * #ClutterAnimatable is an opaque structure whose members cannot be directly
 * accessed
 *
 * Since: 1.0
 */
 /**
 * ClutterAnimatableIface:
 * @animate_property: virtual function for custom interpolation of a
 *   property. This virtual function is deprecated
 * @find_property: virtual function for retrieving the #GParamSpec of
 *   an animatable property
 * @get_initial_state: virtual function for retrieving the initial
@ -50,16 +61,25 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
 *   animatable property
 * @interpolate_value: virtual function for interpolating the progress
 *   of a property
- * @get_actor: virtual function for getting associated actor
+ *
 * Base interface for #GObject<!-- -->s that can be animated by a
 * a #ClutterAnimation.
 *
 * Since: 1.0
 */
-struct _ClutterAnimatableInterface
+struct _ClutterAnimatableIface
 {
  /*< private >*/
  GTypeInterface parent_iface;
  /*< public >*/
  gboolean    (* animate_property)  (ClutterAnimatable *animatable,
                                     ClutterAnimation  *animation,
                                     const gchar       *property_name,
                                     const GValue      *initial_value,
                                     const GValue      *final_value,
                                     gdouble            progress,
                                     GValue            *value);
  GParamSpec *(* find_property)     (ClutterAnimatable *animatable,
                                     const gchar       *property_name);
  void        (* get_initial_state) (ClutterAnimatable *animatable,
@ -73,30 +93,29 @@ struct _ClutterAnimatableInterface
                                     ClutterInterval   *interval,
                                     gdouble            progress,
                                     GValue            *value);
  ClutterActor * (* get_actor)      (ClutterAnimatable *animatable);
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_animatable_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *clutter_animatable_find_property     (ClutterAnimatable *animatable,
                                                  const gchar       *property_name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                                  const gchar       *property_name,
                                                  GValue            *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_set_final_state   (ClutterAnimatable *animatable,
                                                  const gchar       *property_name,
                                                  const GValue      *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 gboolean    clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                                  const gchar       *property_name,
                                                  ClutterInterval   *interval,
                                                  gdouble            progress,
                                                  GValue            *value);
 CLUTTER_EXPORT
 ClutterActor * clutter_animatable_get_actor      (ClutterAnimatable *animatable);
 G_END_DECLS
 #endif /* __CLUTTER_ANIMATABLE_H__ */
--- a/clutter/clutter/clutter-autocleanups.h
+++ b/clutter/clutter/clutter-autocleanups.h
@ -30,8 +30,11 @@
 #ifndef __GI_SCANNER__
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActor, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActorMeta, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAlignConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAnimatable, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBackend, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBindConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBindingPool, g_object_unref)
@ -41,15 +44,21 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBoxLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterBrightnessContrastEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterCanvas, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterChildMeta, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterClickAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterClone, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterColorizeEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterConstraint, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterContainer, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterContent, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDeformEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDesaturateEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDeviceManager, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDragAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterDropAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterEffect, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterFixedLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterFlowLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterGestureAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterGridLayout, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterImage, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterInputDevice, g_object_unref)
@ -83,10 +92,14 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterZoomAction, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterActorBox, clutter_actor_box_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterColor, clutter_color_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterMargin, clutter_margin_free)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPaintContext, clutter_paint_context_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterMatrix, clutter_matrix_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPaintNode, clutter_paint_node_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPaintVolume, clutter_paint_volume_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPathNode, clutter_path_node_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPoint, clutter_point_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterRect, clutter_rect_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterSize, clutter_size_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterVertex, clutter_vertex_free)
 #endif /* __GI_SCANNER__ */
--- a/clutter/clutter/clutter-backend-private.h
+++ b/clutter/clutter/clutter-backend-private.h
@ -23,9 +23,11 @@
 #define __CLUTTER_BACKEND_PRIVATE_H__
 #include <clutter/clutter-backend.h>
-#include <clutter/clutter-seat.h>
+#include <clutter/clutter-device-manager.h>
 #include <clutter/clutter-stage-window.h>
 #include "clutter-event-translator.h"
 #define CLUTTER_BACKEND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BACKEND, ClutterBackendClass))
 #define CLUTTER_IS_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BACKEND))
 #define CLUTTER_BACKEND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BACKEND, ClutterBackendClass))
@ -46,6 +48,8 @@ struct _ClutterBackend
  CoglOnscreen *dummy_onscreen;
  ClutterDeviceManager *device_manager;
  cairo_font_options_t *font_options;
  gchar *font_name;
@ -53,9 +57,7 @@ struct _ClutterBackend
  gfloat units_per_em;
  gint32 units_serial;
-  float fallback_resource_scale;
+  GList *event_translators;
  ClutterStageWindow *stage_window;
  ClutterInputMethod *input_method;
 };
@ -73,6 +75,7 @@ struct _ClutterBackendClass
  ClutterStageWindow *  (* create_stage)       (ClutterBackend  *backend,
                                                ClutterStage    *wrapper,
                                                GError         **error);
  void                  (* init_events)        (ClutterBackend  *backend);
  void                  (* init_features)      (ClutterBackend  *backend);
  void                  (* add_options)        (ClutterBackend  *backend,
                                                GOptionGroup    *group);
@ -85,14 +88,21 @@ struct _ClutterBackendClass
                                                GError         **error);
  gboolean              (* create_context)     (ClutterBackend  *backend,
                                                GError         **error);
  ClutterDeviceManager *(* get_device_manager) (ClutterBackend  *backend);
  void                  (* copy_event_data)    (ClutterBackend     *backend,
                                                const ClutterEvent *src,
                                                ClutterEvent       *dest);
  void                  (* free_event_data)    (ClutterBackend     *backend,
                                                ClutterEvent       *event);
  gboolean              (* translate_event)    (ClutterBackend     *backend,
                                                gpointer            native,
                                                ClutterEvent       *event);
-  ClutterSeat *         (* get_default_seat)   (ClutterBackend *backend);
+  PangoDirection        (* get_keymap_direction) (ClutterBackend   *backend);
-  gboolean              (* is_display_server)  (ClutterBackend *backend);
+  void                  (* bell_notify)          (ClutterBackend   *backend);
  /* signals */
  void (* resolution_changed) (ClutterBackend *backend);
@ -115,32 +125,37 @@ gboolean                _clutter_backend_pre_parse                      (Clutter
 gboolean                _clutter_backend_post_parse                     (ClutterBackend         *backend,
                                                                         GError                **error);
-CLUTTER_EXPORT
+void                    _clutter_backend_init_events                    (ClutterBackend         *backend);
 void                    _clutter_backend_copy_event_data                (ClutterBackend         *backend,
                                                                         const ClutterEvent     *src,
                                                                         ClutterEvent           *dest);
 void                    _clutter_backend_free_event_data                (ClutterBackend         *backend,
                                                                         ClutterEvent           *event);
 gboolean                _clutter_backend_translate_event                (ClutterBackend         *backend,
                                                                         gpointer                native,
                                                                         ClutterEvent           *event);
 CLUTTER_AVAILABLE_IN_MUTTER
 void                    _clutter_backend_add_event_translator           (ClutterBackend         *backend,
                                                                         ClutterEventTranslator *translator);
 void                    _clutter_backend_remove_event_translator        (ClutterBackend         *backend,
                                                                         ClutterEventTranslator *translator);
 ClutterFeatureFlags     _clutter_backend_get_features                   (ClutterBackend         *backend);
 gfloat                  _clutter_backend_get_units_per_em               (ClutterBackend         *backend,
                                                                         PangoFontDescription   *font_desc);
 gint32                  _clutter_backend_get_units_serial               (ClutterBackend         *backend);
 PangoDirection          _clutter_backend_get_keymap_direction           (ClutterBackend         *backend);
 CLUTTER_AVAILABLE_IN_MUTTER
 void                    _clutter_backend_reset_cogl_framebuffer         (ClutterBackend         *backend);
 void                    clutter_set_allowed_drivers                     (const char             *drivers);
-CLUTTER_EXPORT
+void                    clutter_try_set_windowing_backend               (const char             *drivers);
 ClutterStageWindow *    clutter_backend_get_stage_window                (ClutterBackend         *backend);
 CLUTTER_EXPORT
 void clutter_backend_set_fallback_resource_scale (ClutterBackend *backend,
                                                  float           fallback_resource_scale);
 float clutter_backend_get_fallback_resource_scale (ClutterBackend *backend);
 gboolean clutter_backend_is_display_server (ClutterBackend *backend);
 CLUTTER_EXPORT
 void clutter_backend_destroy (ClutterBackend *backend);
 G_END_DECLS
--- a/clutter/clutter/clutter-backend.c
+++ b/clutter/clutter/clutter-backend.c
@ -38,7 +38,11 @@
 * #ClutterBackend is available since Clutter 0.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-backend-private.h"
 #include "clutter-debug.h"
@ -49,9 +53,34 @@
 #include "clutter-stage-manager-private.h"
 #include "clutter-stage-private.h"
 #include "clutter-stage-window.h"
 #include "clutter-version.h"
 #include "clutter-device-manager-private.h"
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-backend.h"
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include "wayland/clutter-wayland-compositor.h"
 #endif
 #include <cogl/cogl.h>
 #ifdef CLUTTER_INPUT_X11
 #include "x11/clutter-backend-x11.h"
 #endif
 #ifdef CLUTTER_INPUT_EVDEV
 #include "evdev/clutter-device-manager-evdev.h"
 #endif
 #ifdef CLUTTER_WINDOWING_EGL
 #include "egl/clutter-backend-eglnative.h"
 #endif
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include <cogl/cogl-wayland-server.h>
 #include <wayland-server.h>
 #include "wayland/clutter-wayland-compositor.h"
 #endif
 #define DEFAULT_FONT_NAME       "Sans 10"
 enum
@ -67,6 +96,12 @@ G_DEFINE_ABSTRACT_TYPE (ClutterBackend, clutter_backend, G_TYPE_OBJECT)
 static guint backend_signals[LAST_SIGNAL] = { 0, };
 /* Global for being able to specify a compositor side wayland display
 * pointer before clutter initialization */
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 static struct wl_display *_wayland_compositor_display;
 #endif
 static void
 clutter_backend_dispose (GObject *gobject)
 {
@ -75,22 +110,28 @@ clutter_backend_dispose (GObject *gobject)
  /* clear the events still in the queue of the main context */
  _clutter_clear_events_queue ();
-  g_clear_object (&backend->dummy_onscreen);
+  /* remove all event translators */
-  if (backend->stage_window)
+  g_clear_pointer (&backend->event_translators, g_list_free);
    {
      g_object_remove_weak_pointer (G_OBJECT (backend->stage_window),
                                    (gpointer *) &backend->stage_window);
      backend->stage_window = NULL;
    }
-  g_clear_pointer (&backend->cogl_source, g_source_destroy);
+  g_clear_pointer (&backend->dummy_onscreen, cogl_object_unref);
  g_clear_pointer (&backend->font_name, g_free);
  g_clear_pointer (&backend->font_options, cairo_font_options_destroy);
  g_clear_object (&backend->input_method);
  G_OBJECT_CLASS (clutter_backend_parent_class)->dispose (gobject);
 }
 static void
 clutter_backend_finalize (GObject *gobject)
 {
  ClutterBackend *backend = CLUTTER_BACKEND (gobject);
  g_source_destroy (backend->cogl_source);
  g_free (backend->font_name);
  clutter_backend_set_font_options (backend, NULL);
  g_clear_object (&backend->input_method);
  G_OBJECT_CLASS (clutter_backend_parent_class)->finalize (gobject);
 }
 static gfloat
 get_units_per_em (ClutterBackend       *backend,
                  PangoFontDescription *font_desc)
@ -189,20 +230,22 @@ clutter_backend_do_real_create_context (ClutterBackend  *backend,
 {
  ClutterBackendClass *klass;
  CoglSwapChain *swap_chain;
  GError *internal_error;
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  swap_chain = NULL;
  internal_error = NULL;
  CLUTTER_NOTE (BACKEND, "Creating Cogl renderer");
-  backend->cogl_renderer = klass->get_renderer (backend, error);
+  backend->cogl_renderer = klass->get_renderer (backend, &internal_error);
  if (backend->cogl_renderer == NULL)
    goto error;
  CLUTTER_NOTE (BACKEND, "Connecting the renderer");
  cogl_renderer_set_driver (backend->cogl_renderer, driver_id);
-  if (!cogl_renderer_connect (backend->cogl_renderer, error))
+  if (!cogl_renderer_connect (backend->cogl_renderer, &internal_error))
    goto error;
  CLUTTER_NOTE (BACKEND, "Creating Cogl swap chain");
@ -214,7 +257,7 @@ clutter_backend_do_real_create_context (ClutterBackend  *backend,
      backend->cogl_display = klass->get_display (backend,
                                                  backend->cogl_renderer,
                                                  swap_chain,
-                                                  error);
+                                                  &internal_error);
    }
  else
    {
@ -230,7 +273,7 @@ clutter_backend_do_real_create_context (ClutterBackend  *backend,
       */
      res = cogl_renderer_check_onscreen_template (backend->cogl_renderer,
                                                   tmpl,
-                                                   error);
+                                                   &internal_error);
      if (!res)
        goto error;
@ -244,12 +287,17 @@ clutter_backend_do_real_create_context (ClutterBackend  *backend,
  if (backend->cogl_display == NULL)
    goto error;
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
  cogl_wayland_display_set_compositor_display (backend->cogl_display,
                                               _wayland_compositor_display);
 #endif
  CLUTTER_NOTE (BACKEND, "Setting up the display");
-  if (!cogl_display_setup (backend->cogl_display, error))
+  if (!cogl_display_setup (backend->cogl_display, &internal_error))
    goto error;
  CLUTTER_NOTE (BACKEND, "Creating the Cogl context");
-  backend->cogl_context = cogl_context_new (backend->cogl_display, error);
+  backend->cogl_context = cogl_context_new (backend->cogl_display, &internal_error);
  if (backend->cogl_context == NULL)
    goto error;
@ -355,7 +403,7 @@ clutter_backend_real_create_context (ClutterBackend  *backend,
      else
        g_set_error_literal (error, CLUTTER_INIT_ERROR,
                             CLUTTER_INIT_ERROR_BACKEND,
-                             "Unable to initialize the Clutter backend: no available drivers found.");
+                            _("Unable to initialize the Clutter backend: no available drivers found."));
      return FALSE;
    }
@ -382,6 +430,14 @@ clutter_backend_real_get_features (ClutterBackend *backend)
      flags |= CLUTTER_FEATURE_STAGE_STATIC;
    }
  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_THROTTLE))
    {
      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers throttling");
      flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
    }
  else
    CLUTTER_NOTE (BACKEND, "Cogl doesn't support swap buffers throttling");
  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_BUFFERS_EVENT))
    {
      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers complete events");
@ -391,8 +447,23 @@ clutter_backend_real_get_features (ClutterBackend *backend)
  return flags;
 }
 static const char *allowed_backends;
 static ClutterBackend * (* custom_backend_func) (void);
 static const struct {
  const char *name;
  ClutterBackend * (* create_backend) (void);
 } available_backends[] = {
 #ifdef CLUTTER_WINDOWING_X11
  { CLUTTER_WINDOWING_X11, clutter_backend_x11_new },
 #endif
 #ifdef CLUTTER_WINDOWING_EGL
  { CLUTTER_WINDOWING_EGL, clutter_backend_egl_native_new },
 #endif
  { NULL, NULL },
 };
 void
 clutter_set_custom_backend_func (ClutterBackend *(* func) (void))
 {
@ -402,23 +473,148 @@ clutter_set_custom_backend_func (ClutterBackend *(* func) (void))
 ClutterBackend *
 _clutter_create_backend (void)
 {
  const char *backends_list;
  ClutterBackend *retval;
  gboolean allow_any;
  char **backends;
  int i;
-  g_return_val_if_fail (custom_backend_func, NULL);
+  if (custom_backend_func)
    {
      retval = custom_backend_func ();
-  retval = custom_backend_func ();
+      if (!retval)
-  if (!retval)
+        g_error ("Failed to create custom backend.");
-    g_error ("Failed to create custom backend.");
+
      return retval;
    }
  if (allowed_backends == NULL)
    allowed_backends = "*";
  allow_any = strstr (allowed_backends, "*") != NULL;
  backends_list = g_getenv ("CLUTTER_BACKEND");
  if (backends_list == NULL)
    backends_list = allowed_backends;
  backends = g_strsplit (backends_list, ",", 0);
  retval = NULL;
  for (i = 0; retval == NULL && backends[i] != NULL; i++)
    {
      const char *backend = backends[i];
      gboolean is_any = g_str_equal (backend, "*");
      int j;
      for (j = 0; available_backends[j].name != NULL; j++)
        {
          if ((is_any && allow_any) ||
              (is_any && strstr (allowed_backends, available_backends[j].name)) ||
              g_str_equal (backend, available_backends[j].name))
            {
              retval = available_backends[j].create_backend ();
              if (retval != NULL)
                break;
            }
        }
    }
  g_strfreev (backends);
  if (retval == NULL)
    g_error ("No default Clutter backend found.");
  return retval;
 }
 static void
 clutter_backend_real_init_events (ClutterBackend *backend)
 {
  const char *input_backend = NULL;
  input_backend = g_getenv ("CLUTTER_INPUT_BACKEND");
  if (input_backend != NULL)
    input_backend = g_intern_string (input_backend);
 #ifdef CLUTTER_INPUT_X11
  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11) &&
      (input_backend == NULL || input_backend == I_(CLUTTER_INPUT_X11)))
    {
      _clutter_backend_x11_events_init (backend);
    }
  else
 #endif
 #ifdef CLUTTER_INPUT_EVDEV
  /* Evdev can be used regardless of the windowing system */
  if ((input_backend != NULL && strcmp (input_backend, CLUTTER_INPUT_EVDEV) == 0)
 #ifdef CLUTTER_WINDOWING_EGL
      /* but we do want to always use it for EGL native */
      || clutter_check_windowing_backend (CLUTTER_WINDOWING_EGL)
 #endif
      )
    {
      _clutter_events_evdev_init (backend);
    }
  else
 #endif
  if (input_backend != NULL)
    {
      if (input_backend != I_(CLUTTER_INPUT_NULL))
        g_error ("Unrecognized input backend '%s'", input_backend);
    }
  else
    g_error ("Unknown input backend");
 }
 static ClutterDeviceManager *
 clutter_backend_real_get_device_manager (ClutterBackend *backend)
 {
  if (G_UNLIKELY (backend->device_manager == NULL))
    {
      g_critical ("No device manager available, expect broken input");
      return NULL;
    }
  return backend->device_manager;
 }
 static gboolean
 clutter_backend_real_translate_event (ClutterBackend *backend,
                                      gpointer        native,
                                      ClutterEvent   *event)
 {
  GList *l;
  for (l = backend->event_translators;
       l != NULL;
       l = l->next)
    {
      ClutterEventTranslator *translator = l->data;
      ClutterTranslateReturn retval;
      retval = _clutter_event_translator_translate_event (translator,
                                                          native,
                                                          event);
      if (retval == CLUTTER_TRANSLATE_QUEUE)
        return TRUE;
      if (retval == CLUTTER_TRANSLATE_REMOVE)
        return FALSE;
    }
  return FALSE;
 }
 static void
 clutter_backend_class_init (ClutterBackendClass *klass)
 {
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->dispose = clutter_backend_dispose;
  gobject_class->finalize = clutter_backend_finalize;
  /**
   * ClutterBackend::resolution-changed:
@ -434,7 +630,8 @@ clutter_backend_class_init (ClutterBackendClass *klass)
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (ClutterBackendClass, resolution_changed),
-                  NULL, NULL, NULL,
+                  NULL, NULL,
                  _clutter_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
  /**
@ -451,7 +648,8 @@ clutter_backend_class_init (ClutterBackendClass *klass)
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (ClutterBackendClass, font_changed),
-                  NULL, NULL, NULL,
+                  NULL, NULL,
                  _clutter_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
  /**
@ -468,12 +666,16 @@ clutter_backend_class_init (ClutterBackendClass *klass)
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (ClutterBackendClass, settings_changed),
-                  NULL, NULL, NULL,
+                  NULL, NULL,
                  _clutter_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
  klass->resolution_changed = clutter_backend_real_resolution_changed;
  klass->font_changed = clutter_backend_real_font_changed;
  klass->init_events = clutter_backend_real_init_events;
  klass->get_device_manager = clutter_backend_real_get_device_manager;
  klass->translate_event = clutter_backend_real_translate_event;
  klass->create_context = clutter_backend_real_create_context;
  klass->get_features = clutter_backend_real_get_features;
 }
@ -484,9 +686,7 @@ clutter_backend_init (ClutterBackend *self)
  self->units_per_em = -1.0;
  self->units_serial = 1;
-  self->dummy_onscreen = NULL;
+  self->dummy_onscreen = COGL_INVALID_HANDLE;
  self->fallback_resource_scale = 1.f;
 }
 void
@ -554,10 +754,6 @@ _clutter_backend_create_stage (ClutterBackend  *backend,
  g_assert (CLUTTER_IS_STAGE_WINDOW (stage_window));
  backend->stage_window = stage_window;
  g_object_add_weak_pointer (G_OBJECT (backend->stage_window),
                             (gpointer *) &backend->stage_window);
  return stage_window;
 }
@ -612,6 +808,17 @@ _clutter_backend_get_features (ClutterBackend *backend)
  return 0;
 }
 void
 _clutter_backend_init_events (ClutterBackend *backend)
 {
  ClutterBackendClass *klass;
  g_assert (CLUTTER_IS_BACKEND (backend));
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  klass->init_events (backend);
 }
 gfloat
 _clutter_backend_get_units_per_em (ClutterBackend       *backend,
                                   PangoFontDescription *font_desc)
@ -626,6 +833,44 @@ _clutter_backend_get_units_per_em (ClutterBackend       *backend,
  return backend->units_per_em;
 }
 void
 _clutter_backend_copy_event_data (ClutterBackend     *backend,
                                  const ClutterEvent *src,
                                  ClutterEvent       *dest)
 {
  ClutterEventExtenderInterface *iface;
  ClutterBackendClass *klass;
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  if (CLUTTER_IS_EVENT_EXTENDER (backend->device_manager))
    {
      iface = CLUTTER_EVENT_EXTENDER_GET_IFACE (backend->device_manager);
      iface->copy_event_data (CLUTTER_EVENT_EXTENDER (backend->device_manager),
                              src, dest);
    }
  else if (klass->copy_event_data != NULL)
    klass->copy_event_data (backend, src, dest);
 }
 void
 _clutter_backend_free_event_data (ClutterBackend *backend,
                                  ClutterEvent   *event)
 {
  ClutterEventExtenderInterface *iface;
  ClutterBackendClass *klass;
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  if (CLUTTER_IS_EVENT_EXTENDER (backend->device_manager))
    {
      iface = CLUTTER_EVENT_EXTENDER_GET_IFACE (backend->device_manager);
      iface->free_event_data (CLUTTER_EVENT_EXTENDER (backend->device_manager),
                              event);
    }
  else if (klass->free_event_data != NULL)
    klass->free_event_data (backend, event);
 }
 /**
 * clutter_get_default_backend:
 *
@ -648,6 +893,129 @@ clutter_get_default_backend (void)
  return clutter_context->backend;
 }
 /**
 * clutter_backend_set_double_click_time:
 * @backend: a #ClutterBackend
 * @msec: milliseconds between two button press events
 *
 * Sets the maximum time between two button press events, used to
 * verify whether it's a double click event or not.
 *
 * Since: 0.4
 *
 * Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
 */
 void
 clutter_backend_set_double_click_time (ClutterBackend *backend,
                                       guint           msec)
 {
  ClutterSettings *settings = clutter_settings_get_default ();
  g_object_set (settings, "double-click-time", msec, NULL);
 }
 /**
 * clutter_backend_get_double_click_time:
 * @backend: a #ClutterBackend
 *
 * Gets the maximum time between two button press events, as set
 * by clutter_backend_set_double_click_time().
 *
 * Return value: a time in milliseconds
 *
 * Since: 0.4
 *
 * Deprecated: 1.4: Use #ClutterSettings:double-click-time instead
 */
 guint
 clutter_backend_get_double_click_time (ClutterBackend *backend)
 {
  ClutterSettings *settings = clutter_settings_get_default ();
  gint retval;
  g_object_get (settings, "double-click-time", &retval, NULL);
  return retval;
 }
 /**
 * clutter_backend_set_double_click_distance:
 * @backend: a #ClutterBackend
 * @distance: a distance, in pixels
 *
 * Sets the maximum distance used to verify a double click event.
 *
 * Since: 0.4
 *
 * Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
 */
 void
 clutter_backend_set_double_click_distance (ClutterBackend *backend,
                                           guint           distance)
 {
  ClutterSettings *settings = clutter_settings_get_default ();
  g_object_set (settings, "double-click-distance", distance, NULL);
 }
 /**
 * clutter_backend_get_double_click_distance:
 * @backend: a #ClutterBackend
 *
 * Retrieves the distance used to verify a double click event
 *
 * Return value: a distance, in pixels.
 *
 * Since: 0.4
 *
 * Deprecated: 1.4: Use #ClutterSettings:double-click-distance instead
 */
 guint
 clutter_backend_get_double_click_distance (ClutterBackend *backend)
 {
  ClutterSettings *settings = clutter_settings_get_default ();
  gint retval;
  g_object_get (settings, "double-click-distance", &retval, NULL);
  return retval;
 }
 /**
 * clutter_backend_set_resolution:
 * @backend: a #ClutterBackend
 * @dpi: the resolution in "dots per inch" (Physical inches aren't
 *   actually involved; the terminology is conventional).
 *
 * Sets the resolution for font handling on the screen. This is a
 * scale factor between points specified in a #PangoFontDescription
 * and cairo units. The default value is 96, meaning that a 10 point
 * font will be 13 units high. (10 * 96. / 72. = 13.3).
 *
 * Applications should never need to call this function.
 *
 * Since: 0.4
 *
 * Deprecated: 1.4: Use #ClutterSettings:font-dpi instead
 */
 void
 clutter_backend_set_resolution (ClutterBackend *backend,
                                gdouble         dpi)
 {
  ClutterSettings *settings;
  gint resolution;
  g_return_if_fail (CLUTTER_IS_BACKEND (backend));
  if (dpi < 0)
    resolution = -1;
  else
    resolution = dpi * 1024;
  settings = clutter_settings_get_default ();
  g_object_set (settings, "font-dpi", resolution, NULL);
 }
 /**
 * clutter_backend_get_resolution:
 * @backend: a #ClutterBackend
@ -753,6 +1121,61 @@ clutter_backend_get_font_options (ClutterBackend *backend)
  return backend->font_options;
 }
 /**
 * clutter_backend_set_font_name:
 * @backend: a #ClutterBackend
 * @font_name: the name of the font
 *
 * Sets the default font to be used by Clutter. The @font_name string
 * must either be %NULL, which means that the font name from the
 * default #ClutterBackend will be used; or be something that can
 * be parsed by the pango_font_description_from_string() function.
 *
 * Since: 1.0
 *
 * Deprecated: 1.4: Use #ClutterSettings:font-name instead
 */
 void
 clutter_backend_set_font_name (ClutterBackend *backend,
                               const gchar    *font_name)
 {
  ClutterSettings *settings = clutter_settings_get_default ();
  g_object_set (settings, "font-name", font_name, NULL);
 }
 /**
 * clutter_backend_get_font_name:
 * @backend: a #ClutterBackend
 *
 * Retrieves the default font name as set by
 * clutter_backend_set_font_name().
 *
 * Return value: the font name for the backend. The returned string is
 *   owned by the #ClutterBackend and should never be modified or freed
 *
 * Since: 1.0
 *
 * Deprecated: 1.4: Use #ClutterSettings:font-name instead
 */
 const gchar *
 clutter_backend_get_font_name (ClutterBackend *backend)
 {
  ClutterSettings *settings;
  g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
  settings = clutter_settings_get_default ();
  /* XXX yuck. but we return a const pointer, so we need to
   * store it in the backend
   */
  g_free (backend->font_name);
  g_object_get (settings, "font-name", &backend->font_name, NULL);
  return backend->font_name;
 }
 gint32
 _clutter_backend_get_units_serial (ClutterBackend *backend)
 {
@ -769,6 +1192,28 @@ _clutter_backend_translate_event (ClutterBackend *backend,
                                                               event);
 }
 void
 _clutter_backend_add_event_translator (ClutterBackend         *backend,
                                       ClutterEventTranslator *translator)
 {
  if (g_list_find (backend->event_translators, translator) != NULL)
    return;
  backend->event_translators =
    g_list_prepend (backend->event_translators, translator);
 }
 void
 _clutter_backend_remove_event_translator (ClutterBackend         *backend,
                                          ClutterEventTranslator *translator)
 {
  if (g_list_find (backend->event_translators, translator) == NULL)
    return;
  backend->event_translators =
    g_list_remove (backend->event_translators, translator);
 }
 /**
 * clutter_backend_get_cogl_context: (skip)
 * @backend: a #ClutterBackend
@ -795,6 +1240,119 @@ clutter_backend_get_cogl_context (ClutterBackend *backend)
  return backend->cogl_context;
 }
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 /**
 * clutter_wayland_set_compositor_display:
 * @display: A compositor side struct wl_display pointer
 *
 * This informs Clutter of your compositor side Wayland display
 * object. This must be called before calling clutter_init().
 *
 * Since: 1.8
 * Stability: unstable
 */
 void
 clutter_wayland_set_compositor_display (void *display)
 {
  if (_clutter_context_is_initialized ())
    {
      g_warning ("%s() can only be used before calling clutter_init()",
                 G_STRFUNC);
      return;
    }
  _wayland_compositor_display = display;
 }
 #endif
 /**
 * clutter_set_windowing_backend:
 * @backend_type: a comma separated list of windowing backends
 *
 * Restricts Clutter to only use the specified backend or list of backends.
 *
 * You can use one of the `CLUTTER_WINDOWING_*` symbols, e.g.
 *
 * |[<!-- language="C" -->
 *   clutter_set_windowing_backend (CLUTTER_WINDOWING_X11);
 * ]|
 *
 * Will force Clutter to use the X11 windowing and input backend, and terminate
 * if the X11 backend could not be initialized successfully.
 *
 * Since Clutter 1.26, you can also use a comma-separated list of windowing
 * system backends to provide a fallback in case backends are not available or
 * enabled, e.g.:
 *
 * |[<!-- language="C" -->
 *   clutter_set_windowing_backend ("gdk,wayland,x11");
 * ]|
 *
 * Will make Clutter test for the GDK, Wayland, and X11 backends in that order.
 *
 * You can use the `*` special value to ask Clutter to use the internally
 * defined list of backends. For instance:
 *
 * |[<!-- language="C" -->
 *   clutter_set_windowing_backend ("x11,wayland,*");
 * ]|
 *
 * Will make Clutter test the X11 and Wayland backends, and then fall back
 * to the internal list of available backends.
 *
 * This function must be called before the first API call to Clutter, including
 * clutter_get_option_context()
 *
 * Since: 1.16
 */
 void
 clutter_set_windowing_backend (const char *backend_type)
 {
  g_return_if_fail (backend_type != NULL);
  allowed_backends = g_strdup (backend_type);
 }
 void
 clutter_try_set_windowing_backend (const char *backend_type)
 {
  if (allowed_backends == NULL)
    clutter_set_windowing_backend (backend_type);
 }
 PangoDirection
 _clutter_backend_get_keymap_direction (ClutterBackend *backend)
 {
  ClutterBackendClass *klass;
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  if (klass->get_keymap_direction != NULL)
    return klass->get_keymap_direction (backend);
  return PANGO_DIRECTION_NEUTRAL;
 }
 void
 _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
 {
  if (backend->dummy_onscreen == COGL_INVALID_HANDLE)
    {
      CoglError *internal_error = NULL;
      backend->dummy_onscreen = cogl_onscreen_new (backend->cogl_context, 1, 1);
      if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (backend->dummy_onscreen),
                                      &internal_error))
        {
          g_critical ("Unable to create dummy onscreen: %s", internal_error->message);
          cogl_error_free (internal_error);
          return;
        }
    }
  cogl_set_framebuffer (COGL_FRAMEBUFFER (backend->dummy_onscreen));
 }
 void
 clutter_set_allowed_drivers (const char *drivers)
 {
@ -807,6 +1365,16 @@ clutter_set_allowed_drivers (const char *drivers)
  allowed_drivers = g_strdup (drivers);
 }
 void
 clutter_backend_bell_notify (ClutterBackend *backend)
 {
  ClutterBackendClass *klass;
  klass = CLUTTER_BACKEND_GET_CLASS (backend);
  if (klass->bell_notify)
    klass->bell_notify (backend);
 }
 /**
 * clutter_backend_get_input_method:
 * @backend: the #CLutterBackend
@ -834,51 +1402,3 @@ clutter_backend_set_input_method (ClutterBackend     *backend,
 {
  g_set_object (&backend->input_method, method);
 }
 ClutterStageWindow *
 clutter_backend_get_stage_window (ClutterBackend *backend)
 {
  return backend->stage_window;
 }
 /**
 * clutter_backend_get_default_seat:
 * @backend: the #ClutterBackend
 *
 * Returns the default seat
 *
 * Returns: (transfer none): the default seat
 **/
 ClutterSeat *
 clutter_backend_get_default_seat (ClutterBackend *backend)
 {
  g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
  return CLUTTER_BACKEND_GET_CLASS (backend)->get_default_seat (backend);
 }
 void
 clutter_backend_set_fallback_resource_scale (ClutterBackend *backend,
                                             float           fallback_resource_scale)
 {
  backend->fallback_resource_scale = fallback_resource_scale;
 }
 float
 clutter_backend_get_fallback_resource_scale (ClutterBackend *backend)
 {
  return backend->fallback_resource_scale;
 }
 gboolean
 clutter_backend_is_display_server (ClutterBackend *backend)
 {
  return CLUTTER_BACKEND_GET_CLASS (backend)->is_display_server (backend);
 }
 void
 clutter_backend_destroy (ClutterBackend *backend)
 {
  g_object_run_dispose (G_OBJECT (backend));
  g_object_unref (backend);
 }
--- a/clutter/clutter/clutter-backend.h
+++ b/clutter/clutter/clutter-backend.h
@ -33,9 +33,8 @@
 #include <cogl/cogl.h>
-#include <clutter/clutter-keymap.h>
+#include <clutter/clutter-config.h>
 #include <clutter/clutter-types.h>
 #include <clutter/clutter-seat.h>
 G_BEGIN_DECLS
@ -54,33 +53,36 @@ G_BEGIN_DECLS
 typedef struct _ClutterBackend          ClutterBackend;
 typedef struct _ClutterBackendClass     ClutterBackendClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_backend_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterBackend *                clutter_get_default_backend             (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_16
 void                            clutter_set_windowing_backend           (const char *backend_type);
 CLUTTER_AVAILABLE_IN_ALL
 gdouble                         clutter_backend_get_resolution          (ClutterBackend             *backend);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_backend_set_font_options        (ClutterBackend             *backend,
                                                                         const cairo_font_options_t *options);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 const cairo_font_options_t *    clutter_backend_get_font_options        (ClutterBackend             *backend);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 CoglContext *                   clutter_backend_get_cogl_context        (ClutterBackend             *backend);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_backend_bell_notify             (ClutterBackend             *backend);
 CLUTTER_AVAILABLE_IN_MUTTER
 ClutterInputMethod *            clutter_backend_get_input_method        (ClutterBackend             *backend);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_MUTTER
 void                            clutter_backend_set_input_method        (ClutterBackend             *backend,
                                                                         ClutterInputMethod         *method);
 CLUTTER_EXPORT
 ClutterSeat *                   clutter_backend_get_default_seat        (ClutterBackend             *backend);
 G_END_DECLS
 #endif /* __CLUTTER_BACKEND_H__ */
--- a/clutter/clutter/clutter-base-types.c
+++ b/clutter/clutter/clutter-base-types.c
--- a/clutter/clutter/clutter-bezier.c
+++ b/clutter/clutter/clutter-bezier.c
@ -35,7 +35,7 @@
 #undef CBZ_L2T_INTERPOLATION
 /****************************************************************************
- * ClutterBezier -- representation of a cubic bezier curve                   *
+ * ClutterBezier -- represenation of a cubic bezier curve                   *
 * (private; a building block for the public bspline object)                *
 ****************************************************************************/
@ -104,7 +104,7 @@ struct _ClutterBezier
 ClutterBezier *
 _clutter_bezier_new (void)
 {
-  return g_new0 (ClutterBezier, 1);
+  return g_slice_new0 (ClutterBezier);
 }
 void
@ -112,7 +112,7 @@ _clutter_bezier_free (ClutterBezier * b)
 {
  if (G_LIKELY (b))
    {
-      g_free (b);
+      g_slice_free (ClutterBezier, b);
    }
 }
@ -213,7 +213,7 @@ sqrti (int number)
     * algorithm does not calculate the square root, but its reciprocal ('y'
     * below), which is only at the end turned to the inverse value. In order
     * for the algorithm to produce satisfactory results, the reciprocal value
-     * must be represented with sufficient precision; the 16.16 we use
+     * must be represented with sufficient precission; the 16.16 we use
     * elsewhere in clutter is not good enough, and 10.22 is used instead.
     */
    _FixedT x;
@ -236,7 +236,7 @@ sqrti (int number)
    /* Now, we convert the float to 10.22 fixed. We exploit the mechanism
     * described at http://www.d6.com/users/checker/pdfs/gdmfp.pdf.
     *
-     * We want 22 bit fraction; a single precision float uses 23 bit
+     * We want 22 bit fraction; a single precission float uses 23 bit
     * mantisa, so we only need to add 2^(23-22) (no need for the 1.5
     * multiplier as we are only dealing with positive numbers).
     *
@ -256,7 +256,7 @@ sqrti (int number)
    flt2.i = (flt2.i >> 11) * (y_1 >> 11);
    /* If the original argument is less than 342, we do another
-     * iteration to improve precision (for arguments >= 342, the single
+     * iteration to improve precission (for arguments >= 342, the single
     * iteration produces generally better results).
     */
    if (x < 171)
--- a/clutter/clutter/clutter-bezier.h
+++ b/clutter/clutter/clutter-bezier.h
@ -36,7 +36,7 @@ G_BEGIN_DECLS
 typedef struct _ClutterBezier ClutterBezier;
-ClutterBezier *_clutter_bezier_new (void);
+ClutterBezier *_clutter_bezier_new ();
 void           _clutter_bezier_free (ClutterBezier * b);
--- a/clutter/clutter/clutter-bin-layout.c
+++ b/clutter/clutter/clutter-bin-layout.c
@ -43,16 +43,18 @@
 * #ClutterBinLayout is available since Clutter 1.2
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-container.h"
 #include "deprecated/clutter-bin-layout.h"
 #include "clutter-actor-private.h"
 #include "clutter-animatable.h"
 #include "clutter-bin-layout.h"
 #include "clutter-child-meta.h"
 #include "clutter-debug.h"
 #include "clutter-enum-types.h"
@ -406,7 +408,8 @@ get_actor_align_factor (ClutterActorAlign alignment)
 static void
 clutter_bin_layout_allocate (ClutterLayoutManager   *manager,
                             ClutterContainer       *container,
-                             const ClutterActorBox  *allocation)
+                             const ClutterActorBox  *allocation,
                             ClutterAllocationFlags  flags)
 {
  gfloat allocation_x, allocation_y;
  gfloat available_w, available_h;
@ -514,7 +517,8 @@ clutter_bin_layout_allocate (ClutterLayoutManager   *manager,
      clutter_actor_allocate_align_fill (child, &child_alloc,
                                         x_align, y_align,
-                                         x_fill, y_fill);
+                                         x_fill, y_fill,
                                         flags);
    }
 }
@ -696,3 +700,187 @@ clutter_bin_layout_new (ClutterBinAlignment x_align,
                       "y-align", y_align,
                       NULL);
 }
 /**
 * clutter_bin_layout_set_alignment:
 * @self: a #ClutterBinLayout
 * @child: (allow-none): a child of @container
 * @x_align: the horizontal alignment policy to be used for the @child
 *   inside @container
 * @y_align: the vertical aligment policy to be used on the @child
 *   inside @container
 *
 * Sets the horizontal and vertical alignment policies to be applied
 * to a @child of @self
 *
 * If @child is %NULL then the @x_align and @y_align values will
 * be set as the default alignment policies
 *
 * Since: 1.2
 *
 * Deprecated: 1.12: Use the #ClutterActor:x-align and
 *   #ClutterActor:y-align properties of #ClutterActor instead.
 */
 void
 clutter_bin_layout_set_alignment (ClutterBinLayout    *self,
                                  ClutterActor        *child,
                                  ClutterBinAlignment  x_align,
                                  ClutterBinAlignment  y_align)
 {
  ClutterBinLayoutPrivate *priv;
  ClutterLayoutManager *manager;
  ClutterLayoutMeta *meta;
  g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
  g_return_if_fail (child == NULL || CLUTTER_IS_ACTOR (child));
  priv = self->priv;
  if (priv->container == NULL)
    {
      if (child == NULL)
        {
          set_x_align (self, x_align);
          set_y_align (self, y_align);
        }
      else
        g_warning ("The layout of type '%s' must be associated to "
                   "a ClutterContainer before setting the alignment "
                   "on its children",
                   G_OBJECT_TYPE_NAME (self));
      return;
    }
  manager = CLUTTER_LAYOUT_MANAGER (self);
  meta = clutter_layout_manager_get_child_meta (manager,
                                                priv->container,
                                                child);
  g_assert (CLUTTER_IS_BIN_LAYER (meta));
  set_layer_x_align (CLUTTER_BIN_LAYER (meta), x_align);
  set_layer_y_align (CLUTTER_BIN_LAYER (meta), y_align);
 }
 /**
 * clutter_bin_layout_get_alignment:
 * @self: a #ClutterBinLayout
 * @child: (allow-none): a child of @container
 * @x_align: (out) (allow-none): return location for the horizontal
 *   alignment policy
 * @y_align: (out) (allow-none): return location for the vertical
 *   alignment policy
 *
 * Retrieves the horizontal and vertical alignment policies for
 * a child of @self
 *
 * If @child is %NULL the default alignment policies will be returned
 * instead
 *
 * Since: 1.2
 *
 * Deprecated: 1.12: Use the #ClutterActor:x-align and the
 *   #ClutterActor:y-align properties of #ClutterActor instead.
 */
 void
 clutter_bin_layout_get_alignment (ClutterBinLayout    *self,
                                  ClutterActor        *child,
                                  ClutterBinAlignment *x_align,
                                  ClutterBinAlignment *y_align)
 {
  ClutterBinLayoutPrivate *priv;
  ClutterLayoutManager *manager;
  ClutterLayoutMeta *meta;
  ClutterBinLayer *layer;
  g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
  priv = self->priv;
  if (priv->container == NULL)
    {
      if (child == NULL)
        {
          if (x_align)
            *x_align = priv->x_align;
          if (y_align)
            *y_align = priv->y_align;
        }
      else
        g_warning ("The layout of type '%s' must be associated to "
                   "a ClutterContainer before getting the alignment "
                   "of its children",
                   G_OBJECT_TYPE_NAME (self));
      return;
    }
  manager = CLUTTER_LAYOUT_MANAGER (self);
  meta = clutter_layout_manager_get_child_meta (manager,
                                                priv->container,
                                                child);
  g_assert (CLUTTER_IS_BIN_LAYER (meta));
  layer = CLUTTER_BIN_LAYER (meta);
  if (x_align)
    *x_align = layer->x_align;
  if (y_align)
    *y_align = layer->y_align;
 }
 /**
 * clutter_bin_layout_add:
 * @self: a #ClutterBinLayout
 * @child: a #ClutterActor
 * @x_align: horizontal alignment policy for @child
 * @y_align: vertical alignment policy for @child
 *
 * Adds a #ClutterActor to the container using @self and
 * sets the alignment policies for it
 *
 * This function is equivalent to clutter_container_add_actor()
 * and clutter_layout_manager_child_set_property() but it does not
 * require a pointer to the #ClutterContainer associated to the
 * #ClutterBinLayout
 *
 * Since: 1.2
 *
 * Deprecated: 1.12: Use clutter_actor_add_child() instead.
 */
 void
 clutter_bin_layout_add (ClutterBinLayout    *self,
                        ClutterActor        *child,
                        ClutterBinAlignment  x_align,
                        ClutterBinAlignment  y_align)
 {
  ClutterBinLayoutPrivate *priv;
  ClutterLayoutManager *manager;
  ClutterLayoutMeta *meta;
  g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
  g_return_if_fail (CLUTTER_IS_ACTOR (child));
  priv = self->priv;
  if (priv->container == NULL)
    {
      g_warning ("The layout of type '%s' must be associated to "
                 "a ClutterContainer before adding children",
                 G_OBJECT_TYPE_NAME (self));
      return;
    }
  clutter_container_add_actor (priv->container, child);
  manager = CLUTTER_LAYOUT_MANAGER (self);
  meta = clutter_layout_manager_get_child_meta (manager,
                                                priv->container,
                                                child);
  g_assert (CLUTTER_IS_BIN_LAYER (meta));
  set_layer_x_align (CLUTTER_BIN_LAYER (meta), x_align);
  set_layer_y_align (CLUTTER_BIN_LAYER (meta), y_align);
 }
--- a/clutter/clutter/clutter-bin-layout.h
+++ b/clutter/clutter/clutter-bin-layout.h
@ -74,10 +74,10 @@ struct _ClutterBinLayoutClass
  ClutterLayoutManagerClass parent_class;
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_bin_layout_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *  clutter_bin_layout_new  (ClutterBinAlignment x_align,
                                                 ClutterBinAlignment y_align);
--- a/clutter/clutter/clutter-bind-constraint.c
+++ b/clutter/clutter/clutter-bind-constraint.c
@ -38,14 +38,12 @@
 *
 * |[<!-- language="C" -->
 * // source
- * rect[0] = clutter_actor_new ();
+ * rect[0] = clutter_rectangle_new_with_color (&red_color);
 * clutter_actor_set_background_color (rect[0], &red_color);
 * clutter_actor_set_position (rect[0], x_pos, y_pos);
 * clutter_actor_set_size (rect[0], 100, 100);
 *
 * // second rectangle
- * rect[1] = clutter_actor_new ();
+ * rect[1] = clutter_rectangle_new_with_color (&green_color);
 * clutter_actor_set_background_color (rect[1], &green_color);
 * clutter_actor_set_size (rect[1], 100, 100);
 * clutter_actor_set_opacity (rect[1], 0);
 *
@ -55,8 +53,7 @@
 * clutter_actor_add_constraint_with_name (rect[1], "green-y", constraint);
 *
 * // third rectangle
- * rect[2] = clutter_actor_new ();
+ * rect[2] = clutter_rectangle_new_with_color (&blue_color);
 * clutter_actor_set_background_color (rect[2], &blue_color);
 * clutter_actor_set_size (rect[2], 100, 100);
 * clutter_actor_set_opacity (rect[2], 0);
 *
@ -83,7 +80,9 @@
 * #ClutterBindConstraint is available since Clutter 1.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
@ -147,58 +146,6 @@ source_destroyed (ClutterActor          *actor,
  bind->source = NULL;
 }
 static void
 clutter_bind_constraint_update_preferred_size (ClutterConstraint  *constraint,
                                               ClutterActor       *actor,
                                               ClutterOrientation  direction,
                                               float               for_size,
                                               float              *minimum_size,
                                               float              *natural_size)
 {
  ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (constraint);
  float source_min, source_nat;
  if (bind->source == NULL)
    return;
  /* only these bindings affect the preferred size */
  if (!(bind->coordinate == CLUTTER_BIND_WIDTH ||
        bind->coordinate == CLUTTER_BIND_HEIGHT ||
        bind->coordinate == CLUTTER_BIND_SIZE ||
        bind->coordinate == CLUTTER_BIND_ALL))
    return;
  if (clutter_actor_contains (bind->source, actor))
    return;
  switch (direction)
    {
    case CLUTTER_ORIENTATION_HORIZONTAL:
      if (bind->coordinate != CLUTTER_BIND_HEIGHT)
        {
          clutter_actor_get_preferred_width (bind->source, for_size,
                                             &source_min,
                                             &source_nat);
          *minimum_size = source_min;
          *natural_size = source_nat;
        }
      break;
    case CLUTTER_ORIENTATION_VERTICAL:
      if (bind->coordinate != CLUTTER_BIND_WIDTH)
        {
          clutter_actor_get_preferred_height (bind->source, for_size,
                                              &source_min,
                                              &source_nat);
          *minimum_size = source_min;
          *natural_size = source_nat;
        }
      break;
    }
 }
 static void
 clutter_bind_constraint_update_allocation (ClutterConstraint *constraint,
                                           ClutterActor      *actor,
@ -207,9 +154,7 @@ clutter_bind_constraint_update_allocation (ClutterConstraint *constraint,
  ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (constraint);
  gfloat source_width, source_height;
  gfloat actor_width, actor_height;
-  graphene_point3d_t source_position;
+  ClutterVertex source_position = { 0., };
  source_position = GRAPHENE_POINT3D_INIT (0.f, 0.f, 0.f);
  if (bind->source == NULL)
    return;
@ -383,8 +328,6 @@ clutter_bind_constraint_class_init (ClutterBindConstraintClass *klass)
  meta_class->set_actor = clutter_bind_constraint_set_actor;
  constraint_class->update_allocation = clutter_bind_constraint_update_allocation;
  constraint_class->update_preferred_size = clutter_bind_constraint_update_preferred_size;
  /**
   * ClutterBindConstraint:source:
   *
--- a/clutter/clutter/clutter-bind-constraint.h
+++ b/clutter/clutter/clutter-bind-constraint.h
@ -48,28 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterBindConstraint           ClutterBindConstraint;
 typedef struct _ClutterBindConstraintClass      ClutterBindConstraintClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_bind_constraint_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *   clutter_bind_constraint_new            (ClutterActor          *source,
                                                              ClutterBindCoordinate  coordinate,
                                                              gfloat                 offset);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_source     (ClutterBindConstraint *constraint,
                                                              ClutterActor          *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *        clutter_bind_constraint_get_source     (ClutterBindConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
                                                              ClutterBindCoordinate  coordinate);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterBindCoordinate clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_offset     (ClutterBindConstraint *constraint,
                                                              gfloat                 offset);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 gfloat                clutter_bind_constraint_get_offset     (ClutterBindConstraint *constraint);
 G_END_DECLS
--- a/clutter/clutter/clutter-binding-pool.c
+++ b/clutter/clutter/clutter-binding-pool.c
@ -94,7 +94,9 @@
 * #ClutterBindingPool is available since Clutter 1.0
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-binding-pool.h"
 #include "clutter-debug.h"
@ -189,7 +191,7 @@ binding_entry_new (const gchar         *name,
  modifiers = modifiers & BINDING_MOD_MASK;
-  entry = g_new0 (ClutterBindingEntry, 1);
+  entry = g_slice_new (ClutterBindingEntry);
  entry->key_val = key_val;
  entry->modifiers = modifiers;
  entry->name = (gchar *) g_intern_string (name);
@ -221,7 +223,7 @@ binding_entry_free (gpointer data)
      g_closure_unref (entry->closure);
-      g_free (entry);
+      g_slice_free (ClutterBindingEntry, entry);
    }
 }
@ -235,7 +237,8 @@ clutter_binding_pool_finalize (GObject *gobject)
  g_hash_table_destroy (pool->entries_hash);
-  g_slist_free_full (pool->entries, (GDestroyNotify) binding_entry_free);
+  g_slist_foreach (pool->entries, (GFunc) binding_entry_free, NULL);
  g_slist_free (pool->entries);
  G_OBJECT_CLASS (clutter_binding_pool_parent_class)->finalize (gobject);
 }
--- a/clutter/clutter/clutter-binding-pool.h
+++ b/clutter/clutter/clutter-binding-pool.h
@ -71,17 +71,17 @@ typedef gboolean (* ClutterBindingActionFunc) (GObject             *gobject,
                                               ClutterModifierType  modifiers,
                                               gpointer             user_data);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_binding_pool_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_new              (const gchar         *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_get_for_class    (gpointer             klass);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_find             (const gchar         *name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_action   (ClutterBindingPool  *pool,
                                                             const gchar         *action_name,
                                                             guint                key_val,
@ -89,44 +89,44 @@ void                  clutter_binding_pool_install_action   (ClutterBindingPool
                                                             GCallback            callback,
                                                             gpointer             data,
                                                             GDestroyNotify       notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_closure  (ClutterBindingPool  *pool,
                                                             const gchar         *action_name,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers,
                                                             GClosure            *closure);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_action  (ClutterBindingPool  *pool,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers,
                                                             GCallback            callback,
                                                             gpointer             data,
                                                             GDestroyNotify       notify);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_closure (ClutterBindingPool  *pool,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers,
                                                             GClosure            *closure);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 const gchar *         clutter_binding_pool_find_action      (ClutterBindingPool  *pool,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_remove_action    (ClutterBindingPool  *pool,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_binding_pool_activate         (ClutterBindingPool  *pool,
                                                             guint                key_val,
                                                             ClutterModifierType  modifiers,
                                                             GObject             *gobject);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_block_action     (ClutterBindingPool  *pool,
                                                             const gchar         *action_name);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_unblock_action   (ClutterBindingPool  *pool,
                                                             const gchar         *action_name);
--- a/clutter/clutter/clutter-blur-effect.c
+++ b/clutter/clutter/clutter-blur-effect.c
@ -37,7 +37,11 @@
 #define CLUTTER_IS_BLUR_EFFECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BLUR_EFFECT))
 #define CLUTTER_BLUR_EFFECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-blur-effect.h"
@ -79,6 +83,9 @@ struct _ClutterBlurEffect
  gint pixel_step_uniform;
  gint tex_width;
  gint tex_height;
  CoglPipeline *pipeline;
 };
@ -93,42 +100,19 @@ G_DEFINE_TYPE (ClutterBlurEffect,
               clutter_blur_effect,
               CLUTTER_TYPE_OFFSCREEN_EFFECT);
 static CoglPipeline *
 clutter_blur_effect_create_pipeline (ClutterOffscreenEffect *effect,
                                     CoglTexture            *texture)
 {
  ClutterBlurEffect *blur_effect = CLUTTER_BLUR_EFFECT (effect);
  if (blur_effect->pixel_step_uniform > -1)
    {
      float pixel_step[2];
      int tex_width, tex_height;
      tex_width = cogl_texture_get_width (texture);
      tex_height = cogl_texture_get_height (texture);
      pixel_step[0] = 1.0f / tex_width;
      pixel_step[1] = 1.0f / tex_height;
      cogl_pipeline_set_uniform_float (blur_effect->pipeline,
                                       blur_effect->pixel_step_uniform,
                                       2, /* n_components */
                                       1, /* count */
                                       pixel_step);
    }
  cogl_pipeline_set_layer_texture (blur_effect->pipeline, 0, texture);
  return cogl_object_ref (blur_effect->pipeline);
 }
 static gboolean
-clutter_blur_effect_pre_paint (ClutterEffect       *effect,
+clutter_blur_effect_pre_paint (ClutterEffect *effect)
                               ClutterPaintNode    *node,
                               ClutterPaintContext *paint_context)
 {
  ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
  ClutterEffectClass *parent_class;
  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
    return FALSE;
  self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
  if (self->actor == NULL)
    return FALSE;
  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
    {
      /* if we don't have support for GLSL shaders then we
@ -142,15 +126,64 @@ clutter_blur_effect_pre_paint (ClutterEffect       *effect,
    }
  parent_class = CLUTTER_EFFECT_CLASS (clutter_blur_effect_parent_class);
-  return parent_class->pre_paint (effect, node, paint_context);
+  if (parent_class->pre_paint (effect))
    {
      ClutterOffscreenEffect *offscreen_effect =
        CLUTTER_OFFSCREEN_EFFECT (effect);
      CoglHandle texture;
      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
      self->tex_width = cogl_texture_get_width (texture);
      self->tex_height = cogl_texture_get_height (texture);
      if (self->pixel_step_uniform > -1)
        {
          gfloat pixel_step[2];
          pixel_step[0] = 1.0f / self->tex_width;
          pixel_step[1] = 1.0f / self->tex_height;
          cogl_pipeline_set_uniform_float (self->pipeline,
                                           self->pixel_step_uniform,
                                           2, /* n_components */
                                           1, /* count */
                                           pixel_step);
        }
      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
      return TRUE;
    }
  else
    return FALSE;
 }
 static void
 clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
 {
  ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
  guint8 paint_opacity;
  paint_opacity = clutter_actor_get_paint_opacity (self->actor);
  cogl_pipeline_set_color4ub (self->pipeline,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity);
  cogl_push_source (self->pipeline);
  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
  cogl_pop_source ();
 }
 static gboolean
-clutter_blur_effect_modify_paint_volume (ClutterEffect      *effect,
+clutter_blur_effect_get_paint_volume (ClutterEffect      *effect,
-                                         ClutterPaintVolume *volume)
+                                      ClutterPaintVolume *volume)
 {
  gfloat cur_width, cur_height;
-  graphene_point3d_t origin;
+  ClutterVertex origin;
  clutter_paint_volume_get_origin (volume, &origin);
  cur_width = clutter_paint_volume_get_width (volume);
@ -191,10 +224,10 @@ clutter_blur_effect_class_init (ClutterBlurEffectClass *klass)
  gobject_class->dispose = clutter_blur_effect_dispose;
  effect_class->pre_paint = clutter_blur_effect_pre_paint;
-  effect_class->modify_paint_volume = clutter_blur_effect_modify_paint_volume;
+  effect_class->get_paint_volume = clutter_blur_effect_get_paint_volume;
  offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_blur_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_blur_effect_paint_target;
 }
 static void
@ -217,7 +250,9 @@ clutter_blur_effect_init (ClutterBlurEffect *self)
      cogl_pipeline_add_layer_snippet (klass->base_pipeline, 0, snippet);
      cogl_object_unref (snippet);
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
                                            0, /* layer number */
                                            COGL_TEXTURE_TYPE_2D);
    }
  self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
--- a/clutter/clutter/clutter-blur-effect.h
+++ b/clutter/clutter/clutter-blur-effect.h
@ -48,10 +48,10 @@ G_BEGIN_DECLS
 typedef struct _ClutterBlurEffect       ClutterBlurEffect;
 typedef struct _ClutterBlurEffectClass  ClutterBlurEffectClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_blur_effect_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_blur_effect_new (void);
 G_END_DECLS
--- a/clutter/clutter/clutter-blur-private.h
+++ b/clutter/clutter/clutter-blur-private.h
@ -1,40 +0,0 @@
 /*
 * Copyright (C) 2020 Endless OS Foundation, LLC
 *
 * 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_BLUR_PRIVATE_H
 #define CLUTTER_BLUR_PRIVATE_H
 #include <glib-object.h>
 #include <cogl/cogl.h>
 G_BEGIN_DECLS
 typedef struct _ClutterBlur ClutterBlur;
 ClutterBlur * clutter_blur_new (CoglTexture *texture,
                                float        sigma);
 void clutter_blur_apply (ClutterBlur *blur);
 CoglTexture * clutter_blur_get_texture (ClutterBlur *blur);
 void clutter_blur_free (ClutterBlur *blur);
 G_END_DECLS
 #endif /* CLUTTER_BLUR_PRIVATE_H */
--- a/clutter/clutter/clutter-blur.c
+++ b/clutter/clutter/clutter-blur.c
@ -1,431 +0,0 @@
 /*
 * Copyright (C) 2020 Endless OS Foundation, LLC
 *
 * 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-blur-private.h"
 #include "clutter-backend.h"
 /**
 * SECTION:clutter-blur
 * @short_description: Blur textures
 *
 * #ClutterBlur is a moderately fast gaussian blur implementation.
 *
 * # Optimizations
 *
 * There are a number of optimizations in place to make this blur implementation
 * real-time. All in all, the implementation performs best when using large
 * blur-radii that allow downscaling the texture to smaller sizes, at small
 * radii where no downscaling is possible this can easily halve the framerate.
 *
 * ## Multipass
 *
 * It is implemented in 2 passes: vertical and horizontal.
 *
 * ## Downscaling
 *
 * #ClutterBlur uses dynamic downscaling to speed up blurring. Downscaling
 * happens in factors of 2 (the image is downscaled either by 2, 4, 8, 16, …)
 * and depends on the blur radius, the texture size, among others.
 *
 * The texture is drawn into a downscaled framebuffer; the blur passes are
 * applied on the downscaled texture contents; and finally, the blurred
 * contents are drawn
 * upscaled again.
 *
 * ## Hardware Interpolation
 *
 * This blur implementation cuts down the number of sampling operations by
 * exploiting the hardware interpolation that is performed when sampling between
 * pixel boundaries. This technique is described at:
 *
 * http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
 *
 * ## Incremental gauss-factor calculation
 *
 * The kernel values for the gaussian kernel are computed incrementally instead
 * of running the expensive calculations multiple times inside the blur shader.
 * The implementation is based on the algorithm presented by K. Turkowski in
 * GPU Gems 3, chapter 40:
 *
 * https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch40.html
 *
 */
 static const char *gaussian_blur_glsl_declarations =
 "uniform float sigma;                                                      \n"
 "uniform float pixel_step;                                                 \n"
 "uniform vec2 direction;                                                   \n";
 static const char *gaussian_blur_glsl =
 "  vec2 uv = vec2 (cogl_tex_coord.st);                                     \n"
 "                                                                          \n"
 "  vec3 gauss_coefficient;                                                 \n"
 "  gauss_coefficient.x = 1.0 / (sqrt (2.0 * 3.14159265) * sigma);          \n"
 "  gauss_coefficient.y = exp (-0.5 / (sigma * sigma));                     \n"
 "  gauss_coefficient.z = gauss_coefficient.y * gauss_coefficient.y;        \n"
 "                                                                          \n"
 "  float gauss_coefficient_total = gauss_coefficient.x;                    \n"
 "                                                                          \n"
 "  vec4 ret = texture2D (cogl_sampler, uv) * gauss_coefficient.x;          \n"
 "  gauss_coefficient.xy *= gauss_coefficient.yz;                           \n"
 "                                                                          \n"
 "  int n_steps = int (ceil (1.5 * sigma)) * 2;                             \n"
 "                                                                          \n"
 "  for (int i = 1; i <= n_steps; i += 2) {                                 \n"
 "    float coefficient_subtotal = gauss_coefficient.x;                     \n"
 "    gauss_coefficient.xy *= gauss_coefficient.yz;                         \n"
 "    coefficient_subtotal += gauss_coefficient.x;                          \n"
 "                                                                          \n"
 "    float gauss_ratio = gauss_coefficient.x / coefficient_subtotal;       \n"
 "                                                                          \n"
 "    float foffset = float (i) + gauss_ratio;                              \n"
 "    vec2 offset = direction * foffset * pixel_step;                       \n"
 "                                                                          \n"
 "    ret += texture2D (cogl_sampler, uv + offset) * coefficient_subtotal;  \n"
 "    ret += texture2D (cogl_sampler, uv - offset) * coefficient_subtotal;  \n"
 "                                                                          \n"
 "    gauss_coefficient_total += 2.0 * coefficient_subtotal;                \n"
 "    gauss_coefficient.xy *= gauss_coefficient.yz;                         \n"
 "  }                                                                       \n"
 "                                                                          \n"
 "  cogl_texel = ret / gauss_coefficient_total;                             \n";
 #define MIN_DOWNSCALE_SIZE 256.f
 #define MAX_SIGMA 6.f
 enum
 {
  VERTICAL,
  HORIZONTAL,
 };
 typedef struct
 {
  CoglFramebuffer *framebuffer;
  CoglPipeline *pipeline;
  CoglTexture *texture;
  int orientation;
 } BlurPass;
 struct _ClutterBlur
 {
  CoglTexture *source_texture;
  float sigma;
  float downscale_factor;
  BlurPass pass[2];
 };
 static CoglPipeline*
 create_blur_pipeline (void)
 {
  static CoglPipelineKey blur_pipeline_key = "clutter-blur-pipeline-private";
  CoglContext *ctx =
    clutter_backend_get_cogl_context (clutter_get_default_backend ());
  CoglPipeline *blur_pipeline;
  blur_pipeline =
    cogl_context_get_named_pipeline (ctx, &blur_pipeline_key);
  if (G_UNLIKELY (blur_pipeline == NULL))
    {
      CoglSnippet *snippet;
      blur_pipeline = cogl_pipeline_new (ctx);
      cogl_pipeline_set_layer_null_texture (blur_pipeline, 0);
      cogl_pipeline_set_layer_filters (blur_pipeline,
                                       0,
                                       COGL_PIPELINE_FILTER_LINEAR,
                                       COGL_PIPELINE_FILTER_LINEAR);
      cogl_pipeline_set_layer_wrap_mode (blur_pipeline,
                                         0,
                                         COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
      snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_TEXTURE_LOOKUP,
                                  gaussian_blur_glsl_declarations,
                                  NULL);
      cogl_snippet_set_replace (snippet, gaussian_blur_glsl);
      cogl_pipeline_add_layer_snippet (blur_pipeline, 0, snippet);
      cogl_object_unref (snippet);
      cogl_context_set_named_pipeline (ctx, &blur_pipeline_key, blur_pipeline);
    }
  return cogl_pipeline_copy (blur_pipeline);
 }
 static void
 update_blur_uniforms (ClutterBlur *blur,
                      BlurPass    *pass)
 {
  gboolean vertical = pass->orientation == VERTICAL;
  int sigma_uniform;
  int pixel_step_uniform;
  int direction_uniform;
  pixel_step_uniform =
    cogl_pipeline_get_uniform_location (pass->pipeline, "pixel_step");
  if (pixel_step_uniform > -1)
    {
      float pixel_step;
      if (vertical)
        pixel_step = 1.f / cogl_texture_get_height (pass->texture);
      else
        pixel_step = 1.f / cogl_texture_get_width (pass->texture);
      cogl_pipeline_set_uniform_1f (pass->pipeline,
                                    pixel_step_uniform,
                                    pixel_step);
    }
  sigma_uniform = cogl_pipeline_get_uniform_location (pass->pipeline, "sigma");
  if (sigma_uniform > -1)
    {
      cogl_pipeline_set_uniform_1f (pass->pipeline,
                                    sigma_uniform,
                                    blur->sigma / blur->downscale_factor);
    }
  direction_uniform =
    cogl_pipeline_get_uniform_location (pass->pipeline, "direction");
  if (direction_uniform > -1)
    {
      gboolean horizontal = !vertical;
      float direction[2] = {
        horizontal,
        vertical,
      };
      cogl_pipeline_set_uniform_float (pass->pipeline,
                                       direction_uniform,
                                       2, 1,
                                       direction);
    }
 }
 static gboolean
 create_fbo (ClutterBlur *blur,
            BlurPass    *pass)
 {
  CoglContext *ctx =
    clutter_backend_get_cogl_context (clutter_get_default_backend ());
  float scaled_height;
  float scaled_width;
  float height;
  float width;
  g_clear_pointer (&pass->texture, cogl_object_unref);
  g_clear_object (&pass->framebuffer);
  width = cogl_texture_get_width (blur->source_texture);
  height = cogl_texture_get_height (blur->source_texture);
  scaled_width = floorf (width / blur->downscale_factor);
  scaled_height = floorf (height / blur->downscale_factor);
  pass->texture = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx,
                                                               scaled_width,
                                                               scaled_height));
  if (!pass->texture)
    return FALSE;
  pass->framebuffer =
    COGL_FRAMEBUFFER (cogl_offscreen_new_with_texture (pass->texture));
  if (!pass->framebuffer)
    {
      g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
      return FALSE;
    }
  cogl_framebuffer_orthographic (pass->framebuffer,
                                 0.0, 0.0,
                                 scaled_width,
                                 scaled_height,
                                 0.0, 1.0);
  return TRUE;
 }
 static gboolean
 setup_blur_pass (ClutterBlur *blur,
                 BlurPass    *pass,
                 int          orientation,
                 CoglTexture *texture)
 {
  pass->orientation = orientation;
  pass->pipeline = create_blur_pipeline ();
  cogl_pipeline_set_layer_texture (pass->pipeline, 0, texture);
  if (!create_fbo (blur, pass))
    return FALSE;
  update_blur_uniforms (blur, pass);
  return TRUE;
 }
 static float
 calculate_downscale_factor (float width,
                            float height,
                            float sigma)
 {
  float downscale_factor = 1.f;
  float scaled_width = width;
  float scaled_height = height;
  float scaled_sigma = sigma;
  /* This is the algorithm used by Firefox; keep downscaling until either the
   * blur radius is lower than the threshold, or the downscaled texture is too
   * small.
   */
  while (scaled_sigma > MAX_SIGMA &&
         scaled_width > MIN_DOWNSCALE_SIZE &&
         scaled_height > MIN_DOWNSCALE_SIZE)
    {
      downscale_factor *= 2.f;
      scaled_width = width / downscale_factor;
      scaled_height = height / downscale_factor;
      scaled_sigma = sigma / downscale_factor;
    }
  return downscale_factor;
 }
 static void
 apply_blur_pass (BlurPass *pass)
 {
  CoglColor transparent;
  cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
  cogl_framebuffer_clear (pass->framebuffer,
                          COGL_BUFFER_BIT_COLOR,
                          &transparent);
  cogl_framebuffer_draw_rectangle (pass->framebuffer,
                                   pass->pipeline,
                                   0, 0,
                                   cogl_texture_get_width (pass->texture),
                                   cogl_texture_get_height (pass->texture));
 }
 static void
 clear_blur_pass (BlurPass *pass)
 {
  g_clear_pointer (&pass->pipeline, cogl_object_unref);
  g_clear_pointer (&pass->texture, cogl_object_unref);
  g_clear_object (&pass->framebuffer);
 }
 /**
 * clutter_blur_new:
 * @texture: a #CoglTexture
 * @sigma: blur sigma
 *
 * Creates a new #ClutterBlur.
 *
 * Returns: (transfer full) (nullable): A newly created #ClutterBlur
 */
 ClutterBlur *
 clutter_blur_new (CoglTexture *texture,
                  float        sigma)
 {
  ClutterBlur *blur;
  unsigned int height;
  unsigned int width;
  BlurPass *hpass;
  BlurPass *vpass;
  g_return_val_if_fail (texture != NULL, NULL);
  g_return_val_if_fail (sigma >= 0.0, NULL);
  width = cogl_texture_get_width (texture);
  height = cogl_texture_get_height (texture);
  blur = g_new0 (ClutterBlur, 1);
  blur->sigma = sigma;
  blur->source_texture = cogl_object_ref (texture);
  blur->downscale_factor = calculate_downscale_factor (width, height, sigma);
  if (G_APPROX_VALUE (sigma, 0.0, FLT_EPSILON))
    goto out;
  vpass = &blur->pass[VERTICAL];
  hpass = &blur->pass[HORIZONTAL];
  if (!setup_blur_pass (blur, vpass, VERTICAL, texture) ||
      !setup_blur_pass (blur, hpass, HORIZONTAL, vpass->texture))
    {
      clutter_blur_free (blur);
      return NULL;
    }
 out:
  return g_steal_pointer (&blur);
 }
 /**
 * clutter_blur_apply:
 * @blur: a #ClutterBlur
 *
 * Applies the blur. The resulting texture can be retrieved by
 * clutter_blur_get_texture().
 */
 void
 clutter_blur_apply (ClutterBlur *blur)
 {
  if (G_APPROX_VALUE (blur->sigma, 0.0, FLT_EPSILON))
    return;
  apply_blur_pass (&blur->pass[VERTICAL]);
  apply_blur_pass (&blur->pass[HORIZONTAL]);
 }
 /**
 * clutter_blur_get_texture:
 * @blur: a #ClutterBlur
 *
 * Retrieves the texture where the blurred contents are stored. The
 * contents are undefined until clutter_blur_apply() is called.
 *
 * Returns: (transfer none): a #CoglTexture
 */
 CoglTexture *
 clutter_blur_get_texture (ClutterBlur *blur)
 {
  if (G_APPROX_VALUE (blur->sigma, 0.0, FLT_EPSILON))
    return blur->source_texture;
  else
    return blur->pass[HORIZONTAL].texture;
 }
 /**
 * clutter_blur_free:
 * @blur: A #ClutterBlur
 *
 * Frees @blur.
 */
 void
 clutter_blur_free (ClutterBlur *blur)
 {
  g_assert (blur);
  clear_blur_pass (&blur->pass[VERTICAL]);
  clear_blur_pass (&blur->pass[HORIZONTAL]);
  cogl_clear_object (&blur->source_texture);
  g_free (blur);
 }
--- a/clutter/clutter/clutter-box-layout.c
+++ b/clutter/clutter/clutter-box-layout.c
--- a/clutter/clutter/clutter-box-layout.h
+++ b/clutter/clutter/clutter-box-layout.h
@ -77,34 +77,92 @@ struct _ClutterBoxLayoutClass
  ClutterLayoutManagerClass parent_class;
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_box_layout_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *  clutter_box_layout_new                 (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void                    clutter_box_layout_set_orientation      (ClutterBoxLayout    *layout,
                                                                 ClutterOrientation   orientation);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterOrientation      clutter_box_layout_get_orientation      (ClutterBoxLayout    *layout);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_spacing          (ClutterBoxLayout    *layout,
                                                                 guint                spacing);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 guint                   clutter_box_layout_get_spacing          (ClutterBoxLayout    *layout);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_homogeneous      (ClutterBoxLayout    *layout,
                                                                 gboolean             homogeneous);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_homogeneous      (ClutterBoxLayout    *layout);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_pack_start       (ClutterBoxLayout    *layout,
                                                                 gboolean             pack_start);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_pack_start       (ClutterBoxLayout    *layout);
 CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_set_orientation)
 void                    clutter_box_layout_set_vertical         (ClutterBoxLayout    *layout,
                                                                 gboolean             vertical);
 CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_get_orientation)
 gboolean                clutter_box_layout_get_vertical         (ClutterBoxLayout    *layout);
 CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_pack                 (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 gboolean             expand,
                                                                 gboolean             x_fill,
                                                                 gboolean             y_fill,
                                                                 ClutterBoxAlignment  x_align,
                                                                 ClutterBoxAlignment  y_align);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_alignment        (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 ClutterBoxAlignment  x_align,
                                                                 ClutterBoxAlignment  y_align);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_get_alignment        (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 ClutterBoxAlignment *x_align,
                                                                 ClutterBoxAlignment *y_align);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_fill             (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 gboolean             x_fill,
                                                                 gboolean             y_fill);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_get_fill             (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 gboolean            *x_fill,
                                                                 gboolean            *y_fill);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_expand           (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor,
                                                                 gboolean             expand);
 CLUTTER_DEPRECATED_IN_1_12
 gboolean                clutter_box_layout_get_expand           (ClutterBoxLayout    *layout,
                                                                 ClutterActor        *actor);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_use_animations   (ClutterBoxLayout    *layout,
                                                                 gboolean             animate);
 CLUTTER_DEPRECATED_IN_1_12
 gboolean                clutter_box_layout_get_use_animations   (ClutterBoxLayout    *layout);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_easing_mode      (ClutterBoxLayout    *layout,
                                                                 gulong               mode);
 CLUTTER_DEPRECATED_IN_1_12
 gulong                  clutter_box_layout_get_easing_mode      (ClutterBoxLayout    *layout);
 CLUTTER_DEPRECATED_IN_1_12
 void                    clutter_box_layout_set_easing_duration  (ClutterBoxLayout    *layout,
                                                                 guint                msecs);
 CLUTTER_DEPRECATED_IN_1_12
 guint                   clutter_box_layout_get_easing_duration  (ClutterBoxLayout    *layout);
 G_END_DECLS
 #endif /* __CLUTTER_BOX_LAYOUT_H__ */
--- a/clutter/clutter/clutter-brightness-contrast-effect.c
+++ b/clutter/clutter/clutter-brightness-contrast-effect.c
@ -37,10 +37,14 @@
 #define CLUTTER_IS_BRIGHTNESS_CONTRAST_EFFECT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT))
 #define CLUTTER_BRIGHTNESS_CONTRAST_EFFECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT, ClutterBrightnessContrastEffectClass))
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-brightness-contrast-effect.h"
 #include <cogl/cogl.h>
@ -67,6 +71,9 @@ struct _ClutterBrightnessContrastEffect
  gint brightness_offset_uniform;
  gint contrast_uniform;
  gint tex_width;
  gint tex_height;
  CoglPipeline *pipeline;
 };
@ -116,34 +123,23 @@ G_DEFINE_TYPE (ClutterBrightnessContrastEffect,
 static gboolean
 will_have_no_effect (ClutterBrightnessContrastEffect *self)
 {
-  return (G_APPROX_VALUE (self->brightness_red, no_change, FLT_EPSILON) &&
+  return (self->brightness_red == no_change &&
-          G_APPROX_VALUE (self->brightness_green, no_change, FLT_EPSILON) &&
+          self->brightness_green == no_change &&
-          G_APPROX_VALUE (self->brightness_blue, no_change, FLT_EPSILON) &&
+          self->brightness_blue == no_change &&
-          G_APPROX_VALUE (self->contrast_red, no_change, FLT_EPSILON) &&
+          self->contrast_red == no_change &&
-          G_APPROX_VALUE (self->contrast_green, no_change, FLT_EPSILON) &&
+          self->contrast_green == no_change &&
-          G_APPROX_VALUE (self->contrast_blue, no_change, FLT_EPSILON));
+          self->contrast_blue == no_change);
 }
 static CoglPipeline *
 clutter_brightness_contrast_effect_create_pipeline (ClutterOffscreenEffect *effect,
                                                    CoglTexture            *texture)
 {
  ClutterBrightnessContrastEffect *self =
    CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
  cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
  return cogl_object_ref (self->pipeline);
 }
 static gboolean
-clutter_brightness_contrast_effect_pre_paint (ClutterEffect       *effect,
+clutter_brightness_contrast_effect_pre_paint (ClutterEffect *effect)
                                              ClutterPaintNode    *node,
                                              ClutterPaintContext *paint_context)
 {
  ClutterBrightnessContrastEffect *self = CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
  ClutterEffectClass *parent_class;
  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
    return FALSE;
  if (will_have_no_effect (self))
    return FALSE;
@ -162,8 +158,44 @@ clutter_brightness_contrast_effect_pre_paint (ClutterEffect       *effect,
  parent_class =
    CLUTTER_EFFECT_CLASS (clutter_brightness_contrast_effect_parent_class);
  if (parent_class->pre_paint (effect))
    {
      ClutterOffscreenEffect *offscreen_effect =
        CLUTTER_OFFSCREEN_EFFECT (effect);
      CoglHandle texture;
-  return parent_class->pre_paint (effect, node, paint_context);
+      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
      self->tex_width = cogl_texture_get_width (texture);
      self->tex_height = cogl_texture_get_height (texture);
      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
      return TRUE;
    }
  else
    return FALSE;
 }
 static void
 clutter_brightness_contrast_effect_paint_target (ClutterOffscreenEffect *effect)
 {
  ClutterBrightnessContrastEffect *self = CLUTTER_BRIGHTNESS_CONTRAST_EFFECT (effect);
  ClutterActor *actor;
  guint8 paint_opacity;
  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
  paint_opacity = clutter_actor_get_paint_opacity (actor);
  cogl_pipeline_set_color4ub (self->pipeline,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity);
  cogl_push_source (self->pipeline);
  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
  cogl_pop_source ();
 }
 static void
@ -263,7 +295,7 @@ clutter_brightness_contrast_effect_class_init (ClutterBrightnessContrastEffectCl
  ClutterOffscreenEffectClass *offscreen_class;
  offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_brightness_contrast_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_brightness_contrast_effect_paint_target;
  effect_class->pre_paint = clutter_brightness_contrast_effect_pre_paint;
@ -407,7 +439,9 @@ clutter_brightness_contrast_effect_init (ClutterBrightnessContrastEffect *self)
      cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
      cogl_object_unref (snippet);
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
                                            0, /* layer number */
                                            COGL_TEXTURE_TYPE_2D);
    }
  self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
@ -463,9 +497,9 @@ clutter_brightness_contrast_effect_set_brightness_full (ClutterBrightnessContras
 {
  g_return_if_fail (CLUTTER_IS_BRIGHTNESS_CONTRAST_EFFECT (effect));
-  if (G_APPROX_VALUE (red, effect->brightness_red, FLT_EPSILON) &&
+  if (red == effect->brightness_red &&
-      G_APPROX_VALUE (green, effect->brightness_green, FLT_EPSILON) &&
+      green == effect->brightness_green &&
-      G_APPROX_VALUE (blue, effect->brightness_blue, FLT_EPSILON))
+      blue == effect->brightness_blue)
    return;
  effect->brightness_red = red;
@ -553,9 +587,9 @@ clutter_brightness_contrast_effect_set_contrast_full (ClutterBrightnessContrastE
 {
  g_return_if_fail (CLUTTER_IS_BRIGHTNESS_CONTRAST_EFFECT (effect));
-  if (G_APPROX_VALUE (red, effect->contrast_red, FLT_EPSILON) &&
+  if (red == effect->contrast_red &&
-      G_APPROX_VALUE (green, effect->contrast_green, FLT_EPSILON) &&
+      green == effect->contrast_green &&
-      G_APPROX_VALUE (blue, effect->contrast_blue, FLT_EPSILON))
+      blue == effect->contrast_blue)
    return;
  effect->contrast_red = red;
--- a/clutter/clutter/clutter-brightness-contrast-effect.h
+++ b/clutter/clutter/clutter-brightness-contrast-effect.h
@ -49,35 +49,35 @@ G_BEGIN_DECLS
 typedef struct _ClutterBrightnessContrastEffect         ClutterBrightnessContrastEffect;
 typedef struct _ClutterBrightnessContrastEffectClass    ClutterBrightnessContrastEffectClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_brightness_contrast_effect_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterEffect * clutter_brightness_contrast_effect_new                          (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness_full          (ClutterBrightnessContrastEffect *effect,
                                                                                 float                            red,
                                                                                 float                            green,
                                                                                 float                            blue);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness               (ClutterBrightnessContrastEffect *effect,
                                                                                 float                            brightness);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_brightness               (ClutterBrightnessContrastEffect *effect,
                                                                                 float                           *red,
                                                                                 float                           *green,
                                                                                 float                           *blue);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast_full            (ClutterBrightnessContrastEffect *effect,
                                                                                 float                            red,
                                                                                 float                            green,
                                                                                 float                            blue);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast                 (ClutterBrightnessContrastEffect *effect,
                                                                                 float                            contrast);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_contrast                 (ClutterBrightnessContrastEffect *effect,
                                                                                 float                           *red,
                                                                                 float                           *green,
--- a/clutter/clutter/clutter-build-config.h.meson
+++ b/clutter/clutter/clutter-build-config.h.meson
@ -1,8 +0,0 @@
 /* Mutter version */
 #mesondefine MUTTER_VERSION
 /* List of Cogl drivers */
 #mesondefine CLUTTER_DRIVERS
 /* Supports PangoFt2 */
 #mesondefine HAVE_PANGO_FT2
--- a/clutter/clutter/clutter-cairo.c
+++ b/clutter/clutter/clutter-cairo.c
@ -27,7 +27,9 @@
 * Clutter provides some utility functions for using Cairo.
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-cairo.h"
 #include "clutter-color.h"
--- a/clutter/clutter/clutter-cairo.h
+++ b/clutter/clutter/clutter-cairo.h
@ -50,9 +50,9 @@ G_BEGIN_DECLS
 #define CLUTTER_CAIRO_FORMAT_ARGB32     (COGL_PIXEL_FORMAT_ARGB_8888_PRE)
 #endif
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 void    clutter_cairo_clear             (cairo_t               *cr);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void    clutter_cairo_set_source_color  (cairo_t               *cr,
                                         const ClutterColor    *color);
--- a/clutter/clutter/clutter-canvas.c
+++ b/clutter/clutter/clutter-canvas.c
@ -42,14 +42,17 @@
 * #ClutterCanvas is available since Clutter 1.10.
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
 #include <cogl/cogl.h>
 #include <cairo-gobject.h>
 #include "clutter-canvas.h"
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-actor-private.h"
 #include "clutter-backend.h"
 #include "clutter-cairo.h"
@ -68,7 +71,6 @@ struct _ClutterCanvasPrivate
  int width;
  int height;
  float scale_factor;
  CoglTexture *texture;
  gboolean dirty;
@ -82,7 +84,6 @@ enum
  PROP_WIDTH,
  PROP_HEIGHT,
  PROP_SCALE_FACTOR,
  LAST_PROP
 };
@ -98,7 +99,7 @@ enum
 static guint canvas_signals[LAST_SIGNAL] = { 0, };
-static void clutter_content_iface_init (ClutterContentInterface *iface);
+static void clutter_content_iface_init (ClutterContentIface *iface);
 G_DEFINE_TYPE_WITH_CODE (ClutterCanvas, clutter_canvas, G_TYPE_OBJECT,
                         G_ADD_PRIVATE (ClutterCanvas)
@ -179,19 +180,6 @@ clutter_canvas_set_property (GObject      *gobject,
      }
      break;
    case PROP_SCALE_FACTOR:
      {
        gfloat new_scale_factor = g_value_get_float (value);
        if (priv->scale_factor != new_scale_factor)
          {
            priv->scale_factor = new_scale_factor;
            clutter_content_invalidate (CLUTTER_CONTENT (gobject));
          }
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
@ -216,10 +204,6 @@ clutter_canvas_get_property (GObject    *gobject,
      g_value_set_int (value, priv->height);
      break;
    case PROP_SCALE_FACTOR:
      g_value_set_float (value, priv->scale_factor);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
@ -263,19 +247,6 @@ clutter_canvas_class_init (ClutterCanvasClass *klass)
                      G_PARAM_READWRITE |
                      G_PARAM_STATIC_STRINGS);
  /**
   * ClutterCanvas:scale-factor:
   *
   * The height of the canvas.
   */
  obj_props[PROP_SCALE_FACTOR] =
    g_param_spec_float ("scale-factor",
                        P_("Scale Factor"),
                        P_("The Scale factor of the canvas"),
                        0.01f, G_MAXFLOAT,
                        1.0f,
                        G_PARAM_READWRITE |
                        G_PARAM_STATIC_STRINGS);
  /**
   * ClutterCanvas::draw:
@ -322,14 +293,12 @@ clutter_canvas_init (ClutterCanvas *self)
  self->priv->width = -1;
  self->priv->height = -1;
  self->priv->scale_factor = 1.0f;
 }
 static void
-clutter_canvas_paint_content (ClutterContent      *content,
+clutter_canvas_paint_content (ClutterContent   *content,
-                              ClutterActor        *actor,
+                              ClutterActor     *actor,
-                              ClutterPaintNode    *root,
+                              ClutterPaintNode *root)
                              ClutterPaintContext *paint_context)
 {
  ClutterCanvas *self = CLUTTER_CANVAS (content);
  ClutterCanvasPrivate *priv = self->priv;
@ -350,7 +319,7 @@ clutter_canvas_paint_content (ClutterContent      *content,
    return;
  node = clutter_actor_create_texture_paint_node (actor, priv->texture);
-  clutter_paint_node_set_static_name (node, "Canvas Content");
+  clutter_paint_node_set_name (node, "Canvas Content");
  clutter_paint_node_add_child (root, node);
  clutter_paint_node_unref (node);
@ -373,8 +342,8 @@ clutter_canvas_emit_draw (ClutterCanvas *self)
  priv->dirty = TRUE;
-  real_width = ceilf (priv->width * priv->scale_factor);
+  real_width = priv->width;
-  real_height = ceilf (priv->height * priv->scale_factor);
+  real_height = priv->height;
  CLUTTER_NOTE (MISC, "Creating Cairo surface with size %d x %d",
                priv->width, priv->height);
@ -420,10 +389,6 @@ clutter_canvas_emit_draw (ClutterCanvas *self)
      mapped_buffer = FALSE;
    }
  cairo_surface_set_device_scale (surface,
                                  priv->scale_factor,
                                  priv->scale_factor);
  self->priv->cr = cr = cairo_create (surface);
  g_signal_emit (self, canvas_signals[DRAW], 0,
@ -485,16 +450,16 @@ clutter_canvas_get_preferred_size (ClutterContent *content,
    return FALSE;
  if (width != NULL)
-    *width = ceilf (priv->width * priv->scale_factor);
+    *width = priv->width;
  if (height != NULL)
-    *height = ceilf (priv->height * priv->scale_factor);
+    *height = priv->height;
  return TRUE;
 }
 static void
-clutter_content_iface_init (ClutterContentInterface *iface)
+clutter_content_iface_init (ClutterContentIface *iface)
 {
  iface->invalidate = clutter_canvas_invalidate;
  iface->paint_content = clutter_canvas_paint_content;
@ -597,48 +562,3 @@ clutter_canvas_set_size (ClutterCanvas *canvas,
  return clutter_canvas_invalidate_internal (canvas, width, height);
 }
 /**
 * clutter_canvas_set_scale_factor:
 * @canvas: a #ClutterCanvas
 * @scale: the integer scaling factor of the canvas
 *
 * Sets the scaling factor of the @canvas, and invalidates the content.
 *
 * This function will cause the @canvas to be invalidated only
 * if the scale factor of the canvas surface has changed.
 */
 void
 clutter_canvas_set_scale_factor (ClutterCanvas *canvas,
                                 float          scale)
 {
  g_return_if_fail (CLUTTER_IS_CANVAS (canvas));
  g_return_if_fail (scale > 0.0f);
  if (canvas->priv->scale_factor != scale)
    {
      canvas->priv->scale_factor = scale;
      g_object_freeze_notify (G_OBJECT (canvas));
      clutter_content_invalidate (CLUTTER_CONTENT (canvas));
      g_object_thaw_notify (G_OBJECT (canvas));
      g_object_notify_by_pspec (G_OBJECT (canvas), obj_props[PROP_SCALE_FACTOR]);
    }
 }
 /**
 * clutter_canvas_get_scale_factor:
 * @canvas: a #ClutterCanvas
 *
 * Gets the scale factor of the @canvas.
 *
 * Return value: the current @canvas scale factor or -1 if invalid
 */
 float
 clutter_canvas_get_scale_factor (ClutterCanvas *canvas)
 {
  g_return_val_if_fail (CLUTTER_IS_CANVAS (canvas), -1.0f);
  return canvas->priv->scale_factor;
 }
--- a/clutter/clutter/clutter-canvas.h
+++ b/clutter/clutter/clutter-canvas.h
@ -85,21 +85,21 @@ struct _ClutterCanvasClass
  gpointer _padding[16];
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_canvas_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 ClutterContent *        clutter_canvas_new                      (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                clutter_canvas_set_size                 (ClutterCanvas *canvas,
                                                                 int            width,
                                                                 int            height);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_18
 void                    clutter_canvas_set_scale_factor         (ClutterCanvas *canvas,
-                                                                 float          scale);
+                                                                 int            scale);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_18
-float                   clutter_canvas_get_scale_factor         (ClutterCanvas *canvas);
+int                     clutter_canvas_get_scale_factor         (ClutterCanvas *canvas);
 G_END_DECLS
--- a/clutter/clutter/clutter-child-meta.c
+++ b/clutter/clutter/clutter-child-meta.c
@ -36,8 +36,9 @@
 *
 * #ClutterChildMeta is available since Clutter 0.8
 */
-
+#ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-child-meta.h"
 #include "clutter-container.h"
--- a/clutter/clutter/clutter-child-meta.h
+++ b/clutter/clutter/clutter-child-meta.h
@ -109,12 +109,12 @@ struct _ClutterChildMetaClass
  GObjectClass parent_class;
 }; 
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_child_meta_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterContainer *      clutter_child_meta_get_container        (ClutterChildMeta *data);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor     *      clutter_child_meta_get_actor            (ClutterChildMeta *data);
 G_END_DECLS
--- a/clutter/clutter/clutter-click-action.c
+++ b/clutter/clutter/clutter-click-action.c
@ -92,7 +92,9 @@
 * #ClutterClickAction is available since Clutter 1.4
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include "clutter-click-action.h"
@ -105,8 +107,8 @@ struct _ClutterClickActionPrivate
 {
  ClutterActor *stage;
-  gulong event_id;
+  guint event_id;
-  gulong capture_id;
+  guint capture_id;
  guint long_press_id;
  gint long_press_threshold;
@ -114,7 +116,7 @@ struct _ClutterClickActionPrivate
  gint drag_threshold;
  guint press_button;
-  ClutterInputDevice *press_device;
+  gint press_device_id;
  ClutterEventSequence *press_sequence;
  ClutterModifierType modifier_state;
  gfloat press_x;
@ -159,8 +161,7 @@ static inline void
 click_action_set_pressed (ClutterClickAction *action,
                          gboolean            is_pressed)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  is_pressed = !!is_pressed;
@ -175,8 +176,7 @@ static inline void
 click_action_set_held (ClutterClickAction *action,
                       gboolean            is_held)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  is_held = !!is_held;
@ -191,8 +191,7 @@ static gboolean
 click_action_emit_long_press (gpointer data)
 {
  ClutterClickAction *action = data;
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  ClutterActor *actor;
  gboolean result;
@ -205,7 +204,11 @@ click_action_emit_long_press (gpointer data)
                 CLUTTER_LONG_PRESS_ACTIVATE,
                 &result);
-  g_clear_signal_handler (&priv->capture_id, priv->stage);
+  if (priv->capture_id != 0)
    {
      g_signal_handler_disconnect (priv->stage, priv->capture_id);
      priv->capture_id = 0;
    }
  click_action_set_pressed (action, FALSE);
  click_action_set_held (action, FALSE);
@ -216,8 +219,7 @@ click_action_emit_long_press (gpointer data)
 static inline void
 click_action_query_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  ClutterActor *actor;
  gboolean result = FALSE;
  gint timeout;
@ -242,7 +244,6 @@ click_action_query_long_press (ClutterClickAction *action)
  if (result)
    {
      g_clear_handle_id (&priv->long_press_id, g_source_remove);
      priv->long_press_id =
        clutter_threads_add_timeout (timeout,
                                     click_action_emit_long_press,
@ -253,8 +254,7 @@ click_action_query_long_press (ClutterClickAction *action)
 static inline void
 click_action_cancel_long_press (ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  if (priv->long_press_id != 0)
    {
@ -263,7 +263,8 @@ click_action_cancel_long_press (ClutterClickAction *action)
      actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
-      g_clear_handle_id (&priv->long_press_id, g_source_remove);
+      g_source_remove (priv->long_press_id);
      priv->long_press_id = 0;
      g_signal_emit (action, click_signals[LONG_PRESS], 0,
                     actor,
@ -272,30 +273,12 @@ click_action_cancel_long_press (ClutterClickAction *action)
    }
 }
 static inline gboolean
 event_within_drag_threshold (ClutterClickAction *click_action,
                             ClutterEvent       *event)
 {
  ClutterClickActionPrivate *priv =
    clutter_click_action_get_instance_private (click_action);
  float motion_x, motion_y;
  float delta_x, delta_y;
  clutter_event_get_coords (event, &motion_x, &motion_y);
  delta_x = ABS (motion_x - priv->press_x);
  delta_y = ABS (motion_y - priv->press_y);
  return delta_x <= priv->drag_threshold && delta_y <= priv->drag_threshold;
 }
 static gboolean
 on_event (ClutterActor       *actor,
          ClutterEvent       *event,
          ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  gboolean has_button = TRUE;
  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
@ -316,7 +299,7 @@ on_event (ClutterActor       *actor,
        return CLUTTER_EVENT_PROPAGATE;
      priv->press_button = has_button ? clutter_event_get_button (event) : 0;
-      priv->press_device = clutter_event_get_device (event);
+      priv->press_device_id = clutter_event_get_device_id (event);
      priv->press_sequence = clutter_event_get_event_sequence (event);
      priv->modifier_state = clutter_event_get_state (event);
      clutter_event_get_coords (event, &priv->press_x, &priv->press_y);
@ -365,8 +348,7 @@ on_captured_event (ClutterActor       *stage,
                   ClutterEvent       *event,
                   ClutterClickAction *action)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  ClutterActor *actor;
  ClutterModifierType modifier_state;
  gboolean has_button = TRUE;
@ -375,10 +357,6 @@ on_captured_event (ClutterActor       *stage,
  switch (clutter_event_type (event))
    {
    case CLUTTER_TOUCH_CANCEL:
      clutter_click_action_release (action);
      break;
    case CLUTTER_TOUCH_END:
      has_button = FALSE;
    case CLUTTER_BUTTON_RELEASE:
@ -387,7 +365,7 @@ on_captured_event (ClutterActor       *stage,
      if ((has_button && clutter_event_get_button (event) != priv->press_button) ||
          (has_button && clutter_event_get_click_count (event) != 1) ||
-          clutter_event_get_device (event) != priv->press_device ||
+          clutter_event_get_device_id (event) != priv->press_device_id ||
          clutter_event_get_event_sequence (event) != priv->press_sequence)
        return CLUTTER_EVENT_PROPAGATE;
@ -395,9 +373,17 @@ on_captured_event (ClutterActor       *stage,
      click_action_cancel_long_press (action);
      /* disconnect the capture */
-      g_clear_signal_handler (&priv->capture_id, priv->stage);
+      if (priv->capture_id != 0)
        {
          g_signal_handler_disconnect (priv->stage, priv->capture_id);
          priv->capture_id = 0;
        }
-      g_clear_handle_id (&priv->long_press_id, g_source_remove);
+      if (priv->long_press_id != 0)
        {
          g_source_remove (priv->long_press_id);
          priv->long_press_id = 0;
        }
      if (!clutter_actor_contains (actor, clutter_event_get_source (event)))
        return CLUTTER_EVENT_PROPAGATE;
@ -419,23 +405,30 @@ on_captured_event (ClutterActor       *stage,
        priv->modifier_state = 0;
      click_action_set_pressed (action, FALSE);
-
+      g_signal_emit (action, click_signals[CLICKED], 0, actor);
      if (event_within_drag_threshold (action, event))
        g_signal_emit (action, click_signals[CLICKED], 0, actor);
      break;
    case CLUTTER_MOTION:
    case CLUTTER_TOUCH_UPDATE:
      {
-        if (clutter_event_get_device (event) != priv->press_device ||
+        gfloat motion_x, motion_y;
        gfloat delta_x, delta_y;
        if (clutter_event_get_device_id (event) != priv->press_device_id ||
            clutter_event_get_event_sequence (event) != priv->press_sequence)
          return CLUTTER_EVENT_PROPAGATE;
        if (!priv->is_held)
          return CLUTTER_EVENT_PROPAGATE;
-        if (!event_within_drag_threshold (action, event))
+        clutter_event_get_coords (event, &motion_x, &motion_y);
-          clutter_click_action_release (action);
+
        delta_x = ABS (motion_x - priv->press_x);
        delta_y = ABS (motion_y - priv->press_y);
        if (delta_x > priv->drag_threshold ||
            delta_y > priv->drag_threshold)
          click_action_cancel_long_press (action);
      }
      break;
@ -451,15 +444,14 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
                                ClutterActor     *actor)
 {
  ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = action->priv;
    clutter_click_action_get_instance_private (action);
  if (priv->event_id != 0)
    {
      ClutterActor *old_actor = clutter_actor_meta_get_actor (meta);
      if (old_actor != NULL)
-        g_clear_signal_handler (&priv->event_id, old_actor);
+        g_signal_handler_disconnect (old_actor, priv->event_id);
      priv->event_id = 0;
    }
@ -467,13 +459,17 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
  if (priv->capture_id != 0)
    {
      if (priv->stage != NULL)
-        g_clear_signal_handler (&priv->capture_id, priv->stage);
+        g_signal_handler_disconnect (priv->stage, priv->capture_id);
      priv->capture_id = 0;
      priv->stage = NULL;
    }
-  g_clear_handle_id (&priv->long_press_id, g_source_remove);
+  if (priv->long_press_id != 0)
    {
      g_source_remove (priv->long_press_id);
      priv->long_press_id = 0;
    }
  click_action_set_pressed (action, FALSE);
  click_action_set_held (action, FALSE);
@ -486,28 +482,13 @@ clutter_click_action_set_actor (ClutterActorMeta *meta,
  CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class)->set_actor (meta, actor);
 }
 static void
 clutter_click_action_set_enabled (ClutterActorMeta *meta,
                                  gboolean          is_enabled)
 {
  ClutterClickAction *click_action = CLUTTER_CLICK_ACTION (meta);
  ClutterActorMetaClass *parent_class =
    CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class);
  if (!is_enabled)
    clutter_click_action_release (click_action);
  parent_class->set_enabled (meta, is_enabled);
 }
 static void
 clutter_click_action_set_property (GObject      *gobject,
                                   guint         prop_id,
                                   const GValue *value,
                                   GParamSpec   *pspec)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
  switch (prop_id)
    {
@ -531,8 +512,7 @@ clutter_click_action_get_property (GObject    *gobject,
                                   GValue     *value,
                                   GParamSpec *pspec)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
  switch (prop_id)
    {
@ -561,15 +541,26 @@ clutter_click_action_get_property (GObject    *gobject,
 static void
 clutter_click_action_dispose (GObject *gobject)
 {
-  ClutterClickActionPrivate *priv =
+  ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
    clutter_click_action_get_instance_private (CLUTTER_CLICK_ACTION (gobject));
-  g_clear_signal_handler (&priv->event_id,
+  if (priv->event_id)
-                          clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (gobject)));
+    {
      g_signal_handler_disconnect (clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (gobject)),
                                   priv->event_id);
      priv->event_id = 0;
    }
-  g_clear_signal_handler (&priv->capture_id, priv->stage);
+  if (priv->capture_id)
    {
      g_signal_handler_disconnect (priv->stage, priv->capture_id);
      priv->capture_id = 0;
    }
-  g_clear_handle_id (&priv->long_press_id, g_source_remove);
+  if (priv->long_press_id)
    {
      g_source_remove (priv->long_press_id);
      priv->long_press_id = 0;
    }
  G_OBJECT_CLASS (clutter_click_action_parent_class)->dispose (gobject);
 }
@ -582,7 +573,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
  ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
  meta_class->set_actor = clutter_click_action_set_actor;
  meta_class->set_enabled = clutter_click_action_set_enabled;
  gobject_class->dispose = clutter_click_action_dispose;
  gobject_class->set_property = clutter_click_action_set_property;
@ -674,7 +664,8 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (ClutterClickActionClass, clicked),
-                  NULL, NULL, NULL,
+                  NULL, NULL,
                  _clutter_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
                  CLUTTER_TYPE_ACTOR);
@ -720,11 +711,9 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
 static void
 clutter_click_action_init (ClutterClickAction *self)
 {
-  ClutterClickActionPrivate *priv =
+  self->priv = clutter_click_action_get_instance_private (self);
-    clutter_click_action_get_instance_private (self);
+  self->priv->long_press_threshold = -1;
-
+  self->priv->long_press_duration = -1;
  priv->long_press_threshold = -1;
  priv->long_press_duration = -1;
 }
 /**
@ -764,13 +753,17 @@ clutter_click_action_release (ClutterClickAction *action)
  g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));
-  priv = clutter_click_action_get_instance_private (action);
+  priv = action->priv;
  if (!priv->is_held)
    return;
  /* disconnect the capture */
-  g_clear_signal_handler (&priv->capture_id, priv->stage);
+  if (priv->capture_id != 0)
    {
      g_signal_handler_disconnect (priv->stage, priv->capture_id);
      priv->capture_id = 0;
    }
  click_action_cancel_long_press (action);
  click_action_set_held (action, FALSE);
@ -790,13 +783,9 @@ clutter_click_action_release (ClutterClickAction *action)
 guint
 clutter_click_action_get_button (ClutterClickAction *action)
 {
  ClutterClickActionPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
-  priv = clutter_click_action_get_instance_private (action);
+  return action->priv->press_button;
  return priv->press_button;
 }
 /**
@ -812,13 +801,9 @@ clutter_click_action_get_button (ClutterClickAction *action)
 ClutterModifierType
 clutter_click_action_get_state (ClutterClickAction *action)
 {
  ClutterClickActionPrivate *priv;
  g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
-  priv = clutter_click_action_get_instance_private (action);
+  return action->priv->modifier_state;
  return priv->modifier_state;
 }
 /**
@ -836,15 +821,11 @@ clutter_click_action_get_coords (ClutterClickAction *action,
                                 gfloat             *press_x,
                                 gfloat             *press_y)
 {
  ClutterClickActionPrivate *priv;
  g_return_if_fail (CLUTTER_IS_ACTION (action));
  priv = clutter_click_action_get_instance_private (action);
  if (press_x != NULL)
-    *press_x = priv->press_x;
+    *press_x = action->priv->press_x;
  if (press_y != NULL)
-    *press_y = priv->press_y;
+    *press_y = action->priv->press_y;
 }
--- a/clutter/clutter/clutter-click-action.h
+++ b/clutter/clutter/clutter-click-action.h
@ -37,13 +37,32 @@
 G_BEGIN_DECLS
-#define CLUTTER_TYPE_CLICK_ACTION (clutter_click_action_get_type ())
+#define CLUTTER_TYPE_CLICK_ACTION               (clutter_click_action_get_type ())
 #define CLUTTER_CLICK_ACTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickAction))
 #define CLUTTER_IS_CLICK_ACTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CLICK_ACTION))
 #define CLUTTER_CLICK_ACTION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))
 #define CLUTTER_IS_CLICK_ACTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CLICK_ACTION))
 #define CLUTTER_CLICK_ACTION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))
-CLUTTER_EXPORT
+typedef struct _ClutterClickAction              ClutterClickAction;
-G_DECLARE_DERIVABLE_TYPE (ClutterClickAction, clutter_click_action,
+typedef struct _ClutterClickActionPrivate       ClutterClickActionPrivate;
-                          CLUTTER, CLICK_ACTION, ClutterAction);
+typedef struct _ClutterClickActionClass         ClutterClickActionClass;
-typedef struct _ClutterClickActionPrivate ClutterClickActionPrivate;
+/**
 * ClutterClickAction:
 *
 * The #ClutterClickAction structure contains
 * only private data and should be accessed using the provided API
 *
 * Since: 1.4
 */
 struct _ClutterClickAction
 {
  /*< private >*/
  ClutterAction parent_instance;
  ClutterClickActionPrivate *priv;
 };
 /**
 * ClutterClickActionClass:
@ -78,19 +97,22 @@ struct _ClutterClickActionClass
  void (* _clutter_click_action7) (void);
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_click_action_get_type (void) G_GNUC_CONST;
 CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *        clutter_click_action_new        (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 guint                  clutter_click_action_get_button (ClutterClickAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterModifierType    clutter_click_action_get_state  (ClutterClickAction *action);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_click_action_get_coords (ClutterClickAction *action,
                                                        gfloat             *press_x,
                                                        gfloat             *press_y);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void                   clutter_click_action_release    (ClutterClickAction *action);
 G_END_DECLS
--- a/clutter/clutter/clutter-clone.c
+++ b/clutter/clutter/clutter-clone.c
@ -37,8 +37,11 @@
 * #ClutterClone is available since Clutter 1.0
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-actor-private.h"
 #include "clutter-clone.h"
 #include "clutter-debug.h"
@ -51,8 +54,6 @@
 struct _ClutterClonePrivate
 {
  ClutterActor *clone_source;
  float x_scale, y_scale;
  gulong source_destroy_id;
 };
@ -120,22 +121,40 @@ clutter_clone_get_preferred_height (ClutterActor *self,
 }
 static void
-clutter_clone_apply_transform (ClutterActor      *self,
+clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix)
                               graphene_matrix_t *matrix)
 {
  ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
  ClutterActorBox box, source_box;
  gfloat x_scale, y_scale;
-
+  /* First chain up and apply all the standard ClutterActor
-  if (priv->clone_source)
+   * transformations... */
    graphene_matrix_scale (matrix, priv->x_scale, priv->y_scale, 1.f);
  CLUTTER_ACTOR_CLASS (clutter_clone_parent_class)->apply_transform (self,
                                                                     matrix);
  /* if we don't have a source, nothing else to do */
  if (priv->clone_source == NULL)
    return;
  /* get our allocated size */
  clutter_actor_get_allocation_box (self, &box);
  /* and get the allocated size of the source */
  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
  /* We need to scale what the clone-source actor paints to fill our own
   * allocation...
   */
  x_scale = clutter_actor_box_get_width (&box)
          / clutter_actor_box_get_width (&source_box);
  y_scale = clutter_actor_box_get_height (&box)
          / clutter_actor_box_get_height (&source_box);
  cogl_matrix_scale (matrix, x_scale, y_scale, x_scale);
 }
 static void
-clutter_clone_paint (ClutterActor        *actor,
+clutter_clone_paint (ClutterActor *actor)
                     ClutterPaintContext *paint_context)
 {
  ClutterClone *self = CLUTTER_CLONE (actor);
  ClutterClonePrivate *priv = self->priv;
@ -172,7 +191,7 @@ clutter_clone_paint (ClutterActor        *actor,
  if (clutter_actor_is_realized (priv->clone_source))
    {
      _clutter_actor_push_clone_paint ();
-      clutter_actor_paint (priv->clone_source, paint_context);
+      clutter_actor_paint (priv->clone_source);
      _clutter_actor_pop_clone_paint ();
    }
@ -195,7 +214,7 @@ clutter_clone_get_paint_volume (ClutterActor       *actor,
  if (priv->clone_source == NULL)
    return TRUE;
-  /* query the volume of the source actor and simply masquerade it as
+  /* query the volume of the source actor and simply masquarade it as
   * the clones volume... */
  source_volume = clutter_actor_get_paint_volume (priv->clone_source);
  if (source_volume == NULL)
@ -222,51 +241,19 @@ clutter_clone_has_overlaps (ClutterActor *actor)
 static void
 clutter_clone_allocate (ClutterActor           *self,
-                        const ClutterActorBox  *box)
+                        const ClutterActorBox  *box,
                        ClutterAllocationFlags  flags)
 {
  ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
  ClutterActorClass *parent_class;
  ClutterActorBox source_box;
  float x_scale, y_scale;
  /* chain up */
  parent_class = CLUTTER_ACTOR_CLASS (clutter_clone_parent_class);
-  parent_class->allocate (self, box);
+  parent_class->allocate (self, box, flags);
  if (priv->clone_source == NULL)
    return;
  /* ClutterActor delays allocating until the actor is shown; however
   * we cannot paint it correctly in that case, so force an allocation.
   */
  if (clutter_actor_get_parent (priv->clone_source) != NULL &&
      !clutter_actor_has_allocation (priv->clone_source))
    {
      float x = 0.f;
      float y = 0.f;
      clutter_actor_get_fixed_position (priv->clone_source, &x, &y);
      clutter_actor_allocate_preferred_size (priv->clone_source, x, y);
    }
  clutter_actor_get_allocation_box (priv->clone_source, &source_box);
  /* We need to scale what the clone-source actor paints to fill our own
   * allocation...
   */
  x_scale = clutter_actor_box_get_width (box)
          / clutter_actor_box_get_width (&source_box);
  y_scale = clutter_actor_box_get_height (box)
          / clutter_actor_box_get_height (&source_box);
  if (!G_APPROX_VALUE (priv->x_scale, x_scale, FLT_EPSILON) ||
      !G_APPROX_VALUE (priv->y_scale, y_scale, FLT_EPSILON))
    {
      priv->x_scale = x_scale;
      priv->y_scale = y_scale;
      clutter_actor_invalidate_transform (CLUTTER_ACTOR (self));
    }
 #if 0
  /* XXX - this is wrong: ClutterClone cannot clone unparented
   * actors, as it will break all invariants
@ -280,7 +267,7 @@ clutter_clone_allocate (ClutterActor           *self,
   * paint cycle, we can safely give it as much size as it requires
   */
  if (clutter_actor_get_parent (priv->clone_source) == NULL)
-    clutter_actor_allocate_preferred_size (priv->clone_source);
+    clutter_actor_allocate_preferred_size (priv->clone_source, flags);
 #endif
 }
@ -372,9 +359,6 @@ static void
 clutter_clone_init (ClutterClone *self)
 {
  self->priv = clutter_clone_get_instance_private (self);
  self->priv->x_scale = 1.f;
  self->priv->y_scale = 1.f;
 }
 /**
@ -411,7 +395,8 @@ clutter_clone_set_source_internal (ClutterClone *self,
  if (priv->clone_source != NULL)
    {
-      g_clear_signal_handler (&priv->source_destroy_id, priv->clone_source);
+      g_signal_handler_disconnect (priv->clone_source, priv->source_destroy_id);
      priv->source_destroy_id = 0;
      _clutter_actor_detach_clone (priv->clone_source, CLUTTER_ACTOR (self));
      g_object_unref (priv->clone_source);
      priv->clone_source = NULL;
--- a/clutter/clutter/clutter-clone.h
+++ b/clutter/clutter/clutter-clone.h
@ -78,15 +78,15 @@ struct _ClutterCloneClass
  void (*_clutter_actor_clone4) (void);
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_clone_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *  clutter_clone_new               (ClutterActor *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_clone_set_source        (ClutterClone *self,
                                                 ClutterActor *source);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *  clutter_clone_get_source        (ClutterClone *self);
 G_END_DECLS
--- a/clutter/clutter/clutter-color.c
+++ b/clutter/clutter/clutter-color.c
@ -33,7 +33,9 @@
 * The alpha channel is fully opaque at 255 and fully transparent at 0.
 */
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #include <math.h>
@ -611,7 +613,7 @@ parse_hsla (ClutterColor *color,
 /**
 * clutter_color_from_string:
 * @color: (out caller-allocates): return location for a #ClutterColor
- * @str: a string specifying a color
+ * @str: a string specifiying a color
 *
 * Parses a string definition of a color, filling the #ClutterColor.red,
 * #ClutterColor.green, #ClutterColor.blue and #ClutterColor.alpha fields 
@ -911,7 +913,7 @@ ClutterColor *
 clutter_color_copy (const ClutterColor *color)
 {
  if (G_LIKELY (color != NULL))
-    return g_memdup2 (color, sizeof (ClutterColor));
+    return g_slice_dup (ClutterColor, color);
  return NULL;
 }
@ -928,7 +930,7 @@ void
 clutter_color_free (ClutterColor *color)
 {
  if (G_LIKELY (color != NULL))
-    g_free (color);
+    g_slice_free (ClutterColor, color);
 }
 /**
@ -977,7 +979,7 @@ clutter_color_new (guint8 red,
 ClutterColor *
 clutter_color_alloc (void)
 {
-  return g_new0 (ClutterColor, 1);
+  return g_slice_new0 (ClutterColor);
 }
 /**
--- a/clutter/clutter/clutter-color.h
+++ b/clutter/clutter/clutter-color.h
@ -68,76 +68,76 @@ struct _ClutterColor
 */
 #define CLUTTER_COLOR_INIT(r,g,b,a)     { (r), (g), (b), (a) }
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_color_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_new         (guint8              red,
                                         guint8              green,
                                         guint8              blue,
                                         guint8              alpha);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_alloc       (void);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_init        (ClutterColor       *color,
                                         guint8              red,
                                         guint8              green,
                                         guint8              blue,
                                         guint8              alpha);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_copy        (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_free        (ClutterColor       *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_add         (const ClutterColor *a,
                                         const ClutterColor *b,
                                         ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_subtract    (const ClutterColor *a,
                                         const ClutterColor *b,
                                         ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_lighten     (const ClutterColor *color,
                                         ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_darken      (const ClutterColor *color,
                                         ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_shade       (const ClutterColor *color,
                                         gdouble             factor,
                                         ClutterColor       *result);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gchar *       clutter_color_to_string   (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 gboolean      clutter_color_from_string (ClutterColor       *color,
                                         const gchar        *str);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_to_hls      (const ClutterColor *color,
                                         gfloat             *hue,
 					 gfloat             *luminance,
 					 gfloat             *saturation);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_hls    (ClutterColor       *color,
                                         gfloat              hue,
                                         gfloat              luminance,
                                         gfloat              saturation);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 guint32       clutter_color_to_pixel    (const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_pixel  (ClutterColor       *color,
                                         guint32             pixel);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 guint         clutter_color_hash        (gconstpointer       v);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_ALL
 gboolean      clutter_color_equal       (gconstpointer       v1,
                                         gconstpointer       v2);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 void          clutter_color_interpolate (const ClutterColor *initial,
                                         const ClutterColor *final,
                                         gdouble             progress,
@ -177,22 +177,22 @@ struct _ClutterParamSpecColor
  ClutterColor *default_value;
 };
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 void                    clutter_value_set_color         (GValue             *value,
                                                         const ClutterColor *color);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 const ClutterColor *    clutter_value_get_color         (const GValue       *value);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_param_color_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *    clutter_param_spec_color        (const gchar        *name,
                                                 const gchar        *nick,
                                                 const gchar        *blurb,
                                                 const ClutterColor *default_value,
                                                 GParamFlags         flags);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterColor *clutter_color_get_static (ClutterStaticColor color);
 G_END_DECLS
--- a/clutter/clutter/clutter-colorize-effect.c
+++ b/clutter/clutter/clutter-colorize-effect.c
@ -37,7 +37,11 @@
 #define CLUTTER_IS_COLORIZE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_COLORIZE_EFFECT))
 #define CLUTTER_COLORIZE_EFFECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_COLORIZE_EFFECT, ClutterColorizeEffectClass))
 #ifdef HAVE_CONFIG_H
 #include "clutter-build-config.h"
 #endif
 #define CLUTTER_ENABLE_EXPERIMENTAL_API
 #include "clutter-colorize-effect.h"
@ -57,6 +61,9 @@ struct _ClutterColorizeEffect
  gint tint_uniform;
  gint tex_width;
  gint tex_height;
  CoglPipeline *pipeline;
 };
@ -99,24 +106,15 @@ G_DEFINE_TYPE (ClutterColorizeEffect,
               clutter_colorize_effect,
               CLUTTER_TYPE_OFFSCREEN_EFFECT);
 static CoglPipeline *
 clutter_colorize_effect_create_pipeline (ClutterOffscreenEffect *effect,
                                         CoglTexture            *texture)
 {
  ClutterColorizeEffect *colorize_effect = CLUTTER_COLORIZE_EFFECT (effect);
  cogl_pipeline_set_layer_texture (colorize_effect->pipeline, 0, texture);
  return cogl_object_ref (colorize_effect->pipeline);
 }
 static gboolean
-clutter_colorize_effect_pre_paint (ClutterEffect       *effect,
+clutter_colorize_effect_pre_paint (ClutterEffect *effect)
                                   ClutterPaintNode    *node,
                                   ClutterPaintContext *paint_context)
 {
  ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect);
  ClutterEffectClass *parent_class;
  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
    return FALSE;
  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
    {
      /* if we don't have support for GLSL shaders then we
@ -130,7 +128,44 @@ clutter_colorize_effect_pre_paint (ClutterEffect       *effect,
    }
  parent_class = CLUTTER_EFFECT_CLASS (clutter_colorize_effect_parent_class);
-  return parent_class->pre_paint (effect, node, paint_context);
+  if (parent_class->pre_paint (effect))
    {
      ClutterOffscreenEffect *offscreen_effect =
        CLUTTER_OFFSCREEN_EFFECT (effect);
      CoglHandle texture;
      texture = clutter_offscreen_effect_get_texture (offscreen_effect);
      self->tex_width = cogl_texture_get_width (texture);
      self->tex_height = cogl_texture_get_height (texture);
      cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
      return TRUE;
    }
  else
    return FALSE;
 }
 static void
 clutter_colorize_effect_paint_target (ClutterOffscreenEffect *effect)
 {
  ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect);
  ClutterActor *actor;
  guint8 paint_opacity;
  actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
  paint_opacity = clutter_actor_get_paint_opacity (actor);
  cogl_pipeline_set_color4ub (self->pipeline,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity,
                              paint_opacity);
  cogl_push_source (self->pipeline);
  cogl_rectangle (0, 0, self->tex_width, self->tex_height);
  cogl_pop_source ();
 }
 static void
@ -196,7 +231,7 @@ clutter_colorize_effect_class_init (ClutterColorizeEffectClass *klass)
  ClutterOffscreenEffectClass *offscreen_class;
  offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
-  offscreen_class->create_pipeline = clutter_colorize_effect_create_pipeline;
+  offscreen_class->paint_target = clutter_colorize_effect_paint_target;
  effect_class->pre_paint = clutter_colorize_effect_pre_paint;
@ -259,7 +294,9 @@ clutter_colorize_effect_init (ClutterColorizeEffect *self)
      cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
      cogl_object_unref (snippet);
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
                                            0, /* layer number */
                                            COGL_TEXTURE_TYPE_2D);
    }
  self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
--- a/clutter/clutter/clutter-colorize-effect.h
+++ b/clutter/clutter/clutter-colorize-effect.h
@ -49,16 +49,16 @@ G_BEGIN_DECLS
 typedef struct _ClutterColorizeEffect           ClutterColorizeEffect;
 typedef struct _ClutterColorizeEffectClass      ClutterColorizeEffectClass;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_colorize_effect_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_colorize_effect_new      (const ClutterColor *tint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
                                                 const ClutterColor    *tint);
-CLUTTER_EXPORT
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_get_tint (ClutterColorizeEffect *effect,
                                                 ClutterColor          *tint);
--- a/clutter/clutter/clutter-config.h.in
+++ b/clutter/clutter/clutter-config.h.in
@ -0,0 +1,16 @@
 #if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
 #error "Only <clutter/clutter.h> can be included directly."
 #endif
 #ifndef __CLUTTER_CONFIG_H__
 #define __CLUTTER_CONFIG_H__
 #include <glib.h>
 G_BEGIN_DECLS
@CLUTTER_CONFIG_DEFINES@
 G_END_DECLS
 #endif /* __CLUTTER_CONFIG_H__ */
--- a/clutter/clutter/clutter-constraint-private.h
+++ b/clutter/clutter/clutter-constraint-private.h
@ -30,6 +30,13 @@ gboolean clutter_constraint_update_allocation (ClutterConstraint *constraint,
                                               ClutterActor      *actor,
                                               ClutterActorBox   *allocation);
 void clutter_constraint_update_preferred_size (ClutterConstraint  *constraint,
                                               ClutterActor       *actor,
                                               ClutterOrientation  direction,
                                               float               for_size,
                                               float              *minimum_size,
                                               float              *natural_size);
 G_END_DECLS
 #endif /* __CLUTTER_CONSTRAINT_PRIVATE_H__ */
--- a/Show More
+++ b/Show More