Bump version to 3.31.90

Update NEWS.

.gitlab-ci.yml

@@ -7,14 +7,27 @@ stages:
 build-mutter:
   stage: build
   script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror
     - ninja -C build
     - ninja -C build install
+  artifacts:
+    expire_in: 1 day
+    paths:
+      - build
 
 test-mutter:
   stage: test
+  dependencies:
+    - build-mutter
+  artifacts:
+    paths:
+      - build
+  variables:
+    XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
+    GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
   script:
-    - meson . build -Degl_device=true -Dwayland_eglstream=true
-    - ninja -C build
-    - glib-compile-schemas $PWD/build/data
-    - env XDG_RUNTIME_DIR=/tmp/ GSETTINGS_SCHEMA_DIR=$PWD/build/data dbus-run-session -- xvfb-run -s '+iglx -noreset' meson test -C build -t 10 --verbose --no-stdsplit --wrap catchsegv
+    - mkdir -m 700 $XDG_RUNTIME_DIR
+    - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
+    - >
+      dbus-run-session -- xvfb-run -s '+iglx -noreset'
+      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --wrap catchsegv

.gitlab-ci/Dockerfile

@@ -11,10 +11,7 @@ RUN dnf -y update && dnf -y upgrade && \
     dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
 
     # Unpackaged versions
-    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00836095-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
-
-    # Packages not yet in stable
-    dnf install -y https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-devel-0.2.5-1.fc29.x86_64.rpm https://kojipkgs.fedoraproject.org//packages/pipewire/0.2.5/1.fc29/x86_64/pipewire-libs-0.2.5-1.fc29.x86_64.rpm && \
+    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
 
     dnf install -y intltool redhat-rpm-config make && \
     dnf clean all

NEWS

@@ -1,3 +1,28 @@
+3.31.90
+=======
+* Fix support of extended characters in on-screen keyboard [Andrea; #109]
+* Improve selection of the primary GPU [Pekka, Emilio; !271]
+* Screen-cast cursor updates as PipeWire stream metadata [Jonas; !357]
+* Fix rendering glitches in magnifier [Daniel; gnome-shell#387]
+* Fix monitor recording on HiDPI [Jonas; !415]
+* Honour secondary GPU supported pixel formats [Pekka; !341]
+* Fall back to CPU copy path when using a software renderer [Emilio; !325]
+* Remove fallback app menu [Florian; gnome-shell#624]
+* wayland: Add support for viewporter protocol [Robert; !323]
+* Misc. bug fixes and cleanups [Florian, Carlos, Olivier, Marco, Robert,
+  Daniel, Pekka, Jonas, Ole, Georges; !391, #335, #442, !406, !395, #447,
+  !375, gnome-shell#349, #451, !416, #784199, !408, !181, !405]
+
+Contributors:
+  Jonas Ådahl, Andrea Azzarone, Ole Jørgen Brønner, Piotr Drąg, Olivier Fourdan,
+  Dariusz Gadomski, Carlos Garnacho, Antoine Jacoutot, Iain Lane, Robert Mader,
+  Emilio Pozuelo Monfort, Florian Müllner, Georges Basile Stavracas Neto,
+  Pekka Paalanen, Marco Trevisan (Treviño), Josh Triplett, Daniel van Vugt
+
+Translators:
+  Fabio Tomat [fur], Balázs Úr [hu], Daniel Mustieles [es], Kukuh Syafaat [id],
+  Jordi Mas [ca], Piotr Drąg [pl]
+
 3.31.4
 ======
 * keybindings: Limit corner move to current monitor [Jānis; #320]

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

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

clutter/clutter/clutter-actor-box.c

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

clutter/clutter/clutter-actor.c

@@ -3740,7 +3740,7 @@ clutter_actor_paint_node (ClutterActor     *actor,
       if (!clutter_stage_get_no_clear_hint (CLUTTER_STAGE (actor)))
         clear_flags |= COGL_BUFFER_BIT_COLOR;
 
-      node = _clutter_root_node_new (fb, &bg_color, clear_flags);
+      node = clutter_root_node_new (fb, &bg_color, clear_flags);
       clutter_paint_node_set_name (node, "stageClear");
       clutter_paint_node_add_rectangle (node, &box);
       clutter_paint_node_add_child (root, node);
@@ -3779,7 +3779,7 @@ clutter_actor_paint_node (ClutterActor     *actor,
     }
 #endif /* CLUTTER_ENABLE_DEBUG */
 
-  _clutter_paint_node_paint (root);
+  clutter_paint_node_paint (root);
 
   return TRUE;
 }
@@ -18467,6 +18467,10 @@ clutter_actor_set_margin_top (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
+
+  if (info->margin.top == margin)
+    return;
+
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_TOP],
                                     info->margin.top,
                                     margin);
@@ -18511,6 +18515,10 @@ clutter_actor_set_margin_bottom (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
+
+  if (info->margin.bottom == margin)
+    return;
+
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_BOTTOM],
                                     info->margin.bottom,
                                     margin);
@@ -18555,6 +18563,10 @@ clutter_actor_set_margin_left (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
+
+  if (info->margin.left == margin)
+    return;
+
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_LEFT],
                                     info->margin.left,
                                     margin);
@@ -18599,6 +18611,10 @@ clutter_actor_set_margin_right (ClutterActor *self,
   g_return_if_fail (margin >= 0.f);
 
   info = _clutter_actor_get_layout_info_or_defaults (self);
+
+  if (info->margin.right == margin)
+    return;
+
   _clutter_actor_create_transition (self, obj_props[PROP_MARGIN_RIGHT],
                                     info->margin.right,
                                     margin);

clutter/clutter/clutter-backend-private.h

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

clutter/clutter/clutter-backend.c

@@ -577,6 +577,18 @@ clutter_backend_real_get_device_manager (ClutterBackend *backend)
   return backend->device_manager;
 }
 
+static ClutterKeymap *
+clutter_backend_real_get_keymap (ClutterBackend *backend)
+{
+  if (G_UNLIKELY (backend->keymap == NULL))
+    {
+      g_critical ("No keymap available, expect broken keyboard input");
+      return NULL;
+    }
+
+  return backend->keymap;
+}
+
 static gboolean
 clutter_backend_real_translate_event (ClutterBackend *backend,
                                       gpointer        native,
@@ -675,6 +687,7 @@ clutter_backend_class_init (ClutterBackendClass *klass)
   klass->translate_event = clutter_backend_real_translate_event;
   klass->create_context = clutter_backend_real_create_context;
   klass->get_features = clutter_backend_real_get_features;
+  klass->get_keymap = clutter_backend_real_get_keymap;
 }
 
 static void
@@ -1399,3 +1412,17 @@ clutter_backend_set_input_method (ClutterBackend     *backend,
 {
   g_set_object (&backend->input_method, method);
 }
+
+/**
+ * clutter_backend_get_keymap:
+ * @backend: the #ClutterBackend
+ *
+ * Gets the keymap used by Clutter
+ *
+ * Returns: (transfer none): the keymap
+ **/
+ClutterKeymap *
+clutter_backend_get_keymap (ClutterBackend *backend)
+{
+  return CLUTTER_BACKEND_GET_CLASS (backend)->get_keymap (backend);
+}

clutter/clutter/clutter-backend.h

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

clutter/clutter/clutter-bezier.h

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

clutter/clutter/clutter-box-layout.c

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

clutter/clutter/clutter-content.c

@@ -38,6 +38,7 @@
 
 #include "clutter-build-config.h"
 
+#include "clutter-actor-private.h"
 #include "clutter-content-private.h"
 
 #include "clutter-debug.h"
@@ -91,6 +92,11 @@ clutter_content_real_invalidate (ClutterContent *content)
 {
 }
 
+static void
+clutter_content_real_invalidate_size (ClutterContent *content)
+{
+}
+
 static void
 clutter_content_real_paint_content (ClutterContent   *content,
                                     ClutterActor     *actor,
@@ -108,6 +114,7 @@ clutter_content_default_init (ClutterContentInterface *iface)
   iface->attached = clutter_content_real_attached;
   iface->detached = clutter_content_real_detached;
   iface->invalidate = clutter_content_real_invalidate;
+  iface->invalidate_size = clutter_content_real_invalidate_size;
 
   /**
    * ClutterContent::attached:
@@ -188,6 +195,45 @@ clutter_content_invalidate (ClutterContent *content)
     }
 }
 
+/**
+ * clutter_content_invalidate_size:
+ * @content: a #ClutterContent
+ *
+ * Signals that @content's size changed. Attached actors with request mode
+ * set to %CLUTTER_REQUEST_CONTENT_SIZE will have a relayout queued.
+ *
+ * Attached actors with other request modes are not redrawn. To redraw them
+ * too, use clutter_content_invalidate().
+ */
+void
+clutter_content_invalidate_size (ClutterContent *content)
+{
+  ClutterActor *actor;
+  GHashTable *actors;
+  GHashTableIter iter;
+
+  g_return_if_fail (CLUTTER_IS_CONTENT (content));
+
+  CLUTTER_CONTENT_GET_IFACE (content)->invalidate_size (content);
+
+  actors = g_object_get_qdata (G_OBJECT (content), quark_content_actors);
+  if (actors == NULL)
+    return;
+
+  g_hash_table_iter_init (&iter, actors);
+  while (g_hash_table_iter_next (&iter, (gpointer *) &actor, NULL))
+    {
+      ClutterRequestMode request_mode;
+
+      g_assert (actor != NULL);
+
+      request_mode = clutter_actor_get_request_mode (actor);
+
+      if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
+        _clutter_actor_queue_only_relayout (actor);
+    }
+}
+
 /*< private >
  * _clutter_content_attached:
  * @content: a #ClutterContent

clutter/clutter/clutter-content.h

@@ -86,6 +86,8 @@ struct _ClutterContentIface
                                          ClutterActor     *actor);
 
   void          (* invalidate)          (ClutterContent   *content);
+
+  void          (* invalidate_size)     (ClutterContent   *content);
 };
 
 CLUTTER_EXPORT
@@ -98,6 +100,9 @@ gboolean        clutter_content_get_preferred_size      (ClutterContent *content
 CLUTTER_EXPORT
 void            clutter_content_invalidate              (ClutterContent *content);
 
+CLUTTER_EXPORT
+void            clutter_content_invalidate_size         (ClutterContent *content);
+
 G_END_DECLS
 
 #endif /* __CLUTTER_CONTENT_H__ */

clutter/clutter/clutter-debug.h

@@ -80,9 +80,9 @@ extern guint clutter_pick_debug_flags;
 extern guint clutter_paint_debug_flags;
 
 void    _clutter_debug_messagev         (const char *format,
-                                         va_list     var_args);
+                                         va_list     var_args) G_GNUC_PRINTF (1, 0);
 void    _clutter_debug_message          (const char *format,
-                                         ...);
+                                         ...) G_GNUC_PRINTF (1, 2);
 
 G_END_DECLS
 

clutter/clutter/clutter-event.h

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

clutter/clutter/clutter-image.c

@@ -53,6 +53,8 @@
 struct _ClutterImagePrivate
 {
   CoglTexture *texture;
+  gint width;
+  gint height;
 };
 
 static void clutter_content_iface_init (ClutterContentIface *iface);
@@ -68,6 +70,27 @@ clutter_image_error_quark (void)
   return g_quark_from_static_string ("clutter-image-error-quark");
 }
 
+static void
+update_image_size (ClutterImage *self)
+{
+  gint width, height;
+
+  if (self->priv->texture == NULL)
+    return;
+
+  width = cogl_texture_get_width (self->priv->texture);
+  height = cogl_texture_get_height (self->priv->texture);
+
+  if (self->priv->width == width &&
+      self->priv->height == height)
+    return;
+
+  self->priv->width = width;
+  self->priv->height = height;
+
+  clutter_content_invalidate_size (CLUTTER_CONTENT (self));
+}
+
 static void
 clutter_image_finalize (GObject *gobject)
 {
@@ -238,6 +261,7 @@ clutter_image_set_data (ClutterImage     *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);
 
   return TRUE;
 }
@@ -306,6 +330,7 @@ clutter_image_set_bytes (ClutterImage     *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);
 
   return TRUE;
 }
@@ -399,6 +424,7 @@ clutter_image_set_area (ClutterImage                 *image,
     }
 
   clutter_content_invalidate (CLUTTER_CONTENT (image));
+  update_image_size (image);
 
   return TRUE;
 }

clutter/clutter/clutter-keymap.c

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

clutter/clutter/clutter-keymap.h

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

clutter/clutter/clutter-offscreen-effect.c

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

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

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

clutter/clutter/clutter-paint-node.c

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

clutter/clutter/clutter-paint-node.h

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

clutter/clutter/clutter-paint-nodes.c

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

clutter/clutter/clutter-paint-nodes.h

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

clutter/clutter/clutter-paint-volume.c

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

clutter/clutter/clutter-pan-action.c

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

clutter/clutter/clutter-private.h

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

clutter/clutter/clutter-shader-effect.c

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

clutter/clutter/clutter-stage.c

@@ -1474,8 +1474,8 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   if (G_LIKELY (!(clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS)))
     {
       CLUTTER_NOTE (PICK, "Pushing pick scissor clip x: %d, y: %d, 1x1",
-                    (int) dirty_x * fb_scale,
-                    (int) dirty_y * fb_scale);
+                    (int) (dirty_x * fb_scale),
+                    (int) (dirty_y * fb_scale));
       cogl_framebuffer_push_scissor_clip (fb, dirty_x * fb_scale, dirty_y * fb_scale, 1, 1);
     }
 
@@ -1495,7 +1495,7 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   read_x = dirty_x * fb_scale;
   read_y = dirty_y * fb_scale;
 
-  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %d",
+  CLUTTER_NOTE (PICK, "Performing pick at %i,%i on view %dx%d+%d+%d s: %f",
                 x, y,
                 view_layout.width, view_layout.height,
                 view_layout.x, view_layout.y, fb_scale);

clutter/clutter/clutter.h

@@ -76,6 +76,7 @@
 #include "clutter-input-focus.h"
 #include "clutter-interval.h"
 #include "clutter-keyframe-transition.h"
+#include "clutter-keymap.h"
 #include "clutter-keysyms.h"
 #include "clutter-layout-manager.h"
 #include "clutter-layout-meta.h"

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

@@ -44,6 +44,7 @@
 #include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-input-device-evdev.h"
+#include "clutter-keymap-evdev.h"
 #include "clutter-seat-evdev.h"
 #include "clutter-virtual-input-device-evdev.h"
 #include "clutter-main.h"
@@ -91,7 +92,6 @@ struct _ClutterDeviceManagerEvdevPrivate
   GSList *seats;
 
   ClutterSeatEvdev *main_seat;
-  struct xkb_keymap *keymap;
 
   ClutterPointerConstrainCallback constrain_callback;
   gpointer                        constrain_data;
@@ -147,10 +147,6 @@ static const char *device_type_str[] = {
  * appear and disappear from the system.
  */
 
-static const char *option_xkb_layout = "us";
-static const char *option_xkb_variant = "";
-static const char *option_xkb_options = "";
-
 static void
 clutter_device_manager_evdev_copy_event_data (ClutterEventExtender *event_extender,
                                               const ClutterEvent   *src,
@@ -1933,8 +1929,6 @@ clutter_device_manager_evdev_constructed (GObject *gobject)
   ClutterDeviceManagerEvdevPrivate *priv;
   ClutterEventSource *source;
   struct udev *udev;
-  struct xkb_context *ctx;
-  struct xkb_rule_names names;
 
   udev = udev_new ();
   if (G_UNLIKELY (udev == NULL))
@@ -1966,17 +1960,6 @@ clutter_device_manager_evdev_constructed (GObject *gobject)
 
   udev_unref (udev);
 
-  names.rules = "evdev";
-  names.model = "pc105";
-  names.layout = option_xkb_layout;
-  names.variant = option_xkb_variant;
-  names.options = option_xkb_options;
-
-  ctx = xkb_context_new (0);
-  g_assert (ctx);
-  priv->keymap = xkb_keymap_new_from_names (ctx, &names, 0);
-  xkb_context_unref (ctx);
-
   priv->main_seat = clutter_seat_evdev_new (manager_evdev);
   priv->seats = g_slist_append (priv->seats, priv->main_seat);
 
@@ -2030,9 +2013,6 @@ clutter_device_manager_evdev_finalize (GObject *object)
   g_slist_free_full (priv->seats, (GDestroyNotify) clutter_seat_evdev_free);
   g_slist_free (priv->devices);
 
-  if (priv->keymap)
-    xkb_keymap_unref (priv->keymap);
-
   if (priv->event_source != NULL)
     clutter_event_source_free (priv->event_source);
 
@@ -2156,6 +2136,7 @@ _clutter_events_evdev_init (ClutterBackend *backend)
 {
   CLUTTER_NOTE (EVENT, "Initializing evdev backend");
 
+  backend->keymap = g_object_new (CLUTTER_TYPE_KEYMAP_EVDEV, NULL);
   backend->device_manager = g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_EVDEV,
                                           "backend", backend,
                                           NULL);
@@ -2218,14 +2199,6 @@ _clutter_device_manager_evdev_release_device_id (ClutterDeviceManagerEvdev *mana
                                                 compare_ids);
 }
 
-struct xkb_keymap *
-_clutter_device_manager_evdev_get_keymap (ClutterDeviceManagerEvdev *manager_evdev)
-{
-  ClutterDeviceManagerEvdevPrivate *priv = manager_evdev->priv;
-
-  return priv->keymap;
-}
-
 ClutterStage *
 _clutter_device_manager_evdev_get_stage (ClutterDeviceManagerEvdev *manager_evdev)
 {
@@ -2288,6 +2261,11 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
   ClutterSeatEvdev *seat;
   xkb_mod_mask_t latched_mods;
   xkb_mod_mask_t locked_mods;
+  struct xkb_keymap *xkb_keymap;
+  ClutterKeymap *keymap;
+
+  keymap = clutter_backend_get_keymap (clutter_get_default_backend ());
+  xkb_keymap = clutter_keymap_evdev_get_keyboard_map (CLUTTER_KEYMAP_EVDEV (keymap));
 
   priv = manager_evdev->priv;
 
@@ -2300,7 +2278,7 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
       locked_mods = xkb_state_serialize_mods (seat->xkb,
                                               XKB_STATE_MODS_LOCKED);
       xkb_state_unref (seat->xkb);
-      seat->xkb = xkb_state_new (priv->keymap);
+      seat->xkb = xkb_state_new (xkb_keymap);
 
       xkb_state_update_mask (seat->xkb,
                              0, /* depressed */
@@ -2308,9 +2286,9 @@ clutter_evdev_update_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
                              locked_mods,
                              0, 0, seat->layout_idx);
 
-      seat->caps_lock_led = xkb_keymap_led_get_index (priv->keymap, XKB_LED_NAME_CAPS);
-      seat->num_lock_led = xkb_keymap_led_get_index (priv->keymap, XKB_LED_NAME_NUM);
-      seat->scroll_lock_led = xkb_keymap_led_get_index (priv->keymap, XKB_LED_NAME_SCROLL);
+      seat->caps_lock_led = xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_CAPS);
+      seat->num_lock_led = xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_NUM);
+      seat->scroll_lock_led = xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_SCROLL);
 
       clutter_seat_evdev_sync_leds (seat);
     }
@@ -2395,20 +2373,18 @@ clutter_evdev_set_device_callbacks (ClutterOpenDeviceCallback  open_callback,
  */
 void
 clutter_evdev_set_keyboard_map (ClutterDeviceManager *evdev,
-				struct xkb_keymap    *keymap)
+				struct xkb_keymap    *xkb_keymap)
 {
   ClutterDeviceManagerEvdev *manager_evdev;
-  ClutterDeviceManagerEvdevPrivate *priv;
+  ClutterKeymap *keymap;
 
   g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (evdev));
 
+  keymap = clutter_backend_get_keymap (clutter_get_default_backend ());
+  clutter_keymap_evdev_set_keyboard_map (CLUTTER_KEYMAP_EVDEV (keymap),
+                                         xkb_keymap);
+
   manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (evdev);
-  priv = manager_evdev->priv;
-
-  if (priv->keymap)
-    xkb_keymap_unref (priv->keymap);
-
-  priv->keymap = xkb_keymap_ref (keymap);
   clutter_evdev_update_xkb_state (manager_evdev);
 }
 
@@ -2503,12 +2479,18 @@ clutter_evdev_set_keyboard_numlock (ClutterDeviceManager *evdev,
   ClutterDeviceManagerEvdevPrivate *priv;
   GSList *iter;
   xkb_mod_mask_t numlock;
+  struct xkb_keymap *xkb_keymap;
+  ClutterKeymap *keymap;
 
   g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER_EVDEV (evdev));
 
   manager_evdev = CLUTTER_DEVICE_MANAGER_EVDEV (evdev);
   priv = manager_evdev->priv;
-  numlock = (1 << xkb_keymap_mod_get_index(priv->keymap, "Mod2"));
+
+  keymap = clutter_backend_get_keymap (clutter_get_default_backend ());
+  xkb_keymap = clutter_keymap_evdev_get_keyboard_map (CLUTTER_KEYMAP_EVDEV (keymap));
+
+  numlock = (1 << xkb_keymap_mod_get_index (xkb_keymap, "Mod2"));
 
   for (iter = priv->seats; iter; iter = iter->next)
     {
@@ -2759,3 +2741,9 @@ clutter_evdev_set_seat_id (const gchar *seat_id)
   g_free (evdev_seat_id);
   evdev_seat_id = g_strdup (seat_id);
 }
+
+struct xkb_state *
+_clutter_device_manager_evdev_get_xkb_state (ClutterDeviceManagerEvdev *manager_evdev)
+{
+  return manager_evdev->priv->main_seat->xkb;
+}

clutter/clutter/evdev/clutter-device-manager-evdev.h

@@ -64,8 +64,6 @@ gint  _clutter_device_manager_evdev_acquire_device_id (ClutterDeviceManagerEvdev
 void  _clutter_device_manager_evdev_release_device_id (ClutterDeviceManagerEvdev *manager_evdev,
                                                        ClutterInputDevice        *device);
 
-struct xkb_keymap * _clutter_device_manager_evdev_get_keymap (ClutterDeviceManagerEvdev *manager_evdev);
-
 ClutterStage * _clutter_device_manager_evdev_get_stage (ClutterDeviceManagerEvdev *manager_evdev);
 
 void _clutter_device_manager_evdev_constrain_pointer (ClutterDeviceManagerEvdev *manager_evdev,
@@ -85,6 +83,8 @@ void _clutter_device_manager_evdev_filter_relative_motion (ClutterDeviceManagerE
 
 void _clutter_device_manager_evdev_dispatch (ClutterDeviceManagerEvdev *manager_evdev);
 
+struct xkb_state * _clutter_device_manager_evdev_get_xkb_state (ClutterDeviceManagerEvdev *manager_evdev);
+
 static inline guint64
 us (guint64 us)
 {

clutter/clutter/evdev/clutter-keymap-evdev.c

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2018 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#include "clutter-build-config.h"
+
+#include "clutter-device-manager-evdev.h"
+#include "clutter-keymap-evdev.h"
+
+static const char *option_xkb_layout = "us";
+static const char *option_xkb_variant = "";
+static const char *option_xkb_options = "";
+
+typedef struct _ClutterKeymapEvdev ClutterKeymapEvdev;
+
+struct _ClutterKeymapEvdev
+{
+  ClutterKeymap parent_instance;
+
+  struct xkb_keymap *keymap;
+};
+
+G_DEFINE_TYPE (ClutterKeymapEvdev, clutter_keymap_evdev,
+               CLUTTER_TYPE_KEYMAP)
+
+static void
+clutter_keymap_evdev_finalize (GObject *object)
+{
+  ClutterKeymapEvdev *keymap = CLUTTER_KEYMAP_EVDEV (object);
+
+  xkb_keymap_unref (keymap->keymap);
+
+  G_OBJECT_CLASS (clutter_keymap_evdev_parent_class)->finalize (object);
+}
+
+static gboolean
+clutter_keymap_evdev_get_num_lock_state (ClutterKeymap *keymap)
+{
+  ClutterDeviceManagerEvdev *device_manager;
+  struct xkb_state *xkb_state;
+
+  device_manager =
+    CLUTTER_DEVICE_MANAGER_EVDEV (clutter_device_manager_get_default ());
+  xkb_state = _clutter_device_manager_evdev_get_xkb_state (device_manager);
+
+  return xkb_state_mod_name_is_active (xkb_state,
+                                       XKB_MOD_NAME_NUM,
+                                       XKB_STATE_MODS_LATCHED ||
+                                       XKB_STATE_MODS_LOCKED);
+}
+
+static gboolean
+clutter_keymap_evdev_get_caps_lock_state (ClutterKeymap *keymap)
+{
+  ClutterDeviceManagerEvdev *device_manager;
+  struct xkb_state *xkb_state;
+
+  device_manager =
+    CLUTTER_DEVICE_MANAGER_EVDEV (clutter_device_manager_get_default ());
+  xkb_state = _clutter_device_manager_evdev_get_xkb_state (device_manager);
+
+  return xkb_state_mod_name_is_active (xkb_state,
+                                       XKB_MOD_NAME_CAPS,
+                                       XKB_STATE_MODS_LATCHED ||
+                                       XKB_STATE_MODS_LOCKED);
+}
+
+static void
+clutter_keymap_evdev_class_init (ClutterKeymapEvdevClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterKeymapClass *keymap_class = CLUTTER_KEYMAP_CLASS (klass);
+
+  object_class->finalize = clutter_keymap_evdev_finalize;
+
+  keymap_class->get_num_lock_state = clutter_keymap_evdev_get_num_lock_state;
+  keymap_class->get_caps_lock_state = clutter_keymap_evdev_get_caps_lock_state;
+}
+
+static void
+clutter_keymap_evdev_init (ClutterKeymapEvdev *keymap)
+{
+  struct xkb_context *ctx;
+  struct xkb_rule_names names;
+
+  names.rules = "evdev";
+  names.model = "pc105";
+  names.layout = option_xkb_layout;
+  names.variant = option_xkb_variant;
+  names.options = option_xkb_options;
+
+  ctx = xkb_context_new (0);
+  g_assert (ctx);
+  keymap->keymap = xkb_keymap_new_from_names (ctx, &names, 0);
+  xkb_context_unref (ctx);
+}
+
+void
+clutter_keymap_evdev_set_keyboard_map (ClutterKeymapEvdev *keymap,
+                                       struct xkb_keymap  *xkb_keymap)
+{
+  if (keymap->keymap)
+    xkb_keymap_unref (keymap->keymap);
+  keymap->keymap = xkb_keymap_ref (xkb_keymap);
+}
+
+struct xkb_keymap *
+clutter_keymap_evdev_get_keyboard_map (ClutterKeymapEvdev *keymap)
+{
+  return keymap->keymap;
+}

clutter/clutter/evdev/clutter-keymap-evdev.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018 Red Hat
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Author: Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#include "clutter-xkb-utils.h"
+#include "clutter-keymap.h"
+
+#define CLUTTER_TYPE_KEYMAP_EVDEV (clutter_keymap_evdev_get_type ())
+G_DECLARE_FINAL_TYPE (ClutterKeymapEvdev, clutter_keymap_evdev,
+                      CLUTTER, KEYMAP_EVDEV,
+                      ClutterKeymap)
+
+void                clutter_keymap_evdev_set_keyboard_map (ClutterKeymapEvdev *keymap,
+                                                           struct xkb_keymap  *xkb_keymap);
+struct xkb_keymap * clutter_keymap_evdev_get_keyboard_map (ClutterKeymapEvdev *keymap);

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

@@ -34,6 +34,7 @@
 #include "clutter-event-private.h"
 #include "clutter-input-device-evdev.h"
 #include "clutter-input-device-tool-evdev.h"
+#include "clutter-keymap-evdev.h"
 #include "clutter-main.h"
 
 /* Try to keep the pointer inside the stage. Hopefully no one is using
@@ -152,7 +153,8 @@ clutter_seat_evdev_new (ClutterDeviceManagerEvdev *manager_evdev)
   ClutterSeatEvdev *seat;
   ClutterInputDevice *device;
   ClutterStage *stage;
-  struct xkb_keymap *keymap;
+  ClutterKeymap *keymap;
+  struct xkb_keymap *xkb_keymap;
 
   seat = g_new0 (ClutterSeatEvdev, 1);
   if (!seat)
@@ -183,17 +185,19 @@ clutter_seat_evdev_new (ClutterDeviceManagerEvdev *manager_evdev)
   seat->repeat_delay = 250;     /* ms */
   seat->repeat_interval = 33;   /* ms */
 
-  keymap = _clutter_device_manager_evdev_get_keymap (manager_evdev);
-  if (keymap)
+  keymap = clutter_backend_get_keymap (clutter_get_default_backend ());
+  xkb_keymap = clutter_keymap_evdev_get_keyboard_map (CLUTTER_KEYMAP_EVDEV (keymap));
+
+  if (xkb_keymap)
     {
-      seat->xkb = xkb_state_new (keymap);
+      seat->xkb = xkb_state_new (xkb_keymap);
 
       seat->caps_lock_led =
-        xkb_keymap_led_get_index (keymap, XKB_LED_NAME_CAPS);
+        xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_CAPS);
       seat->num_lock_led =
-        xkb_keymap_led_get_index (keymap, XKB_LED_NAME_NUM);
+        xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_NUM);
       seat->scroll_lock_led =
-        xkb_keymap_led_get_index (keymap, XKB_LED_NAME_SCROLL);
+        xkb_keymap_led_get_index (xkb_keymap, XKB_LED_NAME_SCROLL);
     }
 
   return seat;
@@ -316,7 +320,13 @@ clutter_seat_evdev_notify_key (ClutterSeatEvdev   *seat,
   queue_event (event);
 
   if (update_keys && (changed_state & XKB_STATE_LEDS))
-    clutter_seat_evdev_sync_leds (seat);
+    {
+      ClutterBackend *backend;
+
+      backend = clutter_get_default_backend ();
+      g_signal_emit_by_name (clutter_backend_get_keymap (backend), "state-changed");
+      clutter_seat_evdev_sync_leds (seat);
+    }
 
   if (state == 0 ||             /* key release */
       !seat->repeat ||
@@ -766,6 +776,7 @@ discrete_to_direction (double discrete_dx,
     return CLUTTER_SCROLL_UP;
   else
     g_assert_not_reached ();
+  return 0;
 }
 
 void

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

@@ -29,6 +29,7 @@
 #include "clutter-private.h"
 #include "clutter-virtual-input-device.h"
 #include "evdev/clutter-input-device-evdev.h"
+#include "evdev/clutter-keymap-evdev.h"
 #include "evdev/clutter-seat-evdev.h"
 #include "evdev/clutter-virtual-input-device-evdev.h"
 
@@ -286,14 +287,14 @@ pick_keycode_for_keyval_in_current_group (ClutterVirtualInputDevice *virtual_dev
 {
   ClutterVirtualInputDeviceEvdev *virtual_evdev =
     CLUTTER_VIRTUAL_INPUT_DEVICE_EVDEV (virtual_device);
-  ClutterDeviceManager *manager;
+  ClutterKeymap *keymap;
   struct xkb_keymap *xkb_keymap;
   struct xkb_state  *state;
   guint keycode, layout;
   xkb_keycode_t min_keycode, max_keycode;
 
-  manager = clutter_virtual_input_device_get_manager (virtual_device);
-  xkb_keymap = _clutter_device_manager_evdev_get_keymap (CLUTTER_DEVICE_MANAGER_EVDEV (manager));
+  keymap = clutter_backend_get_keymap (clutter_get_default_backend ());
+  xkb_keymap = clutter_keymap_evdev_get_keyboard_map (CLUTTER_KEYMAP_EVDEV (keymap));
   state = virtual_evdev->seat->xkb;
 
   layout = xkb_state_serialize_layout (state, XKB_STATE_LAYOUT_EFFECTIVE);

clutter/clutter/meson.build

@@ -48,6 +48,7 @@ clutter_headers = [
   'clutter-input-method.h',
   'clutter-interval.h',
   'clutter-keyframe-transition.h',
+  'clutter-keymap.h',
   'clutter-keysyms.h',
   'clutter-layout-manager.h',
   'clutter-layout-meta.h',
@@ -134,6 +135,7 @@ clutter_sources = [
   'clutter-virtual-input-device.c',
   'clutter-interval.c',
   'clutter-keyframe-transition.c',
+  'clutter-keymap.c',
   'clutter-keysyms-table.c',
   'clutter-layout-manager.c',
   'clutter-layout-meta.c',
@@ -356,6 +358,7 @@ if have_native_backend
     'evdev/clutter-event-evdev.c',
     'evdev/clutter-input-device-evdev.c',
     'evdev/clutter-input-device-tool-evdev.c',
+    'evdev/clutter-keymap-evdev.c',
     'evdev/clutter-seat-evdev.c',
     'evdev/clutter-virtual-input-device-evdev.c',
     'evdev/clutter-xkb-utils.c',
@@ -367,6 +370,7 @@ if have_native_backend
     'evdev/clutter-device-manager-evdev.h',
     'evdev/clutter-input-device-evdev.h',
     'evdev/clutter-input-device-tool-evdev.h',
+    'evdev/clutter-keymap-evdev.h',
     'evdev/clutter-seat-evdev.h',
     'evdev/clutter-virtual-input-device-evdev.h',
     'evdev/clutter-xkb-utils.h',
@@ -491,7 +495,7 @@ clutter_marshal = gnome.genmarshal('clutter-marshal',
   prefix: '_clutter_marshal',
   sources: 'clutter-marshal.list',
   valist_marshallers: true,
-  extra_args: ['--prototypes', '--quiet'],
+  extra_args: ['--quiet'],
   install_dir: clutter_clutter_includedir,
   install_header: true,
 )
@@ -519,10 +523,12 @@ libmutter_clutter = shared_library(libmutter_clutter_name,
     cally_headers,
     cally_private_headers,
   ],
-  soversion: '0.0.0',
+  version: '0.0.0',
+  soversion: 0,
   c_args: clutter_c_args,
   include_directories: clutter_includes,
   dependencies: [clutter_deps],
+  gnu_symbol_visibility: 'hidden',
   link_with: [
     libmutter_cogl,
     libmutter_cogl_pango,

clutter/clutter/x11/clutter-backend-x11.c

@@ -807,6 +807,14 @@ clutter_backend_x11_get_keymap_direction (ClutterBackend *backend)
   return _clutter_keymap_x11_get_direction (backend_x11->keymap);
 }
 
+static ClutterKeymap *
+clutter_backend_x11_get_keymap (ClutterBackend *backend)
+{
+  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
+
+  return CLUTTER_KEYMAP (backend_x11->keymap);
+}
+
 static void
 clutter_backend_x11_class_init (ClutterBackendX11Class *klass)
 {
@@ -829,6 +837,7 @@ clutter_backend_x11_class_init (ClutterBackendX11Class *klass)
   backend_class->get_display = clutter_backend_x11_get_display;
 
   backend_class->get_keymap_direction = clutter_backend_x11_get_keymap_direction;
+  backend_class->get_keymap = clutter_backend_x11_get_keymap;
 }
 
 static void

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

@@ -97,9 +97,9 @@ translate_key_event (ClutterBackendX11       *backend_x11,
     _clutter_keymap_x11_get_is_modifier (backend_x11->keymap,
                                          event->key.hardware_keycode);
   event_x11->num_lock_set =
-    _clutter_keymap_x11_get_num_lock_state (backend_x11->keymap);
+    clutter_keymap_get_num_lock_state (CLUTTER_KEYMAP (backend_x11->keymap));
   event_x11->caps_lock_set =
-    _clutter_keymap_x11_get_caps_lock_state (backend_x11->keymap);
+    clutter_keymap_get_caps_lock_state (CLUTTER_KEYMAP (backend_x11->keymap));
 
   /* unicode_value is the printable representation */
   n = XLookupString (&xevent->xkey, buffer, sizeof (buffer) - 1, NULL, NULL);

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

@@ -1386,9 +1386,9 @@ clutter_device_manager_xi2_translate_event (ClutterEventTranslator *translator,
           _clutter_keymap_x11_get_is_modifier (backend_x11->keymap,
                                                event->key.hardware_keycode);
         event_x11->num_lock_set =
-          _clutter_keymap_x11_get_num_lock_state (backend_x11->keymap);
+          clutter_keymap_get_num_lock_state (CLUTTER_KEYMAP (backend_x11->keymap));
         event_x11->caps_lock_set =
-          _clutter_keymap_x11_get_caps_lock_state (backend_x11->keymap);
+          clutter_keymap_get_caps_lock_state (CLUTTER_KEYMAP (backend_x11->keymap));
 
         source_device = g_hash_table_lookup (manager_xi2->devices_by_id,
                                              GINT_TO_POINTER (xev->sourceid));

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

@@ -53,7 +53,7 @@ struct _DirectionCacheEntry
 
 struct _ClutterKeymapX11
 {
-  GObject parent_instance;
+  ClutterKeymap parent_instance;
 
   ClutterBackend *backend;
 
@@ -86,7 +86,7 @@ struct _ClutterKeymapX11
 
 struct _ClutterKeymapX11Class
 {
-  GObjectClass parent_class;
+  ClutterKeymapClass parent_class;
 };
 
 enum
@@ -104,7 +104,8 @@ static void clutter_event_translator_iface_init (ClutterEventTranslatorIface *if
 
 #define clutter_keymap_x11_get_type     _clutter_keymap_x11_get_type
 
-G_DEFINE_TYPE_WITH_CODE (ClutterKeymapX11, clutter_keymap_x11, G_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (ClutterKeymapX11, clutter_keymap_x11,
+                         CLUTTER_TYPE_KEYMAP,
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_EVENT_TRANSLATOR,
                                                 clutter_event_translator_iface_init));
 
@@ -215,12 +216,10 @@ static void
 update_locked_mods (ClutterKeymapX11 *keymap_x11,
                     gint              locked_mods)
 {
-#if 0
   gboolean old_caps_lock_state, old_num_lock_state;
 
   old_caps_lock_state = keymap_x11->caps_lock_state;
   old_num_lock_state  = keymap_x11->num_lock_state;
-#endif
 
   keymap_x11->caps_lock_state = (locked_mods & CLUTTER_LOCK_MASK) != 0;
   keymap_x11->num_lock_state  = (locked_mods & keymap_x11->num_lock_mask) != 0;
@@ -229,12 +228,9 @@ update_locked_mods (ClutterKeymapX11 *keymap_x11,
                 keymap_x11->num_lock_state ? "set" : "unset",
                 keymap_x11->caps_lock_state ? "set" : "unset");
 
-#if 0
-  /* Add signal to ClutterBackend? */
   if ((keymap_x11->caps_lock_state != old_caps_lock_state) ||
       (keymap_x11->num_lock_state != old_num_lock_state))
-    g_signal_emit_by_name (keymap_x11->backend, "key-lock-changed");
-#endif
+    g_signal_emit_by_name (keymap_x11, "state-changed");
 }
 
 /* the code to retrieve the keymap direction and cache it
@@ -524,10 +520,27 @@ clutter_keymap_x11_finalize (GObject *gobject)
   G_OBJECT_CLASS (clutter_keymap_x11_parent_class)->finalize (gobject);
 }
 
+static gboolean
+clutter_keymap_x11_get_num_lock_state (ClutterKeymap *keymap)
+{
+  ClutterKeymapX11 *keymap_x11 = CLUTTER_KEYMAP_X11 (keymap);
+
+  return keymap_x11->num_lock_state;
+}
+
+static gboolean
+clutter_keymap_x11_get_caps_lock_state (ClutterKeymap *keymap)
+{
+  ClutterKeymapX11 *keymap_x11 = CLUTTER_KEYMAP_X11 (keymap);
+
+  return keymap_x11->caps_lock_state;
+}
+
 static void
 clutter_keymap_x11_class_init (ClutterKeymapX11Class *klass)
 {
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterKeymapClass *keymap_class = CLUTTER_KEYMAP_CLASS (klass);
 
   obj_props[PROP_BACKEND] =
     g_param_spec_object ("backend",
@@ -539,6 +552,10 @@ clutter_keymap_x11_class_init (ClutterKeymapX11Class *klass)
   gobject_class->constructed = clutter_keymap_x11_constructed;
   gobject_class->set_property = clutter_keymap_x11_set_property;
   gobject_class->finalize = clutter_keymap_x11_finalize;
+
+  keymap_class->get_num_lock_state = clutter_keymap_x11_get_num_lock_state;
+  keymap_class->get_caps_lock_state = clutter_keymap_x11_get_caps_lock_state;
+
   g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
 }
 
@@ -612,22 +629,6 @@ _clutter_keymap_x11_get_key_group (ClutterKeymapX11    *keymap,
   return XkbGroupForCoreState (state);
 }
 
-gboolean
-_clutter_keymap_x11_get_num_lock_state (ClutterKeymapX11 *keymap)
-{
-  g_return_val_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap), FALSE);
-
-  return keymap->num_lock_state;
-}
-
-gboolean
-_clutter_keymap_x11_get_caps_lock_state (ClutterKeymapX11 *keymap)
-{
-  g_return_val_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap), FALSE);
-
-  return keymap->caps_lock_state;
-}
-
 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 
 /* XXX - yes, I know that XKeycodeToKeysym() has been deprecated; hopefully,

clutter/clutter/x11/xsettings/xsettings-client.c

@@ -480,7 +480,7 @@ xsettings_client_new_with_grab_funcs (Display             *display,
 {
   XSettingsClient *client;
   char buffer[256];
-  char *atom_names[3];
+  const char *atom_names[3];
   Atom atoms[3];
   
   client = malloc (sizeof *client);

clutter/meson.build

@@ -29,26 +29,30 @@ endif
 clutter_c_args += clutter_debug_c_args
 
 clutter_pkg_deps = [
-  gdk_pixbuf_dep,
+  atk_dep,
   cairo_gobject_dep,
   glib_dep,
   gobject_dep,
   gio_dep,
+  json_glib_dep,
+  pango_dep,
+]
+
+clutter_pkg_private_deps = [
+  gdk_pixbuf_dep,
   gthread_dep,
   gmodule_no_export_dep,
-  atk_dep,
   pangocairo_dep,
-  json_glib_dep,
 ]
 
 if have_pango_ft2
-  clutter_pkg_deps += [
+  clutter_pkg_private_deps += [
     pangoft2_dep,
   ]
 endif
 
 if have_wayland
-  clutter_pkg_deps += [
+  clutter_pkg_private_deps += [
     wayland_egl_dep,
     wayland_server_dep,
   ]
@@ -57,6 +61,8 @@ endif
 if have_x11
   clutter_pkg_deps += [
     x11_dep,
+  ]
+  clutter_pkg_private_deps += [
     xext_dep,
     xdamage_dep,
     xcomposite_dep,
@@ -66,7 +72,7 @@ if have_x11
 endif
 
 if have_native_backend
-  clutter_pkg_deps += [
+  clutter_pkg_private_deps += [
     libudev_dep,
     libinput_dep,
     xkbcommon_dep,
@@ -74,13 +80,14 @@ if have_native_backend
 endif
 
 if have_libwacom
-  clutter_pkg_deps += [
+  clutter_pkg_private_deps += [
     libwacom_dep,
   ]
 endif
 
 clutter_deps = [
   clutter_pkg_deps,
+  clutter_pkg_private_deps,
   libmutter_cogl_dep,
   m_dep
 ]

clutter/tests/conform/actor-offscreen-limit-max-size.c

@@ -1,119 +0,0 @@
-#define CLUTTER_ENABLE_EXPERIMENTAL_API
-#include <clutter/clutter.h>
-
-#define STAGE_WIDTH (300)
-#define STAGE_HEIGHT (300)
-
-typedef struct
-{
-  ClutterActor *stage;
-
-  ClutterActor *actor_group1;
-  ClutterEffect *blur_effect1;
-
-  ClutterActor *actor_group2;
-  ClutterEffect *blur_effect2;
-} Data;
-
-static void
-check_results (ClutterStage *stage, gpointer user_data)
-{
-  Data *data = user_data;
-  gfloat width, height;
-  ClutterRect rect;
-
-  clutter_offscreen_effect_get_target_rect (CLUTTER_OFFSCREEN_EFFECT (data->blur_effect1),
-                                            &rect);
-
-  width = clutter_rect_get_width (&rect);
-  height = clutter_rect_get_height (&rect);
-
-  if (g_test_verbose ())
-    g_print ("Checking effect1 size: %.2f x %.2f\n",
-             clutter_rect_get_width (&rect),
-             clutter_rect_get_height (&rect));
-
-  g_assert_cmpint (width, <, STAGE_WIDTH);
-  g_assert_cmpint (height, <, STAGE_HEIGHT);
-
-  clutter_offscreen_effect_get_target_rect (CLUTTER_OFFSCREEN_EFFECT (data->blur_effect2),
-                                            &rect);
-
-  width = clutter_rect_get_width (&rect);
-  height = clutter_rect_get_height (&rect);
-
-  if (g_test_verbose ())
-    g_print ("Checking effect2 size: %.2f x %.2f\n", width, height);
-
-  g_assert_cmpint (width, ==, STAGE_WIDTH);
-  g_assert_cmpint (height, ==, STAGE_HEIGHT);
-
-
-  clutter_main_quit ();
-}
-
-static ClutterActor *
-create_actor (gfloat x, gfloat y,
-              gfloat width, gfloat height,
-              const ClutterColor *color)
-{
-  return g_object_new (CLUTTER_TYPE_ACTOR,
-                       "x", x,
-                       "y", y,
-                       "width", width,
-                       "height", height,
-                       "background-color", color,
-                       NULL);
-}
-
-static void
-actor_offscreen_limit_max_size (void)
-{
-  Data data;
-
-  if (!cogl_features_available (COGL_FEATURE_OFFSCREEN))
-    return;
-
-  data.stage = clutter_test_get_stage ();
-  g_signal_connect (data.stage, "after-paint",
-                    G_CALLBACK (check_results), &data);
-  clutter_actor_set_size (data.stage, STAGE_WIDTH, STAGE_HEIGHT);
-
-  data.actor_group1 = clutter_actor_new ();
-  clutter_actor_add_child (data.stage, data.actor_group1);
-  data.blur_effect1 = clutter_blur_effect_new ();
-  clutter_actor_add_effect (data.actor_group1, data.blur_effect1);
-  clutter_actor_add_child (data.actor_group1,
-                           create_actor (10, 10,
-                                         100, 100,
-                                         CLUTTER_COLOR_Blue));
-  clutter_actor_add_child (data.actor_group1,
-                           create_actor (100, 100,
-                                         100, 100,
-                                         CLUTTER_COLOR_Gray));
-
-  data.actor_group2 = clutter_actor_new ();
-  clutter_actor_add_child (data.stage, data.actor_group2);
-  data.blur_effect2 = clutter_blur_effect_new ();
-  clutter_actor_add_effect (data.actor_group2, data.blur_effect2);
-  clutter_actor_add_child (data.actor_group2,
-                           create_actor (-10, -10,
-                                         100, 100,
-                                         CLUTTER_COLOR_Yellow));
-  clutter_actor_add_child (data.actor_group2,
-                           create_actor (250, 10,
-                                         100, 100,
-                                         CLUTTER_COLOR_ScarletRed));
-  clutter_actor_add_child (data.actor_group2,
-                           create_actor (10, 250,
-                                         100, 100,
-                                         CLUTTER_COLOR_Yellow));
-
-  clutter_actor_show (data.stage);
-
-  clutter_main ();
-}
-
-CLUTTER_TEST_SUITE (
-  CLUTTER_TEST_UNIT ("/actor/offscreen/limit-max-size", actor_offscreen_limit_max_size)
-)

clutter/tests/conform/actor-offscreen-redirect.c

@@ -189,10 +189,11 @@ verify_redraws (gpointer user_data)
   clutter_actor_queue_redraw (data->child);
   verify_redraw (data, 1);
 
-  /* Modifying the transformation on the parent should cause a
-     redraw */
+  /* Modifying the transformation on the parent should not cause a redraw,
+     since the FBO stores pre-transformed rendering that can be reused with
+     any transformation. */
   clutter_actor_set_anchor_point (data->parent_container, 0, 1);
-  verify_redraw (data, 1);
+  verify_redraw (data, 0);
 
   /* Redrawing an unrelated actor shouldn't cause a redraw */
   clutter_actor_set_position (data->unrelated_actor, 0, 1);

clutter/tests/conform/meson.build

@@ -19,7 +19,6 @@ clutter_conform_tests_actor_tests = [
   'actor-iter',
   'actor-layout',
   'actor-meta',
-  'actor-offscreen-limit-max-size',
   'actor-offscreen-redirect',
   'actor-paint-opacity',
   'actor-pick',

clutter/tests/interactive/test-actors.c

@@ -27,6 +27,9 @@ typedef struct SuperOH
 
 static gint n_hands = NHANDS;
 
+int
+test_actors_main (int argc, char *argv[]);
+
 static GOptionEntry super_oh_entries[] = {
   {
     "num-hands", 'n',

clutter/tests/interactive/test-animation.c

@@ -4,6 +4,12 @@
 
 static gboolean is_expanded = FALSE;
 
+int
+test_animation_main (int argc, char *argv[]);
+
+const char *
+test_animation_describe (void);
+
 static void
 on_rect_transitions_completed (ClutterActor *actor)
 {

clutter/tests/interactive/test-animator.c

@@ -5,6 +5,10 @@
 
 static ClutterAnimator *animator;
 
+gint
+test_animator_main (gint    argc,
+                    gchar **argv);
+
 static ClutterActor *new_rect (gint r,
                                gint g,
                                gint b,

clutter/tests/interactive/test-bind-constraint.c

@@ -47,6 +47,12 @@ static const gchar *desaturare_glsl_shader =
 
 static gboolean      is_expanded = FALSE;
 
+const char *
+test_bind_constraint_describe (void);
+
+int
+test_bind_constraint_main (int argc, char *argv[]);
+
 static gboolean
 on_button_release (ClutterActor *actor,
                    ClutterEvent *event,

clutter/tests/interactive/test-binding-pool.c

@@ -31,6 +31,14 @@ struct _KeyGroupClass
                      ClutterActor *child);
 };
 
+GType key_group_get_type (void);
+
+int
+test_binding_pool_main (int argc, char *argv[]);
+
+const char *
+test_binding_pool_describe (void);
+
 G_DEFINE_TYPE (KeyGroup, key_group, CLUTTER_TYPE_ACTOR)
 
 enum

clutter/tests/interactive/test-cairo-clock.c

@@ -3,6 +3,12 @@
 #include <cairo.h>
 #include <clutter/clutter.h>
 
+int
+test_cairo_clock_main (int argc, char *argv[]);
+
+const char *
+test_cairo_clock_describe (void);
+
 static gboolean
 draw_clock (ClutterCanvas *canvas,
             cairo_t       *cr,

clutter/tests/interactive/test-cairo-flowers.c

@@ -25,6 +25,12 @@ Flower;
 
 static ClutterActor *stage = NULL;
 
+int
+test_cairo_flowers_main (int argc, char **argv);
+
+const char *
+test_cairo_flowers_describe (void);
+
 static gboolean
 draw_flower (ClutterCanvas *canvas,
              cairo_t       *cr,

clutter/tests/interactive/test-cogl-multitexture.c

@@ -30,6 +30,11 @@ typedef struct _TestMultiLayerMaterialState
 
 } TestMultiLayerMaterialState;
 
+int
+test_cogl_multitexture_main (int argc, char *argv[]);
+
+const char *
+test_cogl_multitexture_describe (void);
 
 static void
 frame_cb (ClutterTimeline  *timeline,

clutter/tests/interactive/test-cogl-offscreen.c

@@ -56,6 +56,12 @@ struct _TestCoglboxClass
 
 static GType test_coglbox_get_type (void) G_GNUC_CONST;
 
+int
+test_cogl_offscreen_main (int argc, char *argv[]);
+
+const char *
+test_cogl_offscreen_describe (void);
+
 G_END_DECLS
 
 /* Coglbox private declaration
@@ -153,7 +159,7 @@ test_coglbox_dispose (GObject *object)
  * This sets up a Clutter like coordinate system for a Cogl
  * framebuffer
  */
-void
+static void
 setup_viewport (unsigned int width,
                 unsigned int height,
                 float fovy,

clutter/tests/interactive/test-cogl-point-sprites.c

@@ -51,6 +51,12 @@ struct _Data
   CoglMaterial *material;
 };
 
+int
+test_cogl_point_sprites_main (int argc, char *argv[]);
+
+const char *
+test_cogl_point_sprites_describe (void);
+
 static CoglHandle
 generate_round_texture (void)
 {

clutter/tests/interactive/test-cogl-shader-glsl.c

@@ -7,10 +7,13 @@
 
 typedef struct
 {
-  char *name;
-  char *source;
+  const char *name;
+  const char *source;
 } ShaderSource;
 
+int
+test_cogl_shader_glsl_main (int argc, char *argv[]);
+
 /* a couple of boilerplate defines that are common amongst all the
  * sample shaders
  */
@@ -51,22 +54,6 @@ static ShaderSource shaders[]=
     {"box-blur",
      FRAGMENT_SHADER_VARS
 
-#if GPU_SUPPORTS_DYNAMIC_BRANCHING
-     "uniform float radius;"
-     FRAGMENT_SHADER_BEGIN
-     "float u, v;"
-     "int count = 1;"
-     "for (u=-radius;u<radius;u++)"
-     "  for (v=-radius;v<radius;v++)"
-     "    {"
-     "      color += texture2D(tex, "
-     "          vec2(cogl_tex_coord_in[0].s + u * 2.0 * x_step, "
-     "               cogl_tex_coord_in[0].t + v * 2.0 * y_step));"
-     "      count ++;"
-     "    }"
-     "color = color / float(count);"
-     FRAGMENT_SHADER_END
-#else
      "vec4 get_rgba_rel(sampler2D tex, float dx, float dy)"
      "{"
      "  return texture2D (tex, cogl_tex_coord_in[0].st "
@@ -86,7 +73,6 @@ static ShaderSource shaders[]=
      "  color += get_rgba_rel (tex,  x_step,  y_step); count++;"
      "  color = color / count;"
      FRAGMENT_SHADER_END
-#endif
     },
 
     {"invert",

clutter/tests/interactive/test-cogl-tex-convert.c

@@ -56,6 +56,12 @@ struct _TestCoglboxClass
 
 static GType test_coglbox_get_type (void) G_GNUC_CONST;
 
+int
+test_cogl_tex_convert_main (int argc, char *argv[]);
+
+const char *
+test_cogl_tex_convert_describe (void);
+
 G_END_DECLS
 
 /* Coglbox private declaration

clutter/tests/interactive/test-cogl-tex-foreign.c

@@ -60,6 +60,9 @@ typedef struct _TestCoglbox        TestCoglbox;
 typedef struct _TestCoglboxClass   TestCoglboxClass;
 typedef struct _TestCoglboxPrivate TestCoglboxPrivate;
 
+const char *
+test_cogl_tex_foreign_describe (void);
+
 struct _TestCoglbox
 {
   ClutterActor           parent;
@@ -116,6 +119,9 @@ G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
 #define TEST_COGLBOX_GET_PRIVATE(obj) \
 (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
 
+int
+test_cogl_tex_foreign_main (int argc, char *argv[]);
+
 /* Coglbox implementation
  *--------------------------------------------------*/
 

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

@@ -56,6 +56,12 @@ struct _TestCoglboxClass
 
 static GType test_coglbox_get_type (void) G_GNUC_CONST;
 
+int
+test_cogl_tex_polygon_main (int argc, char *argv[]);
+
+const char *
+test_cogl_tex_polygon_describe (void);
+
 G_END_DECLS
 
 /* Coglbox private declaration

clutter/tests/interactive/test-cogl-tex-tile.c

@@ -57,6 +57,12 @@ struct _TestCoglboxClass
 
 static GType test_coglbox_get_type (void) G_GNUC_CONST;
 
+int
+test_cogl_tex_tile_main (int argc, char *argv[]);
+
+const char *
+test_cogl_tex_tile_describe (void);
+
 G_END_DECLS
 
 /* Coglbox private declaration

clutter/tests/interactive/test-cogl-vertex-buffer.c

@@ -53,6 +53,12 @@ typedef struct _TestState
   guint            frame_id;
 } TestState;
 
+int
+test_cogl_vertex_buffer_main (int argc, char *argv[]);
+
+const char *
+test_cogl_vertex_buffer_describe (void);
+
 static void
 frame_cb (ClutterTimeline *timeline,
           gint             elapsed_msecs,

clutter/tests/interactive/test-content.c

@@ -19,6 +19,14 @@ typedef struct _ColorContentClass {
 
 static void clutter_content_iface_init (ClutterContentIface *iface);
 
+GType color_content_get_type (void);
+
+int
+test_content_main (int argc, char *argv[]);
+
+const char *
+test_content_describe (void);
+
 G_DEFINE_TYPE_WITH_CODE (ColorContent, color_content, G_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTENT,
                                                 clutter_content_iface_init))

clutter/tests/interactive/test-devices.c

@@ -12,6 +12,9 @@ typedef struct {
   GHashTable *devices;
 } TestDevicesApp;
 
+int
+test_devices_main (int argc, char **argv);
+
 static const gchar *
 device_type_name (ClutterInputDevice *device)
 {

clutter/tests/interactive/test-easing.c

@@ -55,6 +55,12 @@ static ClutterActor *easing_mode_label = NULL;
 
 static ClutterAnimation *last_animation = NULL;
 
+int
+test_easing_main (int argc, char *argv[]);
+
+const char *
+test_easing_describe (void);
+
 /* recenter_bouncer:
  *
  * repositions (through an animation) the bouncer at the center of the stage

clutter/tests/interactive/test-events.c

@@ -4,6 +4,12 @@
 
 gboolean IsFullScreen = FALSE, IsMotion = TRUE;
 
+int
+test_events_main (int argc, char *argv[]);
+
+const char *
+test_events_describe (void);
+
 static const gchar *
 get_event_type_name (const ClutterEvent *event)
 {
@@ -53,7 +59,7 @@ get_event_type_name (const ClutterEvent *event)
 static gchar *
 get_event_state_string (const ClutterEvent *event)
 {
-  gchar *mods[18];
+  const char *mods[18];
   int i = 0;
   ClutterModifierType state = clutter_event_get_state (event);
 
@@ -96,7 +102,7 @@ get_event_state_string (const ClutterEvent *event)
     mods[i++] = "-";
 
   mods[i] = NULL;
-  return g_strjoinv (",", mods);
+  return g_strjoinv (",", (char **) mods);
 }
 
 static void
@@ -422,15 +428,15 @@ test_events_main (int argc, char *argv[])
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Events");
   clutter_actor_set_name (stage, "Stage");
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
-  g_signal_connect (stage, "event", G_CALLBACK (input_cb), "stage");
+  g_signal_connect (stage, "event", G_CALLBACK (input_cb), (char *) "stage");
   g_signal_connect (stage, "fullscreen", 
-		    G_CALLBACK (stage_state_cb), "fullscreen");
+		    G_CALLBACK (stage_state_cb), (char *) "fullscreen");
   g_signal_connect (stage, "unfullscreen", 
-		    G_CALLBACK (stage_state_cb), "unfullscreen");
+		    G_CALLBACK (stage_state_cb), (char *) "unfullscreen");
   g_signal_connect (stage, "activate", 
-		    G_CALLBACK (stage_state_cb), "activate");
+		    G_CALLBACK (stage_state_cb), (char *) "activate");
   g_signal_connect (stage, "deactivate", 
-		    G_CALLBACK (stage_state_cb), "deactivate");
+		    G_CALLBACK (stage_state_cb), (char *) "deactivate");
 
   focus_box = clutter_rectangle_new_with_color (CLUTTER_COLOR_Black);
   clutter_actor_set_name (focus_box, "Focus Box");
@@ -442,7 +448,7 @@ test_events_main (int argc, char *argv[])
   clutter_actor_set_position (actor, 100, 100);
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (input_cb), "red box");
+  g_signal_connect (actor, "event", G_CALLBACK (input_cb), (char *) "red box");
   g_signal_connect (actor, "key-focus-in", G_CALLBACK (key_focus_in_cb),
 		    focus_box);
   /* Toggle motion - enter/leave capture */
@@ -457,7 +463,7 @@ test_events_main (int argc, char *argv[])
   clutter_actor_set_position (actor, 250, 100);
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (input_cb), "green box");
+  g_signal_connect (actor, "event", G_CALLBACK (input_cb), (char *) "green box");
   g_signal_connect (actor, "key-focus-in", G_CALLBACK (key_focus_in_cb),
 		    focus_box);
   g_signal_connect (actor, "captured-event", G_CALLBACK (capture_cb), NULL);
@@ -468,7 +474,7 @@ test_events_main (int argc, char *argv[])
   clutter_actor_set_position (actor, 400, 100);
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (input_cb), "blue box");
+  g_signal_connect (actor, "event", G_CALLBACK (input_cb), (char *) "blue box");
   g_signal_connect (actor, "key-focus-in", G_CALLBACK (key_focus_in_cb),
 		    focus_box);
   /* Fullscreen */
@@ -481,7 +487,7 @@ test_events_main (int argc, char *argv[])
   clutter_actor_set_size (actor, 400, 50);
   clutter_actor_set_position (actor, 100, 250);
   clutter_container_add (CLUTTER_CONTAINER(stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (input_cb), "blue box");
+  g_signal_connect (actor, "event", G_CALLBACK (input_cb), (char *) "blue box");
   g_signal_connect (actor, "key-focus-in", G_CALLBACK (key_focus_in_cb),
 		    focus_box);
   g_signal_connect (stage, "key-focus-in", G_CALLBACK (key_focus_in_cb),
@@ -493,7 +499,7 @@ test_events_main (int argc, char *argv[])
   clutter_actor_set_size (actor, 100, 100);
   clutter_actor_set_reactive (actor, TRUE);
 
-  g_signal_connect (actor, "event", G_CALLBACK (input_cb), "yellow box");
+  g_signal_connect (actor, "event", G_CALLBACK (input_cb), (char *) "yellow box");
 
   /* note group not reactive */
   group = clutter_group_new ();

clutter/tests/interactive/test-fbo.c

@@ -8,7 +8,13 @@
 #define STAGE_WIDTH   800
 #define STAGE_HEIGHT  600
 
-ClutterActor *
+int
+test_fbo_main (int argc, char *argv[]);
+
+const char *
+test_fbo_describe (void);
+
+static ClutterActor *
 make_source (void)
 {
   ClutterActor *source, *actor;

clutter/tests/interactive/test-grab.c

@@ -1,6 +1,12 @@
 #include <gmodule.h>
 #include <clutter/clutter.h>
 
+int
+test_grab_main (int argc, char *argv[]);
+
+const char *
+test_grab_describe (void);
+
 static void
 stage_state_cb (ClutterStage    *stage,
 		gpointer         data)
@@ -211,22 +217,22 @@ test_grab_main (int argc, char *argv[])
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Grabs");
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   g_signal_connect (stage, "event",
-                    G_CALLBACK (debug_event_cb), "stage");
+                    G_CALLBACK (debug_event_cb), (char *) "stage");
   g_signal_connect (stage, "fullscreen", 
-		    G_CALLBACK (stage_state_cb), "fullscreen");
+		    G_CALLBACK (stage_state_cb), (char *) "fullscreen");
   g_signal_connect (stage, "unfullscreen", 
-		    G_CALLBACK (stage_state_cb), "unfullscreen");
+		    G_CALLBACK (stage_state_cb), (char *) "unfullscreen");
   g_signal_connect (stage, "activate", 
-		    G_CALLBACK (stage_state_cb), "activate");
+		    G_CALLBACK (stage_state_cb), (char *) "activate");
   g_signal_connect (stage, "deactivate", 
-		    G_CALLBACK (stage_state_cb), "deactivate");
+		    G_CALLBACK (stage_state_cb), (char *) "deactivate");
 
   actor = clutter_rectangle_new_with_color (&rcol);
   clutter_actor_set_size (actor, 100, 100);
   clutter_actor_set_position (actor, 100, 100);
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "red box");
+  g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), (char *) "red box");
   g_signal_connect (actor, "button-press-event",
                     G_CALLBACK (grab_pointer_cb), NULL);
   g_signal_connect (actor, "button-release-event",
@@ -237,7 +243,7 @@ test_grab_main (int argc, char *argv[])
   clutter_actor_set_position (actor, 100, 300);
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
-  g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "yellow box");
+  g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), (char *) "yellow box");
   g_signal_connect (actor, "button-press-event",
                     G_CALLBACK (toggle_grab_pointer_cb), NULL);
 
@@ -247,7 +253,7 @@ test_grab_main (int argc, char *argv[])
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
   g_signal_connect (actor, "event",
-                    G_CALLBACK (debug_event_cb), "blue box");
+                    G_CALLBACK (debug_event_cb), (char *) "blue box");
   g_signal_connect (actor, "button-press-event",
                     G_CALLBACK (grab_pointer_cb), NULL);
   g_signal_connect (actor, "button-release-event",
@@ -259,7 +265,7 @@ test_grab_main (int argc, char *argv[])
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
   g_signal_connect (actor, "event",
-                    G_CALLBACK (debug_event_cb), "green box");
+                    G_CALLBACK (debug_event_cb), (char *) "green box");
   g_signal_connect (actor, "button-press-event",
                     G_CALLBACK (green_press_cb), NULL);
 
@@ -270,7 +276,7 @@ test_grab_main (int argc, char *argv[])
   clutter_actor_set_reactive (actor, TRUE);
   clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL);
   g_signal_connect (actor, "event",
-                    G_CALLBACK (debug_event_cb), "cyan box");
+                    G_CALLBACK (debug_event_cb), (char *) "cyan box");
   g_signal_connect (actor, "button-press-event",
                     G_CALLBACK (cyan_press_cb), NULL);
 

clutter/tests/interactive/test-image.c

@@ -20,6 +20,14 @@ typedef struct _SolidContentClass {
 
 static void clutter_content_iface_init (ClutterContentIface *iface);
 
+GType solid_content_get_type (void);
+
+const char *
+test_image_describe (void);
+
+int
+test_image_main (int argc, char *argv[]);
+
 G_DEFINE_TYPE_WITH_CODE (SolidContent, solid_content, G_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTENT,
                                                 clutter_content_iface_init))

clutter/tests/interactive/test-keyframe-transition.c

@@ -11,6 +11,12 @@ static const ClutterColor colors[] = {
 #define PADDING         (64.0f)
 #define SIZE            (64.0f)
 
+const char *
+test_keyframe_transition_describe (void);
+
+int
+test_keyframe_transition_main (int argc, char *argv[]);
+
 static void
 on_transition_stopped (ClutterActor *actor,
                        const gchar  *transition_name,

clutter/tests/interactive/test-layout.c

@@ -48,6 +48,14 @@ struct _MyThingPrivate
   guint   use_transformed_box : 1;
 };
 
+GType my_thing_get_type (void);
+
+int
+test_layout_main (int argc, char *argv[]);
+
+const char *
+test_layout_describe (void);
+
 G_DEFINE_TYPE_WITH_PRIVATE (MyThing, my_thing, CLUTTER_TYPE_ACTOR)
 
 #define MY_THING_GET_PRIVATE(obj)    \
@@ -417,7 +425,7 @@ my_thing_init (MyThing *thing)
   thing->priv = MY_THING_GET_PRIVATE (thing);
 }
 
-ClutterActor *
+static ClutterActor *
 my_thing_new (gfloat padding,
               gfloat spacing)
 {

clutter/tests/interactive/test-multistage.c

@@ -4,6 +4,9 @@
 static GList *stages = NULL;
 static gint n_stages = 1;
 
+int
+test_multistage_main (int argc, char *argv[]);
+
 static gboolean
 tex_button_cb (ClutterActor    *actor,
                ClutterEvent    *event,

clutter/tests/interactive/test-paint-wrapper.c

@@ -56,6 +56,12 @@ static GOptionEntry super_oh_entries[] = {
   { NULL }
 };
 
+int
+test_paint_wrapper_main (int argc, char *argv[]);
+
+const char *
+test_paint_wrapper_describe (void);
+
 static gboolean
 on_button_press_event (ClutterActor *actor,
                        ClutterEvent *event,

clutter/tests/interactive/test-path-constraint.c

@@ -11,6 +11,10 @@
 
 static gboolean toggled = FALSE;
 
+int
+test_path_constraint_main (int   argc,
+                           char *argv[]);
+
 static gboolean
 on_button_press (ClutterActor *actor,
                  const ClutterEvent *event,

clutter/tests/interactive/test-pixmap.c

@@ -23,6 +23,12 @@
 static gboolean disable_x11 = FALSE;
 static gboolean disable_animation = FALSE;
 
+int
+test_pixmap_main (int argc, char **argv);
+
+const char *
+test_pixmap_describe (void);
+
 static GOptionEntry g_options[] =
 {
   { "disable-x11",
@@ -131,7 +137,7 @@ stage_button_press_cb (ClutterActor    *actor,
   return CLUTTER_EVENT_STOP;
 }
 
-Pixmap
+static Pixmap
 create_pixmap (guint *width, guint *height, guint *depth)
 {
   Display *dpy = clutter_x11_get_default_display ();

clutter/tests/interactive/test-rotate-zoom.c

@@ -26,6 +26,12 @@
 #define STAGE_WIDTH 800
 #define STAGE_HEIGHT 550
 
+int
+test_rotate_zoom_main (int argc, char *argv[]);
+
+const char *
+test_rotate_zoom_describe (void);
+
 static ClutterActor *
 create_hand (void)
 {

clutter/tests/interactive/test-scale.c

@@ -18,6 +18,12 @@ static const ClutterGravity gravities[] = {
 static gint gindex = 0;
 static ClutterActor *label;
 
+int
+test_scale_main (int argc, char *argv[]);
+
+const char *
+test_scale_describe (void);
+
 static void
 set_next_gravity (ClutterActor *actor)
 {

clutter/tests/interactive/test-script.c

@@ -10,6 +10,9 @@
 static ClutterScript *script = NULL;
 static guint merge_id = 0;
 
+int
+test_script_main (int argc, char *argv[]);
+
 static const gchar *test_unmerge =
 "["
 "  {"
@@ -75,28 +78,6 @@ static const gchar *test_behaviour =
 "  }"
 "]";
 
-gdouble
-sine_alpha (ClutterAlpha *alpha,
-            gpointer      dummy G_GNUC_UNUSED)
-{
-  ClutterTimeline *timeline = clutter_alpha_get_timeline (alpha);
-
-  return sin (clutter_timeline_get_progress (timeline) * G_PI);
-}
-
-gdouble
-double_ramp_alpha (ClutterAlpha *alpha,
-                   gpointer      dummy G_GNUC_UNUSED)
-{
-  ClutterTimeline *timeline = clutter_alpha_get_timeline (alpha);
-  gdouble progress = clutter_timeline_get_progress (timeline);
-
-  if (progress >= 0.5)
-    return 1.0 - progress;
-
-  return progress;
-}
-
 static gboolean
 blue_button_press (ClutterActor       *actor,
                    ClutterButtonEvent *event,

clutter/tests/interactive/test-scrolling.c

@@ -20,6 +20,9 @@ static const gchar *rect_color[N_RECTS] = {
 static ClutterActor *rectangle[N_RECTS]; 
 static ClutterActor *viewport = NULL;
 
+int
+test_scrolling_main (int argc, char *argv[]);
+
 static void
 on_drag_end (ClutterDragAction   *action,
              ClutterActor        *actor,

clutter/tests/interactive/test-shader-effects.c

@@ -7,6 +7,9 @@
 
 #include <clutter/clutter.h>
 
+int
+test_shader_effects_main (int argc, char *argv[]);
+
 G_MODULE_EXPORT int
 test_shader_effects_main (int argc, char *argv[])
 {

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

@@ -16,17 +16,23 @@ struct _CallbackData
   guint idle_source;
 };
 
+int
+test_stage_read_pixels_main (int argc, char **argv);
+
+const char *
+test_stage_read_pixels_describe (void);
+
 static ClutterActor *
 make_label (void)
 {
   ClutterActor *label;
   gchar *text;
-  gchar *argv[] = { "ls", "--help", NULL };
+  const char *argv[] = { "ls", "--help", NULL };
 
   label = clutter_text_new ();
   clutter_text_set_font_name (CLUTTER_TEXT (label), "Sans 10");
 
-  if (g_spawn_sync (NULL, argv, NULL,
+  if (g_spawn_sync (NULL, (char **) argv, NULL,
 		    G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_SEARCH_PATH,
 		    NULL, NULL, &text, NULL, NULL, NULL))
     {

clutter/tests/interactive/test-stage-sizing.c

@@ -2,6 +2,12 @@
 #include <gmodule.h>
 #include <clutter/clutter.h>
 
+int
+test_stage_sizing_main (int argc, char *argv[]);
+
+const char *
+test_stage_sizing_describe (void);
+
 static gboolean
 fullscreen_clicked_cb (ClutterStage *stage)
 {

clutter/tests/interactive/test-state-animator.c

@@ -6,6 +6,13 @@
 static ClutterState    *state;
 static ClutterAnimator *animator;
 
+gint
+test_state_animator_main (gint    argc,
+                          gchar **argv);
+
+const char *
+test_state_animator_describe (void);
+
 static gboolean press_event (ClutterActor *actor,
                              ClutterEvent *event,
                              gpointer      user_data)

clutter/tests/interactive/test-state-script.c

@@ -6,15 +6,8 @@
 
 #define TEST_STATE_SCRIPT_FILE  "test-script-signals.json"
 
-gboolean
-on_button_press (ClutterActor *actor,
-                 ClutterEvent *event,
-                 gpointer      dummy G_GNUC_UNUSED)
-{
-  g_print ("Button pressed!\n");
-
-  return FALSE;
-}
+int
+test_state_script_main (int argc, char *argv[]);
 
 G_MODULE_EXPORT int
 test_state_script_main (int argc, char *argv[])

clutter/tests/interactive/test-state.c

@@ -13,6 +13,12 @@
 #define ROWS  (STAGE_HEIGHT/ACTOR_HEIGHT)
 #define TOTAL (ROWS*COLS)
 
+gint
+test_state_main (gint    argc,
+                 gchar **argv);
+
+const char *
+test_state_describe (void);
 
 static gboolean press_event (ClutterActor *actor,
                              ClutterEvent *event,

clutter/tests/interactive/test-swipe-action.c

@@ -7,6 +7,12 @@ enum {
   BOTH          = 2
 };
 
+int
+test_swipe_action_main (int argc, char *argv[]);
+
+const char *
+test_swipe_action_describe (void);
+
 static void
 swept_cb (ClutterSwipeAction    *action,
           ClutterActor          *actor,

clutter/tests/interactive/test-table-layout.c

@@ -9,6 +9,12 @@
 
 #define FONT "Sans 12"
 
+int
+test_table_layout_main (int argc, char *argv[]);
+
+const char *
+test_table_layout_describe (void);
+
 static void
 set_text (ClutterActor *actor, const gchar *text)
 {

clutter/tests/interactive/test-text-field.c

@@ -2,6 +2,13 @@
 #include <gmodule.h>
 #include <clutter/clutter.h>
 
+gint
+test_text_field_main (gint    argc,
+                      gchar **argv);
+
+const char *
+test_text_field_describe (void);
+
 static void
 on_entry_activate (ClutterText *text,
                    gpointer     data)

clutter/tests/interactive/test-text.c

@@ -10,6 +10,13 @@ static const gchar *runes =
 "ᛋᚳᛖᚪᛚ᛫ᚦᛖᚪᚻ᛫ᛗᚪᚾᚾᚪ᛫ᚷᛖᚻᚹᛦᛚᚳ᛫ᛗᛁᚳᛚᚢᚾ᛫ᚻᛦᛏ᛫ᛞᚫᛚᚪᚾ\n"
 "ᚷᛁᚠ᛫ᚻᛖ᛫ᚹᛁᛚᛖ᛫ᚠᚩᚱ᛫ᛞᚱᛁᚻᛏᚾᛖ᛫ᛞᚩᛗᛖᛋ᛫ᚻᛚᛇᛏᚪᚾ᛬\n";
 
+gint
+test_text_main (gint    argc,
+                gchar **argv);
+
+const char *
+test_text_describe (void);
+
 G_MODULE_EXPORT gint
 test_text_main (gint    argc,
                 gchar **argv)

clutter/tests/interactive/test-texture-async.c

@@ -11,6 +11,12 @@ enum
 
 static ClutterActor *stage = NULL;
 
+const char *
+test_texture_async_describe (void);
+
+gint
+test_texture_async_main (int argc, char *argv[]);
+
 static void
 on_load_finished (ClutterTexture *texture,
                   const GError   *error,

clutter/tests/interactive/test-texture-material.c

@@ -3,6 +3,9 @@
 #include <gmodule.h>
 #include <clutter/clutter.h>
 
+int
+test_texture_material_main (int argc, char *argv[]);
+
 G_MODULE_EXPORT int
 test_texture_material_main (int argc, char *argv[])
 {

clutter/tests/interactive/test-texture-quality.c

@@ -2,6 +2,12 @@
 #include <gmodule.h>
 #include <clutter/clutter.h>
 
+gint
+test_texture_quality_main (int argc, char *argv[]);
+
+const char *
+test_texture_quality_describe (void);
+
 /* each time the timeline animating the label completes, swap the direction */
 static void
 timeline_completed (ClutterTimeline *timeline,

clutter/tests/interactive/test-texture-slicing.c

@@ -3,7 +3,13 @@
 
 #include <clutter/clutter.h>
 
-guchar*
+int
+test_textures_main (int argc, char *argv[]);
+
+const char *
+test_texture_slicing_describe (void);
+
+static guchar *
 make_rgba_data (int width, int height, int bpp, int has_alpha, int *rowstride_p)
 {
 #define CHECK_SIZE 20

clutter/tests/interactive/test-touch-events.c

@@ -45,6 +45,12 @@ static const ClutterColor static_colors[] = {
 };
 static GHashTable *sequence_to_color = NULL;
 
+int
+test_touch_events_main (int argc, char *argv[]);
+
+const char *
+test_touch_events_describe (void);
+
 static void
 canvas_paint (ClutterCairoTexture *canvas)
 {

clutter/tests/performance/test-common.h

@@ -7,7 +7,8 @@ static gint testframes = 0;
 static float testmaxtime = 1.0;
 
 /* initialize environment to be suitable for fps testing */
-void clutter_perf_fps_init (void)
+static inline void
+clutter_perf_fps_init (void)
 {
   /* Force not syncing to vblank, we want free-running maximum FPS */
   g_setenv ("vblank_mode", "0", FALSE);
@@ -27,17 +28,20 @@ void clutter_perf_fps_init (void)
 static void perf_stage_paint_cb (ClutterStage *stage, gpointer *data);
 static gboolean perf_fake_mouse_cb (gpointer stage);
 
-void clutter_perf_fps_start (ClutterStage *stage)
+static inline void
+clutter_perf_fps_start (ClutterStage *stage)
 {
   g_signal_connect (stage, "paint", G_CALLBACK (perf_stage_paint_cb), NULL);
 }
 
-void clutter_perf_fake_mouse (ClutterStage *stage)
+static inline void
+clutter_perf_fake_mouse (ClutterStage *stage)
 {
   clutter_threads_add_timeout (1000/60, perf_fake_mouse_cb, stage);
 }
 
-void clutter_perf_fps_report (const gchar *id)
+static inline void
+clutter_perf_fps_report (const gchar *id)
 {
   g_print ("\n@ %s: %.2f fps \n",
        id, testframes / g_timer_elapsed (testtimer, NULL));

cogl/cogl-gles2/libmutter-cogl-gles2.map

@@ -1,6 +1,4 @@
 {
-global:
-  gl*;
 local:
   *;
-}
+};

cogl/cogl-gles2/meson.build

@@ -8,16 +8,20 @@ cogl_gles2_sources = [
   'cogl-gles2-api.c',
 ]
 
+libmutter_cogl_gles2_map = 'libmutter-cogl-gles2.map'
+libmutter_cogl_gles2_link_args = [
+  '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(),
+      libmutter_cogl_gles2_map),
+]
 libmutter_cogl_gles2 = shared_library('mutter-cogl-gles2-' + libmutter_api_version,
   sources: [cogl_gles2_sources, cogl_gles2_public_headers],
-  soversion: '0.0.0',
+  version: '0.0.0',
+  soversion: 0,
   c_args: cogl_c_args,
   include_directories: [cogl_includepath, cogl_path_includepath],
-  link_depends: 'libmutter-cogl-gles2.map',
-  dependencies: [
-    cogl_deps,
-    libmutter_cogl_dep
-  ],
+  link_depends: libmutter_cogl_gles2_map,
+  link_args: libmutter_cogl_gles2_link_args,
+  dependencies: libmutter_cogl_dep,
   install_rpath: pkglibdir,
   install_dir: pkglibdir,
   install: true,

cogl/cogl-pango/libmutter-cogl-pango.map

@@ -3,4 +3,4 @@ global:
   cogl_pango_*;
 local:
   *;
-}
+};

cogl/cogl-pango/meson.build

@@ -15,18 +15,24 @@ cogl_pango_public_headers = [
 ]
 
 cogl_pango_deps = [
-  cogl_deps,
   pango_dep,
   pangocairo_dep,
   libmutter_cogl_dep,
 ]
 
+libmutter_cogl_pango_map = 'libmutter-cogl-pango.map'
+libmutter_cogl_pango_link_args = [
+  '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(),
+      libmutter_cogl_pango_map),
+]
 libmutter_cogl_pango = shared_library('mutter-cogl-pango-' + libmutter_api_version,
   sources: [cogl_pango_sources, cogl_pango_public_headers],
-  soversion: '0.0.0',
+  version: '0.0.0',
+  soversion: 0,
   c_args: cogl_c_args,
   include_directories: [cogl_includepath, cogl_path_includepath],
-  link_depends: 'libmutter-cogl-pango.map',
+  link_depends: libmutter_cogl_pango_map,
+  link_args: libmutter_cogl_pango_link_args,
   dependencies: [cogl_pango_deps],
   install_rpath: pkglibdir,
   install_dir: pkglibdir,

cogl/cogl-path/cogl-path.c

@@ -1358,13 +1358,13 @@ _cogl_path_build_fill_attribute_buffer (CoglPath *path)
   gluTessNormal (tess.glu_tess, 0.0, 0.0, 1.0);
 
   gluTessCallback (tess.glu_tess, GLU_TESS_BEGIN_DATA,
-                   _cogl_path_tesselator_begin);
+                   (GCallback) _cogl_path_tesselator_begin);
   gluTessCallback (tess.glu_tess, GLU_TESS_VERTEX_DATA,
-                   _cogl_path_tesselator_vertex);
+                   (GCallback) _cogl_path_tesselator_vertex);
   gluTessCallback (tess.glu_tess, GLU_TESS_END_DATA,
-                   _cogl_path_tesselator_end);
+                   (GCallback) _cogl_path_tesselator_end);
   gluTessCallback (tess.glu_tess, GLU_TESS_COMBINE_DATA,
-                   _cogl_path_tesselator_combine);
+                   (GCallback) _cogl_path_tesselator_combine);
 
   gluTessBeginPolygon (tess.glu_tess, &tess);