clutter/actor: Revert transform order

When doing affine transforms on 2D and 3D spaces, operations are done relative to the origin. That means that, when applying rotations and scales, we must: * translate (-anchor_x, -anchor_y, -anchor_z) * apply the operation * translate (anchor_x, anchor_y, anchor_z) Since OpenGL has its matrices applied in the reverse order, the usual way to do it is, then: * translate (anchor_x, anchor_y, anchor_z) * apply the operation * translate (-anchor_x, anchor_y, anchor_z) However, graphene matrices do not follow the GL format, so matrix operations are done as the first example. Now that we are using graphene_matrix_t for every matrix operation, the transform order is wrong. Apply the transform operations in the opposite order.
cogl/matrix: Fix rotation
2019-03-20 15:17:16 +00:00 · 2019-03-20 15:17:15 +00:00 · 2019-03-20 15:17:15 +00:00 · 2019-03-20 15:17:15 +00:00 · 2019-03-20 15:17:15 +00:00 · 2019-03-20 15:17:15 +00:00
749 changed files with 12628 additions and 31387 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,20 +1,44 @@
 image: registry.gitlab.gnome.org/gnome/mutter/master:v1

 stages:
+ - review
 - build
 - test

+check-commit-log:
+  stage: review
+  script:
+    - ./.gitlab-ci/check-commit-log.sh
+  only:
+    - merge_requests
+
 build-mutter:
  stage: build
  script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror
    - ninja -C build
    - ninja -C build install
+  artifacts:
+    expire_in: 1 day
+    paths:
+      - build
+  only:
+    - merge_requests
+    - /^.*$/

 test-mutter:
  stage: test
+  dependencies:
+    - build-mutter
+  variables:
+    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
+    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
  script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
-    - ninja -C build
-    - glib-compile-schemas $PWD/build/data
-    - env XDG_RUNTIME_DIR=/tmp/ GSETTINGS_SCHEMA_DIR=$PWD/build/data dbus-run-session -- xvfb-run -s '+iglx -noreset' meson test -C build -t 10 --verbose --no-stdsplit --wrap catchsegv
+    - mkdir -m 700 $XDG_RUNTIME_DIR
+    - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
+    - >
+      dbus-run-session -- xvfb-run -s '+iglx -noreset'
+      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --wrap catchsegv
+  only:
+    - merge_requests
+    - /^.*$/
--- a/.gitlab-ci/Dockerfile
+++ b/.gitlab-ci/Dockerfile
@@ -5,16 +5,13 @@ RUN dnf -y update && dnf -y upgrade && \
    dnf builddep -y mutter && \

    # Until Fedora catches up with meson build-deps
-    dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
+    dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland graphene-devel && \

    # For running unit tests
    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \

    # Unpackaged versions
-    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
-
-    # Packages not yet in stable
-    dnf install -y https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-devel-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-libs-0.2.5-1.fc29.x86_64.rpm && \
+    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \

    dnf install -y intltool redhat-rpm-config make && \
    dnf clean all
--- a/.gitlab-ci/check-commit-log.sh
+++ b/.gitlab-ci/check-commit-log.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+if [ -z "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" ]; then
+  echo Cannot review non-merge request
+  exit 1
+fi
+
+git fetch $CI_MERGE_REQUEST_PROJECT_URL.git $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
+
+branch_point=$(git merge-base HEAD FETCH_HEAD)
+
+commits=$(git log --format='format:%H' $branch_point..$CI_COMMIT_SHA)
+
+if [ -z "$commits" ]; then
+  echo Commit range empty
+  exit 1
+fi
+
+function commit_message_has_url() {
+  commit=$1
+  commit_message=$(git show -s --format='format:%b' $commit)
+  echo "$commit_message" | grep -qe "\($CI_MERGE_REQUEST_PROJECT_URL/\(issues\|merge_requests\)/[0-9]\+\|https://bugzilla.gnome.org/show_bug.cgi?id=[0-9]\+\)"
+  return $?
+}
+
+for commit in $commits; do
+  if ! commit_message_has_url $commit; then
+    echo "Missing merge request or issue URL on commit $(echo $commit | cut -c -8)"
+    exit 1
+  fi
+done
--- a/81
+++ b/81
@@ -1,3 +1,84 @@
+3.32.0
+======
+* Fix deadlock when cancelling a theme sound [Andrea; !474]
+* Stop swizzling BGRA buffers (bye-bye inverted colors in screenshots
+  and animations) [Carlos; !486]
+
+Contributors:
+  Andrea Azzarone, Carlos Garnacho, Robert Mader
+
+3.31.92
+=======
+* Fix flicker of apps that use multiple SHM buffers [Jonas Å.; #199]
+* Don't disable page flips after temporary failues [Jonas Å.; #460]
+* Improve redraw performance [Carlos; !196]
+* Add cursor-mode support to window screencasting [Jonas Å.; !413]
+* Add back support for system-wide monitor configurations [Jonas Å.; !253]
+* Add fractional scaling support [Marco, Jonas Å.; !3]
+* Consider remapped keys when guessing keycode from keysym [Andrea; #443]
+* Stop turning on-screen-keyboard off on focus changes [Carlos; !432]
+* Fix crashes [Robert, Carlos, Jonas D., Florian; !447, #361, !426, #479]
+* Misc. bug fixes and cleanups [Benjamin, Adam, Olivier, Niels, Piotr; !457,
+  !452, !459, !380, !361, !461, !464, !471, !473, !463]
+
+Contributors:
+  Jonas Ådahl, Andrea Azzarone, Benjamin Berg, Piotr Drąg, Jonas Dreßler,
+  Olivier Fourdan, Carlos Garnacho, Niels De Graef, Adam Jackson, Robert Mader,
+  Florian Müllner, Marco Trevisan (Treviño)
+
+Translators:
+  Milo Casagrande [it], Tim Sabsch [de], Trần Ngọc Quân [vi],
+  Gwan-gyeong Mun [ko], Марко Костић [sr], Daniel Mustieles [es],
+  Rūdolfs Mazurs [lv], Nathan Follens [nl]
+
+3.31.91
+=======
+* Fix infinite loop in EDID matching [Marco; #459]
+* wayland: Don't resetin text-input state prematurely [Carlos; !410]
+* wayland: Don't maximize windows if minimum size is too big [Olivier; #463]
+* Fix crash when using "restore shortcuts" without focus window [Olivier; #464]
+* Add flag parameter to grab accelerator API [Andrea; !169]
+* Reuse old CRTC if possible to avoid flicker on hotplug [Pekka, Emilio; #373]
+* Misc. bug fixes and cleanups [Marco, Jonas, Niels, Adam, Olivier; !436,
+  !421, #462, !439, !440, !444, !321, !445, !456]
+
+Contributors:
+  Jonas Ådahl, Andrea Azzarone, Olivier Fourdan, Carlos Garnacho,
+  Niels De Graef, Adam Jackson, Emilio Pozuelo Monfort, Pekka Paalanen,
+  Marco Trevisan (Treviño)
+
+Translators:
+  Jiri Grönroos [fi], Charles Monzat [fr], Claude Paroz [fr], Fran Dieguez [gl],
+  Emin Tufan Çetin [tr], Aurimas Černius [lt], Anders Jonsson [sv],
+  Matej Urbančič [sl], Marek Cernocky [cs], Daniel Șerbănescu [ro],
+  Alan Mortensen [da], Baurzhan Muftakhidinov [kk], Yi-Jyun Pan [zh_TW],
+  Daniel Mustieles [es], Rafael Fontenelle [pt_BR]
+
+3.31.90
+=======
+* Fix support of extended characters in on-screen keyboard [Andrea; #109]
+* Improve selection of the primary GPU [Pekka, Emilio; !271]
+* Screen-cast cursor updates as PipeWire stream metadata [Jonas; !357]
+* Fix rendering glitches in magnifier [Daniel; gnome-shell#387]
+* Fix monitor recording on HiDPI [Jonas; !415]
+* Honour secondary GPU supported pixel formats [Pekka; !341]
+* Fall back to CPU copy path when using a software renderer [Emilio; !325]
+* Remove fallback app menu [Florian; gnome-shell#624]
+* wayland: Add support for viewporter protocol [Robert; !323]
+* Misc. bug fixes and cleanups [Florian, Carlos, Olivier, Marco, Robert,
+  Daniel, Pekka, Jonas, Ole, Georges; !391, #335, #442, !406, !395, #447,
+  !375, gnome-shell#349, #451, !416, #784199, !408, !181, !405]
+
+Contributors:
+  Jonas Ådahl, Andrea Azzarone, Ole Jørgen Brønner, Piotr Drąg, Olivier Fourdan,
+  Dariusz Gadomski, Carlos Garnacho, Antoine Jacoutot, Iain Lane, Robert Mader,
+  Emilio Pozuelo Monfort, Florian Müllner, Georges Basile Stavracas Neto,
+  Pekka Paalanen, Marco Trevisan (Treviño), Josh Triplett, Daniel van Vugt
+
+Translators:
+  Fabio Tomat [fur], Balázs Úr [hu], Daniel Mustieles [es], Kukuh Syafaat [id],
+  Jordi Mas [ca], Piotr Drąg [pl]
+
 3.31.4
 ======
 * keybindings: Limit corner move to current monitor [Jānis; #320]
--- a/README.md
+++ b/README.md
@@ -22,6 +22,20 @@ by  Gala, elementary OS's window manager. It can also be run standalone, using
 the  command "mutter", but just running plain mutter is only intended for
 debugging purposes.

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

 Mutter is distributed under the terms of the GNU General Public License,
--- a/clutter/clutter/cally/cally-actor.c
+++ b/clutter/clutter/cally/cally-actor.c
@@ -657,7 +657,7 @@ cally_actor_get_extents (AtkComponent *component,
  ClutterActor *actor      = NULL;
  gint          top_level_x, top_level_y;
  gfloat        f_width, f_height;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];
  ClutterActor  *stage = NULL;

  g_return_if_fail (CALLY_IS_ACTOR (component));
--- a/clutter/clutter/cally/cally-text.c
+++ b/clutter/clutter/cally/cally-text.c
@@ -1438,7 +1438,7 @@ static void cally_text_get_character_extents (AtkText *text,
  PangoLayout *layout;
  PangoRectangle extents;
  const gchar *text_value;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];

  actor = CALLY_GET_CLUTTER_ACTOR (text);
  if (actor == NULL) /* State is defunct */
@@ -2294,7 +2294,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;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];
  PangoLayout *layout;
  gint x_layout, y_layout;

--- a/clutter/clutter/clutter-actor-box-private.h
+++ b/clutter/clutter/clutter-actor-box-private.h
@@ -0,0 +1,12 @@
+#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
@@ -5,6 +5,7 @@
 #include "clutter-types.h"
 #include "clutter-interval.h"
 #include "clutter-private.h"
+#include "clutter-actor-box-private.h"

 /**
 * clutter_actor_box_new:
@@ -339,7 +340,7 @@ clutter_actor_box_contains (const ClutterActorBox *box,
 /**
 * clutter_actor_box_from_vertices:
 * @box: a #ClutterActorBox
- * @verts: (array fixed-size=4): array of four #ClutterVertex
+ * @verts: (array fixed-size=4): array of four #graphene_point3d_t
 *
 * Calculates the bounding box represented by the four vertices; for details
 * of the vertex array see clutter_actor_get_abs_allocation_vertices().
@@ -348,7 +349,7 @@ clutter_actor_box_contains (const ClutterActorBox *box,
 */
 void
 clutter_actor_box_from_vertices (ClutterActorBox     *box,
-                                 const ClutterVertex  verts[])
+                                 const graphene_point3d_t  verts[])
 {
  gfloat x_1, x_2, y_1, y_2;

@@ -542,6 +543,78 @@ clutter_actor_box_set_size (ClutterActorBox *box,
  box->y2 = box->y1 + height;
 }

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

    /* Use when is_fractional == FALSE */
-    ClutterVertex units;
+    graphene_point3d_t units;
  } v;
 };

@@ -161,7 +163,7 @@ struct _SizeRequest
 struct _ClutterLayoutInfo
 {
  /* fixed position coordinates */
-  ClutterPoint fixed_pos;
+  graphene_point_t fixed_pos;

  ClutterMargin margin;

@@ -171,8 +173,8 @@ struct _ClutterLayoutInfo
  guint x_expand : 1;
  guint y_expand : 1;

-  ClutterSize minimum;
-  ClutterSize natural;
+  graphene_size_t minimum;
+  graphene_size_t natural;
 };

 const ClutterLayoutInfo *       _clutter_actor_get_layout_info_or_defaults      (ClutterActor *self);
@@ -201,13 +203,13 @@ struct _ClutterTransformInfo
  AnchorCoord anchor;

  /* translation */
-  ClutterVertex translation;
+  graphene_point3d_t translation;

  /* z_position */
  gfloat z_position;

  /* transformation center */
-  ClutterPoint pivot;
+  graphene_point_t pivot;
  gfloat pivot_z;

  CoglMatrix transform;
@@ -283,9 +285,6 @@ void                            _clutter_actor_queue_redraw_full
                                                                                         const ClutterPaintVolume *volume,
                                                                                         ClutterEffect            *effect);

-ClutterPaintVolume *            _clutter_actor_get_queue_redraw_clip                    (ClutterActor       *self);
-void                            _clutter_actor_set_queue_redraw_clip                    (ClutterActor       *self,
-                                                                                         ClutterPaintVolume *clip_volume);
 void                            _clutter_actor_finish_queue_redraw                      (ClutterActor       *self,
                                                                                         ClutterPaintVolume *clip);

@@ -316,8 +315,11 @@ void                            _clutter_actor_detach_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_queue_update_resource_scale_recursive    (ClutterActor *actor);

 CoglFramebuffer *               _clutter_actor_get_active_framebuffer                   (ClutterActor *actor);
+gboolean                        _clutter_actor_get_real_resource_scale                  (ClutterActor *actor,
+                                                                                         float        *resource_scale);

 ClutterPaintNode *              clutter_actor_create_texture_paint_node                 (ClutterActor *self,
                                                                                         CoglTexture  *texture);
--- a/clutter/clutter/clutter-actor.c
+++ b/clutter/clutter/clutter-actor.c
--- a/clutter/clutter/clutter-actor.h
+++ b/clutter/clutter/clutter-actor.h
@@ -236,8 +236,9 @@ struct _ClutterActorClass
  void (* pick)                 (ClutterActor          *actor,
                                 const ClutterColor    *color);

-  void (* queue_redraw)         (ClutterActor          *actor,
-                                 ClutterActor          *leaf_that_queued);
+  gboolean (* queue_redraw)     (ClutterActor          *actor,
+                                 ClutterActor          *leaf_that_queued,
+                                 ClutterPaintVolume    *paint_volume);

  /* size negotiation */
  void (* get_preferred_width)  (ClutterActor           *self,
@@ -430,7 +431,7 @@ void                            clutter_actor_get_allocation_box
 CLUTTER_EXPORT
 void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
                                                                                 ClutterActor                *ancestor,
-                                                                                 ClutterVertex                verts[]);
+                                                                                 graphene_point3d_t          *verts);
 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
 CLUTTER_EXPORT
@@ -583,6 +584,11 @@ gboolean                        clutter_actor_is_in_clone_paint
 CLUTTER_EXPORT
 gboolean                        clutter_actor_get_paint_box                     (ClutterActor               *self,
                                                                                 ClutterActorBox            *box);
+
+CLUTTER_EXPORT
+gboolean                        clutter_actor_get_resource_scale                (ClutterActor *self,
+                                                                                 gfloat       *resource_scale);
+
 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_overlaps                      (ClutterActor               *self);

@@ -811,16 +817,16 @@ gboolean                        clutter_actor_transform_stage_point
                                                                                 gfloat                     *y_out);
 CLUTTER_EXPORT
 void                            clutter_actor_get_abs_allocation_vertices       (ClutterActor               *self,
-                                                                                 ClutterVertex               verts[]);
+                                                                                 graphene_point3d_t         *verts);
 CLUTTER_EXPORT
 void                            clutter_actor_apply_transform_to_point          (ClutterActor               *self,
-                                                                                 const ClutterVertex        *point,
-                                                                                 ClutterVertex              *vertex);
+                                                                                 const graphene_point3d_t   *point,
+                                                                                 graphene_point3d_t         *vertex);
 CLUTTER_EXPORT
 void                            clutter_actor_apply_relative_transform_to_point (ClutterActor               *self,
                                                                                 ClutterActor               *ancestor,
-                                                                                 const ClutterVertex        *point,
-                                                                                 ClutterVertex              *vertex);
+                                                                                 const graphene_point3d_t   *point,
+                                                                                 graphene_point3d_t         *vertex);

 /* Implicit animations */
 CLUTTER_EXPORT
--- a/clutter/clutter/clutter-animatable.c
+++ b/clutter/clutter/clutter-animatable.c
@@ -30,7 +30,7 @@
 * to control how a #ClutterAnimation will animate a property.
 *
 * Each #ClutterAnimatable should implement the
- * #ClutterAnimatableIface.interpolate_property() virtual function of the
+ * #ClutterAnimatableInterface.interpolate_property() virtual function of the
 * interface to compute the animation state between two values of an interval
 * depending on a progress factor, expressed as a floating point value.
 *
@@ -57,7 +57,6 @@
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"

-typedef ClutterAnimatableIface  ClutterAnimatableInterface;
 G_DEFINE_INTERFACE (ClutterAnimatable, clutter_animatable, G_TYPE_OBJECT);

 static void
@@ -101,7 +100,7 @@ clutter_animatable_animate_property (ClutterAnimatable *animatable,
                                     gdouble            progress,
                                     GValue            *value)
 {
-  ClutterAnimatableIface *iface;
+  ClutterAnimatableInterface *iface;
  gboolean res;

  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
@@ -155,7 +154,7 @@ GParamSpec *
 clutter_animatable_find_property (ClutterAnimatable *animatable,
                                  const gchar       *property_name)
 {
-  ClutterAnimatableIface *iface;
+  ClutterAnimatableInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), NULL);
  g_return_val_if_fail (property_name != NULL, NULL);
@@ -185,7 +184,7 @@ clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                      const gchar       *property_name,
                                      GValue            *value)
 {
-  ClutterAnimatableIface *iface;
+  ClutterAnimatableInterface *iface;

  g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
  g_return_if_fail (property_name != NULL);
@@ -214,7 +213,7 @@ clutter_animatable_set_final_state (ClutterAnimatable *animatable,
                                    const gchar       *property_name,
                                    const GValue      *value)
 {
-  ClutterAnimatableIface *iface;
+  ClutterAnimatableInterface *iface;

  g_return_if_fail (CLUTTER_IS_ANIMATABLE (animatable));
  g_return_if_fail (property_name != NULL);
@@ -260,7 +259,7 @@ clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                      gdouble            progress,
                                      GValue            *value)
 {
-  ClutterAnimatableIface *iface;
+  ClutterAnimatableInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
  g_return_val_if_fail (property_name != NULL, FALSE);
--- a/clutter/clutter/clutter-animatable.h
+++ b/clutter/clutter/clutter-animatable.h
@@ -33,24 +33,15 @@

 G_BEGIN_DECLS

-#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))
+#define CLUTTER_TYPE_ANIMATABLE (clutter_animatable_get_type ())

-typedef struct _ClutterAnimatableIface          ClutterAnimatableIface;
+CLUTTER_EXPORT
+G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
+                     CLUTTER, ANIMATABLE,
+                     GObject)

 /**
- * ClutterAnimatable:
- *
- * #ClutterAnimatable is an opaque structure whose members cannot be directly
- * accessed
- *
- * Since: 1.0
- */
-
-/**
- * ClutterAnimatableIface:
+ * ClutterAnimatableInterface:
 * @animate_property: virtual function for custom interpolation of a
 *   property. This virtual function is deprecated
 * @find_property: virtual function for retrieving the #GParamSpec of
@@ -67,7 +58,7 @@ typedef struct _ClutterAnimatableIface          ClutterAnimatableIface;
 *
 * Since: 1.0
 */
-struct _ClutterAnimatableIface
+struct _ClutterAnimatableInterface
 {
  /*< private >*/
  GTypeInterface parent_iface;
@@ -95,9 +86,6 @@ struct _ClutterAnimatableIface
                                     GValue            *value);
 };

-CLUTTER_EXPORT
-GType clutter_animatable_get_type (void) G_GNUC_CONST;
-
 CLUTTER_EXPORT
 GParamSpec *clutter_animatable_find_property     (ClutterAnimatable *animatable,
                                                  const gchar       *property_name);
--- a/clutter/clutter/clutter-autocleanups.h
+++ b/clutter/clutter/clutter-autocleanups.h
@@ -34,7 +34,6 @@ 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)
@@ -49,7 +48,6 @@ 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)
@@ -96,10 +94,6 @@ 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
@@ -24,6 +24,7 @@

 #include <clutter/clutter-backend.h>
 #include <clutter/clutter-device-manager.h>
+#include <clutter/clutter-keymap.h>
 #include <clutter/clutter-stage-window.h>

 #include "clutter-event-translator.h"
@@ -60,6 +61,8 @@ struct _ClutterBackend
  GList *event_translators;

  ClutterInputMethod *input_method;
+
+  ClutterKeymap *keymap;
 };

 struct _ClutterBackendClass
@@ -104,6 +107,8 @@ struct _ClutterBackendClass

  void                  (* bell_notify)          (ClutterBackend   *backend);

+  ClutterKeymap *       (* get_keymap)           (ClutterBackend   *backend);
+
  /* signals */
  void (* resolution_changed) (ClutterBackend *backend);
  void (* font_changed)       (ClutterBackend *backend);
@@ -155,8 +160,6 @@ void                    _clutter_backend_reset_cogl_framebuffer         (Clutter

 void                    clutter_set_allowed_drivers                     (const char             *drivers);

-void                    clutter_try_set_windowing_backend               (const char             *drivers);
-
 G_END_DECLS

 #endif /* __CLUTTER_BACKEND_PRIVATE_H__ */
--- a/clutter/clutter/clutter-backend.c
+++ b/clutter/clutter/clutter-backend.c
@@ -53,9 +53,6 @@
 #include "clutter-stage-window.h"
 #include "clutter-device-manager-private.h"

-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "deprecated/clutter-backend.h"
-
 #ifdef CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT
 #include "wayland/clutter-wayland-compositor.h"
 #endif
@@ -577,6 +574,18 @@ clutter_backend_real_get_device_manager (ClutterBackend *backend)
  return backend->device_manager;
 }

+static ClutterKeymap *
+clutter_backend_real_get_keymap (ClutterBackend *backend)
+{
+  if (G_UNLIKELY (backend->keymap == NULL))
+    {
+      g_critical ("No keymap available, expect broken keyboard input");
+      return NULL;
+    }
+
+  return backend->keymap;
+}
+
 static gboolean
 clutter_backend_real_translate_event (ClutterBackend *backend,
                                      gpointer        native,
@@ -675,6 +684,7 @@ clutter_backend_class_init (ClutterBackendClass *klass)
  klass->translate_event = clutter_backend_real_translate_event;
  klass->create_context = clutter_backend_real_create_context;
  klass->get_features = clutter_backend_real_get_features;
+  klass->get_keymap = clutter_backend_real_get_keymap;
 }

 static void
@@ -890,129 +900,6 @@ 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
@@ -1118,61 +1005,6 @@ 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)
 {
@@ -1262,61 +1094,6 @@ clutter_wayland_set_compositor_display (void *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)
 {
@@ -1399,3 +1176,17 @@ clutter_backend_set_input_method (ClutterBackend     *backend,
 {
  g_set_object (&backend->input_method, method);
 }
+
+/**
+ * clutter_backend_get_keymap:
+ * @backend: the #ClutterBackend
+ *
+ * Gets the keymap used by Clutter
+ *
+ * Returns: (transfer none): the keymap
+ **/
+ClutterKeymap *
+clutter_backend_get_keymap (ClutterBackend *backend)
+{
+  return CLUTTER_BACKEND_GET_CLASS (backend)->get_keymap (backend);
+}
--- a/clutter/clutter/clutter-backend.h
+++ b/clutter/clutter/clutter-backend.h
@@ -34,6 +34,7 @@
 #include <cogl/cogl.h>

 #include <clutter/clutter-config.h>
+#include <clutter/clutter-keymap.h>
 #include <clutter/clutter-types.h>

 G_BEGIN_DECLS
@@ -59,9 +60,6 @@ GType clutter_backend_get_type (void) G_GNUC_CONST;
 CLUTTER_EXPORT
 ClutterBackend *                clutter_get_default_backend             (void);

-CLUTTER_EXPORT
-void                            clutter_set_windowing_backend           (const char *backend_type);
-
 CLUTTER_EXPORT
 gdouble                         clutter_backend_get_resolution          (ClutterBackend             *backend);

@@ -83,6 +81,9 @@ ClutterInputMethod *            clutter_backend_get_input_method        (Clutter
 CLUTTER_EXPORT
 void                            clutter_backend_set_input_method        (ClutterBackend             *backend,
                                                                         ClutterInputMethod         *method);
+CLUTTER_EXPORT
+ClutterKeymap *                 clutter_backend_get_keymap              (ClutterBackend             *backend);
+
 G_END_DECLS

 #endif /* __CLUTTER_BACKEND_H__ */
--- a/clutter/clutter/clutter-base-types.c
+++ b/clutter/clutter/clutter-base-types.c
--- 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 ();
+ClutterBezier *_clutter_bezier_new (void);

 void           _clutter_bezier_free (ClutterBezier * b);

--- a/clutter/clutter/clutter-bind-constraint.c
+++ b/clutter/clutter/clutter-bind-constraint.c
@@ -152,7 +152,9 @@ clutter_bind_constraint_update_allocation (ClutterConstraint *constraint,
  ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (constraint);
  gfloat source_width, source_height;
  gfloat actor_width, actor_height;
-  ClutterVertex source_position = { 0., };
+  graphene_point3d_t source_position;
+
+  source_position = GRAPHENE_POINT3D_INIT (0.f, 0.f, 0.f);

  if (bind->source == NULL)
    return;
--- a/clutter/clutter/clutter-blur-effect.c
+++ b/clutter/clutter/clutter-blur-effect.c
@@ -182,7 +182,7 @@ clutter_blur_effect_get_paint_volume (ClutterEffect      *effect,
                                      ClutterPaintVolume *volume)
 {
  gfloat cur_width, cur_height;
-  ClutterVertex origin;
+  graphene_point3d_t origin;

  clutter_paint_volume_get_origin (volume, &origin);
  cur_width = clutter_paint_volume_get_width (volume);
--- a/clutter/clutter/clutter-box-layout.c
+++ b/clutter/clutter/clutter-box-layout.c
@@ -150,9 +150,9 @@ typedef struct _RequestedSize
  gfloat natural_size;
 } RequestedSize;

-static gint distribute_natural_allocation (gint                  extra_space,
-					   guint                 n_requested_sizes,
-					   RequestedSize        *sizes);
+static float distribute_natural_allocation (float          extra_space,
+                                            unsigned int   n_requested_sizes,
+                                            RequestedSize *sizes);
 static void count_expand_children         (ClutterLayoutManager *layout,
 					   ClutterContainer     *container,
 					   gint                 *visible_children,
@@ -624,7 +624,19 @@ get_preferred_size_for_opposite_orientation (ClutterBoxLayout   *self,
  else
    {
      /* Bring children up to size first */
-      size = distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
+      if (isnormal (size) || size == 0)
+        {
+          size = distribute_natural_allocation (MAX (0, size),
+                                                nvis_children,
+                                                sizes);
+        }
+      else
+        {
+          g_critical ("Actor %s (%p) received the invalid "
+                      "value %f as minimum/natural size\n",
+                       G_OBJECT_TYPE_NAME (container), container, size);
+          size = 0;
+        }

      /* Calculate space which hasn't distributed yet,
       * and is available for expanding children.
@@ -879,17 +891,18 @@ compare_gap (gconstpointer p1,
 *
 * Pulled from gtksizerequest.c from Gtk+
 */
-static gint
-distribute_natural_allocation (gint           extra_space,
-                               guint          n_requested_sizes,
+static float
+distribute_natural_allocation (float          extra_space,
+                               unsigned int   n_requested_sizes,
                               RequestedSize *sizes)
 {
-  guint *spreading;
-  gint   i;
+  unsigned int *spreading;
+  int i;

+  g_return_val_if_fail (isnormal (extra_space) || extra_space == 0, 0);
  g_return_val_if_fail (extra_space >= 0, 0);

-  spreading = g_newa (guint, n_requested_sizes);
+  spreading = g_newa (unsigned int, n_requested_sizes);

  for (i = 0; i < n_requested_sizes; i++)
    spreading[i] = i;
@@ -913,7 +926,7 @@ distribute_natural_allocation (gint           extra_space,

  /* Sort descending by gap and position. */
  g_qsort_with_data (spreading,
-                     n_requested_sizes, sizeof (guint),
+                     n_requested_sizes, sizeof (unsigned int),
                     compare_gap, sizes);

  /* Distribute available space.
@@ -925,11 +938,11 @@ distribute_natural_allocation (gint           extra_space,
       * Sort order and reducing remaining space by assigned space
       * ensures that space is distributed equally.
       */
-      gint glue = (extra_space + i) / (i + 1);
-      gint gap = sizes[(spreading[i])].natural_size
-               - sizes[(spreading[i])].minimum_size;
+      int glue = (extra_space + i) / (i + 1);
+      int gap = sizes[(spreading[i])].natural_size
+              - sizes[(spreading[i])].minimum_size;

-      gint extra = MIN (glue, gap);
+      int extra = MIN (glue, gap);

      sizes[spreading[i]].minimum_size += extra;

@@ -1056,7 +1069,9 @@ clutter_box_layout_allocate (ClutterLayoutManager   *layout,
  else
    {
      /* Bring children up to size first */
-      size = distribute_natural_allocation (MAX (0, size), nvis_children, sizes);
+      size = (gint) distribute_natural_allocation (MAX (0, (float) size),
+                                                   nvis_children,
+                                                   sizes);

      /* Calculate space which hasn't distributed yet,
       * and is available for expanding children.
--- a/clutter/clutter/clutter-canvas.c
+++ b/clutter/clutter/clutter-canvas.c
@@ -44,6 +44,7 @@

 #include "clutter-build-config.h"

+#include <math.h>
 #include <cogl/cogl.h>
 #include <cairo-gobject.h>

@@ -69,6 +70,7 @@ struct _ClutterCanvasPrivate

  int width;
  int height;
+  float scale_factor;

  CoglTexture *texture;
  gboolean dirty;
@@ -82,6 +84,7 @@ enum

  PROP_WIDTH,
  PROP_HEIGHT,
+  PROP_SCALE_FACTOR,

  LAST_PROP
 };
@@ -97,7 +100,7 @@ enum

 static guint canvas_signals[LAST_SIGNAL] = { 0, };

-static void clutter_content_iface_init (ClutterContentIface *iface);
+static void clutter_content_iface_init (ClutterContentInterface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterCanvas, clutter_canvas, G_TYPE_OBJECT,
                         G_ADD_PRIVATE (ClutterCanvas)
@@ -178,6 +181,19 @@ 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;
@@ -202,6 +218,10 @@ 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;
@@ -245,6 +265,19 @@ 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:
@@ -291,6 +324,7 @@ clutter_canvas_init (ClutterCanvas *self)

  self->priv->width = -1;
  self->priv->height = -1;
+  self->priv->scale_factor = 1.0f;
 }

 static void
@@ -340,8 +374,8 @@ clutter_canvas_emit_draw (ClutterCanvas *self)

  priv->dirty = TRUE;

-  real_width = priv->width;
-  real_height = priv->height;
+  real_width = ceilf (priv->width * priv->scale_factor);
+  real_height = ceilf (priv->height * priv->scale_factor);

  CLUTTER_NOTE (MISC, "Creating Cairo surface with size %d x %d",
                priv->width, priv->height);
@@ -387,6 +421,10 @@ 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,
@@ -448,16 +486,16 @@ clutter_canvas_get_preferred_size (ClutterContent *content,
    return FALSE;

  if (width != NULL)
-    *width = priv->width;
+    *width = ceilf (priv->width * priv->scale_factor);

  if (height != NULL)
-    *height = priv->height;
+    *height = ceilf (priv->height * priv->scale_factor);

  return TRUE;
 }

 static void
-clutter_content_iface_init (ClutterContentIface *iface)
+clutter_content_iface_init (ClutterContentInterface *iface)
 {
  iface->invalidate = clutter_canvas_invalidate;
  iface->paint_content = clutter_canvas_paint_content;
@@ -560,3 +598,48 @@ 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
@@ -97,9 +97,9 @@ gboolean                clutter_canvas_set_size                 (ClutterCanvas *

 CLUTTER_EXPORT
 void                    clutter_canvas_set_scale_factor         (ClutterCanvas *canvas,
-                                                                 int            scale);
+                                                                 float          scale);
 CLUTTER_EXPORT
-int                     clutter_canvas_get_scale_factor         (ClutterCanvas *canvas);
+float                   clutter_canvas_get_scale_factor         (ClutterCanvas *canvas);

 G_END_DECLS

--- a/clutter/clutter/clutter-content.c
+++ b/clutter/clutter/clutter-content.c
@@ -38,14 +38,13 @@

 #include "clutter-build-config.h"

+#include "clutter-actor-private.h"
 #include "clutter-content-private.h"

 #include "clutter-debug.h"
 #include "clutter-marshal.h"
 #include "clutter-private.h"

-typedef struct _ClutterContentIface     ClutterContentInterface;
-
 enum
 {
  ATTACHED,
@@ -91,6 +90,11 @@ clutter_content_real_invalidate (ClutterContent *content)
 {
 }

+static void
+clutter_content_real_invalidate_size (ClutterContent *content)
+{
+}
+
 static void
 clutter_content_real_paint_content (ClutterContent   *content,
                                    ClutterActor     *actor,
@@ -108,6 +112,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
  iface->attached = clutter_content_real_attached;
  iface->detached = clutter_content_real_detached;
  iface->invalidate = clutter_content_real_invalidate;
+  iface->invalidate_size = clutter_content_real_invalidate_size;

  /**
   * ClutterContent::attached:
@@ -123,7 +128,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
    g_signal_new (I_("attached"),
                  G_TYPE_FROM_INTERFACE (iface),
                  G_SIGNAL_RUN_FIRST,
-                  G_STRUCT_OFFSET (ClutterContentIface, attached),
+                  G_STRUCT_OFFSET (ClutterContentInterface, attached),
                  NULL, NULL,
                  _clutter_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
@@ -143,7 +148,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
    g_signal_new (I_("detached"),
                  G_TYPE_FROM_INTERFACE (iface),
                  G_SIGNAL_RUN_FIRST,
-                  G_STRUCT_OFFSET (ClutterContentIface, detached),
+                  G_STRUCT_OFFSET (ClutterContentInterface, detached),
                  NULL, NULL,
                  _clutter_marshal_VOID__OBJECT,
                  G_TYPE_NONE, 1,
@@ -188,6 +193,45 @@ clutter_content_invalidate (ClutterContent *content)
    }
 }

+/**
+ * clutter_content_invalidate_size:
+ * @content: a #ClutterContent
+ *
+ * Signals that @content's size changed. Attached actors with request mode
+ * set to %CLUTTER_REQUEST_CONTENT_SIZE will have a relayout queued.
+ *
+ * Attached actors with other request modes are not redrawn. To redraw them
+ * too, use clutter_content_invalidate().
+ */
+void
+clutter_content_invalidate_size (ClutterContent *content)
+{
+  ClutterActor *actor;
+  GHashTable *actors;
+  GHashTableIter iter;
+
+  g_return_if_fail (CLUTTER_IS_CONTENT (content));
+
+  CLUTTER_CONTENT_GET_IFACE (content)->invalidate_size (content);
+
+  actors = g_object_get_qdata (G_OBJECT (content), quark_content_actors);
+  if (actors == NULL)
+    return;
+
+  g_hash_table_iter_init (&iter, actors);
+  while (g_hash_table_iter_next (&iter, (gpointer *) &actor, NULL))
+    {
+      ClutterRequestMode request_mode;
+
+      g_assert (actor != NULL);
+
+      request_mode = clutter_actor_get_request_mode (actor);
+
+      if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
+        _clutter_actor_queue_only_relayout (actor);
+    }
+}
+
 /*< private >
 * _clutter_content_attached:
 * @content: a #ClutterContent
@@ -199,7 +243,7 @@ clutter_content_invalidate (ClutterContent *content)
 * is associated to a #ClutterContent, to set up a backpointer from
 * the @content to the @actor.
 *
- * This function will invoke the #ClutterContentIface.attached() virtual
+ * This function will invoke the #ClutterContentInterface.attached() virtual
 * function.
 */
 void
@@ -233,7 +277,7 @@ _clutter_content_attached (ClutterContent *content,
 * This function should be used internally every time a #ClutterActor
 * removes the association with a #ClutterContent.
 *
- * This function will invoke the #ClutterContentIface.detached() virtual
+ * This function will invoke the #ClutterContentInterface.detached() virtual
 * function.
 */
 void
@@ -262,7 +306,7 @@ _clutter_content_detached (ClutterContent *content,
 *
 * Creates the render tree for the @content and @actor.
 *
- * This function will invoke the #ClutterContentIface.paint_content()
+ * This function will invoke the #ClutterContentInterface.paint_content()
 * virtual function.
 */
 void
--- a/clutter/clutter/clutter-content.h
+++ b/clutter/clutter/clutter-content.h
@@ -33,24 +33,13 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_CONTENT            (clutter_content_get_type ())
-#define CLUTTER_CONTENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CONTENT, ClutterContent))
-#define CLUTTER_IS_CONTENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CONTENT))
-#define CLUTTER_CONTENT_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_CONTENT, ClutterContentIface))
+#define CLUTTER_TYPE_CONTENT (clutter_content_get_type ())

-typedef struct _ClutterContentIface     ClutterContentIface;
+CLUTTER_EXPORT
+G_DECLARE_INTERFACE (ClutterContent, clutter_content, CLUTTER, CONTENT, GObject)

 /**
- * ClutterContent:
- *
- * The #ClutterContent structure is an opaque type
- * whose members cannot be acccessed directly.
- *
- * Since: 1.10
- */
-
-/**
- * ClutterContentIface:
+ * ClutterContentInterface:
 * @get_preferred_size: virtual function; should be overridden by subclasses
 *   of #ClutterContent that have a natural size
 * @paint_content: virtual function; called each time the content needs to
@@ -62,12 +51,12 @@ typedef struct _ClutterContentIface     ClutterContentIface;
 * @invalidate: virtual function; called each time a #ClutterContent state
 *   is changed.
 *
- * The #ClutterContentIface structure contains only
+ * The #ClutterContentInterface structure contains only
 * private data.
 *
 * Since: 1.10
 */
-struct _ClutterContentIface
+struct _ClutterContentInterface
 {
  /*< private >*/
  GTypeInterface g_iface;
@@ -86,10 +75,9 @@ struct _ClutterContentIface
                                         ClutterActor     *actor);

  void          (* invalidate)          (ClutterContent   *content);
-};

-CLUTTER_EXPORT
-GType clutter_content_get_type (void) G_GNUC_CONST;
+  void          (* invalidate_size)     (ClutterContent   *content);
+};

 CLUTTER_EXPORT
 gboolean        clutter_content_get_preferred_size      (ClutterContent *content,
@@ -98,6 +86,9 @@ gboolean        clutter_content_get_preferred_size      (ClutterContent *content
 CLUTTER_EXPORT
 void            clutter_content_invalidate              (ClutterContent *content);

+CLUTTER_EXPORT
+void            clutter_content_invalidate_size         (ClutterContent *content);
+
 G_END_DECLS

 #endif /* __CLUTTER_CONTENT_H__ */
--- a/clutter/clutter/clutter-debug.h
+++ b/clutter/clutter/clutter-debug.h
@@ -6,7 +6,8 @@

 G_BEGIN_DECLS

-typedef enum {
+typedef enum
+{
  CLUTTER_DEBUG_MISC                = 1 << 0,
  CLUTTER_DEBUG_ACTOR               = 1 << 1,
  CLUTTER_DEBUG_TEXTURE             = 1 << 2,
@@ -26,12 +27,14 @@ typedef enum {
  CLUTTER_DEBUG_OOB_TRANSFORMS      = 1 << 16
 } ClutterDebugFlag;

-typedef enum {
+typedef enum
+{
  CLUTTER_DEBUG_NOP_PICKING         = 1 << 0,
  CLUTTER_DEBUG_DUMP_PICK_BUFFERS   = 1 << 1
 } ClutterPickDebugFlag;

-typedef enum {
+typedef enum
+{
  CLUTTER_DEBUG_DISABLE_SWAP_EVENTS     = 1 << 0,
  CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS = 1 << 1,
  CLUTTER_DEBUG_REDRAWS                 = 1 << 2,
@@ -80,9 +83,9 @@ extern guint clutter_pick_debug_flags;
 extern guint clutter_paint_debug_flags;

 void    _clutter_debug_messagev         (const char *format,
-                                         va_list     var_args);
+                                         va_list     var_args) G_GNUC_PRINTF (1, 0);
 void    _clutter_debug_message          (const char *format,
-                                         ...);
+                                         ...) G_GNUC_PRINTF (1, 2);

 G_END_DECLS

--- a/clutter/clutter/clutter-deform-effect.c
+++ b/clutter/clutter/clutter-deform-effect.c
@@ -177,7 +177,7 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)

  if (priv->is_dirty)
    {
-      ClutterRect rect;
+      graphene_rect_t rect;
      gboolean mapped_buffer;
      CoglVertexP3T2C4 *verts;
      ClutterActor *actor;
@@ -193,8 +193,8 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
       */
      if (clutter_offscreen_effect_get_target_rect (effect, &rect))
        {
-          width = clutter_rect_get_width (&rect);
-          height = clutter_rect_get_height (&rect);
+          width = graphene_rect_get_width (&rect);
+          height = graphene_rect_get_height (&rect);
        }
      else
        clutter_actor_get_size (actor, &width, &height);
--- a/clutter/clutter/clutter-deprecated.h
+++ b/clutter/clutter/clutter-deprecated.h
@@ -7,37 +7,24 @@
 #include "deprecated/clutter-alpha.h"
 #include "deprecated/clutter-animatable.h"
 #include "deprecated/clutter-animation.h"
-#include "deprecated/clutter-animator.h"
-#include "deprecated/clutter-backend.h"
 #include "deprecated/clutter-behaviour.h"
 #include "deprecated/clutter-behaviour-depth.h"
-#include "deprecated/clutter-behaviour-ellipse.h"
 #include "deprecated/clutter-behaviour-opacity.h"
-#include "deprecated/clutter-behaviour-path.h"
-#include "deprecated/clutter-behaviour-rotate.h"
 #include "deprecated/clutter-behaviour-scale.h"
 #include "deprecated/clutter-bin-layout.h"
 #include "deprecated/clutter-box.h"
 #include "deprecated/clutter-cairo-texture.h"
 #include "deprecated/clutter-container.h"
-#include "deprecated/clutter-frame-source.h"
 #include "deprecated/clutter-group.h"
-#include "deprecated/clutter-input-device.h"
 #include "deprecated/clutter-keysyms.h"
-#include "deprecated/clutter-list-model.h"
 #include "deprecated/clutter-main.h"
-#include "deprecated/clutter-model.h"
 #include "deprecated/clutter-rectangle.h"
-#include "deprecated/clutter-score.h"
-#include "deprecated/clutter-shader.h"
 #include "deprecated/clutter-stage-manager.h"
 #include "deprecated/clutter-stage.h"
 #include "deprecated/clutter-state.h"
 #include "deprecated/clutter-table-layout.h"
 #include "deprecated/clutter-texture.h"
 #include "deprecated/clutter-timeline.h"
-#include "deprecated/clutter-timeout-pool.h"
-#include "deprecated/clutter-util.h"

 #undef __CLUTTER_DEPRECATED_H_INSIDE__

--- a/clutter/clutter/clutter-drag-action.c
+++ b/clutter/clutter/clutter-drag-action.c
@@ -81,7 +81,7 @@ struct _ClutterDragActionPrivate
  gint y_drag_threshold;
  ClutterActor *drag_handle;
  ClutterDragAxis drag_axis;
-  ClutterRect drag_area;
+  graphene_rect_t drag_area;

  ClutterInputDevice *device;
  ClutterEventSequence *sequence;
@@ -542,7 +542,7 @@ clutter_drag_action_real_drag_motion (ClutterDragAction *action,

  if (action->priv->drag_area_set)
    {
-      ClutterRect *drag_area = &action->priv->drag_area;
+      graphene_rect_t *drag_area = &action->priv->drag_area;

      x = CLAMP (x, drag_area->origin.x, drag_area->origin.x + drag_area->size.width);
      y = CLAMP (y, drag_area->origin.y, drag_area->origin.y + drag_area->size.height);
@@ -811,7 +811,7 @@ clutter_drag_action_class_init (ClutterDragActionClass *klass)
    g_param_spec_boxed ("drag-area",
 			P_("Drag Area"),
 			P_("Constrains the dragging to a rectangle"),
-			CLUTTER_TYPE_RECT,
+			GRAPHENE_TYPE_RECT,
 			CLUTTER_PARAM_READWRITE);

  /**
@@ -1267,10 +1267,10 @@ clutter_drag_action_get_motion_coords (ClutterDragAction *action,
 /**
 * clutter_drag_action_get_drag_area:
 * @action: a #ClutterDragAction
- * @drag_area: (out caller-allocates): a #ClutterRect to be filled
+ * @drag_area: (out caller-allocates): a #graphene_rect_t to be filled
 *
 * Retrieves the "drag area" associated with @action, that
- * is a #ClutterRect that constrains the actor movements,
+ * is a #graphene_rect_t that constrains the actor movements,
 * in parents coordinates.
 *
 * Returns: %TRUE if the actor is actually constrained (and thus
@@ -1278,7 +1278,7 @@ clutter_drag_action_get_motion_coords (ClutterDragAction *action,
 */
 gboolean
 clutter_drag_action_get_drag_area (ClutterDragAction *action,
-				   ClutterRect       *drag_area)
+                                   graphene_rect_t   *drag_area)
 {
  g_return_val_if_fail (CLUTTER_IS_DRAG_ACTION (action), FALSE);

@@ -1298,8 +1298,8 @@ clutter_drag_action_get_drag_area (ClutterDragAction *action,
 * If @drag_area is %NULL, the actor is not constrained.
 */
 void
-clutter_drag_action_set_drag_area (ClutterDragAction *action,
-				   const ClutterRect *drag_area)
+clutter_drag_action_set_drag_area (ClutterDragAction     *action,
+                                   const graphene_rect_t *drag_area)
 {
  ClutterDragActionPrivate *priv;

--- a/clutter/clutter/clutter-drag-action.h
+++ b/clutter/clutter/clutter-drag-action.h
@@ -141,11 +141,11 @@ void            clutter_drag_action_get_motion_coords  (ClutterDragAction *actio

 CLUTTER_EXPORT
 gboolean        clutter_drag_action_get_drag_area      (ClutterDragAction *action,
-                                                        ClutterRect       *drag_area);
+                                                        graphene_rect_t   *drag_area);

 CLUTTER_EXPORT
-void            clutter_drag_action_set_drag_area      (ClutterDragAction *action,
-                                                        const ClutterRect *drag_area);
+void            clutter_drag_action_set_drag_area      (ClutterDragAction     *action,
+                                                        const graphene_rect_t *drag_area);

 G_END_DECLS

--- a/clutter/clutter/clutter-enums.h
+++ b/clutter/clutter/clutter-enums.h
@@ -51,7 +51,8 @@ G_BEGIN_DECLS
 *
 * Deprecated: 1.22: Use the normalized #ClutterActor pivot point instead
 */
-typedef enum { /*< prefix=CLUTTER_GRAVITY >*/
+typedef enum /*< prefix=CLUTTER_GRAVITY >*/
+{
  CLUTTER_GRAVITY_NONE       = 0,
  CLUTTER_GRAVITY_NORTH,
  CLUTTER_GRAVITY_NORTH_EAST,
@@ -74,7 +75,8 @@ typedef enum { /*< prefix=CLUTTER_GRAVITY >*/
 *
 * Since: 0.4
 */
-typedef enum { /*< prefix=CLUTTER >*/
+typedef enum /*< prefix=CLUTTER >*/
+{
  CLUTTER_X_AXIS,
  CLUTTER_Y_AXIS,
  CLUTTER_Z_AXIS
@@ -91,7 +93,8 @@ typedef enum { /*< prefix=CLUTTER >*/
 *
 * Deprecated: 1.22
 */
-typedef enum { /*< prefix=CLUTTER_ROTATE >*/
+typedef enum /*< prefix=CLUTTER_ROTATE >*/
+{
  CLUTTER_ROTATE_CW,
  CLUTTER_ROTATE_CCW
 } ClutterRotateDirection;
@@ -107,7 +110,8 @@ typedef enum { /*< prefix=CLUTTER_ROTATE >*/
 *
 * Since: 0.8
 */
-typedef enum { /*< prefix=CLUTTER_REQUEST >*/
+typedef enum /*< prefix=CLUTTER_REQUEST >*/
+{
  CLUTTER_REQUEST_HEIGHT_FOR_WIDTH,
  CLUTTER_REQUEST_WIDTH_FOR_HEIGHT,
  CLUTTER_REQUEST_CONTENT_SIZE
@@ -200,7 +204,8 @@ typedef enum { /*< prefix=CLUTTER_REQUEST >*/
 *
 * Since: 1.0
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_CUSTOM_MODE = 0,

  /* linear */
@@ -284,7 +289,8 @@ typedef enum {
 *
 * Deprecated: 1.22: Use #cairo_font_options_t instead
 */
-typedef enum { /*< prefix=CLUTTER_FONT >*/
+typedef enum /*< prefix=CLUTTER_FONT >*/
+{
  CLUTTER_FONT_MIPMAPPING = (1 << 0),
  CLUTTER_FONT_HINTING    = (1 << 1)
 } ClutterFontFlags;
@@ -300,7 +306,8 @@ typedef enum { /*< prefix=CLUTTER_FONT >*/
 *
 * Since: 1.2
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_TEXT_DIRECTION_DEFAULT,
  CLUTTER_TEXT_DIRECTION_LTR,
  CLUTTER_TEXT_DIRECTION_RTL
@@ -315,7 +322,8 @@ typedef enum {
 *
 * Since: 1.4
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_VERTEX_SHADER,
  CLUTTER_FRAGMENT_SHADER
 } ClutterShaderType;
@@ -350,7 +358,8 @@ typedef enum {
 *
 * Since: 0.4
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SHIFT_MASK    = 1 << 0,
  CLUTTER_LOCK_MASK     = 1 << 1,
  CLUTTER_CONTROL_MASK  = 1 << 2,
@@ -416,7 +425,8 @@ typedef enum {
 * Keyboard accessibility features applied to a ClutterInputDevice keyboard.
 *
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_A11Y_KEYBOARD_ENABLED          = 1 << 0,
  CLUTTER_A11Y_TIMEOUT_ENABLED           = 1 << 1,
  CLUTTER_A11Y_MOUSE_KEYS_ENABLED        = 1 << 2,
@@ -448,7 +458,8 @@ typedef enum {
 *
 * Flags used to signal the state of an actor.
 */
-typedef enum { /*< prefix=CLUTTER_ACTOR >*/
+typedef enum /*< prefix=CLUTTER_ACTOR >*/
+{
  CLUTTER_ACTOR_MAPPED    = 1 << 1,
  CLUTTER_ACTOR_REALIZED  = 1 << 2,
  CLUTTER_ACTOR_REACTIVE  = 1 << 3,
@@ -468,7 +479,8 @@ typedef enum { /*< prefix=CLUTTER_ACTOR >*/
 *
 * Since: 1.8
 */
-typedef enum { /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
+typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
+{
  CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY = 1<<0,
  CLUTTER_OFFSCREEN_REDIRECT_ALWAYS = 1<<1
 } ClutterOffscreenRedirect;
@@ -492,7 +504,8 @@ typedef enum { /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
 *
 * Since: 1.0
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_ALLOCATION_NONE         = 0,
  CLUTTER_ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
  CLUTTER_DELEGATE_LAYOUT         = 1 << 2
@@ -509,7 +522,8 @@ typedef enum {
 *
 * Since: 1.4
 */
-typedef enum { /*< prefix=CLUTTER_ALIGN >*/
+typedef enum /*< prefix=CLUTTER_ALIGN >*/
+{
  CLUTTER_ALIGN_X_AXIS,
  CLUTTER_ALIGN_Y_AXIS,
  CLUTTER_ALIGN_BOTH
@@ -526,7 +540,8 @@ typedef enum { /*< prefix=CLUTTER_ALIGN >*/
 *
 * Deprecated: 1.22
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_INTERPOLATION_LINEAR,
  CLUTTER_INTERPOLATION_CUBIC
 } ClutterInterpolation;
@@ -551,7 +566,8 @@ typedef enum {
 * Deprecated: 1.12: Use #ClutterActorAlign and the #ClutterActor
 *   API instead
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_BIN_ALIGNMENT_FIXED,
  CLUTTER_BIN_ALIGNMENT_FILL,
  CLUTTER_BIN_ALIGNMENT_START,
@@ -576,7 +592,8 @@ typedef enum {
 *
 * Since: 1.4
 */
-typedef enum { /*< prefix=CLUTTER_BIND >*/
+typedef enum /*< prefix=CLUTTER_BIND >*/
+{
  CLUTTER_BIND_X,
  CLUTTER_BIND_Y,
  CLUTTER_BIND_WIDTH,
@@ -595,7 +612,8 @@ typedef enum { /*< prefix=CLUTTER_BIND >*/
 *
 * Flags passed to the ‘paint’ or ‘pick’ method of #ClutterEffect.
 */
-typedef enum { /*< prefix=CLUTTER_EFFECT_PAINT >*/
+typedef enum /*< prefix=CLUTTER_EFFECT_PAINT >*/
+{
  CLUTTER_EFFECT_PAINT_ACTOR_DIRTY = (1 << 0)
 } ClutterEffectPaintFlags;

@@ -611,7 +629,8 @@ typedef enum { /*< prefix=CLUTTER_EFFECT_PAINT >*/
 *
 * Since: 1.2
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_BOX_ALIGNMENT_START,
  CLUTTER_BOX_ALIGNMENT_END,
  CLUTTER_BOX_ALIGNMENT_CENTER
@@ -628,7 +647,8 @@ typedef enum {
 *
 * Since: 1.8
 */
-typedef enum { /*< prefix=CLUTTER_LONG_PRESS >*/
+typedef enum /*< prefix=CLUTTER_LONG_PRESS >*/
+{
  CLUTTER_LONG_PRESS_QUERY,
  CLUTTER_LONG_PRESS_ACTIVATE,
  CLUTTER_LONG_PRESS_CANCEL
@@ -686,7 +706,8 @@ typedef enum { /*< prefix=CLUTTER_LONG_PRESS >*/
 *
 * Since: 1.6
 */
-typedef enum { /*< prefix=CLUTTER_COLOR >*/
+typedef enum /*< prefix=CLUTTER_COLOR >*/
+{
  /* CGA/EGA-like palette */
  CLUTTER_COLOR_WHITE           = 0,
  CLUTTER_COLOR_BLACK,
@@ -750,7 +771,8 @@ typedef enum { /*< prefix=CLUTTER_COLOR >*/
 *
 * Since: 1.4
 */
-typedef enum { /*< prefix=CLUTTER_DRAG >*/
+typedef enum /*< prefix=CLUTTER_DRAG >*/
+{
  CLUTTER_DRAG_AXIS_NONE = 0,

  CLUTTER_DRAG_X_AXIS,
@@ -767,7 +789,8 @@ typedef enum { /*< prefix=CLUTTER_DRAG >*/
 *
 * Since: 0.6
 */
-typedef enum { /*< flags prefix=CLUTTER_EVENT >*/
+typedef enum /*< flags prefix=CLUTTER_EVENT >*/
+{
  CLUTTER_EVENT_NONE              = 0,
  CLUTTER_EVENT_FLAG_SYNTHETIC    = 1 << 0,
  CLUTTER_EVENT_FLAG_INPUT_METHOD = 1 << 1,
@@ -812,7 +835,8 @@ typedef enum { /*< flags prefix=CLUTTER_EVENT >*/
 *
 * Since: 0.4
 */
-typedef enum { /*< prefix=CLUTTER >*/
+typedef enum /*< prefix=CLUTTER >*/
+{
  CLUTTER_NOTHING = 0,
  CLUTTER_KEY_PRESS,
  CLUTTER_KEY_RELEASE,
@@ -857,7 +881,8 @@ typedef enum { /*< prefix=CLUTTER >*/
 *
 * Since: 0.4
 */
-typedef enum { /*< prefix=CLUTTER_SCROLL >*/
+typedef enum /*< prefix=CLUTTER_SCROLL >*/
+{
  CLUTTER_SCROLL_UP,
  CLUTTER_SCROLL_DOWN,
  CLUTTER_SCROLL_LEFT,
@@ -875,7 +900,8 @@ typedef enum { /*< prefix=CLUTTER_SCROLL >*/
 *
 * Since: 0.4
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_STAGE_STATE_FULLSCREEN       = (1 << 1),
  CLUTTER_STAGE_STATE_OFFSCREEN        = (1 << 2),
  CLUTTER_STAGE_STATE_ACTIVATED        = (1 << 3)
@@ -927,7 +953,8 @@ typedef enum
 *
 * Since: 1.2
 */
-typedef enum { /*< prefix=CLUTTER_FLOW >*/
+typedef enum /*< prefix=CLUTTER_FLOW >*/
+{
  CLUTTER_FLOW_HORIZONTAL,
  CLUTTER_FLOW_VERTICAL
 } ClutterFlowOrientation;
@@ -954,7 +981,8 @@ typedef enum { /*< prefix=CLUTTER_FLOW >*/
 *
 * Since: 1.0
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_POINTER_DEVICE,
  CLUTTER_KEYBOARD_DEVICE,
  CLUTTER_EXTENSION_DEVICE,
@@ -982,7 +1010,8 @@ typedef enum {
 *
 * Since: 1.6
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_MODE_MASTER,
  CLUTTER_INPUT_MODE_SLAVE,
  CLUTTER_INPUT_MODE_FLOATING
@@ -1007,7 +1036,8 @@ typedef enum {
 *
 * Since: 1.6
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_AXIS_IGNORE,

  CLUTTER_INPUT_AXIS_X,
@@ -1034,7 +1064,8 @@ typedef enum {
 *
 * Since: 1.6
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SNAP_EDGE_TOP,
  CLUTTER_SNAP_EDGE_RIGHT,
  CLUTTER_SNAP_EDGE_BOTTOM,
@@ -1051,7 +1082,8 @@ typedef enum {
 *
 * Since: 1.0
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_PICK_NONE = 0,
  CLUTTER_PICK_REACTIVE,
  CLUTTER_PICK_ALL
@@ -1068,7 +1100,8 @@ typedef enum {
 *
 * Since: 1.8
 */
-typedef enum { /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
+typedef enum /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
+{
  CLUTTER_SWIPE_DIRECTION_UP    = 1 << 0,
  CLUTTER_SWIPE_DIRECTION_DOWN  = 1 << 1,
  CLUTTER_SWIPE_DIRECTION_LEFT  = 1 << 2,
@@ -1088,7 +1121,8 @@ typedef enum { /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
 *
 * Since: 1.12
 */
-typedef enum { /*< prefix=CLUTTER_PAN >*/
+typedef enum /*< prefix=CLUTTER_PAN >*/
+{
  CLUTTER_PAN_AXIS_NONE = 0,

  CLUTTER_PAN_X_AXIS,
@@ -1113,7 +1147,8 @@ typedef enum { /*< prefix=CLUTTER_PAN >*/
 *
 * Deprecated: 1.22: Use the alignment properties of #ClutterActor
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_TABLE_ALIGNMENT_START,
  CLUTTER_TABLE_ALIGNMENT_CENTER,
  CLUTTER_TABLE_ALIGNMENT_END
@@ -1134,7 +1169,8 @@ typedef enum {
 * Deprecated: 1.22: The #ClutterTexture class was the only user of
 *   this API
 */
-typedef enum { /*< prefix=CLUTTER_TEXTURE >*/
+typedef enum /*< prefix=CLUTTER_TEXTURE >*/
+{
  CLUTTER_TEXTURE_NONE             = 0,
  CLUTTER_TEXTURE_RGB_FLAG_BGR     = 1 << 1,
  CLUTTER_TEXTURE_RGB_FLAG_PREMULT = 1 << 2, /* FIXME: not handled */
@@ -1158,7 +1194,8 @@ typedef enum { /*< prefix=CLUTTER_TEXTURE >*/
 *   this API; use #ClutterImage and clutter_actor_set_content_scaling_filters()
 *   instead.
 */
-typedef enum { /*< prefix=CLUTTER_TEXTURE_QUALITY >*/
+typedef enum /*< prefix=CLUTTER_TEXTURE_QUALITY >*/
+{
  CLUTTER_TEXTURE_QUALITY_LOW,
  CLUTTER_TEXTURE_QUALITY_MEDIUM,
  CLUTTER_TEXTURE_QUALITY_HIGH
@@ -1173,7 +1210,8 @@ typedef enum { /*< prefix=CLUTTER_TEXTURE_QUALITY >*/
 *
 * Since: 0.6
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_TIMELINE_FORWARD,
  CLUTTER_TIMELINE_BACKWARD
 } ClutterTimelineDirection;
@@ -1192,7 +1230,8 @@ typedef enum {
 *
 * Since: 1.0
 */
-typedef enum { /*< prefix=CLUTTER_UNIT >*/
+typedef enum /*< prefix=CLUTTER_UNIT >*/
+{
  CLUTTER_UNIT_PIXEL,
  CLUTTER_UNIT_EM,
  CLUTTER_UNIT_MM,
@@ -1222,7 +1261,8 @@ typedef enum { /*< prefix=CLUTTER_UNIT >*/
 *
 * Since: 1.0
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_PATH_MOVE_TO      = 0,
  CLUTTER_PATH_LINE_TO      = 1,
  CLUTTER_PATH_CURVE_TO     = 2,
@@ -1253,7 +1293,8 @@ typedef enum {
 *
 * Since: 1.10
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_ACTOR_ALIGN_FILL,
  CLUTTER_ACTOR_ALIGN_START,
  CLUTTER_ACTOR_ALIGN_CENTER,
@@ -1273,7 +1314,8 @@ typedef enum {
 *
 * Since: 1.10
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_REPAINT_FLAGS_PRE_PAINT = 1 << 0,
  CLUTTER_REPAINT_FLAGS_POST_PAINT = 1 << 1,
  CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD = 1 << 2
@@ -1298,7 +1340,8 @@ typedef enum {
 *
 * Since: 1.10
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_CONTENT_GRAVITY_TOP_LEFT,
  CLUTTER_CONTENT_GRAVITY_TOP,
  CLUTTER_CONTENT_GRAVITY_TOP_RIGHT,
@@ -1328,7 +1371,8 @@ typedef enum {
 *
 * Since: 1.10
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SCALING_FILTER_LINEAR,
  CLUTTER_SCALING_FILTER_NEAREST,
  CLUTTER_SCALING_FILTER_TRILINEAR
@@ -1343,7 +1387,8 @@ typedef enum {
 *
 * Since: 1.12
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_ORIENTATION_HORIZONTAL,
  CLUTTER_ORIENTATION_VERTICAL
 } ClutterOrientation;
@@ -1359,7 +1404,8 @@ typedef enum {
 *
 * Since: 1.12
 */
-typedef enum { /*< prefix=CLUTTER_SCROLL >*/
+typedef enum /*< prefix=CLUTTER_SCROLL >*/
+{
  CLUTTER_SCROLL_NONE         = 0,

  CLUTTER_SCROLL_HORIZONTALLY = 1 << 0,
@@ -1379,7 +1425,8 @@ typedef enum { /*< prefix=CLUTTER_SCROLL >*/
 *
 * Since: 1.12
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_GRID_POSITION_LEFT,
  CLUTTER_GRID_POSITION_RIGHT,
  CLUTTER_GRID_POSITION_TOP,
@@ -1397,7 +1444,8 @@ typedef enum {
 *
 * Since: 1.12
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_REPEAT_NONE   = 0,
  CLUTTER_REPEAT_X_AXIS = 1 << 0,
  CLUTTER_REPEAT_Y_AXIS = 1 << 1,
@@ -1419,7 +1467,8 @@ typedef enum {
 *
 * Since: 1.12
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_STEP_MODE_START,
  CLUTTER_STEP_MODE_END
 } ClutterStepMode;
@@ -1435,7 +1484,8 @@ typedef enum {
 *
 * Since: 1.12
 */
-typedef enum { /*< prefix=CLUTTER_ZOOM >*/
+typedef enum /*< prefix=CLUTTER_ZOOM >*/
+{
  CLUTTER_ZOOM_X_AXIS,
  CLUTTER_ZOOM_Y_AXIS,
  CLUTTER_ZOOM_BOTH
@@ -1458,7 +1508,8 @@ typedef enum { /*< prefix=CLUTTER_ZOOM >*/
 *
 * Since: 1.18
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_GESTURE_TRIGGER_EDGE_NONE  = 0,
  CLUTTER_GESTURE_TRIGGER_EDGE_AFTER,
  CLUTTER_GESTURE_TRIGGER_EDGE_BEFORE
@@ -1494,7 +1545,8 @@ typedef enum {
 *
 * Since: 1.24
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN,
  CLUTTER_TOUCHPAD_GESTURE_PHASE_UPDATE,
  CLUTTER_TOUCHPAD_GESTURE_PHASE_END,
@@ -1516,7 +1568,8 @@ typedef enum {
 *
 * Since: 1.26
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SCROLL_SOURCE_UNKNOWN,
  CLUTTER_SCROLL_SOURCE_WHEEL,
  CLUTTER_SCROLL_SOURCE_FINGER,
@@ -1534,7 +1587,8 @@ typedef enum {
 *
 * Since: 1.26
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SCROLL_FINISHED_NONE       = 0,
  CLUTTER_SCROLL_FINISHED_HORIZONTAL = 1 << 0,
  CLUTTER_SCROLL_FINISHED_VERTICAL   = 1 << 1
@@ -1555,7 +1609,8 @@ typedef enum {
 *
 * Since: 1.28
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_DEVICE_TOOL_NONE,
  CLUTTER_INPUT_DEVICE_TOOL_PEN,
  CLUTTER_INPUT_DEVICE_TOOL_ERASER,
@@ -1566,17 +1621,20 @@ typedef enum {
  CLUTTER_INPUT_DEVICE_TOOL_LENS
 } ClutterInputDeviceToolType;

-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_DEVICE_PAD_SOURCE_UNKNOWN,
  CLUTTER_INPUT_DEVICE_PAD_SOURCE_FINGER,
 } ClutterInputDevicePadSource;

-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE,
  CLUTTER_INPUT_DEVICE_MAPPING_RELATIVE,
 } ClutterInputDeviceMapping;

-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_CONTENT_HINT_COMPLETION          = 1 << 0,
  CLUTTER_INPUT_CONTENT_HINT_SPELLCHECK          = 1 << 1,
  CLUTTER_INPUT_CONTENT_HINT_AUTO_CAPITALIZATION = 1 << 2,
@@ -1589,7 +1647,8 @@ typedef enum {
  CLUTTER_INPUT_CONTENT_HINT_MULTILINE           = 1 << 9,
 } ClutterInputContentHintFlags;

-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_CONTENT_PURPOSE_NORMAL,
  CLUTTER_INPUT_CONTENT_PURPOSE_ALPHA,
  CLUTTER_INPUT_CONTENT_PURPOSE_DIGITS,
@@ -1605,7 +1664,8 @@ typedef enum {
  CLUTTER_INPUT_CONTENT_PURPOSE_TERMINAL,
 } ClutterInputContentPurpose;

-typedef enum {
+typedef enum
+{
  CLUTTER_INPUT_PANEL_STATE_OFF,
  CLUTTER_INPUT_PANEL_STATE_ON,
  CLUTTER_INPUT_PANEL_STATE_TOGGLE,
--- a/clutter/clutter/clutter-event-translator.h
+++ b/clutter/clutter/clutter-event-translator.h
@@ -14,7 +14,8 @@ G_BEGIN_DECLS
 typedef struct _ClutterEventTranslator          ClutterEventTranslator;
 typedef struct _ClutterEventTranslatorIface     ClutterEventTranslatorIface;

-typedef enum {
+typedef enum
+{
  CLUTTER_TRANSLATE_CONTINUE,
  CLUTTER_TRANSLATE_REMOVE,
  CLUTTER_TRANSLATE_QUEUE
--- a/clutter/clutter/clutter-event.c
+++ b/clutter/clutter/clutter-event.c
@@ -370,7 +370,7 @@ clutter_event_get_coords (const ClutterEvent *event,
                          gfloat             *x,
                          gfloat             *y)
 {
-  ClutterPoint coords;
+  graphene_point_t coords;

  g_return_if_fail (event != NULL);

@@ -386,15 +386,15 @@ clutter_event_get_coords (const ClutterEvent *event,
 /**
 * clutter_event_get_position:
 * @event: a #ClutterEvent
- * @position: a #ClutterPoint
+ * @position: a #graphene_point_t
 *
- * Retrieves the event coordinates as a #ClutterPoint.
+ * Retrieves the event coordinates as a #graphene_point_t.
 *
 * Since: 1.12
 */
 void
 clutter_event_get_position (const ClutterEvent *event,
-                            ClutterPoint       *position)
+                            graphene_point_t   *position)
 {
  g_return_if_fail (event != NULL);
  g_return_if_fail (position != NULL);
@@ -415,42 +415,42 @@ clutter_event_get_position (const ClutterEvent *event,
    case CLUTTER_PAD_BUTTON_RELEASE:
    case CLUTTER_PAD_STRIP:
    case CLUTTER_PAD_RING:
-      clutter_point_init (position, 0.f, 0.f);
+      graphene_point_init (position, 0.f, 0.f);
      break;

    case CLUTTER_ENTER:
    case CLUTTER_LEAVE:
-      clutter_point_init (position, event->crossing.x, event->crossing.y);
+      graphene_point_init (position, event->crossing.x, event->crossing.y);
      break;

    case CLUTTER_BUTTON_PRESS:
    case CLUTTER_BUTTON_RELEASE:
-      clutter_point_init (position, event->button.x, event->button.y);
+      graphene_point_init (position, event->button.x, event->button.y);
      break;

    case CLUTTER_MOTION:
-      clutter_point_init (position, event->motion.x, event->motion.y);
+      graphene_point_init (position, event->motion.x, event->motion.y);
      break;

    case CLUTTER_TOUCH_BEGIN:
    case CLUTTER_TOUCH_UPDATE:
    case CLUTTER_TOUCH_END:
    case CLUTTER_TOUCH_CANCEL:
-      clutter_point_init (position, event->touch.x, event->touch.y);
+      graphene_point_init (position, event->touch.x, event->touch.y);
      break;

    case CLUTTER_SCROLL:
-      clutter_point_init (position, event->scroll.x, event->scroll.y);
+      graphene_point_init (position, event->scroll.x, event->scroll.y);
      break;

    case CLUTTER_TOUCHPAD_PINCH:
-      clutter_point_init (position, event->touchpad_pinch.x,
-                          event->touchpad_pinch.y);
+      graphene_point_init (position, event->touchpad_pinch.x,
+                           event->touchpad_pinch.y);
      break;

    case CLUTTER_TOUCHPAD_SWIPE:
-      clutter_point_init (position, event->touchpad_swipe.x,
-                          event->touchpad_swipe.y);
+      graphene_point_init (position, event->touchpad_swipe.x,
+                           event->touchpad_swipe.y);
      break;
    }

@@ -1793,12 +1793,12 @@ float
 clutter_event_get_distance (const ClutterEvent *source,
                            const ClutterEvent *target)
 {
-  ClutterPoint p0, p1;
+  graphene_point_t p0, p1;

  clutter_event_get_position (source, &p0);
  clutter_event_get_position (source, &p1);

-  return clutter_point_distance (&p0, &p1, NULL, NULL);
+  return graphene_point_distance (&p0, &p1, NULL, NULL);
 }

 /**
@@ -1819,17 +1819,17 @@ double
 clutter_event_get_angle (const ClutterEvent *source,
                         const ClutterEvent *target)
 {
-  ClutterPoint p0, p1;
+  graphene_point_t p0, p1;
  float x_distance, y_distance;
  double angle;

  clutter_event_get_position (source, &p0);
  clutter_event_get_position (target, &p1);

-  if (clutter_point_equals (&p0, &p1))
+  if (graphene_point_equal (&p0, &p1))
    return 0;

-  clutter_point_distance (&p0, &p1, &x_distance, &y_distance);
+  graphene_point_distance (&p0, &p1, &x_distance, &y_distance);

  angle = atan2 (x_distance, y_distance);

--- a/clutter/clutter/clutter-event.h
+++ b/clutter/clutter/clutter-event.h
@@ -685,7 +685,7 @@ void                    clutter_event_get_coords                (const ClutterEv
                                                                 gfloat                 *y);
 CLUTTER_EXPORT
 void                    clutter_event_get_position              (const ClutterEvent     *event,
-                                                                 ClutterPoint           *position);
+                                                                 graphene_point_t       *position);
 CLUTTER_EXPORT
 float                   clutter_event_get_distance              (const ClutterEvent     *source,
                                                                 const ClutterEvent     *target);
@@ -772,7 +772,10 @@ void                    clutter_event_get_gesture_motion_delta       (const Clut
                                                                      gdouble                *dx,
                                                                      gdouble                *dy);

+CLUTTER_EXPORT
 ClutterScrollSource      clutter_event_get_scroll_source             (const ClutterEvent     *event);
+
+CLUTTER_EXPORT
 ClutterScrollFinishFlags clutter_event_get_scroll_finish_flags       (const ClutterEvent     *event);

 CLUTTER_EXPORT
--- a/clutter/clutter/clutter-graphene.c
+++ b/clutter/clutter/clutter-graphene.c
@@ -0,0 +1,108 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * Copyright (C) 2019 Endless, Inc
+ * Copyright (C) 2009, 2010 Intel Corp
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "clutter-graphene.h"
+#include "clutter-private.h"
+#include "clutter-types.h"
+
+static gboolean
+graphene_point_progress (const GValue *a,
+                         const GValue *b,
+                         gdouble       progress,
+                         GValue       *retval)
+{
+  const graphene_point_t *ap = g_value_get_boxed (a);
+  const graphene_point_t *bp = g_value_get_boxed (b);
+  graphene_point_t res;
+
+  graphene_point_interpolate (ap, bp, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_point3d_progress (const GValue *a,
+                           const GValue *b,
+                           gdouble       progress,
+                           GValue       *retval)
+{
+  const graphene_point3d_t *av = g_value_get_boxed (a);
+  const graphene_point3d_t *bv = g_value_get_boxed (b);
+  graphene_point3d_t res;
+
+  graphene_point3d_interpolate (av, bv, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_rect_progress (const GValue *a,
+                        const GValue *b,
+                        gdouble       progress,
+                        GValue       *retval)
+{
+  const graphene_rect_t *rect_a = g_value_get_boxed (a);
+  const graphene_rect_t *rect_b = g_value_get_boxed (b);
+  graphene_rect_t res;
+
+  graphene_rect_interpolate (rect_a, rect_b, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_size_progress (const GValue *a,
+                        const GValue *b,
+                        gdouble       progress,
+                        GValue       *retval)
+{
+  const graphene_size_t *as = g_value_get_boxed (a);
+  const graphene_size_t *bs = g_value_get_boxed (b);
+  graphene_size_t res;
+
+  graphene_size_interpolate (as, bs, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+void
+clutter_graphene_init (void)
+{
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT,
+                                           graphene_point_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT3D,
+                                           graphene_point3d_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_RECT,
+                                           graphene_rect_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_SIZE,
+                                           graphene_size_progress);
+}
--- a/clutter/clutter/clutter-graphene.h
+++ b/clutter/clutter/clutter-graphene.h
@@ -3,9 +3,10 @@
 *
 * An OpenGL based 'interactive canvas' library.
 *
- * Authored By Matthew Allum  <mallum@openedhand.com>
+ * Authored By Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
 *
- * Copyright (C) 2006 OpenedHand
+ * Copyright (C) 2019 Endless, Inc
+ * Copyright (C) 2009, 2010 Intel Corp
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -19,18 +20,11 @@
 *
 * 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_GLX_H__
-#define __CLUTTER_GLX_H__
+#ifndef CLUTTER_GRAPHENE_H
+#define CLUTTER_GRAPHENE_H

-#include <glib.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-#include <clutter/clutter.h>
-#include <clutter/glx/clutter-glx-texture-pixmap.h>
+void clutter_graphene_init (void);

-#endif /* __CLUTTER_GLX_H__ */
+#endif
--- a/clutter/clutter/clutter-image.c
+++ b/clutter/clutter/clutter-image.c
@@ -53,9 +53,11 @@
 struct _ClutterImagePrivate
 {
  CoglTexture *texture;
+  gint width;
+  gint height;
 };

-static void clutter_content_iface_init (ClutterContentIface *iface);
+static void clutter_content_iface_init (ClutterContentInterface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterImage, clutter_image, G_TYPE_OBJECT,
                         G_ADD_PRIVATE (ClutterImage)
@@ -68,6 +70,27 @@ clutter_image_error_quark (void)
  return g_quark_from_static_string ("clutter-image-error-quark");
 }

+static void
+update_image_size (ClutterImage *self)
+{
+  gint width, height;
+
+  if (self->priv->texture == NULL)
+    return;
+
+  width = cogl_texture_get_width (self->priv->texture);
+  height = cogl_texture_get_height (self->priv->texture);
+
+  if (self->priv->width == width &&
+      self->priv->height == height)
+    return;
+
+  self->priv->width = width;
+  self->priv->height = height;
+
+  clutter_content_invalidate_size (CLUTTER_CONTENT (self));
+}
+
 static void
 clutter_image_finalize (GObject *gobject)
 {
@@ -131,7 +154,7 @@ clutter_image_get_preferred_size (ClutterContent *content,
 }

 static void
-clutter_content_iface_init (ClutterContentIface *iface)
+clutter_content_iface_init (ClutterContentInterface *iface)
 {
  iface->get_preferred_size = clutter_image_get_preferred_size;
  iface->paint_content = clutter_image_paint_content;
@@ -238,6 +261,7 @@ clutter_image_set_data (ClutterImage     *image,
    }

  clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);

  return TRUE;
 }
@@ -306,6 +330,7 @@ clutter_image_set_bytes (ClutterImage     *image,
    }

  clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);

  return TRUE;
 }
@@ -399,6 +424,7 @@ clutter_image_set_area (ClutterImage                 *image,
    }

  clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);

  return TRUE;
 }
--- a/clutter/clutter/clutter-image.h
+++ b/clutter/clutter/clutter-image.h
@@ -63,7 +63,8 @@ typedef struct _ClutterImageClass      ClutterImageClass;
 *
 * Since: 1.10
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_IMAGE_ERROR_INVALID_DATA
 } ClutterImageError;

--- a/clutter/clutter/clutter-input-device-tool.c
+++ b/clutter/clutter/clutter-input-device-tool.c
@@ -35,7 +35,8 @@ struct _ClutterInputDeviceToolPrivate
  guint64 id;
 };

-enum {
+enum
+{
  PROP_0,
  PROP_TYPE,
  PROP_SERIAL,
--- a/clutter/clutter/clutter-input-device.c
+++ b/clutter/clutter/clutter-input-device.c
@@ -986,7 +986,7 @@ clutter_input_device_get_enabled (ClutterInputDevice *device)
 gboolean
 clutter_input_device_get_coords (ClutterInputDevice   *device,
                                 ClutterEventSequence *sequence,
-                                 ClutterPoint         *point)
+                                 graphene_point_t     *point)
 {
  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
  g_return_val_if_fail (point != NULL, FALSE);
@@ -1033,7 +1033,9 @@ _clutter_input_device_update (ClutterInputDevice   *device,
  ClutterStage *stage;
  ClutterActor *new_cursor_actor;
  ClutterActor *old_cursor_actor;
-  ClutterPoint point = { -1, -1 };
+  graphene_point_t point;
+
+  point = GRAPHENE_POINT_INIT (-1.0f, -1.0f);

  if (device->device_type == CLUTTER_KEYBOARD_DEVICE)
    return NULL;
--- a/clutter/clutter/clutter-input-device.h
+++ b/clutter/clutter/clutter-input-device.h
@@ -58,7 +58,7 @@ gint                    clutter_input_device_get_device_id      (ClutterInputDev
 CLUTTER_EXPORT
 gboolean                clutter_input_device_get_coords        (ClutterInputDevice   *device,
                                                                ClutterEventSequence *sequence,
-                                                                ClutterPoint         *point);
+                                                                graphene_point_t     *point);
 CLUTTER_EXPORT
 ClutterModifierType     clutter_input_device_get_modifier_state (ClutterInputDevice  *device);
 CLUTTER_EXPORT
--- a/clutter/clutter/clutter-input-focus.c
+++ b/clutter/clutter/clutter-input-focus.c
@@ -89,8 +89,8 @@ clutter_input_focus_reset (ClutterInputFocus *focus)
 }

 void
-clutter_input_focus_set_cursor_location (ClutterInputFocus *focus,
-                                         const ClutterRect *rect)
+clutter_input_focus_set_cursor_location (ClutterInputFocus     *focus,
+                                         const graphene_rect_t *rect)
 {
  ClutterInputFocusPrivate *priv;

@@ -175,7 +175,8 @@ clutter_input_focus_set_can_show_preedit (ClutterInputFocus *focus,
 }

 void
-clutter_input_focus_request_toggle_input_panel (ClutterInputFocus *focus)
+clutter_input_focus_set_input_panel_state (ClutterInputFocus      *focus,
+                                           ClutterInputPanelState  state)
 {
  ClutterInputFocusPrivate *priv;

@@ -184,7 +185,7 @@ clutter_input_focus_request_toggle_input_panel (ClutterInputFocus *focus)

  priv = clutter_input_focus_get_instance_private (focus);

-  clutter_input_method_toggle_input_panel (priv->im);
+  clutter_input_method_set_input_panel_state (priv->im, state);
 }

 void
--- a/clutter/clutter/clutter-input-focus.h
+++ b/clutter/clutter/clutter-input-focus.h
@@ -57,8 +57,8 @@ gboolean clutter_input_focus_is_focused (ClutterInputFocus *focus);
 CLUTTER_EXPORT
 void clutter_input_focus_reset (ClutterInputFocus *focus);
 CLUTTER_EXPORT
-void clutter_input_focus_set_cursor_location (ClutterInputFocus *focus,
-                                              const ClutterRect *rect);
+void clutter_input_focus_set_cursor_location (ClutterInputFocus     *focus,
+                                              const graphene_rect_t *rect);

 CLUTTER_EXPORT
 void clutter_input_focus_set_surrounding (ClutterInputFocus *focus,
@@ -78,6 +78,7 @@ CLUTTER_EXPORT
 void clutter_input_focus_set_can_show_preedit (ClutterInputFocus *focus,
                                               gboolean           can_show_preedit);
 CLUTTER_EXPORT
-void clutter_input_focus_request_toggle_input_panel (ClutterInputFocus *focus);
+void clutter_input_focus_set_input_panel_state (ClutterInputFocus      *focus,
+                                                ClutterInputPanelState  state);

 #endif /* __CLUTTER_INPUT_FOCUS_H__ */
--- a/clutter/clutter/clutter-input-method-private.h
+++ b/clutter/clutter/clutter-input-method-private.h
@@ -26,8 +26,8 @@ ClutterInputFocus * clutter_input_method_get_focus (ClutterInputMethod *method);

 void clutter_input_method_reset               (ClutterInputMethod *method);

-void clutter_input_method_set_cursor_location (ClutterInputMethod *method,
-                                               const ClutterRect  *rect);
+void clutter_input_method_set_cursor_location (ClutterInputMethod    *method,
+                                               const graphene_rect_t *rect);
 void clutter_input_method_set_surrounding     (ClutterInputMethod *method,
                                               const gchar        *text,
                                               guint               cursor,
--- a/clutter/clutter/clutter-input-method.c
+++ b/clutter/clutter/clutter-input-method.c
@@ -37,7 +37,8 @@ struct _ClutterInputMethodPrivate
  gboolean can_show_preedit;
 };

-enum {
+enum
+{
  COMMIT,
  DELETE_SURROUNDING,
  REQUEST_SURROUNDING,
@@ -46,7 +47,8 @@ enum {
  N_SIGNALS,
 };

-enum {
+enum
+{
  PROP_0,
  PROP_CONTENT_HINTS,
  PROP_CONTENT_PURPOSE,
@@ -185,7 +187,7 @@ clutter_input_method_class_init (ClutterInputMethodClass *klass)
                  G_TYPE_FROM_CLASS (object_class),
                  G_SIGNAL_RUN_LAST,
                  0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 1, CLUTTER_TYPE_RECT);
+                  G_TYPE_NONE, 1, GRAPHENE_TYPE_RECT);

  pspecs[PROP_CONTENT_HINTS] =
    g_param_spec_flags ("content-hints",
@@ -264,9 +266,6 @@ clutter_input_method_focus_out (ClutterInputMethod *im)

  klass = CLUTTER_INPUT_METHOD_GET_CLASS (im);
  klass->focus_out (im);
-
-  g_signal_emit (im, signals[INPUT_PANEL_STATE],
-                 0, CLUTTER_INPUT_PANEL_STATE_OFF);
 }

 ClutterInputFocus *
@@ -361,12 +360,12 @@ clutter_input_method_notify_key_event (ClutterInputMethod *im,
 }

 void
-clutter_input_method_toggle_input_panel (ClutterInputMethod *im)
+clutter_input_method_set_input_panel_state (ClutterInputMethod     *im,
+                                            ClutterInputPanelState  state)
 {
  g_return_if_fail (CLUTTER_IS_INPUT_METHOD (im));

-  g_signal_emit (im, signals[INPUT_PANEL_STATE], 0,
-                 CLUTTER_INPUT_PANEL_STATE_TOGGLE);
+  g_signal_emit (im, signals[INPUT_PANEL_STATE], 0, state);
 }

 void
@@ -378,8 +377,8 @@ clutter_input_method_reset (ClutterInputMethod *im)
 }

 void
-clutter_input_method_set_cursor_location (ClutterInputMethod *im,
-                                          const ClutterRect  *rect)
+clutter_input_method_set_cursor_location (ClutterInputMethod    *im,
+                                          const graphene_rect_t *rect)
 {
  g_return_if_fail (CLUTTER_IS_INPUT_METHOD (im));

--- a/clutter/clutter/clutter-input-method.h
+++ b/clutter/clutter/clutter-input-method.h
@@ -42,8 +42,8 @@ struct _ClutterInputMethodClass

  void (* reset) (ClutterInputMethod *im);

-  void (* set_cursor_location) (ClutterInputMethod          *im,
-                                const ClutterRect           *rect);
+  void (* set_cursor_location) (ClutterInputMethod    *im,
+                                const graphene_rect_t *rect);
  void (* set_surrounding) (ClutterInputMethod *im,
                            const gchar        *text,
                            guint               cursor,
@@ -83,7 +83,8 @@ void clutter_input_method_notify_key_event (ClutterInputMethod *im,
                                            const ClutterEvent *event,
                                            gboolean            filtered);
 CLUTTER_EXPORT
-void clutter_input_method_request_toggle_input_panel (ClutterInputMethod *im);
+void clutter_input_method_set_input_panel_state (ClutterInputMethod     *im,
+                                                 ClutterInputPanelState  state);

 CLUTTER_EXPORT
 void clutter_input_method_forward_key (ClutterInputMethod *im,
--- a/clutter/clutter/clutter-keymap.c
+++ b/clutter/clutter/clutter-keymap.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2018 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-keymap.h"
+#include "clutter-private.h"
+
+G_DEFINE_ABSTRACT_TYPE (ClutterKeymap, clutter_keymap, G_TYPE_OBJECT)
+
+enum
+{
+  STATE_CHANGED,
+  N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0, };
+
+static void
+clutter_keymap_class_init (ClutterKeymapClass *klass)
+{
+  signals[STATE_CHANGED] =
+    g_signal_new (I_("state-changed"),
+		  G_TYPE_FROM_CLASS (klass),
+		  G_SIGNAL_RUN_FIRST,
+		  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+}
+
+static void
+clutter_keymap_init (ClutterKeymap *keymap)
+{
+}
+
+gboolean
+clutter_keymap_get_num_lock_state (ClutterKeymap *keymap)
+{
+  return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_num_lock_state (keymap);
+}
+
+gboolean
+clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap)
+{
+  return CLUTTER_KEYMAP_GET_CLASS (keymap)->get_caps_lock_state (keymap);
+}
--- a/clutter/clutter/clutter-keymap.h
+++ b/clutter/clutter/clutter-keymap.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2018 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#ifndef CLUTTER_KEYMAP_H
+#define CLUTTER_KEYMAP_H
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#include <clutter/clutter-macros.h>
+
+#include <glib-object.h>
+
+typedef struct _ClutterKeymap ClutterKeymap;
+typedef struct _ClutterKeymapClass ClutterKeymapClass;
+
+struct _ClutterKeymapClass
+{
+  GObjectClass parent_class;
+
+  gboolean (* get_num_lock_state)  (ClutterKeymap *keymap);
+  gboolean (* get_caps_lock_state) (ClutterKeymap *keymap);
+};
+
+#define CLUTTER_TYPE_KEYMAP (clutter_keymap_get_type ())
+CLUTTER_EXPORT
+G_DECLARE_DERIVABLE_TYPE (ClutterKeymap, clutter_keymap,
+			  CLUTTER, KEYMAP,
+			  GObject)
+
+CLUTTER_EXPORT
+gboolean clutter_keymap_get_num_lock_state  (ClutterKeymap *keymap);
+
+CLUTTER_EXPORT
+gboolean clutter_keymap_get_caps_lock_state (ClutterKeymap *keymap);
+
+#endif /* CLUTTER_KEYMAP_H */
--- a/clutter/clutter/clutter-main.c
+++ b/clutter/clutter/clutter-main.c
@@ -58,6 +58,7 @@
 #include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-feature.h"
+#include "clutter-graphene.h"
 #include "clutter-main.h"
 #include "clutter-master-clock.h"
 #include "clutter-mutter.h"
@@ -193,17 +194,6 @@ clutter_config_read_from_key_file (GKeyFile *keyfile)
  if (!g_key_file_has_group (keyfile, ENVIRONMENT_GROUP))
    return;

-  str_value =
-    g_key_file_get_string (keyfile, ENVIRONMENT_GROUP,
-                           "Backends",
-                           &key_error);
-  if (key_error != NULL)
-    g_clear_error (&key_error);
-  else
-    clutter_try_set_windowing_backend (str_value);
-
-  g_free (str_value);
-
  str_value =
    g_key_file_get_string (keyfile, ENVIRONMENT_GROUP,
                           "Drivers",
@@ -2585,6 +2575,8 @@ clutter_base_init (void)

      /* initialise the Big Clutter Lock™ if necessary */
      clutter_threads_init_default ();
+
+      clutter_graphene_init ();
    }
 }

--- a/clutter/clutter/clutter-main.h
+++ b/clutter/clutter/clutter-main.h
@@ -53,7 +53,8 @@ G_BEGIN_DECLS
 *
 * Since: 0.2
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_INIT_SUCCESS        =  1,
  CLUTTER_INIT_ERROR_UNKNOWN  =  0,
  CLUTTER_INIT_ERROR_THREADS  = -1,
--- a/clutter/clutter/clutter-marshal.list
+++ b/clutter/clutter/clutter-marshal.list
@@ -1,6 +1,7 @@
 BOOLEAN:BOXED
 BOOLEAN:BOXED,INT,INT
 BOOLEAN:OBJECT,BOOLEAN
+BOOLEAN:OBJECT,BOXED
 BOOLEAN:OBJECT,BOXED,DOUBLE
 BOOLEAN:OBJECT,DOUBLE
 BOOLEAN:OBJECT,ENUM
--- a/clutter/clutter/clutter-master-clock-default.c
+++ b/clutter/clutter/clutter-master-clock-default.c
@@ -109,7 +109,8 @@ static GSourceFuncs clock_funcs = {
  NULL
 };

-static void clutter_master_clock_iface_init (ClutterMasterClockIface *iface);
+static void
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface);

 #define clutter_master_clock_default_get_type   _clutter_master_clock_default_get_type

@@ -689,7 +690,7 @@ clutter_master_clock_default_set_paused (ClutterMasterClock *clock,
 }

 static void
-clutter_master_clock_iface_init (ClutterMasterClockIface *iface)
+clutter_master_clock_iface_init (ClutterMasterClockInterface *iface)
 {
  iface->add_timeline = clutter_master_clock_default_add_timeline;
  iface->remove_timeline = clutter_master_clock_default_remove_timeline;
--- a/clutter/clutter/clutter-master-clock.c
+++ b/clutter/clutter/clutter-master-clock.c
@@ -37,10 +37,6 @@
 #include "clutter-master-clock-default.h"
 #include "clutter-private.h"

-#define clutter_master_clock_get_type   _clutter_master_clock_get_type
-
-typedef ClutterMasterClockIface ClutterMasterClockInterface;
-
 G_DEFINE_INTERFACE (ClutterMasterClock, clutter_master_clock, G_TYPE_OBJECT)

 static void
--- a/clutter/clutter/clutter-master-clock.h
+++ b/clutter/clutter/clutter-master-clock.h
@@ -28,15 +28,12 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_MASTER_CLOCK               (_clutter_master_clock_get_type ())
-#define CLUTTER_MASTER_CLOCK(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClock))
-#define CLUTTER_IS_MASTER_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MASTER_CLOCK))
-#define CLUTTER_MASTER_CLOCK_GET_IFACE(obj)     (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockIface))
+#define CLUTTER_TYPE_MASTER_CLOCK (clutter_master_clock_get_type ())
+G_DECLARE_INTERFACE (ClutterMasterClock, clutter_master_clock,
+                     CLUTTER, MASTER_CLOCK,
+                     GObject)

-typedef struct _ClutterMasterClock      ClutterMasterClock; /* dummy */
-typedef struct _ClutterMasterClockIface ClutterMasterClockIface;
-
-struct _ClutterMasterClockIface
+struct _ClutterMasterClockInterface
 {
  /*< private >*/
  GTypeInterface parent_iface;
@@ -51,8 +48,6 @@ struct _ClutterMasterClockIface
                                   gboolean            paused);
 };

-GType _clutter_master_clock_get_type (void) G_GNUC_CONST;
-
 ClutterMasterClock *    _clutter_master_clock_get_default               (void);
 void                    _clutter_master_clock_add_timeline              (ClutterMasterClock *master_clock,
                                                                         ClutterTimeline    *timeline);
--- a/clutter/clutter/clutter-mutter.h
+++ b/clutter/clutter/clutter-mutter.h
@@ -49,6 +49,12 @@ void clutter_stage_freeze_updates (ClutterStage *stage);
 CLUTTER_EXPORT
 void clutter_stage_thaw_updates (ClutterStage *stage);

+CLUTTER_EXPORT
+void clutter_stage_update_resource_scales (ClutterStage *stage);
+
+CLUTTER_EXPORT
+gboolean clutter_actor_has_damage (ClutterActor *actor);
+
 #undef __CLUTTER_H_INSIDE__

 #endif /* __CLUTTER_MUTTER_H__ */
--- a/clutter/clutter/clutter-offscreen-effect.c
+++ b/clutter/clutter/clutter-offscreen-effect.c
@@ -66,12 +66,16 @@

 #include "clutter-offscreen-effect.h"

+#include <math.h>
+
 #include "cogl/cogl.h"

 #include "clutter-actor-private.h"
 #include "clutter-debug.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
+#include "clutter-paint-volume-private.h"
+#include "clutter-actor-box-private.h"

 struct _ClutterOffscreenEffectPrivate
 {
@@ -82,27 +86,19 @@ struct _ClutterOffscreenEffectPrivate
  ClutterActor *actor;
  ClutterActor *stage;

-  gfloat x_offset;
-  gfloat y_offset;
+  graphene_point3d_t position;
+
+  int fbo_offset_x;
+  int fbo_offset_y;

  /* This is the calculated size of the fbo before being passed
     through create_texture(). This needs to be tracked separately so
     that we can detect when a different size is calculated and
     regenerate the fbo */
-  int fbo_width;
-  int fbo_height;
+  int target_width;
+  int target_height;

  gint old_opacity_override;
-
-  /* The matrix that was current the last time the fbo was updated. We
-     need to keep track of this to detect when we can reuse the
-     contents of the fbo without redrawing the actor. We need the
-     actual matrix rather than just detecting queued redraws on the
-     actor because any change in the parent hierarchy (even just a
-     translation) could cause the actor to look completely different
-     and it won't cause a redraw to be queued on the parent's
-     children. */
-  CoglMatrix last_matrix_drawn;
 };

 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterOffscreenEffect,
@@ -141,8 +137,35 @@ clutter_offscreen_effect_real_create_texture (ClutterOffscreenEffect *effect,
                                     COGL_PIXEL_FORMAT_RGBA_8888_PRE);
 }

+static void
+ensure_pipeline_filter_for_scale (ClutterOffscreenEffect *self,
+                                  float                   resource_scale)
+{
+  CoglPipelineFilter filter;
+
+  if (!self->priv->target)
+    return;
+
+  /* If no fractional scaling is set, we're always going to render the texture
+     at a 1:1 texel:pixel ratio so, in such case we can use 'nearest' filtering
+     to decrease the effects of rounding errors in the geometry calculation;
+     if instead we we're using a global fractional scaling we need to make sure
+     that we're using the default linear effect, not to create artifacts when
+     scaling down the texture */
+  if (fmodf (resource_scale, 1.0f) == 0)
+    filter = COGL_PIPELINE_FILTER_NEAREST;
+  else
+    filter = COGL_PIPELINE_FILTER_LINEAR;
+
+  cogl_pipeline_set_layer_filters (self->priv->target, 0 /* layer_index */,
+                                   filter, filter);
+}
+
 static gboolean
-update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
+update_fbo (ClutterEffect *effect,
+            int            target_width,
+            int            target_height,
+            float          resource_scale)
 {
  ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
  ClutterOffscreenEffectPrivate *priv = self->priv;
@@ -157,10 +180,13 @@ update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
      return FALSE;
    }

-  if (priv->fbo_width == fbo_width &&
-      priv->fbo_height == fbo_height &&
+  if (priv->target_width == target_width &&
+      priv->target_height == target_height &&
      priv->offscreen != NULL)
+  {
+    ensure_pipeline_filter_for_scale (self, resource_scale);
    return TRUE;
+  }

  if (priv->target == NULL)
    {
@@ -168,14 +194,7 @@ update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
        clutter_backend_get_cogl_context (clutter_get_default_backend ());

      priv->target = cogl_pipeline_new (ctx);
-
-      /* We're always going to render the texture at a 1:1 texel:pixel
-         ratio so we can use 'nearest' filtering to decrease the
-         effects of rounding errors in the geometry calculation */
-      cogl_pipeline_set_layer_filters (priv->target,
-                                       0, /* layer_index */
-                                       COGL_PIPELINE_FILTER_NEAREST,
-                                       COGL_PIPELINE_FILTER_NEAREST);
+      ensure_pipeline_filter_for_scale (self, resource_scale);
    }

  if (priv->texture != NULL)
@@ -191,14 +210,14 @@ update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
    }

  priv->texture =
-    clutter_offscreen_effect_create_texture (self, fbo_width, fbo_height);
+    clutter_offscreen_effect_create_texture (self, target_width, target_height);
  if (priv->texture == NULL)
    return FALSE;

  cogl_pipeline_set_layer_texture (priv->target, 0, priv->texture);

-  priv->fbo_width = fbo_width;
-  priv->fbo_height = fbo_height;
+  priv->target_width = target_width;
+  priv->target_height = target_height;

  priv->offscreen = cogl_offscreen_new_to_texture (priv->texture);
  if (priv->offscreen == NULL)
@@ -208,8 +227,8 @@ update_fbo (ClutterEffect *effect, int fbo_width, int fbo_height)
      cogl_handle_unref (priv->target);
      priv->target = NULL;

-      priv->fbo_width = 0;
-      priv->fbo_height = 0;
+      priv->target_width = 0;
+      priv->target_height = 0;

      return FALSE;
    }
@@ -222,15 +241,19 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
 {
  ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
  ClutterOffscreenEffectPrivate *priv = self->priv;
-  ClutterActorBox box;
+  ClutterActorBox raw_box, box;
  ClutterActor *stage;
-  CoglMatrix projection;
+  CoglMatrix projection, old_modelview, modelview;
+  const ClutterPaintVolume *volume;
  CoglColor transparent;
  gfloat stage_width, stage_height;
-  gfloat fbo_width = -1, fbo_height = -1;
-  gfloat width, height;
-  gfloat xexpand, yexpand;
-  int texture_width, texture_height;
+  gfloat target_width = -1, target_height = -1;
+  gfloat resource_scale;
+  gfloat ceiled_resource_scale;
+  graphene_point3d_t local_offset;
+  gfloat old_viewport[4];
+
+  local_offset = GRAPHENE_POINT3D_INIT (0.0f, 0.0f, 0.0f);

  if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
    return FALSE;
@@ -241,101 +264,109 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
  stage = _clutter_actor_get_stage_internal (priv->actor);
  clutter_actor_get_size (stage, &stage_width, &stage_height);

-  /* The paint box is the bounding box of the actor's paint volume in
-   * stage coordinates. This will give us the size for the framebuffer
-   * we need to redirect its rendering offscreen and its position will
-   * be used to setup an offset viewport */
-  if (clutter_actor_get_paint_box (priv->actor, &box))
+  if (_clutter_actor_get_real_resource_scale (priv->actor, &resource_scale))
    {
-      clutter_actor_box_get_size (&box, &fbo_width, &fbo_height);
-      clutter_actor_box_get_origin (&box, &priv->x_offset, &priv->y_offset);
-
-      fbo_width = MIN (fbo_width, stage_width);
-      fbo_height = MIN (fbo_height, stage_height);
+      ceiled_resource_scale = ceilf (resource_scale);
+      stage_width *= ceiled_resource_scale;
+      stage_height *= ceiled_resource_scale;
    }
  else
    {
-      fbo_width = stage_width;
-      fbo_height = stage_height;
+      /* We are sure we have a resource scale set to a good value at paint */
+      g_assert_not_reached ();
    }

-  if (fbo_width == stage_width)
-    priv->x_offset = 0.0f;
-  if (fbo_height == stage_height)
-    priv->y_offset = 0.0f;
+  /* Get the minimal bounding box for what we want to paint, relative to the
+   * parent of priv->actor. Note that we may actually be painting a clone of
+   * priv->actor so we need to be careful to avoid querying the transformation
+   * of priv->actor (like clutter_actor_get_paint_box would). Just stay in
+   * local coordinates for now...
+   */
+  volume = clutter_actor_get_paint_volume (priv->actor);
+  if (volume)
+    {
+      ClutterPaintVolume mutable_volume;
+
+      _clutter_paint_volume_copy_static (volume, &mutable_volume);
+      _clutter_paint_volume_get_bounding_box (&mutable_volume, &raw_box);
+      clutter_paint_volume_free (&mutable_volume);
+    }
+  else
+    {
+      clutter_actor_get_allocation_box (priv->actor, &raw_box);
+    }
+
+  box = raw_box;
+  _clutter_actor_box_enlarge_for_effects (&box);
+
+  priv->fbo_offset_x = box.x1 - raw_box.x1;
+  priv->fbo_offset_y = box.y1 - raw_box.y1;
+
+  clutter_actor_box_scale (&box, ceiled_resource_scale);
+  clutter_actor_box_get_size (&box, &target_width, &target_height);
+
+  target_width = ceilf (target_width);
+  target_height = ceilf (target_height);

  /* First assert that the framebuffer is the right size... */
-  if (!update_fbo (effect, fbo_width, fbo_height))
+  if (!update_fbo (effect, target_width, target_height, resource_scale))
    return FALSE;

-  texture_width = cogl_texture_get_width (priv->texture);
-  texture_height = cogl_texture_get_height (priv->texture);
-
-  /* get the current modelview matrix so that we can copy it to the
-   * framebuffer. We also store the matrix that was last used when we
-   * updated the FBO so that we can detect when we don't need to
-   * update the FBO to paint a second time */
-  cogl_get_modelview_matrix (&priv->last_matrix_drawn);
+  cogl_get_modelview_matrix (&old_modelview);

  /* let's draw offscreen */
  cogl_push_framebuffer (priv->offscreen);

-  /* Copy the modelview that would have been used if rendering onscreen */
-  cogl_set_modelview_matrix (&priv->last_matrix_drawn);
-
-  /* Set up the viewport so that it has the same size as the stage,
-   * but offset it so that the actor of interest lands on our
-   * framebuffer. */
-  clutter_actor_get_size (priv->stage, &width, &height);
-
-  /* Expand the viewport if the actor is partially off-stage,
-   * otherwise the actor will end up clipped to the stage viewport
+  /* We don't want the FBO contents to be transformed. That could waste memory
+   * (e.g. during zoom), or result in something that's not rectangular (clipped
+   * incorrectly). So drop the modelview matrix of the current paint chain.
+   * This is fine since paint_texture runs with the same modelview matrix,
+   * so it will come out correctly whenever that is used to put the FBO
+   * contents on screen...
   */
-  xexpand = 0.f;
-  if (priv->x_offset < 0.f)
-    xexpand = -priv->x_offset;
-  if (priv->x_offset + texture_width > width)
-    xexpand = MAX (xexpand, (priv->x_offset + texture_width) - width);
+  clutter_actor_get_transform (priv->stage, &modelview);
+  cogl_framebuffer_set_modelview_matrix (priv->offscreen, &modelview);

-  yexpand = 0.f;
-  if (priv->y_offset < 0.f)
-    yexpand = -priv->y_offset;
-  if (priv->y_offset + texture_height > height)
-    yexpand = MAX (yexpand, (priv->y_offset + texture_height) - height);
+  /* Save the original viewport for calculating priv->position */
+  _clutter_stage_get_viewport (CLUTTER_STAGE (priv->stage),
+                               &old_viewport[0],
+                               &old_viewport[1],
+                               &old_viewport[2],
+                               &old_viewport[3]);

-  /* Set the viewport */
-  cogl_set_viewport (-(priv->x_offset + xexpand), -(priv->y_offset + yexpand),
-                     width + (2 * xexpand), height + (2 * yexpand));
+  /* Set up the viewport so that it has the same size as the stage (avoid
+   * distortion), but translated to account for the FBO offset...
+   */
+  cogl_framebuffer_set_viewport (priv->offscreen,
+                                 -priv->fbo_offset_x,
+                                 -priv->fbo_offset_y,
+                                 stage_width,
+                                 stage_height);

  /* Copy the stage's projection matrix across to the framebuffer */
  _clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
                                        &projection);

-  /* If we've expanded the viewport, make sure to scale the projection
-   * matrix accordingly (as it's been initialised to work with the
-   * original viewport and not our expanded one).
+  /* Now save the global position of the effect (not just of the actor).
+   * It doesn't appear anyone actually uses this yet, but get_target_rect is
+   * documented as returning it. So we should...
   */
-  if (xexpand > 0.f || yexpand > 0.f)
-    {
-      gfloat new_width, new_height;
+  _clutter_util_fully_transform_vertices (&old_modelview,
+                                          &projection,
+                                          old_viewport,
+                                          &local_offset,
+                                          &priv->position,
+                                          1);

-      new_width = width + (2 * xexpand);
-      new_height = height + (2 * yexpand);
-
-      cogl_matrix_scale (&projection,
-                         width / new_width,
-                         height / new_height,
-                         1);
-    }
-
-  cogl_set_projection_matrix (&projection);
+  cogl_framebuffer_set_projection_matrix (priv->offscreen, &projection);

  cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
-  cogl_clear (&transparent,
-              COGL_BUFFER_BIT_COLOR |
-              COGL_BUFFER_BIT_DEPTH);
+  cogl_framebuffer_clear (priv->offscreen,
+                          COGL_BUFFER_BIT_COLOR |
+                          COGL_BUFFER_BIT_DEPTH,
+                          &transparent);

-  cogl_push_matrix ();
+  cogl_framebuffer_push_matrix (priv->offscreen);

  /* Override the actor's opacity to fully opaque - we paint the offscreen
   * texture with the actor's paint opacity, so we need to do this to avoid
@@ -381,25 +412,37 @@ static void
 clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect)
 {
  ClutterOffscreenEffectPrivate *priv = effect->priv;
+  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
  CoglMatrix modelview;
+  float resource_scale;

-  cogl_push_matrix ();
+  cogl_framebuffer_push_matrix (framebuffer);

-  /* Now reset the modelview to put us in stage coordinates so
-   * we can drawn the result of our offscreen render as a textured
-   * quad... */
+  /* The current modelview matrix is *almost* perfect already. It's only
+   * missing a correction for the expanded FBO and offset rendering within...
+   */
+  cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);

-  cogl_matrix_init_identity (&modelview);
-  _clutter_actor_apply_modelview_transform (priv->stage, &modelview);
-  cogl_matrix_translate (&modelview, priv->x_offset, priv->y_offset, 0.0f);
-  cogl_set_modelview_matrix (&modelview);
+  if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) &&
+      resource_scale != 1.0f)
+    {
+      float paint_scale = 1.0f / resource_scale;
+      cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1);
+    }
+
+  cogl_matrix_translate (&modelview,
+                         priv->fbo_offset_x,
+                         priv->fbo_offset_y,
+                         0.0f);
+
+  cogl_framebuffer_set_modelview_matrix (framebuffer, &modelview);

  /* paint the target material; this is virtualized for
   * sub-classes that require special hand-holding
   */
  clutter_offscreen_effect_paint_target (effect);

-  cogl_pop_matrix ();
+  cogl_framebuffer_pop_matrix (framebuffer);
 }

 static void
@@ -416,7 +459,7 @@ clutter_offscreen_effect_post_paint (ClutterEffect *effect)
  /* Restore the previous opacity override */
  clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);

-  cogl_pop_matrix ();
+  cogl_framebuffer_pop_matrix (priv->offscreen);
  cogl_pop_framebuffer ();

  clutter_offscreen_effect_paint_texture (self);
@@ -428,16 +471,11 @@ clutter_offscreen_effect_paint (ClutterEffect           *effect,
 {
  ClutterOffscreenEffect *self = CLUTTER_OFFSCREEN_EFFECT (effect);
  ClutterOffscreenEffectPrivate *priv = self->priv;
-  CoglMatrix matrix;

-  cogl_get_modelview_matrix (&matrix);
-
-  /* If we've already got a cached image for the same matrix and the
-     actor hasn't been redrawn then we can just use the cached image
-     in the fbo */
-  if (priv->offscreen == NULL ||
-      (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY) ||
-      !cogl_matrix_equal (&matrix, &priv->last_matrix_drawn))
+  /* If we've already got a cached image and the actor hasn't been redrawn
+   * then we can just use the cached image in the FBO.
+   */
+  if (priv->offscreen == NULL || (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY))
    {
      /* Chain up to the parent paint method which will call the pre and
         post paint functions to update the image */
@@ -650,7 +688,7 @@ clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
 */
 gboolean
 clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
-                                          ClutterRect            *rect)
+                                          graphene_rect_t        *rect)
 {
  ClutterOffscreenEffectPrivate *priv;

@@ -662,11 +700,11 @@ clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
  if (priv->texture == NULL)
    return FALSE;

-  clutter_rect_init (rect,
-                     priv->x_offset,
-                     priv->y_offset,
-                     cogl_texture_get_width (priv->texture),
-                     cogl_texture_get_height (priv->texture));
+  graphene_rect_init (rect,
+                      priv->position.x,
+                      priv->position.y,
+                      cogl_texture_get_width (priv->texture),
+                      cogl_texture_get_height (priv->texture));

  return TRUE;
 }
--- a/clutter/clutter/clutter-offscreen-effect.h
+++ b/clutter/clutter/clutter-offscreen-effect.h
@@ -114,7 +114,7 @@ gboolean        clutter_offscreen_effect_get_target_size        (ClutterOffscree

 CLUTTER_EXPORT
 gboolean        clutter_offscreen_effect_get_target_rect        (ClutterOffscreenEffect *effect,
-                                                                 ClutterRect            *rect);
+                                                                 graphene_rect_t        *rect);

 G_END_DECLS

--- a/clutter/clutter/clutter-paint-node-private.h
+++ b/clutter/clutter/clutter-paint-node-private.h
@@ -74,9 +74,11 @@ struct _ClutterPaintNodeClass

 #define PAINT_OP_INIT   { PAINT_OP_INVALID }

-typedef enum {
+typedef enum
+{
  PAINT_OP_INVALID = 0,
  PAINT_OP_TEX_RECT,
+  PAINT_OP_MULTITEX_RECT,
  PAINT_OP_PATH,
  PAINT_OP_PRIMITIVE
 } PaintOpCode;
@@ -85,6 +87,8 @@ struct _ClutterPaintOperation
 {
  PaintOpCode opcode;

+  GArray *multitex_coords;
+
  union {
    float texrect[8];

@@ -94,7 +98,6 @@ struct _ClutterPaintOperation
  } op;
 };

-GType _clutter_root_node_get_type (void) G_GNUC_CONST;
 GType _clutter_transform_node_get_type (void) G_GNUC_CONST;
 GType _clutter_dummy_node_get_type (void) G_GNUC_CONST;

@@ -107,13 +110,9 @@ void                    _clutter_paint_operation_paint_primitive        (const C
 void                    _clutter_paint_node_init_types                  (void);
 gpointer                _clutter_paint_node_create                      (GType gtype);

-ClutterPaintNode *      _clutter_root_node_new                          (CoglFramebuffer             *framebuffer,
-                                                                         const ClutterColor          *clear_color,
-                                                                         CoglBufferBit                clear_flags);
 ClutterPaintNode *      _clutter_transform_node_new                     (const CoglMatrix            *matrix);
 ClutterPaintNode *      _clutter_dummy_node_new                         (ClutterActor                *actor);

-void                    _clutter_paint_node_paint                       (ClutterPaintNode            *root);
 void                    _clutter_paint_node_dump_tree                   (ClutterPaintNode            *root);

 G_GNUC_INTERNAL
--- a/clutter/clutter/clutter-paint-node.c
+++ b/clutter/clutter/clutter-paint-node.c
@@ -761,6 +761,11 @@ clutter_paint_operation_clear (ClutterPaintOperation *op)
    case PAINT_OP_TEX_RECT:
      break;

+    case PAINT_OP_MULTITEX_RECT:
+      if (op->multitex_coords != NULL)
+        g_array_unref (op->multitex_coords);
+      break;
+
    case PAINT_OP_PATH:
      if (op->op.path != NULL)
        cogl_object_unref (op->op.path);
@@ -794,6 +799,27 @@ clutter_paint_op_init_tex_rect (ClutterPaintOperation *op,
  op->op.texrect[7] = y_2;
 }

+static inline void
+clutter_paint_op_init_multitex_rect (ClutterPaintOperation *op,
+                                     const ClutterActorBox *rect,
+                                     const float           *tex_coords,
+                                     unsigned int           tex_coords_len)
+{
+  clutter_paint_operation_clear (op);
+
+  op->opcode = PAINT_OP_MULTITEX_RECT;
+  op->multitex_coords = g_array_sized_new (FALSE, FALSE,
+                                           sizeof (float),
+                                           tex_coords_len);
+
+  g_array_append_vals (op->multitex_coords, tex_coords, tex_coords_len);
+
+  op->op.texrect[0] = rect->x1;
+  op->op.texrect[1] = rect->y1;
+  op->op.texrect[2] = rect->x2;
+  op->op.texrect[3] = rect->y2;
+}
+
 static inline void
 clutter_paint_op_init_path (ClutterPaintOperation *op,
                            CoglPath              *path)
@@ -881,6 +907,33 @@ clutter_paint_node_add_texture_rectangle (ClutterPaintNode      *node,
  g_array_append_val (node->operations, operation);
 }

+
+/**
+ * clutter_paint_node_add_multitexture_rectangle:
+ * @node: a #ClutterPaintNode
+ * @rect: a #ClutterActorBox
+ * @text_coords: array of multitexture values
+ * @text_coords_len: number of items of @text_coords
+ *
+ * Adds a rectangle region to the @node, with multitexture coordinates.
+ */
+void
+clutter_paint_node_add_multitexture_rectangle (ClutterPaintNode      *node,
+                                               const ClutterActorBox *rect,
+                                               const float           *text_coords,
+                                               unsigned int           text_coords_len)
+{
+  ClutterPaintOperation operation = PAINT_OP_INIT;
+
+  g_return_if_fail (CLUTTER_IS_PAINT_NODE (node));
+  g_return_if_fail (rect != NULL);
+
+  clutter_paint_node_maybe_init_operations (node);
+
+  clutter_paint_op_init_multitex_rect (&operation, rect, text_coords, text_coords_len);
+  g_array_append_val (node->operations, operation);
+}
+
 /**
 * clutter_paint_node_add_path: (skip)
 * @node: a #ClutterPaintNode
@@ -936,15 +989,15 @@ clutter_paint_node_add_primitive (ClutterPaintNode *node,
  g_array_append_val (node->operations, operation);
 }

-/*< private >
- * _clutter_paint_node_paint:
+/**
+ * clutter_paint_node_paint:
 * @node: a #ClutterPaintNode
 *
 * Paints the @node using the class implementation, traversing
 * its children, if any.
 */
 void
-_clutter_paint_node_paint (ClutterPaintNode *node)
+clutter_paint_node_paint (ClutterPaintNode *node)
 {
  ClutterPaintNodeClass *klass = CLUTTER_PAINT_NODE_GET_CLASS (node);
  ClutterPaintNode *iter;
@@ -961,7 +1014,7 @@ _clutter_paint_node_paint (ClutterPaintNode *node)
       iter != NULL;
       iter = iter->next_sibling)
    {
-      _clutter_paint_node_paint (iter);
+      clutter_paint_node_paint (iter);
    }

  if (res)
@@ -1006,7 +1059,7 @@ clutter_paint_node_to_json (ClutterPaintNode *node)

  if (node->operations != NULL)
    {
-      guint i;
+      guint i, j;

      for (i = 0; i < node->operations->len; i++)
        {
@@ -1031,6 +1084,19 @@ clutter_paint_node_to_json (ClutterPaintNode *node)
              json_builder_end_array (builder);
              break;

+            case PAINT_OP_MULTITEX_RECT:
+              json_builder_set_member_name (builder, "texrect");
+              json_builder_begin_array (builder);
+
+              for (j = 0; i < op->multitex_coords->len; j++)
+                {
+                  float coord = g_array_index (op->multitex_coords, float, j);
+                  json_builder_add_double_value (builder, coord);
+                }
+
+              json_builder_end_array (builder);
+              break;
+
            case PAINT_OP_PATH:
              json_builder_set_member_name (builder, "path");
              json_builder_add_int_value (builder, (gint64) op->op.path);
--- a/clutter/clutter/clutter-paint-node.h
+++ b/clutter/clutter/clutter-paint-node.h
@@ -49,6 +49,9 @@ ClutterPaintNode *      clutter_paint_node_ref                          (Clutter
 CLUTTER_EXPORT
 void                    clutter_paint_node_unref                        (ClutterPaintNode      *node);

+CLUTTER_EXPORT
+void                    clutter_paint_node_paint                        (ClutterPaintNode      *node);
+
 CLUTTER_EXPORT
 void                    clutter_paint_node_set_name                     (ClutterPaintNode      *node,
                                                                         const char            *name);
@@ -67,6 +70,12 @@ void                    clutter_paint_node_add_texture_rectangle        (Clutter
                                                                         float                  x_2,
                                                                         float                  y_2);

+CLUTTER_EXPORT
+void                   clutter_paint_node_add_multitexture_rectangle   (ClutterPaintNode       *node,
+                                                                        const ClutterActorBox  *rect,
+                                                                        const float            *text_coords,
+                                                                        unsigned int            text_coords_len);
+
 CLUTTER_EXPORT
 void                    clutter_paint_node_add_path                     (ClutterPaintNode      *node,
                                                                         CoglPath              *path);
--- a/clutter/clutter/clutter-paint-nodes.c
+++ b/clutter/clutter/clutter-paint-nodes.c
@@ -83,16 +83,13 @@ _clutter_paint_node_init_types (void)
 }

 /*
- * Root node, private
+ * Root node
 *
 * any frame can only have a since RootNode instance for each
 * top-level actor.
 */

-#define clutter_root_node_get_type      _clutter_root_node_get_type
-
-typedef struct _ClutterRootNode         ClutterRootNode;
-typedef struct _ClutterPaintNodeClass   ClutterRootNodeClass;
+#define clutter_root_node_get_type      clutter_root_node_get_type

 struct _ClutterRootNode
 {
@@ -111,6 +108,8 @@ clutter_root_node_pre_draw (ClutterPaintNode *node)
 {
  ClutterRootNode *rnode = (ClutterRootNode *) node;

+  cogl_push_framebuffer (rnode->framebuffer);
+
  cogl_framebuffer_clear (rnode->framebuffer,
                          rnode->clear_flags,
                          &rnode->clear_color);
@@ -121,6 +120,7 @@ clutter_root_node_pre_draw (ClutterPaintNode *node)
 static void
 clutter_root_node_post_draw (ClutterPaintNode *node)
 {
+  cogl_pop_framebuffer ();
 }

 static void
@@ -158,13 +158,13 @@ clutter_root_node_init (ClutterRootNode *self)
 }

 ClutterPaintNode *
-_clutter_root_node_new (CoglFramebuffer    *framebuffer,
-                        const ClutterColor *clear_color,
-                        CoglBufferBit       clear_flags)
+clutter_root_node_new (CoglFramebuffer    *framebuffer,
+                       const ClutterColor *clear_color,
+                       CoglBufferBit       clear_flags)
 {
  ClutterRootNode *res;

-  res = _clutter_paint_node_create (_clutter_root_node_get_type ());
+  res = _clutter_paint_node_create (CLUTTER_TYPE_ROOT_NODE);

  cogl_color_init_from_4ub (&res->clear_color,
                            clear_color->red,
@@ -431,6 +431,17 @@ clutter_pipeline_node_draw (ClutterPaintNode *node)
                                              op->op.texrect[7]);
          break;

+        case PAINT_OP_MULTITEX_RECT:
+          cogl_framebuffer_draw_multitextured_rectangle (cogl_get_draw_framebuffer (),
+                                                         pnode->pipeline,
+                                                         op->op.texrect[0],
+                                                         op->op.texrect[1],
+                                                         op->op.texrect[2],
+                                                         op->op.texrect[3],
+                                                         (float*) op->multitex_coords->data,
+                                                         op->multitex_coords->len);
+          break;
+
        case PAINT_OP_PATH:
          cogl_path_fill (op->op.path);
          break;
@@ -827,6 +838,7 @@ clutter_text_node_draw (ClutterPaintNode *node)
            cogl_framebuffer_pop_clip (fb);
          break;

+        case PAINT_OP_MULTITEX_RECT:
        case PAINT_OP_PATH:
        case PAINT_OP_PRIMITIVE:
        case PAINT_OP_INVALID:
@@ -992,6 +1004,7 @@ clutter_clip_node_pre_draw (ClutterPaintNode *node)
          retval = TRUE;
          break;

+        case PAINT_OP_MULTITEX_RECT:
        case PAINT_OP_PRIMITIVE:
        case PAINT_OP_INVALID:
          break;
@@ -1025,6 +1038,7 @@ clutter_clip_node_post_draw (ClutterPaintNode *node)
          cogl_framebuffer_pop_clip (fb);
          break;

+        case PAINT_OP_MULTITEX_RECT:
        case PAINT_OP_PRIMITIVE:
        case PAINT_OP_INVALID:
          break;
@@ -1180,6 +1194,17 @@ clutter_layer_node_post_draw (ClutterPaintNode *node)
          cogl_pop_source ();
          break;

+        case PAINT_OP_MULTITEX_RECT:
+          cogl_framebuffer_draw_multitextured_rectangle (cogl_get_draw_framebuffer (),
+                                                         lnode->state,
+                                                         op->op.texrect[0],
+                                                         op->op.texrect[1],
+                                                         op->op.texrect[2],
+                                                         op->op.texrect[3],
+                                                         (float*) op->multitex_coords->data,
+                                                         op->multitex_coords->len);
+          break;
+
        case PAINT_OP_PATH:
          cogl_push_source (lnode->state);
          cogl_path_fill (op->op.path);
--- a/clutter/clutter/clutter-paint-nodes.h
+++ b/clutter/clutter/clutter-paint-nodes.h
@@ -143,6 +143,26 @@ CLUTTER_EXPORT
 ClutterPaintNode *      clutter_text_node_new           (PangoLayout           *layout,
                                                         const ClutterColor    *color);

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

 #endif /* __CLUTTER_PAINT_NODES_H__ */
--- a/clutter/clutter/clutter-paint-volume-private.h
+++ b/clutter/clutter/clutter-paint-volume-private.h
@@ -58,7 +58,7 @@ struct _ClutterPaintVolume
   * elements 4, 5, 6 and 7 most of the time for 2D actors when
   * calculating the projected paint box.
   */
-  ClutterVertex vertices[8];
+  graphene_point3d_t vertices[8];

  /* As an optimization for internally managed PaintVolumes we allow
   * initializing ClutterPaintVolume variables allocated on the stack
--- a/clutter/clutter/clutter-paint-volume.c
+++ b/clutter/clutter/clutter-paint-volume.c
@@ -35,6 +35,7 @@
 #include "clutter-paint-volume-private.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
+#include "clutter-actor-box-private.h"

 G_DEFINE_BOXED_TYPE (ClutterPaintVolume, clutter_paint_volume,
                     clutter_paint_volume_copy,
@@ -62,7 +63,7 @@ _clutter_paint_volume_new (ClutterActor *actor)

  pv->actor = actor;

-  memset (pv->vertices, 0, 8 * sizeof (ClutterVertex));
+  memset (pv->vertices, 0, 8 * sizeof (graphene_point3d_t));

  pv->is_static = FALSE;
  pv->is_empty = TRUE;
@@ -95,7 +96,7 @@ _clutter_paint_volume_init_static (ClutterPaintVolume *pv,
 {
  pv->actor = actor;

-  memset (pv->vertices, 0, 8 * sizeof (ClutterVertex));
+  memset (pv->vertices, 0, 8 * sizeof (graphene_point3d_t));

  pv->is_static = TRUE;
  pv->is_empty = TRUE;
@@ -169,7 +170,7 @@ clutter_paint_volume_free (ClutterPaintVolume *pv)
 /**
 * clutter_paint_volume_set_origin:
 * @pv: a #ClutterPaintVolume
- * @origin: a #ClutterVertex
+ * @origin: a #graphene_point3d_t
 *
 * Sets the origin of the paint volume.
 *
@@ -182,7 +183,7 @@ clutter_paint_volume_free (ClutterPaintVolume *pv)
 */
 void
 clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
-                                 const ClutterVertex *origin)
+                                 const graphene_point3d_t *origin)
 {
  static const int key_vertices[4] = { 0, 1, 3, 4 };
  float dx, dy, dz;
@@ -209,7 +210,7 @@ clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
 /**
 * clutter_paint_volume_get_origin:
 * @pv: a #ClutterPaintVolume
- * @vertex: (out): the return location for a #ClutterVertex
+ * @vertex: (out): the return location for a #graphene_point3d_t
 *
 * Retrieves the origin of the #ClutterPaintVolume.
 *
@@ -217,7 +218,7 @@ clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
 */
 void
 clutter_paint_volume_get_origin (const ClutterPaintVolume *pv,
-                                 ClutterVertex            *vertex)
+                                 graphene_point3d_t       *vertex)
 {
  g_return_if_fail (pv != NULL);
  g_return_if_fail (vertex != NULL);
@@ -658,7 +659,7 @@ clutter_paint_volume_union_box (ClutterPaintVolume    *pv,
                                const ClutterActorBox *box)
 {
  ClutterPaintVolume volume;
-  ClutterVertex origin;
+  graphene_point3d_t origin;

  g_return_if_fail (pv != NULL);
  g_return_if_fail (box != NULL);
@@ -756,7 +757,7 @@ _clutter_paint_volume_get_bounding_box (ClutterPaintVolume *pv,
                                        ClutterActorBox *box)
 {
  gfloat x_min, y_min, x_max, y_max;
-  ClutterVertex *vertices;
+  graphene_point3d_t *vertices;
  int count;
  gint i;

@@ -877,9 +878,9 @@ _clutter_paint_volume_transform (ClutterPaintVolume *pv,

  cogl_matrix_transform_points (matrix,
                                3,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                pv->vertices,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                pv->vertices,
                                transform_count);

@@ -895,7 +896,7 @@ _clutter_paint_volume_axis_align (ClutterPaintVolume *pv)
 {
  int count;
  int i;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
  float max_x;
  float max_y;
  float max_z;
@@ -1074,7 +1075,7 @@ _clutter_paint_volume_cull (ClutterPaintVolume *pv,
                            const ClutterPlane *planes)
 {
  int vertex_count;
-  ClutterVertex *vertices = pv->vertices;
+  graphene_point3d_t *vertices = pv->vertices;
  gboolean partial = FALSE;
  int i;
  int j;
@@ -1096,24 +1097,18 @@ _clutter_paint_volume_cull (ClutterPaintVolume *pv,

  for (i = 0; i < 4; i++)
    {
+      const ClutterPlane *plane = &planes[i];
      int out = 0;
      for (j = 0; j < vertex_count; j++)
        {
-          ClutterVertex p;
-          float distance;
+          graphene_vec3_t v;

-          /* XXX: for perspective projections this can be optimized
-           * out because all the planes should pass through the origin
-           * so (0,0,0) is a valid v0. */
-          p.x = vertices[j].x - planes[i].v0[0];
-          p.y = vertices[j].y - planes[i].v0[1];
-          p.z = vertices[j].z - planes[i].v0[2];
+          graphene_vec3_init (&v,
+                              vertices[j].x - graphene_vec3_get_x (&plane->v0),
+                              vertices[j].y - graphene_vec3_get_y (&plane->v0),
+                              vertices[j].z - graphene_vec3_get_z (&plane->v0));

-          distance = (planes[i].n[0] * p.x +
-                      planes[i].n[1] * p.y +
-                      planes[i].n[2] * p.z);
-
-          if (distance < 0)
+          if (graphene_vec3_dot (&plane->n, &v) < 0)
            out++;
        }

@@ -1138,8 +1133,6 @@ _clutter_paint_volume_get_stage_paint_box (ClutterPaintVolume *pv,
  CoglMatrix modelview;
  CoglMatrix projection;
  float viewport[4];
-  float width;
-  float height;

  _clutter_paint_volume_copy_static (pv, &projected_pv);

@@ -1179,50 +1172,7 @@ _clutter_paint_volume_get_stage_paint_box (ClutterPaintVolume *pv,
      return;
    }

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

  clutter_paint_volume_free (&projected_pv);
 }
--- a/clutter/clutter/clutter-pan-action.c
+++ b/clutter/clutter/clutter-pan-action.c
@@ -961,6 +961,7 @@ clutter_pan_action_get_motion_delta (ClutterPanAction *self,
      return clutter_pan_action_get_interpolated_delta (self, delta_x, delta_y);
    default:
      g_assert_not_reached ();
+      return 0.0f;
    }
 }

--- a/clutter/clutter/clutter-private.h
+++ b/clutter/clutter/clutter-private.h
@@ -69,6 +69,9 @@ typedef struct _ClutterVertex4          ClutterVertex4;
 #define CLUTTER_ACTOR_IN_REPARENT(a)            ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_REPARENT) != FALSE)
 #define CLUTTER_ACTOR_IN_PAINT(a)               ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PAINT) != FALSE)
 #define CLUTTER_ACTOR_IN_RELAYOUT(a)            ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_RELAYOUT) != FALSE)
+#define CLUTTER_ACTOR_IN_PREF_WIDTH(a)          ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PREF_WIDTH) != FALSE)
+#define CLUTTER_ACTOR_IN_PREF_HEIGHT(a)         ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PREF_HEIGHT) != FALSE)
+#define CLUTTER_ACTOR_IN_PREF_SIZE(a)           ((CLUTTER_PRIVATE_FLAGS (a) & (CLUTTER_IN_PREF_HEIGHT|CLUTTER_IN_PREF_WIDTH)) != FALSE)

 #define CLUTTER_PARAM_READABLE  (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)
 #define CLUTTER_PARAM_WRITABLE  (G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)
@@ -91,21 +94,24 @@ typedef struct _ClutterVertex4          ClutterVertex4;
 * because it will break for negative numbers. */
 #define CLUTTER_NEARBYINT(x) ((int) ((x) < 0.0f ? (x) - 0.5f : (x) + 0.5f))

-typedef enum {
+typedef enum
+{
  CLUTTER_ACTOR_UNUSED_FLAG = 0,

  CLUTTER_IN_DESTRUCTION = 1 << 0,
  CLUTTER_IS_TOPLEVEL    = 1 << 1,
  CLUTTER_IN_REPARENT    = 1 << 2,
+  CLUTTER_IN_PREF_WIDTH  = 1 << 3,
+  CLUTTER_IN_PREF_HEIGHT = 1 << 4,

  /* Used to avoid recursion */
-  CLUTTER_IN_PAINT       = 1 << 3,
+  CLUTTER_IN_PAINT       = 1 << 5,

  /* Used to avoid recursion */
-  CLUTTER_IN_RELAYOUT    = 1 << 4,
+  CLUTTER_IN_RELAYOUT    = 1 << 6,

  /* a flag for internal children of Containers (DEPRECATED) */
-  CLUTTER_INTERNAL_CHILD = 1 << 5
+  CLUTTER_INTERNAL_CHILD = 1 << 7
 } ClutterPrivateFlags;

 /*
@@ -202,7 +208,7 @@ gboolean      _clutter_feature_init (GError **error);

 /* Diagnostic mode */
 gboolean        _clutter_diagnostic_enabled     (void);
-void            _clutter_diagnostic_message     (const char *fmt, ...);
+void            _clutter_diagnostic_message     (const char *fmt, ...) G_GNUC_PRINTF (1, 2);

 /* Picking code */
 guint           _clutter_pixel_to_id            (guchar        pixel[4]);
@@ -233,12 +239,23 @@ void _clutter_run_repaint_functions (ClutterRepaintFlags flags);

 GType _clutter_layout_manager_get_child_meta_type (ClutterLayoutManager *manager);

-void  _clutter_util_fully_transform_vertices (const CoglMatrix    *modelview,
-                                              const CoglMatrix    *projection,
-                                              const float         *viewport,
-                                              const ClutterVertex *vertices_in,
-                                              ClutterVertex       *vertices_out,
-                                              int                  n_vertices);
+void  _clutter_util_fully_transform_vertices (const CoglMatrix         *modelview,
+                                              const CoglMatrix         *projection,
+                                              const float              *viewport,
+                                              const graphene_point3d_t *vertices_in,
+                                              graphene_point3d_t       *vertices_out,
+                                              int                       n_vertices);
+
+void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
+                                        graphene_rect_t             *dest);
+
+void _clutter_util_rectangle_int_extents (const graphene_rect_t *src,
+                                          cairo_rectangle_int_t *dest);
+
+void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
+                                     int                          x,
+                                     int                          y,
+                                     cairo_rectangle_int_t       *dest);

 void _clutter_util_rectangle_union (const cairo_rectangle_int_t *src1,
                                    const cairo_rectangle_int_t *src2,
@@ -257,12 +274,6 @@ struct _ClutterVertex4
  float w;
 };

-void
-_clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
-                                   const ClutterVertex4 *b,
-                                   double                progress,
-                                   ClutterVertex4       *res);
-
 #define CLUTTER_MATRIX_INIT_IDENTITY { \
  1.0f, 0.0f, 0.0f, 0.0f, \
  0.0f, 1.0f, 0.0f, 0.0f, \
@@ -270,26 +281,10 @@ _clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
  0.0f, 0.0f, 0.0f, 1.0f, \
 }

-float   _clutter_util_matrix_determinant        (const ClutterMatrix *matrix);
-
-void    _clutter_util_matrix_skew_xy            (ClutterMatrix *matrix,
-                                                 float          factor);
-void    _clutter_util_matrix_skew_xz            (ClutterMatrix *matrix,
-                                                 float          factor);
-void    _clutter_util_matrix_skew_yz            (ClutterMatrix *matrix,
-                                                 float          factor);
-
-gboolean        _clutter_util_matrix_decompose  (const ClutterMatrix *src,
-                                                 ClutterVertex       *scale_p,
-                                                 float                shear_p[3],
-                                                 ClutterVertex       *rotate_p,
-                                                 ClutterVertex       *translate_p,
-                                                 ClutterVertex4      *perspective_p);
-
 typedef struct _ClutterPlane
 {
-  float v0[3];
-  float n[3];
+  graphene_vec3_t v0;
+  graphene_vec3_t n;
 } ClutterPlane;

 typedef enum _ClutterCullResult
--- a/clutter/clutter/clutter-script-parser.c
+++ b/clutter/clutter/clutter-script-parser.c
@@ -352,63 +352,64 @@ _clutter_script_parse_knot (ClutterScript *script,
 }

 static gboolean
-parse_geometry_from_array (JsonArray       *array,
-                           ClutterGeometry *geometry)
+parse_rect_from_array (JsonArray       *array,
+                       graphene_rect_t *rect)
 {
  if (json_array_get_length (array) != 4)
    return FALSE;

-  geometry->x = json_array_get_int_element (array, 0);
-  geometry->y = json_array_get_int_element (array, 1);
-  geometry->width = json_array_get_int_element (array, 2);
-  geometry->height = json_array_get_int_element (array, 3);
+  graphene_rect_init (rect,
+                      json_array_get_int_element (array, 0),
+                      json_array_get_int_element (array, 1),
+                      json_array_get_int_element (array, 2),
+                      json_array_get_int_element (array, 3));

  return TRUE;
 }

 static gboolean
-parse_geometry_from_object (JsonObject      *object,
-                            ClutterGeometry *geometry)
+parse_rect_from_object (JsonObject      *object,
+                            graphene_rect_t *rect)
 {
  if (json_object_has_member (object, "x"))
-    geometry->x = json_object_get_int_member (object, "x");
+    rect->origin.x = json_object_get_int_member (object, "x");
  else
-    geometry->x = 0;
+    rect->origin.x = 0;

  if (json_object_has_member (object, "y"))
-    geometry->y = json_object_get_int_member (object, "y");
+    rect->origin.y = json_object_get_int_member (object, "y");
  else
-    geometry->y = 0;
+    rect->origin.y = 0;

  if (json_object_has_member (object, "width"))
-    geometry->width = json_object_get_int_member (object, "width");
+    rect->size.width = json_object_get_int_member (object, "width");
  else
-    geometry->width = 0;
+    rect->size.width = 0;

  if (json_object_has_member (object, "height"))
-    geometry->height = json_object_get_int_member (object, "height");
+    rect->size.height = json_object_get_int_member (object, "height");
  else
-    geometry->height = 0;
+    rect->size.height = 0;

  return TRUE;
 }

 gboolean
-_clutter_script_parse_geometry (ClutterScript   *script,
-                                JsonNode        *node,
-                                ClutterGeometry *geometry)
+_clutter_script_parse_rect (ClutterScript   *script,
+                            JsonNode        *node,
+                            graphene_rect_t *rect)
 {
  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
  g_return_val_if_fail (node != NULL, FALSE);
-  g_return_val_if_fail (geometry != NULL, FALSE);
+  g_return_val_if_fail (rect != NULL, FALSE);

  switch (JSON_NODE_TYPE (node))
    {
    case JSON_NODE_ARRAY:
-      return parse_geometry_from_array (json_node_get_array (node), geometry);
+      return parse_rect_from_array (json_node_get_array (node), rect);

    case JSON_NODE_OBJECT:
-      return parse_geometry_from_object (json_node_get_object (node), geometry);
+      return parse_rect_from_object (json_node_get_object (node), rect);

    default:
      break;
@@ -492,8 +493,8 @@ _clutter_script_parse_color (ClutterScript *script,
 }

 static gboolean
-parse_point_from_array (JsonArray    *array,
-                        ClutterPoint *point)
+parse_point_from_array (JsonArray        *array,
+                        graphene_point_t *point)
 {
  if (json_array_get_length (array) != 2)
    return FALSE;
@@ -505,8 +506,8 @@ parse_point_from_array (JsonArray    *array,
 }

 static gboolean
-parse_point_from_object (JsonObject   *object,
-                         ClutterPoint *point)
+parse_point_from_object (JsonObject       *object,
+                         graphene_point_t *point)
 {
  if (json_object_has_member (object, "x"))
    point->x = json_object_get_double_member (object, "x");
@@ -522,9 +523,9 @@ parse_point_from_object (JsonObject   *object,
 }

 gboolean
-_clutter_script_parse_point (ClutterScript *script,
-                             JsonNode      *node,
-                             ClutterPoint  *point)
+_clutter_script_parse_point (ClutterScript    *script,
+                             JsonNode         *node,
+                             graphene_point_t *point)
 {
  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
  g_return_val_if_fail (node != NULL, FALSE);
@@ -546,8 +547,8 @@ _clutter_script_parse_point (ClutterScript *script,
 }

 static gboolean
-parse_size_from_array (JsonArray   *array,
-                       ClutterSize *size)
+parse_size_from_array (JsonArray       *array,
+                       graphene_size_t *size)
 {
  if (json_array_get_length (array) != 2)
    return FALSE;
@@ -559,8 +560,8 @@ parse_size_from_array (JsonArray   *array,
 }

 static gboolean
-parse_size_from_object (JsonObject  *object,
-                        ClutterSize *size)
+parse_size_from_object (JsonObject      *object,
+                        graphene_size_t *size)
 {
  if (json_object_has_member (object, "width"))
    size->width = json_object_get_double_member (object, "width");
@@ -576,9 +577,9 @@ parse_size_from_object (JsonObject  *object,
 }

 gboolean
-_clutter_script_parse_size (ClutterScript *script,
-                            JsonNode      *node,
-                            ClutterSize   *size)
+_clutter_script_parse_size (ClutterScript   *script,
+                            JsonNode        *node,
+                            graphene_size_t *size)
 {
  g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
  g_return_val_if_fail (node != NULL, FALSE);
@@ -1328,11 +1329,11 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (p_type == CLUTTER_TYPE_GEOMETRY)
+          else if (p_type == GRAPHENE_TYPE_RECT)
            {
-              ClutterGeometry geom = { 0, };
+              graphene_rect_t rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);

-              /* geometry := {
+              /* rect := {
               *        "x" : (int),
               *        "y" : (int),
               *        "width" : (int),
@@ -1340,9 +1341,9 @@ _clutter_script_parse_node (ClutterScript *script,
               * }
               */

-              if (_clutter_script_parse_geometry (script, node, &geom))
+              if (_clutter_script_parse_rect (script, node, &rect))
                {
-                  g_value_set_boxed (value, &geom);
+                  g_value_set_boxed (value, &rect);
                  return TRUE;
                }
            }
@@ -1364,9 +1365,9 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (p_type == CLUTTER_TYPE_POINT)
+          else if (p_type == GRAPHENE_TYPE_POINT)
            {
-              ClutterPoint point = CLUTTER_POINT_INIT_ZERO;
+              graphene_point_t point = GRAPHENE_POINT_INIT_ZERO;

              if (_clutter_script_parse_point (script, node, &point))
                {
@@ -1374,9 +1375,9 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (p_type == CLUTTER_TYPE_SIZE)
+          else if (p_type == GRAPHENE_TYPE_SIZE)
            {
-              ClutterSize size = CLUTTER_SIZE_INIT_ZERO;
+              graphene_size_t size = GRAPHENE_SIZE_INIT_ZERO;

              if (_clutter_script_parse_size (script, node, &size))
                {
@@ -1417,15 +1418,15 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_GEOMETRY))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_RECT))
            {
-              ClutterGeometry geom = { 0, };
+              graphene_rect_t rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);

-              /* geometry := [ (int), (int), (int), (int) ] */
+              /* rect := [ (int), (int), (int), (int) ] */

-              if (_clutter_script_parse_geometry (script, node, &geom))
+              if (_clutter_script_parse_rect (script, node, &rect))
                {
-                  g_value_set_boxed (value, &geom);
+                  g_value_set_boxed (value, &rect);
                  return TRUE;
                }
            }
@@ -1441,9 +1442,9 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_POINT))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_POINT))
            {
-              ClutterPoint point = CLUTTER_POINT_INIT_ZERO;
+              graphene_point_t point = GRAPHENE_POINT_INIT_ZERO;

              if (_clutter_script_parse_point (script, node, &point))
                {
@@ -1451,9 +1452,9 @@ _clutter_script_parse_node (ClutterScript *script,
                  return TRUE;
                }
            }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_SIZE))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_SIZE))
            {
-              ClutterSize size = CLUTTER_SIZE_INIT_ZERO;
+              graphene_size_t size = GRAPHENE_SIZE_INIT_ZERO;

              if (_clutter_script_parse_size (script, node, &size))
                {
--- a/clutter/clutter/clutter-script-private.h
+++ b/clutter/clutter/clutter-script-private.h
@@ -122,9 +122,9 @@ gboolean _clutter_script_flags_from_string (GType          gtype,
 gboolean _clutter_script_parse_knot        (ClutterScript   *script,
                                            JsonNode        *node,
                                            ClutterKnot     *knot);
-gboolean _clutter_script_parse_geometry    (ClutterScript   *script,
+gboolean _clutter_script_parse_rect        (ClutterScript   *script,
                                            JsonNode        *node,
-                                            ClutterGeometry *geometry);
+                                            graphene_rect_t *rect);
 gboolean _clutter_script_parse_color       (ClutterScript   *script,
                                            JsonNode        *node,
                                            ClutterColor    *color);
@@ -132,10 +132,10 @@ GObject *_clutter_script_parse_alpha       (ClutterScript   *script,
                                            JsonNode        *node);
 gboolean _clutter_script_parse_point       (ClutterScript   *script,
                                            JsonNode        *node,
-                                            ClutterPoint    *point);
+                                            graphene_point_t *point);
 gboolean _clutter_script_parse_size        (ClutterScript   *script,
                                            JsonNode        *node,
-                                            ClutterSize     *size);
+                                            graphene_size_t *size);

 gboolean _clutter_script_parse_translatable_string (ClutterScript *script,
                                                    JsonNode      *node,
--- a/clutter/clutter/clutter-script.h
+++ b/clutter/clutter/clutter-script.h
@@ -79,7 +79,8 @@ typedef void (* ClutterScriptConnectFunc) (ClutterScript *script,
 *
 * Since: 0.6
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_SCRIPT_ERROR_INVALID_TYPE_FUNCTION,
  CLUTTER_SCRIPT_ERROR_INVALID_PROPERTY,
  CLUTTER_SCRIPT_ERROR_INVALID_VALUE
--- a/clutter/clutter/clutter-scroll-actor.c
+++ b/clutter/clutter/clutter-scroll-actor.c
@@ -56,7 +56,7 @@

 struct _ClutterScrollActorPrivate
 {
-  ClutterPoint scroll_to;
+  graphene_point_t scroll_to;

  ClutterScrollMode scroll_mode;

@@ -84,9 +84,9 @@ enum
 static GParamSpec *obj_props[PROP_LAST] = { NULL, };
 static GParamSpec *animatable_props[ANIM_PROP_LAST] = { NULL, };

-static ClutterAnimatableIface *parent_animatable_iface = NULL;
+static ClutterAnimatableInterface *parent_animatable_iface = NULL;

-static void     clutter_animatable_iface_init   (ClutterAnimatableIface *iface);
+static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterScrollActor, clutter_scroll_actor, CLUTTER_TYPE_ACTOR,
                         G_ADD_PRIVATE (ClutterScrollActor)
@@ -94,19 +94,19 @@ G_DEFINE_TYPE_WITH_CODE (ClutterScrollActor, clutter_scroll_actor, CLUTTER_TYPE_
                                                clutter_animatable_iface_init))

 static void
-clutter_scroll_actor_set_scroll_to_internal (ClutterScrollActor *self,
-                                             const ClutterPoint *point)
+clutter_scroll_actor_set_scroll_to_internal (ClutterScrollActor     *self,
+                                             const graphene_point_t *point)
 {
  ClutterScrollActorPrivate *priv = self->priv;
  ClutterActor *actor = CLUTTER_ACTOR (self);
  ClutterMatrix m = CLUTTER_MATRIX_INIT_IDENTITY;
  float dx, dy;

-  if (clutter_point_equals (&priv->scroll_to, point))
+  if (graphene_point_equal (&priv->scroll_to, point))
    return;

  if (point == NULL)
-    clutter_point_init (&priv->scroll_to, 0.f, 0.f);
+    graphene_point_init (&priv->scroll_to, 0.f, 0.f);
  else
    priv->scroll_to = *point;

@@ -216,7 +216,7 @@ clutter_scroll_actor_set_final_state (ClutterAnimatable *animatable,
  if (strcmp (property_name, "scroll-to") == 0)
    {
      ClutterScrollActor *self = CLUTTER_SCROLL_ACTOR (animatable);
-      const ClutterPoint *point = g_value_get_boxed (value);
+      const graphene_point_t *point = g_value_get_boxed (value);

      clutter_scroll_actor_set_scroll_to_internal (self, point);
    }
@@ -240,7 +240,7 @@ clutter_scroll_actor_get_initial_state (ClutterAnimatable *animatable,
 }

 static void
-clutter_animatable_iface_init (ClutterAnimatableIface *iface)
+clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
 {
  parent_animatable_iface = g_type_interface_peek_parent (iface);

@@ -248,7 +248,7 @@ clutter_animatable_iface_init (ClutterAnimatableIface *iface)
    g_param_spec_boxed ("scroll-to",
                        "Scroll To",
                        "The point to scroll the actor to",
-                        CLUTTER_TYPE_POINT,
+                        GRAPHENE_TYPE_POINT,
                        G_PARAM_READWRITE |
                        G_PARAM_STATIC_STRINGS |
                        CLUTTER_PARAM_ANIMATABLE);
@@ -322,7 +322,7 @@ clutter_scroll_actor_get_scroll_mode (ClutterScrollActor *actor)
 /**
 * clutter_scroll_actor_scroll_to_point:
 * @actor: a #ClutterScrollActor
- * @point: a #ClutterPoint
+ * @point: a #graphene_point_t
 *
 * Scrolls the contents of @actor so that @point is the new origin
 * of the visible area.
@@ -335,8 +335,8 @@ clutter_scroll_actor_get_scroll_mode (ClutterScrollActor *actor)
 * Since: 1.12
 */
 void
-clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,
-                                      const ClutterPoint *point)
+clutter_scroll_actor_scroll_to_point (ClutterScrollActor     *actor,
+                                      const graphene_point_t *point)
 {
  ClutterScrollActorPrivate *priv;
  const ClutterAnimationInfo *info;
@@ -390,10 +390,10 @@ clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,

  /* if a transition already exist, update its bounds */
  clutter_transition_set_from (priv->transition,
-                               CLUTTER_TYPE_POINT,
+                               GRAPHENE_TYPE_POINT,
                               &priv->scroll_to);
  clutter_transition_set_to (priv->transition,
-                             CLUTTER_TYPE_POINT,
+                             GRAPHENE_TYPE_POINT,
                             point);

  /* always use the current easing state */
@@ -417,10 +417,10 @@ clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,
 * Since: 1.12
 */
 void
-clutter_scroll_actor_scroll_to_rect (ClutterScrollActor *actor,
-                                     const ClutterRect  *rect)
+clutter_scroll_actor_scroll_to_rect (ClutterScrollActor    *actor,
+                                     const graphene_rect_t *rect)
 {
-  ClutterRect n_rect;
+  graphene_rect_t n_rect;

  g_return_if_fail (CLUTTER_IS_SCROLL_ACTOR (actor));
  g_return_if_fail (rect != NULL);
@@ -428,7 +428,7 @@ clutter_scroll_actor_scroll_to_rect (ClutterScrollActor *actor,
  n_rect = *rect;

  /* normalize, so that we have a valid origin */
-  clutter_rect_normalize (&n_rect);
+  graphene_rect_normalize (&n_rect);

  clutter_scroll_actor_scroll_to_point (actor, &n_rect.origin);
 }
--- a/clutter/clutter/clutter-scroll-actor.h
+++ b/clutter/clutter/clutter-scroll-actor.h
@@ -86,11 +86,11 @@ CLUTTER_EXPORT
 ClutterScrollMode       clutter_scroll_actor_get_scroll_mode    (ClutterScrollActor *actor);

 CLUTTER_EXPORT
-void                    clutter_scroll_actor_scroll_to_point    (ClutterScrollActor *actor,
-                                                                 const ClutterPoint *point);
+void                    clutter_scroll_actor_scroll_to_point    (ClutterScrollActor     *actor,
+                                                                 const graphene_point_t *point);
 CLUTTER_EXPORT
-void                    clutter_scroll_actor_scroll_to_rect     (ClutterScrollActor *actor,
-                                                                 const ClutterRect  *rect);
+void                    clutter_scroll_actor_scroll_to_rect     (ClutterScrollActor    *actor,
+                                                                 const graphene_rect_t *rect);

 G_END_DECLS

--- a/clutter/clutter/clutter-shader-effect.c
+++ b/clutter/clutter/clutter-shader-effect.c
@@ -333,6 +333,7 @@ clutter_shader_effect_create_shader (ClutterShaderEffect *self)

    default:
      g_assert_not_reached ();
+      return COGL_INVALID_HANDLE;
    }
 }

--- a/clutter/clutter/clutter-stage-private.h
+++ b/clutter/clutter/clutter-stage-private.h
@@ -124,11 +124,16 @@ gboolean                _clutter_stage_update_state     (ClutterStage      *stag

 void                    _clutter_stage_set_scale_factor (ClutterStage      *stage,
                                                         int                factor);
+gboolean                _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
+                                                                           graphene_rect_t *rect,
+                                                                           float           *view_scale);

 void            _clutter_stage_presented                (ClutterStage      *stage,
                                                         CoglFrameEvent     frame_event,
                                                         ClutterFrameInfo  *frame_info);

+GList *         _clutter_stage_peek_stage_views         (ClutterStage *stage);
+
 G_END_DECLS

 #endif /* __CLUTTER_STAGE_PRIVATE_H__ */
--- a/clutter/clutter/clutter-stage-view.c
+++ b/clutter/clutter/clutter-stage-view.c
@@ -133,8 +133,8 @@ clutter_stage_view_blit_offscreen (ClutterStageView            *view,
   * the bottom right corner.
   */
  cogl_matrix_init_identity (&matrix);
-  cogl_matrix_translate (&matrix, -1, 1, 0);
  cogl_matrix_scale (&matrix, 2, -2, 0);
+  cogl_matrix_translate (&matrix, -1, 1, 0);
  cogl_framebuffer_set_projection_matrix (priv->framebuffer, &matrix);

  cogl_framebuffer_draw_rectangle (priv->framebuffer,
--- a/clutter/clutter/clutter-stage-window.c
+++ b/clutter/clutter/clutter-stage-window.c
@@ -14,10 +14,6 @@
 * #ClutterStage actor, abstracting away the specifics of the windowing system.
 */

-#define clutter_stage_window_get_type   _clutter_stage_window_get_type
-
-typedef ClutterStageWindowIface ClutterStageWindowInterface;
-
 G_DEFINE_INTERFACE (ClutterStageWindow, clutter_stage_window, G_TYPE_OBJECT);

 static void
@@ -60,7 +56,7 @@ void
 _clutter_stage_window_set_title (ClutterStageWindow *window,
                                 const gchar        *title)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  if (iface->set_title)
    iface->set_title (window, title);
@@ -70,7 +66,7 @@ void
 _clutter_stage_window_set_fullscreen (ClutterStageWindow *window,
                                      gboolean            is_fullscreen)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  if (iface->set_fullscreen)
    iface->set_fullscreen (window, is_fullscreen);
@@ -80,7 +76,7 @@ void
 _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                          gboolean            is_visible)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  if (iface->set_cursor_visible)
    iface->set_cursor_visible (window, is_visible);
@@ -138,7 +134,7 @@ void
 _clutter_stage_window_schedule_update  (ClutterStageWindow *window,
                                        int                 sync_delay)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

@@ -163,7 +159,7 @@ _clutter_stage_window_schedule_update  (ClutterStageWindow *window,
 gint64
 _clutter_stage_window_get_update_time (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), 0);

@@ -186,7 +182,7 @@ _clutter_stage_window_get_update_time (ClutterStageWindow *window)
 void
 _clutter_stage_window_clear_update_time (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

@@ -204,7 +200,7 @@ void
 _clutter_stage_window_add_redraw_clip (ClutterStageWindow    *window,
                                       cairo_rectangle_int_t *stage_clip)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

@@ -224,7 +220,7 @@ _clutter_stage_window_add_redraw_clip (ClutterStageWindow    *window,
 gboolean
 _clutter_stage_window_has_redraw_clips (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);

@@ -246,7 +242,7 @@ _clutter_stage_window_has_redraw_clips (ClutterStageWindow *window)
 gboolean
 _clutter_stage_window_ignoring_redraw_clips (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);

@@ -261,7 +257,7 @@ gboolean
 _clutter_stage_window_get_redraw_clip_bounds (ClutterStageWindow    *window,
                                              cairo_rectangle_int_t *stage_clip)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);

@@ -276,7 +272,7 @@ void
 _clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
                                        gboolean            accept_focus)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

@@ -288,7 +284,7 @@ _clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
 void
 _clutter_stage_window_redraw (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_if_fail (CLUTTER_IS_STAGE_WINDOW (window));

@@ -303,7 +299,7 @@ _clutter_stage_window_get_dirty_pixel (ClutterStageWindow *window,
                                       ClutterStageView   *view,
                                       int *x, int *y)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  *x = 0;
  *y = 0;
@@ -318,7 +314,7 @@ _clutter_stage_window_get_dirty_pixel (ClutterStageWindow *window,
 gboolean
 _clutter_stage_window_can_clip_redraws (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface;
+  ClutterStageWindowInterface *iface;

  g_return_val_if_fail (CLUTTER_IS_STAGE_WINDOW (window), FALSE);

@@ -332,7 +328,7 @@ _clutter_stage_window_can_clip_redraws (ClutterStageWindow *window)
 GList *
 _clutter_stage_window_get_views (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  return iface->get_views (window);
 }
@@ -340,7 +336,7 @@ _clutter_stage_window_get_views (ClutterStageWindow *window)
 void
 _clutter_stage_window_finish_frame (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  if (iface->finish_frame)
    iface->finish_frame (window);
@@ -349,7 +345,7 @@ _clutter_stage_window_finish_frame (ClutterStageWindow *window)
 int64_t
 _clutter_stage_window_get_frame_counter (ClutterStageWindow *window)
 {
-  ClutterStageWindowIface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);

  if (iface->get_frame_counter)
    return iface->get_frame_counter (window);
--- a/clutter/clutter/clutter-stage-window.h
+++ b/clutter/clutter/clutter-stage-window.h
@@ -7,30 +7,21 @@

 G_BEGIN_DECLS

-#define CLUTTER_TYPE_STAGE_WINDOW               (_clutter_stage_window_get_type ())
-#define CLUTTER_STAGE_WINDOW(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE_WINDOW, ClutterStageWindow))
-#define CLUTTER_IS_STAGE_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE_WINDOW))
-#define CLUTTER_STAGE_WINDOW_GET_IFACE(obj)     (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_STAGE_WINDOW, ClutterStageWindowIface))
+#define CLUTTER_TYPE_STAGE_WINDOW (clutter_stage_window_get_type ())
+
+CLUTTER_EXPORT
+G_DECLARE_INTERFACE (ClutterStageWindow, clutter_stage_window,
+                     CLUTTER, STAGE_WINDOW,
+                     GObject)

 /*
- * ClutterStageWindow: (skip)
- *
- * #ClutterStageWindow is an opaque structure
- * whose members should not be accessed directly
- *
- * Since: 0.8
- */
-typedef struct _ClutterStageWindow      ClutterStageWindow; /* dummy */
-typedef struct _ClutterStageWindowIface ClutterStageWindowIface;
-
-/*
- * ClutterStageWindowIface: (skip)
+ * ClutterStageWindowInterface: (skip)
 *
 * The interface implemented by backends for stage windows
 *
 * Since: 0.8
 */
-struct _ClutterStageWindowIface
+struct _ClutterStageWindowInterface
 {
  /*< private >*/
  GTypeInterface parent_iface;
@@ -88,9 +79,6 @@ struct _ClutterStageWindowIface
  void              (* finish_frame)            (ClutterStageWindow *stage_window);
 };

-CLUTTER_EXPORT
-GType _clutter_stage_window_get_type (void) G_GNUC_CONST;
-
 ClutterActor *    _clutter_stage_window_get_wrapper        (ClutterStageWindow *window);

 void              _clutter_stage_window_set_title          (ClutterStageWindow *window,
--- a/clutter/clutter/clutter-stage.c
+++ b/clutter/clutter/clutter-stage.c
@@ -87,7 +87,8 @@
 *
 * A series of hints that enable or disable behaviours on the stage
 */
-typedef enum { /*< prefix=CLUTTER_STAGE >*/
+typedef enum /*< prefix=CLUTTER_STAGE >*/
+{
  CLUTTER_STAGE_HINT_NONE = 0,

  CLUTTER_STAGE_NO_CLEAR_ON_PAINT = 1 << 0
@@ -113,8 +114,6 @@ struct _ClutterStagePrivate
  CoglMatrix view;
  float viewport[4];

-  ClutterFog fog;
-
  gchar *title;
  ClutterActor *key_focused_actor;

@@ -153,7 +152,6 @@ struct _ClutterStagePrivate
  guint is_fullscreen          : 1;
  guint is_cursor_visible      : 1;
  guint is_user_resizable      : 1;
-  guint use_fog                : 1;
  guint throttle_motion_events : 1;
  guint use_alpha              : 1;
  guint min_size_changed       : 1;
@@ -174,8 +172,6 @@ enum
  PROP_PERSPECTIVE,
  PROP_TITLE,
  PROP_USER_RESIZABLE,
-  PROP_USE_FOG,
-  PROP_FOG,
  PROP_USE_ALPHA,
  PROP_KEY_FOCUS,
  PROP_NO_CLEAR_HINT,
@@ -201,6 +197,12 @@ static const ClutterColor default_stage_color = { 255, 255, 255, 255 };

 static void clutter_stage_maybe_finish_queue_redraws (ClutterStage *stage);
 static void free_queue_redraw_entry (ClutterStageQueueRedrawEntry *entry);
+static void capture_view_into (ClutterStage          *stage,
+                               gboolean               paint,
+                               ClutterStageView      *view,
+                               cairo_rectangle_int_t *rect,
+                               uint8_t               *data,
+                               int                    stride);

 static void clutter_container_iface_init (ClutterContainerIface *iface);

@@ -507,8 +509,9 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
  Vector4 *tmp_poly;
  ClutterPlane *plane;
  int i;
-  float b[3];
-  float c[3];
+  Vector4 *poly;
+  graphene_vec3_t b;
+  graphene_vec3_t c;
  int count;

  tmp_poly = g_alloca (sizeof (Vector4) * n_vertices * 2);
@@ -529,7 +532,7 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
   * frustum; coordinates range from [-Wc,Wc] left to right on the
   * x-axis and [Wc,-Wc] top to bottom on the y-axis.
   */
-  Wc = DEPTH * projection->wz + projection->ww;
+  Wc = DEPTH * projection->zw + projection->ww;

 #define CLIP_X(X) ((((float)X - viewport[0]) * (2.0 / viewport[2])) - 1) * Wc
 #define CLIP_Y(Y) ((((float)Y - viewport[1]) * (2.0 / viewport[3])) - 1) * -Wc
@@ -542,7 +545,7 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
      tmp_poly[i].w = Wc;
    }

-  Wc = DEPTH * 2 * projection->wz + projection->ww;
+  Wc = DEPTH * 2 * projection->zw + projection->ww;

  /* FIXME: technically we don't need to project all of the points
   * twice, it would be enough project every other point since
@@ -575,23 +578,37 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
  for (i = 0; i < count; i++)
    {
      plane = &planes[i];
-      memcpy (plane->v0, tmp_poly + i, sizeof (float) * 3);
-      memcpy (b, tmp_poly + n_vertices + i, sizeof (float) * 3);
-      memcpy (c, tmp_poly + n_vertices + i + 1, sizeof (float) * 3);
-      cogl_vector3_subtract (b, b, plane->v0);
-      cogl_vector3_subtract (c, c, plane->v0);
-      cogl_vector3_cross_product (plane->n, b, c);
-      cogl_vector3_normalize (plane->n);
+
+      poly = &tmp_poly[i];
+      graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
+
+      poly = &tmp_poly[n_vertices + i];
+      graphene_vec3_init (&b, poly->x, poly->y, poly->z);
+
+      poly = &tmp_poly[n_vertices + i + 1];
+      graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+      graphene_vec3_subtract (&b, &plane->v0, &b);
+      graphene_vec3_subtract (&c, &plane->v0, &c);
+      graphene_vec3_cross (&b, &c, &plane->n);
+      graphene_vec3_normalize (&plane->n, &plane->n);
    }

  plane = &planes[n_vertices - 1];
-  memcpy (plane->v0, tmp_poly + 0, sizeof (float) * 3);
-  memcpy (b, tmp_poly + (2 * n_vertices - 1), sizeof (float) * 3);
-  memcpy (c, tmp_poly + n_vertices, sizeof (float) * 3);
-  cogl_vector3_subtract (b, b, plane->v0);
-  cogl_vector3_subtract (c, c, plane->v0);
-  cogl_vector3_cross_product (plane->n, b, c);
-  cogl_vector3_normalize (plane->n);
+
+  poly = &tmp_poly[0];
+  graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
+
+  poly = &tmp_poly[2 * n_vertices - 1];
+  graphene_vec3_init (&b, poly->x, poly->y, poly->z);
+
+  poly = &tmp_poly[n_vertices];
+  graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+  graphene_vec3_subtract (&b, &plane->v0, &b);
+  graphene_vec3_subtract (&c, &plane->v0, &c);
+  graphene_vec3_cross (&b, &c, &plane->n);
+  graphene_vec3_normalize (&plane->n, &plane->n);
 }

 static void
@@ -1147,7 +1164,7 @@ _clutter_stage_check_updated_pointers (ClutterStage *stage)
  GSList *updating = NULL;
  const GSList *devices;
  cairo_rectangle_int_t clip;
-  ClutterPoint point;
+  graphene_point_t point;
  gboolean has_clip;

  has_clip = _clutter_stage_window_get_redraw_clip_bounds (priv->impl, &clip);
@@ -1274,45 +1291,44 @@ clutter_stage_real_queue_relayout (ClutterActor *self)
  parent_class->queue_relayout (self);
 }

-static void
-clutter_stage_real_queue_redraw (ClutterActor *actor,
-                                 ClutterActor *leaf)
+static gboolean
+clutter_stage_real_queue_redraw (ClutterActor       *actor,
+                                 ClutterActor       *leaf,
+                                 ClutterPaintVolume *redraw_clip)
 {
  ClutterStage *stage = CLUTTER_STAGE (actor);
  ClutterStageWindow *stage_window;
-  ClutterPaintVolume *redraw_clip;
  ClutterActorBox bounding_box;
  ClutterActorBox intersection_box;
  cairo_rectangle_int_t geom, stage_clip;

  if (CLUTTER_ACTOR_IN_DESTRUCTION (actor))
-    return;
+    return TRUE;

  /* If the backend can't do anything with redraw clips (e.g. it already knows
   * it needs to redraw everything anyway) then don't spend time transforming
   * any clip volume into stage coordinates... */
  stage_window = _clutter_stage_get_window (stage);
  if (stage_window == NULL)
-    return;
+    return TRUE;

  if (_clutter_stage_window_ignoring_redraw_clips (stage_window))
    {
      _clutter_stage_window_add_redraw_clip (stage_window, NULL);
-      return;
+      return FALSE;
    }

  /* Convert the clip volume into stage coordinates and then into an
   * axis aligned stage coordinates bounding box...
   */
-  redraw_clip = _clutter_actor_get_queue_redraw_clip (leaf);
  if (redraw_clip == NULL)
    {
      _clutter_stage_window_add_redraw_clip (stage_window, NULL);
-      return;
+      return FALSE;
    }

  if (redraw_clip->is_empty)
-    return;
+    return TRUE;

  _clutter_paint_volume_get_stage_paint_box (redraw_clip,
                                             stage,
@@ -1328,7 +1344,7 @@ clutter_stage_real_queue_redraw (ClutterActor *actor,
  /* There is no need to track degenerate/empty redraw clips */
  if (intersection_box.x2 <= intersection_box.x1 ||
      intersection_box.y2 <= intersection_box.y1)
-    return;
+    return TRUE;

  /* when converting to integer coordinates make sure we round the edges of the
   * clip rectangle outwards... */
@@ -1338,6 +1354,7 @@ clutter_stage_real_queue_redraw (ClutterActor *actor,
  stage_clip.height = intersection_box.y2 - stage_clip.y;

  _clutter_stage_window_add_redraw_clip (stage_window, &stage_clip);
+  return FALSE;
 }

 gboolean
@@ -1474,8 +1491,8 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
  if (G_LIKELY (!(clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS)))
    {
      CLUTTER_NOTE (PICK, "Pushing pick scissor clip x: %d, y: %d, 1x1",
-                    (int) dirty_x * fb_scale,
-                    (int) dirty_y * fb_scale);
+                    (int) (dirty_x * fb_scale),
+                    (int) (dirty_y * fb_scale));
      cogl_framebuffer_push_scissor_clip (fb, dirty_x * fb_scale, dirty_y * fb_scale, 1, 1);
    }

@@ -1495,7 +1512,7 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
  read_x = dirty_x * fb_scale;
  read_y = dirty_y * fb_scale;

-  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %d",
+  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %f",
                x, y,
                view_layout.width, view_layout.height,
                view_layout.x, view_layout.y, fb_scale);
@@ -1720,14 +1737,6 @@ clutter_stage_set_property (GObject      *object,
      clutter_stage_set_user_resizable (stage, g_value_get_boolean (value));
      break;

-    case PROP_USE_FOG:
-      clutter_stage_set_use_fog (stage, g_value_get_boolean (value));
-      break;
-
-    case PROP_FOG:
-      clutter_stage_set_fog (stage, g_value_get_boxed (value));
-      break;
-
    case PROP_USE_ALPHA:
      clutter_stage_set_use_alpha (stage, g_value_get_boolean (value));
      break;
@@ -1794,14 +1803,6 @@ clutter_stage_get_property (GObject    *gobject,
      g_value_set_boolean (value, priv->is_user_resizable);
      break;

-    case PROP_USE_FOG:
-      g_value_set_boolean (value, priv->use_fog);
-      break;
-
-    case PROP_FOG:
-      g_value_set_boxed (value, &priv->fog);
-      break;
-
    case PROP_USE_ALPHA:
      g_value_set_boolean (value, priv->use_alpha);
      break;
@@ -2028,41 +2029,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
                               CLUTTER_PARAM_READWRITE);
  g_object_class_install_property (gobject_class, PROP_TITLE, pspec);

-  /**
-   * ClutterStage:use-fog:
-   *
-   * Whether the stage should use a linear GL "fog" in creating the
-   * depth-cueing effect, to enhance the perception of depth by fading
-   * actors farther from the viewpoint.
-   *
-   * Since: 0.6
-   *
-   * Deprecated: 1.10: This property does not do anything.
-   */
-  pspec = g_param_spec_boolean ("use-fog",
-                                P_("Use Fog"),
-                                P_("Whether to enable depth cueing"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_USE_FOG, pspec);
-
-  /**
-   * ClutterStage:fog:
-   *
-   * The settings for the GL "fog", used only if #ClutterStage:use-fog
-   * is set to %TRUE
-   *
-   * Since: 1.0
-   *
-   * Deprecated: 1.10: This property does not do anything.
-   */
-  pspec = g_param_spec_boxed ("fog",
-                              P_("Fog"),
-                              P_("Settings for the depth cueing"),
-                              CLUTTER_TYPE_FOG,
-                              CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_FOG, pspec);
-
  /**
   * ClutterStage:use-alpha:
   *
@@ -2315,7 +2281,6 @@ clutter_stage_init (ClutterStage *self)
  priv->is_fullscreen = FALSE;
  priv->is_user_resizable = FALSE;
  priv->is_cursor_visible = TRUE;
-  priv->use_fog = FALSE;
  priv->throttle_motion_events = TRUE;
  priv->min_size_changed = FALSE;
  priv->sync_delay = -1;
@@ -2353,11 +2318,6 @@ clutter_stage_init (ClutterStage *self)
                                      geom.width,
                                      geom.height);

-
-  /* FIXME - remove for 2.0 */
-  priv->fog.z_near = 1.0;
-  priv->fog.z_far  = 2.0;
-
  priv->relayout_pending = TRUE;

  clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
@@ -2742,7 +2702,7 @@ clutter_stage_set_fullscreen (ClutterStage *stage,
  if (priv->is_fullscreen != fullscreen)
    {
      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowIface *iface;
+      ClutterStageWindowInterface *iface;

      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);

@@ -2807,7 +2767,7 @@ clutter_stage_set_user_resizable (ClutterStage *stage,
      && priv->is_user_resizable != resizable)
    {
      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowIface *iface;
+      ClutterStageWindowInterface *iface;

      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
      if (iface->set_user_resizable)
@@ -2856,7 +2816,7 @@ clutter_stage_show_cursor (ClutterStage *stage)
  if (!priv->is_cursor_visible)
    {
      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowIface *iface;
+      ClutterStageWindowInterface *iface;

      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
      if (iface->set_cursor_visible)
@@ -2889,7 +2849,7 @@ clutter_stage_hide_cursor (ClutterStage *stage)
  if (priv->is_cursor_visible)
    {
      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
-      ClutterStageWindowIface *iface;
+      ClutterStageWindowInterface *iface;

      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
      if (iface->set_cursor_visible)
@@ -2937,6 +2897,9 @@ clutter_stage_read_pixels (ClutterStage *stage,
  cairo_region_t *clip;
  cairo_rectangle_int_t clip_rect;
  CoglFramebuffer *framebuffer;
+  float view_scale;
+  float pixel_width;
+  float pixel_height;
  uint8_t *pixels;

  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
@@ -2979,10 +2942,15 @@ clutter_stage_read_pixels (ClutterStage *stage,
  cogl_push_framebuffer (framebuffer);
  clutter_stage_do_paint_view (stage, view, &clip_rect);

-  pixels = g_malloc0 (clip_rect.width * clip_rect.height * 4);
+  view_scale = clutter_stage_view_get_scale (view);
+  pixel_width = roundf (clip_rect.width * view_scale);
+  pixel_height = roundf (clip_rect.height * view_scale);
+
+  pixels = g_malloc0 (pixel_width * pixel_height * 4);
  cogl_framebuffer_read_pixels (framebuffer,
-                                clip_rect.x, clip_rect.y,
-                                clip_rect.width, clip_rect.height,
+                                clip_rect.x * view_scale,
+                                clip_rect.y * view_scale,
+                                pixel_width, pixel_height,
                                COGL_PIXEL_FORMAT_RGBA_8888,
                                pixels);

@@ -3242,136 +3210,6 @@ clutter_stage_get_key_focus (ClutterStage *stage)
  return CLUTTER_ACTOR (stage);
 }

-/**
- * clutter_stage_get_use_fog:
- * @stage: the #ClutterStage
- *
- * Gets whether the depth cueing effect is enabled on @stage.
- *
- * Return value: %TRUE if the depth cueing effect is enabled
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: This function will always return %FALSE
- */
-gboolean
-clutter_stage_get_use_fog (ClutterStage *stage)
-{
-  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
-
-  return stage->priv->use_fog;
-}
-
-/**
- * clutter_stage_set_use_fog:
- * @stage: the #ClutterStage
- * @fog: %TRUE for enabling the depth cueing effect
- *
- * Sets whether the depth cueing effect on the stage should be enabled
- * or not.
- *
- * Depth cueing is a 3D effect that makes actors farther away from the
- * viewing point less opaque, by fading them with the stage color.
-
- * The parameters of the GL fog used can be changed using the
- * clutter_stage_set_fog() function.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: Calling this function produces no visible effect
- */
-void
-clutter_stage_set_use_fog (ClutterStage *stage,
-                           gboolean      fog)
-{
-}
-
-/**
- * clutter_stage_set_fog:
- * @stage: the #ClutterStage
- * @fog: a #ClutterFog structure
- *
- * Sets the fog (also known as "depth cueing") settings for the @stage.
- *
- * A #ClutterStage will only use a linear fog progression, which
- * depends solely on the distance from the viewer. The cogl_set_fog()
- * function in COGL exposes more of the underlying implementation,
- * and allows changing the for progression function. It can be directly
- * used by disabling the #ClutterStage:use-fog property and connecting
- * a signal handler to the #ClutterActor::paint signal on the @stage,
- * like:
- *
- * |[
- *   clutter_stage_set_use_fog (stage, FALSE);
- *   g_signal_connect (stage, "paint", G_CALLBACK (on_stage_paint), NULL);
- * ]|
- *
- * The paint signal handler will call cogl_set_fog() with the
- * desired settings:
- *
- * |[
- *   static void
- *   on_stage_paint (ClutterActor *actor)
- *   {
- *     ClutterColor stage_color = { 0, };
- *     CoglColor fog_color = { 0, };
- *
- *     // set the fog color to the stage background color
- *     clutter_stage_get_color (CLUTTER_STAGE (actor), &stage_color);
- *     cogl_color_init_from_4ub (&fog_color,
- *                               stage_color.red,
- *                               stage_color.green,
- *                               stage_color.blue,
- *                               stage_color.alpha);
- *
- *     // enable fog //
- *     cogl_set_fog (&fog_color,
- *                   COGL_FOG_MODE_EXPONENTIAL, // mode
- *                   0.5,                       // density
- *                   5.0, 30.0);                // z_near and z_far
- *   }
- * ]|
- *
- * The fogging functions only work correctly when the visible actors use
- * unmultiplied alpha colors. By default Cogl will premultiply textures and
- * cogl_set_source_color() will premultiply colors, so unless you explicitly
- * load your textures requesting an unmultiplied internal format and use
- * cogl_material_set_color() you can only use fogging with fully opaque actors.
- * Support for premultiplied colors will improve in the future when we can
- * depend on fragment shaders.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: Fog settings are ignored.
- */
-void
-clutter_stage_set_fog (ClutterStage *stage,
-                       ClutterFog   *fog)
-{
-}
-
-/**
- * clutter_stage_get_fog:
- * @stage: the #ClutterStage
- * @fog: (out): return location for a #ClutterFog structure
- *
- * Retrieves the current depth cueing settings from the stage.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: This function will always return the default
- *   values of #ClutterFog
- */
-void
-clutter_stage_get_fog (ClutterStage *stage,
-                        ClutterFog   *fog)
-{
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-  g_return_if_fail (fog != NULL);
-
-  *fog = stage->priv->fog;
-}
-
 /*** Perspective boxed type ******/

 static gpointer
@@ -3394,24 +3232,6 @@ G_DEFINE_BOXED_TYPE (ClutterPerspective, clutter_perspective,
                     clutter_perspective_copy,
                     clutter_perspective_free);

-static gpointer
-clutter_fog_copy (gpointer data)
-{
-  if (G_LIKELY (data))
-    return g_slice_dup (ClutterFog, data);
-
-  return NULL;
-}
-
-static void
-clutter_fog_free (gpointer data)
-{
-  if (G_LIKELY (data))
-    g_slice_free (ClutterFog, data);
-}
-
-G_DEFINE_BOXED_TYPE (ClutterFog, clutter_fog, clutter_fog_copy, clutter_fog_free);
-
 /**
 * clutter_stage_new:
 *
@@ -4756,62 +4576,33 @@ static void
 capture_view (ClutterStage          *stage,
              gboolean               paint,
              ClutterStageView      *view,
-              cairo_rectangle_int_t *rect,
              ClutterCapture        *capture)
 {
-  CoglFramebuffer *framebuffer;
-  ClutterBackend *backend;
-  CoglContext *context;
  cairo_surface_t *image;
  uint8_t *data;
  int stride;
-  CoglBitmap *bitmap;
-  cairo_rectangle_int_t view_layout;
+  cairo_rectangle_int_t *rect;
  float view_scale;
+  float texture_width;
+  float texture_height;

-  framebuffer = clutter_stage_view_get_framebuffer (view);
-
-  if (paint)
-    {
-      cogl_push_framebuffer (framebuffer);
-      _clutter_stage_maybe_setup_viewport (stage, view);
-      clutter_stage_do_paint_view (stage, view, rect);
-    }
+  rect = &capture->rect;

  view_scale = clutter_stage_view_get_scale (view);
+  texture_width = roundf (rect->width * view_scale);
+  texture_height = roundf (rect->height * view_scale);
  image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
-                                      rect->width * view_scale,
-                                      rect->height * view_scale);
+                                      texture_width, texture_height);
  cairo_surface_set_device_scale (image, view_scale, view_scale);

+
  data = cairo_image_surface_get_data (image);
  stride = cairo_image_surface_get_stride (image);

-  backend = clutter_get_default_backend ();
-  context = clutter_backend_get_cogl_context (backend);
-  bitmap = cogl_bitmap_new_for_data (context,
-                                     rect->width * view_scale,
-                                     rect->height * view_scale,
-                                     CLUTTER_CAIRO_FORMAT_ARGB32,
-                                     stride,
-                                     data);
-
-  clutter_stage_view_get_layout (view, &view_layout);
-
-  cogl_framebuffer_read_pixels_into_bitmap (framebuffer,
-                                            (rect->x - view_layout.x) * view_scale,
-                                            (rect->y - view_layout.y) * view_scale,
-                                            COGL_READ_PIXELS_COLOR_BUFFER,
-                                            bitmap);
-
-  if (paint)
-    cogl_pop_framebuffer ();
-
-  capture->rect = *rect;
+  capture_view_into (stage, paint, view, rect, data, stride);
  capture->image = image;

  cairo_surface_mark_dirty (capture->image);
-  cogl_object_unref (bitmap);
 }

 gboolean
@@ -4827,34 +4618,91 @@ clutter_stage_capture (ClutterStage          *stage,
  ClutterCapture *captures;
  int n_captures;

+  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
+
  captures = g_new0 (ClutterCapture, g_list_length (views));
  n_captures = 0;

  for (l = views; l; l = l->next)
    {
      ClutterStageView *view = l->data;
+      ClutterCapture *capture;
      cairo_rectangle_int_t view_layout;
      cairo_region_t *region;
-      cairo_rectangle_int_t view_capture_rect;

      clutter_stage_view_get_layout (view, &view_layout);
      region = cairo_region_create_rectangle (&view_layout);
      cairo_region_intersect_rectangle (region, rect);
-      cairo_region_get_extents (region, &view_capture_rect);
+
+      capture = &captures[n_captures];
+      cairo_region_get_extents (region, &capture->rect);
      cairo_region_destroy (region);

-      if (view_capture_rect.width == 0 || view_capture_rect.height == 0)
+      if (capture->rect.width == 0 || capture->rect.height == 0)
        continue;

-      capture_view (stage, paint, view, &view_capture_rect,
-                    &captures[n_captures]);
+      capture_view (stage, paint, view, capture);

      n_captures++;
    }

+  if (n_captures == 0)
+    g_clear_pointer (&captures, g_free);
+
  *out_captures = captures;
  *out_n_captures = n_captures;

+  return n_captures > 0;
+}
+
+gboolean
+clutter_stage_get_capture_final_size (ClutterStage          *stage,
+                                      cairo_rectangle_int_t *rect,
+                                      int                   *out_width,
+                                      int                   *out_height,
+                                      float                 *out_scale)
+{
+  float max_scale;
+
+  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
+
+  if (rect)
+    {
+      graphene_rect_t capture_rect;
+
+      _clutter_util_rect_from_rectangle (rect, &capture_rect);
+      if (!_clutter_stage_get_max_view_scale_factor_for_rect (stage,
+                                                              &capture_rect,
+                                                              &max_scale))
+        return FALSE;
+
+      if (out_width)
+        *out_width = (gint) roundf (rect->width * max_scale);
+
+      if (out_height)
+        *out_height = (gint) roundf (rect->height * max_scale);
+    }
+  else
+    {
+      ClutterActorBox alloc;
+      float stage_width, stage_height;
+
+      clutter_actor_get_allocation_box (CLUTTER_ACTOR (stage), &alloc);
+      clutter_actor_box_get_size (&alloc, &stage_width, &stage_height);
+      if (!_clutter_actor_get_real_resource_scale (CLUTTER_ACTOR (stage),
+                                                   &max_scale))
+        return FALSE;
+
+      if (out_width)
+        *out_width = (gint) roundf (stage_width * max_scale);
+
+      if (out_height)
+        *out_height = (gint) roundf (stage_height * max_scale);
+    }
+
+  if (out_scale)
+    *out_scale = max_scale;
+
  return TRUE;
 }

@@ -4871,6 +4719,11 @@ capture_view_into (ClutterStage          *stage,
  CoglContext *context;
  CoglBitmap *bitmap;
  cairo_rectangle_int_t view_layout;
+  float view_scale;
+  float texture_width;
+  float texture_height;
+
+  g_return_if_fail (CLUTTER_IS_STAGE (stage));

  framebuffer = clutter_stage_view_get_framebuffer (view);

@@ -4881,10 +4734,14 @@ capture_view_into (ClutterStage          *stage,
      clutter_stage_do_paint_view (stage, view, rect);
    }

+  view_scale = clutter_stage_view_get_scale (view);
+  texture_width = roundf (rect->width * view_scale);
+  texture_height = roundf (rect->height * view_scale);
+
  backend = clutter_get_default_backend ();
  context = clutter_backend_get_cogl_context (backend);
  bitmap = cogl_bitmap_new_for_data (context,
-                                     rect->width, rect->height,
+                                     texture_width, texture_height,
                                     CLUTTER_CAIRO_FORMAT_ARGB32,
                                     stride,
                                     data);
@@ -4892,8 +4749,8 @@ capture_view_into (ClutterStage          *stage,
  clutter_stage_view_get_layout (view, &view_layout);

  cogl_framebuffer_read_pixels_into_bitmap (framebuffer,
-                                            rect->x - view_layout.x,
-                                            rect->y - view_layout.y,
+                                            roundf ((rect->x - view_layout.x) * view_scale),
+                                            roundf ((rect->y - view_layout.y) * view_scale),
                                            COGL_READ_PIXELS_COLOR_BUFFER,
                                            bitmap);

@@ -5002,3 +4859,46 @@ clutter_stage_thaw_updates (ClutterStage *stage)
      _clutter_master_clock_set_paused (master_clock, FALSE);
    }
 }
+
+GList *
+_clutter_stage_peek_stage_views (ClutterStage *stage)
+{
+  ClutterStagePrivate *priv = stage->priv;
+
+  return _clutter_stage_window_get_views (priv->impl);
+}
+
+void
+clutter_stage_update_resource_scales (ClutterStage *stage)
+{
+  _clutter_actor_queue_update_resource_scale_recursive (CLUTTER_ACTOR (stage));
+}
+
+gboolean
+_clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
+                                                   graphene_rect_t *rect,
+                                                   float           *view_scale)
+{
+  ClutterStagePrivate *priv = stage->priv;
+  float scale = 0.0f;
+  GList *l;
+
+  for (l = _clutter_stage_window_get_views (priv->impl); l; l = l->next)
+    {
+      ClutterStageView *view = l->data;
+      cairo_rectangle_int_t view_layout;
+      graphene_rect_t view_rect;
+
+      clutter_stage_view_get_layout (view, &view_layout);
+      _clutter_util_rect_from_rectangle (&view_layout, &view_rect);
+
+      if (graphene_rect_intersection (&view_rect, rect, NULL))
+        scale = MAX (clutter_stage_view_get_scale (view), scale);
+    }
+
+  if (scale == 0.0)
+    return FALSE;
+
+  *view_scale = scale;
+  return TRUE;
+}
--- a/clutter/clutter/clutter-stage.h
+++ b/clutter/clutter/clutter-stage.h
@@ -115,26 +115,6 @@ struct _ClutterPerspective
  gfloat z_far;
 };

-/**
- * ClutterFog:
- * @z_near: starting distance from the viewer to the near clipping
- *   plane (always positive)
- * @z_far: final distance from the viewer to the far clipping
- *   plane (always positive)
- *
- * Fog settings used to create the depth cueing effect.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: The fog-related API in #ClutterStage has been
- *   deprecated as well.
- */
-struct _ClutterFog
-{
-  gfloat z_near;
-  gfloat z_far;
-};
-
 /**
 * ClutterFrameInfo: (skip)
 */
@@ -153,8 +133,6 @@ typedef struct _ClutterCapture

 CLUTTER_EXPORT
 GType clutter_perspective_get_type (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-GType clutter_fog_get_type (void) G_GNUC_CONST;
 CLUTTER_EXPORT
 GType clutter_stage_get_type (void) G_GNUC_CONST;

@@ -261,6 +239,13 @@ CLUTTER_EXPORT
 void            clutter_stage_skip_sync_delay                   (ClutterStage          *stage);
 #endif

+CLUTTER_EXPORT
+gboolean clutter_stage_get_capture_final_size (ClutterStage          *stage,
+                                               cairo_rectangle_int_t *rect,
+                                               int                   *width,
+                                               int                   *height,
+                                               float                 *scale);
+
 CLUTTER_EXPORT
 gboolean clutter_stage_capture (ClutterStage          *stage,
                                gboolean               paint,
--- a/clutter/clutter/clutter-test-utils.c
+++ b/clutter/clutter/clutter-test-utils.c
@@ -273,7 +273,7 @@ clutter_test_run (void)
 typedef struct {
  ClutterActor *stage;

-  ClutterPoint point;
+  graphene_point_t point;

  gpointer result;

@@ -348,10 +348,10 @@ on_key_press_event (ClutterActor *stage,
 * Since: 1.18
 */
 gboolean
-clutter_test_check_actor_at_point (ClutterActor        *stage,
-                                   const ClutterPoint  *point,
-                                   ClutterActor        *actor,
-                                   ClutterActor       **result)
+clutter_test_check_actor_at_point (ClutterActor            *stage,
+                                   const graphene_point_t  *point,
+                                   ClutterActor            *actor,
+                                   ClutterActor           **result)
 {
  ValidateData *data;
  guint press_id = 0;
@@ -410,10 +410,10 @@ clutter_test_check_actor_at_point (ClutterActor        *stage,
 * Since: 1.18
 */
 gboolean
-clutter_test_check_color_at_point (ClutterActor       *stage,
-                                   const ClutterPoint *point,
-                                   const ClutterColor *color,
-                                   ClutterColor       *result)
+clutter_test_check_color_at_point (ClutterActor           *stage,
+                                   const graphene_point_t *point,
+                                   const ClutterColor     *color,
+                                   ClutterColor           *result)
 {
  ValidateData *data;
  gboolean retval;
--- a/clutter/clutter/clutter-test-utils.h
+++ b/clutter/clutter/clutter-test-utils.h
@@ -112,7 +112,7 @@ ClutterActor *  clutter_test_get_stage          (void);

 #define clutter_test_assert_actor_at_point(stage,point,actor) \
 G_STMT_START { \
-  const ClutterPoint *__p = (point); \
+  const graphene_point_t *__p = (point); \
  ClutterActor *__actor = (actor); \
  ClutterActor *__stage = (stage); \
  ClutterActor *__res; \
@@ -132,7 +132,7 @@ G_STMT_START { \

 #define clutter_test_assert_color_at_point(stage,point,color) \
 G_STMT_START { \
-  const ClutterPoint *__p = (point); \
+  const graphene_point_t *__p = (point); \
  const ClutterColor *__c = (color); \
  ClutterActor *__stage = (stage); \
  ClutterColor __res; \
@@ -149,15 +149,15 @@ G_STMT_START { \
 } G_STMT_END

 CLUTTER_EXPORT
-gboolean        clutter_test_check_actor_at_point       (ClutterActor       *stage,
-                                                         const ClutterPoint *point,
-                                                         ClutterActor       *actor,
-                                                         ClutterActor      **result);
+gboolean        clutter_test_check_actor_at_point       (ClutterActor            *stage,
+                                                         const graphene_point_t  *point,
+                                                         ClutterActor            *actor,
+                                                         ClutterActor           **result);
 CLUTTER_EXPORT
-gboolean        clutter_test_check_color_at_point       (ClutterActor       *stage,
-                                                         const ClutterPoint *point,
-                                                         const ClutterColor *color,
-                                                         ClutterColor       *result);
+gboolean        clutter_test_check_color_at_point       (ClutterActor           *stage,
+                                                         const graphene_point_t *point,
+                                                         const ClutterColor     *color,
+                                                         ClutterColor           *result);

 G_END_DECLS

--- a/clutter/clutter/clutter-text-buffer.c
+++ b/clutter/clutter/clutter-text-buffer.c
@@ -50,7 +50,8 @@
 /* Initial size of buffer, in bytes */
 #define MIN_SIZE 16

-enum {
+enum
+{
  PROP_0,
  PROP_TEXT,
  PROP_LENGTH,
@@ -60,7 +61,8 @@ enum {

 static GParamSpec *obj_props[PROP_LAST] = { NULL, };

-enum {
+enum
+{
  INSERTED_TEXT,
  DELETED_TEXT,
  LAST_SIGNAL
--- a/clutter/clutter/clutter-text.c
+++ b/clutter/clutter/clutter-text.c
@@ -144,18 +144,20 @@ struct _ClutterTextPrivate
   */
  gint x_pos;

-  /* the x position of the PangoLayout when in
-   * single line mode, to scroll the contents of the
+  /* the x position of the PangoLayout (in both physical and logical pixels)
+   * when in single line mode, to scroll the contents of the
   * text actor
   */
  gint text_x;
+  gint text_logical_x;

-  /* the y position of the PangoLayout, fixed to 0 by
-   * default for now */
+  /* the y position of the PangoLayout (in both physical and logical pixels),
+   * fixed to 0 by default for now */
  gint text_y;
+  gint text_logical_y;

  /* Where to draw the cursor */
-  ClutterRect cursor_rect;
+  graphene_rect_t cursor_rect;
  ClutterColor cursor_color;
  guint cursor_size;

@@ -185,6 +187,9 @@ struct _ClutterTextPrivate
  ClutterInputContentHintFlags input_hints;
  ClutterInputContentPurpose input_purpose;

+  /* Signal handler for when the :resource-scale changes */
+  guint resource_scale_changed_id;
+
  /* bitfields */
  guint alignment               : 2;
  guint wrap                    : 1;
@@ -279,7 +284,7 @@ static const ClutterColor default_selected_text_color = {   0,   0,   0, 255 };

 static CoglPipeline *default_color_pipeline = NULL;

-static ClutterAnimatableIface *parent_animatable_iface = NULL;
+static ClutterAnimatableInterface *parent_animatable_iface = NULL;
 static ClutterScriptableIface *parent_scriptable_iface = NULL;

 /* ClutterTextInputFocus */
@@ -290,6 +295,33 @@ G_DECLARE_FINAL_TYPE (ClutterTextInputFocus, clutter_text_input_focus,
 G_DEFINE_TYPE (ClutterTextInputFocus, clutter_text_input_focus,
               CLUTTER_TYPE_INPUT_FOCUS)

+/* Utilities pango to (logical) pixels functions */
+static float
+pixels_to_pango (float px)
+{
+  return ceilf (px * (float) PANGO_SCALE);
+}
+
+static float
+logical_pixels_to_pango (float px,
+                         float scale)
+{
+  return pixels_to_pango (px * scale);
+}
+
+static float
+pango_to_pixels (float size)
+{
+  return ceilf (size / (float) PANGO_SCALE);
+}
+
+static float
+pango_to_logical_pixels (float size,
+                         float scale)
+{
+  return pango_to_pixels (size / scale);
+}
+
 static void
 clutter_text_input_focus_request_surrounding (ClutterInputFocus *focus)
 {
@@ -389,7 +421,7 @@ clutter_text_input_focus_new (ClutterText *text)

 /* ClutterText */
 static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
-static void clutter_animatable_iface_init (ClutterAnimatableIface *iface);
+static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterText,
                         clutter_text,
@@ -550,6 +582,63 @@ clutter_text_get_display_text (ClutterText *self)
    }
 }

+static void
+ensure_effective_pango_scale_attribute (ClutterText *self)
+{
+  float resource_scale;
+  ClutterTextPrivate *priv = self->priv;
+
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale) ||
+      resource_scale == 1.0)
+    return;
+
+  if (priv->effective_attrs != NULL)
+    {
+      PangoAttrIterator *iter;
+      PangoAttribute *scale_attrib;
+      PangoAttrList *old_attributes;
+
+      old_attributes = priv->effective_attrs;
+      priv->effective_attrs = pango_attr_list_copy (priv->effective_attrs);
+      pango_attr_list_unref (old_attributes);
+
+      iter = pango_attr_list_get_iterator (priv->effective_attrs);
+      scale_attrib = pango_attr_iterator_get (iter, PANGO_ATTR_SCALE);
+
+      if (scale_attrib != NULL)
+        resource_scale *= ((PangoAttrFloat *) scale_attrib)->value;
+
+      pango_attr_iterator_destroy (iter);
+    }
+  else
+    priv->effective_attrs = pango_attr_list_new ();
+
+  pango_attr_list_change (priv->effective_attrs,
+                          pango_attr_scale_new (resource_scale));
+}
+
+static void
+set_effective_pango_attributes (ClutterText   *self,
+                                PangoAttrList *attributes)
+{
+  ClutterTextPrivate *priv = self->priv;
+
+  if (attributes != NULL)
+    {
+      PangoAttrList *old_attributes = priv->effective_attrs;
+      priv->effective_attrs = pango_attr_list_ref (attributes);
+
+      if (old_attributes != NULL)
+        pango_attr_list_unref (old_attributes);
+    }
+  else
+    {
+      g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref);
+    }
+
+  ensure_effective_pango_scale_attribute (self);
+}
+
 static inline void
 clutter_text_ensure_effective_attributes (ClutterText *self)
 {
@@ -563,21 +652,25 @@ clutter_text_ensure_effective_attributes (ClutterText *self)
  /* Same as if we don't have any attribute at all.
   * We also ignore markup attributes for editable. */
  if (priv->attrs == NULL && (priv->editable || priv->markup_attrs == NULL))
-    return;
+    {
+      set_effective_pango_attributes (self, NULL);
+      return;
+    }

  if (priv->attrs != NULL)
    {
      /* If there are no markup attributes, or if this is editable (in which
       * case we ignore markup), then we can just use these attrs directly */
      if (priv->editable || priv->markup_attrs == NULL)
-        priv->effective_attrs = pango_attr_list_ref (priv->attrs);
+        set_effective_pango_attributes (self, priv->attrs);
      else
        {
          /* Otherwise we need to merge the two lists */
+          PangoAttrList *effective_attrs;
          PangoAttrIterator *iter;
          GSList *attributes, *l;

-          priv->effective_attrs = pango_attr_list_copy (priv->markup_attrs);
+          effective_attrs = pango_attr_list_copy (priv->markup_attrs);

          iter = pango_attr_list_get_iterator (priv->attrs);
          do
@@ -588,7 +681,7 @@ clutter_text_ensure_effective_attributes (ClutterText *self)
                {
                  PangoAttribute *attr = l->data;

-                  pango_attr_list_insert (priv->effective_attrs, attr);
+                  pango_attr_list_insert (effective_attrs, attr);
                }

              g_slist_free (attributes);
@@ -596,12 +689,14 @@ clutter_text_ensure_effective_attributes (ClutterText *self)
          while (pango_attr_iterator_next (iter));

          pango_attr_iterator_destroy (iter);
+
+          set_effective_pango_attributes (self, effective_attrs);
+          pango_attr_list_unref (effective_attrs);
        }
    }
  else if (priv->markup_attrs != NULL)
    {
-      /* We can just use the markup attributes directly */
-      priv->effective_attrs = pango_attr_list_ref (priv->markup_attrs);
+      set_effective_pango_attributes (self, priv->markup_attrs);
    }
 }

@@ -810,6 +905,18 @@ clutter_text_direction_changed_cb (GObject    *gobject,
  /* no need to queue a relayout: set_text_direction() will do that for us */
 }

+static void
+clutter_text_resource_scale_changed_cb (GObject    *gobject,
+                                        GParamSpec *pspec)
+{
+  ClutterText *self = CLUTTER_TEXT (gobject);
+  ClutterTextPrivate *priv = self->priv;
+
+  g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref);
+  clutter_text_dirty_cache (self);
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (gobject));
+}
+
 /*
 * clutter_text_create_layout:
 * @text: a #ClutterText
@@ -877,7 +984,7 @@ clutter_text_create_layout (ClutterText *text,
       !((priv->editable && priv->single_line_mode) ||
         (priv->ellipsize == PANGO_ELLIPSIZE_NONE && !priv->wrap))))
    {
-      width = allocation_width * 1024 + 0.5f;
+      width = pixels_to_pango (allocation_width);
    }

  /* Pango only uses height if ellipsization is enabled, so don't set
@@ -894,7 +1001,7 @@ clutter_text_create_layout (ClutterText *text,
      priv->ellipsize != PANGO_ELLIPSIZE_NONE &&
      !priv->single_line_mode)
    {
-      height = allocation_height * 1024 + 0.5f;
+      height = pixels_to_pango (allocation_height);
    }

  /* Search for a cached layout with the same width and keep
@@ -991,6 +1098,37 @@ clutter_text_create_layout (ClutterText *text,
  return oldest_cache->layout;
 }

+static PangoLayout *
+create_text_layout_with_scale (ClutterText *text,
+                               gfloat       allocation_width,
+                               gfloat       allocation_height,
+                               gfloat       scale)
+{
+  if (allocation_width > 0)
+    allocation_width = roundf (allocation_width * scale);
+
+  if (allocation_height > 0)
+    allocation_height = roundf (allocation_height * scale);
+
+  return clutter_text_create_layout (text, allocation_width, allocation_height);
+}
+
+static PangoLayout *
+maybe_create_text_layout_with_resource_scale (ClutterText *text,
+                                              gfloat       allocation_width,
+                                              gfloat       allocation_height)
+{
+  float resource_scale;
+
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (text), &resource_scale))
+    return NULL;
+
+  return create_text_layout_with_scale (text,
+                                        allocation_width,
+                                        allocation_height,
+                                        resource_scale);
+}
+
 /**
 * clutter_text_coords_to_position:
 * @self: a #ClutterText
@@ -1011,14 +1149,18 @@ clutter_text_coords_to_position (ClutterText *self,
  gint index_;
  gint px, py;
  gint trailing;
+  gfloat resource_scale;

  g_return_val_if_fail (CLUTTER_IS_TEXT (self), 0);

+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return 0;
+
  /* Take any offset due to scrolling into account, and normalize
   * the coordinates to PangoScale units
   */
-  px = (x - self->priv->text_x) * PANGO_SCALE;
-  py = (y - self->priv->text_y) * PANGO_SCALE;
+  px = logical_pixels_to_pango (x - self->priv->text_logical_x, resource_scale);
+  py = logical_pixels_to_pango (y - self->priv->text_logical_y, resource_scale);

  pango_layout_xy_to_index (clutter_text_get_layout (self),
                            px, py,
@@ -1027,26 +1169,12 @@ clutter_text_coords_to_position (ClutterText *self,
  return index_ + trailing;
 }

-/**
- * clutter_text_position_to_coords:
- * @self: a #ClutterText
- * @position: position in characters
- * @x: (out): return location for the X coordinate, or %NULL
- * @y: (out): return location for the Y coordinate, or %NULL
- * @line_height: (out): return location for the line height, or %NULL
- *
- * Retrieves the coordinates of the given @position.
- *
- * Return value: %TRUE if the conversion was successful
- *
- * Since: 1.0
- */
-gboolean
-clutter_text_position_to_coords (ClutterText *self,
-                                 gint         position,
-                                 gfloat      *x,
-                                 gfloat      *y,
-                                 gfloat      *line_height)
+static gboolean
+clutter_text_position_to_coords_internal (ClutterText *self,
+                                          gint         position,
+                                          gfloat      *x,
+                                          gfloat      *y,
+                                          gfloat      *line_height)
 {
  ClutterTextPrivate *priv;
  PangoRectangle rect;
@@ -1112,7 +1240,7 @@ clutter_text_position_to_coords (ClutterText *self,

  if (x)
    {
-      *x = (gfloat) rect.x / 1024.0f;
+      *x = pango_to_pixels (rect.x);

      /* Take any offset due to scrolling into account */
      if (priv->single_line_mode)
@@ -1120,19 +1248,63 @@ clutter_text_position_to_coords (ClutterText *self,
    }

  if (y)
-    *y = (gfloat) rect.y / 1024.0f;
+    *y = pango_to_pixels (rect.y);

  if (line_height)
-    *line_height = (gfloat) rect.height / 1024.0f;
+    *line_height = pango_to_pixels (rect.height);

  return TRUE;
 }

+/**
+ * clutter_text_position_to_coords:
+ * @self: a #ClutterText
+ * @position: position in characters
+ * @x: (out): return location for the X coordinate, or %NULL
+ * @y: (out): return location for the Y coordinate, or %NULL
+ * @line_height: (out): return location for the line height, or %NULL
+ *
+ * Retrieves the coordinates of the given @position.
+ *
+ * Return value: %TRUE if the conversion was successful
+ *
+ * Since: 1.0
+ */
+gboolean
+clutter_text_position_to_coords (ClutterText *self,
+                                 gint         position,
+                                 gfloat      *x,
+                                 gfloat      *y,
+                                 gfloat      *line_height)
+{
+  gfloat resource_scale;
+  gboolean ret;
+
+  g_return_val_if_fail (CLUTTER_IS_TEXT (self), FALSE);
+
+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return FALSE;
+
+  ret = clutter_text_position_to_coords_internal (self, position,
+                                                  x, y, line_height);
+
+  if (x)
+    *x /= resource_scale;
+
+  if (y)
+    *y /= resource_scale;
+
+  if (line_height)
+    *line_height /= resource_scale;
+
+  return ret;
+}
+
 static inline void
 update_cursor_location (ClutterText *self)
 {
  ClutterTextPrivate *priv = self->priv;
-  ClutterRect rect;
+  graphene_rect_t rect;
  float x, y;

  if (!priv->editable)
@@ -1140,16 +1312,17 @@ update_cursor_location (ClutterText *self)

  rect = priv->cursor_rect;
  clutter_actor_get_transformed_position (CLUTTER_ACTOR (self), &x, &y);
-  clutter_rect_offset (&rect, x, y);
+  graphene_rect_offset (&rect, x, y);
  clutter_input_focus_set_cursor_location (priv->input_focus, &rect);
 }

 static inline void
-clutter_text_ensure_cursor_position (ClutterText *self)
+clutter_text_ensure_cursor_position (ClutterText *self,
+                                     float        scale)
 {
  ClutterTextPrivate *priv = self->priv;
  gfloat x, y, cursor_height;
-  ClutterRect cursor_rect = CLUTTER_RECT_INIT_ZERO;
+  graphene_rect_t cursor_rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);
  gint position;

  position = priv->position;
@@ -1168,29 +1341,21 @@ clutter_text_ensure_cursor_position (ClutterText *self)
                priv->preedit_set ? priv->preedit_cursor_pos : 0);

  x = y = cursor_height = 0;
-  clutter_text_position_to_coords (self, position,
-                                   &x, &y,
-                                   &cursor_height);
+  clutter_text_position_to_coords_internal (self, position,
+                                            &x, &y,
+                                            &cursor_height);

-  clutter_rect_init (&cursor_rect,
-                     x,
-                     y + CURSOR_Y_PADDING,
-                     priv->cursor_size,
-                     cursor_height - 2 * CURSOR_Y_PADDING);
+  graphene_rect_init (&cursor_rect,
+                      x,
+                      y + CURSOR_Y_PADDING * scale,
+                      priv->cursor_size * scale,
+                      cursor_height - 2 * CURSOR_Y_PADDING * scale);

-  if (!clutter_rect_equals (&priv->cursor_rect, &cursor_rect))
+  if (!graphene_rect_equal (&priv->cursor_rect, &cursor_rect))
    {
-      ClutterGeometry cursor_pos;
-
      priv->cursor_rect = cursor_rect;

-      /* XXX:2.0 - remove */
-      cursor_pos.x = clutter_rect_get_x (&priv->cursor_rect);
-      cursor_pos.y = clutter_rect_get_y (&priv->cursor_rect);
-      cursor_pos.width = clutter_rect_get_width (&priv->cursor_rect);
-      cursor_pos.height = clutter_rect_get_height (&priv->cursor_rect);
-      g_signal_emit (self, text_signals[CURSOR_EVENT], 0, &cursor_pos);
-
+      g_signal_emit (self, text_signals[CURSOR_EVENT], 0, &cursor_rect);
      g_signal_emit (self, text_signals[CURSOR_CHANGED], 0);

      update_cursor_location (self);
@@ -1599,6 +1764,12 @@ clutter_text_dispose (GObject *gobject)
      priv->direction_changed_id = 0;
    }

+  if (priv->resource_scale_changed_id)
+    {
+      g_signal_handler_disconnect (self, priv->resource_scale_changed_id);
+      priv->resource_scale_changed_id = 0;
+    }
+
  if (priv->settings_changed_id)
    {
      g_signal_handler_disconnect (clutter_get_default_backend (),
@@ -1651,6 +1822,7 @@ typedef void (* ClutterTextSelectionFunc) (ClutterText           *text,

 static void
 clutter_text_foreach_selection_rectangle (ClutterText              *self,
+                                          float                     scale,
                                          ClutterTextSelectionFunc  func,
                                          gpointer                  user_data)
 {
@@ -1702,9 +1874,9 @@ clutter_text_foreach_selection_rectangle (ClutterText              *self,
                                      &n_ranges);
      pango_layout_line_x_to_index (line, 0, &index_, NULL);

-      clutter_text_position_to_coords (self,
-                                       bytes_to_offset (utf8, index_),
-                                       NULL, &y, &height);
+      clutter_text_position_to_coords_internal (self,
+                                                bytes_to_offset (utf8, index_),
+                                                NULL, &y, &height);

      box.y1 = y;
      box.y2 = y + height;
@@ -1714,18 +1886,18 @@ clutter_text_foreach_selection_rectangle (ClutterText              *self,
          gfloat range_x;
          gfloat range_width;

-          range_x = ranges[i * 2] / PANGO_SCALE;
+          range_x = pango_to_pixels (ranges[i * 2]);

          /* Account for any scrolling in single line mode */
          if (priv->single_line_mode)
            range_x += priv->text_x;


-          range_width = ((gfloat) ranges[i * 2 + 1] - (gfloat) ranges[i * 2])
-                      / PANGO_SCALE;
-
+          range_width = pango_to_pixels (ranges[i * 2 + 1] - ranges[i * 2]);
          box.x1 = range_x;
-          box.x2 = ceilf (range_x + range_width + .5f);
+          box.x2 = ceilf (range_x + range_width);
+
+          clutter_actor_box_scale (&box, scale);

          func (self, &box, user_data);
        }
@@ -1744,6 +1916,14 @@ add_selection_rectangle_to_path (ClutterText           *text,
  cogl_path_rectangle (user_data, box->x1, box->y1, box->x2, box->y2);
 }

+static void
+clutter_text_foreach_selection_rectangle_prescaled (ClutterText              *self,
+                                                    ClutterTextSelectionFunc  func,
+                                                    gpointer                  user_data)
+{
+  clutter_text_foreach_selection_rectangle (self, 1.0f, func, user_data);
+}
+
 /* Draws the selected text, its background, and the cursor */
 static void
 selection_paint (ClutterText     *self,
@@ -1799,9 +1979,9 @@ selection_paint (ClutterText     *self,
      else
        color = &priv->text_color;

-      clutter_text_foreach_selection_rectangle (self,
-                                                add_selection_rectangle_to_path,
-                                                selection_path);
+      clutter_text_foreach_selection_rectangle_prescaled (self,
+                                                          add_selection_rectangle_to_path,
+                                                          selection_path);

      cogl_path_fill (selection_path);

@@ -1998,7 +2178,8 @@ clutter_text_press (ClutterActor *actor,
    return CLUTTER_EVENT_PROPAGATE;

  clutter_actor_grab_key_focus (actor);
-  clutter_input_focus_request_toggle_input_panel (priv->input_focus);
+  clutter_input_focus_set_input_panel_state (priv->input_focus,
+                                             CLUTTER_INPUT_PANEL_STATE_TOGGLE);

  /* if the actor is empty we just reset everything and not
   * set up the dragging of the selection since there's nothing
@@ -2390,6 +2571,7 @@ clutter_text_paint (ClutterActor *self)
  guint n_chars;
  float alloc_width;
  float alloc_height;
+  float resource_scale;

  fb = cogl_get_draw_framebuffer ();

@@ -2399,8 +2581,6 @@ clutter_text_paint (ClutterActor *self)
  n_chars = clutter_text_buffer_get_length (get_buffer (text));

  clutter_actor_get_allocation_box (self, &alloc);
-  alloc_width = alloc.x2 - alloc.x1;
-  alloc_height = alloc.y2 - alloc.y1;

  if (G_UNLIKELY (default_color_pipeline == NULL))
    {
@@ -2433,7 +2613,8 @@ clutter_text_paint (ClutterActor *self)
      cogl_framebuffer_draw_rectangle (fb,
                                       color_pipeline,
                                       0, 0,
-                                       alloc_width, alloc_height);
+                                       clutter_actor_box_get_width (&alloc),
+                                       clutter_actor_box_get_height (&alloc));

      cogl_object_unref (color_pipeline);
    }
@@ -2446,6 +2627,12 @@ clutter_text_paint (ClutterActor *self)
      !clutter_text_should_draw_cursor (text))
    return;

+  if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale))
+    return;
+
+  clutter_actor_box_scale (&alloc, resource_scale);
+  clutter_actor_box_get_size (&alloc, &alloc_width, &alloc_height);
+
  if (priv->editable && priv->single_line_mode)
    layout = clutter_text_create_layout (text, -1, -1);
  else
@@ -2477,8 +2664,15 @@ clutter_text_paint (ClutterActor *self)
        }
    }

+  if (resource_scale != 1.0f)
+    {
+      float paint_scale = 1.0f / resource_scale;
+      cogl_framebuffer_push_matrix (fb);
+      cogl_framebuffer_scale (fb, paint_scale, paint_scale, 1.0f);
+    }
+
  if (clutter_text_should_draw_cursor (text))
-    clutter_text_ensure_cursor_position (text);
+    clutter_text_ensure_cursor_position (text, resource_scale);

  if (priv->editable && priv->single_line_mode)
    {
@@ -2492,13 +2686,13 @@ clutter_text_paint (ClutterActor *self)
      clip_set = TRUE;

      actor_width = alloc_width - 2 * TEXT_PADDING;
-      text_width  = logical_rect.width / PANGO_SCALE;
+      text_width  = pango_to_pixels (logical_rect.width);

      rtl = priv->resolved_direction == PANGO_DIRECTION_RTL;

      if (actor_width < text_width)
        {
-          gint cursor_x = clutter_rect_get_x (&priv->cursor_rect);
+          gint cursor_x = graphene_rect_get_x (&priv->cursor_rect);

          if (priv->position == -1)
            {
@@ -2549,8 +2743,10 @@ clutter_text_paint (ClutterActor *self)
    {
      priv->text_x = text_x;
      priv->text_y = text_y;
+      priv->text_logical_x = roundf ((float) text_x / resource_scale);
+      priv->text_logical_y = roundf ((float) text_y / resource_scale);

-      clutter_text_ensure_cursor_position (text);
+      clutter_text_ensure_cursor_position (text, resource_scale);
    }

  real_opacity = clutter_actor_get_paint_opacity (self)
@@ -2569,6 +2765,9 @@ clutter_text_paint (ClutterActor *self)

  selection_paint (text, fb);

+  if (resource_scale != 1.0f)
+    cogl_framebuffer_pop_matrix (fb);
+
  if (clip_set)
    cogl_framebuffer_pop_clip (fb);
 }
@@ -2580,7 +2779,7 @@ add_selection_to_paint_volume (ClutterText           *text,
 {
  ClutterPaintVolume *total_volume = user_data;
  ClutterPaintVolume rect_volume;
-  ClutterVertex vertex;
+  graphene_point3d_t vertex;

  _clutter_paint_volume_init_static (&rect_volume, CLUTTER_ACTOR (text));

@@ -2598,26 +2797,32 @@ add_selection_to_paint_volume (ClutterText           *text,

 static void
 clutter_text_get_paint_volume_for_cursor (ClutterText        *text,
+                                          float               resource_scale,
                                          ClutterPaintVolume *volume)
 {
  ClutterTextPrivate *priv = text->priv;
-  ClutterVertex origin;
+  graphene_point3d_t origin;

-  clutter_text_ensure_cursor_position (text);
+  clutter_text_ensure_cursor_position (text, resource_scale);

  if (priv->position == priv->selection_bound)
    {
-      origin.x = priv->cursor_rect.origin.x;
-      origin.y = priv->cursor_rect.origin.y;
+      float width, height;
+
+      width = priv->cursor_rect.size.width / resource_scale;
+      height = priv->cursor_rect.size.height / resource_scale;
+      origin.x = priv->cursor_rect.origin.x / resource_scale;
+      origin.y = priv->cursor_rect.origin.y / resource_scale;
      origin.z = 0;

      clutter_paint_volume_set_origin (volume, &origin);
-      clutter_paint_volume_set_width (volume, priv->cursor_rect.size.width);
-      clutter_paint_volume_set_height (volume, priv->cursor_rect.size.height);
+      clutter_paint_volume_set_width (volume, width);
+      clutter_paint_volume_set_height (volume, height);
    }
  else
    {
      clutter_text_foreach_selection_rectangle (text,
+                                                1.0f / resource_scale,
                                                add_selection_to_paint_volume,
                                                volume);
    }
@@ -2639,7 +2844,8 @@ clutter_text_get_paint_volume (ClutterActor       *self,
    {
      PangoLayout *layout;
      PangoRectangle ink_rect;
-      ClutterVertex origin;
+      graphene_point3d_t origin;
+      float resource_scale;

      /* If the text is single line editable then it gets clipped to
         the allocation anyway so we can just use that */
@@ -2654,19 +2860,24 @@ clutter_text_get_paint_volume (ClutterActor       *self,
      if (!clutter_actor_has_allocation (self))
        return FALSE;

+      if (!clutter_actor_get_resource_scale (self, &resource_scale))
+        return FALSE;
+
      _clutter_paint_volume_init_static (&priv->paint_volume, self);

      layout = clutter_text_get_layout (text);
      pango_layout_get_extents (layout, &ink_rect, NULL);

-      origin.x = ink_rect.x / (float) PANGO_SCALE;
-      origin.y = ink_rect.y / (float) PANGO_SCALE;
+      origin.x = pango_to_logical_pixels (ink_rect.x, resource_scale);
+      origin.y = pango_to_logical_pixels (ink_rect.y, resource_scale);
      origin.z = 0;
      clutter_paint_volume_set_origin (&priv->paint_volume, &origin);
      clutter_paint_volume_set_width (&priv->paint_volume,
-                                      ink_rect.width / (float) PANGO_SCALE);
+                                      pango_to_logical_pixels (ink_rect.width,
+                                                               resource_scale));
      clutter_paint_volume_set_height (&priv->paint_volume,
-                                       ink_rect.height / (float) PANGO_SCALE);
+                                       pango_to_logical_pixels (ink_rect.height,
+                                                                resource_scale));

      /* If the cursor is visible then that will likely be drawn
         outside of the ink rectangle so we should merge that in */
@@ -2676,7 +2887,8 @@ clutter_text_get_paint_volume (ClutterActor       *self,

          _clutter_paint_volume_init_static (&cursor_paint_volume, self);

-          clutter_text_get_paint_volume_for_cursor (text, &cursor_paint_volume);
+          clutter_text_get_paint_volume_for_cursor (text, resource_scale,
+                                                    &cursor_paint_volume);

          clutter_paint_volume_union (&priv->paint_volume,
                                      &cursor_paint_volume);
@@ -2704,9 +2916,12 @@ clutter_text_get_preferred_width (ClutterActor *self,
  PangoLayout *layout;
  gint logical_width;
  gfloat layout_width;
+  gfloat resource_scale;
+
+  if (!clutter_actor_get_resource_scale (self, &resource_scale))
+    resource_scale = 1;

  layout = clutter_text_create_layout (text, -1, -1);
-
  pango_layout_get_extents (layout, NULL, &logical_rect);

  /* the X coordinate of the logical rectangle might be non-zero
@@ -2716,7 +2931,7 @@ clutter_text_get_preferred_width (ClutterActor *self,
  logical_width = logical_rect.x + logical_rect.width;

  layout_width = logical_width > 0
-    ? ceilf (logical_width / 1024.0f)
+    ? pango_to_logical_pixels (logical_width, resource_scale)
    : 1;

  if (min_width_p)
@@ -2758,12 +2973,16 @@ clutter_text_get_preferred_height (ClutterActor *self,
      PangoRectangle logical_rect = { 0, };
      gint logical_height;
      gfloat layout_height;
+      gfloat resource_scale;
+
+      if (!clutter_actor_get_resource_scale (self, &resource_scale))
+        resource_scale = 1;

      if (priv->single_line_mode)
        for_width = -1;

-      layout = clutter_text_create_layout (CLUTTER_TEXT (self),
-                                           for_width, -1);
+      layout = create_text_layout_with_scale (CLUTTER_TEXT (self),
+                                              for_width, -1, resource_scale);

      pango_layout_get_extents (layout, NULL, &logical_rect);

@@ -2772,7 +2991,7 @@ clutter_text_get_preferred_height (ClutterActor *self,
       * the height accordingly
       */
      logical_height = logical_rect.y + logical_rect.height;
-      layout_height = ceilf (logical_height / 1024.0f);
+      layout_height = pango_to_logical_pixels (logical_height, resource_scale);

      if (min_height_p)
        {
@@ -2788,7 +3007,8 @@ clutter_text_get_preferred_height (ClutterActor *self,
              pango_layout_line_get_extents (line, NULL, &logical_rect);

              logical_height = logical_rect.y + logical_rect.height;
-              line_height = ceilf (logical_height / 1024.0f);
+              line_height = pango_to_logical_pixels (logical_height,
+                                                     resource_scale);

              *min_height_p = line_height;
            }
@@ -2819,9 +3039,9 @@ clutter_text_allocate (ClutterActor           *self,
  if (text->priv->editable && text->priv->single_line_mode)
    clutter_text_create_layout (text, -1, -1);
  else
-    clutter_text_create_layout (text,
-                                box->x2 - box->x1,
-                                box->y2 - box->y1);
+    maybe_create_text_layout_with_resource_scale (text,
+                                                  box->x2 - box->x1,
+                                                  box->y2 - box->y1);

  parent_class = CLUTTER_ACTOR_CLASS (clutter_text_parent_class);
  parent_class->allocate (self, box, flags);
@@ -3547,7 +3767,7 @@ clutter_text_set_final_state (ClutterAnimatable *animatable,
 }

 static void
-clutter_animatable_iface_init (ClutterAnimatableIface *iface)
+clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
 {
  parent_animatable_iface = g_type_interface_peek_parent (iface);

@@ -4160,10 +4380,10 @@ clutter_text_class_init (ClutterTextClass *klass)
  /**
   * ClutterText::cursor-event:
   * @self: the #ClutterText that emitted the signal
-   * @geometry: the coordinates of the cursor
+   * @rect: the coordinates of the cursor
   *
   * The ::cursor-event signal is emitted whenever the cursor position
-   * changes inside a #ClutterText actor. Inside @geometry it is stored
+   * changes inside a #ClutterText actor. Inside @rect it is stored
   * the current position and size of the cursor, relative to the actor
   * itself.
   *
@@ -4179,7 +4399,7 @@ clutter_text_class_init (ClutterTextClass *klass)
 		  NULL, NULL,
 		  _clutter_marshal_VOID__BOXED,
 		  G_TYPE_NONE, 1,
-		  CLUTTER_TYPE_GEOMETRY | G_SIGNAL_TYPE_STATIC_SCOPE);
+		  GRAPHENE_TYPE_RECT | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**
   * ClutterText::cursor-changed:
@@ -4392,6 +4612,11 @@ clutter_text_init (ClutterText *self)
                      NULL);

  priv->input_focus = clutter_text_input_focus_new (self);
+
+  priv->resource_scale_changed_id =
+    g_signal_connect (self, "notify::resource-scale",
+                      G_CALLBACK (clutter_text_resource_scale_changed_cb),
+                      NULL);
 }

 /**
@@ -5502,6 +5727,7 @@ clutter_text_set_markup (ClutterText *self,
 PangoLayout *
 clutter_text_get_layout (ClutterText *self)
 {
+  PangoLayout *layout;
  gfloat width, height;

  g_return_val_if_fail (CLUTTER_IS_TEXT (self), NULL);
@@ -5510,8 +5736,12 @@ clutter_text_get_layout (ClutterText *self)
    return clutter_text_create_layout (self, -1, -1);

  clutter_actor_get_size (CLUTTER_ACTOR (self), &width, &height);
+  layout = maybe_create_text_layout_with_resource_scale (self, width, height);

-  return clutter_text_create_layout (self, width, height);
+  if (!layout)
+    layout = clutter_text_create_layout (self, width, height);
+
+  return layout;
 }

 /**
@@ -6515,10 +6745,10 @@ clutter_text_get_layout_offsets (ClutterText *self,
  priv = self->priv;

  if (x != NULL)
-    *x = priv->text_x;
+    *x = priv->text_logical_x;

  if (y != NULL)
-    *y = priv->text_y;
+    *y = priv->text_logical_y;
 }

 /**
@@ -6534,8 +6764,8 @@ clutter_text_get_layout_offsets (ClutterText *self,
 * Since: 1.16
 */
 void
-clutter_text_get_cursor_rect (ClutterText *self,
-                              ClutterRect *rect)
+clutter_text_get_cursor_rect (ClutterText     *self,
+                              graphene_rect_t *rect)
 {
  g_return_if_fail (CLUTTER_IS_TEXT (self));
  g_return_if_fail (rect != NULL);
--- a/clutter/clutter/clutter-text.h
+++ b/clutter/clutter/clutter-text.h
@@ -82,7 +82,7 @@ struct _ClutterTextClass
  void (* text_changed)   (ClutterText           *self);
  void (* activate)       (ClutterText           *self);
  void (* cursor_event)   (ClutterText           *self,
-                           const ClutterGeometry *geometry);
+                           const graphene_rect_t *rect);
  void (* cursor_changed) (ClutterText           *self);

  /*< private >*/
@@ -230,7 +230,7 @@ CLUTTER_EXPORT
 guint                 clutter_text_get_cursor_size      (ClutterText          *self);
 CLUTTER_EXPORT
 void                  clutter_text_get_cursor_rect      (ClutterText          *self,
-                                                         ClutterRect          *rect);
+                                                         graphene_rect_t      *rect);
 CLUTTER_EXPORT
 void                  clutter_text_set_selectable       (ClutterText          *self,
                                                         gboolean              selectable);
--- a/clutter/clutter/clutter-texture.h
+++ b/clutter/clutter/clutter-texture.h
@@ -53,7 +53,8 @@ G_BEGIN_DECLS
 *
 * Since: 0.4
 */
-typedef enum {
+typedef enum
+{
  CLUTTER_TEXTURE_ERROR_OUT_OF_MEMORY,
  CLUTTER_TEXTURE_ERROR_NO_YUV,
  CLUTTER_TEXTURE_ERROR_BAD_FORMAT
--- a/clutter/clutter/clutter-timeline.c
+++ b/clutter/clutter/clutter-timeline.c
@@ -145,8 +145,8 @@ struct _ClutterTimelinePrivate
  ClutterStepMode step_mode;

  /* cubic-bezier() parameters */
-  ClutterPoint cb_1;
-  ClutterPoint cb_2;
+  graphene_point_t cb_1;
+  graphene_point_t cb_2;

  guint is_playing         : 1;

@@ -850,8 +850,8 @@ clutter_timeline_init (ClutterTimeline *self)
  self->priv->step_mode = CLUTTER_STEP_MODE_END;

  /* default cubic-bezier() paramereters are (0, 0, 1, 1) */
-  clutter_point_init (&self->priv->cb_1, 0, 0);
-  clutter_point_init (&self->priv->cb_2, 1, 1);
+  graphene_point_init (&self->priv->cb_1, 0, 0);
+  graphene_point_init (&self->priv->cb_2, 1, 1);
 }

 struct CheckIfMarkerHitClosure
@@ -2493,9 +2493,9 @@ clutter_timeline_get_step_progress (ClutterTimeline *timeline,
 * Since: 1.12
 */
 void
-clutter_timeline_set_cubic_bezier_progress (ClutterTimeline    *timeline,
-                                            const ClutterPoint *c_1,
-                                            const ClutterPoint *c_2)
+clutter_timeline_set_cubic_bezier_progress (ClutterTimeline        *timeline,
+                                            const graphene_point_t *c_1,
+                                            const graphene_point_t *c_2)
 {
  ClutterTimelinePrivate *priv;

@@ -2530,9 +2530,9 @@ clutter_timeline_set_cubic_bezier_progress (ClutterTimeline    *timeline,
 * Since: 1.12
 */
 gboolean
-clutter_timeline_get_cubic_bezier_progress (ClutterTimeline *timeline,
-                                            ClutterPoint    *c_1,
-                                            ClutterPoint    *c_2)
+clutter_timeline_get_cubic_bezier_progress (ClutterTimeline  *timeline,
+                                            graphene_point_t *c_1,
+                                            graphene_point_t *c_2)
 {
  g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), FALSE);

--- a/clutter/clutter/clutter-timeline.h
+++ b/clutter/clutter/clutter-timeline.h
@@ -209,12 +209,12 @@ gboolean                        clutter_timeline_get_step_progress
                                                                                 ClutterStepMode          *step_mode);
 CLUTTER_EXPORT
 void                            clutter_timeline_set_cubic_bezier_progress      (ClutterTimeline          *timeline,
-                                                                                 const ClutterPoint       *c_1,
-                                                                                 const ClutterPoint       *c_2);
+                                                                                 const graphene_point_t   *c_1,
+                                                                                 const graphene_point_t   *c_2);
 CLUTTER_EXPORT
 gboolean                        clutter_timeline_get_cubic_bezier_progress      (ClutterTimeline          *timeline,
-                                                                                 ClutterPoint             *c_1,
-                                                                                 ClutterPoint             *c_2);
+                                                                                 graphene_point_t         *c_1,
+                                                                                 graphene_point_t         *c_2);

 CLUTTER_EXPORT
 gint64                          clutter_timeline_get_duration_hint              (ClutterTimeline          *timeline);
--- a/clutter/clutter/clutter-types.h
+++ b/clutter/clutter/clutter-types.h
@@ -33,20 +33,16 @@
 #include <clutter/clutter-macros.h>
 #include <clutter/clutter-enums.h>

+#include <graphene-gobject.h>
+
 G_BEGIN_DECLS

 #define CLUTTER_TYPE_ACTOR_BOX          (clutter_actor_box_get_type ())
-#define CLUTTER_TYPE_FOG                (clutter_fog_get_type ())
-#define CLUTTER_TYPE_GEOMETRY           (clutter_geometry_get_type ())
 #define CLUTTER_TYPE_KNOT               (clutter_knot_get_type ())
 #define CLUTTER_TYPE_MARGIN             (clutter_margin_get_type ())
 #define CLUTTER_TYPE_MATRIX             (clutter_matrix_get_type ())
 #define CLUTTER_TYPE_PAINT_VOLUME       (clutter_paint_volume_get_type ())
 #define CLUTTER_TYPE_PERSPECTIVE        (clutter_perspective_get_type ())
-#define CLUTTER_TYPE_VERTEX             (clutter_vertex_get_type ())
-#define CLUTTER_TYPE_POINT              (clutter_point_get_type ())
-#define CLUTTER_TYPE_SIZE               (clutter_size_get_type ())
-#define CLUTTER_TYPE_RECT               (clutter_rect_get_type ())

 typedef struct _ClutterActor                    ClutterActor;

@@ -79,18 +75,12 @@ typedef struct _ClutterPathNode                 ClutterPathNode;

 typedef struct _ClutterActorBox                 ClutterActorBox;
 typedef struct _ClutterColor                    ClutterColor;
-typedef struct _ClutterGeometry                 ClutterGeometry; /* XXX:2.0 - remove */
 typedef struct _ClutterKnot                     ClutterKnot;
 typedef struct _ClutterMargin                   ClutterMargin;
 typedef struct _ClutterPerspective              ClutterPerspective;
-typedef struct _ClutterPoint                    ClutterPoint;
-typedef struct _ClutterRect                     ClutterRect;
-typedef struct _ClutterSize                     ClutterSize;
-typedef struct _ClutterVertex                   ClutterVertex;

 typedef struct _ClutterAlpha            	ClutterAlpha;
 typedef struct _ClutterAnimation                ClutterAnimation;
-typedef struct _ClutterAnimator         	ClutterAnimator;
 typedef struct _ClutterState            	ClutterState;

 typedef struct _ClutterInputDeviceTool          ClutterInputDeviceTool;
@@ -114,7 +104,6 @@ typedef union _ClutterEvent                     ClutterEvent;
 */
 typedef struct _ClutterEventSequence            ClutterEventSequence;

-typedef struct _ClutterFog                      ClutterFog; /* deprecated */
 typedef struct _ClutterBehaviour                ClutterBehaviour; /* deprecated */
 typedef struct _ClutterShader                   ClutterShader; /* deprecated */

@@ -138,303 +127,6 @@ typedef struct _ClutterShader                   ClutterShader; /* deprecated */
 */
 typedef struct _ClutterPaintVolume      ClutterPaintVolume;

-/**
- * ClutterPoint:
- * @x: X coordinate, in pixels
- * @y: Y coordinate, in pixels
- *
- * A point in 2D space.
- *
- * Since: 1.12
- */
-struct _ClutterPoint
-{
-  float x;
-  float y;
-};
-
-/**
- * CLUTTER_POINT_INIT:
- * @x: X coordinate
- * @y: Y coordinate
- *
- * A simple macro for initializing a #ClutterPoint when declaring it, e.g.:
- *
- * |[
- *   ClutterPoint p = CLUTTER_POINT_INIT (100, 100);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_POINT_INIT(x,y)         { (x), (y) }
-
-/**
- * CLUTTER_POINT_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterPoint to (0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_POINT_INIT_ZERO         CLUTTER_POINT_INIT (0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_point_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-const ClutterPoint *    clutter_point_zero      (void);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_alloc     (void);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_init      (ClutterPoint       *point,
-                                                 float               x,
-                                                 float               y);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_copy      (const ClutterPoint *point);
-CLUTTER_EXPORT
-void                    clutter_point_free      (ClutterPoint       *point);
-CLUTTER_EXPORT
-gboolean                clutter_point_equals    (const ClutterPoint *a,
-                                                 const ClutterPoint *b);
-CLUTTER_EXPORT
-float                   clutter_point_distance  (const ClutterPoint *a,
-                                                 const ClutterPoint *b,
-                                                 float              *x_distance,
-                                                 float              *y_distance);
-
-/**
- * ClutterSize:
- * @width: the width, in pixels
- * @height: the height, in pixels
- *
- * A size, in 2D space.
- *
- * Since: 1.12
- */
-struct _ClutterSize
-{
-  float width;
-  float height;
-};
-
-/**
- * CLUTTER_SIZE_INIT:
- * @width: the width
- * @height: the height
- *
- * A simple macro for initializing a #ClutterSize when declaring it, e.g.:
- *
- * |[
- *   ClutterSize s = CLUTTER_SIZE_INIT (200, 200);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_SIZE_INIT(width,height) { (width), (height) }
-
-/**
- * CLUTTER_SIZE_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterSize to (0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_SIZE_INIT_ZERO          CLUTTER_SIZE_INIT (0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_size_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_alloc      (void);
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_init       (ClutterSize       *size,
-                                         float              width,
-                                         float              height);
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_copy       (const ClutterSize *size);
-CLUTTER_EXPORT
-void            clutter_size_free       (ClutterSize       *size);
-CLUTTER_EXPORT
-gboolean        clutter_size_equals     (const ClutterSize *a,
-                                         const ClutterSize *b);
-
-/**
- * ClutterRect:
- * @origin: the origin of the rectangle
- * @size: the size of the rectangle
- *
- * The location and size of a rectangle.
- *
- * The width and height of a #ClutterRect can be negative; Clutter considers
- * a rectangle with an origin of [ 0.0, 0.0 ] and a size of [ 10.0, 10.0 ] to
- * be equivalent to a rectangle with origin of [ 10.0, 10.0 ] and size of
- * [ -10.0, -10.0 ].
- *
- * Application code can normalize rectangles using clutter_rect_normalize():
- * this function will ensure that the width and height of a #ClutterRect are
- * positive values. All functions taking a #ClutterRect as an argument will
- * implicitly normalize it before computing eventual results. For this reason
- * it is safer to access the contents of a #ClutterRect by using the provided
- * API at all times, instead of directly accessing the structure members.
- *
- * Since: 1.12
- */
-struct _ClutterRect
-{
-  ClutterPoint origin;
-  ClutterSize size;
-};
-
-/**
- * CLUTTER_RECT_INIT:
- * @x: the X coordinate
- * @y: the Y coordinate
- * @width: the width
- * @height: the height
- *
- * A simple macro for initializing a #ClutterRect when declaring it, e.g.:
- *
- * |[
- *   ClutterRect r = CLUTTER_RECT_INIT (100, 100, 200, 200);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_RECT_INIT(x,y,width,height)     { { (x), (y) }, { (width), (height) } }
-
-/**
- * CLUTTER_RECT_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterRect to (0, 0, 0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_RECT_INIT_ZERO                  CLUTTER_RECT_INIT (0.f, 0.f, 0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_rect_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-const ClutterRect *     clutter_rect_zero               (void);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_alloc              (void);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_init               (ClutterRect       *rect,
-                                                         float              x,
-                                                         float              y,
-                                                         float              width,
-                                                         float              height);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_copy               (const ClutterRect *rect);
-CLUTTER_EXPORT
-void                    clutter_rect_free               (ClutterRect       *rect);
-CLUTTER_EXPORT
-gboolean                clutter_rect_equals             (ClutterRect       *a,
-                                                         ClutterRect       *b);
-
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_normalize          (ClutterRect       *rect);
-CLUTTER_EXPORT
-void                    clutter_rect_get_center         (ClutterRect       *rect,
-                                                         ClutterPoint      *center);
-CLUTTER_EXPORT
-gboolean                clutter_rect_contains_point     (ClutterRect       *rect,
-                                                         ClutterPoint      *point);
-CLUTTER_EXPORT
-gboolean                clutter_rect_contains_rect      (ClutterRect       *a,
-                                                         ClutterRect       *b);
-CLUTTER_EXPORT
-void                    clutter_rect_union              (ClutterRect       *a,
-                                                         ClutterRect       *b,
-                                                         ClutterRect       *res);
-CLUTTER_EXPORT
-gboolean                clutter_rect_intersection       (ClutterRect       *a,
-                                                         ClutterRect       *b,
-                                                         ClutterRect       *res);
-CLUTTER_EXPORT
-void                    clutter_rect_offset             (ClutterRect       *rect,
-                                                         float              d_x,
-                                                         float              d_y);
-CLUTTER_EXPORT
-void                    clutter_rect_inset              (ClutterRect       *rect,
-                                                         float              d_x,
-                                                         float              d_y);
-CLUTTER_EXPORT
-void                    clutter_rect_clamp_to_pixel     (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_x              (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_y              (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_width          (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_height         (ClutterRect       *rect);
-
-/**
- * ClutterVertex:
- * @x: X coordinate of the vertex
- * @y: Y coordinate of the vertex
- * @z: Z coordinate of the vertex
- *
- * A point in 3D space, expressed in pixels
- *
- * Since: 0.4
- */
-struct _ClutterVertex
-{
-  gfloat x;
-  gfloat y;
-  gfloat z;
-};
-
-/**
- * CLUTTER_VERTEX_INIT:
- * @x: the X coordinate of the vertex
- * @y: the Y coordinate of the vertex
- * @z: the Z coordinate of the vertex
- *
- * A simple macro for initializing a #ClutterVertex when declaring it, e.g.:
- *
- * |[
- *   ClutterVertex v = CLUTTER_VERTEX_INIT (x, y, z);
- * ]|
- *
- * Since: 1.10
- */
-#define CLUTTER_VERTEX_INIT(x,y,z)      { (x), (y), (z) }
-
-/**
- * CLUTTER_VERTEX_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterVertex to (0, 0, 0).
- *
- * Since: 1.12
- */
-#define CLUTTER_VERTEX_INIT_ZERO        CLUTTER_VERTEX_INIT (0.f, 0.f, 0.f)
-
-CLUTTER_EXPORT
-GType          clutter_vertex_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_new      (gfloat               x,
-                                        gfloat               y,
-                                        gfloat               z);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_alloc    (void);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_init     (ClutterVertex       *vertex,
-                                        gfloat               x,
-                                        gfloat               y,
-                                        gfloat               z);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_copy     (const ClutterVertex *vertex);
-CLUTTER_EXPORT
-void           clutter_vertex_free     (ClutterVertex       *vertex);
-CLUTTER_EXPORT
-gboolean       clutter_vertex_equal    (const ClutterVertex *vertex_a,
-                                        const ClutterVertex *vertex_b);
-
 /**
 * ClutterActorBox:
 * @x1: X coordinate of the top left corner
@@ -539,7 +231,7 @@ gboolean         clutter_actor_box_contains      (const ClutterActorBox *box,
                                                  gfloat                 y);
 CLUTTER_EXPORT
 void             clutter_actor_box_from_vertices (ClutterActorBox       *box,
-                                                  const ClutterVertex    verts[]);
+                                                  const graphene_point3d_t verts[]);
 CLUTTER_EXPORT
 void             clutter_actor_box_interpolate   (const ClutterActorBox *initial,
                                                  const ClutterActorBox *final,
@@ -561,40 +253,9 @@ void             clutter_actor_box_set_size       (ClutterActorBox       *box,
                                                   gfloat                 width,
                                                   gfloat                 height);

-/**
- * ClutterGeometry:
- * @x: X coordinate of the top left corner of an actor
- * @y: Y coordinate of the top left corner of an actor
- * @width: width of an actor
- * @height: height of an actor
- *
- * The rectangle containing an actor's bounding box, measured in pixels.
- *
- * You should not use #ClutterGeometry, or operate on its fields
- * directly; you should use #cairo_rectangle_int_t or #ClutterRect if you
- * need a rectangle type, depending on the precision required.
- *
- * Deprecated: 1.16
- */
-struct _ClutterGeometry
-{
-  /*< public >*/
-  gint   x;
-  gint   y;
-  guint  width;
-  guint  height;
-};
-
 CLUTTER_EXPORT
-GType clutter_geometry_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-void      clutter_geometry_union      (const ClutterGeometry *geometry_a,
-                                       const ClutterGeometry *geometry_b,
-                                       ClutterGeometry       *result);
-CLUTTER_DEPRECATED
-gboolean  clutter_geometry_intersects (const ClutterGeometry *geometry0,
-                                       const ClutterGeometry *geometry1);
+void             clutter_actor_box_scale          (ClutterActorBox       *box,
+                                                   gfloat                 scale);

 /**
 * ClutterKnot:
@@ -667,10 +328,10 @@ void                clutter_paint_volume_free                (ClutterPaintVolume

 CLUTTER_EXPORT
 void                clutter_paint_volume_set_origin          (ClutterPaintVolume       *pv,
-                                                              const ClutterVertex      *origin);
+                                                              const graphene_point3d_t *origin);
 CLUTTER_EXPORT
 void                clutter_paint_volume_get_origin          (const ClutterPaintVolume *pv,
-                                                              ClutterVertex            *vertex);
+                                                              graphene_point3d_t       *vertex);
 CLUTTER_EXPORT
 void                clutter_paint_volume_set_width           (ClutterPaintVolume       *pv,
                                                              gfloat                    width);
--- a/clutter/clutter/clutter-util.c
+++ b/clutter/clutter/clutter-util.c
@@ -39,29 +39,6 @@
 #include "clutter-interval.h"
 #include "clutter-private.h"

-#include "deprecated/clutter-util.h"
-
-/**
- * clutter_util_next_p2:
- * @a: Value to get the next power
- *
- * Calculates the nearest power of two, greater than or equal to @a.
- *
- * Return value: The nearest power of two, greater or equal to @a.
- *
- * Deprecated: 1.2
- */
-gint
-clutter_util_next_p2 (gint a)
-{
-  int rval = 1;
-
-  while (rval < a)
-    rval <<= 1;
-
-  return rval;
-}
-
 /* Help macros to scale from OpenGL <-1,1> coordinates system to
 * window coordinates ranging [0,window-size]
 */
@@ -73,8 +50,8 @@ void
 _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
                                        const CoglMatrix *projection,
                                        const float *viewport,
-                                        const ClutterVertex *vertices_in,
-                                        ClutterVertex *vertices_out,
+                                        const graphene_point3d_t *vertices_in,
+                                        graphene_point3d_t *vertices_out,
                                        int n_vertices)
 {
  CoglMatrix modelview_projection;
@@ -91,7 +68,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
                            modelview);
      cogl_matrix_project_points (&modelview_projection,
                                  3,
-                                  sizeof (ClutterVertex),
+                                  sizeof (graphene_point3d_t),
                                  vertices_in,
                                  sizeof (ClutterVertex4),
                                  vertices_tmp,
@@ -101,7 +78,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
    {
      cogl_matrix_transform_points (modelview,
                                    3,
-                                    sizeof (ClutterVertex),
+                                    sizeof (graphene_point3d_t),
                                    vertices_in,
                                    sizeof (ClutterVertex4),
                                    vertices_tmp,
@@ -119,7 +96,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
  for (i = 0; i < n_vertices; i++)
    {
      ClutterVertex4 vertex_tmp = vertices_tmp[i];
-      ClutterVertex *vertex_out = &vertices_out[i];
+      graphene_point3d_t *vertex_out = &vertices_out[i];
      /* Finally translate from OpenGL coords to window coords */
      vertex_out->x = MTX_GL_SCALE_X (vertex_tmp.x, vertex_tmp.w,
                                      viewport[2], viewport[0]);
@@ -128,6 +105,47 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
    }
 }

+void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
+                                        graphene_rect_t             *dest)
+{
+  *dest = (graphene_rect_t) {
+    .origin = {
+      .x = src->x,
+      .y = src->y
+    },
+    .size = {
+      .width = src->width,
+      .height = src->height
+    }
+  };
+}
+
+void _clutter_util_rectangle_int_extents (const  graphene_rect_t *src,
+                                          cairo_rectangle_int_t  *dest)
+{
+  graphene_rect_t tmp = *src;
+
+  graphene_rect_round (&tmp, &tmp);
+
+  *dest = (cairo_rectangle_int_t) {
+    .x = tmp.origin.x,
+    .y = tmp.origin.y,
+    .width = tmp.size.width,
+    .height = tmp.size.height,
+  };
+}
+
+void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
+                                     int                          x,
+                                     int                          y,
+                                     cairo_rectangle_int_t       *dest)
+{
+  *dest = *src;
+
+  dest->x += x;
+  dest->y += y;
+}
+
 /*< private >
 * _clutter_util_rectangle_union:
 * @src1: first rectangle to union
@@ -192,346 +210,6 @@ _clutter_util_rectangle_intersection (const cairo_rectangle_int_t *src1,
    }
 }

-float
-_clutter_util_matrix_determinant (const ClutterMatrix *matrix)
-{
-  return matrix->xw * matrix->yz * matrix->zy * matrix->wz
-       - matrix->xz * matrix->yw * matrix->zy * matrix->wz
-       - matrix->xw * matrix->yy * matrix->zz * matrix->wz
-       + matrix->xy * matrix->yw * matrix->zz * matrix->wz
-       + matrix->xz * matrix->yy * matrix->zw * matrix->wz
-       - matrix->xy * matrix->yz * matrix->zw * matrix->wz
-       - matrix->xw * matrix->yz * matrix->zx * matrix->wy
-       + matrix->xz * matrix->yw * matrix->zx * matrix->wy
-       + matrix->xw * matrix->yx * matrix->zz * matrix->wy
-       - matrix->xx * matrix->yw * matrix->zz * matrix->wy
-       - matrix->xz * matrix->yx * matrix->zw * matrix->wy
-       + matrix->xx * matrix->yz * matrix->zw * matrix->wy
-       + matrix->xw * matrix->yy * matrix->zx * matrix->wz
-       - matrix->xy * matrix->yw * matrix->zx * matrix->wz
-       - matrix->xw * matrix->yx * matrix->zy * matrix->wz
-       + matrix->xx * matrix->yw * matrix->zy * matrix->wz
-       + matrix->xy * matrix->yx * matrix->zw * matrix->wz
-       - matrix->xx * matrix->yy * matrix->zw * matrix->wz
-       - matrix->xz * matrix->yy * matrix->zx * matrix->ww
-       + matrix->xy * matrix->yz * matrix->zx * matrix->ww
-       + matrix->xz * matrix->yx * matrix->zy * matrix->ww
-       - matrix->xx * matrix->yz * matrix->zy * matrix->ww
-       - matrix->xy * matrix->yx * matrix->zz * matrix->ww
-       + matrix->xx * matrix->yy * matrix->zz * matrix->ww;
-}
-
-static void
-_clutter_util_matrix_transpose_vector4_transform (const ClutterMatrix  *matrix,
-                                                  const ClutterVertex4 *point,
-                                                  ClutterVertex4       *res)
-{
-  res->x = matrix->xx * point->x
-         + matrix->xy * point->y
-         + matrix->xz * point->z
-         + matrix->xw * point->w;
-
-  res->y = matrix->yx * point->x
-         + matrix->yy * point->y
-         + matrix->yz * point->z
-         + matrix->yw * point->w;
-
-  res->z = matrix->zx * point->x
-         + matrix->zy * point->y
-         + matrix->zz * point->z
-         + matrix->zw * point->w;
-
-  res->w = matrix->wz * point->x
-         + matrix->wy * point->w
-         + matrix->wz * point->z
-         + matrix->ww * point->w;
-}
-
-void
-_clutter_util_matrix_skew_xy (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->yx += matrix->xx * factor;
-  matrix->yy += matrix->xy * factor;
-  matrix->yz += matrix->xz * factor;
-  matrix->yw += matrix->xw * factor;
-}
-
-void
-_clutter_util_matrix_skew_xz (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->zx += matrix->xx * factor;
-  matrix->zy += matrix->xy * factor;
-  matrix->zz += matrix->xz * factor;
-  matrix->zw += matrix->xw * factor;
-}
-
-void
-_clutter_util_matrix_skew_yz (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->zx += matrix->yx * factor;
-  matrix->zy += matrix->yy * factor;
-  matrix->zz += matrix->yz * factor;
-  matrix->zw += matrix->yw * factor;
-}
-
-static float
-_clutter_util_vertex_length (const ClutterVertex *vertex)
-{
-  return sqrtf (vertex->x * vertex->x + vertex->y * vertex->y + vertex->z * vertex->z);
-}
-
-static void
-_clutter_util_vertex_normalize (ClutterVertex *vertex)
-{
-  float factor = _clutter_util_vertex_length (vertex);
-
-  if (factor == 0.f)
-    return;
-
-  vertex->x /= factor;
-  vertex->y /= factor;
-  vertex->z /= factor;
-}
-
-static float
-_clutter_util_vertex_dot (const ClutterVertex *v1,
-                          const ClutterVertex *v2)
-{
-  return v1->x * v2->x + v1->y * v2->y + v1->z * v2->z;
-}
-
-static void
-_clutter_util_vertex_cross (const ClutterVertex *v1,
-                            const ClutterVertex *v2,
-                            ClutterVertex       *res)
-{
-  res->x = v1->y * v2->z - v2->y * v1->z;
-  res->y = v1->z * v2->x - v2->z * v1->x;
-  res->z = v1->x * v2->y - v2->x * v1->y;
-}
-
-static void
-_clutter_util_vertex_combine (const ClutterVertex *a,
-                              const ClutterVertex *b,
-                              double               ascl,
-                              double               bscl,
-                              ClutterVertex       *res)
-{
-  res->x = (ascl * a->x) + (bscl * b->x);
-  res->y = (ascl * a->y) + (bscl * b->y);
-  res->z = (ascl * a->z) + (bscl * b->z);
-}
-
-void
-_clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
-                                   const ClutterVertex4 *b,
-                                   double                progress,
-                                   ClutterVertex4       *res)
-{
-  res->x = a->x + (b->x - a->x) * progress;
-  res->y = a->y + (b->y - a->y) * progress;
-  res->z = a->z + (b->z - a->z) * progress;
-  res->w = a->w + (b->w - a->w) * progress;
-}
-
-/*< private >
- * clutter_util_matrix_decompose:
- * @src: the matrix to decompose
- * @scale_p: (out caller-allocates): return location for a vertex containing
- *   the scaling factors
- * @shear_p: (out) (array length=3): return location for an array of 3
- *   elements containing the skew factors (XY, XZ, and YZ respectively)
- * @rotate_p: (out caller-allocates): return location for a vertex containing
- *   the Euler angles
- * @translate_p: (out caller-allocates): return location for a vertex
- *   containing the translation vector
- * @perspective_p: (out caller-allocates: return location for a 4D vertex
- *   containing the perspective
- *
- * Decomposes a #ClutterMatrix into the transformations that compose it.
- *
- * This code is based on the matrix decomposition algorithm as published in
- * the CSS Transforms specification by the W3C CSS working group, available
- * at http://www.w3.org/TR/css3-transforms/.
- *
- * The algorithm, in turn, is based on the "unmatrix" method published in
- * "Graphics Gems II, edited by Jim Arvo", which is available at:
- * http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c
- *
- * Return value: %TRUE if the decomposition was successful, and %FALSE
- *   if the matrix is singular
- */
-gboolean
-_clutter_util_matrix_decompose (const ClutterMatrix *src,
-                                ClutterVertex       *scale_p,
-                                float                shear_p[3],
-                                ClutterVertex       *rotate_p,
-                                ClutterVertex       *translate_p,
-                                ClutterVertex4      *perspective_p)
-{
-  CoglMatrix matrix = *src;
-  CoglMatrix perspective;
-  ClutterVertex4 vertex_tmp;
-  ClutterVertex row[3], pdum;
-  int i, j;
-
-#define XY_SHEAR        0
-#define XZ_SHEAR        1
-#define YZ_SHEAR        2
-#define MAT(m,r,c)      ((float *)(m))[(c) * 4 + (r)]
-
-  /* normalize the matrix */
-  if (matrix.ww == 0.f)
-    return FALSE;
-
-  for (i = 0; i < 4; i++)
-    {
-      for (j = 0; j < 4; j++)
-        {
-          MAT (&matrix, j, i) /= MAT (&matrix, 3, 3);
-        }
-    }
-
-  /* perspective is used to solve for perspective, but it also provides
-   * an easy way to test for singularity of the upper 3x3 component
-   */
-  perspective = matrix;
-
-  /* transpose */
-  MAT (&perspective, 3, 0) = 0.f;
-  MAT (&perspective, 3, 1) = 0.f;
-  MAT (&perspective, 3, 2) = 0.f;
-  MAT (&perspective, 3, 3) = 1.f;
-
-  if (_clutter_util_matrix_determinant (&perspective) == 0.f)
-    return FALSE;
-
-  if (MAT (&matrix, 3, 0) != 0.f ||
-      MAT (&matrix, 3, 1) != 0.f ||
-      MAT (&matrix, 3, 2) != 0.f)
-    {
-      CoglMatrix perspective_inv;
-      ClutterVertex4 p;
-
-      vertex_tmp.x = MAT (&matrix, 3, 0);
-      vertex_tmp.y = MAT (&matrix, 3, 1);
-      vertex_tmp.z = MAT (&matrix, 3, 2);
-      vertex_tmp.w = MAT (&matrix, 3, 3);
-
-      /* solve the equation by inverting perspective... */
-      cogl_matrix_get_inverse (&perspective, &perspective_inv);
-
-      /* ... and multiplying vertex_tmp by the inverse */
-      _clutter_util_matrix_transpose_vector4_transform (&perspective_inv,
-                                                        &vertex_tmp,
-                                                        &p);
-
-      *perspective_p = p;
-
-      /* clear the perspective part */
-      MAT (&matrix, 3, 0) = 0.0f;
-      MAT (&matrix, 3, 1) = 0.0f;
-      MAT (&matrix, 3, 2) = 0.0f;
-      MAT (&matrix, 3, 3) = 1.0f;
-    }
-  else
-    {
-      /* no perspective */
-      perspective_p->x = 0.0f;
-      perspective_p->y = 0.0f;
-      perspective_p->z = 0.0f;
-      perspective_p->w = 1.0f;
-    }
-
-  /* translation */
-  translate_p->x = MAT (&matrix, 0, 3);
-  MAT (&matrix, 0, 3) = 0.f;
-  translate_p->y = MAT (&matrix, 1, 3);
-  MAT (&matrix, 1, 3) = 0.f;
-  translate_p->z = MAT (&matrix, 2, 3);
-  MAT (&matrix, 2, 3) = 0.f;
-
-  /* scale and shear; we split the upper 3x3 matrix into rows */
-  for (i = 0; i < 3; i++)
-    {
-      row[i].x = MAT (&matrix, i, 0);
-      row[i].y = MAT (&matrix, i, 1);
-      row[i].z = MAT (&matrix, i, 2);
-    }
-
-  /* compute scale.x and normalize the first row */
-  scale_p->x = _clutter_util_vertex_length (&row[0]);
-  _clutter_util_vertex_normalize (&row[0]);
-
-  /* compute XY shear and make the second row orthogonal to the first */
-  shear_p[XY_SHEAR] = _clutter_util_vertex_dot (&row[0], &row[1]);
-  _clutter_util_vertex_combine (&row[1], &row[0],
-                                1.0, -shear_p[XY_SHEAR],
-                                &row[1]);
-
-  /* compute the Y scale and normalize the second row */
-  scale_p->y = _clutter_util_vertex_length (&row[1]);
-  _clutter_util_vertex_normalize (&row[1]);
-  shear_p[XY_SHEAR] /= scale_p->y;
-
-  /* compute XZ and YZ shears, orthogonalize the third row */
-  shear_p[XZ_SHEAR] = _clutter_util_vertex_dot (&row[0], &row[2]);
-  _clutter_util_vertex_combine (&row[2], &row[0],
-                                1.0, -shear_p[XZ_SHEAR],
-                                &row[2]);
-
-  shear_p[YZ_SHEAR] = _clutter_util_vertex_dot (&row[1], &row[2]);
-  _clutter_util_vertex_combine (&row[2], &row[1],
-                                1.0, -shear_p[YZ_SHEAR],
-                                &row[2]);
-
-  /* get the Z scale and normalize the third row*/
-  scale_p->z = _clutter_util_vertex_length (&row[2]);
-  _clutter_util_vertex_normalize (&row[2]);
-  shear_p[XZ_SHEAR] /= scale_p->z;
-  shear_p[YZ_SHEAR] /= scale_p->z;
-
-  /* at this point, the matrix (inside row[]) is orthonormal.
-   * check for a coordinate system flip; if the determinant
-   * is -1, then negate the matrix and scaling factors
-   */
-  _clutter_util_vertex_cross (&row[1], &row[2], &pdum);
-  if (_clutter_util_vertex_dot (&row[0], &pdum) < 0.f)
-    {
-      scale_p->x *= -1.f;
-
-      for (i = 0; i < 3; i++)
-        {
-          row[i].x *= -1.f;
-          row[i].y *= -1.f;
-          row[i].z *= -1.f;
-        }
-    }
-
-  /* now get the rotations out */
-  rotate_p->y = asinf (-row[0].z);
-  if (cosf (rotate_p->y) != 0.f)
-    {
-      rotate_p->x = atan2f (row[1].z, row[2].z);
-      rotate_p->z = atan2f (row[0].y, row[0].x);
-    }
-  else
-    {
-      rotate_p->x = atan2f (-row[2].x, row[1].y);
-      rotate_p->z = 0.f;
-    }
-
-#undef XY_SHEAR
-#undef XZ_SHEAR
-#undef YZ_SHEAR
-#undef MAT
-
-  return TRUE;
-}
-
 typedef struct
 {
  GType value_type;
--- a/clutter/clutter/clutter-zoom-action.c
+++ b/clutter/clutter/clutter-zoom-action.c
@@ -80,9 +80,9 @@ struct _ClutterZoomActionPrivate

  ZoomPoint points[2];

-  ClutterPoint initial_focal_point;
-  ClutterPoint focal_point;
-  ClutterPoint transformed_focal_point;
+  graphene_point_t initial_focal_point;
+  graphene_point_t focal_point;
+  graphene_point_t transformed_focal_point;

  gfloat initial_x;
  gfloat initial_y;
@@ -238,13 +238,13 @@ clutter_zoom_action_gesture_cancel (ClutterGestureAction *action,
 static gboolean
 clutter_zoom_action_real_zoom (ClutterZoomAction *action,
                               ClutterActor      *actor,
-                               ClutterPoint      *focal_point,
+                               graphene_point_t  *focal_point,
                               gdouble            factor)
 {
  ClutterZoomActionPrivate *priv = action->priv;
  gfloat x, y, z;
  gdouble scale_x, scale_y;
-  ClutterVertex out, in;
+  graphene_point3d_t out, in;

  in.x = priv->transformed_focal_point.x;
  in.y = priv->transformed_focal_point.y;
@@ -400,7 +400,7 @@ clutter_zoom_action_class_init (ClutterZoomActionClass *klass)
                  _clutter_marshal_BOOLEAN__OBJECT_BOXED_DOUBLE,
                  G_TYPE_BOOLEAN, 3,
                  CLUTTER_TYPE_ACTOR,
-                  CLUTTER_TYPE_POINT,
+                  GRAPHENE_TYPE_POINT,
                  G_TYPE_DOUBLE);
 }

@@ -478,7 +478,7 @@ clutter_zoom_action_get_zoom_axis (ClutterZoomAction *action)
 /**
 * clutter_zoom_action_get_focal_point:
 * @action: a #ClutterZoomAction
- * @point: (out): a #ClutterPoint
+ * @point: (out): a #graphene_point_t
 *
 * Retrieves the focal point of the current zoom
 *
@@ -486,7 +486,7 @@ clutter_zoom_action_get_zoom_axis (ClutterZoomAction *action)
 */
 void
 clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
-                                     ClutterPoint      *point)
+                                     graphene_point_t  *point)
 {
  g_return_if_fail (CLUTTER_IS_ZOOM_ACTION (action));
  g_return_if_fail (point != NULL);
@@ -497,7 +497,7 @@ clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
 /**
 * clutter_zoom_action_get_transformed_focal_point:
 * @action: a #ClutterZoomAction
- * @point: (out): a #ClutterPoint
+ * @point: (out): a #graphene_point_t
 *
 * Retrieves the focal point relative to the actor's coordinates of
 * the current zoom
@@ -506,7 +506,7 @@ clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
 */
 void
 clutter_zoom_action_get_transformed_focal_point (ClutterZoomAction *action,
-                                                 ClutterPoint      *point)
+                                                 graphene_point_t  *point)
 {
  g_return_if_fail (CLUTTER_IS_ZOOM_ACTION (action));
  g_return_if_fail (point != NULL);
--- a/clutter/clutter/clutter-zoom-action.h
+++ b/clutter/clutter/clutter-zoom-action.h
@@ -79,7 +79,7 @@ struct _ClutterZoomActionClass
  /*< public >*/
  gboolean (* zoom)  (ClutterZoomAction *action,
                      ClutterActor      *actor,
-                      ClutterPoint      *focal_point,
+                      graphene_point_t  *focal_point,
                      gdouble            factor);

  /*< private >*/
@@ -104,10 +104,10 @@ ClutterZoomAxis clutter_zoom_action_get_zoom_axis               (ClutterZoomActi

 CLUTTER_EXPORT
 void            clutter_zoom_action_get_focal_point             (ClutterZoomAction *action,
-                                                                 ClutterPoint      *point);
+                                                                 graphene_point_t  *point);
 CLUTTER_EXPORT
 void            clutter_zoom_action_get_transformed_focal_point (ClutterZoomAction *action,
-                                                                 ClutterPoint      *point);
+                                                                 graphene_point_t  *point);

 G_END_DECLS

--- a/clutter/clutter/clutter.h
+++ b/clutter/clutter/clutter.h
@@ -76,6 +76,7 @@
 #include "clutter-input-focus.h"
 #include "clutter-interval.h"
 #include "clutter-keyframe-transition.h"
+#include "clutter-keymap.h"
 #include "clutter-keysyms.h"
 #include "clutter-layout-manager.h"
 #include "clutter-layout-meta.h"
--- a/clutter/clutter/cogl/clutter-stage-cogl.c
+++ b/clutter/clutter/cogl/clutter-stage-cogl.c
@@ -60,7 +60,8 @@ typedef struct _ClutterStageViewCoglPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (ClutterStageViewCogl, clutter_stage_view_cogl,
                            CLUTTER_TYPE_STAGE_VIEW)

-static void clutter_stage_window_iface_init (ClutterStageWindowIface *iface);
+static void
+clutter_stage_window_iface_init (ClutterStageWindowInterface *iface);

 G_DEFINE_TYPE_WITH_CODE (ClutterStageCogl,
                         _clutter_stage_cogl,
@@ -68,7 +69,8 @@ G_DEFINE_TYPE_WITH_CODE (ClutterStageCogl,
                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_STAGE_WINDOW,
                                                clutter_stage_window_iface_init));

-enum {
+enum
+{
  PROP_0,
  PROP_WRAPPER,
  PROP_BACKEND,
@@ -549,31 +551,19 @@ calculate_scissor_region (cairo_rectangle_int_t *fb_clip_region,
                          int                    fb_height,
                          cairo_rectangle_int_t *out_scissor_rect)
 {
-  int scissor_x;
-  int scissor_y;
-  int scissor_width;
-  int scissor_height;
+  *out_scissor_rect = *fb_clip_region;

-  scissor_x = fb_clip_region->x;
-  scissor_y = fb_clip_region->y;
-  scissor_width = fb_clip_region->width;
-  scissor_height = fb_clip_region->height;
+  if (subpixel_compensation == 0)
+    return;

  if (fb_clip_region->x > 0)
-    scissor_x += subpixel_compensation;
+    out_scissor_rect->x += subpixel_compensation;
  if (fb_clip_region->y > 0)
-    scissor_y += subpixel_compensation;
+    out_scissor_rect->y += subpixel_compensation;
  if (fb_clip_region->x + fb_clip_region->width < fb_width)
-    scissor_width -= 2 * subpixel_compensation;
+    out_scissor_rect->width -= 2 * subpixel_compensation;
  if (fb_clip_region->y + fb_clip_region->height < fb_height)
-    scissor_height -= 2 * subpixel_compensation;
-
-  *out_scissor_rect = (cairo_rectangle_int_t) {
-    .x = scissor_x,
-    .y = scissor_y,
-    .width = scissor_width,
-    .height = scissor_height
-  };
+    out_scissor_rect->height -= 2 * subpixel_compensation;
 }

 static inline gboolean
@@ -585,6 +575,18 @@ is_buffer_age_enabled (void)
         cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE);
 }

+static void
+scale_and_clamp_rect (const graphene_rect_t *rect,
+                      float                  scale,
+                      cairo_rectangle_int_t *dest)
+
+{
+  graphene_rect_t tmp = *rect;
+
+  graphene_rect_scale (&tmp, scale, scale, &tmp);
+  _clutter_util_rectangle_int_extents (&tmp, dest);
+}
+
 static gboolean
 clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
                                ClutterStageView   *view)
@@ -648,21 +650,22 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
       * frames when starting up... */
      cogl_onscreen_get_frame_counter (COGL_ONSCREEN (fb)) > 3)
    {
+      graphene_rect_t rect;
+
      may_use_clipped_redraw = TRUE;

-      if (fb_scale != floorf (fb_scale))
-        subpixel_compensation = ceilf (fb_scale);
+      _clutter_util_rect_from_rectangle (&redraw_clip, &rect);
+      graphene_rect_offset (&rect, -view_rect.x, -view_rect.y);
+      scale_and_clamp_rect (&rect, fb_scale, &fb_clip_region);

-      fb_clip_region = (cairo_rectangle_int_t) {
-        .x = (floorf ((redraw_clip.x - view_rect.x) * fb_scale) -
-              subpixel_compensation),
-        .y = (floorf ((redraw_clip.y - view_rect.y) * fb_scale) -
-              subpixel_compensation),
-        .width = (ceilf (redraw_clip.width * fb_scale) +
-                  (2 * subpixel_compensation)),
-        .height = (ceilf (redraw_clip.height * fb_scale) +
-                   (2 * subpixel_compensation))
-      };
+      if (fb_scale != floorf (fb_scale))
+        {
+          subpixel_compensation = ceilf (fb_scale);
+          fb_clip_region.x -= subpixel_compensation;
+          fb_clip_region.y -= subpixel_compensation;
+          fb_clip_region.width += 2 * subpixel_compensation;
+          fb_clip_region.height += 2 * subpixel_compensation;
+        }
    }
  else
    {
@@ -690,6 +693,7 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,

          if (valid_buffer_age (view_cogl, age))
            {
+              graphene_rect_t rect;
              cairo_rectangle_int_t damage_region;

              *current_fb_damage = fb_clip_region;
@@ -705,12 +709,12 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
                }

              /* Update the bounding redraw clip state with the extra damage. */
-              damage_region = (cairo_rectangle_int_t) {
-                .x = view_rect.x + floorf (fb_clip_region.x / fb_scale),
-                .y = view_rect.y + floorf (fb_clip_region.y / fb_scale),
-                .width = ceilf (fb_clip_region.width / fb_scale),
-                .height = ceilf (fb_clip_region.height / fb_scale)
-              };
+              _clutter_util_rect_from_rectangle (&fb_clip_region, &rect);
+              scale_and_clamp_rect (&rect, 1.0f / fb_scale, &damage_region);
+              _clutter_util_rectangle_offset (&damage_region,
+                                              view_rect.x,
+                                              view_rect.y,
+                                              &damage_region);
              _clutter_util_rectangle_union (&stage_cogl->bounding_redraw_clip,
                                             &damage_region,
                                             &stage_cogl->bounding_redraw_clip);
@@ -749,7 +753,9 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
    }
  else if (use_clipped_redraw)
    {
+      graphene_rect_t rect;
      cairo_rectangle_int_t scissor_rect;
+      cairo_rectangle_int_t paint_rect;

      calculate_scissor_region (&fb_clip_region,
                                subpixel_compensation,
@@ -770,13 +776,15 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
                                          scissor_rect.y,
                                          scissor_rect.width,
                                          scissor_rect.height);
-      paint_stage (stage_cogl, view,
-                   &(cairo_rectangle_int_t) {
-                     .x = view_rect.x + floorf ((fb_clip_region.x - 0) / fb_scale),
-                     .y = view_rect.y + floorf ((fb_clip_region.y - 0) / fb_scale),
-                     .width = ceilf ((fb_clip_region.width + 0) / fb_scale),
-                     .height = ceilf ((fb_clip_region.height + 0) / fb_scale)
-                   });
+
+      _clutter_util_rect_from_rectangle (&fb_clip_region, &rect);
+      scale_and_clamp_rect (&rect, 1.0f / fb_scale, &paint_rect);
+      _clutter_util_rectangle_offset (&paint_rect,
+                                      view_rect.x,
+                                      view_rect.y,
+                                      &paint_rect);
+
+      paint_stage (stage_cogl, view, &paint_rect);
      cogl_framebuffer_pop_clip (fb);

      stage_cogl->using_clipped_redraw = FALSE;
@@ -791,7 +799,9 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
          may_use_clipped_redraw &&
          !clip_region_empty)
        {
+          graphene_rect_t rect;
          cairo_rectangle_int_t scissor_rect;
+          cairo_rectangle_int_t paint_rect;

          calculate_scissor_region (&fb_clip_region,
                                    subpixel_compensation,
@@ -803,13 +813,15 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
                                              scissor_rect.y,
                                              scissor_rect.width,
                                              scissor_rect.height);
-          paint_stage (stage_cogl, view,
-                       &(cairo_rectangle_int_t) {
-                         .x = view_rect.x + floorf (fb_clip_region.x / fb_scale),
-                         .y = view_rect.y + floorf (fb_clip_region.y / fb_scale),
-                         .width = ceilf (fb_clip_region.width / fb_scale),
-                         .height = ceilf (fb_clip_region.height / fb_scale)
-                       });
+
+          _clutter_util_rect_from_rectangle (&fb_clip_region, &rect);
+          scale_and_clamp_rect (&rect, 1.0f / fb_scale, &paint_rect);
+          _clutter_util_rectangle_offset (&paint_rect,
+                                          view_rect.x,
+                                          view_rect.y,
+                                          &paint_rect);
+
+          paint_stage (stage_cogl, view, &paint_rect);
          cogl_framebuffer_pop_clip (fb);
        }
      else
@@ -994,7 +1006,7 @@ clutter_stage_cogl_get_dirty_pixel (ClutterStageWindow *stage_window,
 }

 static void
-clutter_stage_window_iface_init (ClutterStageWindowIface *iface)
+clutter_stage_window_iface_init (ClutterStageWindowInterface *iface)
 {
  iface->realize = clutter_stage_cogl_realize;
  iface->unrealize = clutter_stage_cogl_unrealize;
--- a/clutter/clutter/deprecated/clutter-actor-deprecated.c
+++ b/clutter/clutter/deprecated/clutter-actor-deprecated.c
@@ -1,409 +0,0 @@
-#include "clutter-build-config.h"
-
-#include <glib-object.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "deprecated/clutter-actor.h"
-
-#include "clutter-actor-private.h"
-#include "clutter-private.h"
-#include "clutter-shader.h"
-
-typedef struct _ShaderData ShaderData;
-
-struct _ShaderData
-{
-  ClutterShader *shader;
-
-  /* back pointer to the actor */
-  ClutterActor *actor;
-
-  /* list of values that should be set on the shader
-   * before each paint cycle
-   */
-  GHashTable *value_hash;
-};
-
-static void
-shader_value_free (gpointer data)
-{
-  GValue *var = data;
-  g_value_unset (var);
-  g_slice_free (GValue, var);
-}
-
-static void
-destroy_shader_data (gpointer data)
-{
-  ShaderData *shader_data = data;
-
-  if (shader_data == NULL)
-    return;
-
-  if (shader_data->shader != NULL)
-    {
-      g_object_unref (shader_data->shader);
-      shader_data->shader = NULL;
-    }
-
-  if (shader_data->value_hash != NULL)
-    {
-      g_hash_table_destroy (shader_data->value_hash);
-      shader_data->value_hash = NULL;
-    }
-
-  g_slice_free (ShaderData, shader_data);
-}
-
-/**
- * clutter_actor_get_shader:
- * @self: a #ClutterActor
- *
- * Queries the currently set #ClutterShader on @self.
- *
- * Return value: (transfer none): The currently set #ClutterShader
- *   or %NULL if no shader is set.
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use clutter_actor_get_effect() instead.
- */
-ClutterShader *
-clutter_actor_get_shader (ClutterActor *self)
-{
-  ShaderData *shader_data;
-
-  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data != NULL)
-    return shader_data->shader;
-
-  return NULL;
-}
-
-/**
- * clutter_actor_set_shader:
- * @self: a #ClutterActor
- * @shader: (allow-none): a #ClutterShader or %NULL to unset the shader.
- *
- * Sets the #ClutterShader to be used when rendering @self.
- *
- * If @shader is %NULL this function will unset any currently set shader
- * for the actor.
- *
- * Any #ClutterEffect applied to @self will take the precedence
- * over the #ClutterShader set using this function.
- *
- * Return value: %TRUE if the shader was successfully applied
- *   or removed
- *
- * Since: 0.6
- *
- * Deprecated: 1.8: Use #ClutterShaderEffect and
- *   clutter_actor_add_effect() instead.
- */
-gboolean
-clutter_actor_set_shader (ClutterActor  *self,
-                          ClutterShader *shader)
-{
-  ShaderData *shader_data;
-
-  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
-  g_return_val_if_fail (shader == NULL || CLUTTER_IS_SHADER (shader), FALSE);
-
-  if (shader != NULL)
-    g_object_ref (shader);
-  else
-    {
-      /* if shader passed in is NULL we destroy the shader */
-      g_object_set_data (G_OBJECT (self), "-clutter-actor-shader-data", NULL);
-      return TRUE;
-    }
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    {
-      shader_data = g_slice_new (ShaderData);
-      shader_data->actor = self;
-      shader_data->shader = NULL;
-      shader_data->value_hash =
-        g_hash_table_new_full (g_str_hash, g_str_equal,
-                               g_free,
-                               shader_value_free);
-
-      g_object_set_data_full (G_OBJECT (self), "-clutter-actor-shader-data",
-                              shader_data,
-                              destroy_shader_data);
-    }
-
-  if (shader_data->shader != NULL)
-    g_object_unref (shader_data->shader);
-
-  shader_data->shader = shader;
-
-  clutter_actor_queue_redraw (self);
-
-  return TRUE;
-}
-
-static void
-set_each_param (gpointer key,
-                gpointer value,
-                gpointer user_data)
-{
-  ClutterShader *shader = user_data;
-  const gchar *uniform = key;
-  GValue *var = value;
-
-  clutter_shader_set_uniform (shader, uniform, var);
-}
-
-void
-_clutter_actor_shader_pre_paint (ClutterActor *actor,
-                                 gboolean      repeat)
-{
-  ShaderData *shader_data;
-  ClutterShader *shader;
-
-  shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    return;
-
-  shader = shader_data->shader;
-  if (shader != NULL)
-    {
-      clutter_shader_set_is_enabled (shader, TRUE);
-
-      g_hash_table_foreach (shader_data->value_hash, set_each_param, shader);
-
-      if (!repeat)
-        _clutter_context_push_shader_stack (actor);
-    }
-}
-
-void
-_clutter_actor_shader_post_paint (ClutterActor *actor)
-{
-  ShaderData *shader_data;
-  ClutterShader *shader;
-
-  shader_data = g_object_get_data (G_OBJECT (actor), "-clutter-actor-shader-data");
-  if (G_LIKELY (shader_data == NULL))
-    return;
-
-  shader = shader_data->shader;
-  if (shader != NULL)
-    {
-      ClutterActor *head;
-
-      clutter_shader_set_is_enabled (shader, FALSE);
-
-      /* remove the actor from the shaders stack; if there is another
-       * actor inside it, then call pre-paint again to set its shader
-       * but this time with the second argument being TRUE, indicating
-       * that we are re-applying an existing shader and thus should it
-       * not be prepended to the stack
-       */
-      head = _clutter_context_pop_shader_stack (actor);
-      if (head != NULL)
-        _clutter_actor_shader_pre_paint (head, TRUE);
-    }
-}
-
-static inline void
-clutter_actor_set_shader_param_internal (ClutterActor *self,
-                                         const gchar  *param,
-                                         const GValue *value)
-{
-  ShaderData *shader_data;
-  GValue *var;
-
-  shader_data = g_object_get_data (G_OBJECT (self), "-clutter-actor-shader-data");
-  if (shader_data == NULL)
-    return;
-
-  var = g_slice_new0 (GValue);
-  g_value_init (var, G_VALUE_TYPE (value));
-  g_value_copy (value, var);
-  g_hash_table_insert (shader_data->value_hash, g_strdup (param), var);
-
-  clutter_actor_queue_redraw (self);
-}
-
-/**
- * clutter_actor_set_shader_param:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named parameter of the shader applied
- * to @actor.
- *
- * Since: 1.0
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform_value() instead
- */
-void
-clutter_actor_set_shader_param (ClutterActor *self,
-                                const gchar  *param,
-                                const GValue *value)
-{
-  g_return_if_fail (CLUTTER_IS_ACTOR (self));
-  g_return_if_fail (param != NULL);
-  g_return_if_fail (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_INT (value) ||
-                    CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value) ||
-                    G_VALUE_HOLDS_FLOAT (value) ||
-                    G_VALUE_HOLDS_INT (value));
-
-  clutter_actor_set_shader_param_internal (self, param, value);
-}
-
-/**
- * clutter_actor_set_shader_param_float:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named float parameter of the shader applied
- * to @actor.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
- */
-void
-clutter_actor_set_shader_param_float (ClutterActor *self,
-                                      const gchar  *param,
-                                      gfloat        value)
-{
-  GValue var = { 0, };
-
-  g_value_init (&var, G_TYPE_FLOAT);
-  g_value_set_float (&var, value);
-
-  clutter_actor_set_shader_param_internal (self, param, &var);
-
-  g_value_unset (&var);
-}
-
-/**
- * clutter_actor_set_shader_param_int:
- * @self: a #ClutterActor
- * @param: the name of the parameter
- * @value: the value of the parameter
- *
- * Sets the value for a named int parameter of the shader applied to
- * @actor.
- *
- * Since: 0.8
- *
- * Deprecated: 1.8: Use clutter_shader_effect_set_uniform() instead
- */
-void
-clutter_actor_set_shader_param_int (ClutterActor *self,
-                                    const gchar  *param,
-                                    gint          value)
-{
-  GValue var = { 0, };
-
-  g_value_init (&var, G_TYPE_INT);
-  g_value_set_int (&var, value);
-
-  clutter_actor_set_shader_param_internal (self, param, &var);
-
-  g_value_unset (&var);
-}
-
-/**
- * clutter_actor_set_geometry:
- * @self: A #ClutterActor
- * @geometry: A #ClutterGeometry
- *
- * Sets the actor's fixed position and forces its minimum and natural
- * size, in pixels. This means the untransformed actor will have the
- * given geometry. This is the same as calling clutter_actor_set_position()
- * and clutter_actor_set_size().
- *
- * Deprecated: 1.10: Use clutter_actor_set_position() and
- *   clutter_actor_set_size() instead.
- */
-void
-clutter_actor_set_geometry (ClutterActor          *self,
-			    const ClutterGeometry *geometry)
-{
-  g_object_freeze_notify (G_OBJECT (self));
-
-  clutter_actor_set_position (self, geometry->x, geometry->y);
-  clutter_actor_set_size (self, geometry->width, geometry->height);
-
-  g_object_thaw_notify (G_OBJECT (self));
-}
-
-/**
- * clutter_actor_get_geometry:
- * @self: A #ClutterActor
- * @geometry: (out caller-allocates): A location to store actors #ClutterGeometry
- *
- * Gets the size and position of an actor relative to its parent
- * actor. This is the same as calling clutter_actor_get_position() and
- * clutter_actor_get_size(). It tries to "do what you mean" and get the
- * requested size and position if the actor's allocation is invalid.
- *
- * Deprecated: 1.10: Use clutter_actor_get_position() and
- *   clutter_actor_get_size(), or clutter_actor_get_allocation_geometry()
- *   instead.
- */
-void
-clutter_actor_get_geometry (ClutterActor    *self,
-			    ClutterGeometry *geometry)
-{
-  gfloat x, y, width, height;
-
-  g_return_if_fail (CLUTTER_IS_ACTOR (self));
-  g_return_if_fail (geometry != NULL);
-
-  clutter_actor_get_position (self, &x, &y);
-  clutter_actor_get_size (self, &width, &height);
-
-  geometry->x = (int) x;
-  geometry->y = (int) y;
-  geometry->width = (int) width;
-  geometry->height = (int) height;
-}
-
-/**
- * clutter_actor_get_allocation_geometry:
- * @self: A #ClutterActor
- * @geom: (out): allocation geometry in pixels
- *
- * Gets the layout box an actor has been assigned.  The allocation can
- * only be assumed valid inside a paint() method; anywhere else, it
- * may be out-of-date.
- *
- * An allocation does not incorporate the actor's scale or anchor point;
- * those transformations do not affect layout, only rendering.
- *
- * The returned rectangle is in pixels.
- *
- * Since: 0.8
- *
- * Deprecated: 1.12: Use clutter_actor_get_allocation_box() instead.
- */
-void
-clutter_actor_get_allocation_geometry (ClutterActor    *self,
-                                       ClutterGeometry *geom)
-{
-  ClutterActorBox box;
-
-  g_return_if_fail (CLUTTER_IS_ACTOR (self));
-  g_return_if_fail (geom != NULL);
-
-  clutter_actor_get_allocation_box (self, &box);
-
-  geom->x = CLUTTER_NEARBYINT (clutter_actor_box_get_x (&box));
-  geom->y = CLUTTER_NEARBYINT (clutter_actor_box_get_y (&box));
-  geom->width = CLUTTER_NEARBYINT (clutter_actor_box_get_width (&box));
-  geom->height = CLUTTER_NEARBYINT (clutter_actor_box_get_height (&box));
-}
--- a/clutter/clutter/deprecated/clutter-actor.h
+++ b/clutter/clutter/deprecated/clutter-actor.h
@@ -33,13 +33,6 @@

 G_BEGIN_DECLS

-CLUTTER_DEPRECATED
-void            clutter_actor_set_geometry                      (ClutterActor          *self,
-                                                                 const ClutterGeometry *geometry);
-
-CLUTTER_DEPRECATED_FOR(clutter_actor_get_allocation_geometry)
-void            clutter_actor_get_geometry                      (ClutterActor          *self,
-                                                                 ClutterGeometry       *geometry);
 CLUTTER_DEPRECATED
 guint32         clutter_actor_get_gid                           (ClutterActor          *self);

@@ -152,10 +145,6 @@ CLUTTER_DEPRECATED
 void            clutter_actor_get_transformation_matrix         (ClutterActor          *self,
                                                                 ClutterMatrix         *matrix);

-CLUTTER_DEPRECATED_FOR (clutter_actor_get_allocation_box)
-void            clutter_actor_get_allocation_geometry           (ClutterActor          *self,
-                                                                 ClutterGeometry       *geom);
-
 G_END_DECLS

 #endif /* __CLUTTER_ACTOR_DEPRECATED_H__ */
--- a/clutter/clutter/deprecated/clutter-animation.c
+++ b/clutter/clutter/deprecated/clutter-animation.c
@@ -2222,7 +2222,7 @@ clutter_actor_animate_with_timeline (ClutterActor    *actor,
 *
 * Will animate the "rotation-angle-z" property between the current value
 * and 360 degrees, and set the "rotation-center-z" property to the fixed
- * value of the #ClutterVertex "center".
+ * value of the #graphene_point3d_t "center".
 *
 * This function will implicitly create a #ClutterAnimation object which
 * will be assigned to the @actor and will be returned to the developer
--- a/clutter/clutter/deprecated/clutter-animator.c
+++ b/clutter/clutter/deprecated/clutter-animator.c
--- a/clutter/clutter/deprecated/clutter-animator.h
+++ b/clutter/clutter/deprecated/clutter-animator.h
@@ -1,188 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Copyright (C) 2010 Intel Corporation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author:
- *   Øyvind Kolås <pippin@linux.intel.com>
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_ANIMATOR_H__
-#define __CLUTTER_ANIMATOR_H__
-
-#include <clutter/clutter-types.h>
-#include <clutter/clutter-timeline.h>
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_ANIMATOR                   (clutter_animator_get_type ())
-#define CLUTTER_TYPE_ANIMATOR_KEY               (clutter_animator_key_get_type ())
-
-#define CLUTTER_ANIMATOR(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ANIMATOR, ClutterAnimator))
-#define CLUTTER_ANIMATOR_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ANIMATOR, ClutterAnimatorClass))
-#define CLUTTER_IS_ANIMATOR(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ANIMATOR))
-#define CLUTTER_IS_ANIMATOR_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ANIMATOR))
-#define CLUTTER_ANIMATOR_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ANIMATOR, ClutterAnimatorClass))
-
-/* ClutterAnimator is typedef in clutter-types.h */
-
-typedef struct _ClutterAnimatorClass   ClutterAnimatorClass;
-typedef struct _ClutterAnimatorPrivate ClutterAnimatorPrivate;
-
-/**
- * ClutterAnimatorKey:
- *
- * A key frame inside a #ClutterAnimator
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-typedef struct _ClutterAnimatorKey     ClutterAnimatorKey;
-
-/**
- * ClutterAnimator:
- *
- * The #ClutterAnimator structure contains only private data and
- * should be accessed using the provided API
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-struct _ClutterAnimator
-{
-  /*< private >*/
-  GObject parent_instance;
-
-  ClutterAnimatorPrivate *priv;
-};
-
-/**
- * ClutterAnimatorClass:
- *
- * The #ClutterAnimatorClass structure contains only private data
- *
- * Since: 1.2
- *
- * Deprecated: 1.12
- */
-struct _ClutterAnimatorClass
-{
-  /*< private >*/
-  GObjectClass parent_class;
-
-  /* padding for future expansion */
-  gpointer _padding_dummy[16];
-};
-
-CLUTTER_DEPRECATED
-GType                clutter_animator_get_type                   (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-ClutterAnimator *    clutter_animator_new                        (void);
-CLUTTER_DEPRECATED
-ClutterAnimator *    clutter_animator_set_key                    (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  guint                 mode,
-                                                                  gdouble               progress,
-                                                                  const GValue         *value);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set                        (ClutterAnimator      *animator,
-                                                                  gpointer              first_object,
-                                                                  const gchar          *first_property_name,
-                                                                  guint                 first_mode,
-                                                                  gdouble               first_progress,
-                                                                  ...) G_GNUC_NULL_TERMINATED;
-CLUTTER_DEPRECATED
-GList              * clutter_animator_get_keys                   (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress);
-
-CLUTTER_DEPRECATED
-void                 clutter_animator_remove_key                 (ClutterAnimator      *animator,
-                                                                  GObject              *object, 
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress);
-
-CLUTTER_DEPRECATED
-ClutterTimeline *    clutter_animator_start                      (ClutterAnimator      *animator);
-
-CLUTTER_DEPRECATED
-gboolean             clutter_animator_compute_value              (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gdouble               progress,
-                                                                  GValue               *value);
-
-CLUTTER_DEPRECATED
-ClutterTimeline *    clutter_animator_get_timeline               (ClutterAnimator      *animator);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set_timeline               (ClutterAnimator      *animator,
-                                                                  ClutterTimeline      *timeline);
-CLUTTER_DEPRECATED
-guint                clutter_animator_get_duration               (ClutterAnimator      *animator);
-CLUTTER_DEPRECATED
-void                 clutter_animator_set_duration               (ClutterAnimator      *animator,
-                                                                  guint                 duration);
-
-CLUTTER_DEPRECATED
-gboolean             clutter_animator_property_get_ease_in       (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name);
-CLUTTER_DEPRECATED
-void                 clutter_animator_property_set_ease_in       (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  gboolean              ease_in);
-
-CLUTTER_DEPRECATED
-ClutterInterpolation clutter_animator_property_get_interpolation (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name);
-CLUTTER_DEPRECATED
-void                 clutter_animator_property_set_interpolation (ClutterAnimator      *animator,
-                                                                  GObject              *object,
-                                                                  const gchar          *property_name,
-                                                                  ClutterInterpolation  interpolation);
-
-CLUTTER_DEPRECATED
-GType           clutter_animator_key_get_type           (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-GObject *       clutter_animator_key_get_object         (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-const gchar *   clutter_animator_key_get_property_name  (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-GType           clutter_animator_key_get_property_type  (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gulong          clutter_animator_key_get_mode           (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gdouble         clutter_animator_key_get_progress       (const ClutterAnimatorKey *key);
-CLUTTER_DEPRECATED
-gboolean        clutter_animator_key_get_value          (const ClutterAnimatorKey *key,
-                                                         GValue                   *value);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ANIMATOR_H__ */
--- a/clutter/clutter/deprecated/clutter-backend.h
+++ b/clutter/clutter/deprecated/clutter-backend.h
@@ -1,64 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *
- * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
- * Copyright (C) 2009, 2010 Intel Corp
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_BACKEND_DEPRECATED_H__
-#define __CLUTTER_BACKEND_DEPRECATED_H__
-
-#include <clutter/clutter-types.h>
-
-G_BEGIN_DECLS
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:font_dpi)
-void            clutter_backend_set_resolution                  (ClutterBackend *backend,
-                                                                 gdouble         dpi);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_time)
-void            clutter_backend_set_double_click_time           (ClutterBackend *backend,
-                                                                 guint           msec);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_time)
-guint           clutter_backend_get_double_click_time           (ClutterBackend *backend);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_distance)
-void            clutter_backend_set_double_click_distance       (ClutterBackend *backend,
-                                                                 guint           distance);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:double_click_distance)
-guint           clutter_backend_get_double_click_distance       (ClutterBackend *backend);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:font_name)
-void            clutter_backend_set_font_name                   (ClutterBackend *backend,
-                                                                 const gchar    *font_name);
-
-CLUTTER_DEPRECATED_FOR(ClutterSettings:font_name)
-const gchar *   clutter_backend_get_font_name                   (ClutterBackend *backend);
-
-
-G_END_DECLS
-
-#endif /* __CLUTTER_BACKEND_DEPRECATED_H__ */
--- a/Show More
+++ b/Show More