Merge branch 'master' into cogl-float

.gitignore

@@ -111,6 +111,7 @@ stamp-h1
 /tests/interactive/test-easing
 /tests/interactive/test-interactive
 /tests/interactive/test-binding-pool
+/tests/interactive/test-text-field
 /tests/interactive/redhand.png
 /tests/interactive/test-script.json
 /tests/conform/test-conformance
@@ -158,6 +159,7 @@ stamp-h1
 /clutter/x11/stamp-clutter-x11-enum-types.h
 /po/Makefile.in.in
 /po/POTFILES
+/po/*.pot
 *.swn
 *.swo
 *.swp

clutter/Makefile.am

@@ -64,7 +64,6 @@ source_h =					\
         $(srcdir)/clutter-container.h		\
         $(srcdir)/clutter-deprecated.h		\
 	$(srcdir)/clutter-effect.h 		\
-        $(srcdir)/clutter-entry.h               \
 	$(srcdir)/clutter-event.h 		\
 	$(srcdir)/clutter-feature.h 		\
 	$(srcdir)/clutter-fixed.h 		\
@@ -72,7 +71,6 @@ source_h =					\
 	$(srcdir)/clutter-group.h 		\
         $(srcdir)/clutter-interval.h            \
 	$(srcdir)/clutter-keysyms.h 		\
-	$(srcdir)/clutter-label.h 		\
 	$(srcdir)/clutter-list-model.h		\
 	$(srcdir)/clutter-main.h		\
 	$(srcdir)/clutter-media.h		\
@@ -87,6 +85,7 @@ source_h =					\
 	$(srcdir)/clutter-stage.h 		\
 	$(srcdir)/clutter-stage-manager.h	\
 	$(srcdir)/clutter-texture.h 		\
+        $(srcdir)/clutter-text.h                \
 	$(srcdir)/clutter-timeline.h 		\
 	$(srcdir)/clutter-timeout-pool.h 	\
 	$(srcdir)/clutter-types.h		\
@@ -155,7 +154,6 @@ source_c = \
 	clutter-color.c 		\
 	clutter-container.c		\
 	clutter-effect.c      		\
-        clutter-entry.c                 \
 	clutter-enum-types.c		\
         clutter-event.c 		\
 	clutter-feature.c 		\
@@ -164,7 +162,6 @@ source_c = \
 	clutter-group.c 		\
 	clutter-id-pool.c 		\
         clutter-interval.c              \
-	clutter-label.c 		\
 	clutter-list-model.c		\
 	clutter-main.c 			\
 	clutter-marshal.c		\
@@ -182,6 +179,7 @@ source_c = \
 	clutter-stage-manager.c		\
 	clutter-stage-window.c		\
 	clutter-texture.c 		\
+        clutter-text.c                  \
 	clutter-timeline.c 		\
 	clutter-timeout-pool.c		\
 	clutter-units.c			\

clutter/clutter-actor.c

@@ -221,7 +221,9 @@ struct _ClutterActorPrivate
   /* cached allocation is invalid (request has changed, probably) */
   guint needs_allocation     : 1;
 
-  guint           has_clip : 1;
+  guint show_on_set_parent   : 1;
+  guint has_clip             : 1;
+
   ClutterUnit     clip[4];
 
   /* Rotation angles */
@@ -260,7 +262,7 @@ struct _ClutterActorPrivate
 
   ShaderData     *shader_data;
 
-  gboolean        show_on_set_parent;
+  PangoContext   *pango_context;
 };
 
 enum
@@ -772,6 +774,24 @@ clutter_actor_real_allocate (ClutterActor          *self,
   g_object_thaw_notify (G_OBJECT (self));
 }
 
+/* like ClutterVertex, but using CoglFixed and with a w component */
+typedef struct {
+  CoglFixed x;
+  CoglFixed y;
+  CoglFixed z;
+  CoglFixed w;
+} fixed_vertex_t;
+
+/* copies a fixed vertex into a ClutterVertex */
+static inline void
+fixed_vertex_to_units (const fixed_vertex_t *f,
+                       ClutterVertex        *u)
+{
+  u->x = CLUTTER_UNITS_FROM_FIXED (f->x);
+  u->y = CLUTTER_UNITS_FROM_FIXED (f->y);
+  u->z = CLUTTER_UNITS_FROM_FIXED (f->z);
+}
+
 /*
  * Utility functions for manipulating transformation matrix
  *
@@ -779,49 +799,114 @@ clutter_actor_real_allocate (ClutterActor          *self,
  */
 #define M(m,row,col)  (m)[(col) * 4 + (row)]
 
-/* Transform point (x,y,z) by matrix */
+/* Transforms a vertex using the passed matrix; vertex is
-static void
+ * an in-out parameter
-mtx_transform (ClutterFixed m[16],
+ */
-	       ClutterFixed *x, ClutterFixed *y, ClutterFixed *z,
+static inline void
-	       ClutterFixed *w)
+mtx_transform (const ClutterFixed  m[],
+               fixed_vertex_t     *vertex)
 {
-    ClutterFixed _x, _y, _z, _w;
+  ClutterFixed _x, _y, _z, _w;
-    _x = *x;
-    _y = *y;
-    _z = *z;
-    _w = *w;
 
-    /* We care lot about precision here, so have to use QMUL */
+  _x = vertex->x;
-    *x = COGL_FIXED_MUL (M (m, 0, 0), _x)
+  _y = vertex->y;
-       + COGL_FIXED_MUL (M (m, 0, 1), _y)
+  _z = vertex->z;
-       + COGL_FIXED_MUL (M (m, 0, 2), _z)
+  _w = vertex->w;
-       + COGL_FIXED_MUL (M (m, 0, 3), _w);
 
-    *y = COGL_FIXED_MUL (M (m, 1, 0), _x)
+  /* We care lot about precision here, so have to use MUL instead
-       + COGL_FIXED_MUL (M (m, 1, 1), _y)
+   * of FAST_MUL
-       + COGL_FIXED_MUL (M (m, 1, 2), _z)
+   */
-       + COGL_FIXED_MUL (M (m, 1, 3), _w);
+  vertex->x = COGL_FIXED_MUL (M (m, 0, 0), _x)
+            + COGL_FIXED_MUL (M (m, 0, 1), _y)
+            + COGL_FIXED_MUL (M (m, 0, 2), _z)
+            + COGL_FIXED_MUL (M (m, 0, 3), _w);
 
-    *z = COGL_FIXED_MUL (M (m, 2, 0), _x)
+  vertex->y = COGL_FIXED_MUL (M (m, 1, 0), _x)
-       + COGL_FIXED_MUL (M (m, 2, 1), _y)
+            + COGL_FIXED_MUL (M (m, 1, 1), _y)
-       + COGL_FIXED_MUL (M (m, 2, 2), _z)
+            + COGL_FIXED_MUL (M (m, 1, 2), _z)
-       + COGL_FIXED_MUL (M (m, 2, 3), _w);
+            + COGL_FIXED_MUL (M (m, 1, 3), _w);
 
-    *w = COGL_FIXED_MUL (M (m, 3, 0), _x)
+  vertex->z = COGL_FIXED_MUL (M (m, 2, 0), _x)
-       + COGL_FIXED_MUL (M (m, 3, 1), _y)
+            + COGL_FIXED_MUL (M (m, 2, 1), _y)
-       + COGL_FIXED_MUL (M (m, 3, 2), _z)
+            + COGL_FIXED_MUL (M (m, 2, 2), _z)
-       + COGL_FIXED_MUL (M (m, 3, 3), _w);
+            + COGL_FIXED_MUL (M (m, 2, 3), _w);
 
-    /* Specially for Matthew: was going to put a comment here, but could not
+  vertex->w = COGL_FIXED_MUL (M (m, 3, 0), _x)
-     * think of anything at all to say ;)
+            + COGL_FIXED_MUL (M (m, 3, 1), _y)
-     */
+            + COGL_FIXED_MUL (M (m, 3, 2), _z)
+            + COGL_FIXED_MUL (M (m, 3, 3), _w);
+
+  /* Specially for Matthew: was going to put a comment here, but could not
+   * think of anything at all to say ;)
+   */
 }
 
 #undef M
 
+/* Help macros to scale from OpenGL <-1,1> coordinates system to our
+ * X-window based <0,window-size> coordinates
+ */
+#define MTX_GL_SCALE_X(x,w,v1,v2) (COGL_FIXED_MUL (((COGL_FIXED_DIV ((x), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2))
+#define MTX_GL_SCALE_Y(y,w,v1,v2) ((v1) - COGL_FIXED_MUL (((COGL_FIXED_DIV ((y), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2))
+#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
+
+/* transforms a 4-tuple of coordinates using @matrix and
+ * places the result into a fixed @vertex
+ */
+static inline void
+fixed_vertex_transform (const ClutterFixed  matrix[],
+                        ClutterFixed        x,
+                        ClutterFixed        y,
+                        ClutterFixed        z,
+                        ClutterFixed        w,
+                        fixed_vertex_t     *vertex)
+{
+  fixed_vertex_t tmp = { 0, };
+
+  tmp.x = x;
+  tmp.y = y;
+  tmp.z = z;
+  tmp.w = w;
+
+  mtx_transform (matrix, &tmp);
+
+  *vertex = tmp;
+}
+
+/* scales a fixed @vertex using @matrix and @viewport, and
+ * transforms the result into ClutterUnits, filling @vertex_p
+ */
+static inline void
+fixed_vertex_scale (const ClutterFixed    matrix[],
+                    const fixed_vertex_t *vertex,
+                    const ClutterFixed    viewport[],
+                    ClutterVertex        *vertex_p)
+{
+  ClutterFixed v_x, v_y, v_width, v_height;
+  fixed_vertex_t tmp = { 0, };
+
+  tmp = *vertex;
+
+  mtx_transform (matrix, &tmp);
+
+  v_x      = viewport[0];
+  v_y      = viewport[1];
+  v_width  = viewport[2];
+  v_height = viewport[3];
+
+  tmp.x = MTX_GL_SCALE_X (tmp.x, tmp.w, v_width, v_x);
+  tmp.y = MTX_GL_SCALE_Y (tmp.y, tmp.w, v_height, v_y);
+  tmp.z = MTX_GL_SCALE_Z (tmp.z, tmp.w, v_width, v_x);
+  tmp.w = 0;
+
+  fixed_vertex_to_units (&tmp, vertex_p);
+}
+
 /* Applies the transforms associated with this actor and its ancestors,
  * retrieves the resulting OpenGL modelview matrix, and uses the matrix
  * to transform the supplied point
+ *
+ * The point coordinates are in-out parameters
  */
 static void
 clutter_actor_transform_point_relative (ClutterActor *actor,
@@ -832,14 +917,33 @@ clutter_actor_transform_point_relative (ClutterActor *actor,
 					ClutterUnit  *w)
 {
   ClutterFixed mtx[16];
+  fixed_vertex_t vertex = { 0, };
+
+  vertex.x = (x != NULL) ? CLUTTER_UNITS_TO_FIXED (*x) : 0;
+  vertex.y = (y != NULL) ? CLUTTER_UNITS_TO_FIXED (*y) : 0;
+  vertex.z = (z != NULL) ? CLUTTER_UNITS_TO_FIXED (*z) : 0;
+  vertex.w = (w != NULL) ? CLUTTER_UNITS_TO_FIXED (*w) : 0;
 
   cogl_push_matrix();
 
   _clutter_actor_apply_modelview_transform_recursive (actor, ancestor);
+
   cogl_get_modelview_matrix (mtx);
-  mtx_transform (mtx, x, y, z, w);
+  mtx_transform (mtx, &vertex);
 
   cogl_pop_matrix();
+
+  if (x)
+    *x = CLUTTER_UNITS_FROM_FIXED (vertex.x);
+
+  if (y)
+    *y = CLUTTER_UNITS_FROM_FIXED (vertex.y);
+
+  if (z)
+    *z = CLUTTER_UNITS_FROM_FIXED (vertex.z);
+
+  if (w)
+    *w = CLUTTER_UNITS_FROM_FIXED (vertex.w);
 }
 
 /* Applies the transforms associated with this actor and its ancestors,
@@ -854,22 +958,34 @@ clutter_actor_transform_point (ClutterActor *actor,
 			       ClutterUnit  *w)
 {
   ClutterFixed mtx[16];
+  fixed_vertex_t vertex = { 0, };
+
+  vertex.x = (x != NULL) ? CLUTTER_UNITS_TO_FIXED (*x) : 0;
+  vertex.y = (y != NULL) ? CLUTTER_UNITS_TO_FIXED (*y) : 0;
+  vertex.z = (z != NULL) ? CLUTTER_UNITS_TO_FIXED (*z) : 0;
+  vertex.w = (w != NULL) ? CLUTTER_UNITS_TO_FIXED (*w) : 0;
 
   cogl_push_matrix();
 
   _clutter_actor_apply_modelview_transform_recursive (actor, NULL);
+
   cogl_get_modelview_matrix (mtx);
-  mtx_transform (mtx, x, y, z, w);
+  mtx_transform (mtx, &vertex);
 
   cogl_pop_matrix();
-}
 
-/* Help macros to scale from OpenGL <-1,1> coordinates system to our
+  if (x)
- * X-window based <0,window-size> coordinates
+    *x = CLUTTER_UNITS_FROM_FIXED (vertex.x);
- */
+
-#define MTX_GL_SCALE_X(x,w,v1,v2) (COGL_FIXED_MUL (((COGL_FIXED_DIV ((x), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2))
+  if (y)
-#define MTX_GL_SCALE_Y(y,w,v1,v2) ((v1) - COGL_FIXED_MUL (((COGL_FIXED_DIV ((y), (w)) + COGL_FIXED_1) >> 1), (v1)) + (v2))
+    *y = CLUTTER_UNITS_FROM_FIXED (vertex.y);
-#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
+
+  if (z)
+    *z = CLUTTER_UNITS_FROM_FIXED (vertex.z);
+
+  if (w)
+    *w = CLUTTER_UNITS_FROM_FIXED (vertex.w);
+}
 
 /**
  * clutter_actor_apply_relative_transform_to_point:
@@ -896,21 +1012,22 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor        *self,
 						 const ClutterVertex *point,
 						 ClutterVertex       *vertex)
 {
-  ClutterVertex tmp = { 0, };
   ClutterFixed v[4];
-  ClutterFixed w = COGL_FIXED_1;
+  ClutterFixed x, y, z, w;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
   g_return_if_fail (ancestor == NULL || CLUTTER_IS_ACTOR (ancestor));
   g_return_if_fail (point != NULL);
   g_return_if_fail (vertex != NULL);
 
-  tmp = *point;
+  x = CLUTTER_UNITS_TO_FIXED (vertex->x);
+  y = CLUTTER_UNITS_TO_FIXED (vertex->y);
+  z = CLUTTER_UNITS_TO_FIXED (vertex->z);
+  w = COGL_FIXED_1;
 
   /* First we tranform the point using the OpenGL modelview matrix */
   clutter_actor_transform_point_relative (self, ancestor,
-					  &tmp.x, &tmp.y, &tmp.z,
+					  &x, &y, &z, &w);
-					  &w);
 
   cogl_get_viewport (v);
 
@@ -918,9 +1035,12 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor        *self,
    * The w[3] parameter should always be 1.0 here, so we ignore it; otherwise
    * we would have to divide the original verts with it.
    */
-  vertex->x = COGL_FIXED_MUL ((tmp.x + COGL_FIXED_0_5), v[2]);
+  vertex->x =
-  vertex->y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - tmp.y), v[3]);
+    CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL ((x + COGL_FIXED_0_5), v[2]));
-  vertex->z = COGL_FIXED_MUL ((tmp.z + COGL_FIXED_0_5), v[2]);
+  vertex->y =
+    CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL ((COGL_FIXED_0_5 - y), v[3]));
+  vertex->z =
+    CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL ((z + COGL_FIXED_0_5), v[2]));
 }
 
 /**
@@ -940,30 +1060,35 @@ clutter_actor_apply_transform_to_point (ClutterActor        *self,
                                         const ClutterVertex *point,
                                         ClutterVertex       *vertex)
 {
-  ClutterVertex tmp = { 0, };
   ClutterFixed mtx_p[16];
   ClutterFixed v[4];
-  ClutterFixed w = COGL_FIXED_1;
+  fixed_vertex_t tmp = { 0, };
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
   g_return_if_fail (point != NULL);
   g_return_if_fail (vertex != NULL);
 
-  tmp = *point;
+  tmp.x = CLUTTER_UNITS_TO_FIXED (vertex->x);
+  tmp.y = CLUTTER_UNITS_TO_FIXED (vertex->y);
+  tmp.z = CLUTTER_UNITS_TO_FIXED (vertex->z);
+  tmp.w = COGL_FIXED_1;
 
   /* First we tranform the point using the OpenGL modelview matrix */
-  clutter_actor_transform_point (self, &tmp.x, &tmp.y, &tmp.z, &w);
+  clutter_actor_transform_point (self, &tmp.x, &tmp.y, &tmp.z, &tmp.w);
 
   cogl_get_projection_matrix (mtx_p);
   cogl_get_viewport (v);
 
   /* Now, transform it again with the projection matrix */
-  mtx_transform (mtx_p, &tmp.x, &tmp.y, &tmp.z, &w);
+  mtx_transform (mtx_p, &tmp);
 
   /* Finaly translate from OpenGL coords to window coords */
-  vertex->x = MTX_GL_SCALE_X (tmp.x, w, v[2], v[0]);
+  vertex->x =
-  vertex->y = MTX_GL_SCALE_Y (tmp.y, w, v[3], v[1]);
+    CLUTTER_UNITS_FROM_FIXED (MTX_GL_SCALE_X (tmp.x, tmp.w, v[2], v[0]));
-  vertex->z = MTX_GL_SCALE_Z (tmp.z, w, v[2], v[0]);
+  vertex->y =
+    CLUTTER_UNITS_FROM_FIXED (MTX_GL_SCALE_Y (tmp.y, tmp.w, v[3], v[1]));
+  vertex->z =
+    CLUTTER_UNITS_FROM_FIXED (MTX_GL_SCALE_Z (tmp.z, tmp.w, v[2], v[0]));
 }
 
 /* Recursively tranform supplied vertices with the tranform for the current
@@ -971,66 +1096,27 @@ clutter_actor_apply_transform_to_point (ClutterActor        *self,
  * for all the vertices in one go).
  */
 static void
-clutter_actor_transform_vertices_relative (ClutterActor  *self,
+clutter_actor_transform_vertices_relative (ClutterActor   *self,
-					   ClutterActor  *ancestor,
+					   ClutterActor   *ancestor,
-					   ClutterVertex  verts[4],
+                                           fixed_vertex_t  vertices[])
-					   ClutterFixed   w[4])
 {
-  ClutterFixed    mtx[16];
+  ClutterActorPrivate *priv = self->priv;
-  ClutterFixed    _x, _y, _z, _w;
+  ClutterFixed mtx[16];
+  ClutterFixed width, height;
+
+  width  = CLUTTER_UNITS_TO_FIXED (priv->allocation.x2 - priv->allocation.x1);
+  height = CLUTTER_UNITS_TO_FIXED (priv->allocation.y2 - priv->allocation.y1);
 
   cogl_push_matrix();
 
   _clutter_actor_apply_modelview_transform_recursive (self, ancestor);
+
   cogl_get_modelview_matrix (mtx);
 
-  _x = 0;
+  fixed_vertex_transform (mtx, 0,     0,      0, COGL_FIXED_1, &vertices[0]);
-  _y = 0;
+  fixed_vertex_transform (mtx, width, 0,      0, COGL_FIXED_1, &vertices[1]);
-  _z = 0;
+  fixed_vertex_transform (mtx, 0,     height, 0, COGL_FIXED_1, &vertices[2]);
-  _w = COGL_FIXED_1;
+  fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]);
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[0].x = _x;
-  verts[0].y = _y;
-  verts[0].z = _z;
-  w[0] = _w;
-
-  _x = self->priv->allocation.x2 - self->priv->allocation.x1;
-  _y = 0;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[1].x = _x;
-  verts[1].y = _y;
-  verts[1].z = _z;
-  w[1] = _w;
-
-  _x = 0;
-  _y = self->priv->allocation.y2 - self->priv->allocation.y1;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[2].x = _x;
-  verts[2].y = _y;
-  verts[2].z = _z;
-  w[2] = _w;
-
-  _x = self->priv->allocation.x2 - self->priv->allocation.x1;
-  _y = self->priv->allocation.y2 - self->priv->allocation.y1;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[3].x = _x;
-  verts[3].y = _y;
-  verts[3].z = _z;
-  w[3] = _w;
 
   cogl_pop_matrix();
 }
@@ -1045,12 +1131,15 @@ clutter_actor_transform_and_project_box (ClutterActor          *self,
 					 const ClutterActorBox *box,
 					 ClutterVertex          verts[4])
 {
-  ClutterActor          *stage;
+  ClutterActor *stage;
-  ClutterFixed           mtx[16];
+  ClutterFixed mtx[16];
-  ClutterFixed           mtx_p[16];
+  ClutterFixed mtx_p[16];
-  ClutterFixed           _x, _y, _z, _w;
+  ClutterFixed v[4];
-  ClutterFixed           w[4];
+  ClutterFixed width, height;
-  ClutterFixed           v[4];
+  fixed_vertex_t vertices[4];
+
+  width = CLUTTER_UNITS_TO_FIXED (box->x2 - box->x1);
+  height = CLUTTER_UNITS_TO_FIXED (box->y2 - box->y1);
 
   /* We essentially have to dupe some code from clutter_redraw() here
    * to make sure GL Matrices etc are initialised if we're called and we
@@ -1071,102 +1160,25 @@ clutter_actor_transform_and_project_box (ClutterActor          *self,
   _clutter_stage_maybe_setup_viewport (CLUTTER_STAGE (stage));
 
   cogl_push_matrix();
+
   _clutter_actor_apply_modelview_transform_recursive (self, NULL);
 
   cogl_get_modelview_matrix (mtx);
 
-  _x = 0;
+  fixed_vertex_transform (mtx, 0,     0,      0, COGL_FIXED_1, &vertices[0]);
-  _y = 0;
+  fixed_vertex_transform (mtx, width, 0,      0, COGL_FIXED_1, &vertices[1]);
-  _z = 0;
+  fixed_vertex_transform (mtx, 0,     height, 0, COGL_FIXED_1, &vertices[2]);
-  _w = COGL_FIXED_1;
+  fixed_vertex_transform (mtx, width, height, 0, COGL_FIXED_1, &vertices[3]);
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[0].x = _x;
-  verts[0].y = _y;
-  verts[0].z = _z;
-  w[0] = _w;
-
-  _x = box->x2 - box->x1;
-  _y = 0;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[1].x = _x;
-  verts[1].y = _y;
-  verts[1].z = _z;
-  w[1] = _w;
-
-  _x = 0;
-  _y = box->y2 - box->y1;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[2].x = _x;
-  verts[2].y = _y;
-  verts[2].z = _z;
-  w[2] = _w;
-
-  _x = box->x2 - box->x1;
-  _y = box->y2 - box->y1;
-  _z = 0;
-  _w = COGL_FIXED_1;
-
-  mtx_transform (mtx, &_x, &_y, &_z, &_w);
-
-  verts[3].x = _x;
-  verts[3].y = _y;
-  verts[3].z = _z;
-  w[3] = _w;
 
   cogl_pop_matrix();
 
   cogl_get_projection_matrix (mtx_p);
   cogl_get_viewport (v);
 
-  mtx_transform (mtx_p,
+  fixed_vertex_scale (mtx_p, &vertices[0], v, &verts[0]);
-		 &verts[0].x,
+  fixed_vertex_scale (mtx_p, &vertices[1], v, &verts[1]);
-		 &verts[0].y,
+  fixed_vertex_scale (mtx_p, &vertices[2], v, &verts[2]);
-		 &verts[0].z,
+  fixed_vertex_scale (mtx_p, &vertices[3], v, &verts[3]);
-		 &w[0]);
-
-  verts[0].x = MTX_GL_SCALE_X (verts[0].x, w[0], v[2], v[0]);
-  verts[0].y = MTX_GL_SCALE_Y (verts[0].y, w[0], v[3], v[1]);
-  verts[0].z = MTX_GL_SCALE_Z (verts[0].z, w[0], v[2], v[0]);
-
-  mtx_transform (mtx_p,
-		 &verts[1].x,
-		 &verts[1].y,
-		 &verts[1].z,
-		 &w[1]);
-
-  verts[1].x = MTX_GL_SCALE_X (verts[1].x, w[1], v[2], v[0]);
-  verts[1].y = MTX_GL_SCALE_Y (verts[1].y, w[1], v[3], v[1]);
-  verts[1].z = MTX_GL_SCALE_Z (verts[1].z, w[1], v[2], v[0]);
-
-  mtx_transform (mtx_p,
-		 &verts[2].x,
-		 &verts[2].y,
-		 &verts[2].z,
-		 &w[2]);
-
-  verts[2].x = MTX_GL_SCALE_X (verts[2].x, w[2], v[2], v[0]);
-  verts[2].y = MTX_GL_SCALE_Y (verts[2].y, w[2], v[3], v[1]);
-  verts[2].z = MTX_GL_SCALE_Z (verts[2].z, w[2], v[2], v[0]);
-
-  mtx_transform (mtx_p,
-		 &verts[3].x,
-		 &verts[3].y,
-		 &verts[3].z,
-		 &w[3]);
-
-  verts[3].x = MTX_GL_SCALE_X (verts[3].x, w[3], v[2], v[0]);
-  verts[3].y = MTX_GL_SCALE_Y (verts[3].y, w[3], v[3], v[1]);
-  verts[3].z = MTX_GL_SCALE_Z (verts[3].z, w[3], v[2], v[0]);
 }
 
 /**
@@ -1181,10 +1193,10 @@ clutter_actor_transform_and_project_box (ClutterActor          *self,
  * actor in the plane of @ancestor. The returned vertices relate to
  * the #ClutterActorBox coordinates as follows:
  * <itemizedlist>
- *   <listitem><para>v[0] contains (x1, y1)</para></listitem>
+ *   <listitem><para>@verts[0] contains (x1, y1)</para></listitem>
- *   <listitem><para>v[1] contains (x2, y1)</para></listitem>
+ *   <listitem><para>@verts[1] contains (x2, y1)</para></listitem>
- *   <listitem><para>v[2] contains (x1, y2)</para></listitem>
+ *   <listitem><para>@verts[2] contains (x1, y2)</para></listitem>
- *   <listitem><para>v[3] contains (x2, y2)</para></listitem>
+ *   <listitem><para>@verts[3] contains (x2, y2)</para></listitem>
  * </itemizedlist>
  *
  * If @ancestor is %NULL the ancestor will be the #ClutterStage. In
@@ -1197,12 +1209,13 @@ clutter_actor_transform_and_project_box (ClutterActor          *self,
 void
 clutter_actor_get_allocation_vertices (ClutterActor  *self,
                                        ClutterActor  *ancestor,
-                                       ClutterVertex  verts[4])
+                                       ClutterVertex  verts[])
 {
-  ClutterFixed           v[4];
+  ClutterActorPrivate *priv;
-  ClutterFixed           w[4];
+  ClutterActor *stage;
-  ClutterActorPrivate   *priv;
+  ClutterFixed v[4];
-  ClutterActor          *stage;
+  fixed_vertex_t vertices[4];
+  fixed_vertex_t tmp = { 0, };
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
   g_return_if_fail (ancestor == NULL || CLUTTER_IS_ACTOR (ancestor));
@@ -1234,28 +1247,33 @@ clutter_actor_get_allocation_vertices (ClutterActor  *self,
   if (priv->needs_allocation)
     _clutter_stage_maybe_relayout (stage);
 
-  clutter_actor_transform_vertices_relative (self, ancestor, verts, w);
+  clutter_actor_transform_vertices_relative (self, ancestor, vertices);
+
   cogl_get_viewport (v);
 
   /*
-   * The w[3] parameter should always be 1.0 here, so we ignore it; otherwise
+   * The w[3] parameter should always be 1.0 here, so we ignore it;
-   * we would have to devide the original verts with it.
+   * otherwise we would have to divide the original verts with it.
    */
-  verts[0].x = COGL_FIXED_MUL ((verts[0].x + COGL_FIXED_0_5), v[2]);
+  tmp.x = COGL_FIXED_MUL ((vertices[0].x + COGL_FIXED_0_5), v[2]);
-  verts[0].y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - verts[0].y), v[3]);
+  tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[0].y), v[3]);
-  verts[0].z = COGL_FIXED_MUL ((verts[0].z + COGL_FIXED_0_5), v[2]);
+  tmp.z = COGL_FIXED_MUL ((vertices[0].z + COGL_FIXED_0_5), v[2]);
+  fixed_vertex_to_units (&tmp, &verts[0]);
 
-  verts[1].x = COGL_FIXED_MUL ((verts[1].x + COGL_FIXED_0_5), v[2]);
+  tmp.x = COGL_FIXED_MUL ((vertices[1].x + COGL_FIXED_0_5), v[2]);
-  verts[1].y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - verts[1].y), v[3]);
+  tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[1].y), v[3]);
-  verts[1].z = COGL_FIXED_MUL ((verts[1].z + COGL_FIXED_0_5), v[2]);
+  tmp.z = COGL_FIXED_MUL ((vertices[1].z + COGL_FIXED_0_5), v[2]);
+  fixed_vertex_to_units (&tmp, &verts[1]);
 
-  verts[2].x = COGL_FIXED_MUL ((verts[2].x + COGL_FIXED_0_5), v[2]);
+  tmp.x = COGL_FIXED_MUL ((vertices[2].x + COGL_FIXED_0_5), v[2]);
-  verts[2].y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - verts[2].y), v[3]);
+  tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[2].y), v[3]);
-  verts[2].z = COGL_FIXED_MUL ((verts[2].z + COGL_FIXED_0_5), v[2]);
+  tmp.z = COGL_FIXED_MUL ((vertices[2].z + COGL_FIXED_0_5), v[2]);
+  fixed_vertex_to_units (&tmp, &verts[2]);
 
-  verts[3].x = COGL_FIXED_MUL ((verts[3].x + COGL_FIXED_0_5), v[2]);
+  tmp.x = COGL_FIXED_MUL ((vertices[3].x + COGL_FIXED_0_5), v[2]);
-  verts[3].y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - verts[3].y), v[3]);
+  tmp.y = COGL_FIXED_MUL ((COGL_FIXED_0_5 - vertices[3].y), v[3]);
-  verts[3].z = COGL_FIXED_MUL ((verts[3].z + COGL_FIXED_0_5), v[2]);
+  tmp.z = COGL_FIXED_MUL ((vertices[3].z + COGL_FIXED_0_5), v[2]);
+  fixed_vertex_to_units (&tmp, &verts[3]);
 }
 
 /**
@@ -1941,6 +1959,12 @@ clutter_actor_dispose (GObject *object)
 
   destroy_shader_data (self);
 
+  if (priv->pango_context)
+    {
+      g_object_unref (priv->pango_context);
+      priv->pango_context = NULL;
+    }
+
   g_signal_emit (self, actor_signals[DESTROY], 0);
 
   G_OBJECT_CLASS (clutter_actor_parent_class)->dispose (object);
@@ -6842,17 +6866,18 @@ clutter_scriptable_iface_init (ClutterScriptableIface *iface)
  * Since: 0.6
  */
 gboolean
-clutter_actor_transform_stage_point (ClutterActor  *self,
+clutter_actor_transform_stage_point (ClutterActor *self,
-				     ClutterUnit    x,
+				     ClutterUnit   x,
-				     ClutterUnit    y,
+				     ClutterUnit   y,
-				     ClutterUnit   *x_out,
+				     ClutterUnit  *x_out,
-				     ClutterUnit   *y_out)
+				     ClutterUnit  *y_out)
 {
   ClutterVertex v[4];
   ClutterFixed  ST[3][3];
   ClutterFixed  RQ[3][3];
   int du, dv, xi, yi;
-  ClutterFixed xf, yf, wf, px, py, det;
+  ClutterUnit px, py;
+  ClutterFixed xf, yf, wf, det;
   ClutterActorPrivate *priv;
 
   g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
@@ -6865,11 +6890,12 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
    *
    * http://www.cs.cmu.edu/~ph/texfund/texfund.pdf
    *
-   * and the sample implementaion at http://www.cs.cmu.edu/~ph/src/texfund/.
+   * and the sample implementation at http://www.cs.cmu.edu/~ph/src/texfund/.
    *
-   * Our texture is a rectangle with origin [0,0], so we are mapping from quad
+   * Our texture is a rectangle with origin [0, 0], so we are mapping from
-   * to rectangle only, which significantly simplifies things; the function
+   * quad to rectangle only, which significantly simplifies things; the
-   * calls have been unrolled, and most of the math is done in fixed point.
+   * function calls have been unrolled, and most of the math is done in fixed
+   * point.
    */
 
   clutter_actor_get_abs_allocation_vertices (self, v);
@@ -6886,9 +6912,11 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
 
 #define FP2FX COGL_FIXED_FROM_FLOAT
 #define FX2FP COGL_FIXED_TO_DOUBLE
+#define UX2FP CLUTTER_UNITS_TO_FLOAT
+#define UX2FX CLUTTER_UNITS_TO_FIXED
 #define FP2INT CLUTTER_FLOAT_TO_INT
-#define DET2X(a,b,c,d)  (COGL_FIXED_MUL (a, d) - COGL_FIXED_MUL (b, c))
+#define DET2X(a,b,c,d)  (COGL_FIXED_MUL ((a), (d)) - COGL_FIXED_MUL ((b), (c)))
-#define DET2FP(a,b,c,d) (a*d - b*c)
+#define DET2FP(a,b,c,d) ((a) * (d) - (b) * (c))
 
   /*
    * First, find mapping from unit uv square to xy quadrilateral; this
@@ -6900,20 +6928,21 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
   py = v[0].y - v[1].y + v[3].y - v[2].y;
 
   if (!px && !py)
-    { /* affine transform */
+    {
-      RQ[0][0] = v[1].x - v[0].x;
+      /* affine transform */
-      RQ[1][0] = v[3].x - v[1].x;
+      RQ[0][0] = UX2FX (v[1].x - v[0].x);
-      RQ[2][0] = v[0].x;
+      RQ[1][0] = UX2FX (v[3].x - v[1].x);
-      RQ[0][1] = v[1].y - v[0].y;
+      RQ[2][0] = UX2FX (v[0].x);
-      RQ[1][1] = v[3].y - v[1].y;
+      RQ[0][1] = UX2FX (v[1].y - v[0].y);
-      RQ[2][1] = v[0].y;
+      RQ[1][1] = UX2FX (v[3].y - v[1].y);
+      RQ[2][1] = UX2FX (v[0].y);
       RQ[0][2] = 0;
       RQ[1][2] = 0;
       RQ[2][2] = COGL_FIXED_1;
     }
   else
-    { /*
+    {
-       * projective transform
+      /* projective transform
        *
        * Must do this in floating point, as the del value can overflow the
        * range of ClutterFixed for large actors.
@@ -6923,13 +6952,12 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
        */
       double dx1, dx2, dy1, dy2, del;
 
-      dx1 = FX2FP (v[1].x - v[3].x);
+      dx1 = UX2FP (v[1].x - v[3].x);
-      dx2 = FX2FP (v[2].x - v[3].x);
+      dx2 = UX2FP (v[2].x - v[3].x);
-      dy1 = FX2FP (v[1].y - v[3].y);
+      dy1 = UX2FP (v[1].y - v[3].y);
-      dy2 = FX2FP (v[2].y - v[3].y);
+      dy2 = UX2FP (v[2].y - v[3].y);
-
-      del = DET2FP (dx1,dx2, dy1,dy2);
 
+      del = DET2FP (dx1, dx2, dy1, dy2);
       if (!del)
 	return FALSE;
 
@@ -6937,16 +6965,20 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
        * The division here needs to be done in floating point for
        * precisions reasons.
        */
-      RQ[0][2] = FP2FX (DET2FP (FX2FP(px),dx2, FX2FP(py),dy2) / del);
+      RQ[0][2] = FP2FX (DET2FP (UX2FP (px), dx2, UX2FP (py), dy2) / del);
-      RQ[1][2] = FP2FX (DET2FP (dx1,FX2FP(px), dy1,FX2FP(py)) / del);
+      RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del);
-      RQ[1][2] = FP2FX (DET2FP(dx1,FX2FP(px), dy1,FX2FP(py))/del);
+      RQ[1][2] = FP2FX (DET2FP (dx1, UX2FP (px), dy1, UX2FP (py)) / del);
       RQ[2][2] = COGL_FIXED_1;
-      RQ[0][0] = v[1].x - v[0].x + COGL_FIXED_MUL (RQ[0][2], v[1].x);
+      RQ[0][0] = UX2FX (v[1].x - v[0].x)
-      RQ[1][0] = v[2].x - v[0].x + COGL_FIXED_MUL (RQ[1][2], v[2].x);
+               + COGL_FIXED_MUL (RQ[0][2], UX2FX (v[1].x));
-      RQ[2][0] = v[0].x;
+      RQ[1][0] = UX2FX (v[2].x - v[0].x)
-      RQ[0][1] = v[1].y - v[0].y + COGL_FIXED_MUL (RQ[0][2], v[1].y);
+               + COGL_FIXED_MUL (RQ[1][2], UX2FX (v[2].x));
-      RQ[1][1] = v[2].y - v[0].y + COGL_FIXED_MUL (RQ[1][2], v[2].y);
+      RQ[2][0] = UX2FX (v[0].x);
-      RQ[2][1] = v[0].y;
+      RQ[0][1] = UX2FX (v[1].y - v[0].y)
+               + COGL_FIXED_MUL (RQ[0][2], UX2FX (v[1].y));
+      RQ[1][1] = UX2FX (v[2].y - v[0].y)
+               + COGL_FIXED_MUL (RQ[1][2], UX2FX (v[2].y));
+      RQ[2][1] = UX2FX (v[0].y);
     }
 
   /*
@@ -6985,24 +7017,27 @@ clutter_actor_transform_stage_point (ClutterActor  *self,
     return FALSE;
 
   /*
-   * Now transform our point with the ST matrix; the notional w coordiance
+   * Now transform our point with the ST matrix; the notional w
-   * is 1, hence the last part is simply added.
+   * coordinate is 1, hence the last part is simply added.
    */
   xi = CLUTTER_UNITS_TO_DEVICE (x);
   yi = CLUTTER_UNITS_TO_DEVICE (y);
 
-  xf = xi*ST[0][0] + yi*ST[1][0] + ST[2][0];
+  xf = xi * ST[0][0] + yi * ST[1][0] + ST[2][0];
-  yf = xi*ST[0][1] + yi*ST[1][1] + ST[2][1];
+  yf = xi * ST[0][1] + yi * ST[1][1] + ST[2][1];
-  wf = xi*ST[0][2] + yi*ST[1][2] + ST[2][2];
+  wf = xi * ST[0][2] + yi * ST[1][2] + ST[2][2];
 
   /*
    * The division needs to be done in floating point for precision reasons.
    */
   if (x_out)
     *x_out = CLUTTER_UNITS_FROM_FLOAT (FX2FP (xf) / FX2FP (wf));
+
   if (y_out)
     *y_out = CLUTTER_UNITS_FROM_FLOAT (FX2FP (yf) / FX2FP (wf));
 
+#undef UX2FX
+#undef UX2FP
 #undef FP2FX
 #undef FX2FP
 #undef FP2INT
@@ -7197,11 +7232,11 @@ clutter_actor_set_shader (ClutterActor  *self,
   g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
   g_return_val_if_fail (shader == NULL || CLUTTER_IS_SHADER (shader), FALSE);
 
-  /* if shader passed in is NULL we destroy the shader */
+  if (shader)
-  if (shader == NULL)
+    g_object_ref (shader);
-    {
+  else
-      destroy_shader_data (self);
+    /* if shader passed in is NULL we destroy the shader */
-    }
+    destroy_shader_data (self);
 
   actor_priv = self->priv;
   shader_data = actor_priv->shader_data;
@@ -7215,15 +7250,9 @@ clutter_actor_set_shader (ClutterActor  *self,
                                shader_value_free);
     }
   if (shader_data->shader)
-    {
+    g_object_unref (shader_data->shader);
-      g_object_unref (shader_data->shader);
-      shader_data->shader = NULL;
-    }
 
-  if (shader)
+  shader_data->shader = shader;
-    {
-      shader_data->shader = g_object_ref (shader);
-    }
 
   if (CLUTTER_ACTOR_IS_VISIBLE (self))
     clutter_actor_queue_redraw (self);
@@ -7570,3 +7599,99 @@ clutter_actor_allocate_preferred_size (ClutterActor *self,
 
   clutter_actor_allocate (self, &actor_box, absolute_origin_changed);
 }
+
+/**
+ * clutter_actor_grab_key_focus:
+ * @self: a #ClutterActor
+ *
+ * Sets the key focus of the #ClutterStage including @self
+ * to this #ClutterActor.
+ *
+ * Since: 1.0
+ */
+void
+clutter_actor_grab_key_focus (ClutterActor *self)
+{
+  ClutterActor *parent;
+
+  g_return_if_fail (CLUTTER_IS_ACTOR (self));
+
+  parent = clutter_actor_get_parent (self);
+  if (!parent)
+    return;
+
+  parent = clutter_actor_get_stage (self);
+  if (parent && CLUTTER_IS_STAGE (parent))
+    clutter_stage_set_key_focus (CLUTTER_STAGE (parent), self);
+}
+
+/**
+ * clutter_actor_get_pango_context:
+ * @self: a #ClutterActor
+ *
+ * Retrieves the #PangoContext for @self. The actor's #PangoContext
+ * is already configured using the appropriate font map, resolution
+ * and font options.
+ *
+ * Unlike clutter_actor_create_pango_context(), this context is owend
+ * by the #ClutterActor and it will be updated each time the options
+ * stored by the #ClutterBackend change.
+ *
+ * You can use the returned #PangoContext to create a #PangoLayout
+ * and render text using cogl_pango_render_layout() to reuse the
+ * glyphs cache also used by Clutter.
+ *
+ * Return value: the #PangoContext for a #ClutterActor. The returned
+ *   #PangoContext is owned by the actor and should not be unreferenced
+ *   by the application code
+ *
+ * Since: 1.0
+ */
+PangoContext *
+clutter_actor_get_pango_context (ClutterActor *self)
+{
+  ClutterActorPrivate *priv;
+  ClutterMainContext *ctx;
+
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
+
+  priv = self->priv;
+
+  if (priv->pango_context)
+    return priv->pango_context;
+
+  ctx = CLUTTER_CONTEXT ();
+  priv->pango_context = _clutter_context_get_pango_context (ctx);
+  g_object_ref (priv->pango_context);
+
+  return priv->pango_context;
+}
+
+/**
+ * clutter_actor_create_pango_context:
+ * @self: a #ClutterActor
+ *
+ * Creates a #PangoContext for the given actor. The #PangoContext
+ * is already configured using the appropriate font map, resolution
+ * and font options.
+ *
+ * See also clutter_actor_get_pango_context().
+ *
+ * Return value: the newly created #PangoContext. Use g_object_ref()
+ *   on the returned value to deallocate its resources
+ *
+ * Since: 1.0
+ */
+PangoContext *
+clutter_actor_create_pango_context (ClutterActor *self)
+{
+  ClutterMainContext *ctx;
+  PangoContext *retval;
+
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
+
+  ctx = CLUTTER_CONTEXT ();
+  retval = _clutter_context_create_pango_context (ctx);
+
+  return retval;
+}

clutter/clutter-actor.h

@@ -31,6 +31,8 @@
 /* clutter-actor.h */
 
 #include <glib-object.h>
+#include <pango/pango.h>
+
 #include <clutter/clutter-color.h>
 #include <clutter/clutter-fixed.h>
 #include <clutter/clutter-types.h>
@@ -420,6 +422,8 @@ void                  clutter_actor_set_opacity               (ClutterActor
                                                                guint8                 opacity);
 guint8                clutter_actor_get_opacity               (ClutterActor          *self);
 guint8                clutter_actor_get_paint_opacity         (ClutterActor          *self);
+gboolean              clutter_actor_get_paint_visibility      (ClutterActor          *self);
+
 
 void                  clutter_actor_set_name                  (ClutterActor          *self,
                                                                const gchar           *name);
@@ -545,21 +549,24 @@ gboolean clutter_actor_is_rotated                     (ClutterActor   *self);
 gboolean clutter_actor_is_scaled                      (ClutterActor   *self);
 gboolean clutter_actor_should_pick_paint              (ClutterActor   *self);
 
-void     clutter_actor_box_get_from_vertices          (ClutterVertex    vtx[4],
+void     clutter_actor_box_get_from_vertices          (ClutterVertex        vtx[4],
-				                       ClutterActorBox *box);
+				                       ClutterActorBox     *box);
 
-void clutter_actor_get_abs_allocation_vertices       (ClutterActor  *self,
+void clutter_actor_get_abs_allocation_vertices        (ClutterActor        *self,
-                                                      ClutterVertex  verts[4]);
+                                                       ClutterVertex        verts[4]);
 
-void clutter_actor_apply_transform_to_point          (ClutterActor        *self,
+void clutter_actor_apply_transform_to_point           (ClutterActor        *self,
-                                                      const ClutterVertex *point,
+                                                       const ClutterVertex *point,
-                                                      ClutterVertex       *vertex);
+                                                       ClutterVertex       *vertex);
-void clutter_actor_apply_relative_transform_to_point (ClutterActor        *self,
+void clutter_actor_apply_relative_transform_to_point  (ClutterActor        *self,
-                                                      ClutterActor        *ancestor,
+                                                       ClutterActor        *ancestor,
-                                                      const ClutterVertex *point,
+                                                       const ClutterVertex *point,
-                                                      ClutterVertex       *vertex);
+                                                       ClutterVertex       *vertex);
 
-gboolean clutter_actor_get_paint_visibility           (ClutterActor *self);
+void          clutter_actor_grab_key_focus            (ClutterActor        *self);
+
+PangoContext *clutter_actor_get_pango_context         (ClutterActor        *self);
+PangoContext *clutter_actor_create_pango_context      (ClutterActor        *self);
 
 G_END_DECLS
 

clutter/clutter-alpha.c

@@ -395,6 +395,9 @@ clutter_alpha_set_timeline (ClutterAlpha    *alpha,
   
   priv = alpha->priv;
 
+  if (priv->timeline == timeline)
+    return;
+
   if (priv->timeline)
     {
       g_signal_handlers_disconnect_by_func (priv->timeline,
@@ -565,13 +568,13 @@ clutter_alpha_set_mode (ClutterAlpha      *alpha,
 
   priv = alpha->priv;
 
-  priv->mode = mode;
-
   /* sanity check to avoid getting an out of sync enum/function mapping */
   g_assert (animation_modes[mode].mode == mode);
   if (G_LIKELY (animation_modes[mode].func != NULL))
     clutter_alpha_set_func (alpha, animation_modes[mode].func, NULL, NULL);
 
+  priv->mode = mode;
+
   g_object_notify (G_OBJECT (alpha), "mode");
 }
 

clutter/clutter-animation.c

@@ -739,6 +739,8 @@ clutter_animation_set_actor (ClutterAnimation *animation,
 
   priv = animation->priv;
 
+  g_object_ref (actor);
+
   if (priv->actor)
     {
       g_object_weak_unref (G_OBJECT (animation),
@@ -750,7 +752,7 @@ clutter_animation_set_actor (ClutterAnimation *animation,
       g_object_unref (priv->actor);
     }
 
-  priv->actor = g_object_ref (actor);
+  priv->actor = actor;
   g_object_weak_ref (G_OBJECT (animation),
                      on_animation_weak_notify,
                      priv->actor);
@@ -780,12 +782,11 @@ clutter_animation_get_actor (ClutterAnimation *animation)
 }
 
 static inline void
-clutter_animation_set_mode_internal (ClutterAnimation *animation)
+clutter_animation_set_mode_internal (ClutterAnimation *animation,
+                                     ClutterAlpha     *alpha)
 {
   ClutterAnimationPrivate *priv = animation->priv;
-  ClutterAlpha *alpha;
 
-  alpha = clutter_animation_get_alpha (animation);
   if (alpha)
     clutter_alpha_set_mode (alpha, priv->mode);
 }
@@ -810,7 +811,7 @@ clutter_animation_set_mode (ClutterAnimation     *animation,
   priv = animation->priv;
 
   priv->mode = mode;
-  clutter_animation_set_mode_internal (animation);
+  clutter_animation_set_mode_internal (animation, priv->alpha);
 
   g_object_notify (G_OBJECT (animation), "mode");
 }
@@ -968,6 +969,9 @@ clutter_animation_set_timeline (ClutterAnimation *animation,
 
   priv = animation->priv;
 
+  if (timeline && priv->timeline == timeline)
+    return;
+
   g_object_freeze_notify (G_OBJECT (animation));
 
   if (priv->timeline)
@@ -1048,6 +1052,19 @@ clutter_animation_set_alpha (ClutterAnimation *animation,
 
   priv = animation->priv;
 
+  if (!alpha)
+    {
+      ClutterTimeline *timeline;
+
+      timeline = clutter_animation_get_timeline (animation);
+
+      alpha = clutter_alpha_new ();
+      clutter_alpha_set_timeline (alpha, timeline);
+      clutter_animation_set_mode_internal (animation, alpha);
+    }
+
+  g_object_ref_sink (alpha);
+
   if (priv->alpha)
     {
       if (priv->alpha_notify_id)
@@ -1058,18 +1075,7 @@ clutter_animation_set_alpha (ClutterAnimation *animation,
       priv->alpha = NULL;
     }
 
-  if (!alpha)
+  priv->alpha = alpha;
-    {
-      ClutterTimeline *timeline;
-
-      timeline = clutter_animation_get_timeline (animation);
-
-      alpha = clutter_alpha_new ();
-      clutter_alpha_set_timeline (alpha, timeline);
-      clutter_animation_set_mode_internal (animation);
-    }
-
-  priv->alpha = g_object_ref_sink (alpha);
 
   priv->alpha_notify_id =
     g_signal_connect (alpha, "notify::alpha",

clutter/clutter-backend.c

@@ -44,10 +44,13 @@
 #include "clutter-backend.h"
 #include "clutter-debug.h"
 #include "clutter-fixed.h"
+#include "clutter-marshal.h"
 #include "clutter-private.h"
 
 G_DEFINE_ABSTRACT_TYPE (ClutterBackend, clutter_backend, G_TYPE_OBJECT);
 
+#define DEFAULT_FONT_NAME       "Sans 10"
+
 #define CLUTTER_BACKEND_GET_PRIVATE(obj) \
 (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_BACKEND, ClutterBackendPrivate))
 
@@ -60,11 +63,24 @@ struct _ClutterBackendPrivate
   ClutterFixed resolution;
 
   cairo_font_options_t *font_options;
+
+  gchar *font_name;
 };
 
+enum
+{
+  RESOLUTION_CHANGED,
+  FONT_CHANGED,
+
+  LAST_SIGNAL
+};
+
+static guint backend_signals[LAST_SIGNAL] = { 0, };
+
 static void
 clutter_backend_dispose (GObject *gobject)
 {
+  ClutterBackendPrivate *priv = CLUTTER_BACKEND (gobject)->priv;
   ClutterMainContext *clutter_context;
 
   clutter_context = clutter_context_get_default ();
@@ -76,6 +92,8 @@ clutter_backend_dispose (GObject *gobject)
       clutter_context->events_queue = NULL;
     }
 
+  g_free (priv->font_name);
+
   clutter_backend_set_font_options (CLUTTER_BACKEND (gobject), NULL);
 
   G_OBJECT_CLASS (clutter_backend_parent_class)->dispose (gobject);
@@ -89,6 +107,24 @@ clutter_backend_class_init (ClutterBackendClass *klass)
   gobject_class->dispose = clutter_backend_dispose;
 
   g_type_class_add_private (gobject_class, sizeof (ClutterBackendPrivate));
+
+  backend_signals[RESOLUTION_CHANGED] =
+    g_signal_new (I_("resolution-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterBackendClass, resolution_changed),
+                  NULL, NULL,
+                  clutter_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  backend_signals[FONT_CHANGED] =
+    g_signal_new (I_("font-changed"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (ClutterBackendClass, font_changed),
+                  NULL, NULL,
+                  clutter_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
 }
 
 static void
@@ -388,8 +424,9 @@ clutter_backend_set_resolution (ClutterBackend *backend,
     priv->resolution = fixed_dpi;
 
   if (CLUTTER_CONTEXT ()->font_map)
-    cogl_pango_font_map_set_resolution (CLUTTER_CONTEXT ()->font_map,
+    cogl_pango_font_map_set_resolution (CLUTTER_CONTEXT ()->font_map, dpi);
-					COGL_FIXED_TO_FLOAT (fixed_dpi));
+
+  g_signal_emit (backend, backend_signals[RESOLUTION_CHANGED], 0);
 }
 
 /**
@@ -445,6 +482,8 @@ clutter_backend_set_font_options (ClutterBackend       *backend,
         priv->font_options = cairo_font_options_copy (options);
       else
         priv->font_options = NULL;
+
+      g_signal_emit (backend, backend_signals[FONT_CHANGED], 0);
     }
 }
 
@@ -482,3 +521,63 @@ clutter_backend_get_font_options (ClutterBackend *backend)
   return priv->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
+ */
+void
+clutter_backend_set_font_name (ClutterBackend *backend,
+                               const gchar    *font_name)
+{
+  ClutterBackendPrivate *priv;
+
+  g_return_if_fail (CLUTTER_IS_BACKEND (backend));
+
+  priv = backend->priv;
+
+  g_free (priv->font_name);
+
+  if (font_name == NULL || *font_name == '\0')
+    priv->font_name = g_strdup (DEFAULT_FONT_NAME);
+  else
+    priv->font_name = g_strdup (font_name);
+
+  g_signal_emit (backend, backend_signals[FONT_CHANGED], 0);
+}
+
+/**
+ * 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
+ */
+G_CONST_RETURN gchar *
+clutter_backend_get_font_name (ClutterBackend *backend)
+{
+  ClutterBackendPrivate *priv;
+
+  g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL);
+
+  priv = backend->priv;
+
+  if (G_LIKELY (priv->font_name))
+    return priv->font_name;
+
+  priv->font_name = g_strdup (DEFAULT_FONT_NAME);
+
+  return priv->font_name;
+}

clutter/clutter-backend.h

@@ -30,6 +30,8 @@
 
 #include <cairo.h>
 #include <glib-object.h>
+#include <pango/pango.h>
+
 #include <clutter/clutter-actor.h>
 #include <clutter/clutter-stage.h>
 #include <clutter/clutter-event.h>
@@ -77,6 +79,10 @@ struct _ClutterBackendClass
                                             ClutterStage    *stage);
   void                (* ensure_context)   (ClutterBackend  *backend,
                                             ClutterStage    *stage);
+
+  /* signals */
+  void (* resolution_changed) (ClutterBackend *backend);
+  void (* font_changed)       (ClutterBackend *backend);
 };
 
 GType clutter_backend_get_type    (void) G_GNUC_CONST;
@@ -95,6 +101,9 @@ guint                 clutter_backend_get_double_click_distance (ClutterBackend
 void                  clutter_backend_set_font_options          (ClutterBackend       *backend,
                                                                  cairo_font_options_t *options);
 cairo_font_options_t *clutter_backend_get_font_options          (ClutterBackend       *backend);
+void                  clutter_backend_set_font_name             (ClutterBackend       *backend,
+                                                                 const gchar          *font_name);
+G_CONST_RETURN gchar *clutter_backend_get_font_name             (ClutterBackend       *backend);
 
 G_END_DECLS
 

clutter/clutter-behaviour-rotate.c

@@ -619,7 +619,7 @@ clutter_behaviour_rotate_get_boundsx (ClutterBehaviourRotate *rotate,
 
   priv = rotate->priv;
 
-  if (angle_start);
+  if (angle_start)
     *angle_start = priv->angle_start;
 
   if (angle_end)

clutter/clutter-behaviour.c

@@ -570,6 +570,9 @@ clutter_behaviour_set_alpha (ClutterBehaviour *behave,
 
   priv = behave->priv;
 
+  if (alpha)
+    g_object_ref_sink (alpha);
+
   if (priv->notify_id)
     {
       CLUTTER_NOTE (BEHAVIOUR, "removing previous notify-id (%d)",
@@ -590,7 +593,6 @@ clutter_behaviour_set_alpha (ClutterBehaviour *behave,
   if (alpha)
     {
       priv->alpha = alpha;
-      g_object_ref_sink (priv->alpha);
 
       priv->notify_id = g_signal_connect (priv->alpha, "notify::alpha",
                                           G_CALLBACK(notify_cb),

clutter/clutter-binding-pool.c

@@ -476,10 +476,129 @@ clutter_binding_pool_install_closure (ClutterBindingPool  *pool,
   g_hash_table_insert (pool->entries_hash, entry, entry);
 }
 
-gchar **
+/**
-clutter_binding_pool_list_actions (ClutterBindingPool *pool)
+ * clutter_binding_pool_override_action:
+ * @pool: a #ClutterBindingPool
+ * @key_val: key symbol
+ * @modifiers: bitmask of modifiers
+ * @callback: function to be called when the action is activated
+ * @data: data to be passed to @callback
+ * @notify: function to be called when the action is removed
+ *   from the pool
+ *
+ * Allows overriding the action for @key_val and @modifiers inside a
+ * #ClutterBindingPool. See clutter_binding_pool_install_action().
+ *
+ * When an action has been activated using clutter_binding_pool_activate()
+ * the passed @callback will be invoked (with @data).
+ *
+ * Actions can be blocked with clutter_binding_pool_block_action()
+ * and then unblocked using clutter_binding_pool_unblock_action().
+ *
+ * Since: 1.0
+ */
+void
+clutter_binding_pool_override_action (ClutterBindingPool  *pool,
+                                      guint                key_val,
+                                      ClutterModifierType  modifiers,
+                                      GCallback            callback,
+                                      gpointer             data,
+                                      GDestroyNotify       notify)
 {
-  return NULL;
+  ClutterBindingEntry *entry;
+  GClosure *closure;
+
+  g_return_if_fail (pool != NULL);
+  g_return_if_fail (key_val != 0);
+  g_return_if_fail (callback != NULL);
+
+  entry = binding_pool_lookup_entry (pool, key_val, modifiers);
+  if (G_UNLIKELY (entry == NULL))
+    {
+      g_warning ("There is no action for the given key symbol "
+                 "of %d (modifiers: %d) installed inside the "
+                 "binding pool.",
+                 key_val, modifiers);
+      return;
+    }
+
+  if (entry->closure)
+    {
+      g_closure_unref (entry->closure);
+      entry->closure = NULL;
+    }
+
+  closure = g_cclosure_new (callback, data, (GClosureNotify) notify);
+  entry->closure = g_closure_ref (closure);
+  g_closure_sink (closure);
+
+  if (G_CLOSURE_NEEDS_MARSHAL (closure))
+    {
+      GClosureMarshal marshal;
+
+      marshal = clutter_marshal_BOOLEAN__STRING_UINT_ENUM;
+      g_closure_set_marshal (closure, marshal);
+    }
+}
+
+/**
+ * clutter_binding_pool_override_closure:
+ * @pool: a #ClutterBindingPool
+ * @key_val: key symbol
+ * @modifiers: bitmask of modifiers
+ * @closure: a #GClosure
+ *
+ * A #GClosure variant of clutter_binding_pool_override_action().
+ *
+ * Allows overriding the action for @key_val and @modifiers inside a
+ * #ClutterBindingPool. See clutter_binding_pool_install_closure().
+ *
+ * When an action has been activated using clutter_binding_pool_activate()
+ * the passed @callback will be invoked (with @data).
+ *
+ * Actions can be blocked with clutter_binding_pool_block_action()
+ * and then unblocked using clutter_binding_pool_unblock_action().
+ *
+ * Since: 1.0
+ */
+void
+clutter_binding_pool_override_closure (ClutterBindingPool  *pool,
+                                       guint                key_val,
+                                       ClutterModifierType  modifiers,
+                                       GClosure            *closure)
+{
+  ClutterBindingEntry *entry;
+
+  g_return_if_fail (pool != NULL);
+  g_return_if_fail (key_val != 0);
+  g_return_if_fail (closure != NULL);
+
+  entry = binding_pool_lookup_entry (pool, key_val, modifiers);
+  if (G_UNLIKELY (entry == NULL))
+    {
+      g_warning ("There is no action for the given key symbol "
+                 "of %d (modifiers: %d) installed inside the "
+                 "binding pool.",
+                 key_val, modifiers);
+      return;
+    }
+
+  if (entry->closure)
+    {
+      g_closure_unref (entry->closure);
+      entry->closure = NULL;
+    }
+
+  entry->closure = g_closure_ref (closure);
+  g_closure_sink (closure);
+
+  if (G_CLOSURE_NEEDS_MARSHAL (closure))
+    {
+      GClosureMarshal marshal;
+
+      marshal = clutter_marshal_BOOLEAN__STRING_UINT_ENUM;
+      g_closure_set_marshal (closure, marshal);
+    }
 }
 
 /**
@@ -531,6 +650,7 @@ clutter_binding_pool_remove_action (ClutterBindingPool  *pool,
                                     ClutterModifierType  modifiers)
 {
   ClutterBindingEntry remove_entry = { 0, };
+  GSList *l;
 
   g_return_if_fail (pool != NULL);
   g_return_if_fail (key_val != 0);
@@ -540,6 +660,18 @@ clutter_binding_pool_remove_action (ClutterBindingPool  *pool,
   remove_entry.key_val = key_val;
   remove_entry.modifiers = modifiers;
 
+  for (l = pool->entries; l != NULL; l = l->data)
+    {
+      ClutterBindingEntry *e = l->data;
+
+      if (e->key_val == remove_entry.key_val &&
+          e->modifiers == remove_entry.modifiers)
+        {
+          pool->entries = g_slist_remove_link (pool->entries, l);
+          break;
+        }
+    }
+
   g_hash_table_remove (pool->entries_hash, &remove_entry);
 }
 

clutter/clutter-binding-pool.h

@@ -56,40 +56,49 @@ typedef gboolean (* ClutterBindingActionFunc) (GObject             *gobject,
                                                guint                key_val,
                                                ClutterModifierType  modifiers);
 
-ClutterBindingPool *  clutter_binding_pool_new             (const gchar         *name);
+ClutterBindingPool *  clutter_binding_pool_new              (const gchar         *name);
-ClutterBindingPool *  clutter_binding_pool_get_for_class   (gpointer             klass);
+ClutterBindingPool *  clutter_binding_pool_get_for_class    (gpointer             klass);
-ClutterBindingPool *  clutter_binding_pool_find            (const gchar         *name);
+ClutterBindingPool *  clutter_binding_pool_find             (const gchar         *name);
 
-void                  clutter_binding_pool_install_action  (ClutterBindingPool  *pool,
+void                  clutter_binding_pool_install_action   (ClutterBindingPool  *pool,
-                                                            const gchar         *action_name,
+                                                             const gchar         *action_name,
-                                                            guint                key_val,
+                                                             guint                key_val,
-                                                            ClutterModifierType  modifiers,
+                                                             ClutterModifierType  modifiers,
-                                                            GCallback            callback,
+                                                             GCallback            callback,
-                                                            gpointer             data,
+                                                             gpointer             data,
-                                                            GDestroyNotify       notify);
+                                                             GDestroyNotify       notify);
-void                  clutter_binding_pool_install_closure (ClutterBindingPool  *pool,
+void                  clutter_binding_pool_install_closure  (ClutterBindingPool  *pool,
-                                                            const gchar         *action_name,
+                                                             const gchar         *action_name,
-                                                            guint                key_val,
+                                                             guint                key_val,
-                                                            ClutterModifierType  modifiers,
+                                                             ClutterModifierType  modifiers,
-                                                            GClosure            *closure);
+                                                             GClosure            *closure);
+void                  clutter_binding_pool_override_action  (ClutterBindingPool  *pool,
+                                                             guint                key_val,
+                                                             ClutterModifierType  modifiers,
+                                                             GCallback            callback,
+                                                             gpointer             data,
+                                                             GDestroyNotify       notify);
+void                  clutter_binding_pool_override_closure (ClutterBindingPool  *pool,
+                                                             guint                key_val,
+                                                             ClutterModifierType  modifiers,
+                                                             GClosure            *closure);
 
-gchar **              clutter_binding_pool_list_actions    (ClutterBindingPool  *pool);
+G_CONST_RETURN gchar *clutter_binding_pool_find_action      (ClutterBindingPool  *pool,
-G_CONST_RETURN gchar *clutter_binding_pool_find_action     (ClutterBindingPool  *pool,
+                                                             guint                key_val,
-                                                            guint                key_val,
+                                                             ClutterModifierType  modifiers);
-                                                            ClutterModifierType  modifiers);
+void                  clutter_binding_pool_remove_action    (ClutterBindingPool  *pool,
-void                  clutter_binding_pool_remove_action   (ClutterBindingPool  *pool,
+                                                             guint                key_val,
-                                                            guint                key_val,
+                                                             ClutterModifierType  modifiers);
-                                                            ClutterModifierType  modifiers);
 
-gboolean              clutter_binding_pool_activate        (ClutterBindingPool  *pool,
+gboolean              clutter_binding_pool_activate         (ClutterBindingPool  *pool,
-                                                            guint                key_val,
+                                                             guint                key_val,
-                                                            ClutterModifierType  modifiers,
+                                                             ClutterModifierType  modifiers,
-                                                            GObject             *gobject);
+                                                             GObject             *gobject);
 
-void                  clutter_binding_pool_block_action    (ClutterBindingPool  *pool,
+void                  clutter_binding_pool_block_action     (ClutterBindingPool  *pool,
-                                                            const gchar         *action_name);
+                                                             const gchar         *action_name);
-void                  clutter_binding_pool_unblock_action  (ClutterBindingPool  *pool,
+void                  clutter_binding_pool_unblock_action   (ClutterBindingPool  *pool,
-                                                            const gchar         *action_name);
+                                                             const gchar         *action_name);
 
 G_END_DECLS
 

clutter/clutter-clone-texture.c

@@ -25,7 +25,7 @@
 
 /**
  * SECTION:clutter-clone-texture
- * @short_description: Actor for cloning existing textures in an 
+ * @short_description: Actor for cloning existing textures in an
  * efficient way.
  *
  * #ClutterCloneTexture allows the cloning of existing #ClutterTexture based
@@ -39,7 +39,7 @@
 #include "clutter-main.h"
 #include "clutter-feature.h"
 #include "clutter-actor.h"
-#include "clutter-util.h" 
+#include "clutter-util.h"
 #include "clutter-enum-types.h"
 #include "clutter-private.h"
 #include "clutter-debug.h"
@@ -157,16 +157,16 @@ clutter_clone_texture_paint (ClutterActor *self)
 		clutter_actor_get_name (self) ? clutter_actor_get_name (self)
                                               : "unknown");
 
-  /* parent texture may have been hidden, there for need to make sure its 
+  /* parent texture may have been hidden, there for need to make sure its
-   * realised with resources available.  
+   * realised with resources available.
   */
   parent_texture = CLUTTER_ACTOR (priv->parent_texture);
   if (!CLUTTER_ACTOR_IS_REALIZED (parent_texture))
     clutter_actor_realize (parent_texture);
 
-   /* If 'parent' texture isn't visible we run its paint to be sure it 
+   /* If 'parent' texture isn't visible we run its paint to be sure it
-    * updates. Needed for TFP and likely FBOs. 
+    * updates. Needed for TFP and likely FBOs.
-    * Potentially could cause issues 
+    * Potentially could cause issues
     */
   if (!clutter_actor_get_paint_visibility(parent_texture))
     {
@@ -221,6 +221,9 @@ set_parent_texture (ClutterCloneTexture *ctexture,
   ClutterActor *actor = CLUTTER_ACTOR (ctexture);
   gboolean was_visible = CLUTTER_ACTOR_IS_VISIBLE (ctexture);
 
+  if (priv->parent_texture == texture)
+    return;
+
   if (priv->parent_texture)
     {
       g_object_unref (priv->parent_texture);
@@ -230,7 +233,7 @@ set_parent_texture (ClutterCloneTexture *ctexture,
         clutter_actor_hide (actor);
     }
 
-  if (texture) 
+  if (texture)
     {
       priv->parent_texture = g_object_ref (texture);
 
@@ -244,14 +247,14 @@ set_parent_texture (ClutterCloneTexture *ctexture,
 
       clutter_actor_queue_relayout (actor);
     }
-      
+
 }
 
-static void 
+static void
 clutter_clone_texture_dispose (GObject *object)
 {
   ClutterCloneTexture         *self = CLUTTER_CLONE_TEXTURE(object);
-  ClutterCloneTexturePrivate  *priv = self->priv;  
+  ClutterCloneTexturePrivate  *priv = self->priv;
 
   if (priv->parent_texture)
     g_object_unref (priv->parent_texture);
@@ -261,7 +264,7 @@ clutter_clone_texture_dispose (GObject *object)
   G_OBJECT_CLASS (clutter_clone_texture_parent_class)->dispose (object);
 }
 
-static void 
+static void
 clutter_clone_texture_finalize (GObject *object)
 {
   G_OBJECT_CLASS (clutter_clone_texture_parent_class)->finalize (object);
@@ -391,7 +394,7 @@ clutter_clone_texture_init (ClutterCloneTexture *self)
  * clutter_clone_texture_new:
  * @texture: a #ClutterTexture, or %NULL
  *
- * Creates an efficient 'clone' of a pre-existing texture with which it 
+ * Creates an efficient 'clone' of a pre-existing texture with which it
  * shares the underlying pixbuf data.
  *
  * You can use clutter_clone_texture_set_parent_texture() to change the
@@ -412,7 +415,7 @@ clutter_clone_texture_new (ClutterTexture *texture)
 /**
  * clutter_clone_texture_get_parent_texture:
  * @clone: a #ClutterCloneTexture
- * 
+ *
  * Retrieves the parent #ClutterTexture used by @clone.
  *
  * Return value: a #ClutterTexture actor, or %NULL

clutter/clutter-entry.h

@@ -1,165 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *             Neil Jagdish Patel <njp@o-hand.com
- *
- * Copyright (C) 2006 OpenedHand
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_ENTRY_H__
-#define __CLUTTER_ENTRY_H__
-
-#include <clutter/clutter-actor.h>
-#include <clutter/clutter-color.h>
-#include <clutter/clutter-event.h>
-#include <pango/pango.h>
-
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_ENTRY (clutter_entry_get_type ())
-
-#define CLUTTER_ENTRY(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  CLUTTER_TYPE_ENTRY, ClutterEntry))
-
-#define CLUTTER_ENTRY_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), \
-  CLUTTER_TYPE_ENTRY, ClutterEntryClass))
-
-#define CLUTTER_IS_ENTRY(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
-  CLUTTER_TYPE_ENTRY))
-
-#define CLUTTER_IS_ENTRY_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
-  CLUTTER_TYPE_ENTRY))
-
-#define CLUTTER_ENTRY_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
-  CLUTTER_TYPE_ENTRY, ClutterEntryClass))
-
-typedef struct _ClutterEntry ClutterEntry;
-typedef struct _ClutterEntryClass ClutterEntryClass;
-typedef struct _ClutterEntryPrivate ClutterEntryPrivate;
-
-struct _ClutterEntry
-{
-  /*< private >*/
-  ClutterActor parent_instance;
-
-  ClutterEntryPrivate   *priv;
-};
-
-/**
- * ClutterEntryClass:
- * @paint_cursor: virtual function for subclasses to use to draw a custom
- *   cursor instead of the default one
- * @text_changed: signal class handler for ClutterEntry::text-changed
- * @cursor_event: signal class handler for ClutterEntry::cursor-event
- * @activate: signal class handler for ClutterEntry::activate
- *
- * Class fo entry actors.
- *
- * Since: 0.4
- */
-struct _ClutterEntryClass 
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-  
-  /*< public >*/
-  /* vfuncs, not signals */
-  void (* paint_cursor) (ClutterEntry    *entry);
-  
-  /* signals */
-  void (* text_changed) (ClutterEntry    *entry);
-  void (* cursor_event) (ClutterEntry    *entry,
-                         ClutterGeometry *geometry);
-  void (* activate)     (ClutterEntry    *entry);
-    
-  /*< private >*/
-  /* padding for future */
-  void (*_clutter_entry_1) (void);
-  void (*_clutter_entry_2) (void);
-  void (*_clutter_entry_3) (void);
-  void (*_clutter_entry_4) (void);
-}; 
-
-GType clutter_entry_get_type (void) G_GNUC_CONST;
-
-ClutterActor *        clutter_entry_new                 (void);
-ClutterActor *        clutter_entry_new_full            (const gchar        *font_name,
-							 const gchar        *text,
-							 const ClutterColor *color);
-ClutterActor *        clutter_entry_new_with_text       (const gchar        *font_name,
-                                                         const gchar        *text);
-void                  clutter_entry_set_text            (ClutterEntry       *entry,
-						         const gchar        *text);
-G_CONST_RETURN gchar *clutter_entry_get_text            (ClutterEntry       *entry);
-void                  clutter_entry_set_font_name       (ClutterEntry       *entry,
-						         const gchar        *font_name);
-G_CONST_RETURN gchar *clutter_entry_get_font_name       (ClutterEntry       *entry);
-void                  clutter_entry_set_color           (ClutterEntry       *entry,
-						         const ClutterColor *color);
-void                  clutter_entry_get_color           (ClutterEntry       *entry,
-						         ClutterColor       *color);
-PangoLayout *         clutter_entry_get_layout          (ClutterEntry       *entry);
-void                  clutter_entry_set_alignment       (ClutterEntry       *entry,
-                                                         PangoAlignment      alignment);
-PangoAlignment        clutter_entry_get_alignment       (ClutterEntry       *entry);
-void                  clutter_entry_set_cursor_position (ClutterEntry       *entry,
-                                                         gint                position);
-gint                  clutter_entry_get_cursor_position (ClutterEntry       *entry);
-void                  clutter_entry_insert_unichar      (ClutterEntry       *entry,
-                                                         gunichar            wc);
-void                  clutter_entry_delete_chars        (ClutterEntry       *entry,
-                                                         guint               len);
-void                  clutter_entry_insert_text         (ClutterEntry       *entry,
-                                                         const gchar        *text,
-                                                         gssize              position);
-void                  clutter_entry_delete_text         (ClutterEntry       *entry,
-                                                         gssize              start_pos,
-                                                         gssize              end_pos);
-void                  clutter_entry_set_visible_cursor  (ClutterEntry       *entry,
-                                                         gboolean            visible);
-gboolean              clutter_entry_get_visible_cursor  (ClutterEntry       *entry);
-
-void                  clutter_entry_set_visibility      (ClutterEntry       *entry,
-                                                         gboolean            visible);
-gboolean              clutter_entry_get_visibility      (ClutterEntry       *entry);
-void                  clutter_entry_set_invisible_char  (ClutterEntry       *entry,
-                                                         gunichar            wc);
-gunichar              clutter_entry_get_invisible_char  (ClutterEntry       *entry);
-void                  clutter_entry_set_max_length      (ClutterEntry       *entry,
-                                                         gint                max);
-gint                  clutter_entry_get_max_length      (ClutterEntry       *entry);
-
-#ifndef CLUTTER_DISABLE_DEPRECATED
-void                  clutter_entry_handle_key_event    (ClutterEntry       *entry,
-                                                         ClutterKeyEvent    *kev);
-#endif
-
-G_END_DECLS
-
-#endif /* __CLUTTER_ENTRY_H__ */

clutter/clutter-label.h

@@ -1,128 +0,0 @@
-/*
- * Clutter.
- *
- * An OpenGL based 'interactive canvas' library.
- *
- * Authored By Matthew Allum  <mallum@openedhand.com>
- *
- * Copyright (C) 2006 OpenedHand
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
-#ifndef __CLUTTER_LABEL_H__
-#define __CLUTTER_LABEL_H__
-
-#include <clutter/clutter-actor.h>
-#include <clutter/clutter-color.h>
-#include <pango/pango.h>
-
-
-G_BEGIN_DECLS
-
-#define CLUTTER_TYPE_LABEL (clutter_label_get_type ())
-
-#define CLUTTER_LABEL(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  CLUTTER_TYPE_LABEL, ClutterLabel))
-
-#define CLUTTER_LABEL_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), \
-  CLUTTER_TYPE_LABEL, ClutterLabelClass))
-
-#define CLUTTER_IS_LABEL(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
-  CLUTTER_TYPE_LABEL))
-
-#define CLUTTER_IS_LABEL_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
-  CLUTTER_TYPE_LABEL))
-
-#define CLUTTER_LABEL_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
-  CLUTTER_TYPE_LABEL, ClutterLabelClass))
-
-typedef struct _ClutterLabel ClutterLabel;
-typedef struct _ClutterLabelClass ClutterLabelClass;
-typedef struct _ClutterLabelPrivate ClutterLabelPrivate;
-
-struct _ClutterLabel
-{
-  ClutterActor         parent;
-
-  /*< private >*/
-  ClutterLabelPrivate   *priv;
-};
-
-struct _ClutterLabelClass 
-{
-  /*< private >*/
-  ClutterActorClass parent_class;
-
-  void (*_clutter_label_1) (void);
-  void (*_clutter_label_2) (void);
-  void (*_clutter_label_3) (void);
-  void (*_clutter_label_4) (void);
-}; 
-
-GType clutter_label_get_type (void) G_GNUC_CONST;
-
-ClutterActor *        clutter_label_new                (void);
-
-ClutterActor*         clutter_label_new_full           (const gchar        *font_name,
-							const gchar        *text,
-							const ClutterColor *color);
-
-ClutterActor *        clutter_label_new_with_text      (const gchar        *font_name,
-                                                        const gchar        *text);
-void                  clutter_label_set_text           (ClutterLabel       *label,
-						        const gchar        *text);
-G_CONST_RETURN gchar *clutter_label_get_text           (ClutterLabel       *label);
-void                  clutter_label_set_font_name      (ClutterLabel       *label,
-						        const gchar        *font_name);
-G_CONST_RETURN gchar *clutter_label_get_font_name      (ClutterLabel       *label);
-void                  clutter_label_set_color          (ClutterLabel       *label,
-						        const ClutterColor *color);
-void                  clutter_label_get_color          (ClutterLabel       *label,
-						        ClutterColor       *color);
-void                  clutter_label_set_ellipsize      (ClutterLabel       *label,
-                                                        PangoEllipsizeMode  mode);
-PangoEllipsizeMode    clutter_label_get_ellipsize      (ClutterLabel       *label);
-void                  clutter_label_set_line_wrap      (ClutterLabel       *label,
-                                                        gboolean            wrap);
-gboolean              clutter_label_get_line_wrap      (ClutterLabel       *label);
-void                  clutter_label_set_line_wrap_mode (ClutterLabel       *label,
-                                                        PangoWrapMode       wrap_mode);
-PangoWrapMode         clutter_label_get_line_wrap_mode (ClutterLabel       *label);
-PangoLayout *         clutter_label_get_layout         (ClutterLabel       *label);
-void                  clutter_label_set_attributes     (ClutterLabel       *label,
-                                                        PangoAttrList      *attrs);
-PangoAttrList *       clutter_label_get_attributes     (ClutterLabel       *label);
-void                  clutter_label_set_use_markup     (ClutterLabel       *label,
-                                                        gboolean            setting);
-gboolean              clutter_label_get_use_markup     (ClutterLabel       *label);
-void                  clutter_label_set_alignment      (ClutterLabel       *label,
-                                                        PangoAlignment      alignment);
-PangoAlignment        clutter_label_get_alignment      (ClutterLabel       *label);
-void                  clutter_label_set_justify        (ClutterLabel       *label,
-                                                        gboolean            justify);
-gboolean              clutter_label_get_justify        (ClutterLabel       *label);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_LABEL_H__ */

clutter/clutter-main.c

@@ -53,21 +53,23 @@
 #include "pango/cogl-pango.h"
 
 /* main context */
-static ClutterMainContext *ClutterCntx  = NULL;
+static ClutterMainContext *ClutterCntx       = NULL;
 
 /* main lock and locking/unlocking functions */
-static GMutex *clutter_threads_mutex    = NULL;
+static GMutex *clutter_threads_mutex         = NULL;
-static GCallback clutter_threads_lock   = NULL;
+static GCallback clutter_threads_lock        = NULL;
-static GCallback clutter_threads_unlock = NULL;
+static GCallback clutter_threads_unlock      = NULL;
 
-static gboolean clutter_is_initialized  = FALSE;
+static gboolean clutter_is_initialized       = FALSE;
-static gboolean clutter_show_fps        = FALSE;
+static gboolean clutter_show_fps             = FALSE;
-static gboolean clutter_fatal_warnings  = FALSE;
+static gboolean clutter_fatal_warnings       = FALSE;
 
-static guint clutter_default_fps        = 60;
+static guint clutter_default_fps             = 60;
 
-static guint clutter_main_loop_level    = 0;
+static guint clutter_main_loop_level         = 0;
-static GSList *main_loops               = NULL;
+static GSList *main_loops                    = NULL;
+
+static PangoDirection clutter_text_direction = PANGO_DIRECTION_LTR;
 
 guint clutter_debug_flags = 0;  /* global clutter debug flag */
 
@@ -401,23 +403,100 @@ _clutter_do_pick (ClutterStage   *stage,
   return clutter_get_actor_by_gid (id);
 }
 
+static PangoDirection
+clutter_get_text_direction (void)
+{
+  PangoDirection dir = PANGO_DIRECTION_LTR;
+  const gchar *direction;
+
+  direction = g_getenv ("CLUTTER_TEXT_DIRECTION");
+  if (direction && *direction != '\0')
+    {
+      if (strcmp (direction, "rtl") == 0)
+        dir = PANGO_DIRECTION_RTL;
+      else if (strcmp (direction, "ltr") == 0)
+        dir = PANGO_DIRECTION_LTR;
+    }
+  else
+    {
+      /* Translate to default:RTL if you want your widgets
+       * to be RTL, otherwise translate to default:LTR.
+       *
+       * Do *not* translate it to "predefinito:LTR": if it
+       * it isn't default:LTR or default:RTL it will not work
+       */
+      char *e = _("default:LTR");
+
+      if (strcmp (e, "default:RTL") == 0)
+        dir = PANGO_DIRECTION_RTL;
+      else if (strcmp (e, "default:LTR") == 0)
+        dir = PANGO_DIRECTION_LTR;
+      else
+        g_warning ("Whoever translated default:LTR did so wrongly.");
+    }
+
+  return dir;
+}
+
+static void
+update_pango_context (ClutterBackend *backend,
+                      PangoContext   *context)
+{
+  PangoFontDescription *font_desc;
+  cairo_font_options_t *font_options;
+  const gchar *font_name;
+  gdouble resolution;
+
+  /* update the text direction */
+  pango_context_set_base_dir (context, clutter_text_direction);
+
+  /* get the configuration for the PangoContext from the backend */
+  font_name = clutter_backend_get_font_name (backend);
+  font_options = clutter_backend_get_font_options (backend);
+  resolution = clutter_backend_get_resolution (backend);
+
+  font_desc = pango_font_description_from_string (font_name);
+
+  if (resolution < 0)
+    resolution = 96.0; /* fall back */
+
+  pango_context_set_font_description (context, font_desc);
+  pango_cairo_context_set_font_options (context, font_options);
+  pango_cairo_context_set_resolution (context, resolution);
+
+  pango_font_description_free (font_desc);
+}
+
+PangoContext *
+_clutter_context_get_pango_context (ClutterMainContext *self)
+{
+  if (G_UNLIKELY (self->pango_context == NULL))
+    {
+      PangoContext *context;
+
+      context = cogl_pango_font_map_create_context (self->font_map);
+      self->pango_context = context;
+
+      g_signal_connect (self->backend, "resolution-changed",
+                        G_CALLBACK (update_pango_context),
+                        self->pango_context);
+      g_signal_connect (self->backend, "font-changed",
+                        G_CALLBACK (update_pango_context),
+                        self->pango_context);
+    }
+
+  update_pango_context (self->backend, self->pango_context);
+
+  return self->pango_context;
+}
+
 PangoContext *
 _clutter_context_create_pango_context (ClutterMainContext *self)
 {
   PangoContext *context;
-  gdouble resolution;
-  cairo_font_options_t *font_options;
-
-  resolution = clutter_backend_get_resolution (self->backend);
-  if (resolution < 0)
-    resolution = 96.0; /* fall back */
 
   context = cogl_pango_font_map_create_context (self->font_map);
-
+  update_pango_context (self->backend, context);
-  pango_cairo_context_set_resolution (context, resolution);
-
-  font_options = clutter_backend_get_font_options (self->backend);
-  pango_cairo_context_set_font_options (context, font_options);
 
   return context;
 }
@@ -1004,6 +1083,17 @@ clutter_get_timestamp (void)
 #endif
 }
 
+static gboolean
+clutter_arg_direction_cb (const char *key,
+                          const char *value,
+                          gpointer    user_data)
+{
+  clutter_text_direction =
+    (strcmp (value, "rtl") == 0) ? PANGO_DIRECTION_RTL
+                                 : PANGO_DIRECTION_LTR;
+
+  return TRUE;
+}
 
 #ifdef CLUTTER_ENABLE_DEBUG
 static gboolean
@@ -1077,6 +1167,8 @@ clutter_init_real (GError **error)
   cogl_pango_font_map_set_resolution (ctx->font_map, resolution);
   cogl_pango_font_map_set_use_mipmapping (ctx->font_map, TRUE);
 
+  clutter_text_direction = clutter_get_text_direction ();
+
   /* Stage will give us a GL Context etc */
   stage = clutter_stage_get_default ();
   if (!stage)
@@ -1142,16 +1234,19 @@ clutter_init_real (GError **error)
 
 static GOptionEntry clutter_args[] = {
   { "clutter-show-fps", 0, 0, G_OPTION_ARG_NONE, &clutter_show_fps,
-    "Show frames per second", NULL },
+    N_("Show frames per second"), NULL },
   { "clutter-default-fps", 0, 0, G_OPTION_ARG_INT, &clutter_default_fps,
-    "Default frame rate", "FPS" },
+    N_("Default frame rate"), "FPS" },
   { "g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &clutter_fatal_warnings,
-    "Make all warnings fatal", NULL },
+    N_("Make all warnings fatal"), NULL },
+  { "clutter-text-direction", 0, 0, G_OPTION_ARG_CALLBACK,
+    clutter_arg_direction_cb,
+    N_("Direction for the text"), "DIRECTION" },
 #ifdef CLUTTER_ENABLE_DEBUG
   { "clutter-debug", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_debug_cb,
-    "Clutter debugging flags to set", "FLAGS" },
+    N_("Clutter debugging flags to set"), "FLAGS" },
   { "clutter-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_no_debug_cb,
-    "Clutter debugging flags to unset", "FLAGS" },
+    N_("Clutter debugging flags to unset"), "FLAGS" },
 #endif /* CLUTTER_ENABLE_DEBUG */
   { NULL, },
 };
@@ -1294,13 +1389,14 @@ clutter_get_option_group (void)
   context = clutter_context_get_default ();
 
   group = g_option_group_new ("clutter",
-                              "Clutter Options",
+                              _("Clutter Options"),
-                              "Show Clutter Options",
+                              _("Show Clutter Options"),
                               NULL,
                               NULL);
 
   g_option_group_set_parse_hooks (group, pre_parse_hook, post_parse_hook);
   g_option_group_add_entries (group, clutter_args);
+  g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
 
   /* add backend-specific options */
   _clutter_backend_add_options (context->backend, group);
@@ -2118,6 +2214,9 @@ clutter_base_init (void)
 
       initialised = TRUE;
 
+      bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+      bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+
       /* initialise GLib type system */
       g_type_init ();
 

clutter/clutter-private.h

@@ -38,6 +38,8 @@
 
 #include <glib.h>
 
+#include "pango/cogl-pango.h"
+
 #include "clutter-backend.h"
 #include "clutter-event.h"
 #include "clutter-feature.h"
@@ -45,7 +47,6 @@
 #include "clutter-stage-manager.h"
 #include "clutter-stage-window.h"
 #include "clutter-stage.h"
-#include "pango/cogl-pango.h"
 
 G_BEGIN_DECLS
 
@@ -125,15 +126,17 @@ struct _ClutterMainContext
   gint fb_r_mask, fb_g_mask, fb_b_mask;
   gint fb_r_mask_used, fb_g_mask_used, fb_b_mask_used;
 
-  CoglPangoFontMap *font_map;       /* Global font map */
+  PangoContext     *pango_context;      /* Global Pango context */
+  CoglPangoFontMap *font_map;           /* Global font map */
 
-  GSList              *input_devices; /* For extra input devices, i.e
+  GSList              *input_devices;   /* For extra input devices, i.e
-                                         MultiTouch */
+                                           MultiTouch */
 };
 
 #define CLUTTER_CONTEXT()	(clutter_context_get_default ())
 ClutterMainContext *clutter_context_get_default (void);
 PangoContext *_clutter_context_create_pango_context (ClutterMainContext *self);
+PangoContext *_clutter_context_get_pango_context    (ClutterMainContext *self);
 
 #define CLUTTER_PRIVATE_FLAGS(a)	 (((ClutterActor *) (a))->private_flags)
 #define CLUTTER_SET_PRIVATE_FLAGS(a,f)	 (CLUTTER_PRIVATE_FLAGS (a) |= (f))

clutter/clutter-stage.c

@@ -1201,7 +1201,7 @@ clutter_stage_read_pixels (ClutterStage *stage,
 
   /* The y co-ordinate should be given in OpenGL's coordinate system
      so 0 is the bottom row */
-  y = stage_height - 1 - y - height;
+  y = stage_height - y - height;
 
   glFinish ();
 

clutter/clutter-text.h

@@ -0,0 +1,198 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2008  Intel Corporation.
+ *
+ * Authored By: Øyvind Kolås <pippin@o-hand.com>
+ *              Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_TEXT_H__
+#define __CLUTTER_TEXT_H__
+
+#include <clutter/clutter-actor.h>
+#include <pango/pango.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_TEXT               (clutter_text_get_type ())
+#define CLUTTER_TEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TEXT, ClutterText))
+#define CLUTTER_TEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TEXT, ClutterTextClass))
+#define CLUTTER_IS_TEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TEXT))
+#define CLUTTER_IS_TEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TEXT))
+#define CLUTTER_TEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TEXT, ClutterTextClass))
+
+typedef struct _ClutterText        ClutterText;
+typedef struct _ClutterTextPrivate ClutterTextPrivate;
+typedef struct _ClutterTextClass   ClutterTextClass;
+
+/**
+ * ClutterText:
+ *
+ * The #ClutterText struct contains only private data.
+ *
+ * Since: 1.0
+ */
+struct _ClutterText
+{
+  /*< private >*/
+  ClutterActor parent_instance;
+
+  ClutterTextPrivate *priv;
+};
+
+/**
+ * ClutterTextClass:
+ * @text_changed: class handler for the #ClutterText::text-changed signal
+ * @activate: class handler for the #ClutterText::activate signal
+ * @cursor_event: class handler for the #ClutterText::cursor_event signal
+ *
+ * The #ClutterTextClass struct contains only private data.
+ *
+ * Since: 1.0
+ */
+struct _ClutterTextClass
+{
+  /*< private >*/
+  ClutterActorClass parent_class;
+
+  /*< public >*/
+  /* signals, not vfuncs */
+  void (* text_changed) (ClutterText           *self);
+  void (* activate)     (ClutterText           *self);
+  void (* cursor_event) (ClutterText           *self,
+                         const ClutterGeometry *geometry);
+
+  /*< private >*/
+  /* padding for future expansion */
+  void (* _clutter_reserved1) (void);
+  void (* _clutter_reserved2) (void);
+  void (* _clutter_reserved3) (void);
+  void (* _clutter_reserved4) (void);
+  void (* _clutter_reserved5) (void);
+  void (* _clutter_reserved6) (void);
+  void (* _clutter_reserved7) (void);
+  void (* _clutter_reserved8) (void);
+};
+
+GType clutter_text_get_type (void) G_GNUC_CONST;
+
+ClutterActor *        clutter_text_new                  (void);
+ClutterActor *        clutter_text_new_full             (const gchar        *font_name,
+                                                         const gchar        *text,
+                                                         const ClutterColor *color);
+ClutterActor *        clutter_text_new_with_text        (const gchar        *font_name,
+                                                         const gchar        *text);
+
+G_CONST_RETURN gchar *clutter_text_get_text             (ClutterText        *self);
+void                  clutter_text_set_text             (ClutterText        *self,
+                                                         const gchar        *text);
+PangoLayout *         clutter_text_get_layout           (ClutterText        *self);
+void                  clutter_text_set_color            (ClutterText        *self,
+                                                         const ClutterColor *color);
+void                  clutter_text_get_color            (ClutterText        *self,
+                                                         ClutterColor       *color);
+void                  clutter_text_set_font_name        (ClutterText        *self,
+                                                         const gchar        *font_name);
+G_CONST_RETURN gchar *clutter_text_get_font_name        (ClutterText        *self);
+
+void                  clutter_text_set_ellipsize        (ClutterText        *self,
+                                                         PangoEllipsizeMode  mode);
+PangoEllipsizeMode    clutter_text_get_ellipsize        (ClutterText        *self);
+void                  clutter_text_set_line_wrap        (ClutterText        *self,
+                                                         gboolean            line_wrap);
+gboolean              clutter_text_get_line_wrap        (ClutterText        *self);
+void                  clutter_text_set_line_wrap_mode   (ClutterText        *self,
+                                                         PangoWrapMode       wrap_mode);
+PangoWrapMode         clutter_text_get_line_wrap_mode   (ClutterText        *self);
+PangoLayout *         clutter_text_get_layout           (ClutterText        *self);
+void                  clutter_text_set_attributes       (ClutterText        *self,
+                                                         PangoAttrList      *attrs);
+PangoAttrList *       clutter_text_get_attributes       (ClutterText        *self);
+void                  clutter_text_set_use_markup       (ClutterText        *self,
+                                                         gboolean            setting);
+gboolean              clutter_text_get_use_markup       (ClutterText        *self);
+void                  clutter_text_set_alignment        (ClutterText        *self,
+                                                         PangoAlignment      alignment);
+PangoAlignment        clutter_text_get_alignment        (ClutterText        *self);
+void                  clutter_text_set_justify          (ClutterText        *self,
+                                                         gboolean            justify);
+gboolean              clutter_text_get_justify          (ClutterText        *self);
+
+void                  clutter_text_insert_unichar       (ClutterText        *self,
+                                                         gunichar            wc);
+void                  clutter_text_delete_chars         (ClutterText        *self,
+                                                         guint               n_chars);
+void                  clutter_text_insert_text          (ClutterText        *self,
+                                                         const gchar        *text,
+                                                         gssize              position);
+void                  clutter_text_delete_text          (ClutterText        *self,
+                                                         gssize              start_pos,
+                                                         gssize              end_pos);
+gchar *               clutter_text_get_chars            (ClutterText        *self,
+                                                         gssize              start_pos,
+                                                         gssize              end_pos);
+void                  clutter_text_set_editable         (ClutterText        *self,
+                                                         gboolean            editable);
+gboolean              clutter_text_get_editable         (ClutterText        *self);
+void                  clutter_text_set_activatable      (ClutterText        *self,
+                                                         gboolean            activatable);
+gboolean              clutter_text_get_activatable      (ClutterText        *self);
+
+gint                  clutter_text_get_cursor_position  (ClutterText        *self);
+void                  clutter_text_set_cursor_position  (ClutterText        *self,
+                                                         gint                position);
+void                  clutter_text_set_cursor_visible   (ClutterText        *self,
+                                                         gboolean            cursor_visible);
+gboolean              clutter_text_get_cursor_visible   (ClutterText        *self);
+void                  clutter_text_set_cursor_color     (ClutterText        *self,
+                                                         const ClutterColor *color);
+void                  clutter_text_get_cursor_color     (ClutterText        *self,
+                                                         ClutterColor       *color);
+void                  clutter_text_set_cursor_size      (ClutterText        *self,
+                                                         gint                size);
+guint                 clutter_text_get_cursor_size      (ClutterText        *self);
+void                  clutter_text_set_selectable       (ClutterText        *self,
+                                                         gboolean            selectable);
+gboolean              clutter_text_get_selectable       (ClutterText        *self);
+void                  clutter_text_set_selection_bound  (ClutterText        *self,
+                                                         gint                selection_bound);
+gint                  clutter_text_get_selection_bound  (ClutterText        *self);
+void                  clutter_text_set_selection        (ClutterText        *self,
+                                                         gssize              start_pos,
+                                                         gssize              end_pos);
+gchar *               clutter_text_get_selection        (ClutterText        *self);
+void                  clutter_text_set_password_char    (ClutterText        *self,
+                                                         gunichar            wc);
+gunichar              clutter_text_get_password_char    (ClutterText        *self);
+void                  clutter_text_set_max_length       (ClutterText        *self,
+                                                         gint                max);
+gint                  clutter_text_get_max_length       (ClutterText        *self);
+void                  clutter_text_set_single_line_mode (ClutterText        *self,
+                                                         gboolean            single_line);
+gboolean              clutter_text_get_single_line_mode (ClutterText        *self);
+
+gboolean              clutter_text_activate             (ClutterText        *self);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_TEXT_H__ */

clutter/clutter-texture.c

@@ -252,8 +252,8 @@ clutter_texture_realize (ClutterActor *actor)
       if (priv->texture != COGL_INVALID_HANDLE)
 	cogl_texture_unref (priv->texture);
 
-      priv->texture 
+      priv->texture
-            = cogl_texture_new_with_size 
+            = cogl_texture_new_with_size
                           (priv->width,
                            priv->height,
                            priv->no_slice ? -1 : priv->max_tile_waste,
@@ -376,12 +376,12 @@ clutter_texture_get_preferred_height (ClutterActor *self,
             {
               /* Set the natural height so as to preserve the aspect ratio */
               ClutterFixed ratio, width;
-              
+
               ratio = COGL_FIXED_DIV (COGL_FIXED_FROM_INT (priv->height),
                                       COGL_FIXED_FROM_INT (priv->width));
 
               width = CLUTTER_UNITS_TO_FIXED (for_width);
-              
+
               *natural_height_p =
                 CLUTTER_UNITS_FROM_FIXED (COGL_FIXED_MUL (ratio, width));
             }
@@ -417,7 +417,8 @@ clutter_texture_set_fbo_projection (ClutterActor *self)
   ClutterTexturePrivate *priv = CLUTTER_TEXTURE (self)->priv;
   ClutterVertex verts[4];
   ClutterFixed viewport[4];
-  ClutterFixed  x_min, x_max, y_min, y_max;
+  ClutterUnit x_min, x_max, y_min, y_max;
+  ClutterFixed tx_min, tx_max, ty_min, ty_max;
   ClutterPerspective perspective;
   ClutterStage *stage;
   ClutterFixed tan_angle, near_size;
@@ -450,21 +451,26 @@ clutter_texture_set_fbo_projection (ClutterActor *self)
 
   /* Convert the coordinates back to [-1,1] range */
   cogl_get_viewport (viewport);
-  x_min = COGL_FIXED_DIV (x_min, viewport[2]) * 2 - COGL_FIXED_1;
+
-  x_max = COGL_FIXED_DIV (x_max, viewport[2]) * 2 - COGL_FIXED_1;
+  tx_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_min), viewport[2])
-  y_min = COGL_FIXED_DIV (y_min, viewport[3]) * 2 - COGL_FIXED_1;
+         * 2 - COGL_FIXED_1;
-  y_max = COGL_FIXED_DIV (y_max, viewport[3]) * 2 - COGL_FIXED_1;
+  tx_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (x_max), viewport[2])
+         * 2 - COGL_FIXED_1;
+  ty_min = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_min), viewport[3])
+         * 2 - COGL_FIXED_1;
+  ty_max = COGL_FIXED_DIV (CLUTTER_UNITS_TO_FIXED (y_max), viewport[3])
+         * 2 - COGL_FIXED_1;
 
   /* Set up a projection matrix so that the actor will be projected as
      if it was drawn at its original location */
-  tan_angle = clutter_tani (CLUTTER_ANGLE_FROM_DEGX (perspective.fovy / 2));
+  tan_angle = cogl_angle_tan (COGL_ANGLE_FROM_DEGX (perspective.fovy / 2));
   near_size = COGL_FIXED_MUL (perspective.z_near, tan_angle);
 
-  cogl_frustum (COGL_FIXED_MUL (x_min, near_size),
+  cogl_frustum (COGL_FIXED_MUL (tx_min, near_size),
-		COGL_FIXED_MUL (x_max, near_size),
+                COGL_FIXED_MUL (tx_max, near_size),
-		COGL_FIXED_MUL (-y_min, near_size),
+                COGL_FIXED_MUL (-ty_min, near_size),
-		COGL_FIXED_MUL (-y_max, near_size),
+                COGL_FIXED_MUL (-ty_max, near_size),
-		perspective.z_near, perspective.z_far);
+                perspective.z_near, perspective.z_far);
 }
 
 static void
@@ -544,8 +550,10 @@ clutter_texture_paint (ClutterActor *self)
 
       /* Restore the perspective matrix using cogl_perspective so that
 	 the inverse matrix will be right */
-      cogl_perspective (perspective.fovy, perspective.aspect,
+      cogl_perspective (perspective.fovy,
-			perspective.z_near, perspective.z_far);
+                        perspective.aspect,
+                        perspective.z_near,
+                        perspective.z_far);
 
       /* If there is a shader on top of the shader stack, turn it back on. */
       if (shader)
@@ -588,9 +596,9 @@ clutter_texture_paint (ClutterActor *self)
 
   /* Paint will have translated us */
   cogl_texture_rectangle (priv->texture, 0, 0,
-			  COGL_FIXED_FROM_INT (x_2 - x_1),
+                          COGL_FIXED_FROM_INT (x_2 - x_1),
-			  COGL_FIXED_FROM_INT (y_2 - y_1),
+                          COGL_FIXED_FROM_INT (y_2 - y_1),
-			  0, 0, t_w, t_h);
+                          0, 0, t_w, t_h);
 }
 
 static void
@@ -938,7 +946,7 @@ clutter_scriptable_iface_init (ClutterScriptableIface *iface)
   parent_scriptable_iface = g_type_interface_peek_parent (iface);
 
   if (!parent_scriptable_iface)
-    parent_scriptable_iface = g_type_default_interface_peek 
+    parent_scriptable_iface = g_type_default_interface_peek
                                           (CLUTTER_TYPE_SCRIPTABLE);
 
   iface->set_custom_property = clutter_texture_set_custom_property;
@@ -1028,7 +1036,7 @@ clutter_texture_load_from_local_data (ClutterTexture *texture)
 				     priv->local_data_rowstride,
 				     priv->local_data_has_alpha ? 4: 3,
 				     0, NULL);
-				     
+
   g_free (priv->local_data);
   priv->local_data = NULL;
 }
@@ -1136,7 +1144,7 @@ clutter_texture_set_from_data (ClutterTexture     *texture,
 
   priv = texture->priv;
 
-  if ((new_texture = cogl_texture_new_from_data 
+  if ((new_texture = cogl_texture_new_from_data
                           (width, height,
                            priv->no_slice ? -1 : priv->max_tile_waste,
                            priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH,
@@ -1171,7 +1179,7 @@ clutter_texture_set_from_data (ClutterTexture     *texture,
  * @width: Width in pixels of image data.
  * @height: Height in pixels of image data
  * @rowstride: Distance in bytes between row starts.
- * @bpp: bytes per pixel (Currently only 3 and 4 supported, 
+ * @bpp: bytes per pixel (Currently only 3 and 4 supported,
  *                        depending on @has_alpha)
  * @flags: #ClutterTextureFlags
  * @error: return location for a #GError, or %NULL.
@@ -1318,7 +1326,7 @@ clutter_texture_set_from_file (ClutterTexture *texture,
 
   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
-  if ((new_texture = cogl_texture_new_from_file 
+  if ((new_texture = cogl_texture_new_from_file
                           (filename,
                            priv->no_slice ? -1 : priv->max_tile_waste,
                            priv->filter_quality == CLUTTER_TEXTURE_QUALITY_HIGH,
@@ -1577,7 +1585,7 @@ clutter_texture_get_base_size (ClutterTexture *texture,
  * @width: Width in pixels of region to update.
  * @height: Height in pixels of region to update.
  * @rowstride: Distance in bytes between row starts on source buffer.
- * @bpp: bytes per pixel (Currently only 3 and 4 supported, 
+ * @bpp: bytes per pixel (Currently only 3 and 4 supported,
  *                        depending on @has_alpha)
  * @flags: #ClutterTextureFlags
  * @error: return location for a #GError, or %NULL
@@ -1736,7 +1744,7 @@ on_fbo_parent_change (ClutterActor        *actor,
  *
  * Note this function is intented as a utility call for uniformly applying
  * shaders to groups and other potential visual effects. It requires that
- * the %CLUTTER_FEATURE_OFFSCREEN feature is supported by the current backend 
+ * the %CLUTTER_FEATURE_OFFSCREEN feature is supported by the current backend
  * and the target system.
  *
  * Some tips on usage:
@@ -1829,7 +1837,7 @@ clutter_texture_new_from_actor (ClutterActor *actor)
     return NULL;
 
   /* Hopefully now were good.. */
-  texture = g_object_new (CLUTTER_TYPE_TEXTURE, 
+  texture = g_object_new (CLUTTER_TYPE_TEXTURE,
                           "disable-slicing", TRUE,
                           NULL);
 

clutter/clutter-texture.h

@@ -80,8 +80,8 @@ struct _ClutterTextureClass
 {
   ClutterActorClass parent_class;
 
-  void (*size_change)   (ClutterTexture *texture, 
+  void (*size_change)   (ClutterTexture *texture,
-		         gint            width, 
+		         gint            width,
 		         gint            height);
   void (*pixbuf_change) (ClutterTexture *texture);
 

clutter/clutter.h

@@ -47,14 +47,12 @@
 #include "clutter-container.h"
 #include "clutter-deprecated.h"
 #include "clutter-effect.h"
-#include "clutter-entry.h"
 #include "clutter-event.h"
 #include "clutter-feature.h"
 #include "clutter-frame-source.h"
 #include "clutter-group.h"
 #include "clutter-interval.h"
 #include "clutter-keysyms.h" 
-#include "clutter-label.h"
 #include "clutter-list-model.h"
 #include "clutter-main.h"
 #include "clutter-media.h"
@@ -69,6 +67,7 @@
 #include "clutter-stage.h"
 #include "clutter-stage-manager.h"
 #include "clutter-texture.h"
+#include "clutter-text.h"
 #include "clutter-timeline.h"
 #include "clutter-timeout-pool.h"
 #include "clutter-types.h"

clutter/cogl/cogl-texture.h

@@ -148,7 +148,7 @@ gboolean        cogl_is_texture               (CoglHandle          handle);
 /**
  * cogl_texture_get_width:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the width of a cogl texture.
  *
  * Returns: the width of the GPU side texture in pixels:
@@ -158,7 +158,7 @@ guint           cogl_texture_get_width        (CoglHandle          handle);
 /**
  * cogl_texture_get_height:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the height of a cogl texture.
  *
  * Returns: the height of the GPU side texture in pixels:
@@ -168,7 +168,7 @@ guint           cogl_texture_get_height       (CoglHandle          handle);
 /**
  * cogl_texture_get_format:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the #CoglPixelFormat of a cogl texture.
  *
  * Returns: the #CoglPixelFormat of the GPU side texture.
@@ -179,7 +179,7 @@ CoglPixelFormat cogl_texture_get_format       (CoglHandle          handle);
 /**
  * cogl_texture_get_rowstride:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the rowstride of a cogl texture.
  *
  * Returns: the offset in bytes between each consequetive row of pixels.
@@ -189,7 +189,7 @@ guint           cogl_texture_get_rowstride    (CoglHandle          handle);
 /**
  * cogl_texture_get_max_waste:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the maximum wasted (unused) pixels in one dimension of a GPU side
  * texture.
  *
@@ -200,7 +200,7 @@ gint            cogl_texture_get_max_waste    (CoglHandle          handle);
 /**
  * cogl_texture_get_min_filter:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the currently set downscaling filter for a cogl texture.
  *
  * Returns: the current downscaling filter for a cogl texture.
@@ -210,7 +210,7 @@ COGLenum        cogl_texture_get_min_filter   (CoglHandle          handle);
 /**
  * cogl_texture_get_mag_filter:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query the currently set downscaling filter for a cogl texture.
  *
  * Returns: the current downscaling filter for a cogl texture.
@@ -220,7 +220,7 @@ COGLenum        cogl_texture_get_mag_filter   (CoglHandle          handle);
 /**
  * cogl_texture_is_sliced:
  * @handle: a #CoglHandle for a texture.
- * 
+ *
  * Query if a texture is sliced (stored as multiple GPU side tecture
  * objects).
  *
@@ -235,7 +235,7 @@ gboolean        cogl_texture_is_sliced        (CoglHandle          handle);
  * @out_gl_handle: pointer to return location for the textures GL handle, or
  * NULL.
  * @out_gl_target: pointer to return location for the GL target type, or NULL.
- * 
+ *
  * Query the GL handles for a GPU side texture through it's #CoglHandle,
  * if the texture is spliced the data for the first sub texture will be
  * queried.
@@ -255,7 +255,7 @@ gboolean        cogl_texture_get_gl_texture   (CoglHandle         handle,
  * specified.
  * @data: memory location to write contents of buffer, or %NULL if we're
  * only querying the data size through the return value.
- * 
+ *
  * Copy the pixel data from a cogl texture to system memory.
  *
  * Returns: the size of the texture data in bytes (or 0 if the texture
@@ -271,7 +271,7 @@ gint            cogl_texture_get_data         (CoglHandle          handle,
  * @handle: a #CoglHandle.
  * @min_filter: the filter used when scaling the texture down.
  * @mag_filter: the filter used when magnifying the texture.
- * 
+ *
  * Changes the decimation and interpolation filters used when the texture is
  * drawn at other scales than 100%.
  */
@@ -297,7 +297,7 @@ void            cogl_texture_set_filters      (CoglHandle          handle,
  * @data: the actual pixel data.
  *
  * Sets the pixels in a rectangular subregion of @handle from an in-memory
- * buffer containing pixel data. 
+ * buffer containing pixel data.
  *
  * Returns: %TRUE if the subregion upload was successful, otherwise %FALSE.
  */
@@ -385,6 +385,29 @@ void            cogl_texture_polygon          (CoglHandle          handle,
                                                CoglTextureVertex  *vertices,
                                                gboolean            use_color);
 
+/**
+ * cogl_texture_multiple_rectangles:
+ * @handle: a @CoglHandle.
+ * @verts: an array of vertices
+ * @n_rects: number of rectangles to draw
+ *
+ * Draws a series of rectangles in the same way that
+ * cogl_texture_rectangle() does. In some situations it can give a
+ * significant performance boost to use this function rather than
+ * calling cogl_texture_rectangle() separately for each rectangle.
+ *
+ * @verts should point to an array of #CoglFixed<!-- -->s with
+ * @n_rects * 8 elements. Each group of 8 values corresponds to the
+ * parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
+ * meaning as in cogl_texture_rectangle().
+ *
+ * Since: 1.0
+ */
+void            cogl_texture_multiple_rectangles
+                                              (CoglHandle          handle,
+                                               const CoglFixed    *verts,
+                                               guint               n_rects);
+
 G_END_DECLS
 
 #endif /* __COGL_TEXTURE_H__ */

clutter/cogl/gl/cogl-context.c

@@ -41,27 +41,29 @@ cogl_create_context ()
 {
   if (_context != NULL)
     return FALSE;
-  
+
   /* Allocate context memory */
   _context = (CoglContext*) g_malloc (sizeof (CoglContext));
-  
+
   /* Init default values */
   _context->feature_flags = 0;
   _context->features_cached = FALSE;
-  
+
   _context->enable_flags = 0;
   _context->color_alpha = 255;
-  
+
   _context->path_nodes = g_array_new (FALSE, FALSE, sizeof (CoglPathNode));
   _context->last_path = 0;
-  
+
   _context->texture_handles = NULL;
-  _context->texture_vertices_size = 0;
+  _context->texture_vertices = g_array_new (FALSE, FALSE,
-  _context->texture_vertices = NULL;
+                                            sizeof (CoglTextureGLVertex));
-  
+  _context->texture_indices = g_array_new (FALSE, FALSE,
+                                           sizeof (GLushort));
+
   _context->fbo_handles = NULL;
   _context->draw_buffer = COGL_WINDOW_BUFFER;
-  
+
   _context->blend_src_factor = CGL_SRC_ALPHA;
   _context->blend_dst_factor = CGL_ONE_MINUS_SRC_ALPHA;
 
@@ -70,7 +72,7 @@ cogl_create_context ()
   _context->program_handles = NULL;
 
   _context->mesh_handles = NULL;
-  
+
   _context->pf_glGenRenderbuffersEXT = NULL;
   _context->pf_glBindRenderbufferEXT = NULL;
   _context->pf_glRenderbufferStorageEXT = NULL;
@@ -82,7 +84,7 @@ cogl_create_context ()
   _context->pf_glDeleteFramebuffersEXT = NULL;
   _context->pf_glBlitFramebufferEXT = NULL;
   _context->pf_glRenderbufferStorageMultisampleEXT = NULL;
-  
+
   _context->pf_glCreateProgramObjectARB = NULL;
   _context->pf_glCreateShaderObjectARB = NULL;
   _context->pf_glShaderSourceARB = NULL;
@@ -115,7 +117,7 @@ cogl_create_context ()
   _context->pf_glUniformMatrix4fvARB = NULL;
 
   _context->pf_glDrawRangeElements = NULL;
-  
+
   /* Init OpenGL state */
   GE( glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) );
   GE( glColorMask (TRUE, TRUE, TRUE, FALSE) );
@@ -124,7 +126,7 @@ cogl_create_context ()
 
   /* Initialise the clip stack */
   _cogl_clip_stack_state_init ();
-  
+
   return TRUE;
 }
 
@@ -147,7 +149,12 @@ cogl_destroy_context ()
     g_array_free (_context->shader_handles, TRUE);
   if (_context->program_handles)
     g_array_free (_context->program_handles, TRUE);
-  
+
+  if (_context->texture_vertices)
+    g_array_free (_context->texture_vertices, TRUE);
+  if (_context->texture_indices)
+    g_array_free (_context->texture_indices, TRUE);
+
   g_free (_context);
 }
 
@@ -157,6 +164,6 @@ _cogl_context_get_default ()
   /* Create if doesn't exist yet */
   if (_context == NULL)
     cogl_create_context ();
-  
+
   return _context;
 }

clutter/cogl/gl/cogl-context.h

@@ -41,7 +41,7 @@ typedef struct
   /* Features cache */
   CoglFeatureFlags  feature_flags;
   gboolean          features_cached;
-  
+
   /* Enable cache */
   gulong            enable_flags;
   guint8            color_alpha;
@@ -49,7 +49,7 @@ typedef struct
   COGLenum          blend_dst_factor;
 
   gboolean          enable_backface_culling;
-  
+
   /* Primitives */
   CoglFixedVec2     path_start;
   CoglFixedVec2     path_pen;
@@ -60,12 +60,18 @@ typedef struct
 
   /* Cache of inverse projection matrix */
   GLfloat           inverse_projection[16];
-  
+
   /* Textures */
   GArray	      *texture_handles;
-  CoglTextureGLVertex *texture_vertices;
+  GArray              *texture_vertices;
-  gulong               texture_vertices_size;
+  GArray              *texture_indices;
-  
+  /* The gl texture number that the above vertices apply to. This to
+     detect when a different slice is encountered so that the vertices
+     can be flushed */
+  GLuint               texture_current;
+  GLenum               texture_target;
+  GLenum               texture_wrap_mode;
+
   /* Framebuffer objects */
   GArray           *fbo_handles;
   CoglBufferTarget  draw_buffer;
@@ -78,10 +84,10 @@ typedef struct
 
   /* Clip stack */
   CoglClipStackState clip;
-  
+
   /* Mesh */
   GArray           *mesh_handles;
-  
+
   /* Relying on glext.h to define these */
   COGL_PFNGLGENRENDERBUFFERSEXTPROC                pf_glGenRenderbuffersEXT;
   COGL_PFNGLDELETERENDERBUFFERSEXTPROC             pf_glDeleteRenderbuffersEXT;
@@ -95,7 +101,7 @@ typedef struct
   COGL_PFNGLDELETEFRAMEBUFFERSEXTPROC              pf_glDeleteFramebuffersEXT;
   COGL_PFNGLBLITFRAMEBUFFEREXTPROC                 pf_glBlitFramebufferEXT;
   COGL_PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC  pf_glRenderbufferStorageMultisampleEXT;
-  
+
   COGL_PFNGLCREATEPROGRAMOBJECTARBPROC             pf_glCreateProgramObjectARB;
   COGL_PFNGLCREATESHADEROBJECTARBPROC              pf_glCreateShaderObjectARB;
   COGL_PFNGLSHADERSOURCEARBPROC                    pf_glShaderSourceARB;
@@ -151,6 +157,6 @@ _cogl_context_get_default ();
 CoglContext *ctxvar = _cogl_context_get_default (); \
 if (ctxvar == NULL) return retval;
 
-#define NO_RETVAL 
+#define NO_RETVAL
 
 #endif /* __COGL_CONTEXT_H */

clutter/cogl/gles/cogl-context.c

@@ -59,9 +59,11 @@ cogl_create_context ()
   _context->last_path = 0;
 
   _context->texture_handles = NULL;
-  _context->texture_vertices_size = 0;
+  _context->texture_vertices = g_array_new (FALSE, FALSE,
-  _context->texture_vertices = NULL;
+                                            sizeof (CoglTextureGLVertex));
-  
+  _context->texture_indices = g_array_new (FALSE, FALSE,
+                                           sizeof (GLushort));
+
   _context->fbo_handles = NULL;
   _context->program_handles = NULL;
   _context->shader_handles = NULL;
@@ -104,8 +106,10 @@ cogl_destroy_context ()
 #endif
 
   if (_context->texture_vertices)
-    g_free (_context->texture_vertices);
+    g_array_free (_context->texture_vertices, TRUE);
-  
+  if (_context->texture_indices)
+    g_array_free (_context->texture_indices, TRUE);
+
   if (_context->texture_handles)
     g_array_free (_context->texture_handles, TRUE);
   if (_context->fbo_handles)

clutter/cogl/gles/cogl-context.h

@@ -65,9 +65,14 @@ typedef struct
 
   /* Textures */
   GArray              *texture_handles;
-  CoglTextureGLVertex *texture_vertices;
+  GArray              *texture_vertices;
-  gulong               texture_vertices_size;
+  GArray              *texture_indices;
-  
+  /* The gl texture number that the above vertices apply to. This to
+     detect when a different slice is encountered so that the vertices
+     can be flushed */
+  GLuint               texture_current;
+  GLenum               texture_target;
+
   /* Framebuffer objects */
   GArray              *fbo_handles;
   CoglBufferTarget     draw_buffer;

clutter/cogl/gles/cogl-texture.c

@@ -2047,6 +2047,94 @@ cogl_texture_get_data (CoglHandle       handle,
   return byte_size;
 }
 
+static void
+_cogl_texture_flush_vertices (void)
+{
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+  if (ctx->texture_vertices->len > 0)
+    {
+      int needed_indices;
+      CoglTextureGLVertex *p
+        = (CoglTextureGLVertex *) ctx->texture_vertices->data;
+
+      /* The indices are always the same sequence regardless of the
+         vertices so we only need to change it if there are more
+         vertices than ever before */
+      needed_indices = ctx->texture_vertices->len / 4 * 6;
+      if (needed_indices > ctx->texture_indices->len)
+        {
+          int old_len = ctx->texture_indices->len;
+          int vert_num = old_len / 6 * 4;
+          int i;
+          GLushort *q;
+
+          /* Add two triangles for each quad to the list of
+             indices. That makes six new indices but two of the
+             vertices in the triangles are shared. */
+          g_array_set_size (ctx->texture_indices, needed_indices);
+          q = &g_array_index (ctx->texture_indices, GLushort, old_len);
+
+          for (i = old_len;
+               i < ctx->texture_indices->len;
+               i += 6, vert_num += 4)
+            {
+              *(q++) = vert_num + 0;
+              *(q++) = vert_num + 1;
+              *(q++) = vert_num + 3;
+
+              *(q++) = vert_num + 1;
+              *(q++) = vert_num + 2;
+              *(q++) = vert_num + 3;
+            }
+        }
+
+      GE( glVertexPointer (2, GL_FLOAT,
+                           sizeof (CoglTextureGLVertex), p->v ) );
+      GE( glTexCoordPointer (2, GL_FLOAT,
+                             sizeof (CoglTextureGLVertex), p->t ) );
+
+      GE( glBindTexture (ctx->texture_target, ctx->texture_current) );
+      GE( glDrawElements (GL_TRIANGLES,
+                          needed_indices,
+                          GL_UNSIGNED_SHORT,
+                          ctx->texture_indices->data) );
+
+      g_array_set_size (ctx->texture_vertices, 0);
+    }
+}
+
+static void
+_cogl_texture_add_quad_vertices (GLfloat x1, GLfloat y1,
+                                 GLfloat x2, GLfloat y2,
+                                 GLfloat tx1, GLfloat ty1,
+                                 GLfloat tx2, GLfloat ty2)
+{
+  CoglTextureGLVertex *p;
+  GLushort first_vert;
+
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+  /* Add the four vertices of the quad to the list of queued
+     vertices */
+  first_vert = ctx->texture_vertices->len;
+  g_array_set_size (ctx->texture_vertices, first_vert + 4);
+  p = &g_array_index (ctx->texture_vertices, CoglTextureGLVertex, first_vert);
+
+  p->v[0] = x1;  p->v[1] = y1;
+  p->t[0] = tx1; p->t[1] = ty1;
+  p++;
+  p->v[0] = x1;  p->v[1] = y2;
+  p->t[0] = tx1; p->t[1] = ty2;
+  p++;
+  p->v[0] = x2;  p->v[1] = y2;
+  p->t[0] = tx2; p->t[1] = ty2;
+  p++;
+  p->v[0] = x2;  p->v[1] = y1;
+  p->t[0] = tx2; p->t[1] = ty1;
+  p++;
+}
+
 static void
 _cogl_texture_quad_sw (CoglTexture *tex,
 		       CoglFixed x1,
@@ -2067,31 +2155,13 @@ _cogl_texture_quad_sw (CoglTexture *tex,
   CoglFixed       slice_tx2 ,  slice_ty2;
   CoglFixed       slice_qx1 ,  slice_qy1;
   CoglFixed       slice_qx2 ,  slice_qy2;
-  GLfloat         tex_coords[8];
-  GLfloat         quad_coords[8];
   GLuint          gl_handle;
-  gulong          enable_flags = (COGL_ENABLE_TEXTURE_2D
+
-                                  | COGL_ENABLE_VERTEX_ARRAY
-                                  | COGL_ENABLE_TEXCOORD_ARRAY);
-  
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
 #if COGL_DEBUG
   printf("=== Drawing Tex Quad (Software Tiling Mode) ===\n");
 #endif
-  
-  
-  /* Prepare GL state */
-  if (ctx->color_alpha < 255
-      || tex->bitmap.format & COGL_A_BIT)
-    {
-      enable_flags |= COGL_ENABLE_BLEND;
-    }
-
-  if (ctx->enable_backface_culling)
-    enable_flags |= COGL_ENABLE_BACKFACE_CULLING;
-
-  cogl_enable (enable_flags);
 
   /* If the texture coordinates are backwards then swap both the
      geometry and texture coordinates so that the texture will be
@@ -2115,10 +2185,7 @@ _cogl_texture_quad_sw (CoglTexture *tex,
       ty1 = ty2;
       ty2 = temp;
     }
-  
+
-  GE( glTexCoordPointer (2, GL_FLOAT, 0, tex_coords) );
-  GE( glVertexPointer   (2, GL_FLOAT, 0, quad_coords) );
-  
   /* Scale ratio from texture to quad widths */
   tw = COGL_FIXED_FROM_INT (tex->bitmap.width);
   th = COGL_FIXED_FROM_INT (tex->bitmap.height);
@@ -2158,17 +2225,16 @@ _cogl_texture_quad_sw (CoglTexture *tex,
       
       slice_qy2 = first_qy +
 	COGL_FIXED_MUL (iter_y.intersect_end - first_ty, tqy);
-      
+
       /* Localize slice texture coordinates */
       slice_ty1 = iter_y.intersect_start - iter_y.pos;
       slice_ty2 = iter_y.intersect_end - iter_y.pos;
-      
+
       /* Normalize texture coordinates to current slice
          (rectangle texture targets take denormalized) */
       slice_ty1 /= iter_y.span->size;
       slice_ty2 /= iter_y.span->size;
-      
+
-      
       /* Iterate until whole quad width covered */
       for (_cogl_span_iter_begin (&iter_x, tex->slice_x_spans,
 				  first_tx, tx1, tx2) ;
@@ -2188,12 +2254,12 @@ _cogl_texture_quad_sw (CoglTexture *tex,
 	  /* Localize slice texture coordinates */
 	  slice_tx1 = iter_x.intersect_start - iter_x.pos;
 	  slice_tx2 = iter_x.intersect_end - iter_x.pos;
-	  
+
 	  /* Normalize texture coordinates to current slice
              (rectangle texture targets take denormalized) */
           slice_tx1 /= iter_x.span->size;
           slice_tx2 /= iter_x.span->size;
-	  
+
 #if COGL_DEBUG
 	  printf("~~~~~ slice (%d,%d)\n", iter_x.index, iter_y.index);
 	  printf("qx1: %f\n", COGL_FIXED_TO_FLOAT (slice_qx1));
@@ -2210,26 +2276,23 @@ _cogl_texture_quad_sw (CoglTexture *tex,
 	  gl_handle = g_array_index (tex->slice_gl_handles, GLuint,
 				     iter_y.index * iter_x.array->len +
 				     iter_x.index);
-	  
-	  GE( cogl_gles2_wrapper_bind_texture (tex->gl_target, gl_handle,
-					       tex->gl_intformat) );
 
-#define CFX_F COGL_FIXED_TO_FLOAT
+          /* If we're using a different texture from the one already queued
-	  
+             then flush the vertices */
-	  /* Draw textured quad */
+          if (ctx->texture_vertices->len > 0
-          tex_coords[0] = CFX_F(slice_tx1); tex_coords[1] = CFX_F(slice_ty2);
+              && gl_handle != ctx->texture_current)
-          tex_coords[2] = CFX_F(slice_tx2); tex_coords[3] = CFX_F(slice_ty2);
+            _cogl_texture_flush_vertices ();
-          tex_coords[4] = CFX_F(slice_tx1); tex_coords[5] = CFX_F(slice_ty1);
+          ctx->texture_target = tex->gl_target;
-          tex_coords[6] = CFX_F(slice_tx2); tex_coords[7] = CFX_F(slice_ty1);
+          ctx->texture_current = gl_handle;
 
-          quad_coords[0] = CFX_F(slice_qx1); quad_coords[1] = CFX_F(slice_qy2);
+          _cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (slice_qx1),
-          quad_coords[2] = CFX_F(slice_qx2); quad_coords[3] = CFX_F(slice_qy2);
+                                           COGL_FIXED_TO_FLOAT (slice_qy1),
-          quad_coords[4] = CFX_F(slice_qx1); quad_coords[5] = CFX_F(slice_qy1);
+                                           COGL_FIXED_TO_FLOAT (slice_qx2),
-          quad_coords[6] = CFX_F(slice_qx2); quad_coords[7] = CFX_F(slice_qy1);
+                                           COGL_FIXED_TO_FLOAT (slice_qy2),
-
+                                           COGL_FIXED_TO_FLOAT (slice_tx1),
-	  GE (glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
+                                           COGL_FIXED_TO_FLOAT (slice_ty1),
-
+                                           COGL_FIXED_TO_FLOAT (slice_tx2),
-#undef CFX_F
+                                           COGL_FIXED_TO_FLOAT (slice_ty2));
 	}
     }
 }
@@ -2245,41 +2308,27 @@ _cogl_texture_quad_hw (CoglTexture *tex,
 		       CoglFixed tx2,
 		       CoglFixed ty2)
 {
-  GLfloat           tex_coords[8];
-  GLfloat           quad_coords[8];
   GLuint            gl_handle;
   CoglTexSliceSpan *x_span;
   CoglTexSliceSpan *y_span;
-  gulong            enable_flags = (COGL_ENABLE_TEXTURE_2D
-                                   | COGL_ENABLE_VERTEX_ARRAY
-                                   | COGL_ENABLE_TEXCOORD_ARRAY);
 
 #if COGL_DEBUG
   printf("=== Drawing Tex Quad (Hardware Tiling Mode) ===\n");
 #endif
-  
-  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-  
-  /* Prepare GL state */
-  if (ctx->color_alpha < 255
-      || tex->bitmap.format & COGL_A_BIT)
-    {
-      enable_flags |= COGL_ENABLE_BLEND;
-    }
-  
-  if (ctx->enable_backface_culling)
-    enable_flags |= COGL_ENABLE_BACKFACE_CULLING;
 
-  cogl_enable (enable_flags);
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-  
+
-  GE( glTexCoordPointer (2, GL_FLOAT, 0, tex_coords) );
-  GE( glVertexPointer   (2, GL_FLOAT, 0, quad_coords) );
-  
   /* Pick and bind opengl texture object */
   gl_handle = g_array_index (tex->slice_gl_handles, GLuint, 0);
-  GE( cogl_gles2_wrapper_bind_texture (tex->gl_target, gl_handle,
+
-				       tex->gl_intformat) );
+  /* If we're using a different texture from the one already queued
-  
+     then flush the vertices */
+  if (ctx->texture_vertices->len > 0
+      && gl_handle != ctx->texture_current)
+    _cogl_texture_flush_vertices ();
+  ctx->texture_target = tex->gl_target;
+  ctx->texture_current = gl_handle;
+
   /* Don't include the waste in the texture coordinates */
   x_span = &g_array_index (tex->slice_x_spans, CoglTexSliceSpan, 0);
   y_span = &g_array_index (tex->slice_y_spans, CoglTexSliceSpan, 0);
@@ -2290,22 +2339,80 @@ _cogl_texture_quad_hw (CoglTexture *tex,
   ty1 = ty1 * (y_span->size - y_span->waste) / y_span->size;
   ty2 = ty2 * (y_span->size - y_span->waste) / y_span->size;
 
-#define CFX_F(x) COGL_FIXED_TO_FLOAT(x)
+  _cogl_texture_add_quad_vertices (COGL_FIXED_TO_FLOAT (x1),
+                                   COGL_FIXED_TO_FLOAT (y1),
+                                   COGL_FIXED_TO_FLOAT (x2),
+                                   COGL_FIXED_TO_FLOAT (y2),
+                                   COGL_FIXED_TO_FLOAT (tx1),
+                                   COGL_FIXED_TO_FLOAT (ty1),
+                                   COGL_FIXED_TO_FLOAT (tx2),
+                                   COGL_FIXED_TO_FLOAT (ty2));
+}
+
+void
+cogl_texture_multiple_rectangles (CoglHandle       handle,
+                                  const CoglFixed *verts,
+                                  guint            n_rects)
+{
+  CoglTexture    *tex;
+  gulong          enable_flags = (COGL_ENABLE_VERTEX_ARRAY
+                                  | COGL_ENABLE_TEXCOORD_ARRAY
+                                  | COGL_ENABLE_TEXTURE_2D);
+
+  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
+
+  /* Check if valid texture */
+  if (!cogl_is_texture (handle))
+    return;
   
-  /* Draw textured quad */
+  cogl_clip_ensure ();
-  tex_coords[0] = CFX_F(tx1); tex_coords[1] = CFX_F(ty2);
-  tex_coords[2] = CFX_F(tx2); tex_coords[3] = CFX_F(ty2);
-  tex_coords[4] = CFX_F(tx1); tex_coords[5] = CFX_F(ty1);
-  tex_coords[6] = CFX_F(tx2); tex_coords[7] = CFX_F(ty1);
 
-  quad_coords[0] = CFX_F(x1); quad_coords[1] = CFX_F(y2);
+  tex = _cogl_texture_pointer_from_handle (handle);
-  quad_coords[2] = CFX_F(x2); quad_coords[3] = CFX_F(y2);
+  
-  quad_coords[4] = CFX_F(x1); quad_coords[5] = CFX_F(y1);
+  /* Make sure we got stuff to draw */
-  quad_coords[6] = CFX_F(x2); quad_coords[7] = CFX_F(y1);
+  if (tex->slice_gl_handles == NULL)
+    return;
+  
+  if (tex->slice_gl_handles->len == 0)
+    return;
 
-  GE (glDrawArrays (GL_TRIANGLE_STRIP, 0, 4) );
+  /* Prepare GL state */
+  if (ctx->color_alpha < 255
+      || tex->bitmap.format & COGL_A_BIT)
+    enable_flags |= COGL_ENABLE_BLEND;
 
-#undef CFX_F
+  if (ctx->enable_backface_culling)
+    enable_flags |= COGL_ENABLE_BACKFACE_CULLING;
+
+  cogl_enable (enable_flags);
+
+  g_array_set_size (ctx->texture_vertices, 0);
+
+  while (n_rects-- > 0)
+    {
+      if (verts[4] != verts[6] && verts[5] != verts[7])
+        {
+          /* If there is only one GL texture and either the texture is
+             NPOT (no waste) or all of the coordinates are in the
+             range [0,1] then we can use hardware tiling */
+          if (tex->slice_gl_handles->len == 1
+              && ((cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
+                   && tex->gl_target == GL_TEXTURE_2D)
+                  || (verts[4] >= 0 && verts[4] <= COGL_FIXED_1
+                      && verts[6] >= 0 && verts[6] <= COGL_FIXED_1
+                      && verts[5] >= 0 && verts[5] <= COGL_FIXED_1
+                      && verts[7] >= 0 && verts[7] <= COGL_FIXED_1)))
+            _cogl_texture_quad_hw (tex, verts[0],verts[1], verts[2],verts[3],
+                                   verts[4],verts[5], verts[6],verts[7]);
+          else
+            _cogl_texture_quad_sw (tex, verts[0],verts[1], verts[2],verts[3],
+                                   verts[4],verts[5], verts[6],verts[7]);
+        }
+
+      verts += 8;
+    }
+
+  _cogl_texture_flush_vertices ();
 }
 
 void
@@ -2319,47 +2426,18 @@ cogl_texture_rectangle (CoglHandle   handle,
 			CoglFixed tx2,
 			CoglFixed ty2)
 {
-  CoglTexture       *tex;
+  CoglFixed verts[8];
-  
-  /* Check if valid texture */
-  if (!cogl_is_texture (handle))
-    return;
 
-  cogl_clip_ensure ();
+  verts[0] = x1;
-  
+  verts[1] = y1;
-  tex = _cogl_texture_pointer_from_handle (handle);
+  verts[2] = x2;
-  
+  verts[3] = y2;
-  /* Make sure we got stuff to draw */
+  verts[4] = tx1;
-  if (tex->slice_gl_handles == NULL)
+  verts[5] = ty1;
-    return;
+  verts[6] = tx2;
-  
+  verts[7] = ty2;
-  if (tex->slice_gl_handles->len == 0)
+
-    return;
+  cogl_texture_multiple_rectangles (handle, verts, 1);
-  
-  if (tx1 == tx2 || ty1 == ty2)
-    return;
-  
-  /* Pick tiling mode according to hw support */
-  if (cogl_features_available (COGL_FEATURE_TEXTURE_NPOT)
-      && tex->slice_gl_handles->len == 1)
-    {
-      _cogl_texture_quad_hw (tex, x1,y1, x2,y2, tx1,ty1, tx2,ty2);
-    }
-  else
-    {
-      if (tex->slice_gl_handles->len == 1
-          && tx1 >= -COGL_FIXED_1
-          && tx2 <= COGL_FIXED_1
-          && ty1 >= -COGL_FIXED_1
-          && ty2 <= COGL_FIXED_1)
-	{
-	  _cogl_texture_quad_hw (tex, x1,y1, x2,y2, tx1,ty1, tx2,ty2);
-	}
-      else
-	{
-	  _cogl_texture_quad_sw (tex, x1,y1, x2,y2, tx1,ty1, tx2,ty2);
-	}
-    }
 }
 
 void
@@ -2405,23 +2483,9 @@ cogl_texture_polygon (CoglHandle         handle,
   /* Make sure there is enough space in the global texture vertex
      array. This is used so we can render the polygon with a single
      call to OpenGL but still support any number of vertices */
-  if (ctx->texture_vertices_size < n_vertices)
+  g_array_set_size (ctx->texture_vertices, n_vertices);
-    {
+  p = (CoglTextureGLVertex *) ctx->texture_vertices->data;
-      guint nsize = ctx->texture_vertices_size;
-      
-      if (nsize == 0)
-	nsize = 1;
-      do
-	nsize *= 2;
-      while (nsize < n_vertices);
-      
-      ctx->texture_vertices_size = nsize;
 
-      ctx->texture_vertices = g_realloc (ctx->texture_vertices,
-					 nsize
-					 * sizeof (CoglTextureGLVertex));
-    }
-  
   /* Prepare GL state */
   enable_flags = (COGL_ENABLE_TEXTURE_2D
 		  | COGL_ENABLE_VERTEX_ARRAY
@@ -2447,14 +2511,12 @@ cogl_texture_polygon (CoglHandle         handle,
   if (use_color)
     {
       enable_flags |= COGL_ENABLE_COLOR_ARRAY;
-      GE( glColorPointer (4, GL_UNSIGNED_BYTE, sizeof (CoglTextureGLVertex),
+      GE( glColorPointer (4, GL_UNSIGNED_BYTE,
-			  ctx->texture_vertices[0].c) );
+                          sizeof (CoglTextureGLVertex), p->c) );
-    }
+     }
 
-  GE( glVertexPointer (3, GL_FLOAT, sizeof (CoglTextureGLVertex),
+  GE( glVertexPointer (3, GL_FLOAT, sizeof (CoglTextureGLVertex), p->v ) );
-		       ctx->texture_vertices[0].v) );
+  GE( glTexCoordPointer (2, GL_FLOAT, sizeof (CoglTextureGLVertex), p->t ) );
-  GE( glTexCoordPointer (2, GL_FLOAT, sizeof (CoglTextureGLVertex),
-			 ctx->texture_vertices[0].t) );
 
   cogl_enable (enable_flags);
   
@@ -2464,7 +2526,7 @@ cogl_texture_polygon (CoglHandle         handle,
 
   /* Convert the vertices into an array of GLfloats ready to pass to
      OpenGL */
-  for (i = 0, p = ctx->texture_vertices; i < n_vertices; i++, p++)
+  for (i = 0; i < n_vertices; i++, p++)
     {
 #define CFX_F COGL_FIXED_TO_FLOAT
 

clutter/glx/clutter-backend-glx.c

@@ -29,6 +29,8 @@
 #include <unistd.h>
 #endif
 
+#include <glib/gi18n-lib.h>
+
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
@@ -150,7 +152,7 @@ static const GOptionEntry entries[] =
   { "vblank", 0, 
     0, 
     G_OPTION_ARG_STRING, &clutter_vblank_name,
-    "VBlank method to be used (none, dri or glx)", "METHOD" 
+    N_("VBlank method to be used (none, dri or glx)"), "METHOD"
   },
   { NULL }
 };

clutter/pango/cogl-pango-render.c

@@ -51,6 +51,10 @@ struct _CoglPangoRenderer
   CoglPangoGlyphCache *mipmapped_glyph_cache;
 
   gboolean use_mipmapping;
+
+  /* Array of rectangles to draw from the current texture */
+  GArray *glyph_rectangles;
+  CoglHandle glyph_texture;
 };
 
 struct _CoglPangoRendererClass
@@ -58,6 +62,46 @@ struct _CoglPangoRendererClass
   PangoRendererClass class_instance;
 };
 
+static void
+cogl_pango_renderer_glyphs_end (CoglPangoRenderer *priv)
+{
+  if (priv->glyph_rectangles->len > 0)
+    {
+      CoglFixed *rectangles = (CoglFixed *) priv->glyph_rectangles->data;
+      cogl_texture_multiple_rectangles (priv->glyph_texture, rectangles,
+                                        priv->glyph_rectangles->len / 8);
+      g_array_set_size (priv->glyph_rectangles, 0);
+    }
+}
+
+static void
+cogl_pango_renderer_draw_glyph (CoglPangoRenderer        *priv,
+                                CoglPangoGlyphCacheValue *cache_value,
+                                CoglFixed                 x1,
+                                CoglFixed                 y1)
+{
+  CoglFixed x2, y2;
+  CoglFixed *p;
+
+  if (priv->glyph_rectangles->len > 0
+      && priv->glyph_texture != cache_value->texture)
+    cogl_pango_renderer_glyphs_end (priv);
+
+  priv->glyph_texture = cache_value->texture;
+
+  x2 = x1 + CLUTTER_INT_TO_FIXED (cache_value->draw_width);
+  y2 = y1 + CLUTTER_INT_TO_FIXED (cache_value->draw_height);
+
+  g_array_set_size (priv->glyph_rectangles, priv->glyph_rectangles->len + 8);
+  p = &g_array_index (priv->glyph_rectangles, CoglFixed,
+                      priv->glyph_rectangles->len - 8);
+
+  *(p++) = x1;               *(p++) = y1;
+  *(p++) = x2;               *(p++) = y2;
+  *(p++) = cache_value->tx1; *(p++) = cache_value->ty1;
+  *(p++) = cache_value->tx2; *(p++) = cache_value->ty2;
+}
+
 #define COGL_PANGO_UNIT_TO_FIXED(x) ((x) << (COGL_FIXED_Q - 10))
 
 static void cogl_pango_renderer_finalize (GObject *object);
@@ -89,6 +133,7 @@ cogl_pango_renderer_init (CoglPangoRenderer *priv)
   priv->glyph_cache = cogl_pango_glyph_cache_new (FALSE);
   priv->mipmapped_glyph_cache = cogl_pango_glyph_cache_new (TRUE);
   priv->use_mipmapping = FALSE;
+  priv->glyph_rectangles = g_array_new (FALSE, FALSE, sizeof (CoglFixed));
 }
 
 static void
@@ -111,6 +156,7 @@ cogl_pango_renderer_finalize (GObject *object)
 
   cogl_pango_glyph_cache_free (priv->mipmapped_glyph_cache);
   cogl_pango_glyph_cache_free (priv->glyph_cache);
+  g_array_free (priv->glyph_rectangles, TRUE);
 
   G_OBJECT_CLASS (cogl_pango_renderer_parent_class)->finalize (object);
 }
@@ -376,10 +422,10 @@ cogl_pango_renderer_draw_box (int x,     int y,
 
 static void
 cogl_pango_renderer_get_device_units (PangoRenderer *renderer,
-					 int            xin,
+                                      int            xin,
-					 int            yin,
+                                      int            yin,
-					 CoglFixed     *xout,
+                                      CoglFixed     *xout,
-					 CoglFixed     *yout)
+                                      CoglFixed     *yout)
 {
   const PangoMatrix *matrix;
 
@@ -454,6 +500,7 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer    *renderer,
 				 int               xi,
 				 int               yi)
 {
+  CoglPangoRenderer *priv = (CoglPangoRenderer *) renderer;
   CoglPangoGlyphCacheValue *cache_value;
   int i;
 
@@ -474,6 +521,8 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer    *renderer,
 	{
 	  PangoFontMetrics *metrics;
 
+          cogl_pango_renderer_glyphs_end (priv);
+
 	  if (font == NULL ||
               (metrics = pango_font_get_metrics (font, NULL)) == NULL)
             {
@@ -503,10 +552,14 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer    *renderer,
                                                   gi->glyph);
 
 	  if (cache_value == NULL)
-	    cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x),
+            {
-					  COGL_FIXED_TO_INT (y),
+              cogl_pango_renderer_glyphs_end (priv);
-					  PANGO_UNKNOWN_GLYPH_WIDTH,
+
-					  PANGO_UNKNOWN_GLYPH_HEIGHT);
+              cogl_pango_renderer_draw_box (COGL_FIXED_TO_INT (x),
+                                            COGL_FIXED_TO_INT (y),
+                                            PANGO_UNKNOWN_GLYPH_WIDTH,
+                                            PANGO_UNKNOWN_GLYPH_HEIGHT);
+            }
 	  else
 	    {
               CoglFixed width, height;
@@ -517,15 +570,12 @@ cogl_pango_renderer_draw_glyphs (PangoRenderer    *renderer,
               width = x + COGL_FIXED_FROM_INT (cache_value->draw_width);
               height = y + COGL_FIXED_FROM_INT (cache_value->draw_height);
 
-	      /* Render the glyph from the texture */
+              cogl_pango_renderer_draw_glyph (priv, cache_value, x, y);
-	      cogl_texture_rectangle (cache_value->texture,
-                                      x, y,
-                                      width, height,
-				      cache_value->tx1, cache_value->ty1,
-				      cache_value->tx2, cache_value->ty2);
 	    }
 	}
 
       xi += gi->geometry.width;
     }
+
+  cogl_pango_renderer_glyphs_end (priv);
 }

clutter/x11/clutter-backend-x11.c

@@ -23,6 +23,8 @@
 #include "config.h"
 #endif
 
+#include <glib/gi18n-lib.h>
+
 #include <string.h>
 #include <sys/types.h>
 #ifdef HAVE_UNISTD_H
@@ -235,18 +237,18 @@ static const GOptionEntry entries[] =
     "display", 0,
     G_OPTION_FLAG_IN_MAIN,
     G_OPTION_ARG_STRING, &clutter_display_name,
-    "X display to use", "DISPLAY"
+    N_("X display to use"), "DISPLAY"
   },
   {
     "screen", 0,
     G_OPTION_FLAG_IN_MAIN,
     G_OPTION_ARG_INT, &clutter_screen,
-    "X screen to use", "SCREEN"
+    N_("X screen to use"), "SCREEN"
   },
   { "synch", 0,
     0,
     G_OPTION_ARG_NONE, &clutter_synchronise,
-    "Make X calls synchronous", NULL,
+    N_("Make X calls synchronous"), NULL,
   },
   { NULL }
 };

configure.ac

@@ -580,7 +580,7 @@ AC_ARG_ENABLE([maintainer-flags],
               enable_maintainer_flags=maintainer_flags_default)
 
 if test "x$enable_maintainer_flags" = "xyes"; then
-  CPPFLAGS="$CPPFLAGS -Werror -Wall -Wshadow -Wcast-align -Wno-uninitialized"
+  CPPFLAGS="$CPPFLAGS -Werror -Wall -Wshadow -Wcast-align -Wno-uninitialized -Wempty-body -Wformat-security -Winit-self"
 fi
 
 
@@ -637,6 +637,7 @@ AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, "$GETTEXT_PACKAGE",
 
 ALL_LINGUAS=""
 AM_GLIB_GNU_GETTEXT
+GLIB_DEFINE_LOCALEDIR(LOCALEDIR)
 
 AC_CONFIG_FILES([
         Makefile

doc/reference/clutter/Makefile.am

@@ -55,6 +55,7 @@ CFILE_GLOB=$(top_srcdir)/clutter/*.c
 # e.g. IGNORE_HFILES=gtkdebug.h gtkintl.h
 IGNORE_HFILES=\
 	clutter.h \
+        clutter-bezier.h \
 	clutter-debug.h \
 	clutter-deprecated.h \
 	clutter-enum-types.h \

doc/reference/clutter/clutter-docs.xml

@@ -58,8 +58,7 @@
       <xi:include href="xml/clutter-texture.xml"/>
       <xi:include href="xml/clutter-clone-texture.xml"/>
       <xi:include href="xml/clutter-cairo-texture.xml"/>
-      <xi:include href="xml/clutter-label.xml"/>
+      <xi:include href="xml/clutter-text.xml"/>
-      <xi:include href="xml/clutter-entry.xml"/>
     </chapter>
 
     <chapter>

doc/reference/clutter/clutter-sections.txt

@@ -66,48 +66,6 @@ clutter_unit_get_type
 clutter_param_unit_get_type
 </SECTION>
 
-<SECTION>
-<FILE>clutter-label</FILE>
-<TITLE>ClutterLabel</TITLE>
-ClutterLabel
-ClutterLabelClass
-clutter_label_new
-clutter_label_new_with_text
-clutter_label_new_full
-clutter_label_set_text
-clutter_label_get_text
-clutter_label_set_font_name
-clutter_label_get_font_name
-clutter_label_set_color
-clutter_label_get_color
-clutter_label_set_ellipsize
-clutter_label_get_ellipsize
-clutter_label_set_line_wrap
-clutter_label_get_line_wrap
-clutter_label_set_line_wrap_mode
-clutter_label_get_line_wrap_mode
-clutter_label_get_layout
-clutter_label_set_attributes
-clutter_label_get_attributes
-clutter_label_set_use_markup
-clutter_label_get_use_markup
-clutter_label_set_alignment
-clutter_label_get_alignment
-clutter_label_get_justify
-clutter_label_set_justify
-
-<SUBSECTION Standard>
-CLUTTER_LABEL
-CLUTTER_IS_LABEL
-CLUTTER_TYPE_LABEL
-CLUTTER_LABEL_CLASS
-CLUTTER_IS_LABEL_CLASS
-CLUTTER_LABEL_GET_CLASS
-<SUBSECTION Private>
-ClutterLabelPrivate
-clutter_label_get_type
-</SECTION>
-
 <SECTION>
 <FILE>clutter-behaviour</FILE>
 <TITLE>ClutterBehaviour</TITLE>
@@ -476,6 +434,11 @@ clutter_actor_get_scalex
 clutter_actor_set_rotationx
 clutter_actor_get_rotationx
 
+<SUBSECTION>
+clutter_actor_grab_key_focus
+clutter_actor_get_pango_context
+clutter_actor_create_pango_context
+
 <SUBSECTION Standard>
 CLUTTER_TYPE_GEOMETRY
 CLUTTER_TYPE_ACTOR_BOX
@@ -698,6 +661,8 @@ ClutterPathCallback
 ClutterPathNodeType
 clutter_path_new
 clutter_path_new_with_description
+
+<SUBSECTION>
 clutter_path_add_move_to
 clutter_path_add_rel_move_to
 clutter_path_add_line_to
@@ -708,6 +673,8 @@ clutter_path_add_close
 clutter_path_add_string
 clutter_path_add_node
 clutter_path_add_cairo_path
+
+<SUBSECTION>
 clutter_path_get_n_nodes
 clutter_path_get_node
 clutter_path_get_nodes
@@ -736,11 +703,9 @@ CLUTTER_PATH_CLASS
 CLUTTER_IS_PATH
 CLUTTER_IS_PATH_CLASS
 CLUTTER_PATH_GET_CLASS
-CLUTTER_BEZIER_MAX_LENGTH
 CLUTTER_PATH_RELATIVE
 
 <SUBSECTION Private>
-ClutterBezier
 ClutterPathPrivate
 clutter_path_get_type
 clutter_path_node_get_type
@@ -869,14 +834,16 @@ clutter_behaviour_ellipse_get_type
 <FILE>clutter-backend</FILE>
 <TITLE>ClutterBackend</TITLE>
 clutter_get_default_backend
-clutter_backend_get_resolution
 clutter_backend_set_resolution
-clutter_backend_get_double_click_time
+clutter_backend_get_resolution
 clutter_backend_set_double_click_time
-clutter_backend_get_double_click_distance
+clutter_backend_get_double_click_time
 clutter_backend_set_double_click_distance
+clutter_backend_get_double_click_distance
 clutter_backend_set_font_options
 clutter_backend_get_font_options
+clutter_backend_set_font_name
+clutter_backend_get_font_name
 <SUBSECTION Standard>
 CLUTTER_BACKEND
 CLUTTER_IS_BACKEND
@@ -1219,50 +1186,6 @@ CLUTTER_COGL
 CLUTTER_NO_FPU
 </SECTION>
 
-<SECTION>
-<FILE>clutter-entry</FILE>
-<TITLE>ClutterEntry</TITLE>
-ClutterEntry
-ClutterEntryClass
-clutter_entry_new
-clutter_entry_new_with_text
-clutter_entry_new_full
-clutter_entry_set_text
-clutter_entry_get_text
-clutter_entry_set_font_name
-clutter_entry_get_font_name
-clutter_entry_set_color
-clutter_entry_get_color
-clutter_entry_get_layout
-clutter_entry_set_alignment
-clutter_entry_get_alignment
-clutter_entry_set_cursor_position
-clutter_entry_get_cursor_position
-clutter_entry_handle_key_event
-clutter_entry_insert_unichar
-clutter_entry_delete_chars
-clutter_entry_insert_text
-clutter_entry_delete_text
-clutter_entry_set_visible_cursor
-clutter_entry_get_visible_cursor
-clutter_entry_set_visibility
-clutter_entry_get_visibility
-clutter_entry_set_invisible_char
-clutter_entry_get_invisible_char
-clutter_entry_set_max_length
-clutter_entry_get_max_length
-<SUBSECTION Standard>
-CLUTTER_ENTRY
-CLUTTER_IS_ENTRY
-CLUTTER_TYPE_ENTRY
-CLUTTER_ENTRY_CLASS
-CLUTTER_IS_ENTRY_CLASS
-CLUTTER_ENTRY_GET_CLASS
-<SUBSECTION Private>
-ClutterEntryPrivate
-clutter_entry_get_type
-</SECTION>
-
 <SECTION>
 <FILE>clutter-effect</FILE>
 <TITLE>Clutter Effects</TITLE>
@@ -1533,23 +1456,25 @@ clutter_shader_release
 clutter_shader_is_compiled
 clutter_shader_set_is_enabled
 clutter_shader_get_is_enabled
-clutter_shader_set_uniform_1f
+
+<SUBSECTION>
 clutter_shader_set_uniform
 clutter_shader_get_cogl_program
 clutter_shader_get_cogl_fragment_shader
 clutter_shader_get_cogl_vertex_shader
+clutter_shader_set_uniform_1f
 
 <SUBSECTION>
-CLUTTER_VALUE_HOLDS_SHADER_FLOAT
 ClutterShaderFloat
+CLUTTER_VALUE_HOLDS_SHADER_FLOAT
 clutter_value_set_shader_float
 clutter_value_get_shader_float
-CLUTTER_VALUE_HOLDS_SHADER_INT
 ClutterShaderInt
+CLUTTER_VALUE_HOLDS_SHADER_INT
 clutter_value_set_shader_int
 clutter_value_get_shader_int
-CLUTTER_VALUE_HOLDS_SHADER_MATRIX
 ClutterShaderMatrix
+CLUTTER_VALUE_HOLDS_SHADER_MATRIX
 clutter_value_set_shader_matrix
 clutter_value_get_shader_matrix
 
@@ -1572,6 +1497,9 @@ clutter_shader_float_get_type
 clutter_shader_int_get_type
 clutter_shader_matrix_get_type
 clutter_shader_error_quark
+clutter_shader_float_get_type
+clutter_shader_int_get_type
+clutter_shader_matrix_get_type
 </SECTION>
 
 <SECTION>
@@ -1638,8 +1566,8 @@ clutter_interval_set_interval
 clutter_interval_get_interval
 
 <SUBSECTION>
-clutter_interval_validate
 clutter_interval_compute_value
+clutter_interval_validate
 
 <SUBSECTION Standard>
 CLUTTER_TYPE_INTERVAL
@@ -1668,7 +1596,8 @@ clutter_binding_pool_find
 <SUBSECTION>
 clutter_binding_pool_install_action
 clutter_binding_pool_install_closure
-clutter_binding_pool_list_actions
+clutter_binding_pool_override_action
+clutter_binding_pool_override_closure
 clutter_binding_pool_find_action
 clutter_binding_pool_remove_action
 clutter_binding_pool_block_action
@@ -1679,8 +1608,8 @@ clutter_binding_pool_activate
 </SECTION>
 
 <SECTION>
-<TITLE>ClutterCairoTexture</TITLE>
 <FILE>clutter-cairo-texture</FILE>
+<TITLE>ClutterCairoTexture</TITLE>
 ClutterCairoTexture
 ClutterCairoTextureClass
 clutter_cairo_texture_new
@@ -1705,4 +1634,82 @@ CLUTTER_CAIRO_TEXTURE_GET_CLASS
 <SUBSECTION Private>
 ClutterCairoTexturePrivate
 clutter_cairo_texture_get_type
+
+<SECTION>
+<TITLE>ClutterText</TITLE>
+<FILE>clutter-text</FILE>
+ClutterText
+ClutterTextClass
+clutter_text_new
+clutter_text_new_full
+clutter_text_new_with_text
+
+<SUBSECTION>
+clutter_text_set_text
+clutter_text_get_text
+clutter_text_set_activatable
+clutter_text_get_activatable
+clutter_text_set_alignment
+clutter_text_get_alignment
+clutter_text_set_attributes
+clutter_text_get_attributes
+clutter_text_set_color
+clutter_text_get_color
+clutter_text_set_ellipsize
+clutter_text_get_ellipsize
+clutter_text_set_font_name
+clutter_text_get_font_name
+clutter_text_set_password_char
+clutter_text_get_password_char
+clutter_text_set_justify
+clutter_text_get_justify
+clutter_text_get_layout
+clutter_text_set_line_wrap
+clutter_text_get_line_wrap
+clutter_text_set_line_wrap_mode
+clutter_text_get_line_wrap_mode
+clutter_text_set_max_length
+clutter_text_get_max_length
+clutter_text_set_selectable
+clutter_text_get_selectable
+clutter_text_set_selection
+clutter_text_get_selection
+clutter_text_set_selection_bound
+clutter_text_get_selection_bound
+clutter_text_set_single_line_mode
+clutter_text_get_single_line_mode
+clutter_text_set_use_markup
+clutter_text_get_use_markup
+
+<SUBSECTION>
+clutter_text_set_editable
+clutter_text_get_editable
+clutter_text_insert_text
+clutter_text_insert_unichar
+clutter_text_delete_chars
+clutter_text_delete_text
+clutter_text_get_chars
+clutter_text_set_cursor_color
+clutter_text_get_cursor_color
+clutter_text_set_cursor_position
+clutter_text_get_cursor_position
+clutter_text_set_cursor_visible
+clutter_text_get_cursor_visible
+clutter_text_set_cursor_size
+clutter_text_get_cursor_size
+
+<SUBSECTION>
+clutter_text_activate
+
+<SUBSECTION Standard>
+CLUTTER_IS_TEXT
+CLUTTER_IS_TEXT_CLASS
+CLUTTER_TEXT
+CLUTTER_TEXT_CLASS
+CLUTTER_TEXT_GET_CLASS
+CLUTTER_TYPE_TEXT
+
+<SUBSECTION Private>
+ClutterTextPrivate
+clutter_text_get_type
 </SECTION>

doc/reference/clutter/clutter.types

@@ -6,7 +6,6 @@ clutter_stage_get_type
 clutter_rectangle_get_type
 clutter_texture_get_type
 clutter_clone_texture_get_type
-clutter_label_get_type
 clutter_timeline_get_type
 clutter_media_get_type
 clutter_behaviour_get_type
@@ -19,7 +18,6 @@ clutter_path_get_type
 clutter_behaviour_rotate_get_type
 clutter_behaviour_scale_get_type
 clutter_backend_get_type
-clutter_entry_get_type
 clutter_script_get_type
 clutter_scriptable_get_type
 clutter_model_get_type
@@ -29,3 +27,4 @@ clutter_score_get_type
 clutter_shader_get_type
 clutter_child_meta_get_type
 clutter_cairo_texture_get_type
+clutter_text_get_type

doc/reference/cogl/cogl-sections.txt

@@ -120,6 +120,7 @@ cogl_texture_set_region
 cogl_texture_ref
 cogl_texture_unref
 cogl_texture_rectangle
+cogl_texture_multiple_rectangles
 cogl_texture_polygon
 </SECTION>
 

po/POTFILES.in

@@ -0,0 +1,14 @@
+clutter/clutter-actor.c
+clutter/clutter-behaviour.c
+clutter/clutter-color.c
+clutter/clutter-container.c
+clutter/clutter-event.c
+clutter/clutter-fixed.c
+clutter/clutter-fixed.h
+clutter/clutter-main.c
+clutter/clutter-stage-window.c
+clutter/clutter-stage.c
+clutter/clutter-texture.c
+clutter/clutter-units.c
+clutter/glx/clutter-backend-glx.c
+clutter/x11/clutter-backend-x11.c

tests/conform/Makefile.am

@@ -17,15 +17,15 @@ test_conformance_SOURCES = 		\
 	test-mesh-mutability.c 		\
 	test-path.c 			\
 	test-pick.c 			\
-	test-label-cache.c 		\
-	test-clutter-entry.c 		\
 	test-clutter-rectangle.c 	\
 	test-clutter-fixed.c 		\
 	test-actor-invariants.c 	\
 	test-paint-opacity.c 		\
 	test-backface-culling.c 	\
 	test-binding-pool.c		\
-	$(NULL)
+        test-clutter-text.c             \
+        test-text-cache.c               \
+        $(NULL)
 
 # For convenience, this provides a way to easily run individual unit tests:
 .PHONY: wrappers clean-wrappers

tests/conform/test-binding-pool.c

@@ -260,9 +260,9 @@ on_activate (KeyGroup     *key_group,
              ClutterActor *child,
              gpointer      data)
 {
-  gint index = GPOINTER_TO_INT (data);
+  gint _index = GPOINTER_TO_INT (data);
 
-  g_assert_cmpint (key_group->selected_index, ==, index);
+  g_assert_cmpint (key_group->selected_index, ==, _index);
 }
 
 void

tests/conform/test-clutter-entry.c

@@ -1,370 +0,0 @@
-#include <glib.h>
-#include <clutter/clutter.h>
-#include <string.h>
-
-#include "test-conform-common.h"
-
-typedef struct {
-  gunichar   unichar;
-  const char bytes[6];
-  gint       nbytes;
-} TestData;
-
-const TestData
-test_data[] = {
-  { 0xe4,   "\xc3\xa4",     2 }, /* LATIN SMALL LETTER A WITH DIAERESIS */
-  { 0x2665, "\xe2\x99\xa5", 3 }  /* BLACK HEART SUIT */
-};
-
-void
-test_entry_utf8_validation (TestConformSimpleFixture *fixture,
-			    gconstpointer data)
-{
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      gunichar unichar;
-      char bytes[6];
-      int nbytes;
-
-      g_assert (g_unichar_validate (t->unichar));
-
-      nbytes = g_unichar_to_utf8 (t->unichar, bytes);
-      bytes[nbytes] = '\0';
-      g_assert (nbytes == t->nbytes);
-      g_assert (memcmp (t->bytes, bytes, nbytes) == 0);
-
-      unichar = g_utf8_get_char_validated (bytes, nbytes);
-      g_assert (unichar == t->unichar);
-    }
-}
-
-static int
-get_nbytes (ClutterEntry *entry)
-{
-  const char *s = clutter_entry_get_text (entry);
-  return strlen (s);
-}
-
-static int
-get_nchars (ClutterEntry *entry)
-{
-  const char *s = clutter_entry_get_text (entry);
-  g_assert (g_utf8_validate (s, -1, NULL));
-  return g_utf8_strlen (s, -1);
-}
-
-#define DONT_MOVE_CURSOR    (-2)
-
-static void
-insert_unichar (ClutterEntry *entry, gunichar unichar, int position)
-{
-  if (position > DONT_MOVE_CURSOR)
-    {
-      clutter_entry_set_cursor_position (entry, position);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, position);
-    }
-
-  clutter_entry_insert_unichar (entry, unichar);
-}
-
-void
-test_entry_empty (TestConformSimpleFixture *fixture,
-		  gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-
-  g_assert (clutter_entry_get_text (entry) == NULL);
-  g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_set_empty (TestConformSimpleFixture *fixture,
-		      gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-
-  /* annoyingly slightly different from initially empty */
-  clutter_entry_set_text (entry, "");
-  g_assert_cmpint (get_nchars (entry), ==, 0);
-  g_assert_cmpint (get_nbytes (entry), ==, 0);
-  g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_set_text (TestConformSimpleFixture *fixture,
-		     gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-
-  clutter_entry_set_text (entry, "abcdef");
-  g_assert_cmpint (get_nchars (entry), ==, 6);
-  g_assert_cmpint (get_nbytes (entry), ==, 6);
-  g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-
-  clutter_entry_set_cursor_position (entry, 5);
-  g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 5);
-
-  clutter_entry_set_text (entry, "");
-  /* FIXME: cursor position should be -1?
-  g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-  */
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_append_some (TestConformSimpleFixture *fixture,
-		        gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      int j;
-
-      for (j = 1; j <= 4; j++)
-        {
-          insert_unichar (entry, t->unichar, DONT_MOVE_CURSOR);
-          g_assert_cmpint (get_nchars (entry), ==, j);
-          g_assert_cmpint (get_nbytes (entry), ==, j * t->nbytes);
-          g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-        }
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_prepend_some (TestConformSimpleFixture *fixture,
-		         gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      int j;
-
-      clutter_entry_insert_unichar (entry, t->unichar);
-      g_assert_cmpint (get_nchars (entry), ==, 1);
-      g_assert_cmpint (get_nbytes (entry), ==, 1 * t->nbytes);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-
-      for (j = 2; j <= 4; j++)
-        {
-          insert_unichar (entry, t->unichar, 0);
-          g_assert_cmpint (get_nchars (entry), ==, j);
-          g_assert_cmpint (get_nbytes (entry), ==, j * t->nbytes);
-          g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 1);
-        }
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_insert (TestConformSimpleFixture *fixture,
-		   gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-
-      clutter_entry_insert_unichar (entry, t->unichar);
-      clutter_entry_insert_unichar (entry, t->unichar);
-
-      insert_unichar (entry, t->unichar, 1);
-      g_assert_cmpint (get_nchars (entry), ==, 3);
-      g_assert_cmpint (get_nbytes (entry), ==, 3 * t->nbytes);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 2);
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_delete_chars (TestConformSimpleFixture *fixture,
-			 gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      int j;
-
-      for (j = 0; j < 4; j++)
-        clutter_entry_insert_unichar (entry, t->unichar);
-
-      clutter_entry_set_cursor_position (entry, 2);
-      clutter_entry_delete_chars (entry, 1);
-      g_assert_cmpint (get_nchars (entry), ==, 3);
-      g_assert_cmpint (get_nbytes (entry), ==, 3 * t->nbytes);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 1);
-
-      clutter_entry_set_cursor_position (entry, 2);
-      clutter_entry_delete_chars (entry, 1);
-      g_assert_cmpint (get_nchars (entry), ==, 2);
-      g_assert_cmpint (get_nbytes (entry), ==, 2 * t->nbytes);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 1);
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_delete_text (TestConformSimpleFixture *fixture,
-			gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      int j;
-
-      for (j = 0; j < 4; j++)
-        clutter_entry_insert_unichar (entry, t->unichar);
-
-      clutter_entry_set_cursor_position (entry, 3);
-      clutter_entry_delete_text (entry, 2, 4);
-
-      g_assert_cmpint (get_nchars (entry), ==, 2);
-      g_assert_cmpint (get_nbytes (entry), ==, 2 * t->nbytes);
-
-      /* FIXME: cursor position should be -1?
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-      */
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-static void
-init_event (ClutterKeyEvent *event)
-{
-  event->type = CLUTTER_KEY_PRESS;
-  event->time = 0;      /* not needed */
-  event->flags = CLUTTER_EVENT_FLAG_SYNTHETIC;
-  event->stage = NULL;  /* not needed */
-  event->source = NULL; /* not needed */
-  event->modifier_state = 0;
-  event->hardware_keycode = 0; /* not needed */
-}
-
-static void
-send_keyval (ClutterEntry *entry, int keyval)
-{
-  ClutterKeyEvent event;
-
-  init_event (&event);
-  event.keyval = keyval;
-  event.unicode_value = 0; /* should be ignored for cursor keys etc. */
-
-  clutter_entry_handle_key_event (entry, &event);
-}
-
-static inline void
-send_unichar (ClutterEntry *entry, gunichar unichar)
-{
-  ClutterKeyEvent event;
-
-  init_event (&event);
-  event.keyval = 0; /* should be ignored for printable characters */
-  event.unicode_value = unichar;
-
-  clutter_entry_handle_key_event (entry, &event);
-}
-
-void
-test_entry_cursor (TestConformSimpleFixture *fixture,
-		   gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-      int j;
-
-      for (j = 0; j < 4; ++j)
-        clutter_entry_insert_unichar (entry, t->unichar);
-
-      clutter_entry_set_cursor_position (entry, 2);
-
-      /* test cursor moves and is clamped */
-      send_keyval (entry, CLUTTER_Left);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 1);
-
-      send_keyval (entry, CLUTTER_Left);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 0);
-
-      send_keyval (entry, CLUTTER_Left);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 0);
-
-      /* delete text containing the cursor */
-      clutter_entry_set_cursor_position (entry, 3);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, 3);
-
-      clutter_entry_delete_text (entry, 2, 4);
-      send_keyval (entry, CLUTTER_Left);
-
-      /* FIXME: cursor position should be -1?
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-      */
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-
-void
-test_entry_event (TestConformSimpleFixture *fixture,
-		  gconstpointer data)
-{
-  ClutterEntry *entry = CLUTTER_ENTRY (clutter_entry_new ());
-  int i;
-
-  for (i = 0; i < G_N_ELEMENTS (test_data); i++)
-    {
-      const TestData *t = &test_data[i];
-
-      send_unichar (entry, t->unichar);
-
-      g_assert_cmpint (get_nchars (entry), ==, 1);
-      g_assert_cmpint (get_nbytes (entry), ==, 1 * t->nbytes);
-      g_assert_cmpint (clutter_entry_get_cursor_position (entry), ==, -1);
-
-      clutter_entry_set_text (entry, "");
-    }
-
-  clutter_actor_destroy (CLUTTER_ACTOR (entry));
-}
-

tests/conform/test-clutter-text.c

@@ -0,0 +1,431 @@
+#include <glib.h>
+#include <clutter/clutter.h>
+#include <string.h>
+
+#include "test-conform-common.h"
+
+typedef struct {
+  gunichar   unichar;
+  const char bytes[6];
+  gint       nbytes;
+} TestData;
+
+static const TestData
+test_text_data[] = {
+  { 0xe4,   "\xc3\xa4",     2 }, /* LATIN SMALL LETTER A WITH DIAERESIS */
+  { 0x2665, "\xe2\x99\xa5", 3 }  /* BLACK HEART SUIT */
+};
+
+void
+test_text_utf8_validation (TestConformSimpleFixture *fixture,
+			    gconstpointer data)
+{
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      gunichar unichar;
+      char bytes[6];
+      int nbytes;
+
+      g_assert (g_unichar_validate (t->unichar));
+
+      nbytes = g_unichar_to_utf8 (t->unichar, bytes);
+      bytes[nbytes] = '\0';
+      g_assert (nbytes == t->nbytes);
+      g_assert (memcmp (t->bytes, bytes, nbytes) == 0);
+
+      unichar = g_utf8_get_char_validated (bytes, nbytes);
+      g_assert (unichar == t->unichar);
+    }
+}
+
+static int
+get_nbytes (ClutterText *text)
+{
+  const char *s = clutter_text_get_text (text);
+  return strlen (s);
+}
+
+static int
+get_nchars (ClutterText *text)
+{
+  const char *s = clutter_text_get_text (text);
+  g_assert (g_utf8_validate (s, -1, NULL));
+  return g_utf8_strlen (s, -1);
+}
+
+#define DONT_MOVE_CURSOR    (-2)
+
+static void
+insert_unichar (ClutterText *text, gunichar unichar, int position)
+{
+  if (position > DONT_MOVE_CURSOR)
+    {
+      clutter_text_set_cursor_position (text, position);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, position);
+    }
+
+  clutter_text_insert_unichar (text, unichar);
+}
+
+void
+test_text_empty (TestConformSimpleFixture *fixture,
+		  gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+
+  g_assert_cmpstr (clutter_text_get_text (text), ==, "");
+  g_assert_cmpint (*clutter_text_get_text (text), ==, '\0');
+  g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_set_empty (TestConformSimpleFixture *fixture,
+		      gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+
+  /* annoyingly slightly different from initially empty */
+  clutter_text_set_text (text, "");
+  g_assert_cmpint (get_nchars (text), ==, 0);
+  g_assert_cmpint (get_nbytes (text), ==, 0);
+  g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_set_text (TestConformSimpleFixture *fixture,
+		     gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+
+  clutter_text_set_text (text, "abcdef");
+  g_assert_cmpint (get_nchars (text), ==, 6);
+  g_assert_cmpint (get_nbytes (text), ==, 6);
+  g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+
+  clutter_text_set_cursor_position (text, 5);
+  g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 5);
+
+  /* FIXME: cursor position should be -1?
+  clutter_text_set_text (text, "");
+  g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+  */
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_append_some (TestConformSimpleFixture *fixture,
+		        gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      int j;
+
+      for (j = 1; j <= 4; j++)
+        {
+          insert_unichar (text, t->unichar, DONT_MOVE_CURSOR);
+
+          g_assert_cmpint (get_nchars (text), ==, j);
+          g_assert_cmpint (get_nbytes (text), ==, j * t->nbytes);
+          g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+        }
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_prepend_some (TestConformSimpleFixture *fixture,
+		         gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      int j;
+
+      clutter_text_insert_unichar (text, t->unichar);
+
+      g_assert_cmpint (get_nchars (text), ==, 1);
+      g_assert_cmpint (get_nbytes (text), ==, 1 * t->nbytes);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+
+      for (j = 2; j <= 4; j++)
+        {
+          insert_unichar (text, t->unichar, 0);
+
+          g_assert_cmpint (get_nchars (text), ==, j);
+          g_assert_cmpint (get_nbytes (text), ==, j * t->nbytes);
+          g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 1);
+        }
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_insert (TestConformSimpleFixture *fixture,
+		   gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+
+      clutter_text_insert_unichar (text, t->unichar);
+      clutter_text_insert_unichar (text, t->unichar);
+
+      insert_unichar (text, t->unichar, 1);
+
+      g_assert_cmpint (get_nchars (text), ==, 3);
+      g_assert_cmpint (get_nbytes (text), ==, 3 * t->nbytes);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 2);
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_delete_chars (TestConformSimpleFixture *fixture,
+			 gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      int j;
+
+      for (j = 0; j < 4; j++)
+        clutter_text_insert_unichar (text, t->unichar);
+
+      clutter_text_set_cursor_position (text, 2);
+      clutter_text_delete_chars (text, 1);
+      g_assert_cmpint (get_nchars (text), ==, 3);
+      g_assert_cmpint (get_nbytes (text), ==, 3 * t->nbytes);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 1);
+
+      clutter_text_set_cursor_position (text, 2);
+      clutter_text_delete_chars (text, 1);
+      g_assert_cmpint (get_nchars (text), ==, 2);
+      g_assert_cmpint (get_nbytes (text), ==, 2 * t->nbytes);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 1);
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_get_chars (TestConformSimpleFixture *fixture,
+                     gconstpointer             data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  gchar *chars;
+
+  clutter_text_set_text (text, "00abcdef11");
+  g_assert_cmpint (get_nchars (text), ==, 10);
+  g_assert_cmpint (get_nbytes (text), ==, 10);
+  g_assert_cmpstr (clutter_text_get_text (text), ==, "00abcdef11");
+
+  chars = clutter_text_get_chars (text, 2, -1);
+  g_assert_cmpstr (chars, ==, "abcdef11");
+  g_free (chars);
+
+  chars = clutter_text_get_chars (text, 0, 8);
+  g_assert_cmpstr (chars, ==, "00abcdef");
+  g_free (chars);
+
+  chars = clutter_text_get_chars (text, 2, 8);
+  g_assert_cmpstr (chars, ==, "abcdef");
+  g_free (chars);
+
+  chars = clutter_text_get_chars (text, 8, 12);
+  g_assert_cmpstr (chars, ==, "11");
+  g_free (chars);
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_delete_text (TestConformSimpleFixture *fixture,
+			gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      int j;
+
+      for (j = 0; j < 4; j++)
+        clutter_text_insert_unichar (text, t->unichar);
+
+      clutter_text_set_cursor_position (text, 3);
+      clutter_text_delete_text (text, 2, 4);
+
+      g_assert_cmpint (get_nchars (text), ==, 2);
+      g_assert_cmpint (get_nbytes (text), ==, 2 * t->nbytes);
+
+      /* FIXME: cursor position should be -1?
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+      */
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_password_char (TestConformSimpleFixture *fixture,
+                         gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+
+  g_assert_cmpint (clutter_text_get_password_char (text), ==, 0);
+
+  clutter_text_set_text (text, "hello");
+  g_assert_cmpstr (clutter_text_get_text (text), ==, "hello");
+
+  clutter_text_set_password_char (text, '*');
+  g_assert_cmpint (clutter_text_get_password_char (text), ==, '*');
+
+  g_assert_cmpstr (clutter_text_get_text (text), ==, "hello");
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+static void
+init_event (ClutterKeyEvent *event)
+{
+  event->type = CLUTTER_KEY_PRESS;
+  event->time = 0;      /* not needed */
+  event->flags = CLUTTER_EVENT_FLAG_SYNTHETIC;
+  event->stage = NULL;  /* not needed */
+  event->source = NULL; /* not needed */
+  event->modifier_state = 0;
+  event->hardware_keycode = 0; /* not needed */
+}
+
+static void
+send_keyval (ClutterText *text, int keyval)
+{
+  ClutterKeyEvent event;
+
+  init_event (&event);
+  event.keyval = keyval;
+  event.unicode_value = 0; /* should be ignored for cursor keys etc. */
+
+  clutter_actor_event (CLUTTER_ACTOR (text), (ClutterEvent *) &event, FALSE);
+}
+
+static void
+send_unichar (ClutterText *text, gunichar unichar)
+{
+  ClutterKeyEvent event;
+
+  init_event (&event);
+  event.keyval = 0; /* should be ignored for printable characters */
+  event.unicode_value = unichar;
+
+  clutter_actor_event (CLUTTER_ACTOR (text), (ClutterEvent *) &event, FALSE);
+}
+
+void
+test_text_cursor (TestConformSimpleFixture *fixture,
+		   gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  /* only editable entries listen to events */
+  clutter_text_set_editable (text, TRUE);
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+      int j;
+
+      for (j = 0; j < 4; ++j)
+        clutter_text_insert_unichar (text, t->unichar);
+
+      clutter_text_set_cursor_position (text, 2);
+
+      /* test cursor moves and is clamped */
+      send_keyval (text, CLUTTER_Left);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 1);
+
+      send_keyval (text, CLUTTER_Left);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 0);
+
+      send_keyval (text, CLUTTER_Left);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 0);
+
+      /* delete text containing the cursor */
+      clutter_text_set_cursor_position (text, 3);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, 3);
+
+      clutter_text_delete_text (text, 2, 4);
+      send_keyval (text, CLUTTER_Left);
+
+      /* FIXME: cursor position should be -1?
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+      */
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+
+void
+test_text_event (TestConformSimpleFixture *fixture,
+		  gconstpointer data)
+{
+  ClutterText *text = CLUTTER_TEXT (clutter_text_new ());
+  int i;
+
+  /* only editable entries listen to events */
+  clutter_text_set_editable (text, TRUE);
+
+  for (i = 0; i < G_N_ELEMENTS (test_text_data); i++)
+    {
+      const TestData *t = &test_text_data[i];
+
+      send_unichar (text, t->unichar);
+
+      g_assert_cmpint (get_nchars (text), ==, 1);
+      g_assert_cmpint (get_nbytes (text), ==, 1 * t->nbytes);
+      g_assert_cmpint (clutter_text_get_cursor_position (text), ==, -1);
+
+      clutter_text_set_text (text, "");
+    }
+
+  clutter_actor_destroy (CLUTTER_ACTOR (text));
+}
+

tests/conform/test-conform-main.c

@@ -68,22 +68,21 @@ main (int argc, char **argv)
   
   TEST_CONFORM_SIMPLE ("/picking", test_pick);
 
-  TEST_CONFORM_SIMPLE ("/label", test_label_cache);
+  /* ClutterText */
-
+  TEST_CONFORM_SIMPLE ("/text", test_text_utf8_validation);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_utf8_validation);
+  TEST_CONFORM_SIMPLE ("/text", test_text_empty);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_empty);
+  TEST_CONFORM_SIMPLE ("/text", test_text_set_empty);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_set_empty);
+  TEST_CONFORM_SIMPLE ("/text", test_text_set_text);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_set_text);
+  TEST_CONFORM_SIMPLE ("/text", test_text_append_some);
-
+  TEST_CONFORM_SIMPLE ("/text", test_text_prepend_some);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_append_some);
+  TEST_CONFORM_SIMPLE ("/text", test_text_insert);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_prepend_some);
+  TEST_CONFORM_SIMPLE ("/text", test_text_delete_chars);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_insert);
+  TEST_CONFORM_SIMPLE ("/text", test_text_delete_text);
-
+  TEST_CONFORM_SIMPLE ("/text", test_text_cursor);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_delete_chars);
+  TEST_CONFORM_SIMPLE ("/text", test_text_event);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_delete_text);
+  TEST_CONFORM_SIMPLE ("/text", test_text_get_chars);
-
+  TEST_CONFORM_SIMPLE ("/text", test_text_cache);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_cursor);
+  TEST_CONFORM_SIMPLE ("/text", test_text_password_char);
-  TEST_CONFORM_SIMPLE ("/entry", test_entry_event);
 
   TEST_CONFORM_SIMPLE ("/rectangle", test_rect_set_size);
   TEST_CONFORM_SIMPLE ("/rectangle", test_rect_set_color);

tests/conform/test-paint-opacity.c

@@ -14,12 +14,12 @@ test_label_opacity (TestConformSimpleFixture *fixture,
 
   stage = clutter_stage_get_default ();
 
-  label = clutter_label_new_with_text ("Sans 18px", "Label, 50% opacity");
+  label = clutter_text_new_with_text ("Sans 18px", "Label, 50% opacity");
-  clutter_label_set_color (CLUTTER_LABEL (label), &label_color);
+  clutter_text_set_color (CLUTTER_TEXT (label), &label_color);
 
   if (g_test_verbose ())
     g_print ("label 50%%.get_color()/1\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
+  clutter_text_get_color (CLUTTER_TEXT (label), &color_check);
   g_assert (color_check.alpha == label_color.alpha);
 
   clutter_container_add (CLUTTER_CONTAINER (stage), label, NULL);
@@ -27,12 +27,16 @@ test_label_opacity (TestConformSimpleFixture *fixture,
 
   if (g_test_verbose ())
     g_print ("label 50%%.get_color()/2\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
+  clutter_text_get_color (CLUTTER_TEXT (label), &color_check);
   g_assert (color_check.alpha == label_color.alpha);
 
   if (g_test_verbose ())
-    g_print ("label 50%%.get_paint_opacity() = %d\n",
+    g_print ("label 50%%.get_paint_opacity()/1\n");
-             clutter_actor_get_paint_opacity (label));
+  g_assert (clutter_actor_get_paint_opacity (label) == 255);
+
+  if (g_test_verbose ())
+    g_print ("label 50%%.get_paint_opacity()/2\n");
+  clutter_actor_set_opacity (label, 128);
   g_assert (clutter_actor_get_paint_opacity (label) == 128);
 
   clutter_actor_destroy (label);
@@ -66,8 +70,7 @@ test_rectangle_opacity (TestConformSimpleFixture *fixture,
   g_assert (color_check.alpha == rect_color.alpha);
 
   if (g_test_verbose ())
-    g_print ("rect 100%%.get_paint_opacity() = %d\n",
+    g_print ("rect 100%%.get_paint_opacity()\n");
-             clutter_actor_get_paint_opacity (rect));
   g_assert (clutter_actor_get_paint_opacity (rect) == 255);
 
   clutter_actor_destroy (rect);
@@ -91,25 +94,24 @@ test_paint_opacity (TestConformSimpleFixture *fixture,
   clutter_actor_set_position (group1, 10, 30);
   clutter_actor_show (group1);
 
-  label = clutter_label_new_with_text ("Sans 18px", "Label+Group, 25% opacity");
+  label = clutter_text_new_with_text ("Sans 18px", "Label+Group, 25% opacity");
-  clutter_label_set_color (CLUTTER_LABEL (label), &label_color);
+  clutter_text_set_color (CLUTTER_TEXT (label), &label_color);
 
   if (g_test_verbose ())
     g_print ("label 50%% + group 50%%.get_color()/1\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
+  clutter_text_get_color (CLUTTER_TEXT (label), &color_check);
   g_assert (color_check.alpha == label_color.alpha);
 
   clutter_container_add (CLUTTER_CONTAINER (group1), label, NULL);
 
   if (g_test_verbose ())
     g_print ("label 50%% + group 50%%.get_color()/2\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
+  clutter_text_get_color (CLUTTER_TEXT (label), &color_check);
   g_assert (color_check.alpha == label_color.alpha);
 
   if (g_test_verbose ())
-    g_print ("label 50%% + group 50%%.get_paint_opacity() = %d\n",
+    g_print ("label 50%% + group 50%%.get_paint_opacity() = 128\n");
-             clutter_actor_get_paint_opacity (label));
+  g_assert (clutter_actor_get_paint_opacity (label) == 128);
-  g_assert (clutter_actor_get_paint_opacity (label) == 64);
 
   clutter_actor_destroy (label);
 
@@ -133,9 +135,7 @@ test_paint_opacity (TestConformSimpleFixture *fixture,
   g_assert (color_check.alpha == rect_color.alpha);
 
   if (g_test_verbose ())
-    g_print ("rect 100%%.get_paint_opacity() = %d\n",
+    g_print ("rect 100%%.get_paint_opacity()\n");
-             clutter_actor_get_paint_opacity (rect));
-
   g_assert (clutter_actor_get_paint_opacity (rect) == 128);
 
   clutter_actor_destroy (rect);

tests/conform/test-text-cache.c

@@ -34,7 +34,7 @@ on_paint (ClutterActor *label, CallbackData *data)
 
   /* Check whether the layout used for this paint is different from
      the layout used for the last paint */
-  new_layout = clutter_label_get_layout (CLUTTER_LABEL (data->label));
+  new_layout = clutter_text_get_layout (CLUTTER_TEXT (data->label));
   data->layout_changed = data->old_layout != new_layout;
 
   if (data->old_layout)
@@ -71,7 +71,17 @@ check_result (CallbackData *data, const char *note,
   if (memcmp (&test_extents, &data->label_extents, sizeof (PangoRectangle)))
     {
       if (g_test_verbose ())
-        g_print ("extents are different, ");
+        g_print ("extents are different: expected: %d, %d, %d, %d "
+                 "-> text: %d, %d, %d, %d\n",
+                 test_extents.x / 1024,
+                 test_extents.y / 1024,
+                 test_extents.width / 1024,
+                 test_extents.height / 1024,
+                 data->label_extents.x / 1024,
+                 data->label_extents.y / 1024,
+                 data->label_extents.width / 1024,
+                 data->label_extents.height / 1024);
+
       fail = TRUE;
     }
   else
@@ -119,29 +129,29 @@ do_tests (CallbackData *data)
   PangoAttribute *attr;
 
   /* TEST 1: change the text */
-  clutter_label_set_text (CLUTTER_LABEL (data->label), "Counter 0");
+  clutter_text_set_text (CLUTTER_TEXT (data->label), "Counter 0");
   pango_layout_set_text (data->test_layout, "Counter 0", -1);
-  check_result (data, "Change text", TRUE);
+  g_assert (check_result (data, "Change text", TRUE) == FALSE);
 
   /* TEST 2: change a single character */
-  clutter_label_set_text (CLUTTER_LABEL (data->label), "Counter 1");
+  clutter_text_set_text (CLUTTER_TEXT (data->label), "Counter 1");
   pango_layout_set_text (data->test_layout, "Counter 1", -1);
-  check_result (data, "Change a single character", TRUE);
+  g_assert (check_result (data, "Change a single character", TRUE) == FALSE);
 
   /* TEST 3: move the label */
   clutter_actor_set_position (data->label, 10, 0);
-  check_result (data, "Move the label", FALSE);
+  g_assert (check_result (data, "Move the label", FALSE) == FALSE);
 
   /* TEST 4: change the font */
-  clutter_label_set_font_name (CLUTTER_LABEL (data->label), "Serif 15");
+  clutter_text_set_font_name (CLUTTER_TEXT (data->label), "Serif 15");
   fd = pango_font_description_from_string ("Serif 15");
   pango_layout_set_font_description (data->test_layout, fd);
   pango_font_description_free (fd);
-  check_result (data, "Change the font", TRUE);
+  g_assert (check_result (data, "Change the font", TRUE) == FALSE);
 
   /* TEST 5: change the color */
-  clutter_label_set_color (CLUTTER_LABEL (data->label), &red);
+  clutter_text_set_color (CLUTTER_TEXT (data->label), &red);
-  check_result (data, "Change the color", FALSE);
+  g_assert (check_result (data, "Change the color", FALSE) == FALSE);
 
   /* TEST 6: change the attributes */
   attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
@@ -150,23 +160,23 @@ do_tests (CallbackData *data)
   attr_list = pango_attr_list_new ();
   pango_attr_list_insert (attr_list, attr);
   attr_list_copy = pango_attr_list_copy (attr_list);
-  clutter_label_set_attributes (CLUTTER_LABEL (data->label), attr_list);
+  clutter_text_set_attributes (CLUTTER_TEXT (data->label), attr_list);
   pango_layout_set_attributes (data->test_layout, attr_list_copy);
   pango_attr_list_unref (attr_list_copy);
   pango_attr_list_unref (attr_list);
-  check_result (data, "Change the attributes", TRUE);
+  g_assert (check_result (data, "Change the attributes", TRUE) == FALSE);
 
   /* TEST 7: change the text again */
-  clutter_label_set_attributes (CLUTTER_LABEL (data->label), NULL);
+  clutter_text_set_attributes (CLUTTER_TEXT (data->label), NULL);
-  clutter_label_set_text (CLUTTER_LABEL (data->label), long_text);
+  clutter_text_set_text (CLUTTER_TEXT (data->label), long_text);
   pango_layout_set_attributes (data->test_layout, NULL);
   pango_layout_set_text (data->test_layout, long_text, -1);
-  check_result (data, "Change the text again", TRUE);
+  g_assert (check_result (data, "Change the text again", TRUE) == FALSE);
 
   /* TEST 8: enable markup */
-  clutter_label_set_use_markup (CLUTTER_LABEL (data->label), TRUE);
+  clutter_text_set_use_markup (CLUTTER_TEXT (data->label), TRUE);
   pango_layout_set_markup (data->test_layout, long_text, -1);
-  check_result (data, "Enable markup", TRUE);
+  g_assert (check_result (data, "Enable markup", TRUE) == FALSE);
 
   /* This part can't be a test because Clutter won't restrict the
      width if wrapping and ellipsizing is disabled so the extents will
@@ -178,39 +188,39 @@ do_tests (CallbackData *data)
   force_redraw (data);
 
   /* TEST 9: enable ellipsize */
-  clutter_label_set_ellipsize (CLUTTER_LABEL (data->label),
+  clutter_text_set_ellipsize (CLUTTER_TEXT (data->label),
 			       PANGO_ELLIPSIZE_END);
   pango_layout_set_ellipsize (data->test_layout, PANGO_ELLIPSIZE_END);
-  check_result (data, "Enable ellipsize", TRUE);
+  g_assert (check_result (data, "Enable ellipsize", TRUE) == FALSE);
-  clutter_label_set_ellipsize (CLUTTER_LABEL (data->label),
+  clutter_text_set_ellipsize (CLUTTER_TEXT (data->label),
 			       PANGO_ELLIPSIZE_NONE);
   pango_layout_set_ellipsize (data->test_layout, PANGO_ELLIPSIZE_NONE);
   force_redraw (data);
 
   /* TEST 10: enable line wrap */
-  clutter_label_set_line_wrap (CLUTTER_LABEL (data->label), TRUE);
+  clutter_text_set_line_wrap (CLUTTER_TEXT (data->label), TRUE);
   pango_layout_set_wrap (data->test_layout, PANGO_WRAP_WORD);
-  check_result (data, "Enable line wrap", TRUE);
+  g_assert (check_result (data, "Enable line wrap", TRUE) == FALSE);
 
   /* TEST 11: change wrap mode */
-  clutter_label_set_line_wrap_mode (CLUTTER_LABEL (data->label),
+  clutter_text_set_line_wrap_mode (CLUTTER_TEXT (data->label),
 				    PANGO_WRAP_CHAR);
   pango_layout_set_wrap (data->test_layout, PANGO_WRAP_CHAR);
-  check_result (data, "Change wrap mode", TRUE);
+  g_assert (check_result (data, "Change wrap mode", TRUE) == FALSE);
 
   /* TEST 12: enable justify */
-  clutter_label_set_justify (CLUTTER_LABEL (data->label), TRUE);
+  clutter_text_set_justify (CLUTTER_TEXT (data->label), TRUE);
   pango_layout_set_justify (data->test_layout, TRUE);
   /* Pango appears to have a bug which means that you can't change the
      justification after setting the text but this fixes it.
      See http://bugzilla.gnome.org/show_bug.cgi?id=551865 */
   pango_layout_context_changed (data->test_layout);
-  check_result (data, "Enable justify", TRUE);
+  g_assert (check_result (data, "Enable justify", TRUE) == FALSE);
 
   /* TEST 13: change alignment */
-  clutter_label_set_alignment (CLUTTER_LABEL (data->label), PANGO_ALIGN_RIGHT);
+  clutter_text_set_alignment (CLUTTER_TEXT (data->label), PANGO_ALIGN_RIGHT);
   pango_layout_set_alignment (data->test_layout, PANGO_ALIGN_RIGHT);
-  check_result (data, "Change alignment", TRUE);
+  g_assert (check_result (data, "Change alignment", TRUE) == FALSE);
 
   clutter_main_quit ();
 
@@ -218,7 +228,7 @@ do_tests (CallbackData *data)
 }
 
 static PangoLayout *
-make_layout_like_label (ClutterLabel *label)
+make_layout_like_label (ClutterText *label)
 {
   PangoLayout *label_layout, *new_layout;
   PangoContext *context;
@@ -226,7 +236,7 @@ make_layout_like_label (ClutterLabel *label)
 
   /* Make another layout using the same context as the layout from the
      label */
-  label_layout = clutter_label_get_layout (label);
+  label_layout = clutter_text_get_layout (label);
   context = pango_layout_get_context (label_layout);
   new_layout = pango_layout_new (context);
   fd = pango_font_description_from_string (TEST_FONT);
@@ -237,8 +247,8 @@ make_layout_like_label (ClutterLabel *label)
 }
 
 void
-test_label_cache (TestConformSimpleFixture *fixture,
+test_text_cache (TestConformSimpleFixture *fixture,
-		  gconstpointer _data)
+                 gconstpointer _data)
 {
   CallbackData data;
 
@@ -246,9 +256,9 @@ test_label_cache (TestConformSimpleFixture *fixture,
 
   data.stage = clutter_stage_get_default ();
 
-  data.label = clutter_label_new_with_text (TEST_FONT, "");
+  data.label = clutter_text_new_with_text (TEST_FONT, "");
 
-  data.test_layout = make_layout_like_label (CLUTTER_LABEL (data.label));
+  data.test_layout = make_layout_like_label (CLUTTER_TEXT (data.label));
 
   g_signal_connect (data.label, "paint", G_CALLBACK (on_paint), &data);
 

tests/interactive/Makefile.am

@@ -6,7 +6,6 @@ UNIT_TESTS = \
 	test-scale.c \
         test-actors.c \
 	test-behave.c \
-	test-entry.c \
 	test-project.c \
 	test-perspective.c \
 	test-rotate.c \
@@ -22,7 +21,6 @@ UNIT_TESTS = \
 	test-unproject.c \
 	test-viewport.c \
 	test-fbo.c \
-	test-opacity.c \
 	test-multistage.c \
 	test-cogl-primitives.c \
 	test-cogl-tex-tile.c \
@@ -39,7 +37,9 @@ UNIT_TESTS = \
 	test-layout.c \
         test-animation.c \
         test-easing.c \
-        test-binding-pool.c
+        test-binding-pool.c \
+        test-text.c \
+        test-text-field.c
 
 if X11_TESTS
 UNIT_TESTS += test-pixmap.c

tests/interactive/test-clip.c

@@ -15,7 +15,7 @@ typedef enum
 struct _Clip
 {
   ClipType type;
-  gint x1, y1, x2, y2;  
+  gint x1, y1, x2, y2;
 };
 
 struct _CallbackData
@@ -24,7 +24,7 @@ struct _CallbackData
   CoglHandle hand;
 
   Clip current_clip;
-  
+
   GSList *clips;
 };
 
@@ -122,7 +122,7 @@ on_paint (ClutterActor *actor, CallbackData *data)
 {
   int i;
   ClutterGeometry stage_size;
-  guint hand_width, hand_height;
+  gint hand_width, hand_height;
   GSList *node;
 
   clutter_actor_get_allocation_geometry (data->stage, &stage_size);
@@ -242,7 +242,7 @@ on_motion (ClutterActor *stage, ClutterMotionEvent *event,
     {
       data->current_clip.x2 = event->x;
       data->current_clip.y2 = event->y;
-      
+
       clutter_actor_queue_redraw (stage);
     }
 
@@ -305,8 +305,8 @@ test_clip_main (int argc, char **argv)
   data.hand = cogl_texture_new_from_file ("redhand.png", 64, FALSE,
                                           COGL_PIXEL_FORMAT_ANY, NULL);
 
-  label = clutter_label_new_with_text ("Sans 12px", instructions);
+  label = clutter_text_new_with_text ("Sans 12px", instructions);
-  clutter_label_set_line_wrap (CLUTTER_LABEL (label), TRUE);
+  clutter_text_set_line_wrap (CLUTTER_TEXT (label), TRUE);
   clutter_actor_set_width (label, clutter_actor_get_width (data.stage) - 310);
   clutter_actor_set_y (label,
                        clutter_actor_get_height (data.stage)

tests/interactive/test-cogl-tex-polygon.c

@@ -297,16 +297,16 @@ frame_cb (ClutterTimeline *timeline,
 }
 
 static void
-update_toggle_text (ClutterLabel *button, gboolean val)
+update_toggle_text (ClutterText *button, gboolean val)
 {
-  clutter_label_set_text (button, val ? "Enabled" : "Disabled");
+  clutter_text_set_text (button, val ? "Enabled" : "Disabled");
 }
 
 static gboolean
 on_toggle_click (ClutterActor *button, ClutterEvent *event,
 		 gboolean *toggle_val)
 {
-  update_toggle_text (CLUTTER_LABEL (button), *toggle_val = !*toggle_val);
+  update_toggle_text (CLUTTER_TEXT (button), *toggle_val = !*toggle_val);
 
   return TRUE;
 }
@@ -315,12 +315,12 @@ static ClutterActor *
 make_toggle (const char *label_text, gboolean *toggle_val)
 {
   ClutterActor *group = clutter_group_new ();
-  ClutterActor *label = clutter_label_new_with_text ("Sans 14", label_text);
+  ClutterActor *label = clutter_text_new_with_text ("Sans 14", label_text);
-  ClutterActor *button = clutter_label_new_with_text ("Sans 14", "");
+  ClutterActor *button = clutter_text_new_with_text ("Sans 14", "");
   
   clutter_actor_set_reactive (button, TRUE);
 
-  update_toggle_text (CLUTTER_LABEL (button), *toggle_val);
+  update_toggle_text (CLUTTER_TEXT (button), *toggle_val);
   
   clutter_actor_set_position (button, clutter_actor_get_width (label) + 10, 0);
   clutter_container_add (CLUTTER_CONTAINER (group), label, button, NULL);
@@ -373,7 +373,7 @@ test_cogl_tex_polygon_main (int argc, char *argv[])
   clutter_actor_set_position (filtering_toggle, 0,
 			      clutter_actor_get_y (slicing_toggle)
 			      - clutter_actor_get_height (filtering_toggle));
-  note = clutter_label_new_with_text ("Sans 10", "<- Click to change");
+  note = clutter_text_new_with_text ("Sans 10", "<- Click to change");
   clutter_actor_set_position (note,
 			      clutter_actor_get_width (filtering_toggle) + 10,
 			      (clutter_actor_get_height (stage)

tests/interactive/test-depth.c

@@ -26,7 +26,7 @@ raise_top (gpointer ignored)
 static ClutterActor *
 clone_box (ClutterTexture *original)
 {
-  guint width, height;
+  gint width, height;
   ClutterActor *group;
   ClutterActor *clone;
 
@@ -83,10 +83,10 @@ janus_group (const gchar *front_text,
 
   group = clutter_group_new ();
   rectangle = clutter_rectangle_new_with_color (&slide_color);
-  front = clutter_label_new_with_text ("Sans 50px", front_text);
+  front = clutter_text_new_with_text ("Sans 50px", front_text);
-  back = clutter_label_new_with_text ("Sans 50px", back_text);
+  back = clutter_text_new_with_text ("Sans 50px", back_text);
-  clutter_label_set_color (CLUTTER_LABEL (front), &red);
+  clutter_text_set_color (CLUTTER_TEXT (front), &red);
-  clutter_label_set_color (CLUTTER_LABEL (back), &green);
+  clutter_text_set_color (CLUTTER_TEXT (back), &green);
 
   clutter_actor_get_size (front, &width, &height);
   clutter_actor_get_size (back, &width2, &height2);
@@ -134,7 +134,7 @@ test_depth_main (int argc, char *argv[])
   clutter_stage_add (stage, group);
   clutter_actor_show (group);
 
-  label = clutter_label_new_with_text ("Mono 26", "Clutter");
+  label = clutter_text_new_with_text ("Mono 26", "Clutter");
   clutter_actor_set_position (label, 120, 200);
   clutter_actor_show (label);
 

tests/interactive/test-easing.c

@@ -41,7 +41,7 @@ on_button_press (ClutterActor       *actor,
                           current_mode + 1,
                           n_easing_modes);
 
-  clutter_label_set_text (CLUTTER_LABEL (easing_mode_label), text);
+  clutter_text_set_text (CLUTTER_TEXT (easing_mode_label), text);
   g_free (text);
 
   clutter_actor_get_size (main_stage, &stage_width, &stage_height);
@@ -97,10 +97,10 @@ test_easing_main (int argc, char *argv[])
                           current_mode + 1,
                           n_easing_modes);
 
-  label = clutter_label_new ();
+  label = clutter_text_new ();
   clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
-  clutter_label_set_font_name (CLUTTER_LABEL (label), "Sans 18px");
+  clutter_text_set_font_name (CLUTTER_TEXT (label), "Sans 18px");
-  clutter_label_set_text (CLUTTER_LABEL (label), text);
+  clutter_text_set_text (CLUTTER_TEXT (label), text);
   clutter_actor_get_size (label, &label_width, &label_height);
   clutter_actor_set_position (label,
                               stage_width - label_width - 10,

tests/interactive/test-fbo.c

@@ -43,9 +43,9 @@ make_source(void)
 
   clutter_group_add (source, actor);
 
-  actor = clutter_label_new_with_text ("Sans Bold 50px", "Clutter");
+  actor = clutter_text_new_with_text ("Sans Bold 50px", "Clutter");
 
-  clutter_label_set_color (CLUTTER_LABEL (actor), &yellow);
+  clutter_text_set_color (CLUTTER_TEXT (actor), &yellow);
   clutter_actor_set_y (actor, clutter_actor_get_height(source) + 5);
   clutter_group_add (source, actor);
 

tests/interactive/test-layout.c

@@ -787,7 +787,7 @@ test_layout_main (int argc, char *argv[])
 
   clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
 
-  instructions = clutter_label_new_with_text ("Sans 14", 
+  instructions = clutter_text_new_with_text ("Sans 14",
                                               "<b>Instructions:</b>\n"
                                               "a - add a new item\n"
                                               "d - remove last item\n"
@@ -799,7 +799,7 @@ test_layout_main (int argc, char *argv[])
                                               "s - use transformed box\n"
                                               "q - quit");
 
-  clutter_label_set_use_markup (CLUTTER_LABEL (instructions), TRUE);
+  clutter_text_set_use_markup (CLUTTER_TEXT (instructions), TRUE);
   clutter_actor_set_position (instructions, 450, 10);
   clutter_container_add_actor (CLUTTER_CONTAINER (stage), instructions);
 

tests/interactive/test-multistage.c

@@ -50,10 +50,10 @@ on_button_press (ClutterActor *actor,
   clutter_container_add_actor (CLUTTER_CONTAINER (new_stage), tex);
 
   stage_label = g_strdup_printf ("<b>Stage: %d</b>", ++n_stages); 
-  label = clutter_label_new_with_text ("Mono 12", stage_label);
+  label = clutter_text_new_with_text ("Mono 12", stage_label);
 
-  clutter_label_set_color (CLUTTER_LABEL (label), &white);
+  clutter_text_set_color (CLUTTER_TEXT (label), &white);
-  clutter_label_set_use_markup (CLUTTER_LABEL (label), TRUE);
+  clutter_text_set_use_markup (CLUTTER_TEXT (label), TRUE);
   width = (clutter_actor_get_width (new_stage) 
            - clutter_actor_get_width (label)) / 2;
   height = (clutter_actor_get_height (new_stage) 
@@ -110,7 +110,7 @@ test_multistage_main (int argc, char *argv[])
                     G_CALLBACK (on_button_press),
                     NULL);
 
-  label = clutter_label_new_with_text ("Mono 16", "Default stage");
+  label = clutter_text_new_with_text ("Mono 16", "Default stage");
   width = (clutter_actor_get_width (stage_default) 
            - clutter_actor_get_width (label))
              / 2;

tests/interactive/test-opacity.c

@@ -1,116 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-
-#include <glib.h>
-#include <gmodule.h>
-
-#include <clutter/clutter.h>
-
-G_MODULE_EXPORT int
-test_opacity_main (int argc, char *argv[])
-{
-  ClutterActor *stage, *group1, *group2, *label, *rect;
-  ClutterColor label_color = { 255, 0, 0, 128 };
-  ClutterColor rect_color = { 0, 0, 255, 255 };
-  ClutterColor color_check = { 0, };
-
-  clutter_init (&argc, &argv);
-
-  stage = clutter_stage_get_default ();
-
-  label = clutter_label_new_with_text ("Sans 18px", "Label, 50% opacity");
-  clutter_label_set_color (CLUTTER_LABEL (label), &label_color);
-
-  g_print ("label 50%%.get_color()/1\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
-  g_assert (color_check.alpha == label_color.alpha);
-
-  clutter_container_add (CLUTTER_CONTAINER (stage), label, NULL);
-  clutter_actor_set_position (label, 10, 10);
-
-  g_print ("label 50%%.get_color()/2\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
-  g_assert (color_check.alpha == label_color.alpha);
-
-  g_print ("label 50%%.get_paint_opacity() = %d\n",
-           clutter_actor_get_paint_opacity (label));
-  g_assert (clutter_actor_get_paint_opacity (label) == 128);
-
-  clutter_actor_show (label);
-
-  group1 = clutter_group_new ();
-  clutter_actor_set_opacity (group1, 128);
-  clutter_container_add (CLUTTER_CONTAINER (stage), group1, NULL);
-  clutter_actor_set_position (group1, 10, 30);
-  clutter_actor_show (group1);
-
-  label = clutter_label_new_with_text ("Sans 18px", "Label+Group, 25% opacity");
-
-  clutter_label_set_color (CLUTTER_LABEL (label), &label_color);
-
-  g_print ("label 50%% + group 50%%.get_color()/1\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
-  g_assert (color_check.alpha == label_color.alpha);
-
-  clutter_container_add (CLUTTER_CONTAINER (group1), label, NULL);
-
-  g_print ("label 50%% + group 50%%.get_color()/2\n");
-  clutter_label_get_color (CLUTTER_LABEL (label), &color_check);
-  g_assert (color_check.alpha == label_color.alpha);
-
-  g_print ("label 50%% + group 50%%.get_paint_opacity() = %d\n",
-           clutter_actor_get_paint_opacity (label));
-  g_assert (clutter_actor_get_paint_opacity (label) == 64);
-
-  clutter_actor_show (label);
-
-  group2 = clutter_group_new ();
-  clutter_container_add (CLUTTER_CONTAINER (group1), group2, NULL);
-  clutter_actor_set_position (group2, 10, 60);
-  clutter_actor_show (group2);
-
-  rect = clutter_rectangle_new_with_color (&rect_color);
-  clutter_actor_set_size (rect, 128, 128);
-
-  g_print ("rect 100%% + group 100%% + group 50%%.get_color()/1\n");
-  clutter_rectangle_get_color (CLUTTER_RECTANGLE (rect), &color_check);
-  g_assert (color_check.alpha == rect_color.alpha);
-
-  clutter_container_add (CLUTTER_CONTAINER (group2), rect, NULL);
-
-  g_print ("rect 100%% + group 100%% + group 50%%.get_color()/2\n");
-  clutter_rectangle_get_color (CLUTTER_RECTANGLE (rect), &color_check);
-  g_assert (color_check.alpha == rect_color.alpha);
-
-  g_print ("rect 100%%.get_paint_opacity() = %d\n",
-           clutter_actor_get_paint_opacity (rect));
-  g_assert (clutter_actor_get_paint_opacity (rect) == 128);
-
-  clutter_actor_show (rect);
-
-  rect = clutter_rectangle_new_with_color (&rect_color);
-  clutter_actor_set_size (rect, 128, 128);
-  clutter_actor_set_position (rect, 150, 90);
-
-  g_print ("rect 100%%.get_color()/1\n");
-  clutter_rectangle_get_color (CLUTTER_RECTANGLE (rect), &color_check);
-  g_assert (color_check.alpha == rect_color.alpha);
-
-  clutter_container_add (CLUTTER_CONTAINER (stage), rect, NULL);
-
-  g_print ("rect 100%%.get_color()/2\n");
-  clutter_rectangle_get_color (CLUTTER_RECTANGLE (rect), &color_check);
-  g_assert (color_check.alpha == rect_color.alpha);
-
-  g_print ("rect 100%%.get_paint_opacity() = %d\n",
-           clutter_actor_get_paint_opacity (rect));
-  g_assert (clutter_actor_get_paint_opacity (rect) == 255);
-
-  clutter_actor_show (rect);
-
-  clutter_actor_show_all (stage);
-
-  clutter_main ();
-
-  return EXIT_SUCCESS;
-}

tests/interactive/test-project.c

@@ -224,8 +224,8 @@ test_project_main (int argc, char *argv[])
   clutter_actor_set_rotation (rect, CLUTTER_Y_AXIS, 60, 0, 0, 0);
   clutter_group_add (CLUTTER_GROUP (main_stage), rect);
 
-  label = clutter_label_new_with_text ("Mono 8pt", "Drag the blue rectangles");
+  label = clutter_text_new_with_text ("Mono 8pt", "Drag the blue rectangles");
-  clutter_label_set_color (CLUTTER_LABEL (label), &white);
+  clutter_text_set_color (CLUTTER_TEXT (label), &white);
   
   clutter_actor_set_position (label, 10, 10);
   clutter_group_add (CLUTTER_GROUP (main_stage), label);

tests/interactive/test-random-text.c

@@ -45,7 +45,7 @@ on_idle (gpointer data)
 	       font_names[rand () % FONT_NAME_COUNT],
 	       rand () % (MAX_FONT_SIZE - MIN_FONT_SIZE) + MIN_FONT_SIZE);
 
-      label = clutter_label_new_with_text (font_name, text);
+      label = clutter_text_new_with_text (font_name, text);
 
       if (clutter_actor_get_height (label) > line_height)
 	line_height = clutter_actor_get_height (label);

tests/interactive/test-rotate.c

@@ -33,8 +33,8 @@ test_rotate_main (int argc, char *argv[])
   clutter_actor_show (hand);
   clutter_container_add_actor (CLUTTER_CONTAINER (stage), hand);
 
-  label = clutter_label_new_with_text ("Mono 16", "The Wonder of the Spinning Hand");
+  label = clutter_text_new_with_text ("Mono 16", "The Wonder of the Spinning Hand");
-  clutter_label_set_alignment (CLUTTER_LABEL (label), PANGO_ALIGN_CENTER);
+  clutter_text_set_alignment (CLUTTER_TEXT (label), PANGO_ALIGN_CENTER);
   clutter_actor_set_position (label, 150, 150);
   clutter_actor_set_size (label, 500, 100);
   clutter_actor_show (label);

tests/interactive/test-scale.c

@@ -29,7 +29,7 @@ set_next_gravity (ClutterActor *actor)
 
   eclass = g_type_class_ref (CLUTTER_TYPE_GRAVITY);
   evalue = g_enum_get_value (eclass, gravity);
-  clutter_label_set_text (CLUTTER_LABEL (label), evalue->value_nick);
+  clutter_text_set_text (CLUTTER_TEXT (label), evalue->value_nick);
   g_type_class_unref (eclass);
 
   if (++gindex >= G_N_ELEMENTS (gravities))
@@ -59,8 +59,8 @@ test_scale_main (int argc, char *argv[])
 
   clutter_group_add (CLUTTER_GROUP (stage), rect);
 
-  label = clutter_label_new_with_text ("Sans 20px", "");
+  label = clutter_text_new_with_text ("Sans 20px", "");
-  clutter_label_set_color (CLUTTER_LABEL (label),
+  clutter_text_set_color (CLUTTER_TEXT (label),
                            &(ClutterColor) { 0xff, 0xff, 0xff, 0xff });
   clutter_actor_set_position (label,
                               clutter_actor_get_x (rect),

tests/interactive/test-shader.c

@@ -354,7 +354,7 @@ test_shader_main (gint argc, gchar *argv[])
       if (!child2)
 	g_error("pixbuf load failed: %s", error ? error->message : "Unknown");
       child3 = clutter_rectangle_new ();
-      child4 = clutter_label_new_with_text ("Sans 20px", "Shady stuff");
+      child4 = clutter_text_new_with_text ("Sans 20px", "Shady stuff");
 
       clutter_rectangle_set_color (child3, &color);
       clutter_actor_set_size (child3, 50, 50);

tests/interactive/test-stage-read-pixels.c

@@ -23,14 +23,14 @@ make_label (void)
   gchar *text;
   gchar *argv[] = { "ls", "--help", NULL };
 
-  label = clutter_label_new ();
+  label = clutter_text_new ();
-  clutter_label_set_font_name (CLUTTER_LABEL (label), "Sans 10");
+  clutter_text_set_font_name (CLUTTER_TEXT (label), "Sans 10");
 
   if (g_spawn_sync (NULL, argv, NULL,
 		    G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_SEARCH_PATH,
 		    NULL, NULL, &text, NULL, NULL, NULL))
     {
-      clutter_label_set_text (CLUTTER_LABEL (label), text);
+      clutter_text_set_text (CLUTTER_TEXT (label), text);
       g_free (text);
     }
 

tests/interactive/test-text-field.c

@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include <gmodule.h>
+#include <clutter/clutter.h>
+
+#define FONT "Mono Bold 14px"
+
+static void
+on_entry_paint (ClutterActor *actor,
+                gpointer      data)
+{
+  ClutterActorBox allocation = { 0, };
+  ClutterUnit width, height;
+
+  clutter_actor_get_allocation_box (actor, &allocation);
+  width = allocation.x2 - allocation.x1;
+  height = allocation.y2 - allocation.y1;
+
+  cogl_set_source_color4ub (255, 255, 255, 255);
+  cogl_path_round_rectangle (0, 0,
+                             CLUTTER_UNITS_TO_FIXED (width),
+                             CLUTTER_UNITS_TO_FIXED (height),
+                             COGL_FIXED_FROM_INT (4),
+                             COGL_ANGLE_FROM_DEG (1.0));
+  cogl_path_stroke ();
+}
+
+static void
+on_entry_activate (ClutterText *text,
+                   gpointer     data)
+{
+  g_print ("Text activated: %s\n", clutter_text_get_text (text));
+}
+
+static ClutterActor *
+create_label (const ClutterColor *color,
+              const gchar        *text)
+{
+  ClutterActor *retval = clutter_text_new_full (FONT, text, color);
+
+  clutter_text_set_editable (CLUTTER_TEXT (retval), FALSE);
+  clutter_text_set_selectable (CLUTTER_TEXT (retval), FALSE);
+
+  return retval;
+}
+
+static ClutterActor *
+create_entry (const ClutterColor *color,
+              const gchar        *text,
+              gunichar            password_char,
+              gint                max_length)
+{
+  ClutterActor *retval = clutter_text_new_full (FONT, text, color);
+  ClutterColor selection = { 0, };
+
+  clutter_actor_set_width (retval, 200);
+  clutter_actor_set_reactive (retval, TRUE);
+
+  clutter_color_darken (color, &selection);
+
+  clutter_text_set_editable (CLUTTER_TEXT (retval), TRUE);
+  clutter_text_set_selectable (CLUTTER_TEXT (retval), TRUE);
+  clutter_text_set_activatable (CLUTTER_TEXT (retval), TRUE);
+  clutter_text_set_single_line_mode (CLUTTER_TEXT (retval), TRUE);
+  clutter_text_set_password_char (CLUTTER_TEXT (retval), password_char);
+  clutter_text_set_cursor_color (CLUTTER_TEXT (retval), &selection);
+  clutter_text_set_max_length (CLUTTER_TEXT (retval), max_length);
+
+  g_signal_connect (retval, "activate",
+                    G_CALLBACK (on_entry_activate),
+                    NULL);
+  g_signal_connect (retval, "paint",
+                    G_CALLBACK (on_entry_paint),
+                    NULL);
+
+  return retval;
+}
+
+G_MODULE_EXPORT gint
+test_text_field_main (gint    argc,
+                      gchar **argv)
+{
+  ClutterActor *stage;
+  ClutterActor *text;
+  ClutterColor  entry_color       = {0x33, 0xff, 0x33, 0xff};
+  ClutterColor  label_color       = {0xff, 0xff, 0xff, 0xff};
+  ClutterColor  background_color  = {0x00, 0x00, 0x00, 0xff};
+  gint          height;
+
+  clutter_init (&argc, &argv);
+
+  stage = clutter_stage_get_default ();
+  clutter_stage_set_color (CLUTTER_STAGE (stage), &background_color);
+
+  text = create_label (&label_color, "Input field:    ");
+  clutter_actor_set_position (text, 10, 10);
+  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);
+
+  height = clutter_actor_get_height (text);
+
+  text = create_entry (&entry_color, "some text", 0, 0);
+  clutter_actor_set_position (text, 200, 10);
+  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);
+
+  text = create_label (&label_color, "Password field: ");
+  clutter_actor_set_position (text, 10, height + 12);
+  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);
+
+  text = create_entry (&entry_color, "password", '*', 8);
+  clutter_actor_set_position (text, 200, height + 12);
+  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);
+
+  clutter_actor_show (stage);
+
+  clutter_main ();
+
+  return EXIT_SUCCESS;
+}

tests/interactive/test-text.c

@@ -0,0 +1,89 @@
+#include <stdlib.h>
+
+#include <gmodule.h>
+#include <clutter/clutter.h>
+
+#define FONT "Mono Bold 22px"
+
+static gchar *runes =
+"ᚠᛇᚻ᛫ᛒᛦᚦ᛫ᚠᚱᚩᚠᚢᚱ᛫ᚠᛁᚱᚪ᛫ᚷᛖᚻᚹᛦᛚᚳᚢᛗ\n"
+"ᛋᚳᛖᚪᛚ᛫ᚦᛖᚪᚻ᛫ᛗᚪᚾᚾᚪ᛫ᚷᛖᚻᚹᛦᛚᚳ᛫ᛗᛁᚳᛚᚢᚾ᛫ᚻᛦᛏ᛫ᛞᚫᛚᚪᚾ\n"
+"ᚷᛁᚠ᛫ᚻᛖ᛫ᚹᛁᛚᛖ᛫ᚠᚩᚱ᛫ᛞᚱᛁᚻᛏᚾᛖ᛫ᛞᚩᛗᛖᛋ᛫ᚻᛚᛇᛏᚪᚾ᛬\n";
+
+
+static void
+cursor_event (ClutterText        *text,
+              ClutterGeometry *geometry)
+{
+  gint y;
+
+  y = clutter_actor_get_y (CLUTTER_ACTOR (text));
+
+  if (y + geometry->y < 50)
+    {
+      clutter_actor_set_y (CLUTTER_ACTOR (text), y + 100);
+    }
+  else if (y + geometry->y > 720)
+    {
+      clutter_actor_set_y (CLUTTER_ACTOR (text), y - 100);
+    }
+
+}
+
+G_MODULE_EXPORT gint
+test_text_main (gint    argc,
+                gchar **argv)
+{
+  ClutterActor *stage;
+  ClutterActor *text;
+  ClutterColor  text_color       = { 0x33, 0xff, 0x33, 0xff };
+  ClutterColor  cursor_color     = { 0xff, 0x33, 0x33, 0xff };
+  ClutterColor  background_color = { 0x00, 0x00, 0x00, 0xff };
+
+  clutter_init (&argc, &argv);
+
+  stage = clutter_stage_get_default ();
+  clutter_stage_set_color (CLUTTER_STAGE (stage), &background_color);
+
+  text = clutter_text_new_full (FONT, "·", &text_color);
+
+  clutter_container_add (CLUTTER_CONTAINER (stage), text, NULL);
+  clutter_actor_set_position (text, 40, 30);
+  clutter_actor_set_width (text, 1024);
+  clutter_text_set_line_wrap (CLUTTER_TEXT (text), TRUE);
+
+  clutter_actor_set_reactive (text, TRUE);
+  clutter_stage_set_key_focus (CLUTTER_STAGE (stage), text);
+
+  clutter_text_set_editable (CLUTTER_TEXT (text), TRUE);
+  clutter_text_set_selectable (CLUTTER_TEXT (text), TRUE);
+  clutter_text_set_cursor_color (CLUTTER_TEXT (text), &cursor_color);
+
+  if (argv[1])
+    {
+      GError *error = NULL;
+      gchar *utf8;
+
+      g_file_get_contents (argv[1], &utf8, NULL, &error);
+      if (error)
+        {
+          utf8 = g_strconcat ("Unable to open '", argv[1], "':\n",
+                              error->message,
+                              NULL);
+          g_error_free (error);
+        }
+
+      clutter_text_set_text (CLUTTER_TEXT (text), utf8);
+    }
+  else
+    clutter_text_set_text (CLUTTER_TEXT (text), runes);
+
+  g_signal_connect (text, "cursor-event", G_CALLBACK (cursor_event), NULL);
+
+  clutter_actor_set_size (stage, 1024, 768);
+  clutter_actor_show (stage);
+
+  clutter_main ();
+
+  return EXIT_SUCCESS;
+}

tests/interactive/test-threads.c

@@ -42,7 +42,7 @@ test_thread_done_idle (gpointer user_data)
 
   g_print ("Thread completed\n");
 
-  clutter_label_set_text (CLUTTER_LABEL (data->label), "Completed");
+  clutter_text_set_text (CLUTTER_TEXT (data->label), "Completed");
   clutter_timeline_stop (data->timeline);
 
   test_thread_data_free (data);
@@ -67,7 +67,7 @@ update_label_idle (gpointer data)
 
   text = g_strdup_printf ("Count to %d", update->count);
 
-  clutter_label_set_text (CLUTTER_LABEL (update->thread_data->label), text);
+  clutter_text_set_text (CLUTTER_TEXT (update->thread_data->label), text);
   clutter_actor_set_width (update->thread_data->label, -1);
 
   if (update->count == 0)
@@ -151,7 +151,7 @@ on_key_press_event (ClutterStage    *stage,
   switch (clutter_key_event_symbol (event))
     {
     case CLUTTER_s:
-      clutter_label_set_text (CLUTTER_LABEL (help_label), "Press 'q' to quit");
+      clutter_text_set_text (CLUTTER_TEXT (help_label), "Press 'q' to quit");
 
       clutter_timeline_start (timeline);
       
@@ -191,10 +191,10 @@ test_threads_main (int argc, char *argv[])
   clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
   clutter_actor_set_size (stage, 600, 300);
   
-  count_label = clutter_label_new_with_text ("Mono 12", "Counter");
+  count_label = clutter_text_new_with_text ("Mono 12", "Counter");
   clutter_actor_set_position (count_label, 350, 50);
 
-  help_label = clutter_label_new_with_text ("Mono 12", "Press 's' to start");
+  help_label = clutter_text_new_with_text ("Mono 12", "Press 's' to start");
   clutter_actor_set_position (help_label, 50, 50);
 
   rect = clutter_rectangle_new_with_color (&rect_color);

tests/interactive/test-unproject.c

@@ -5,13 +5,15 @@
 #include <string.h>
 #include <gmodule.h>
 
-ClutterActor *label;
-
 #define RECT_L 200
 #define RECT_T 150
 #define RECT_W 320
 #define RECT_H 240
 
+static ClutterActor *test_rectangle = NULL;
+static ClutterActor *label = NULL;
+
+
 static gboolean
 on_event (ClutterStage *stage,
 	  ClutterEvent *event,
@@ -29,15 +31,14 @@ on_event (ClutterStage *stage,
 
 	actor = clutter_stage_get_actor_at_pos (stage, x, y);
 
-
 	if (clutter_actor_transform_stage_point (actor,
-						CLUTTER_UNITS_FROM_DEVICE (x),
+                                                 CLUTTER_UNITS_FROM_DEVICE (x),
-						CLUTTER_UNITS_FROM_DEVICE (y),
+                                                 CLUTTER_UNITS_FROM_DEVICE (y),
-						&xu2, &yu2))
+                                                 &xu2, &yu2))
 	  {
 	    gchar *txt;
 
-	    if (actor != CLUTTER_ACTOR (stage))
+	    if (actor == test_rectangle)
 	      txt = g_strdup_printf ("Click on rectangle\n"
 				     "Screen coords: [%d, %d]\n"
 				     "Local coords : [%d, %d]",
@@ -52,12 +53,11 @@ on_event (ClutterStage *stage,
 				     CLUTTER_UNITS_TO_DEVICE (xu2),
 				     CLUTTER_UNITS_TO_DEVICE (yu2));
 
-	    clutter_label_set_text (CLUTTER_LABEL (label), txt);
+	    clutter_text_set_text (CLUTTER_TEXT (label), txt);
 	    g_free (txt);
 	  }
 	else
-	  clutter_label_set_text (CLUTTER_LABEL (label),
+	  clutter_text_set_text (CLUTTER_TEXT (label), "Unprojection failed.");
-				  "Unprojection failed.");
       }
       break;
 
@@ -75,9 +75,9 @@ test_unproject_main (int argc, char *argv[])
   gchar *txt;
   ClutterActor *rect, *stage, *label0;
   int i, rotate_x = 0, rotate_y = 60, rotate_z = 0;
-  ClutterColor stage_clr = { 0x0, 0x0, 0x0, 0xff },
+  ClutterColor stage_clr = { 0x0,  0x0,  0x0,  0xff },
                white     = { 0xff, 0xff, 0xff, 0xff },
-               blue      = { 0, 0xff, 0xff, 0xff };
+               blue      = { 0x0,  0xff, 0xff, 0xff };
 
   for (i = 0; i < argc; ++i)
     {
@@ -95,11 +95,12 @@ test_unproject_main (int argc, char *argv[])
 	}
       else if (!strncmp (argv[i], "--help", 6))
 	{
-	  printf ("%s [--rotage-x=degrees] [--rotage-y=degrees] "
+	  g_print ("%s [--rotage-x=degrees] "
-		  "[--rotage-z=degrees]\n",
+                   "[--rotage-y=degrees] "
-		  argv[0]);
+                   "[--rotage-z=degrees]\n",
+		   argv[0]);
 
-	  exit (0);
+	  return EXIT_FAILURE;
 	}
     }
 
@@ -117,6 +118,7 @@ test_unproject_main (int argc, char *argv[])
   clutter_actor_set_rotation (rect, CLUTTER_Y_AXIS, rotate_y, 0, 0, 0);
   clutter_actor_set_rotation (rect, CLUTTER_Z_AXIS, rotate_z, 0, 0, 0);
   clutter_group_add (CLUTTER_GROUP (stage), rect);
+  test_rectangle = rect;
 
   txt = g_strdup_printf ("Rectangle: L %d, R %d, T %d, B %d\n"
 			 "Rotation : x %d, y %d, z %d",
@@ -124,8 +126,8 @@ test_unproject_main (int argc, char *argv[])
 			 RECT_T, RECT_T + RECT_H,
 			 rotate_x, rotate_y, rotate_z);
 
-  label0 = clutter_label_new_with_text ("Mono 8pt", txt);
+  label0 = clutter_text_new_with_text ("Mono 8pt", txt);
-  clutter_label_set_color (CLUTTER_LABEL (label0), &white);
+  clutter_text_set_color (CLUTTER_TEXT (label0), &white);
 
   clutter_actor_set_position (label0, 10, 10);
   clutter_group_add (CLUTTER_GROUP (stage), label0);
@@ -133,9 +135,9 @@ test_unproject_main (int argc, char *argv[])
   g_free (txt);
 
   label =
-    clutter_label_new_with_text ("Mono 8pt", "Click around!");
+    clutter_text_new_with_text ("Mono 8pt", "Click around!");
 
-  clutter_label_set_color (CLUTTER_LABEL (label), &blue);
+  clutter_text_set_color (CLUTTER_TEXT (label), &blue);
 
   clutter_actor_set_position (label, 10, 50);
   clutter_group_add (CLUTTER_GROUP (stage), label);
@@ -146,5 +148,8 @@ test_unproject_main (int argc, char *argv[])
 
   clutter_main();
 
+  test_rectangle = NULL;
+  label = NULL;
+
   return EXIT_SUCCESS;
 }

tests/micro-bench/test-text.c

@@ -80,14 +80,14 @@ main (int argc, char *argv[])
               scale = 1.0;
             }
 
-          label = clutter_label_new_with_text (font_name, text);
+          label = clutter_text_new_with_text (font_name, text);
-          clutter_label_set_color (CLUTTER_LABEL (label), &label_color);
+          clutter_text_set_color (CLUTTER_TEXT (label), &label_color);
           clutter_actor_set_position (label, (1.0*STAGE_WIDTH/COLS)*col,
                                              (1.0*STAGE_HEIGHT/ROWS)*row);
           /*clutter_actor_set_clip (label, 0,0, (1.0*STAGE_WIDTH/COLS),
                                               (1.0*STAGE_HEIGHT/ROWS));*/
           clutter_actor_set_scale (label, scale, scale);
-          clutter_label_set_line_wrap (CLUTTER_LABEL (label), FALSE);
+          clutter_text_set_line_wrap (CLUTTER_TEXT (label), FALSE);
           clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
         }
   }

tests/tools/Makefile.am

@@ -10,6 +10,12 @@ libdisable_npots_la_SOURCES = disable-npots.c
 
 libdisable_npots_la_LIBADD = -ldl
 
+INCLUDES = \
+	-I$(top_srcdir)/clutter	                        \
+	-I$(top_builddir)/clutter                       \
+	$(CLUTTER_CFLAGS)                               \
+	-D_GNU_SOURCE
+
 all-local : disable-npots.sh
 
 clean-local :

tests/tools/disable-npots.c

@@ -4,13 +4,22 @@
  * overrides glGetString and removes the extension strings.
  */
 
-#include <GL/gl.h>
+/* This is just included to get the right GL header */
+#include <cogl/cogl.h>
+
 #include <dlfcn.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <ctype.h>
 
+/* If RTLD_NEXT isn't available then try just using NULL */
+#ifdef  RTLD_NEXT
+#define LIB_HANDLE    RTLD_NEXT
+#else
+#define LIB_HANDLE    NULL
+#endif
+
 typedef const GLubyte * (* GetStringFunc) (GLenum name);
 
 static const char * const bad_strings[]
@@ -23,16 +32,14 @@ const GLubyte *
 glGetString (GLenum name)
 {
   const GLubyte *ret = NULL;
-  static void *gl_lib = NULL;
   static GetStringFunc func = NULL;
   static GLubyte *extensions = NULL;
 
-  if (gl_lib == NULL
+  if (func == NULL
-      && (gl_lib = dlopen ("libGL.so", RTLD_LAZY)) == NULL)
+      && (func = (GetStringFunc) dlsym (LIB_HANDLE, "glGetString")) == NULL)
-    fprintf (stderr, "dlopen: %s\n", dlerror ());
-  else if (func == NULL
-	   && (func = (GetStringFunc) dlsym (gl_lib, "glGetString")) == NULL)
     fprintf (stderr, "dlsym: %s\n", dlerror ());
+  else if (func == glGetString)
+    fprintf (stderr, "dlsym returned the wrapper of glGetString\n");
   else
     {
       ret = (* func) (name);