Add dcvviewer to xwayland_grab_default_access_rules

dcvviewer does not have native wayland support yet

https://gitlab.gnome.org/GNOME/mutter/merge_requests/587

.gitlab-ci.yml

@@ -28,20 +28,6 @@ build-mutter:
     - merge_requests
     - /^.*$/
 
-build-without-native-backend:
-  stage: build
-  script:
-    - meson . build -Dbuildtype=debugoptimized -Dnative_backend=false -Dudev=false --werror --prefix /usr
-    - ninja -C build
-    - ninja -C build install
-  artifacts:
-    expire_in: 1 day
-    paths:
-      - build
-  only:
-    - merge_requests
-    - /^.*$/
-
 test-mutter:
   stage: test
   dependencies:
@@ -49,17 +35,15 @@ test-mutter:
   variables:
     XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
     GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
-    G_SLICE: "always-malloc"
     MALLOC_CHECK_: "3"
     NO_AT_BRIDGE: "1"
-    MALLOC_PERTURB_: "123"
   script:
-    - dconf update
     - mkdir -m 700 $XDG_RUNTIME_DIR
     - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
     - >
+      env MALLOC_PERTURB_="$((RANDOM % 256 + 1))"
       dbus-run-session -- xvfb-run -s '+iglx -noreset'
-      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --print-errorlogs --wrap catchsegv
+      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --wrap catchsegv
   only:
     - merge_requests
     - /^.*$/

.gitlab-ci/Dockerfile

@@ -1,31 +1,20 @@
-# Rebuild and push with
-#
-#     cd .gitlab-ci/
-#     docker build -t registry.gitlab.gnome.org/gnome/mutter/master:v2 .
-#     docker push registry.gitlab.gnome.org/gnome/mutter/master:v2
-#
-
 FROM fedora:30
 
 RUN dnf -y update && dnf -y upgrade && \
     dnf install -y 'dnf-command(builddep)' && \
     dnf install -y 'dnf-command(copr)' && \
     dnf copr enable -y fmuellner/gnome-shell-ci && \
-    dnf copr enable -y jadahl/mutter-ci && \
-    dnf copr enable -y hergertme/sysprof-3 && \
 
     dnf builddep -y mutter && \
 
     # Until Fedora catches up with meson build-deps
     dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
 
-    # Until Fedora catches up with mesa bug fixes
-    dnf upgrade -y mesa-dri-drivers mesa-libEGL && \
-
     # For running unit tests
     dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 '*/xvfb-run' gdm-lib accountsservice-libs && \
 
-    dnf install -y sysprof-devel && \
+    # Unpackaged versions
+    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
 
     dnf install -y intltool redhat-rpm-config make && \
 

NEWS

@@ -1,84 +1,3 @@
-3.33.4
-======
-* Discard page flip retries on hotplug [Jonas; !630]
-* Add xdg-output v2 support [Olivier; #645]
-* Restore DRM format fallbacks [Jonas; !662]
-* Don't emit ::size-changed when only position changed [Daniel; !568]
-* Expose workspace layout properties [Florian; !618]
-* Don't use grab modifiers when shortcuts are inhibited [Olivier; #642]
-* Fix stuttering due to unchanged power save mode notifications [Georges; !674]
-* Add API to reorder workspaces [Adam; !670]
-* Make picking a new focus window more reliable [Marco; !669]
-* Defer actor allocation till shown [Carlos; !677]
-* Try to use primary GPU for copy instead of glReadPixels [Pekka; !615]
-* Unset pointer focus when the cursor is hidden [Jonas D.; !448]
-* Fix modifier-drag on wayland subsurfaces [Robert; !604]
-* Fix background corruption on Nvidia after resuming from suspend [Daniel; !600]
-* Only grab the locate-pointer key when necessary [Olivier; !685, #647]
-* Misc. bug fixes and cleanups [Florian, Jonas, Daniel, Robert, Olivier,
-  Georges, Marco, Carlos, Emmanuele; !648, !650, !647, !656, !658, !637,
-  !663, !660, !659, !665, !666, !668, !667, #667, !676, !678, #672, !680,
-  !683, !688, !689, !687]
-
-Contributors:
-  Jonas Ådahl, Emmanuele Bassi, Adam Bieńkowski, Piotr Drąg, Jonas Dreßler,
-  Olivier Fourdan, Carlos Garnacho, Robert Mader, Florian Müllner,
-  Georges Basile Stavracas Neto, Pekka Paalanen, Marco Trevisan (Treviño),
-  Daniel van Vugt
-
-Translators:
-  Fabio Tomat [fur], Kukuh Syafaat [id]
-
-3.33.3
-======
-* Prepare for running Xwayland on demand [Carlos; !420]
-* Fix text selection color rendering [Florian; #494]
-* Fix black shadows when using fractional scaling [Robert; #609]
-* Honor startup sequence workspace on wayland [Carlos; gnome-shell#674]
-* Only emit 'grab-op-end` signal after dropping grabs [Marco; !596]
-* Add a Sysprof-based profiler [Jonas, Georges; !197, !603]
-* Relax "xwayland-allow-grabs" setting [Olivier; #597]
-* Implement locate-pointer accessibility feature [Olivier; !453]
-* Implement mouse accessibility [Olivier; !512]
-* Consolidate frame throttling [Daniel, Georges; !363]
-* Fix setting blank cursor under wayland [Jonas; #630]
-* Pixel-align OpenGL cursors [Jonas; !610]
-* Handle returning from fullscreen/maximization better [Jonas; !621]
-* Improve screencast support on multi-monitor systems [Georges; !623]
-* Fix running X11 applications with sudo under wayland [Hans; #643]
-* Implement toggle-keys notification [Olivier; #637]
-* Add initial KMS transactional support [Jonas; !525]
-* Improve finding new focus window when the old one is closed [Marco; #308]
-* Misc. bug fixes and cleanups [Jonas, Carlos, Marco, Florian, Pekka, Robert,
-  Douglas, Georges, Daniel, Emil, Niels, Hans, Olivier, Ting-Wei, Corentin;
-  !591, #398, !592, !581, !597, !598, !593, !497, #591, !545, gtk#1675, !601,
-  #568, !564, !605, !609, !115, !214, !611, !617, !616, !619, !624, !622, !627,
-  !628, !629, !632, !633, !631, !636, !639, !638, !634, !640, !529, !644, !590]
-
-Contributors:
-  Jonas Ådahl, Piotr Drąg, Olivier Fourdan, Carlos Garnacho, Hans de Goede,
-  Niels De Graef, Ting-Wei Lan, Robert Mader, Florian Müllner,
-  Georges Basile Stavracas Neto, Corentin Noël, Pekka Paalanen, Douglas R. Reno,
-  Marco Trevisan (Treviño), Emil Velikov, Daniel van Vugt
-
-Translators:
-  Balázs Úr [hu], Daniel Mustieles [es], Nathan Follens [nl], Goran Vidović [hr]
-
-3.33.2
-======
-* Fix rendering lag on Xorg [Daniel; !520, !281]
-* Misc. bug fixes and cleanups [Carlos, Marco, Jonas D., Florian, Niels,
-  Daniel, Benjamin, Jonas Å., Ignacio, Vasilis; #598, !576, !547, !578,
-  !583, !582, !469, !524, !119, !571, !584, !585, !586, #425]
-
-Contributors:
-  Jonas Ådahl, Benjamin Berg, Jonas Dreßler, Carlos Garnacho, Niels De Graef,
-  Vasilis Liaskovitis, Florian Müllner, Ignacio Casal Quinteiro,
-  Marco Trevisan (Treviño), Daniel van Vugt
-
-Translators:
-  Daniel Mustieles [es]
-
 3.33.1
 ======
 * Remove unused APIs and outdated driver support

clutter/clutter/clutter-actor.c

@@ -10107,9 +10107,6 @@ clutter_actor_allocate (ClutterActor           *self,
       return;
     }
 
-  if (!clutter_actor_is_visible (self))
-    return;
-
   priv = self->priv;
 
   old_allocation = priv->allocation;
@@ -17554,7 +17551,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
                l != NULL && l->data != priv->current_effect;
                l = l->next)
             {
-              if (!_clutter_effect_modify_paint_volume (l->data, pv))
+              if (!_clutter_effect_get_paint_volume (l->data, pv))
                 {
                   clutter_paint_volume_free (pv);
                   CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
@@ -17572,7 +17569,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
           /* otherwise, get the cumulative volume */
           effects = _clutter_meta_group_peek_metas (priv->effects);
           for (l = effects; l != NULL; l = l->next)
-            if (!_clutter_effect_modify_paint_volume (l->data, pv))
+            if (!_clutter_effect_get_paint_volume (l->data, pv))
               {
                 clutter_paint_volume_free (pv);
                 CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "

clutter/clutter/clutter-backend.c

@@ -1111,7 +1111,7 @@ _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
 {
   if (backend->dummy_onscreen == COGL_INVALID_HANDLE)
     {
-      GError *internal_error = NULL;
+      CoglError *internal_error = NULL;
 
       backend->dummy_onscreen = cogl_onscreen_new (backend->cogl_context, 1, 1);
 
@@ -1119,7 +1119,7 @@ _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
                                       &internal_error))
         {
           g_critical ("Unable to create dummy onscreen: %s", internal_error->message);
-          g_error_free (internal_error);
+          cogl_error_free (internal_error);
           return;
         }
     }

clutter/clutter/clutter-blur-effect.c

@@ -178,8 +178,8 @@ clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
 }
 
 static gboolean
-clutter_blur_effect_modify_paint_volume (ClutterEffect      *effect,
-                                         ClutterPaintVolume *volume)
+clutter_blur_effect_get_paint_volume (ClutterEffect      *effect,
+                                      ClutterPaintVolume *volume)
 {
   gfloat cur_width, cur_height;
   ClutterVertex origin;
@@ -223,7 +223,7 @@ clutter_blur_effect_class_init (ClutterBlurEffectClass *klass)
   gobject_class->dispose = clutter_blur_effect_dispose;
 
   effect_class->pre_paint = clutter_blur_effect_pre_paint;
-  effect_class->modify_paint_volume = clutter_blur_effect_modify_paint_volume;
+  effect_class->get_paint_volume = clutter_blur_effect_get_paint_volume;
 
   offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
   offscreen_class->paint_target = clutter_blur_effect_paint_target;

clutter/clutter/clutter-clone.c

@@ -252,13 +252,6 @@ clutter_clone_allocate (ClutterActor           *self,
   if (priv->clone_source == NULL)
     return;
 
-  /* ClutterActor delays allocating until the actor is shown; however
-   * we cannot paint it correctly in that case, so force an allocation.
-   */
-  if (clutter_actor_get_parent (priv->clone_source) != NULL &&
-      !clutter_actor_has_allocation (priv->clone_source))
-    clutter_actor_allocate_preferred_size (priv->clone_source, flags);
-
 #if 0
   /* XXX - this is wrong: ClutterClone cannot clone unparented
    * actors, as it will break all invariants

clutter/clutter/clutter-deprecated.h

@@ -17,6 +17,7 @@
 #include "deprecated/clutter-container.h"
 #include "deprecated/clutter-group.h"
 #include "deprecated/clutter-keysyms.h"
+#include "deprecated/clutter-main.h"
 #include "deprecated/clutter-rectangle.h"
 #include "deprecated/clutter-stage-manager.h"
 #include "deprecated/clutter-stage.h"

clutter/clutter/clutter-device-manager-private.h

@@ -69,22 +69,6 @@ typedef struct _ClutterTouchInfo
   gfloat current_y;
 } ClutterTouchInfo;
 
-typedef struct _ClutterPtrA11yData
-{
-  int n_btn_pressed;
-  float current_x;
-  float current_y;
-
-  float dwell_x;
-  float dwell_y;
-  gboolean dwell_drag_started;
-  gboolean dwell_gesture_started;
-  guint dwell_timer;
-
-  guint secondary_click_timer;
-  gboolean secondary_click_triggered;
-} ClutterPtrA11yData;
-
 struct _ClutterInputDevice
 {
   GObject parent_instance;
@@ -159,10 +143,6 @@ struct _ClutterInputDevice
 
   guint has_cursor : 1;
   guint is_enabled : 1;
-
-  /* Accessiblity */
-  ClutterVirtualInputDevice *accessibility_virtual_device;
-  ClutterPtrA11yData *ptr_a11y_data;
 };
 
 typedef void (*ClutterEmitInputDeviceEvent) (ClutterEvent       *event,

clutter/clutter/clutter-device-manager.c

@@ -47,7 +47,6 @@
 #include "clutter-stage-private.h"
 #include "clutter-virtual-input-device.h"
 #include "clutter-input-device-tool.h"
-#include "clutter-input-pointer-a11y-private.h"
 
 struct _ClutterDeviceManagerPrivate
 {
@@ -56,8 +55,6 @@ struct _ClutterDeviceManagerPrivate
 
   /* Keyboard a11y */
   ClutterKbdA11ySettings kbd_a11y_settings;
-  /* Pointer a11y */
-  ClutterPointerA11ySettings pointer_a11y_settings;
 };
 
 enum
@@ -78,9 +75,6 @@ enum
   TOOL_CHANGED,
   KBD_A11Y_MASK_CHANGED,
   KBD_A11Y_FLAGS_CHANGED,
-  PTR_A11Y_DWELL_CLICK_TYPE_CHANGED,
-  PTR_A11Y_TIMEOUT_STARTED,
-  PTR_A11Y_TIMEOUT_STOPPED,
 
   LAST_SIGNAL
 };
@@ -245,67 +239,6 @@ clutter_device_manager_class_init (ClutterDeviceManagerClass *klass)
                   G_TYPE_NONE, 2,
                   G_TYPE_UINT,
                   G_TYPE_UINT);
-
-  /**
-   * ClutterDeviceManager::ptr-a11y-dwell-click-type-changed:
-   * @manager: the #ClutterDeviceManager that emitted the signal
-   * @click_type: the new #ClutterPointerA11yDwellClickType mode
-   *
-   * The ::ptr-a11y-dwell-click-type-changed signal is emitted each time
-   * the ClutterPointerA11yDwellClickType mode is changed as the result
-   * of pointer accessibility operations.
-   */
-  manager_signals[PTR_A11Y_DWELL_CLICK_TYPE_CHANGED] =
-    g_signal_new (I_("ptr-a11y-dwell-click-type-changed"),
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL,
-                  g_cclosure_marshal_VOID__FLAGS,
-                  G_TYPE_NONE, 1,
-                  CLUTTER_TYPE_POINTER_A11Y_DWELL_CLICK_TYPE);
-
-  /**
-   * ClutterDeviceManager::ptr-a11y-timeout-started:
-   * @manager: the #ClutterDeviceManager that emitted the signal
-   * @device: the core pointer #ClutterInputDevice
-   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
-   * @delay: the delay in ms before secondary-click is triggered.
-   *
-   * The ::ptr-a11y-timeout-started signal is emitted when a
-   * pointer accessibility timeout delay is started, so that upper
-   * layers can notify the user with some visual feedback.
-   */
-  manager_signals[PTR_A11Y_TIMEOUT_STARTED] =
-    g_signal_new (I_("ptr-a11y-timeout-started"),
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL,
-                  _clutter_marshal_VOID__OBJECT_FLAGS_UINT,
-                  G_TYPE_NONE, 3,
-                  CLUTTER_TYPE_INPUT_DEVICE,
-                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
-                  G_TYPE_UINT);
-
-  /**
-   * ClutterDeviceManager::ptr-a11y-timeout-stopped:
-   * @manager: the #ClutterDeviceManager that emitted the signal
-   * @device: the core pointer #ClutterInputDevice
-   * @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
-   *
-   * The ::ptr-a11y-timeout-stopped signal is emitted when a running
-   * pointer accessibility timeout delay is stopped, either because
-   * it's triggered at the end of the delay or cancelled, so that
-   * upper layers can notify the user with some visual feedback.
-   */
-  manager_signals[PTR_A11Y_TIMEOUT_STOPPED] =
-    g_signal_new (I_("ptr-a11y-timeout-stopped"),
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0, NULL, NULL,
-                  _clutter_marshal_VOID__OBJECT_FLAGS,
-                  G_TYPE_NONE, 2,
-                  CLUTTER_TYPE_INPUT_DEVICE,
-                  CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE);
 }
 
 static void
@@ -646,88 +579,3 @@ clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_man
 
   *settings = device_manager->priv->kbd_a11y_settings;
 }
-
-static gboolean
-are_pointer_a11y_settings_equal (ClutterPointerA11ySettings *a,
-                                 ClutterPointerA11ySettings *b)
-{
-  return (memcmp (a, b, sizeof (ClutterPointerA11ySettings)) == 0);
-}
-
-static void
-clutter_device_manager_enable_pointer_a11y (ClutterDeviceManager *device_manager)
-{
-  ClutterInputDevice *core_pointer;
-
-  core_pointer = clutter_device_manager_get_core_device (device_manager,
-                                                         CLUTTER_POINTER_DEVICE);
-
-  _clutter_input_pointer_a11y_add_device (core_pointer);
-}
-
-static void
-clutter_device_manager_disable_pointer_a11y (ClutterDeviceManager *device_manager)
-{
-  ClutterInputDevice *core_pointer;
-
-  core_pointer = clutter_device_manager_get_core_device (device_manager,
-                                                         CLUTTER_POINTER_DEVICE);
-
-  _clutter_input_pointer_a11y_remove_device (core_pointer);
-}
-
-/**
- * clutter_device_manager_set_pointer_a11y_settings:
- * @device_manager: a #ClutterDeviceManager
- * @settings: a pointer to a #ClutterPointerA11ySettings
- *
- * Sets the pointer accessibility settings
- **/
-void
-clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
-                                                  ClutterPointerA11ySettings *settings)
-{
-  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
-
-  if (are_pointer_a11y_settings_equal (&device_manager->priv->pointer_a11y_settings, settings))
-    return;
-
-  if (device_manager->priv->pointer_a11y_settings.controls == 0 && settings->controls != 0)
-    clutter_device_manager_enable_pointer_a11y (device_manager);
-  else if (device_manager->priv->pointer_a11y_settings.controls != 0 && settings->controls == 0)
-    clutter_device_manager_disable_pointer_a11y (device_manager);
-
-  device_manager->priv->pointer_a11y_settings = *settings;
-}
-
-/**
- * clutter_device_manager_get_pointer_a11y_settings:
- * @device_manager: a #ClutterDeviceManager
- * @settings: a pointer to a #ClutterPointerA11ySettings
- *
- * Gets the current pointer accessibility settings
- **/
-void
-clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
-                                                  ClutterPointerA11ySettings *settings)
-{
-  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
-
-  *settings = device_manager->priv->pointer_a11y_settings;
-}
-
-/**
- * clutter_device_manager_set_pointer_a11y_dwell_click_type:
- * @device_manager: a #ClutterDeviceManager
- * @click_type: type of click as #ClutterPointerA11yDwellClickType
- *
- * Sets the dwell click type
- **/
-void
-clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
-                                                          ClutterPointerA11yDwellClickType  click_type)
-{
-  g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
-
-  device_manager->priv->pointer_a11y_settings.dwell_click_type = click_type;
-}

clutter/clutter/clutter-device-manager.h

@@ -73,27 +73,6 @@ typedef struct _ClutterKbdA11ySettings
   gint mousekeys_accel_time;
 } ClutterKbdA11ySettings;
 
-/**
- * ClutterPointerA11ySettings:
- *
- * The #ClutterPointerA11ySettings structure contains pointer accessibility
- * settings
- *
- */
-typedef struct _ClutterPointerA11ySettings
-{
-  ClutterPointerA11yFlags controls;
-  ClutterPointerA11yDwellClickType dwell_click_type;
-  ClutterPointerA11yDwellMode dwell_mode;
-  ClutterPointerA11yDwellDirection dwell_gesture_single;
-  ClutterPointerA11yDwellDirection dwell_gesture_double;
-  ClutterPointerA11yDwellDirection dwell_gesture_drag;
-  ClutterPointerA11yDwellDirection dwell_gesture_secondary;
-  gint secondary_click_delay;
-  gint dwell_delay;
-  gint dwell_threshold;
-} ClutterPointerA11ySettings;
-
 /**
  * ClutterDeviceManager:
  *
@@ -173,23 +152,10 @@ ClutterVirtualDeviceType clutter_device_manager_get_supported_virtual_device_typ
 CLUTTER_EXPORT
 void clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
-
 CLUTTER_EXPORT
 void clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager   *device_manager,
                                                    ClutterKbdA11ySettings *settings);
 
-CLUTTER_EXPORT
-void clutter_device_manager_set_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
-                                                       ClutterPointerA11ySettings *settings);
-
-CLUTTER_EXPORT
-void clutter_device_manager_get_pointer_a11y_settings (ClutterDeviceManager       *device_manager,
-                                                       ClutterPointerA11ySettings *settings);
-
-CLUTTER_EXPORT
-void clutter_device_manager_set_pointer_a11y_dwell_click_type (ClutterDeviceManager             *device_manager,
-                                                               ClutterPointerA11yDwellClickType  click_type);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_DEVICE_MANAGER_H__ */

clutter/clutter/clutter-effect-private.h

@@ -7,7 +7,7 @@ G_BEGIN_DECLS
 
 gboolean        _clutter_effect_pre_paint               (ClutterEffect           *effect);
 void            _clutter_effect_post_paint              (ClutterEffect           *effect);
-gboolean        _clutter_effect_modify_paint_volume     (ClutterEffect           *effect,
+gboolean        _clutter_effect_get_paint_volume        (ClutterEffect           *effect,
                                                          ClutterPaintVolume      *volume);
 gboolean        _clutter_effect_has_custom_paint_volume (ClutterEffect           *effect);
 void            _clutter_effect_paint                   (ClutterEffect           *effect,

clutter/clutter/clutter-effect.c

@@ -188,8 +188,8 @@ clutter_effect_real_post_paint (ClutterEffect *effect)
 }
 
 static gboolean
-clutter_effect_real_modify_paint_volume (ClutterEffect      *effect,
-                                         ClutterPaintVolume *volume)
+clutter_effect_real_get_paint_volume (ClutterEffect      *effect,
+                                      ClutterPaintVolume *volume)
 {
   return TRUE;
 }
@@ -252,7 +252,7 @@ clutter_effect_class_init (ClutterEffectClass *klass)
 
   klass->pre_paint = clutter_effect_real_pre_paint;
   klass->post_paint = clutter_effect_real_post_paint;
-  klass->modify_paint_volume = clutter_effect_real_modify_paint_volume;
+  klass->get_paint_volume = clutter_effect_real_get_paint_volume;
   klass->paint = clutter_effect_real_paint;
   klass->pick = clutter_effect_real_pick;
 }
@@ -297,14 +297,13 @@ _clutter_effect_pick (ClutterEffect           *effect,
 }
 
 gboolean
-_clutter_effect_modify_paint_volume (ClutterEffect      *effect,
-                                     ClutterPaintVolume *volume)
+_clutter_effect_get_paint_volume (ClutterEffect      *effect,
+                                  ClutterPaintVolume *volume)
 {
   g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
   g_return_val_if_fail (volume != NULL, FALSE);
 
-  return CLUTTER_EFFECT_GET_CLASS (effect)->modify_paint_volume (effect,
-                                                                 volume);
+  return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume (effect, volume);
 }
 
 gboolean
@@ -312,7 +311,7 @@ _clutter_effect_has_custom_paint_volume (ClutterEffect *effect)
 {
   g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
 
-  return CLUTTER_EFFECT_GET_CLASS (effect)->modify_paint_volume != clutter_effect_real_modify_paint_volume;
+  return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume != clutter_effect_real_get_paint_volume;
 }
 
 /**

clutter/clutter/clutter-effect.h

@@ -60,7 +60,7 @@ struct _ClutterEffect
  * ClutterEffectClass:
  * @pre_paint: virtual function
  * @post_paint: virtual function
- * @modify_paint_volume: virtual function
+ * @get_paint_volume: virtual function
  * @paint: virtual function
  * @pick: virtual function
  *
@@ -74,16 +74,16 @@ struct _ClutterEffectClass
   ClutterActorMetaClass parent_class;
 
   /*< public >*/
-  gboolean (* pre_paint)           (ClutterEffect           *effect);
-  void     (* post_paint)          (ClutterEffect           *effect);
+  gboolean (* pre_paint)        (ClutterEffect           *effect);
+  void     (* post_paint)       (ClutterEffect           *effect);
 
-  gboolean (* modify_paint_volume) (ClutterEffect           *effect,
-                                    ClutterPaintVolume      *volume);
+  gboolean (* get_paint_volume) (ClutterEffect           *effect,
+                                 ClutterPaintVolume      *volume);
 
-  void     (* paint)               (ClutterEffect           *effect,
-                                    ClutterEffectPaintFlags  flags);
-  void     (* pick)                (ClutterEffect           *effect,
-                                    ClutterEffectPaintFlags  flags);
+  void     (* paint)            (ClutterEffect           *effect,
+                                 ClutterEffectPaintFlags  flags);
+  void     (* pick)             (ClutterEffect           *effect,
+                                 ClutterEffectPaintFlags  flags);
 
   /*< private >*/
   void (* _clutter_effect4) (void);

clutter/clutter/clutter-enum-types.h.in

@@ -13,7 +13,7 @@ G_BEGIN_DECLS
 /*** END file-header ***/
 
 /*** BEGIN file-production ***/
-/* enumerations from "@basename@" */
+/* enumerations from "@filename@" */
 /*** END file-production ***/
 
 /*** BEGIN value-header ***/

clutter/clutter/clutter-enums.h

@@ -277,6 +277,24 @@ typedef enum
   CLUTTER_ANIMATION_LAST
 } ClutterAnimationMode;
 
+/**
+ * ClutterFontFlags:
+ * @CLUTTER_FONT_MIPMAPPING: Set to use mipmaps for the glyph cache textures.
+ * @CLUTTER_FONT_HINTING: Set to enable hinting on the glyphs.
+ *
+ * Runtime flags to change the font quality. To be used with
+ * clutter_set_font_flags().
+ *
+ * Since: 1.0
+ *
+ * Deprecated: 1.22: Use #cairo_font_options_t instead
+ */
+typedef enum /*< prefix=CLUTTER_FONT >*/
+{
+  CLUTTER_FONT_MIPMAPPING = (1 << 0),
+  CLUTTER_FONT_HINTING    = (1 << 1)
+} ClutterFontFlags;
+
 /**
  * ClutterTextDirection:
  * @CLUTTER_TEXT_DIRECTION_DEFAULT: Use the default setting, as returned
@@ -425,88 +443,6 @@ typedef enum
   CLUTTER_A11Y_FEATURE_STATE_CHANGE_BEEP = 1 << 13,
 } ClutterKeyboardA11yFlags;
 
-/**
- * ClutterPointerA11yFlags:
- * @CLUTTER_A11Y_POINTER_ENABLED:
- * @CLUTTER_A11Y_SECONDARY_CLICK_ENABLED:
- * @CLUTTER_A11Y_DWELL_ENABLED:
- *
- * Pointer accessibility features applied to a ClutterInputDevice pointer.
- *
- */
-typedef enum {
-  CLUTTER_A11Y_SECONDARY_CLICK_ENABLED   = 1 << 0,
-  CLUTTER_A11Y_DWELL_ENABLED             = 1 << 1,
-} ClutterPointerA11yFlags;
-
-/**
- * ClutterPointerA11yDwellClickType:
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE: Internal use only
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
- * @CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
- *
- * Dwell click types.
- *
- */
-typedef enum {
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE,
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY,
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY,
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE,
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE,
-  CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG,
-} ClutterPointerA11yDwellClickType;
-
-/**
- * ClutterPointerA11yDwellDirection:
- * @CLUTTER_A11Y_DWELL_DIRECTION_NONE:
- * @CLUTTER_A11Y_DWELL_DIRECTION_LEFT:
- * @CLUTTER_A11Y_DWELL_DIRECTION_RIGHT:
- * @CLUTTER_A11Y_DWELL_DIRECTION_UP:
- * @CLUTTER_A11Y_DWELL_DIRECTION_DOWN:
- *
- * Dwell gesture directions.
- *
- */
-typedef enum {
-  CLUTTER_A11Y_DWELL_DIRECTION_NONE,
-  CLUTTER_A11Y_DWELL_DIRECTION_LEFT,
-  CLUTTER_A11Y_DWELL_DIRECTION_RIGHT,
-  CLUTTER_A11Y_DWELL_DIRECTION_UP,
-  CLUTTER_A11Y_DWELL_DIRECTION_DOWN,
-} ClutterPointerA11yDwellDirection;
-
-/**
- * ClutterPointerA11yDwellMode:
- * @CLUTTER_A11Y_DWELL_MODE_WINDOW:
- * @CLUTTER_A11Y_DWELL_MODE_GESTURE:
- *
- * Dwell mode.
- *
- */
-typedef enum {
-  CLUTTER_A11Y_DWELL_MODE_WINDOW,
-  CLUTTER_A11Y_DWELL_MODE_GESTURE,
-} ClutterPointerA11yDwellMode;
-
-/**
- * ClutterPointerA11yTimeoutType:
- * @CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK:
- * @CLUTTER_A11Y_TIMEOUT_TYPE_DWELL:
- * @CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE:
- *
- * Pointer accessibility timeout type.
- *
- */
-typedef enum {
-  CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
-  CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
-  CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
-} ClutterPointerA11yTimeoutType;
-
 /**
  * ClutterActorFlags:
  * @CLUTTER_ACTOR_MAPPED: the actor will be painted (is visible, and inside
@@ -956,6 +892,8 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
 
 /**
  * ClutterStageState:
+ * @CLUTTER_STAGE_STATE_FULLSCREEN: Fullscreen mask
+ * @CLUTTER_STAGE_STATE_OFFSCREEN: Offscreen mask (deprecated)
  * @CLUTTER_STAGE_STATE_ACTIVATED: Activated mask
  *
  * Stage state masks, used by the #ClutterEvent of type %CLUTTER_STAGE_STATE.
@@ -964,6 +902,8 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
  */
 typedef enum
 {
+  CLUTTER_STAGE_STATE_FULLSCREEN       = (1 << 1),
+  CLUTTER_STAGE_STATE_OFFSCREEN        = (1 << 2),
   CLUTTER_STAGE_STATE_ACTIVATED        = (1 << 3)
 } ClutterStageState;
 
@@ -973,6 +913,7 @@ typedef enum
  * @CLUTTER_FEATURE_TEXTURE_YUV: Set if YUV based textures supported.
  * @CLUTTER_FEATURE_TEXTURE_READ_PIXELS: Set if texture pixels can be read.
  * @CLUTTER_FEATURE_STAGE_STATIC: Set if stage size if fixed (i.e framebuffer)
+ * @CLUTTER_FEATURE_STAGE_USER_RESIZE: Set if stage is able to be user resized.
  * @CLUTTER_FEATURE_STAGE_CURSOR: Set if stage has a graphical cursor.
  * @CLUTTER_FEATURE_SHADERS_GLSL: Set if the backend supports GLSL shaders.
  * @CLUTTER_FEATURE_OFFSCREEN: Set if the backend supports offscreen rendering.
@@ -990,6 +931,7 @@ typedef enum
   CLUTTER_FEATURE_TEXTURE_YUV            = (1 << 4),
   CLUTTER_FEATURE_TEXTURE_READ_PIXELS    = (1 << 5),
   CLUTTER_FEATURE_STAGE_STATIC           = (1 << 6),
+  CLUTTER_FEATURE_STAGE_USER_RESIZE      = (1 << 7),
   CLUTTER_FEATURE_STAGE_CURSOR           = (1 << 8),
   CLUTTER_FEATURE_SHADERS_GLSL           = (1 << 9),
   CLUTTER_FEATURE_OFFSCREEN              = (1 << 10),

clutter/clutter/clutter-input-device.c

@@ -107,9 +107,6 @@ clutter_input_device_dispose (GObject *gobject)
       device->associated = NULL;
     }
 
-  if (device->accessibility_virtual_device)
-    g_clear_object (&device->accessibility_virtual_device);
-
   g_clear_pointer (&device->axes, g_array_unref);
   g_clear_pointer (&device->keys, g_array_unref);
   g_clear_pointer (&device->scroll_info, g_array_unref);

clutter/clutter/clutter-input-pointer-a11y-private.h

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2019 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: Olivier Fourdan <ofourdan@redhat.com>
- */
-
-#ifndef __CLUTTER_INPUT_POINTER_A11Y_H__
-#define __CLUTTER_INPUT_POINTER_A11Y_H__
-
-#include <clutter/clutter-types.h>
-#include "clutter-enum-types.h"
-
-G_BEGIN_DECLS
-
-void _clutter_input_pointer_a11y_add_device      (ClutterInputDevice   *device);
-void _clutter_input_pointer_a11y_remove_device   (ClutterInputDevice   *device);
-void _clutter_input_pointer_a11y_on_motion_event (ClutterInputDevice   *device,
-                                                  float                 x,
-                                                  float                 y);
-void _clutter_input_pointer_a11y_on_button_event (ClutterInputDevice   *device,
-                                                  int                   button,
-                                                  gboolean              pressed);
-gboolean _clutter_is_input_pointer_a11y_enabled  (ClutterInputDevice     *device);
-
-G_END_DECLS
-
-#endif /* __CLUTTER_INPUT_POINTER_A11Y_H__ */

clutter/clutter/clutter-input-pointer-a11y.c

@@ -1,669 +0,0 @@
-/*
- * Copyright (C) 2019 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: Olivier Fourdan <ofourdan@redhat.com>
- *
- * This reimplements in Clutter the same behavior as mousetweaks original
- * implementation by Gerd Kohlberger <gerdko gmail com>
- * mousetweaks Copyright (C) 2007-2010 Gerd Kohlberger <gerdko gmail com>
- */
-
-#include "clutter-build-config.h"
-
-#include "clutter-device-manager.h"
-#include "clutter-device-manager-private.h"
-#include "clutter-enum-types.h"
-#include "clutter-input-device.h"
-#include "clutter-input-pointer-a11y-private.h"
-#include "clutter-main.h"
-#include "clutter-virtual-input-device.h"
-
-static gboolean
-is_secondary_click_enabled (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return (settings.controls & CLUTTER_A11Y_SECONDARY_CLICK_ENABLED);
-}
-
-static gboolean
-is_dwell_click_enabled (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return (settings.controls & CLUTTER_A11Y_DWELL_ENABLED);
-}
-
-static unsigned int
-get_secondary_click_delay (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return settings.secondary_click_delay;
-}
-
-static unsigned int
-get_dwell_delay (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return settings.dwell_delay;
-}
-
-static unsigned int
-get_dwell_threshold (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return settings.dwell_threshold;
-}
-
-static ClutterPointerA11yDwellMode
-get_dwell_mode (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  return settings.dwell_mode;
-}
-
-static ClutterPointerA11yDwellClickType
-get_dwell_click_type (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-#
-  return settings.dwell_click_type;
-}
-
-static ClutterPointerA11yDwellClickType
-get_dwell_click_type_for_direction (ClutterInputDevice               *device,
-                                    ClutterPointerA11yDwellDirection  direction)
-{
-  ClutterPointerA11ySettings settings;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  if (direction == settings.dwell_gesture_single)
-    return CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
-  else if (direction == settings.dwell_gesture_double)
-    return CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE;
-  else if (direction == settings.dwell_gesture_drag)
-    return CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG;
-  else if (direction == settings.dwell_gesture_secondary)
-    return CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY;
-
-  return CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE;
-}
-
-static void
-emit_button_press (ClutterInputDevice *device,
-                   gint                button)
-{
-  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
-                                              g_get_monotonic_time (),
-                                              button,
-                                              CLUTTER_BUTTON_STATE_PRESSED);
-}
-
-static void
-emit_button_release (ClutterInputDevice *device,
-                     gint                button)
-{
-  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
-                                              g_get_monotonic_time (),
-                                              button,
-                                              CLUTTER_BUTTON_STATE_RELEASED);
-}
-
-static void
-emit_button_click (ClutterInputDevice *device,
-                   gint                button)
-{
-  emit_button_press (device, button);
-  emit_button_release (device, button);
-}
-
-static void
-restore_dwell_position (ClutterInputDevice *device)
-{
-  clutter_virtual_input_device_notify_absolute_motion (device->accessibility_virtual_device,
-                                                       g_get_monotonic_time (),
-                                                       device->ptr_a11y_data->dwell_x,
-                                                       device->ptr_a11y_data->dwell_y);
-}
-
-static gboolean
-trigger_secondary_click (gpointer data)
-{
-  ClutterInputDevice *device = data;
-
-  device->ptr_a11y_data->secondary_click_triggered = TRUE;
-  device->ptr_a11y_data->secondary_click_timer = 0;
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-stopped",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK);
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-start_secondary_click_timeout (ClutterInputDevice *device)
-{
-  unsigned int delay = get_secondary_click_delay (device);
-
-  device->ptr_a11y_data->secondary_click_timer =
-    clutter_threads_add_timeout (delay, trigger_secondary_click, device);
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-started",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
-                         delay);
-}
-
-static void
-stop_secondary_click_timeout (ClutterInputDevice *device)
-{
-  if (device->ptr_a11y_data->secondary_click_timer)
-    {
-      g_source_remove (device->ptr_a11y_data->secondary_click_timer);
-      device->ptr_a11y_data->secondary_click_timer = 0;
-
-      g_signal_emit_by_name (device->device_manager,
-                             "ptr-a11y-timeout-stopped",
-                             device,
-                             CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK);
-    }
-  device->ptr_a11y_data->secondary_click_triggered = FALSE;
-}
-
-static gboolean
-pointer_has_moved (ClutterInputDevice *device)
-{
-  float dx, dy;
-  gint threshold;
-
-  dx = device->ptr_a11y_data->dwell_x - device->ptr_a11y_data->current_x;
-  dy = device->ptr_a11y_data->dwell_y - device->ptr_a11y_data->current_y;
-  threshold = get_dwell_threshold (device);
-
-  /* Pythagorean theorem */
-  return ((dx * dx) + (dy * dy)) > (threshold * threshold);
-}
-
-static gboolean
-is_secondary_click_pending (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->secondary_click_timer != 0;
-}
-
-static gboolean
-is_secondary_click_triggered (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->secondary_click_triggered;
-}
-
-static gboolean
-is_dwell_click_pending (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->dwell_timer != 0;
-}
-
-static gboolean
-is_dwell_dragging (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->dwell_drag_started;
-}
-
-static gboolean
-is_dwell_gesturing (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->dwell_gesture_started;
-}
-
-static gboolean
-has_button_pressed (ClutterInputDevice *device)
-{
-  return device->ptr_a11y_data->n_btn_pressed > 0;
-}
-
-static gboolean
-should_start_secondary_click_timeout (ClutterInputDevice *device)
-{
-  return !is_dwell_dragging (device);
-}
-
-static gboolean
-should_start_dwell (ClutterInputDevice *device)
-{
-  /* We should trigger a dwell if we've not already started one, and if
-   * no button is currently pressed or we are in the middle of a dwell
-   * drag action.
-   */
-  return !is_dwell_click_pending (device) &&
-         (is_dwell_dragging (device) ||
-          !has_button_pressed (device));
-}
-
-static gboolean
-should_stop_dwell (ClutterInputDevice *device)
-{
-  /* We should stop a dwell if the motion exceeds the threshold, unless
-   * we've started a gesture, because we want to keep the original dwell
-   * location to both detect a gesture and restore the original pointer
-   * location once the gesture is finished.
-   */
-  return pointer_has_moved (device) &&
-         !is_dwell_gesturing (device);
-}
-
-
-static gboolean
-should_update_dwell_position (ClutterInputDevice *device)
-{
-  return !is_dwell_gesturing (device) &&
-         !is_dwell_click_pending (device) &&
-         !is_secondary_click_pending (device);
-}
-
-static void
-update_dwell_click_type (ClutterInputDevice *device)
-{
-  ClutterPointerA11ySettings settings;
-  ClutterPointerA11yDwellClickType dwell_click_type;
-
-  clutter_device_manager_get_pointer_a11y_settings (device->device_manager, &settings);
-
-  dwell_click_type = settings.dwell_click_type;
-  switch (dwell_click_type)
-    {
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
-      dwell_click_type = CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
-      if (!is_dwell_dragging (device))
-        dwell_click_type = CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY;
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE:
-    default:
-      break;
-    }
-
-  if (dwell_click_type != settings.dwell_click_type)
-    {
-      settings.dwell_click_type = dwell_click_type;
-      clutter_device_manager_set_pointer_a11y_settings (device->device_manager,
-                                                        &settings);
-
-      g_signal_emit_by_name (device->device_manager,
-                             "ptr-a11y-dwell-click-type-changed",
-                             dwell_click_type);
-    }
-}
-
-static void
-emit_dwell_click (ClutterInputDevice               *device,
-                  ClutterPointerA11yDwellClickType  dwell_click_type)
-{
-  switch (dwell_click_type)
-    {
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
-      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
-      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
-      emit_button_click (device, CLUTTER_BUTTON_PRIMARY);
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
-      if (is_dwell_dragging (device))
-        {
-          emit_button_release (device, CLUTTER_BUTTON_PRIMARY);
-          device->ptr_a11y_data->dwell_drag_started = FALSE;
-        }
-      else
-        {
-          emit_button_press (device, CLUTTER_BUTTON_PRIMARY);
-          device->ptr_a11y_data->dwell_drag_started = TRUE;
-        }
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
-      emit_button_click (device, CLUTTER_BUTTON_SECONDARY);
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
-      emit_button_click (device, CLUTTER_BUTTON_MIDDLE);
-      break;
-
-    case CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE:
-    default:
-      break;
-    }
-}
-
-static ClutterPointerA11yDwellDirection
-get_dwell_direction (ClutterInputDevice *device)
-{
-  float dx, dy;
-
-  dx = ABS (device->ptr_a11y_data->dwell_x - device->ptr_a11y_data->current_x);
-  dy = ABS (device->ptr_a11y_data->dwell_y - device->ptr_a11y_data->current_y);
-
-  /* The pointer hasn't moved */
-  if (!pointer_has_moved (device))
-    return CLUTTER_A11Y_DWELL_DIRECTION_NONE;
-
-  if (device->ptr_a11y_data->dwell_x < device->ptr_a11y_data->current_x)
-    {
-      if (dx > dy)
-        return CLUTTER_A11Y_DWELL_DIRECTION_LEFT;
-    }
-  else
-    {
-      if (dx > dy)
-        return CLUTTER_A11Y_DWELL_DIRECTION_RIGHT;
-    }
-
-  if (device->ptr_a11y_data->dwell_y < device->ptr_a11y_data->current_y)
-    return CLUTTER_A11Y_DWELL_DIRECTION_UP;
-
-  return CLUTTER_A11Y_DWELL_DIRECTION_DOWN;
-}
-
-static gboolean
-trigger_clear_dwell_gesture (gpointer data)
-{
-  ClutterInputDevice *device = data;
-
-  device->ptr_a11y_data->dwell_timer = 0;
-  device->ptr_a11y_data->dwell_gesture_started = FALSE;
-
-  return G_SOURCE_REMOVE;
-}
-
-static gboolean
-trigger_dwell_gesture (gpointer data)
-{
-  ClutterInputDevice *device = data;
-  ClutterPointerA11yDwellDirection direction;
-  unsigned int delay = get_dwell_delay (device);
-
-  restore_dwell_position (device);
-  direction = get_dwell_direction (device);
-  emit_dwell_click (device,
-                    get_dwell_click_type_for_direction (device,
-                                                        direction));
-
-  /* Do not clear the gesture right away, otherwise we'll start another one */
-  device->ptr_a11y_data->dwell_timer =
-    clutter_threads_add_timeout (delay, trigger_clear_dwell_gesture, device);
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-stopped",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE);
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-start_dwell_gesture_timeout (ClutterInputDevice *device)
-{
-  unsigned int delay = get_dwell_delay (device);
-
-  device->ptr_a11y_data->dwell_timer =
-    clutter_threads_add_timeout (delay, trigger_dwell_gesture, device);
-  device->ptr_a11y_data->dwell_gesture_started = TRUE;
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-started",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
-                         delay);
-}
-
-static gboolean
-trigger_dwell_click (gpointer data)
-{
-  ClutterInputDevice *device = data;
-
-  device->ptr_a11y_data->dwell_timer = 0;
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-stopped",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_DWELL);
-
-  if (get_dwell_mode (device) == CLUTTER_A11Y_DWELL_MODE_GESTURE)
-    {
-      if (is_dwell_dragging (device))
-        emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
-      else
-        start_dwell_gesture_timeout (device);
-    }
-  else
-    {
-      emit_dwell_click (device, get_dwell_click_type (device));
-      update_dwell_click_type (device);
-    }
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-start_dwell_timeout (ClutterInputDevice *device)
-{
-  unsigned int delay = get_dwell_delay (device);
-
-  device->ptr_a11y_data->dwell_timer =
-    clutter_threads_add_timeout (delay, trigger_dwell_click, device);
-
-  g_signal_emit_by_name (device->device_manager,
-                         "ptr-a11y-timeout-started",
-                         device,
-                         CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
-                         delay);
-}
-
-static void
-stop_dwell_timeout (ClutterInputDevice *device)
-{
-  if (device->ptr_a11y_data->dwell_timer)
-    {
-      g_source_remove (device->ptr_a11y_data->dwell_timer);
-      device->ptr_a11y_data->dwell_timer = 0;
-      device->ptr_a11y_data->dwell_gesture_started = FALSE;
-
-      g_signal_emit_by_name (device->device_manager,
-                             "ptr-a11y-timeout-stopped",
-                             device,
-                             CLUTTER_A11Y_TIMEOUT_TYPE_DWELL);
-    }
-}
-
-static void
-update_dwell_position (ClutterInputDevice *device)
-{
-  device->ptr_a11y_data->dwell_x = device->ptr_a11y_data->current_x;
-  device->ptr_a11y_data->dwell_y = device->ptr_a11y_data->current_y;
-}
-
-static void
-update_current_position (ClutterInputDevice *device,
-                         float               x,
-                         float               y)
-{
-  device->ptr_a11y_data->current_x = x;
-  device->ptr_a11y_data->current_y = y;
-}
-
-static gboolean
-is_device_core_pointer (ClutterInputDevice *device)
-{
-  ClutterInputDevice *core_pointer;
-
-  core_pointer = clutter_device_manager_get_core_device (device->device_manager,
-                                                         CLUTTER_POINTER_DEVICE);
-  if (core_pointer == NULL)
-    return FALSE;
-
-  return (core_pointer == device);
-}
-
-void
-_clutter_input_pointer_a11y_add_device (ClutterInputDevice *device)
-{
-  if (!is_device_core_pointer (device))
-    return;
-
-  device->accessibility_virtual_device =
-    clutter_device_manager_create_virtual_device (device->device_manager,
-                                                  CLUTTER_POINTER_DEVICE);
-
-  device->ptr_a11y_data = g_new0 (ClutterPtrA11yData, 1);
-}
-
-void
-_clutter_input_pointer_a11y_remove_device (ClutterInputDevice *device)
-{
-  if (!is_device_core_pointer (device))
-    return;
-
-  /* Terminate a drag if started */
-  if (is_dwell_dragging (device))
-    emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
-
-  stop_dwell_timeout (device);
-  stop_secondary_click_timeout (device);
-
-  g_clear_pointer (&device->ptr_a11y_data, g_free);
-}
-
-void
-_clutter_input_pointer_a11y_on_motion_event (ClutterInputDevice *device,
-                                             float               x,
-                                             float               y)
-{
-  if (!is_device_core_pointer (device))
-    return;
-
-  if (!_clutter_is_input_pointer_a11y_enabled (device))
-    return;
-
-  update_current_position (device, x, y);
-
-  if (is_secondary_click_enabled (device))
-    {
-      if (pointer_has_moved (device))
-        stop_secondary_click_timeout (device);
-    }
-
-  if (is_dwell_click_enabled (device))
-    {
-      if (should_stop_dwell (device))
-        stop_dwell_timeout (device);
-      else if (should_start_dwell (device))
-        start_dwell_timeout (device);
-    }
-
-  if (should_update_dwell_position (device))
-    update_dwell_position (device);
-}
-
-void
-_clutter_input_pointer_a11y_on_button_event (ClutterInputDevice *device,
-                                             int                 button,
-                                             gboolean            pressed)
-{
-  if (!is_device_core_pointer (device))
-    return;
-
-  if (!_clutter_is_input_pointer_a11y_enabled (device))
-    return;
-
-  if (pressed)
-    {
-      device->ptr_a11y_data->n_btn_pressed++;
-
-      if (is_dwell_click_enabled (device))
-        stop_dwell_timeout (device);
-
-      if (is_dwell_dragging (device))
-        stop_dwell_timeout (device);
-
-      if (is_secondary_click_enabled (device))
-        {
-          if (button == CLUTTER_BUTTON_PRIMARY)
-            {
-              if (should_start_secondary_click_timeout (device))
-                start_secondary_click_timeout (device);
-            }
-          else if (is_secondary_click_pending (device))
-            {
-              stop_secondary_click_timeout (device);
-            }
-        }
-    }
-  else
-    {
-      if (has_button_pressed (device))
-        device->ptr_a11y_data->n_btn_pressed--;
-
-      if (is_secondary_click_triggered (device))
-        {
-          emit_button_click (device, CLUTTER_BUTTON_SECONDARY);
-          stop_secondary_click_timeout (device);
-        }
-
-      if (is_secondary_click_pending (device))
-        stop_secondary_click_timeout (device);
-
-      if (is_dwell_dragging (device))
-        emit_dwell_click (device, CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG);
-    }
-}
-
-gboolean
-_clutter_is_input_pointer_a11y_enabled (ClutterInputDevice *device)
-{
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
-
-  return (is_secondary_click_enabled (device) || is_dwell_click_enabled (device));
-}

clutter/clutter/clutter-main.c

@@ -58,7 +58,6 @@
 #include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-feature.h"
-#include "clutter-input-pointer-a11y-private.h"
 #include "clutter-main.h"
 #include "clutter-master-clock.h"
 #include "clutter-mutter.h"
@@ -85,6 +84,8 @@ G_LOCK_DEFINE_STATIC (ClutterCntx);
 
 /* main lock and locking/unlocking functions */
 static GMutex clutter_threads_mutex;
+static GCallback clutter_threads_lock        = NULL;
+static GCallback clutter_threads_unlock      = NULL;
 
 /* command line options */
 static gboolean clutter_is_initialized       = FALSE;
@@ -144,10 +145,38 @@ static const GDebugKey clutter_paint_debug_keys[] = {
   { "damage-region", CLUTTER_DEBUG_PAINT_DAMAGE_REGION },
 };
 
+static void
+clutter_threads_impl_lock (void)
+{
+  g_mutex_lock (&clutter_threads_mutex);
+}
+
+static void
+clutter_threads_impl_unlock (void)
+{
+  /* we need to trylock here, in case the lock hasn't been acquired; on
+   * various systems trying to release a mutex that hasn't been acquired
+   * will cause a run-time error. trylock() will either fail, in which
+   * case we can release the lock we own; or it will succeeds, in which
+   * case we need to release the lock we just acquired. so we ignore the
+   * returned value.
+   *
+   * see: https://bugs.gnome.org/679439
+   */
+  g_mutex_trylock (&clutter_threads_mutex);
+  g_mutex_unlock (&clutter_threads_mutex);
+}
+
 static inline void
 clutter_threads_init_default (void)
 {
   g_mutex_init (&clutter_threads_mutex);
+
+  if (clutter_threads_lock == NULL)
+    clutter_threads_lock = clutter_threads_impl_lock;
+
+  if (clutter_threads_unlock == NULL)
+    clutter_threads_unlock = clutter_threads_impl_unlock;
 }
 
 #define ENVIRONMENT_GROUP       "Environment"
@@ -353,6 +382,28 @@ clutter_config_read (void)
   g_free (config_path);
 }
 
+/**
+ * clutter_get_show_fps:
+ *
+ * Returns whether Clutter should print out the frames per second on the
+ * console. You can enable this setting either using the
+ * <literal>CLUTTER_SHOW_FPS</literal> environment variable or passing
+ * the <literal>--clutter-show-fps</literal> command line argument. *
+ *
+ * Return value: %TRUE if Clutter should show the FPS.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.10: This function does not do anything. Use the environment
+ *   variable or the configuration file to determine whether Clutter should
+ *   print out the FPS counter on the console.
+ */
+gboolean
+clutter_get_show_fps (void)
+{
+  return FALSE;
+}
+
 gboolean
 _clutter_context_get_show_fps (void)
 {
@@ -401,6 +452,86 @@ clutter_disable_accessibility (void)
   clutter_enable_accessibility = FALSE;
 }
 
+/**
+ * clutter_redraw:
+ *
+ * Forces a redraw of the entire stage. Applications should never use this
+ * function, but queue a redraw using clutter_actor_queue_redraw().
+ *
+ * This function should only be used by libraries integrating Clutter from
+ * within another toolkit.
+ *
+ * Deprecated: 1.10: Use clutter_stage_ensure_redraw() instead.
+ */
+void
+clutter_redraw (ClutterStage *stage)
+{
+  g_return_if_fail (CLUTTER_IS_STAGE (stage));
+
+  clutter_stage_ensure_redraw (stage);
+}
+
+/**
+ * clutter_set_motion_events_enabled:
+ * @enable: %TRUE to enable per-actor motion events
+ *
+ * Sets whether per-actor motion events should be enabled or not on
+ * all #ClutterStage<!-- -->s managed by Clutter.
+ *
+ * If @enable is %FALSE the following events will not work:
+ *
+ *  - ClutterActor::motion-event, except on the #ClutterStage
+ *  - ClutterActor::enter-event
+ *  - ClutterActor::leave-event
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.8: Use clutter_stage_set_motion_events_enabled() instead.
+ */
+void
+clutter_set_motion_events_enabled (gboolean enable)
+{
+  ClutterStageManager *stage_manager;
+  ClutterMainContext *context;
+  const GSList *l;
+
+  enable = !!enable;
+
+  context = _clutter_context_get_default ();
+  if (context->motion_events_per_actor == enable)
+    return;
+
+  /* store the flag for later query and for newly created stages */
+  context->motion_events_per_actor = enable;
+
+  /* propagate the change to all stages */
+  stage_manager = clutter_stage_manager_get_default ();
+
+  for (l = clutter_stage_manager_peek_stages (stage_manager);
+       l != NULL;
+       l = l->next)
+    {
+      clutter_stage_set_motion_events_enabled (l->data, enable);
+    }
+}
+
+/**
+ * clutter_get_motion_events_enabled:
+ *
+ * Gets whether the per-actor motion events are enabled.
+ *
+ * Return value: %TRUE if the motion events are enabled
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.8: Use clutter_stage_get_motion_events_enabled() instead.
+ */
+gboolean
+clutter_get_motion_events_enabled (void)
+{
+  return _clutter_context_get_motion_events_enabled ();
+}
+
 void
 _clutter_id_to_color (guint         id_,
                       ClutterColor *col)
@@ -652,6 +783,69 @@ clutter_main (void)
   clutter_main_loop_level--;
 }
 
+/**
+ * clutter_threads_init:
+ *
+ * Initialises the Clutter threading mechanism, so that Clutter API can be
+ * called by multiple threads, using clutter_threads_enter() and
+ * clutter_threads_leave() to mark the critical sections.
+ *
+ * You must call g_thread_init() before this function.
+ *
+ * This function must be called before clutter_init().
+ *
+ * It is safe to call this function multiple times.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.10: This function does not do anything. Threading support
+ *   is initialized when Clutter is initialized.
+ */
+void
+clutter_threads_init (void)
+{
+}
+
+/**
+ * clutter_threads_set_lock_functions: (skip)
+ * @enter_fn: function called when aquiring the Clutter main lock
+ * @leave_fn: function called when releasing the Clutter main lock
+ *
+ * Allows the application to replace the standard method that
+ * Clutter uses to protect its data structures. Normally, Clutter
+ * creates a single #GMutex that is locked by clutter_threads_enter(),
+ * and released by clutter_threads_leave(); using this function an
+ * application provides, instead, a function @enter_fn that is
+ * called by clutter_threads_enter() and a function @leave_fn that is
+ * called by clutter_threads_leave().
+ *
+ * The functions must provide at least same locking functionality
+ * as the default implementation, but can also do extra application
+ * specific processing.
+ *
+ * As an example, consider an application that has its own recursive
+ * lock that when held, holds the Clutter lock as well. When Clutter
+ * unlocks the Clutter lock when entering a recursive main loop, the
+ * application must temporarily release its lock as well.
+ *
+ * Most threaded Clutter apps won't need to use this method.
+ *
+ * This method must be called before clutter_init(), and cannot
+ * be called multiple times.
+ *
+ * Since: 0.4
+ */
+void
+clutter_threads_set_lock_functions (GCallback enter_fn,
+                                    GCallback leave_fn)
+{
+  g_return_if_fail (clutter_threads_lock == NULL &&
+                    clutter_threads_unlock == NULL);
+
+  clutter_threads_lock = enter_fn;
+  clutter_threads_unlock = leave_fn;
+}
+
 gboolean
 _clutter_threads_dispatch (gpointer data)
 {
@@ -708,11 +902,17 @@ _clutter_threads_dispatch_free (gpointer data)
  *    SafeClosure *closure = data;
  *    gboolean res = FALSE;
  *
+ *    // mark the critical section //
+ *
+ *    clutter_threads_enter();
+ *
  *    // the callback does not need to acquire the Clutter
  *     / lock itself, as it is held by the this proxy handler
  *     //
  *    res = closure->callback (closure->data);
  *
+ *    clutter_threads_leave();
+ *
  *    return res;
  * }
  * static gulong
@@ -892,23 +1092,69 @@ clutter_threads_add_timeout (guint       interval,
 void
 _clutter_threads_acquire_lock (void)
 {
-  g_mutex_lock (&clutter_threads_mutex);
+  if (clutter_threads_lock != NULL)
+    (* clutter_threads_lock) ();
 }
 
 void
 _clutter_threads_release_lock (void)
 {
-  /* we need to trylock here, in case the lock hasn't been acquired; on
-   * various systems trying to release a mutex that hasn't been acquired
-   * will cause a run-time error. trylock() will either fail, in which
-   * case we can release the lock we own; or it will succeeds, in which
-   * case we need to release the lock we just acquired. so we ignore the
-   * returned value.
-   *
-   * see: https://bugs.gnome.org/679439
-   */
-  g_mutex_trylock (&clutter_threads_mutex);
-  g_mutex_unlock (&clutter_threads_mutex);
+  if (clutter_threads_unlock != NULL)
+    (* clutter_threads_unlock) ();
+}
+
+/**
+ * clutter_threads_enter:
+ *
+ * Locks the Clutter thread lock.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.12: This function should not be used by application
+ *   code; marking critical sections is not portable on various
+ *   platforms. Instead of acquiring the Clutter lock, schedule UI
+ *   updates from the main loop using clutter_threads_add_idle() or
+ *   clutter_threads_add_timeout().
+ */
+void
+clutter_threads_enter (void)
+{
+  _clutter_threads_acquire_lock ();
+}
+
+/**
+ * clutter_threads_leave:
+ *
+ * Unlocks the Clutter thread lock.
+ *
+ * Since: 0.4
+ *
+ * Deprecated: 1.12: This function should not be used by application
+ *   code; marking critical sections is not portable on various
+ *   platforms. Instead of acquiring the Clutter lock, schedule UI
+ *   updates from the main loop using clutter_threads_add_idle() or
+ *   clutter_threads_add_timeout().
+ */
+void
+clutter_threads_leave (void)
+{
+  _clutter_threads_release_lock ();
+}
+
+
+/**
+ * clutter_get_debug_enabled:
+ *
+ * Check if Clutter has debugging enabled.
+ *
+ * Return value: %FALSE
+ *
+ * Deprecated: 1.10: This function does not do anything.
+ */
+gboolean
+clutter_get_debug_enabled (void)
+{
+  return FALSE;
 }
 
 void
@@ -958,6 +1204,7 @@ clutter_context_get_default_unlocked (void)
       ctx->settings = clutter_settings_get_default ();
       _clutter_settings_set_backend (ctx->settings, ctx->backend);
 
+      ctx->motion_events_per_actor = TRUE;
       ctx->last_repaint_id = 1;
     }
 
@@ -978,6 +1225,36 @@ _clutter_context_get_default (void)
   return retval;
 }
 
+/**
+ * clutter_get_timestamp:
+ *
+ * Returns the approximate number of microseconds passed since Clutter was
+ * intialised.
+ *
+ * This function shdould not be used by application code.
+ *
+ * The output of this function depends on whether Clutter was configured to
+ * enable its debugging code paths, so it's less useful than intended.
+ *
+ * Since Clutter 1.10, this function is an alias to g_get_monotonic_time()
+ * if Clutter was configured to enable the debugging code paths.
+ *
+ * Return value: Number of microseconds since clutter_init() was called, or
+ *   zero if Clutter was not configured with debugging code paths.
+ *
+ * Deprecated: 1.10: Use #GTimer or g_get_monotonic_time() for a proper
+ *   timing source
+ */
+gulong
+clutter_get_timestamp (void)
+{
+#ifdef CLUTTER_ENABLE_DEBUG
+  return (gulong) g_get_monotonic_time ();
+#else
+  return 0L;
+#endif
+}
+
 static gboolean
 clutter_arg_direction_cb (const char *key,
                           const char *value,
@@ -1984,21 +2261,6 @@ _clutter_process_event_details (ClutterActor        *stage,
         break;
 
       case CLUTTER_MOTION:
-#ifdef CLUTTER_WINDOWING_X11
-        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
-          {
-            if (_clutter_is_input_pointer_a11y_enabled (device))
-              {
-                ClutterInputDevice *core_pointer;
-                gfloat x, y;
-
-                clutter_event_get_coords (event, &x, &y);
-                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
-                                                                       CLUTTER_POINTER_DEVICE);
-                _clutter_input_pointer_a11y_on_motion_event (core_pointer, x, y);
-              }
-          }
-#endif /* CLUTTER_WINDOWING_X11 */
         /* only the stage gets motion events if they are enabled */
         if (!clutter_stage_get_motion_events_enabled (CLUTTER_STAGE (stage)) &&
             event->any.source == NULL)
@@ -2037,22 +2299,6 @@ _clutter_process_event_details (ClutterActor        *stage,
       /* fallthrough from motion */
       case CLUTTER_BUTTON_PRESS:
       case CLUTTER_BUTTON_RELEASE:
-#ifdef CLUTTER_WINDOWING_X11
-        if (!clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))
-          {
-            if (_clutter_is_input_pointer_a11y_enabled (device) && (event->type != CLUTTER_MOTION))
-              {
-                ClutterInputDevice *core_pointer;
-
-                core_pointer = clutter_device_manager_get_core_device (device->device_manager,
-                                                                       CLUTTER_POINTER_DEVICE);
-
-                _clutter_input_pointer_a11y_on_button_event (core_pointer,
-                                                             event->button.button,
-                                                             event->type == CLUTTER_BUTTON_PRESS);
-              }
-          }
-#endif /* CLUTTER_WINDOWING_X11 */
       case CLUTTER_SCROLL:
       case CLUTTER_TOUCHPAD_PINCH:
       case CLUTTER_TOUCHPAD_SWIPE:
@@ -2274,7 +2520,7 @@ _clutter_process_event_details (ClutterActor        *stage,
         break;
 
       case CLUTTER_STAGE_STATE:
-        /* focus - forward to stage */
+        /* fullscreen / focus - forward to stage */
         event->any.source = stage;
         if (!_clutter_event_process_filters (event))
           clutter_stage_event (CLUTTER_STAGE (stage), event);
@@ -2380,6 +2626,24 @@ clutter_get_default_frame_rate (void)
   return context->frame_rate;
 }
 
+/**
+ * clutter_set_default_frame_rate:
+ * @frames_per_sec: the new default frame rate
+ *
+ * Sets the default frame rate. This frame rate will be used to limit
+ * the number of frames drawn if Clutter is not able to synchronize
+ * with the vertical refresh rate of the display. When synchronization
+ * is possible, this value is ignored.
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.10: This function does not do anything any more.
+ */
+void
+clutter_set_default_frame_rate (guint frames_per_sec)
+{
+}
+
 static void
 on_grab_actor_destroy (ClutterActor       *actor,
                        ClutterInputDevice *device)
@@ -2594,6 +2858,57 @@ clutter_input_device_get_grabbed_actor (ClutterInputDevice *device)
   return NULL;
 }
 
+/**
+ * clutter_grab_pointer_for_device:
+ * @actor: a #ClutterActor
+ * @id_: a device id, or -1
+ *
+ * Grabs all the pointer events coming from the device @id for @actor.
+ *
+ * If @id is -1 then this function is equivalent to clutter_grab_pointer().
+ *
+ * Since: 0.8
+ *
+ * Deprecated: 1.10: Use clutter_input_device_grab() instead.
+ */
+void
+clutter_grab_pointer_for_device (ClutterActor *actor,
+                                 gint          id_)
+{
+  ClutterDeviceManager *manager;
+  ClutterInputDevice *dev;
+
+  g_return_if_fail (actor == NULL || CLUTTER_IS_ACTOR (actor));
+
+  /* essentially a global grab */
+  if (id_ == -1)
+    {
+      if (actor == NULL)
+        clutter_ungrab_pointer ();
+      else
+        clutter_grab_pointer (actor);
+
+      return;
+    }
+
+  manager = clutter_device_manager_get_default ();
+  if (manager == NULL)
+    return;
+
+  dev = clutter_device_manager_get_device (manager, id_);
+  if (dev == NULL)
+    return;
+
+  if (dev->device_type != CLUTTER_POINTER_DEVICE)
+    return;
+
+  if (actor == NULL)
+    clutter_input_device_ungrab (dev);
+  else
+    clutter_input_device_grab (dev, actor);
+}
+
+
 /**
  * clutter_ungrab_pointer:
  *
@@ -2607,6 +2922,32 @@ clutter_ungrab_pointer (void)
   clutter_grab_pointer (NULL);
 }
 
+/**
+ * clutter_ungrab_pointer_for_device:
+ * @id_: a device id
+ *
+ * Removes an existing grab of the pointer events for device @id_.
+ *
+ * Since: 0.8
+ *
+ * Deprecated: 1.10: Use clutter_input_device_ungrab() instead.
+ */
+void
+clutter_ungrab_pointer_for_device (gint id_)
+{
+  ClutterDeviceManager *manager;
+  ClutterInputDevice *device;
+
+  manager = clutter_device_manager_get_default ();
+  if (manager == NULL)
+    return;
+
+  device = clutter_device_manager_get_device (manager, id_);
+  if (device != NULL)
+    clutter_input_device_ungrab (device);
+}
+
+
 /**
  * clutter_get_pointer_grab:
  *
@@ -2706,6 +3047,170 @@ clutter_get_keyboard_grab (void)
   return context->keyboard_grab_actor;
 }
 
+/**
+ * clutter_clear_glyph_cache:
+ *
+ * Clears the internal cache of glyphs used by the Pango
+ * renderer. This will free up some memory and GL texture
+ * resources. The cache will be automatically refilled as more text is
+ * drawn.
+ *
+ * Since: 0.8
+ *
+ * Deprecated: 1.10: Use clutter_get_font_map() and
+ *   cogl_pango_font_map_clear_glyph_cache() instead.
+ */
+void
+clutter_clear_glyph_cache (void)
+{
+  CoglPangoFontMap *font_map;
+
+  font_map = clutter_context_get_pango_fontmap ();
+  cogl_pango_font_map_clear_glyph_cache (font_map);
+}
+
+/**
+ * clutter_set_font_flags:
+ * @flags: The new flags
+ *
+ * Sets the font quality options for subsequent text rendering
+ * operations.
+ *
+ * Using mipmapped textures will improve the quality for scaled down
+ * text but will use more texture memory.
+ *
+ * Enabling hinting improves text quality for static text but may
+ * introduce some artifacts if the text is animated.
+ *
+ * Since: 1.0
+ *
+ * Deprecated: 1.10: Use clutter_backend_set_font_options() and the
+ *   #cairo_font_option_t API.
+ */
+void
+clutter_set_font_flags (ClutterFontFlags flags)
+{
+  CoglPangoFontMap *font_map;
+  ClutterFontFlags old_flags, changed_flags;
+  const cairo_font_options_t *font_options;
+  cairo_font_options_t *new_font_options;
+  cairo_hint_style_t hint_style;
+  gboolean use_mipmapping;
+  ClutterBackend *backend;
+
+  backend = clutter_get_default_backend ();
+  font_map = clutter_context_get_pango_fontmap ();
+  font_options = clutter_backend_get_font_options (backend);
+  old_flags = 0;
+
+  if (cogl_pango_font_map_get_use_mipmapping (font_map))
+    old_flags |= CLUTTER_FONT_MIPMAPPING;
+
+  hint_style = cairo_font_options_get_hint_style (font_options);
+  if (hint_style != CAIRO_HINT_STYLE_DEFAULT &&
+      hint_style != CAIRO_HINT_STYLE_NONE)
+    old_flags |= CLUTTER_FONT_HINTING;
+
+  if (old_flags == flags)
+    return;
+
+  new_font_options = cairo_font_options_copy (font_options);
+
+  /* Only set the font options that have actually changed so we don't
+     override a detailed setting from the backend */
+  changed_flags = old_flags ^ flags;
+
+  if ((changed_flags & CLUTTER_FONT_MIPMAPPING))
+    {
+      use_mipmapping = (changed_flags & CLUTTER_FONT_MIPMAPPING) != 0;
+
+      cogl_pango_font_map_set_use_mipmapping (font_map, use_mipmapping);
+    }
+
+  if ((changed_flags & CLUTTER_FONT_HINTING))
+    {
+      hint_style = (flags & CLUTTER_FONT_HINTING)
+                 ? CAIRO_HINT_STYLE_FULL
+                 : CAIRO_HINT_STYLE_NONE;
+
+      cairo_font_options_set_hint_style (new_font_options, hint_style);
+    }
+
+  clutter_backend_set_font_options (backend, new_font_options);
+
+  cairo_font_options_destroy (new_font_options);
+}
+
+/**
+ * clutter_get_font_flags:
+ *
+ * Gets the current font flags for rendering text. See
+ * clutter_set_font_flags().
+ *
+ * Return value: The font flags
+ *
+ * Since: 1.0
+ *
+ * Deprecated: 1.10: Use clutter_backend_get_font_options() and the
+ *   #cairo_font_options_t API.
+ */
+ClutterFontFlags
+clutter_get_font_flags (void)
+{
+  CoglPangoFontMap *font_map = NULL;
+  const cairo_font_options_t *font_options;
+  ClutterFontFlags flags = 0;
+  cairo_hint_style_t hint_style;
+
+  font_map = clutter_context_get_pango_fontmap ();
+  if (cogl_pango_font_map_get_use_mipmapping (font_map))
+    flags |= CLUTTER_FONT_MIPMAPPING;
+
+  font_options =
+    clutter_backend_get_font_options (clutter_get_default_backend ());
+
+  hint_style = cairo_font_options_get_hint_style (font_options);
+  if (hint_style != CAIRO_HINT_STYLE_DEFAULT &&
+      hint_style != CAIRO_HINT_STYLE_NONE)
+    flags |= CLUTTER_FONT_HINTING;
+
+  return flags;
+}
+
+/**
+ * clutter_get_input_device_for_id:
+ * @id_: the unique id for a device
+ *
+ * Retrieves the #ClutterInputDevice from its @id_. This is a convenience
+ * wrapper for clutter_device_manager_get_device() and it is functionally
+ * equivalent to:
+ *
+ * |[
+ *   ClutterDeviceManager *manager;
+ *   ClutterInputDevice *device;
+ *
+ *   manager = clutter_device_manager_get_default ();
+ *   device = clutter_device_manager_get_device (manager, id);
+ * ]|
+ *
+ * Return value: (transfer none): a #ClutterInputDevice, or %NULL
+ *
+ * Since: 0.8
+ *
+ * Deprecated: 1.10: Use clutter_device_manager_get_device() instead.
+ */
+ClutterInputDevice *
+clutter_get_input_device_for_id (gint id_)
+{
+  ClutterDeviceManager *manager;
+
+  manager = clutter_device_manager_get_default ();
+  if (manager == NULL)
+    return NULL;
+
+  return clutter_device_manager_get_device (manager, id_);
+}
+
 /**
  * clutter_get_font_map:
  *
@@ -3040,6 +3545,43 @@ _clutter_context_get_pick_mode (void)
   return context->pick_mode;
 }
 
+void
+_clutter_context_push_shader_stack (ClutterActor *actor)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  context->shaders = g_slist_prepend (context->shaders, actor);
+}
+
+ClutterActor *
+_clutter_context_peek_shader_stack (void)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  if (context->shaders != NULL)
+    return context->shaders->data;
+
+  return NULL;
+}
+
+ClutterActor *
+_clutter_context_pop_shader_stack (ClutterActor *actor)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  context->shaders = g_slist_remove (context->shaders, actor);
+
+  return _clutter_context_peek_shader_stack ();
+}
+
+gboolean
+_clutter_context_get_motion_events_enabled (void)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+
+  return context->motion_events_per_actor;
+}
+
 /**
  * clutter_check_windowing_backend:
  * @backend_type: the name of the backend to check

clutter/clutter/clutter-main.h

@@ -117,6 +117,9 @@ void                    clutter_disable_accessibility           (void);
 
 /* Threading functions */
 CLUTTER_EXPORT
+void                    clutter_threads_set_lock_functions      (GCallback enter_fn,
+                                                                 GCallback leave_fn);
+CLUTTER_EXPORT
 guint                   clutter_threads_add_idle                (GSourceFunc    func,
                                                                  gpointer       data);
 CLUTTER_EXPORT

clutter/clutter/clutter-marshal.list

@@ -23,7 +23,6 @@ VOID:FLOAT,FLOAT
 VOID:INT,INT,INT,INT
 VOID:OBJECT
 VOID:OBJECT,FLAGS
-VOID:OBJECT,FLAGS,UINT
 VOID:OBJECT,FLOAT,FLOAT
 VOID:OBJECT,FLOAT,FLOAT,FLAGS
 VOID:OBJECT,OBJECT

clutter/clutter/clutter-master-clock-default.c

@@ -64,6 +64,9 @@ struct _ClutterMasterClockDefault
   /* the current state of the clock, in usecs */
   gint64 cur_tick;
 
+  /* the previous state of the clock, in usecs, used to compute the delta */
+  gint64 prev_tick;
+
 #ifdef CLUTTER_ENABLE_DEBUG
   gint64 frame_budget;
   gint64 remaining_budget;
@@ -74,6 +77,12 @@ struct _ClutterMasterClockDefault
    */
   GSource *source;
 
+  /* If the master clock is idle that means it has
+   * fallen back to idle polling for timeline
+   * progressions and it may have been some time since
+   * the last real stage update.
+   */
+  guint idle : 1;
   guint ensure_next_iteration : 1;
 
   guint paused : 1;
@@ -266,12 +275,78 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
 static gint
 master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
 {
+  gint64 now, next;
+  gint swap_delay;
+
   if (!master_clock_is_running (master_clock))
     return -1;
 
   /* If all of the stages are busy waiting for a swap-buffers to complete
    * then we wait for one to be ready.. */
-  return master_clock_get_swap_wait_time (master_clock);
+  swap_delay = master_clock_get_swap_wait_time (master_clock);
+  if (swap_delay != 0)
+    return swap_delay;
+
+  /* When we have sync-to-vblank, we count on swap-buffer requests (or
+   * swap-buffer-complete events if supported in the backend) to throttle our
+   * frame rate so no additional delay is needed to start the next frame.
+   *
+   * If the master-clock has become idle due to no timeline progression causing
+   * redraws then we can no longer rely on vblank synchronization because the
+   * last real stage update/redraw may have happened a long time ago and so we
+   * fallback to polling for timeline progressions every 1/frame_rate seconds.
+   *
+   * (NB: if there aren't even any timelines running then the master clock will
+   * be completely stopped in master_clock_is_running())
+   */
+  if (clutter_feature_available (CLUTTER_FEATURE_SWAP_THROTTLE) &&
+      !master_clock->idle)
+    {
+      CLUTTER_NOTE (SCHEDULER, "swap throttling available and updated stages");
+      return 0;
+    }
+
+  if (master_clock->prev_tick == 0)
+    {
+      /* If we weren't previously running, then draw the next frame
+       * immediately
+       */
+      CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
+      return 0;
+    }
+
+  /* Otherwise, wait at least 1/frame_rate seconds since we last
+   * started a frame
+   */
+  now = g_source_get_time (master_clock->source);
+
+  next = master_clock->prev_tick;
+
+  /* If time has gone backwards then there's no way of knowing how
+     long we should wait so let's just dispatch immediately */
+  if (now <= next)
+    {
+      CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
+
+      return 0;
+    }
+
+  next += (1000000L / clutter_get_default_frame_rate ());
+
+  if (next <= now)
+    {
+      CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
+                    1000000L / (gulong) clutter_get_default_frame_rate ());
+
+      return 0;
+    }
+  else
+    {
+      CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
+                   (next - now) / 1000);
+
+      return (next - now) / 1000;
+    }
 }
 
 static void
@@ -455,6 +530,7 @@ clutter_clock_dispatch (GSource     *source,
 {
   ClutterClockSource *clock_source = (ClutterClockSource *) source;
   ClutterMasterClockDefault *master_clock = clock_source->master_clock;
+  gboolean stages_updated = FALSE;
   GSList *stages;
 
   CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
@@ -474,6 +550,8 @@ clutter_clock_dispatch (GSource     *source,
    */
   stages = master_clock_list_ready_stages (master_clock);
 
+  master_clock->idle = FALSE;
+
   /* Each frame is split into three separate phases: */
 
   /* 1. process all the events; each stage goes through its events queue
@@ -486,12 +564,19 @@ clutter_clock_dispatch (GSource     *source,
   master_clock_advance_timelines (master_clock);
 
   /* 3. relayout and redraw the stages */
-  master_clock_update_stages (master_clock, stages);
+  stages_updated = master_clock_update_stages (master_clock, stages);
+
+  /* The master clock goes idle if no stages were updated and falls back
+   * to polling for timeline progressions... */
+  if (!stages_updated)
+    master_clock->idle = TRUE;
 
   master_clock_reschedule_stage_updates (master_clock, stages);
 
   g_slist_free_full (stages, g_object_unref);
 
+  master_clock->prev_tick = master_clock->cur_tick;
+
   _clutter_threads_release_lock ();
 
   return TRUE;
@@ -523,6 +608,7 @@ clutter_master_clock_default_init (ClutterMasterClockDefault *self)
   source = clutter_clock_source_new (self);
   self->source = source;
 
+  self->idle = FALSE;
   self->ensure_next_iteration = FALSE;
   self->paused = FALSE;
 

clutter/clutter/clutter-private.h

@@ -146,6 +146,9 @@ struct _ClutterMainContext
   ClutterActor *pointer_grab_actor;
   ClutterActor *keyboard_grab_actor;
 
+  /* stack of actors with shaders during paint */
+  GSList *shaders;
+
   /* fb bit masks for col<->id mapping in picking */
   gint fb_r_mask;
   gint fb_g_mask;
@@ -170,6 +173,7 @@ struct _ClutterMainContext
 
   /* boolean flags */
   guint is_initialized          : 1;
+  guint motion_events_per_actor : 1;
   guint defer_display_setup     : 1;
   guint options_parsed          : 1;
   guint show_fps                : 1;
@@ -194,6 +198,10 @@ void                    _clutter_context_lock                           (void);
 void                    _clutter_context_unlock                         (void);
 gboolean                _clutter_context_is_initialized                 (void);
 ClutterPickMode         _clutter_context_get_pick_mode                  (void);
+void                    _clutter_context_push_shader_stack              (ClutterActor *actor);
+ClutterActor *          _clutter_context_pop_shader_stack               (ClutterActor *actor);
+ClutterActor *          _clutter_context_peek_shader_stack              (void);
+gboolean                _clutter_context_get_motion_events_enabled      (void);
 gboolean                _clutter_context_get_show_fps                   (void);
 
 gboolean      _clutter_feature_init (GError **error);

clutter/clutter/clutter-script-parser.c

@@ -1636,17 +1636,14 @@ clutter_script_translate_parameters (ClutterScript  *script,
                                      GObject        *object,
                                      const gchar    *name,
                                      GList          *properties,
-                                     GPtrArray     **param_names,
-                                     GArray        **param_values)
+                                     GArray        **params)
 {
   ClutterScriptable *scriptable = NULL;
   ClutterScriptableIface *iface = NULL;
   GList *l, *unparsed;
   gboolean parse_custom = FALSE;
 
-  *param_names = g_ptr_array_new_with_free_func (g_free);
-  *param_values = g_array_new (FALSE, FALSE, sizeof (GValue));
-  g_array_set_clear_func (*param_values, (GDestroyNotify) g_value_unset);
+  *params = g_array_new (FALSE, FALSE, sizeof (GParameter));
 
   if (CLUTTER_IS_SCRIPTABLE (object))
     {
@@ -1662,7 +1659,7 @@ clutter_script_translate_parameters (ClutterScript  *script,
   for (l = properties; l != NULL; l = l->next)
     {
       PropertyInfo *pinfo = l->data;
-      GValue value = G_VALUE_INIT;
+      GParameter param = { NULL };
       gboolean res = FALSE;
 
       if (pinfo->is_child || pinfo->is_layout)
@@ -1679,12 +1676,12 @@ clutter_script_translate_parameters (ClutterScript  *script,
                     pinfo->name);
 
       if (parse_custom)
-        res = iface->parse_custom_node (scriptable, script, &value,
+        res = iface->parse_custom_node (scriptable, script, &param.value,
                                         pinfo->name,
                                         pinfo->node);
 
       if (!res)
-        res = _clutter_script_parse_node (script, &value,
+        res = _clutter_script_parse_node (script, &param.value,
                                           pinfo->name,
                                           pinfo->node,
                                           pinfo->pspec);
@@ -1696,8 +1693,9 @@ clutter_script_translate_parameters (ClutterScript  *script,
           continue;
         }
 
-      g_ptr_array_add (*param_names, g_strdup (pinfo->name));
-      g_array_append_val (*param_values, value);
+      param.name = g_strdup (pinfo->name);
+
+      g_array_append_val (*params, param);
 
       property_info_free (pinfo);
     }
@@ -1712,8 +1710,7 @@ clutter_script_construct_parameters (ClutterScript  *script,
                                      GType           gtype,
                                      const gchar    *name,
                                      GList          *properties,
-                                     GPtrArray     **construct_param_names,
-                                     GArray        **construct_param_values)
+                                     GArray        **construct_params)
 {
   GObjectClass *klass;
   GList *l, *unparsed;
@@ -1721,17 +1718,14 @@ clutter_script_construct_parameters (ClutterScript  *script,
   klass = g_type_class_ref (gtype);
   g_assert (klass != NULL);
 
-  *construct_param_names = g_ptr_array_new_with_free_func (g_free);
-  *construct_param_values = g_array_new (FALSE, FALSE, sizeof (GValue));
-  g_array_set_clear_func (*construct_param_values,
-                          (GDestroyNotify) g_value_unset);
+  *construct_params = g_array_new (FALSE, FALSE, sizeof (GParameter));
 
   unparsed = NULL;
 
   for (l = properties; l != NULL; l = l->next)
     {
       PropertyInfo *pinfo = l->data;
-      GValue value = G_VALUE_INIT;
+      GParameter param = { NULL };
       GParamSpec *pspec = NULL;
 
       /* we allow custom property names for classes, so if we
@@ -1755,7 +1749,9 @@ clutter_script_construct_parameters (ClutterScript  *script,
           continue;
         }
 
-      if (!_clutter_script_parse_node (script, &value,
+      param.name = g_strdup (pinfo->name);
+
+      if (!_clutter_script_parse_node (script, &param.value,
                                        pinfo->name,
                                        pinfo->node,
                                        pinfo->pspec))
@@ -1764,8 +1760,7 @@ clutter_script_construct_parameters (ClutterScript  *script,
           continue;
         }
 
-      g_ptr_array_add (*construct_param_names, g_strdup (pinfo->name));
-      g_array_append_val (*construct_param_values, value);
+      g_array_append_val (*construct_params, param);
 
       property_info_free (pinfo);
     }
@@ -2092,8 +2087,7 @@ _clutter_script_apply_properties (ClutterScript *script,
   gboolean set_custom_property = FALSE;
   GObject *object = oinfo->object;
   GList *properties;
-  g_autoptr (GPtrArray) param_names = NULL;
-  g_autoptr (GArray) param_values = NULL;
+  GArray *params;
   guint i;
 
   if (!oinfo->has_unresolved)
@@ -2117,31 +2111,34 @@ _clutter_script_apply_properties (ClutterScript *script,
                                                            object,
                                                            oinfo->id,
                                                            properties,
-                                                           &param_names,
-                                                           &param_values);
+                                                           &params);
 
   /* consume all the properties we could translate in this pass */
-  for (i = 0; i < param_names->len; i++)
+  for (i = 0; i < params->len; i++)
     {
-      char *name = g_ptr_array_index (param_names, i);
-      GValue *value = &g_array_index (param_values, GValue, i);
+      GParameter *param = &g_array_index (params, GParameter, i);
 
       CLUTTER_NOTE (SCRIPT,
                     "Setting %s property '%s' (type:%s) to object '%s' (id:%s)",
                     set_custom_property ? "custom" : "regular",
-                    name,
-                    g_type_name (G_VALUE_TYPE (value)),
+                    param->name,
+                    g_type_name (G_VALUE_TYPE (&param->value)),
                     g_type_name (oinfo->gtype),
                     oinfo->id);
 
       if (set_custom_property)
         iface->set_custom_property (scriptable, script,
-                                    name,
-                                    value);
+                                    param->name,
+                                    &param->value);
       else
-        g_object_set_property (object, name, value);
+        g_object_set_property (object, param->name, &param->value);
+
+      g_free ((gchar *) param->name);
+      g_value_unset (&param->value);
     }
 
+  g_array_free (params, TRUE);
+
   _clutter_script_check_unresolved (script, oinfo);
 }
 
@@ -2149,8 +2146,8 @@ void
 _clutter_script_construct_object (ClutterScript *script,
                                   ObjectInfo    *oinfo)
 {
-  g_autoptr (GPtrArray) param_names = NULL;
-  g_autoptr (GArray) param_values = NULL;
+  GArray *params = NULL;
+  guint i;
 
   /* we have completely updated the object */
   if (oinfo->object != NULL)
@@ -2193,14 +2190,25 @@ _clutter_script_construct_object (ClutterScript *script,
                                              oinfo->gtype,
                                              oinfo->id,
                                              properties,
-                                             &param_names,
-                                             &param_values);
+                                             &params);
 
       default_stage = clutter_stage_manager_get_default_stage (manager);
       oinfo->object = G_OBJECT (default_stage);
+
+      for (i = 0; i < params->len; i++)
+        {
+          GParameter *param = &g_array_index (params, GParameter, i);
+
+          g_free ((gchar *) param->name);
+          g_value_unset (&param->value);
+        }
+
+      g_array_free (params, TRUE);
     }
   else
     {
+      g_autoptr (GPtrArray) param_names = NULL;
+      GArray *param_values;
       GList *properties = oinfo->properties;
 
       /* every other object: first, we get the construction parameters */
@@ -2209,11 +2217,22 @@ _clutter_script_construct_object (ClutterScript *script,
                                              oinfo->gtype,
                                              oinfo->id,
                                              properties,
-                                             &param_names,
-                                             &param_values);
+                                             &params);
+
+      /* Convert GParameter → (GStrv, GValue[]) */
+      param_names = g_ptr_array_sized_new (params->len);
+      param_values = g_array_sized_new (TRUE, FALSE, sizeof (GValue), params->len);
+      for (i = 0; i < params->len; i++)
+        {
+          GParameter *param = &g_array_index (params, GParameter, i);
+
+          g_ptr_array_add (param_names, (gchar *) param->name);
+          g_array_append_val (param_values, param->value);
+        }
+      g_ptr_array_add (param_names, NULL);
 
       oinfo->object = g_object_new_with_properties (oinfo->gtype,
-                                                    param_names->len,
+                                                    params->len,
                                                     (const gchar **) param_names->pdata,
                                                     (const GValue *) param_values->data);
 
@@ -2222,6 +2241,17 @@ _clutter_script_construct_object (ClutterScript *script,
        * else too or only by this ClutterScript object.
        */
       g_object_ref_sink (oinfo->object);
+
+      for (i = 0; i < params->len; i++)
+        {
+          GParameter *param = &g_array_index (params, GParameter, i);
+
+          g_free ((gchar *) param->name);
+          g_value_unset (&param->value);
+        }
+
+      g_array_free (param_values, FALSE);
+      g_array_free (params, TRUE);
    }
 
   g_assert (oinfo->object != NULL);

clutter/clutter/clutter-script.c

@@ -263,6 +263,8 @@ enum
 
 static GParamSpec *obj_props[PROP_LAST];
 
+#define CLUTTER_SCRIPT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_SCRIPT, ClutterScriptPrivate))
+
 struct _ClutterScriptPrivate
 {
   GHashTable *objects;
@@ -375,7 +377,7 @@ object_info_free (gpointer data)
 static void
 clutter_script_finalize (GObject *gobject)
 {
-  ClutterScriptPrivate *priv = CLUTTER_SCRIPT (gobject)->priv;
+  ClutterScriptPrivate *priv = CLUTTER_SCRIPT_GET_PRIVATE (gobject);
 
   g_object_unref (priv->parser);
   g_hash_table_destroy (priv->objects);

clutter/clutter/clutter-stage-private.h

@@ -40,7 +40,6 @@ void                _clutter_stage_paint_view            (ClutterStage
                                                           ClutterStageView            *view,
                                                           const cairo_rectangle_int_t *clip);
 
-void                _clutter_stage_emit_after_paint      (ClutterStage          *stage);
 void                _clutter_stage_set_window            (ClutterStage          *stage,
                                                           ClutterStageWindow    *stage_window);
 ClutterStageWindow *_clutter_stage_get_window            (ClutterStage          *stage);
@@ -118,6 +117,7 @@ void            _clutter_stage_remove_touch_drag_actor (ClutterStage         *st
 
 ClutterStageState       _clutter_stage_get_state        (ClutterStage      *stage);
 gboolean                _clutter_stage_is_activated     (ClutterStage      *stage);
+gboolean                _clutter_stage_is_fullscreen    (ClutterStage      *stage);
 gboolean                _clutter_stage_update_state     (ClutterStage      *stage,
                                                          ClutterStageState  unset_state,
                                                          ClutterStageState  set_state);

clutter/clutter/clutter-stage-view-private.h

@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2019 Red Hat Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef __CLUTTER_STAGE_VIEW_PRIVATE_H__
-#define __CLUTTER_STAGE_VIEW_PRIVATE_H__
-
-#include "clutter/clutter-stage-view.h"
-
-void clutter_stage_view_blit_offscreen (ClutterStageView            *view,
-                                        const cairo_rectangle_int_t *clip);
-
-gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);
-
-void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
-                                            gboolean          dirty);
-
-gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);
-
-void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
-                                              gboolean          dirty);
-
-
-#endif /* __CLUTTER_STAGE_VIEW_PRIVATE_H__ */

clutter/clutter/clutter-stage-view.c

@@ -18,7 +18,6 @@
 #include "clutter-build-config.h"
 
 #include "clutter/clutter-stage-view.h"
-#include "clutter/clutter-stage-view-private.h"
 
 #include <cairo-gobject.h>
 #include <math.h>
@@ -62,14 +61,6 @@ clutter_stage_view_get_layout (ClutterStageView      *view,
   *rect = priv->layout;
 }
 
-/**
- * clutter_stage_view_get_framebuffer:
- * @view: a #ClutterStageView
- *
- * Retrieves the framebuffer of @view to draw to.
- *
- * Returns: (transfer none): a #CoglFramebuffer
- */
 CoglFramebuffer *
 clutter_stage_view_get_framebuffer (ClutterStageView *view)
 {
@@ -82,14 +73,6 @@ clutter_stage_view_get_framebuffer (ClutterStageView *view)
     return priv->framebuffer;
 }
 
-/**
- * clutter_stage_view_get_onscreen:
- * @view: a #ClutterStageView
- *
- * Retrieves the onscreen framebuffer of @view if available.
- *
- * Returns: (transfer none): a #CoglFramebuffer
- */
 CoglFramebuffer *
 clutter_stage_view_get_onscreen (ClutterStageView *view)
 {

clutter/clutter/clutter-stage-view.h

@@ -18,10 +18,6 @@
 #ifndef __CLUTTER_STAGE_VIEW_H__
 #define __CLUTTER_STAGE_VIEW_H__
 
-#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
-#error "Only <clutter/clutter.h> can be included directly."
-#endif
-
 #include <cairo.h>
 #include <glib-object.h>
 #include <cogl/cogl.h>
@@ -61,9 +57,22 @@ void             clutter_stage_view_transform_to_onscreen (ClutterStageView *vie
                                                            gfloat           *x,
                                                            gfloat           *y);
 
+void clutter_stage_view_blit_offscreen (ClutterStageView            *view,
+					const cairo_rectangle_int_t *clip);
+
 CLUTTER_EXPORT
 float clutter_stage_view_get_scale (ClutterStageView *view);
 
+gboolean clutter_stage_view_is_dirty_viewport (ClutterStageView *view);
+
+void clutter_stage_view_set_dirty_viewport (ClutterStageView *view,
+                                            gboolean          dirty);
+
+gboolean clutter_stage_view_is_dirty_projection (ClutterStageView *view);
+
+void clutter_stage_view_set_dirty_projection (ClutterStageView *view,
+                                              gboolean          dirty);
+
 CLUTTER_EXPORT
 void clutter_stage_view_get_offscreen_transformation_matrix (ClutterStageView *view,
                                                              CoglMatrix       *matrix);

clutter/clutter/clutter-stage-window.c

@@ -62,6 +62,16 @@ _clutter_stage_window_set_title (ClutterStageWindow *window,
     iface->set_title (window, title);
 }
 
+void
+_clutter_stage_window_set_fullscreen (ClutterStageWindow *window,
+                                      gboolean            is_fullscreen)
+{
+  ClutterStageWindowInterface *iface = CLUTTER_STAGE_WINDOW_GET_IFACE (window);
+
+  if (iface->set_fullscreen)
+    iface->set_fullscreen (window, is_fullscreen);
+}
+
 void
 _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                           gboolean            is_visible)
@@ -72,6 +82,14 @@ _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
     iface->set_cursor_visible (window, is_visible);
 }
 
+void
+_clutter_stage_window_set_user_resizable (ClutterStageWindow *window,
+                                          gboolean            is_resizable)
+{
+  CLUTTER_STAGE_WINDOW_GET_IFACE (window)->set_user_resizable (window,
+                                                               is_resizable);
+}
+
 gboolean
 _clutter_stage_window_realize (ClutterStageWindow *window)
 {

clutter/clutter/clutter-stage-window.h

@@ -30,8 +30,12 @@ struct _ClutterStageWindowInterface
 
   void              (* set_title)               (ClutterStageWindow *stage_window,
                                                  const gchar        *title);
+  void              (* set_fullscreen)          (ClutterStageWindow *stage_window,
+                                                 gboolean            is_fullscreen);
   void              (* set_cursor_visible)      (ClutterStageWindow *stage_window,
                                                  gboolean            cursor_visible);
+  void              (* set_user_resizable)      (ClutterStageWindow *stage_window,
+                                                 gboolean            is_resizable);
 
   gboolean          (* realize)                 (ClutterStageWindow *stage_window);
   void              (* unrealize)               (ClutterStageWindow *stage_window);
@@ -79,8 +83,12 @@ ClutterActor *    _clutter_stage_window_get_wrapper        (ClutterStageWindow *
 
 void              _clutter_stage_window_set_title          (ClutterStageWindow *window,
                                                             const gchar        *title);
+void              _clutter_stage_window_set_fullscreen     (ClutterStageWindow *window,
+                                                            gboolean            is_fullscreen);
 void              _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
                                                             gboolean            is_visible);
+void              _clutter_stage_window_set_user_resizable (ClutterStageWindow *window,
+                                                            gboolean            is_resizable);
 
 gboolean          _clutter_stage_window_realize                 (ClutterStageWindow *window);
 void              _clutter_stage_window_unrealize               (ClutterStageWindow *window);

clutter/clutter/clutter-stage.c

@@ -72,11 +72,9 @@
 #include "clutter-private.h"
 #include "clutter-stage-manager-private.h"
 #include "clutter-stage-private.h"
-#include "clutter-stage-view-private.h"
 #include "clutter-private.h"
 
 #include "cogl/cogl.h"
-#include "cogl/cogl-trace.h"
 
 /* <private>
  * ClutterStageHint:
@@ -149,13 +147,13 @@ struct _ClutterStagePrivate
   gpointer paint_data;
   GDestroyNotify paint_notify;
 
-  cairo_rectangle_int_t view_clip;
-
   int update_freeze_count;
 
   guint relayout_pending       : 1;
   guint redraw_pending         : 1;
+  guint is_fullscreen          : 1;
   guint is_cursor_visible      : 1;
+  guint is_user_resizable      : 1;
   guint use_fog                : 1;
   guint throttle_motion_events : 1;
   guint use_alpha              : 1;
@@ -171,9 +169,12 @@ enum
   PROP_0,
 
   PROP_COLOR,
+  PROP_FULLSCREEN_SET,
+  PROP_OFFSCREEN,
   PROP_CURSOR_VISIBLE,
   PROP_PERSPECTIVE,
   PROP_TITLE,
+  PROP_USER_RESIZABLE,
   PROP_USE_FOG,
   PROP_FOG,
   PROP_USE_ALPHA,
@@ -184,11 +185,12 @@ enum
 
 enum
 {
+  FULLSCREEN,
+  UNFULLSCREEN,
   ACTIVATE,
   DEACTIVATE,
   DELETE_EVENT,
   AFTER_PAINT,
-  PAINT_VIEW,
   PRESENTED,
 
   LAST_SIGNAL
@@ -401,37 +403,40 @@ clutter_stage_allocate (ClutterActor           *self,
                                     flags | CLUTTER_DELEGATE_LAYOUT);
 
       /* Ensure the window is sized correctly */
-      if (priv->min_size_changed)
+      if (!priv->is_fullscreen)
         {
-          gfloat min_width, min_height;
-          gboolean min_width_set, min_height_set;
+          if (priv->min_size_changed)
+            {
+              gfloat min_width, min_height;
+              gboolean min_width_set, min_height_set;
 
-          g_object_get (G_OBJECT (self),
-                        "min-width", &min_width,
-                        "min-width-set", &min_width_set,
-                        "min-height", &min_height,
-                        "min-height-set", &min_height_set,
-                        NULL);
+              g_object_get (G_OBJECT (self),
+                            "min-width", &min_width,
+                            "min-width-set", &min_width_set,
+                            "min-height", &min_height,
+                            "min-height-set", &min_height_set,
+                            NULL);
 
-          if (!min_width_set)
-            min_width = 1;
-          if (!min_height_set)
-            min_height = 1;
+              if (!min_width_set)
+                min_width = 1;
+              if (!min_height_set)
+                min_height = 1;
 
-          if (width < min_width)
-            width = min_width;
-          if (height < min_height)
-            height = min_height;
+              if (width < min_width)
+                width = min_width;
+              if (height < min_height)
+                height = min_height;
 
-          priv->min_size_changed = FALSE;
-        }
+              priv->min_size_changed = FALSE;
+            }
 
-      if (window_size.width != CLUTTER_NEARBYINT (width) ||
-          window_size.height != CLUTTER_NEARBYINT (height))
-        {
-          _clutter_stage_window_resize (priv->impl,
-                                        CLUTTER_NEARBYINT (width),
-                                        CLUTTER_NEARBYINT (height));
+          if (window_size.width != CLUTTER_NEARBYINT (width) ||
+              window_size.height != CLUTTER_NEARBYINT (height))
+            {
+              _clutter_stage_window_resize (priv->impl,
+                                            CLUTTER_NEARBYINT (width),
+                                            CLUTTER_NEARBYINT (height));
+            }
         }
     }
   else
@@ -683,22 +688,7 @@ _clutter_stage_paint_view (ClutterStage                *stage,
   if (!priv->impl)
     return;
 
-  COGL_TRACE_BEGIN_SCOPED (ClutterStagePaintView, "Paint (view)");
-
-  priv->view_clip = *clip;
-
-  if (g_signal_has_handler_pending (stage, stage_signals[PAINT_VIEW],
-                                    0, TRUE))
-    g_signal_emit (stage, stage_signals[PAINT_VIEW], 0, view);
-  else
-    CLUTTER_STAGE_GET_CLASS (stage)->paint_view (stage, view);
-
-  priv->view_clip = (cairo_rectangle_int_t) { 0 };
-}
-
-void
-_clutter_stage_emit_after_paint (ClutterStage *stage)
-{
+  clutter_stage_do_paint_view (stage, view, clip);
   g_signal_emit (stage, stage_signals[AFTER_PAINT], 0);
 }
 
@@ -854,6 +844,40 @@ clutter_stage_real_deactivate (ClutterStage *stage)
   clutter_stage_emit_key_focus_event (stage, FALSE);
 }
 
+static void
+clutter_stage_real_fullscreen (ClutterStage *stage)
+{
+  ClutterStagePrivate *priv = stage->priv;
+  cairo_rectangle_int_t geom;
+  ClutterActorBox box;
+
+  /* we need to force an allocation here because the size
+   * of the stage might have been changed by the backend
+   *
+   * this is a really bad solution to the issues caused by
+   * the fact that fullscreening the stage on the X11 backends
+   * is really an asynchronous operation
+   */
+  _clutter_stage_window_get_geometry (priv->impl, &geom);
+
+  box.x1 = 0;
+  box.y1 = 0;
+  box.x2 = geom.width;
+  box.y2 = geom.height;
+
+  /* we need to blow the caching on the Stage size, given that
+   * we're about to force an allocation, because if anything
+   * ends up querying the size of the stage during the allocate()
+   * call, like constraints or signal handlers, we'll get into an
+   * inconsistent state: the stage will report the old cached size,
+   * but the allocation will be updated anyway.
+   */
+  clutter_actor_set_size (CLUTTER_ACTOR (stage), -1.0, -1.0);
+  clutter_actor_allocate (CLUTTER_ACTOR (stage),
+                          &box,
+                          CLUTTER_ALLOCATION_NONE);
+}
+
 void
 _clutter_stage_queue_event (ClutterStage *stage,
                             ClutterEvent *event,
@@ -1201,30 +1225,21 @@ _clutter_stage_do_update (ClutterStage *stage)
   if (!CLUTTER_ACTOR_IS_REALIZED (stage))
     return FALSE;
 
-  COGL_TRACE_BEGIN_SCOPED (ClutterStageDoUpdate, "Update");
-
   /* NB: We need to ensure we have an up to date layout *before* we
    * check or clear the pending redraws flag since a relayout may
    * queue a redraw.
    */
-  COGL_TRACE_BEGIN (ClutterStageRelayout, "Layout");
-
   _clutter_stage_maybe_relayout (CLUTTER_ACTOR (stage));
 
-  COGL_TRACE_END (ClutterStageRelayout);
-
   if (!priv->redraw_pending)
     return FALSE;
 
   if (stage_was_relayout)
     pointers = _clutter_stage_check_updated_pointers (stage);
 
-  COGL_TRACE_BEGIN (ClutterStagePaint, "Paint");
-
   clutter_stage_maybe_finish_queue_redraws (stage);
-  clutter_stage_do_redraw (stage);
 
-  COGL_TRACE_END (ClutterStagePaint);
+  clutter_stage_do_redraw (stage);
 
   /* reset the guard, so that new redraws are possible */
   priv->redraw_pending = FALSE;
@@ -1239,16 +1254,12 @@ _clutter_stage_do_update (ClutterStage *stage)
     }
 #endif /* CLUTTER_ENABLE_DEBUG */
 
-  COGL_TRACE_BEGIN (ClutterStagePick, "Pick");
-
   while (pointers)
     {
       _clutter_input_device_update (pointers->data, NULL, TRUE);
       pointers = g_slist_delete_link (pointers, pointers);
     }
 
-  COGL_TRACE_END (ClutterStagePick);
-
   return TRUE;
 }
 
@@ -1559,13 +1570,10 @@ _clutter_stage_do_pick_on_view (ClutterStage     *stage,
   return retval;
 }
 
-/**
- * clutter_stage_get_view_at: (skip)
- */
-ClutterStageView *
-clutter_stage_get_view_at (ClutterStage *stage,
-                           float         x,
-                           float         y)
+static ClutterStageView *
+get_view_at (ClutterStage *stage,
+             int           x,
+             int           y)
 {
   ClutterStagePrivate *priv = stage->priv;
   GList *l;
@@ -1612,7 +1620,7 @@ _clutter_stage_do_pick (ClutterStage   *stage,
   if (x < 0 || x >= stage_width || y < 0 || y >= stage_height)
     return actor;
 
-  view = clutter_stage_get_view_at (stage, x, y);
+  view = get_view_at (stage, x, y);
   if (view)
     return _clutter_stage_do_pick_on_view (stage, x, y, mode, view);
 
@@ -1691,6 +1699,11 @@ clutter_stage_set_property (GObject      *object,
                                           clutter_value_get_color (value));
       break;
 
+    case PROP_OFFSCREEN:
+      if (g_value_get_boolean (value))
+        g_warning ("Offscreen stages are currently not supported\n");
+      break;
+
     case PROP_CURSOR_VISIBLE:
       if (g_value_get_boolean (value))
         clutter_stage_show_cursor (stage);
@@ -1706,6 +1719,10 @@ clutter_stage_set_property (GObject      *object,
       clutter_stage_set_title (stage, g_value_get_string (value));
       break;
 
+    case PROP_USER_RESIZABLE:
+      clutter_stage_set_user_resizable (stage, g_value_get_boolean (value));
+      break;
+
     case PROP_USE_FOG:
       clutter_stage_set_use_fog (stage, g_value_get_boolean (value));
       break;
@@ -1756,6 +1773,14 @@ clutter_stage_get_property (GObject    *gobject,
       }
       break;
 
+    case PROP_OFFSCREEN:
+      g_value_set_boolean (value, FALSE);
+      break;
+
+    case PROP_FULLSCREEN_SET:
+      g_value_set_boolean (value, priv->is_fullscreen);
+      break;
+
     case PROP_CURSOR_VISIBLE:
       g_value_set_boolean (value, priv->is_cursor_visible);
       break;
@@ -1768,6 +1793,10 @@ clutter_stage_get_property (GObject    *gobject,
       g_value_set_string (value, priv->title);
       break;
 
+    case PROP_USER_RESIZABLE:
+      g_value_set_boolean (value, priv->is_user_resizable);
+      break;
+
     case PROP_USE_FOG:
       g_value_set_boolean (value, priv->use_fog);
       break;
@@ -1862,16 +1891,6 @@ clutter_stage_finalize (GObject *object)
   G_OBJECT_CLASS (clutter_stage_parent_class)->finalize (object);
 }
 
-static void
-clutter_stage_real_paint_view (ClutterStage     *stage,
-                               ClutterStageView *view)
-{
-  ClutterStagePrivate *priv = stage->priv;
-  const cairo_rectangle_int_t *clip = &priv->view_clip;
-
-  clutter_stage_do_paint_view (stage, view, clip);
-}
-
 static void
 clutter_stage_class_init (ClutterStageClass *klass)
 {
@@ -1901,8 +1920,42 @@ clutter_stage_class_init (ClutterStageClass *klass)
   actor_class->queue_redraw = clutter_stage_real_queue_redraw;
   actor_class->apply_transform = clutter_stage_real_apply_transform;
 
-  klass->paint_view = clutter_stage_real_paint_view;
-
+  /**
+   * ClutterStage:fullscreen:
+   *
+   * Whether the stage should be fullscreen or not.
+   *
+   * This property is set by calling clutter_stage_set_fullscreen()
+   * but since the actual implementation is delegated to the backend
+   * you should connect to the notify::fullscreen-set signal in order
+   * to get notification if the fullscreen state has been successfully
+   * achieved.
+   *
+   * Since: 1.0
+   */
+  pspec = g_param_spec_boolean ("fullscreen-set",
+                                P_("Fullscreen Set"),
+                                P_("Whether the main stage is fullscreen"),
+                                FALSE,
+                                CLUTTER_PARAM_READABLE);
+  g_object_class_install_property (gobject_class,
+                                   PROP_FULLSCREEN_SET,
+                                   pspec);
+  /**
+   * ClutterStage:offscreen:
+   *
+   * Whether the stage should be rendered in an offscreen buffer.
+   *
+   * Deprecated: 1.10: This property does not do anything.
+   */
+  pspec = g_param_spec_boolean ("offscreen",
+                                P_("Offscreen"),
+                                P_("Whether the main stage should be rendered offscreen"),
+                                FALSE,
+                                CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
+  g_object_class_install_property (gobject_class,
+                                   PROP_OFFSCREEN,
+                                   pspec);
   /**
    * ClutterStage:cursor-visible:
    *
@@ -1916,6 +1969,21 @@ clutter_stage_class_init (ClutterStageClass *klass)
   g_object_class_install_property (gobject_class,
                                    PROP_CURSOR_VISIBLE,
                                    pspec);
+  /**
+   * ClutterStage:user-resizable:
+   *
+   * Whether the stage is resizable via user interaction.
+   *
+   * Since: 0.4
+   */
+  pspec = g_param_spec_boolean ("user-resizable",
+                                P_("User Resizable"),
+                                P_("Whether the stage is able to be resized via user interaction"),
+                                FALSE,
+                                CLUTTER_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class,
+                                   PROP_USER_RESIZABLE,
+                                   pspec);
   /**
    * ClutterStage:color:
    *
@@ -2063,6 +2131,39 @@ clutter_stage_class_init (ClutterStageClass *klass)
                                 CLUTTER_PARAM_READWRITE);
   g_object_class_install_property (gobject_class, PROP_ACCEPT_FOCUS, pspec);
 
+  /**
+   * ClutterStage::fullscreen:
+   * @stage: the stage which was fullscreened
+   *
+   * The ::fullscreen signal is emitted when the stage is made fullscreen.
+   *
+   * Since: 0.6
+   */
+  stage_signals[FULLSCREEN] =
+    g_signal_new (I_("fullscreen"),
+		  G_TYPE_FROM_CLASS (gobject_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (ClutterStageClass, fullscreen),
+		  NULL, NULL,
+		  _clutter_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+  /**
+   * ClutterStage::unfullscreen:
+   * @stage: the stage which has left a fullscreen state.
+   *
+   * The ::unfullscreen signal is emitted when the stage leaves a fullscreen
+   * state.
+   *
+   * Since: 0.6
+   */
+  stage_signals[UNFULLSCREEN] =
+    g_signal_new (I_("unfullscreen"),
+		  G_TYPE_FROM_CLASS (gobject_class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (ClutterStageClass, unfullscreen),
+		  NULL, NULL,
+		  _clutter_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   /**
    * ClutterStage::activate:
    * @stage: the stage which was activated
@@ -2146,28 +2247,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
                   NULL, NULL, NULL,
                   G_TYPE_NONE, 0);
 
-  /**
-   * ClutterStage::paint-view:
-   * @stage: the stage that received the event
-   * @view: a #ClutterStageView
-   *
-   * The ::paint-view signal is emitted before a #ClutterStageView is being
-   * painted.
-   *
-   * The view is painted in the default handler. Hence, if you want to perform
-   * some action after the view is painted, like reading the contents of the
-   * framebuffer, use g_signal_connect_after() or pass %G_CONNECT_AFTER.
-   */
-  stage_signals[PAINT_VIEW] =
-    g_signal_new (I_("paint-view"),
-                  G_TYPE_FROM_CLASS (gobject_class),
-                  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (ClutterStageClass, paint_view),
-                  NULL, NULL,
-                  _clutter_marshal_VOID__OBJECT,
-                  G_TYPE_NONE, 1,
-                  CLUTTER_TYPE_STAGE_VIEW);
-
   /**
    * ClutterStage::presented: (skip)
    * @stage: the stage that received the event
@@ -2185,6 +2264,7 @@ clutter_stage_class_init (ClutterStageClass *klass)
                   G_TYPE_NONE, 2,
                   G_TYPE_INT, G_TYPE_POINTER);
 
+  klass->fullscreen = clutter_stage_real_fullscreen;
   klass->activate = clutter_stage_real_activate;
   klass->deactivate = clutter_stage_real_deactivate;
   klass->delete_event = clutter_stage_real_delete_event;
@@ -2235,12 +2315,21 @@ clutter_stage_init (ClutterStage *self)
 
   priv->event_queue = g_queue_new ();
 
+  priv->is_fullscreen = FALSE;
+  priv->is_user_resizable = FALSE;
   priv->is_cursor_visible = TRUE;
   priv->use_fog = FALSE;
   priv->throttle_motion_events = TRUE;
   priv->min_size_changed = FALSE;
   priv->sync_delay = -1;
-  priv->motion_events_enabled = TRUE;
+
+  /* XXX - we need to keep the invariant that calling
+   * clutter_set_motion_event_enabled() before the stage creation
+   * will cause motion event delivery to be disabled on any newly
+   * created stage. this can go away when we break API and remove
+   * deprecated functions.
+   */
+  priv->motion_events_enabled = _clutter_context_get_motion_events_enabled ();
 
   clutter_actor_set_background_color (CLUTTER_ACTOR (self),
                                       &default_stage_color);
@@ -2623,6 +2712,136 @@ _clutter_stage_get_viewport (ClutterStage *stage,
   *height = priv->viewport[3];
 }
 
+/**
+ * clutter_stage_set_fullscreen:
+ * @stage: a #ClutterStage
+ * @fullscreen: %TRUE to to set the stage fullscreen
+ *
+ * Asks to place the stage window in the fullscreen or unfullscreen
+ * states.
+ *
+ ( Note that you shouldn't assume the window is definitely full screen
+ * afterward, because other entities (e.g. the user or window manager)
+ * could unfullscreen it again, and not all window managers honor
+ * requests to fullscreen windows.
+ *
+ * If you want to receive notification of the fullscreen state you
+ * should either use the #ClutterStage::fullscreen and
+ * #ClutterStage::unfullscreen signals, or use the notify signal
+ * for the #ClutterStage:fullscreen-set property
+ *
+ * Since: 1.0
+ */
+void
+clutter_stage_set_fullscreen (ClutterStage *stage,
+                              gboolean      fullscreen)
+{
+  ClutterStagePrivate *priv;
+
+  g_return_if_fail (CLUTTER_IS_STAGE (stage));
+
+  priv = stage->priv;
+
+  if (priv->is_fullscreen != fullscreen)
+    {
+      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
+      ClutterStageWindowInterface *iface;
+
+      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
+
+      /* Only set if backend implements.
+       *
+       * Also see clutter_stage_event() for setting priv->is_fullscreen
+       * on state change event.
+       */
+      if (iface->set_fullscreen)
+	iface->set_fullscreen (impl, fullscreen);
+    }
+
+  /* If the backend did fullscreen the stage window then we need to resize
+   * the stage and update its viewport so we queue a relayout.  Note: if the
+   * fullscreen request is handled asynchronously we can't rely on this
+   * queue_relayout to update the viewport, but for example the X backend
+   * will recieve a ConfigureNotify after a successful resize which is how
+   * we ensure the viewport is updated on X.
+   */
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (stage));
+}
+
+/**
+ * clutter_stage_get_fullscreen:
+ * @stage: a #ClutterStage
+ *
+ * Retrieves whether the stage is full screen or not
+ *
+ * Return value: %TRUE if the stage is full screen
+ *
+ * Since: 1.0
+ */
+gboolean
+clutter_stage_get_fullscreen (ClutterStage *stage)
+{
+  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
+
+  return stage->priv->is_fullscreen;
+}
+
+/**
+ * clutter_stage_set_user_resizable:
+ * @stage: a #ClutterStage
+ * @resizable: whether the stage should be user resizable.
+ *
+ * Sets if the stage is resizable by user interaction (e.g. via
+ * window manager controls)
+ *
+ * Since: 0.4
+ */
+void
+clutter_stage_set_user_resizable (ClutterStage *stage,
+                                  gboolean      resizable)
+{
+  ClutterStagePrivate *priv;
+
+  g_return_if_fail (CLUTTER_IS_STAGE (stage));
+
+  priv = stage->priv;
+
+  if (clutter_feature_available (CLUTTER_FEATURE_STAGE_USER_RESIZE)
+      && priv->is_user_resizable != resizable)
+    {
+      ClutterStageWindow *impl = CLUTTER_STAGE_WINDOW (priv->impl);
+      ClutterStageWindowInterface *iface;
+
+      iface = CLUTTER_STAGE_WINDOW_GET_IFACE (impl);
+      if (iface->set_user_resizable)
+        {
+          priv->is_user_resizable = resizable;
+
+          iface->set_user_resizable (impl, resizable);
+
+          g_object_notify (G_OBJECT (stage), "user-resizable");
+        }
+    }
+}
+
+/**
+ * clutter_stage_get_user_resizable:
+ * @stage: a #ClutterStage
+ *
+ * Retrieves the value set with clutter_stage_set_user_resizable().
+ *
+ * Return value: %TRUE if the stage is resizable by the user.
+ *
+ * Since: 0.4
+ */
+gboolean
+clutter_stage_get_user_resizable (ClutterStage *stage)
+{
+  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
+
+  return stage->priv->is_user_resizable;
+}
+
 /**
  * clutter_stage_show_cursor:
  * @stage: a #ClutterStage
@@ -2726,8 +2945,6 @@ clutter_stage_read_pixels (ClutterStage *stage,
   float pixel_height;
   uint8_t *pixels;
 
-  COGL_TRACE_BEGIN_SCOPED (ClutterStageReadPixels, "Read Pixels");
-
   g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
 
   priv = stage->priv;
@@ -2793,11 +3010,7 @@ clutter_stage_read_pixels (ClutterStage *stage,
  * @y: Y coordinate to check
  *
  * Checks the scene at the coordinates @x and @y and returns a pointer
- * to the #ClutterActor at those coordinates. The result is the actor which
- * would be at the specified location on the next redraw, and is not
- * necessarily that which was there on the previous redraw. This allows the
- * function to perform chronologically correctly after any queued changes to
- * the scene, and even if nothing has been drawn.
+ * to the #ClutterActor at those coordinates.
  *
  * By using @pick_mode it is possible to control which actors will be
  * painted and thus available.
@@ -2834,9 +3047,13 @@ gboolean
 clutter_stage_event (ClutterStage *stage,
                      ClutterEvent *event)
 {
+  ClutterStagePrivate *priv;
+
   g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
+  priv = stage->priv;
+
   if (event->type == CLUTTER_DELETE)
     {
       gboolean retval = FALSE;
@@ -2856,6 +3073,24 @@ clutter_stage_event (ClutterStage *stage,
   if (clutter_actor_event (CLUTTER_ACTOR (stage), event, FALSE))
     return TRUE;
 
+  if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_FULLSCREEN)
+    {
+      if (event->stage_state.new_state & CLUTTER_STAGE_STATE_FULLSCREEN)
+	{
+	  priv->is_fullscreen = TRUE;
+	  g_signal_emit (stage, stage_signals[FULLSCREEN], 0);
+
+          g_object_notify (G_OBJECT (stage), "fullscreen-set");
+	}
+      else
+	{
+	  priv->is_fullscreen = FALSE;
+	  g_signal_emit (stage, stage_signals[UNFULLSCREEN], 0);
+
+          g_object_notify (G_OBJECT (stage), "fullscreen-set");
+	}
+    }
+
   if (event->stage_state.changed_mask & CLUTTER_STAGE_STATE_ACTIVATED)
     {
       if (event->stage_state.new_state & CLUTTER_STAGE_STATE_ACTIVATED)
@@ -3710,6 +3945,8 @@ clutter_stage_get_use_alpha (ClutterStage *stage)
  * If the current size of @stage is smaller than the minimum size, the
  * @stage will be resized to the new @width and @height
  *
+ * This function has no effect if @stage is fullscreen
+ *
  * Since: 1.2
  */
 void
@@ -4396,6 +4633,20 @@ _clutter_stage_is_activated (ClutterStage *stage)
   return (stage->priv->current_state & CLUTTER_STAGE_STATE_ACTIVATED) != 0;
 }
 
+/*< private >
+ * _clutter_stage_is_fullscreen:
+ * @stage: a #ClutterStage
+ *
+ * Checks whether the @stage state includes %CLUTTER_STAGE_STATE_FULLSCREEN.
+ *
+ * Return value: %TRUE if the @stage is fullscreen
+ */
+gboolean
+_clutter_stage_is_fullscreen (ClutterStage *stage)
+{
+  return (stage->priv->current_state & CLUTTER_STAGE_STATE_FULLSCREEN) != 0;
+}
+
 /*< private >
  * _clutter_stage_update_state:
  * @stage: a #ClutterStage

clutter/clutter/clutter-stage.h

@@ -30,7 +30,6 @@
 
 #include <clutter/clutter-types.h>
 #include <clutter/clutter-group.h>
-#include <clutter/clutter-stage-view.h>
 
 G_BEGIN_DECLS
 
@@ -62,6 +61,8 @@ struct _ClutterStage
 };
 /**
  * ClutterStageClass:
+ * @fullscreen: handler for the #ClutterStage::fullscreen signal
+ * @unfullscreen: handler for the #ClutterStage::unfullscreen signal
  * @activate: handler for the #ClutterStage::activate signal
  * @deactivate: handler for the #ClutterStage::deactivate signal
  * @delete_event: handler for the #ClutterStage::delete-event signal
@@ -78,18 +79,17 @@ struct _ClutterStageClass
 
   /*< public >*/
   /* signals */
+  void (* fullscreen)   (ClutterStage *stage);
+  void (* unfullscreen) (ClutterStage *stage);
   void (* activate)     (ClutterStage *stage);
   void (* deactivate)   (ClutterStage *stage);
 
   gboolean (* delete_event) (ClutterStage *stage,
                              ClutterEvent *event);
 
-  void (* paint_view) (ClutterStage     *stage,
-                       ClutterStageView *view);
-
   /*< private >*/
   /* padding for future expansion */
-  gpointer _padding_dummy[30];
+  gpointer _padding_dummy[31];
 };
 
 /**
@@ -168,6 +168,11 @@ CLUTTER_EXPORT
 void            clutter_stage_get_perspective                   (ClutterStage          *stage,
 			                                         ClutterPerspective    *perspective);
 CLUTTER_EXPORT
+void            clutter_stage_set_fullscreen                    (ClutterStage          *stage,
+                                                                 gboolean               fullscreen);
+CLUTTER_EXPORT
+gboolean        clutter_stage_get_fullscreen                    (ClutterStage          *stage);
+CLUTTER_EXPORT
 void            clutter_stage_show_cursor                       (ClutterStage          *stage);
 CLUTTER_EXPORT
 void            clutter_stage_hide_cursor                       (ClutterStage          *stage);
@@ -176,6 +181,11 @@ void            clutter_stage_set_title                         (ClutterStage
                                                                  const gchar           *title);
 CLUTTER_EXPORT
 const gchar *   clutter_stage_get_title                         (ClutterStage          *stage);
+CLUTTER_EXPORT
+void            clutter_stage_set_user_resizable                (ClutterStage          *stage,
+						                 gboolean               resizable);
+CLUTTER_EXPORT
+gboolean        clutter_stage_get_user_resizable                (ClutterStage          *stage);
 
 CLUTTER_EXPORT
 void            clutter_stage_set_minimum_size                  (ClutterStage          *stage,
@@ -264,10 +274,6 @@ gboolean clutter_stage_capture (ClutterStage          *stage,
                                 cairo_rectangle_int_t *rect,
                                 ClutterCapture       **captures,
                                 int                   *n_captures);
-CLUTTER_EXPORT
-ClutterStageView * clutter_stage_get_view_at (ClutterStage *stage,
-                                              float         x,
-                                              float         y);
 
 G_END_DECLS
 

clutter/clutter/clutter-text-buffer.c

@@ -171,7 +171,7 @@ clutter_text_buffer_normal_insert_text (ClutterTextBuffer *buffer,
 
   /* Actual text insertion */
   at = g_utf8_offset_to_pointer (pv->normal_text, position) - pv->normal_text;
-  memmove (pv->normal_text + at + n_bytes, pv->normal_text + at, pv->normal_text_bytes - at);
+  g_memmove (pv->normal_text + at + n_bytes, pv->normal_text + at, pv->normal_text_bytes - at);
   memcpy (pv->normal_text + at, chars, n_bytes);
 
   /* Book keeping */
@@ -201,7 +201,7 @@ clutter_text_buffer_normal_delete_text (ClutterTextBuffer *buffer,
       start = g_utf8_offset_to_pointer (pv->normal_text, position) - pv->normal_text;
       end = g_utf8_offset_to_pointer (pv->normal_text, position + n_chars) - pv->normal_text;
 
-      memmove (pv->normal_text + start, pv->normal_text + end, pv->normal_text_bytes + 1 - end);
+      g_memmove (pv->normal_text + start, pv->normal_text + end, pv->normal_text_bytes + 1 - end);
       pv->normal_text_chars -= n_chars;
       pv->normal_text_bytes -= (end - start);
 

clutter/clutter/clutter-text.c

@@ -1975,7 +1975,6 @@ selection_paint (ClutterText     *self,
   else
     {
       /* Paint selection background first */
-      CoglPipeline *color_pipeline = cogl_pipeline_copy (default_color_pipeline);
       PangoLayout *layout = clutter_text_get_layout (self);
       CoglPath *selection_path = cogl_path_new ();
       CoglColor cogl_color = { 0, };
@@ -1988,19 +1987,11 @@ selection_paint (ClutterText     *self,
       else
         color = &priv->text_color;
 
-      cogl_color_init_from_4ub (&cogl_color,
-                                color->red,
-                                color->green,
-                                color->blue,
-                                paint_opacity * color->alpha / 255);
-      cogl_color_premultiply (&cogl_color);
-      cogl_pipeline_set_color (color_pipeline, &cogl_color);
-
       clutter_text_foreach_selection_rectangle_prescaled (self,
                                                           add_selection_rectangle_to_path,
                                                           selection_path);
 
-      cogl_framebuffer_fill_path (fb, color_pipeline, selection_path);
+      cogl_path_fill (selection_path);
 
       /* Paint selected text */
       cogl_framebuffer_push_path_clip (fb, selection_path);

clutter/clutter/clutter.h

@@ -101,7 +101,6 @@
 #include "clutter-snap-constraint.h"
 #include "clutter-stage.h"
 #include "clutter-stage-manager.h"
-#include "clutter-stage-view.h"
 #include "clutter-tap-action.h"
 #include "clutter-test-utils.h"
 #include "clutter-texture.h"

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

@@ -45,9 +45,6 @@
 #include "clutter-main.h"
 #include "clutter-private.h"
 #include "clutter-stage-private.h"
-#include "clutter-stage-view-private.h"
-
-#include "cogl/cogl-trace.h"
 
 typedef struct _ClutterStageViewCoglPrivate
 {
@@ -186,56 +183,38 @@ clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
       return;
     }
 
-  refresh_rate = stage_cogl->refresh_rate;
-  if (refresh_rate <= 0.0)
-    refresh_rate = clutter_get_default_frame_rate ();
-
-  refresh_interval = (gint64) (0.5 + G_USEC_PER_SEC / refresh_rate);
-  if (refresh_interval == 0)
+  /* We only extrapolate presentation times for 150ms  - this is somewhat
+   * arbitrary. The reasons it might not be accurate for larger times are
+   * that the refresh interval might be wrong or the vertical refresh
+   * might be downclocked if nothing is going on onscreen.
+   */
+  if (stage_cogl->last_presentation_time == 0||
+      stage_cogl->last_presentation_time < now - 150000)
     {
       stage_cogl->update_time = now;
       return;
     }
 
+  refresh_rate = stage_cogl->refresh_rate;
+  if (refresh_rate == 0.0)
+    refresh_rate = 60.0;
+
+  refresh_interval = (gint64) (0.5 + 1000000 / refresh_rate);
+  if (refresh_interval == 0)
+    refresh_interval = 16667; /* 1/60th second */
+
   min_render_time_allowed = refresh_interval / 2;
   max_render_time_allowed = refresh_interval - 1000 * sync_delay;
 
-  /* Be robust in the case of incredibly bogus refresh rate */
-  if (max_render_time_allowed <= 0)
-    {
-      g_warning ("Unsupported monitor refresh rate detected. "
-                 "(Refresh rate: %.3f, refresh interval: %ld)",
-                 refresh_rate,
-                 refresh_interval);
-      stage_cogl->update_time = now;
-      return;
-    }
-
   if (min_render_time_allowed > max_render_time_allowed)
     min_render_time_allowed = max_render_time_allowed;
 
   next_presentation_time = stage_cogl->last_presentation_time + refresh_interval;
 
-  /* Get next_presentation_time closer to its final value, to reduce
-   * the number of while iterations below.
-   */
-  if (next_presentation_time < now)
-    {
-      int64_t last_virtual_presentation_time = now - now % refresh_interval;
-      int64_t hardware_clock_phase =
-        stage_cogl->last_presentation_time % refresh_interval;
-
-      next_presentation_time =
-        last_virtual_presentation_time + hardware_clock_phase;
-    }
-
   while (next_presentation_time < now + min_render_time_allowed)
     next_presentation_time += refresh_interval;
 
   stage_cogl->update_time = next_presentation_time - max_render_time_allowed;
-
-  if (stage_cogl->update_time == stage_cogl->last_update_time)
-    stage_cogl->update_time = stage_cogl->last_update_time + refresh_interval;
 }
 
 static gint64
@@ -254,7 +233,6 @@ clutter_stage_cogl_clear_update_time (ClutterStageWindow *stage_window)
 {
   ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window);
 
-  stage_cogl->last_update_time = stage_cogl->update_time;
   stage_cogl->update_time = -1;
 }
 
@@ -927,16 +905,26 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
    */
   if (use_clipped_redraw)
     {
-      if (clip_region_empty)
+      if (use_clipped_redraw && clip_region_empty)
         {
           do_swap_buffer = FALSE;
         }
-      else
+      else if (use_clipped_redraw)
         {
           swap_region = fb_clip_region;
           g_assert (swap_region.width > 0);
           do_swap_buffer = TRUE;
         }
+      else
+        {
+          swap_region = (cairo_rectangle_int_t) {
+            .x = 0,
+            .y = 0,
+            .width = view_rect.width * fb_scale,
+            .height = view_rect.height * fb_scale,
+          };
+          do_swap_buffer = TRUE;
+        }
     }
   else
     {
@@ -946,9 +934,6 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
 
   if (do_swap_buffer)
     {
-      COGL_TRACE_BEGIN_SCOPED (ClutterStageCoglRedrawViewSwapFramebuffer,
-                               "Paint (swap framebuffer)");
-
       if (clutter_stage_view_get_onscreen (view) !=
           clutter_stage_view_get_framebuffer (view))
         {
@@ -973,8 +958,6 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
   gboolean swap_event = FALSE;
   GList *l;
 
-  COGL_TRACE_BEGIN (ClutterStageCoglRedraw, "Paint (Cogl Redraw)");
-
   for (l = _clutter_stage_window_get_views (stage_window); l; l = l->next)
     {
       ClutterStageView *view = l->data;
@@ -983,8 +966,6 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
         clutter_stage_cogl_redraw_view (stage_window, view) || swap_event;
     }
 
-  _clutter_stage_emit_after_paint (stage_cogl->wrapper);
-
   _clutter_stage_window_finish_frame (stage_window);
 
   if (swap_event)
@@ -1000,8 +981,6 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
   stage_cogl->initialized_redraw_clip = FALSE;
 
   stage_cogl->frame_count++;
-
-  COGL_TRACE_END (ClutterStageCoglRedraw);
 }
 
 static void

clutter/clutter/cogl/clutter-stage-cogl.h

@@ -53,7 +53,6 @@ struct _ClutterStageCogl
 
   gint64 last_presentation_time;
   gint64 update_time;
-  int64_t last_update_time;
 
   /* We only enable clipped redraws after 2 frames, since we've seen
    * a lot of drivers can struggle to get going and may output some

clutter/clutter/deprecated/clutter-main.h

@@ -0,0 +1,85 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corp
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_MAIN_DEPRECATED_H__
+#define __CLUTTER_MAIN_DEPRECATED_H__
+
+#include <clutter/clutter-types.h>
+#include <clutter/clutter-input-device.h>
+
+G_BEGIN_DECLS
+
+CLUTTER_DEPRECATED
+void                    clutter_threads_init                    (void);
+
+CLUTTER_DEPRECATED
+void                    clutter_threads_enter                   (void);
+
+CLUTTER_DEPRECATED
+void                    clutter_threads_leave                   (void);
+
+CLUTTER_DEPRECATED_FOR(clutter_stage_set_motion_events_enabled)
+void                    clutter_set_motion_events_enabled       (gboolean          enable);
+
+CLUTTER_DEPRECATED_FOR(clutter_stage_get_motion_events_enabled)
+gboolean                clutter_get_motion_events_enabled       (void);
+
+CLUTTER_DEPRECATED_FOR(clutter_stage_ensure_redraw)
+void                    clutter_redraw                          (ClutterStage     *stage);
+
+CLUTTER_DEPRECATED_FOR(cogl_pango_font_map_clear_glyph_cache)
+void                    clutter_clear_glyph_cache               (void);
+
+CLUTTER_DEPRECATED_FOR(clutter_backend_set_font_options)
+void                    clutter_set_font_flags                  (ClutterFontFlags  flags);
+
+CLUTTER_DEPRECATED_FOR(clutter_backend_get_font_options)
+ClutterFontFlags        clutter_get_font_flags                  (void);
+
+CLUTTER_DEPRECATED_FOR(clutter_device_manager_get_device)
+ClutterInputDevice *    clutter_get_input_device_for_id         (gint id_);
+
+CLUTTER_DEPRECATED_FOR(clutter_input_device_grab)
+void                    clutter_grab_pointer_for_device         (ClutterActor     *actor,
+                                                                 gint              id_);
+
+CLUTTER_DEPRECATED_FOR(clutter_input_device_ungrab)
+void                    clutter_ungrab_pointer_for_device       (gint              id_);
+
+CLUTTER_DEPRECATED
+void                    clutter_set_default_frame_rate          (guint             frames_per_sec);
+
+CLUTTER_DEPRECATED
+gulong                  clutter_get_timestamp                   (void);
+
+CLUTTER_DEPRECATED
+gboolean                clutter_get_debug_enabled               (void);
+
+CLUTTER_DEPRECATED
+gboolean                clutter_get_show_fps                    (void);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_MAIN_DEPRECATED_H__ */

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

@@ -739,33 +739,31 @@ get_button_index (gint button)
 }
 
 static void
-emulate_button_press (ClutterInputDeviceEvdev *device_evdev)
+emulate_button_press (ClutterInputDeviceEvdev *device)
 {
-  ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
-  gint btn = device_evdev->mousekeys_btn;
+  gint btn = device->mousekeys_btn;
 
-  if (device_evdev->mousekeys_btn_states[get_button_index (btn)])
+  if (device->mousekeys_btn_states[get_button_index (btn)])
     return;
 
-  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
+  clutter_virtual_input_device_notify_button (device->mousekeys_virtual_device,
                                               g_get_monotonic_time (), btn,
                                               CLUTTER_BUTTON_STATE_PRESSED);
-  device_evdev->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_PRESSED;
+  device->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_PRESSED;
 }
 
 static void
-emulate_button_release (ClutterInputDeviceEvdev *device_evdev)
+emulate_button_release (ClutterInputDeviceEvdev *device)
 {
-  ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
-  gint btn = device_evdev->mousekeys_btn;
+  gint btn = device->mousekeys_btn;
 
-  if (device_evdev->mousekeys_btn_states[get_button_index (btn)] == CLUTTER_BUTTON_STATE_RELEASED)
+  if (device->mousekeys_btn_states[get_button_index (btn)] == CLUTTER_BUTTON_STATE_RELEASED)
     return;
 
-  clutter_virtual_input_device_notify_button (device->accessibility_virtual_device,
+  clutter_virtual_input_device_notify_button (device->mousekeys_virtual_device,
                                               g_get_monotonic_time (), btn,
                                               CLUTTER_BUTTON_STATE_RELEASED);
-  device_evdev->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_RELEASED;
+  device->mousekeys_btn_states[get_button_index (btn)] = CLUTTER_BUTTON_STATE_RELEASED;
 }
 
 static void
@@ -832,18 +830,17 @@ mousekeys_get_speed_factor (ClutterInputDeviceEvdev *device,
 #undef MOUSEKEYS_CURVE
 
 static void
-emulate_pointer_motion (ClutterInputDeviceEvdev *device_evdev,
+emulate_pointer_motion (ClutterInputDeviceEvdev *device,
                         gint                     dx,
                         gint                     dy)
 {
-  ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
   gdouble dx_motion;
   gdouble dy_motion;
   gdouble speed;
   gint64 time_us;
 
   time_us = g_get_monotonic_time ();
-  speed = mousekeys_get_speed_factor (device_evdev, time_us);
+  speed = mousekeys_get_speed_factor (device, time_us);
 
   if (dx < 0)
     dx_motion = floor (((gdouble) dx) * speed);
@@ -855,7 +852,7 @@ emulate_pointer_motion (ClutterInputDeviceEvdev *device_evdev,
   else
     dy_motion = ceil (((gdouble) dy) * speed);
 
-  clutter_virtual_input_device_notify_relative_motion (device->accessibility_virtual_device,
+  clutter_virtual_input_device_notify_relative_motion (device->mousekeys_virtual_device,
                                                        time_us, dx_motion, dy_motion);
 }
 static gboolean
@@ -868,53 +865,51 @@ is_numlock_active (ClutterInputDeviceEvdev *device)
 }
 
 static void
-enable_mousekeys (ClutterInputDeviceEvdev *device_evdev)
+enable_mousekeys (ClutterInputDeviceEvdev *device)
 {
-  ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
-  ClutterDeviceManager *manager = device->device_manager;
+  ClutterDeviceManager *manager;
 
-  device_evdev->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
-  device_evdev->move_mousekeys_timer = 0;
-  device_evdev->mousekeys_first_motion_time = 0;
-  device_evdev->mousekeys_last_motion_time = 0;
-  device_evdev->last_mousekeys_key = 0;
+  device->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
+  device->move_mousekeys_timer = 0;
+  device->mousekeys_first_motion_time = 0;
+  device->mousekeys_last_motion_time = 0;
+  device->last_mousekeys_key = 0;
 
-  if (device->accessibility_virtual_device)
+  if (device->mousekeys_virtual_device)
     return;
 
-  device->accessibility_virtual_device =
+  manager = CLUTTER_INPUT_DEVICE (device)->device_manager;
+  device->mousekeys_virtual_device =
     clutter_device_manager_create_virtual_device (manager,
                                                   CLUTTER_POINTER_DEVICE);
 }
 
 static void
-disable_mousekeys (ClutterInputDeviceEvdev *device_evdev)
+disable_mousekeys (ClutterInputDeviceEvdev *device)
 {
-  ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_evdev);
-
-  stop_mousekeys_move (device_evdev);
+  stop_mousekeys_move (device);
 
   /* Make sure we don't leave button pressed behind... */
-  if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_PRIMARY)])
+  if (device->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_PRIMARY)])
     {
-      device_evdev->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
-      emulate_button_release (device_evdev);
+      device->mousekeys_btn = CLUTTER_BUTTON_PRIMARY;
+      emulate_button_release (device);
     }
 
-  if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_MIDDLE)])
+  if (device->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_MIDDLE)])
     {
-      device_evdev->mousekeys_btn = CLUTTER_BUTTON_MIDDLE;
-      emulate_button_release (device_evdev);
+      device->mousekeys_btn = CLUTTER_BUTTON_MIDDLE;
+      emulate_button_release (device);
     }
 
-  if (device_evdev->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_SECONDARY)])
+  if (device->mousekeys_btn_states[get_button_index (CLUTTER_BUTTON_SECONDARY)])
     {
-      device_evdev->mousekeys_btn = CLUTTER_BUTTON_SECONDARY;
-      emulate_button_release (device_evdev);
+      device->mousekeys_btn = CLUTTER_BUTTON_SECONDARY;
+      emulate_button_release (device);
     }
 
-  if (device->accessibility_virtual_device)
-    g_clear_object (&device->accessibility_virtual_device);
+  if (device->mousekeys_virtual_device)
+    g_clear_object (&device->mousekeys_virtual_device);
 }
 
 static gboolean
@@ -1225,7 +1220,7 @@ clutter_input_device_evdev_apply_kbd_a11y_settings (ClutterInputDeviceEvdev *dev
       update_internal_xkb_state (device, 0, 0);
     }
 
-  if (changed_flags & CLUTTER_A11Y_KEYBOARD_ENABLED)
+  if (changed_flags & (CLUTTER_A11Y_KEYBOARD_ENABLED | CLUTTER_A11Y_TOGGLE_KEYS_ENABLED))
     {
       device->toggle_slowkeys_timer = 0;
       device->shift_count = 0;
@@ -1246,13 +1241,6 @@ clutter_input_device_evdev_apply_kbd_a11y_settings (ClutterInputDeviceEvdev *dev
   device->a11y_flags = settings->controls;
 }
 
-void
-clutter_evdev_a11y_maybe_notify_toggle_keys (ClutterInputDeviceEvdev *device)
-{
-  if (device->a11y_flags & CLUTTER_A11Y_TOGGLE_KEYS_ENABLED)
-    clutter_input_device_evdev_bell_notify ();
-}
-
 static void
 release_device_touch_slot (gpointer value)
 {

clutter/clutter/evdev/clutter-input-device-evdev.h

@@ -94,6 +94,7 @@ struct _ClutterInputDeviceEvdev
   gdouble mousekeys_curve_factor;
   guint move_mousekeys_timer;
   guint16 last_mousekeys_key;
+  ClutterVirtualInputDevice *mousekeys_virtual_device;
 };
 
 GType                     _clutter_input_device_evdev_get_type        (void) G_GNUC_CONST;
@@ -150,7 +151,6 @@ void                      clutter_input_device_evdev_release_touch_state (Clutte
 void                      clutter_input_device_evdev_release_touch_slots (ClutterInputDeviceEvdev *device_evdev,
                                                                           uint64_t                 time_us);
 
-void                      clutter_evdev_a11y_maybe_notify_toggle_keys  (ClutterInputDeviceEvdev *);
 
 G_END_DECLS
 

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

@@ -326,7 +326,6 @@ clutter_seat_evdev_notify_key (ClutterSeatEvdev   *seat,
       backend = clutter_get_default_backend ();
       g_signal_emit_by_name (clutter_backend_get_keymap (backend), "state-changed");
       clutter_seat_evdev_sync_leds (seat);
-      clutter_evdev_a11y_maybe_notify_toggle_keys (CLUTTER_INPUT_DEVICE_EVDEV (seat->core_keyboard));
     }
 
   if (state == 0 ||             /* key release */

clutter/clutter/meson.build

@@ -75,7 +75,6 @@ clutter_headers = [
   'clutter-snap-constraint.h',
   'clutter-stage.h',
   'clutter-stage-manager.h',
-  'clutter-stage-view.h',
   'clutter-tap-action.h',
   'clutter-test-utils.h',
   'clutter-texture.h',
@@ -134,7 +133,6 @@ clutter_sources = [
   'clutter-input-device-tool.c',
   'clutter-input-focus.c',
   'clutter-input-method.c',
-  'clutter-input-pointer-a11y.c',
   'clutter-virtual-input-device.c',
   'clutter-interval.c',
   'clutter-keyframe-transition.c',
@@ -165,7 +163,6 @@ clutter_sources = [
   'clutter-snap-constraint.c',
   'clutter-stage.c',
   'clutter-stage-manager.c',
-  'clutter-stage-view.c',
   'clutter-stage-window.c',
   'clutter-tap-action.c',
   'clutter-test-utils.c',
@@ -198,7 +195,6 @@ clutter_private_headers = [
   'clutter-id-pool.h',
   'clutter-input-focus-private.h',
   'clutter-input-method-private.h',
-  'clutter-input-pointer-a11y-private.h',
   'clutter-master-clock.h',
   'clutter-master-clock-default.h',
   'clutter-offscreen-effect-private.h',
@@ -209,7 +205,7 @@ clutter_private_headers = [
   'clutter-settings-private.h',
   'clutter-stage-manager-private.h',
   'clutter-stage-private.h',
-  'clutter-stage-view-private.h',
+  'clutter-stage-view.h',
   'clutter-stage-window.h',
 ]
 
@@ -217,6 +213,7 @@ clutter_nonintrospected_sources = [
   'clutter-easing.c',
   'clutter-event-translator.c',
   'clutter-id-pool.c',
+  'clutter-stage-view.c',
 ]
 
 clutter_deprecated_headers = [
@@ -234,6 +231,7 @@ clutter_deprecated_headers = [
   'deprecated/clutter-container.h',
   'deprecated/clutter-group.h',
   'deprecated/clutter-keysyms.h',
+  'deprecated/clutter-main.h',
   'deprecated/clutter-rectangle.h',
   'deprecated/clutter-stage-manager.h',
   'deprecated/clutter-stage.h',
@@ -343,8 +341,14 @@ if have_native_backend
 endif
 
 if have_wayland
+  clutter_wayland_nonintrospected_sources = [
+    'wayland/clutter-wayland-surface.c',
+  ]
+  clutter_backend_nonintrospected_sources += clutter_wayland_nonintrospected_sources
+
   clutter_wayland_private_headers = [
     'wayland/clutter-wayland-compositor.h',
+    'wayland/clutter-wayland-surface.h',
   ]
   clutter_backend_private_headers += clutter_wayland_private_headers
 endif
@@ -500,12 +504,7 @@ libmutter_clutter_dep = declare_dependency(
 )
 
 if have_introspection
-  clutter_introspection_args = introspection_args + [
-    '-DCLUTTER_SYSCONFDIR="@0@"'.format(join_paths(prefix, sysconfdir)),
-    '-DCLUTTER_COMPILATION=1',
-    '-DCOGL_DISABLE_DEPRECATION_WARNINGS',
-    '-DG_LOG_DOMAIN="Clutter"'
-  ]
+  clutter_introspection_args = introspection_args + clutter_c_args
 
   libmutter_clutter_gir = gnome.generate_gir(libmutter_clutter,
     sources: [

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

@@ -0,0 +1,654 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *  Robert Bragg <robert@linux.intel.com>
+ */
+
+/**
+ * SECTION:clutter-wayland-surface
+ * @Title: ClutterWaylandSurface
+ * @short_description: An actor which displays the content of a client surface
+ *
+ * #ClutterWaylandSurface is an actor for displaying the contents of a client
+ * surface. It is intended to support developers implementing Clutter based
+ * wayland compositors.
+ */
+
+#include "clutter-build-config.h"
+
+#define CLUTTER_ENABLE_EXPERIMENTAL_API
+
+#include "clutter-wayland-surface.h"
+
+#include "clutter-actor-private.h"
+#include "clutter-marshal.h"
+#include "clutter-paint-volume-private.h"
+#include "clutter-private.h"
+#include "clutter-backend.h"
+
+#include <cogl/cogl.h>
+#include <cogl/cogl-wayland-server.h>
+
+enum
+{
+  PROP_SURFACE = 1,
+  PROP_SURFACE_WIDTH,
+  PROP_SURFACE_HEIGHT,
+  PROP_COGL_TEXTURE,
+  PROP_LAST
+};
+
+static GParamSpec *obj_props[PROP_LAST];
+
+enum
+{
+  QUEUE_DAMAGE_REDRAW,
+
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
+struct _ClutterWaylandSurfacePrivate
+{
+  struct wl_surface *surface;
+  CoglTexture2D *buffer;
+  int width, height;
+  CoglPipeline *pipeline;
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE (ClutterWaylandSurface,
+                            clutter_wayland_surface,
+                            CLUTTER_TYPE_ACTOR)
+
+static gboolean
+clutter_wayland_surface_get_paint_volume (ClutterActor *self,
+                                          ClutterPaintVolume *volume)
+{
+  return clutter_paint_volume_set_from_allocation (volume, self);
+}
+
+static void
+clutter_wayland_surface_queue_damage_redraw (ClutterWaylandSurface *texture,
+                                             gint x,
+                                             gint y,
+                                             gint width,
+                                             gint height)
+{
+  ClutterWaylandSurfacePrivate *priv = texture->priv;
+  ClutterActor *self = CLUTTER_ACTOR (texture);
+  ClutterActorBox allocation;
+  float scale_x;
+  float scale_y;
+  cairo_rectangle_int_t clip;
+
+  /* NB: clutter_actor_queue_redraw_with_clip expects a box in the actor's
+   * coordinate space so we need to convert from surface coordinates to
+   * actor coordinates...
+   */
+
+  /* Calling clutter_actor_get_allocation_box() is enormously expensive
+   * if the actor has an out-of-date allocation, since it triggers
+   * a full redraw. clutter_actor_queue_redraw_with_clip() would redraw
+   * the whole stage anyways in that case, so just go ahead and do
+   * it here.
+   */
+  if (!clutter_actor_has_allocation (self))
+    {
+      clutter_actor_queue_redraw (self);
+      return;
+    }
+
+  if (priv->width == 0 || priv->height == 0)
+    return;
+
+  clutter_actor_get_allocation_box (self, &allocation);
+
+  scale_x = (allocation.x2 - allocation.x1) / priv->width;
+  scale_y = (allocation.y2 - allocation.y1) / priv->height;
+
+  clip.x = x * scale_x;
+  clip.y = y * scale_y;
+  clip.width = width * scale_x;
+  clip.height = height * scale_y;
+  clutter_actor_queue_redraw_with_clip (self, &clip);
+}
+
+static void
+free_pipeline (ClutterWaylandSurface *self)
+{
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+
+  if (priv->pipeline)
+    {
+      cogl_object_unref (priv->pipeline);
+      priv->pipeline = NULL;
+    }
+}
+
+static void
+opacity_change_cb (ClutterWaylandSurface *self)
+{
+  free_pipeline (self);
+}
+
+static void
+clutter_wayland_surface_init (ClutterWaylandSurface *self)
+{
+  ClutterWaylandSurfacePrivate *priv;
+  
+  priv = clutter_wayland_surface_get_instance_private (self);
+  priv->surface = NULL;
+  priv->width = 0;
+  priv->height = 0;
+
+  self->priv = priv;
+
+  g_signal_connect (self, "notify::opacity", G_CALLBACK (opacity_change_cb), NULL);
+}
+
+static void
+free_surface_buffers (ClutterWaylandSurface *self)
+{
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+
+  if (priv->buffer)
+    {
+      cogl_object_unref (priv->buffer);
+      priv->buffer = NULL;
+      free_pipeline (self);
+    }
+}
+
+static void
+clutter_wayland_surface_dispose (GObject *object)
+{
+  ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+
+  free_pipeline (self);
+  free_surface_buffers (self);
+  priv->surface = NULL;
+
+  G_OBJECT_CLASS (clutter_wayland_surface_parent_class)->dispose (object);
+}
+
+static void
+set_size (ClutterWaylandSurface *self,
+          int width,
+          int height)
+{
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+
+  if (priv->width != width)
+    {
+      priv->width = width;
+      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_WIDTH]);
+    }
+  if (priv->height != height)
+    {
+      priv->height = height;
+      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_HEIGHT]);
+    }
+
+  clutter_actor_set_size (CLUTTER_ACTOR (self), priv->width, priv->height);
+}
+
+/**
+ * clutter_wayland_surface_get_surface:
+ * @self: a #ClutterWaylandSurface
+ *
+ * Retrieves a point to the Wayland surface used by the actor.
+ *
+ * Return value: (transfer none): a wl_surface pointer, or %NULL
+ *
+ * Since: 1.10
+ */
+struct wl_surface *
+clutter_wayland_surface_get_surface (ClutterWaylandSurface *self)
+{
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+  return priv->surface;
+}
+
+/**
+ * clutter_wayland_surface_set_surface:
+ * @self: a #ClutterWaylandSurface
+ * @surface: a Wayland wl_surface pointer
+ *
+ * Sets the Wayland surface to be used by the actor.
+ *
+ * Since: 1.10
+ */
+void
+clutter_wayland_surface_set_surface (ClutterWaylandSurface *self,
+                                     struct wl_surface *surface)
+{
+  ClutterWaylandSurfacePrivate *priv;
+
+  g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+  priv = self->priv;
+
+  if (priv->surface == surface)
+    return;
+
+  if (priv->surface)
+    {
+      free_pipeline (self);
+      free_surface_buffers (self);
+      g_signal_emit (self, signals[QUEUE_DAMAGE_REDRAW],
+                     0,
+                     0, 0, priv->width, priv->height);
+    }
+
+  priv->surface = surface;
+
+  /* XXX: should we freeze/thaw notifications? */
+
+  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE]);
+
+  /* We have to wait until the next attach event to find out the surface
+   * geometry... */
+  set_size (self, 0, 0);
+}
+
+static void
+clutter_wayland_surface_set_property (GObject *object,
+                                      guint prop_id,
+                                      const GValue *value,
+                                      GParamSpec *pspec)
+{
+  ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+
+  switch (prop_id)
+    {
+    case PROP_SURFACE:
+      clutter_wayland_surface_set_surface (self, g_value_get_pointer (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+clutter_wayland_surface_get_property (GObject *object,
+                                      guint prop_id,
+                                      GValue *value,
+                                      GParamSpec *pspec)
+{
+  ClutterWaylandSurface *self = CLUTTER_WAYLAND_SURFACE (object);
+  ClutterWaylandSurfacePrivate *priv = self->priv;
+
+  switch (prop_id)
+    {
+    case PROP_SURFACE:
+      g_value_set_pointer (value, priv->surface);
+      break;
+    case PROP_SURFACE_WIDTH:
+      g_value_set_uint (value, priv->width);
+      break;
+    case PROP_SURFACE_HEIGHT:
+      g_value_set_uint (value, priv->height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+clutter_wayland_surface_paint (ClutterActor *self)
+{
+  ClutterWaylandSurfacePrivate *priv;
+  CoglFramebuffer *framebuffer;
+  ClutterActorBox box;
+
+  g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+  priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+  framebuffer = cogl_get_draw_framebuffer ();
+
+  if (G_UNLIKELY (priv->pipeline == NULL))
+    {
+      CoglContext *ctx =
+        clutter_backend_get_cogl_context (clutter_get_default_backend ());
+      guint8 paint_opacity = clutter_actor_get_paint_opacity (self);
+
+      priv->pipeline = cogl_pipeline_new (ctx);
+      cogl_pipeline_set_color4ub (priv->pipeline,
+                                  paint_opacity,
+                                  paint_opacity,
+                                  paint_opacity,
+                                  paint_opacity);
+      cogl_pipeline_set_layer_texture (priv->pipeline, 0,
+                                       COGL_TEXTURE (priv->buffer));
+    }
+
+  clutter_actor_get_allocation_box (self, &box);
+  cogl_framebuffer_draw_rectangle (framebuffer,
+                                   priv->pipeline,
+                                   0, 0,
+                                   box.x2 - box.x1, box.y2 - box.y1);
+}
+
+static void
+clutter_wayland_surface_get_preferred_width (ClutterActor *self,
+                                             gfloat for_height,
+                                             gfloat *min_width_p,
+                                             gfloat *natural_width_p)
+{
+  ClutterWaylandSurfacePrivate *priv;
+
+  g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+  priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+
+  if (min_width_p)
+    *min_width_p = 0;
+
+  if (natural_width_p)
+    *natural_width_p = priv->width;
+}
+
+static void
+clutter_wayland_surface_get_preferred_height (ClutterActor *self,
+                                              gfloat for_width,
+                                              gfloat *min_height_p,
+                                              gfloat *natural_height_p)
+{
+  ClutterWaylandSurfacePrivate *priv;
+
+  g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+  priv = CLUTTER_WAYLAND_SURFACE (self)->priv;
+
+  if (min_height_p)
+    *min_height_p = 0;
+
+  if (natural_height_p)
+    *natural_height_p = priv->height;
+}
+
+static gboolean
+clutter_wayland_surface_has_overlaps (ClutterActor *self)
+{
+  /* Rectangles never need an offscreen redirect because there are
+     never any overlapping primitives */
+  return FALSE;
+}
+
+static void
+clutter_wayland_surface_class_init (ClutterWaylandSurfaceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  GParamSpec *pspec;
+
+  actor_class->get_paint_volume = clutter_wayland_surface_get_paint_volume;
+  actor_class->paint = clutter_wayland_surface_paint;
+  actor_class->get_preferred_width =
+    clutter_wayland_surface_get_preferred_width;
+  actor_class->get_preferred_height =
+    clutter_wayland_surface_get_preferred_height;
+  actor_class->has_overlaps = clutter_wayland_surface_has_overlaps;
+
+  object_class->dispose      = clutter_wayland_surface_dispose;
+  object_class->set_property = clutter_wayland_surface_set_property;
+  object_class->get_property = clutter_wayland_surface_get_property;
+
+  pspec = g_param_spec_pointer ("surface",
+			        P_("Surface"),
+			        P_("The underlying wayland surface"),
+                                CLUTTER_PARAM_READWRITE|
+                                G_PARAM_CONSTRUCT_ONLY);
+  obj_props[PROP_SURFACE] = pspec;
+  g_object_class_install_property (object_class, PROP_SURFACE, pspec);
+
+  pspec = g_param_spec_uint ("surface-width",
+                             P_("Surface width"),
+                             P_("The width of the underlying wayland surface"),
+                             0, G_MAXUINT,
+                             0,
+                             G_PARAM_READABLE);
+  obj_props[PROP_SURFACE_WIDTH] = pspec;
+  g_object_class_install_property (object_class, PROP_SURFACE_WIDTH, pspec);
+
+  pspec = g_param_spec_uint ("surface-height",
+                             P_("Surface height"),
+                             P_("The height of the underlying wayland surface"),
+                             0, G_MAXUINT,
+                             0,
+                             G_PARAM_READABLE);
+  obj_props[PROP_SURFACE_HEIGHT] = pspec;
+  g_object_class_install_property (object_class, PROP_SURFACE_HEIGHT, pspec);
+
+  pspec = g_param_spec_boxed ("cogl-texture",
+                              P_("Cogl Texture"),
+                              P_("The underlying Cogl texture handle used to draw this actor"),
+                              COGL_TYPE_HANDLE,
+                              CLUTTER_PARAM_READWRITE);
+  obj_props[PROP_COGL_TEXTURE] = pspec;
+  g_object_class_install_property (object_class, PROP_COGL_TEXTURE, pspec);
+
+  /**
+   * ClutterWaylandSurface::queue-damage-redraw:
+   * @texture: the object which received the signal
+   * @x: The top left x position of the damage region
+   * @y: The top left y position of the damage region
+   * @width: The width of the damage region
+   * @height: The height of the damage region
+   *
+   * ::queue-damage-redraw is emitted to notify that some sub-region
+   * of the texture has been changed. This usually means a redraw
+   * needs to be queued for the actor.
+   *
+   * The default handler will queue a clipped redraw in response to
+   * the damage, using the assumption that the pixmap is being painted
+   * to a rectangle covering the transformed allocation of the actor.
+   * If you sub-class and change the paint method so this isn't true
+   * then you must also provide your own damage signal handler to
+   * queue a redraw that blocks this default behaviour.
+   *
+   * Since: 1.10
+   */
+  signals[QUEUE_DAMAGE_REDRAW] =
+    g_signal_new (g_intern_static_string ("queue-damage-redraw"),
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (ClutterWaylandSurfaceClass, queue_damage_redraw),
+                  NULL, NULL,
+                  _clutter_marshal_VOID__INT_INT_INT_INT,
+                  G_TYPE_NONE, 4,
+                  G_TYPE_INT,
+                  G_TYPE_INT,
+                  G_TYPE_INT,
+                  G_TYPE_INT);
+  klass->queue_damage_redraw = clutter_wayland_surface_queue_damage_redraw;
+}
+
+/**
+ * clutter_wayland_surface_new:
+ * @surface: the Wayland surface this actor should represent
+ *
+ * Creates a new #ClutterWaylandSurface for @surface
+ *
+ * Return value: A new #ClutterWaylandSurface representing @surface
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+ClutterActor *
+clutter_wayland_surface_new (struct wl_surface *surface)
+{
+  ClutterActor *actor;
+
+  actor = g_object_new (CLUTTER_WAYLAND_TYPE_SURFACE,
+                        "surface", surface,
+                        NULL);
+
+  return actor;
+}
+
+/**
+ * clutter_wayland_surface_attach_buffer:
+ * @self: A #ClutterWaylandSurface actor
+ * @buffer: A compositor side resource representing a wl_buffer
+ * @error: A #GError
+ *
+ * This associates a client's buffer with the #ClutterWaylandSurface
+ * actor @self. This will automatically result in @self being re-drawn
+ * with the new buffer contents.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+gboolean
+clutter_wayland_surface_attach_buffer (ClutterWaylandSurface *self,
+                                       struct wl_resource *buffer,
+                                       GError **error)
+{
+  ClutterWaylandSurfacePrivate *priv;
+  ClutterBackend *backend = clutter_get_default_backend ();
+  CoglContext *context = clutter_backend_get_cogl_context (backend);
+
+  g_return_val_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self), TRUE);
+
+  priv = self->priv;
+
+  free_surface_buffers (self);
+
+  priv->buffer =
+    cogl_wayland_texture_2d_new_from_buffer (context, buffer, error);
+
+  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_COGL_TEXTURE]);
+
+  /* NB: We don't queue a redraw of the actor here because we don't
+   * know how much of the buffer has changed with respect to the
+   * previous buffer. We only ever queue a redraw in response to
+   * surface damage. */
+
+  if (!priv->buffer)
+    return FALSE;
+
+  set_size (self,
+            cogl_texture_get_width (COGL_TEXTURE (priv->buffer)),
+            cogl_texture_get_height (COGL_TEXTURE (priv->buffer)));
+
+  return TRUE;
+}
+
+/**
+ * clutter_wayland_surface_damage_buffer:
+ * @self: A #ClutterWaylandSurface actor
+ * @buffer: A wayland resource for a buffer
+ * @x: The x coordinate of the damaged rectangle
+ * @y: The y coordinate of the damaged rectangle
+ * @width: The width of the damaged rectangle
+ * @height: The height of the damaged rectangle
+ *
+ * This marks a region of the given @buffer has having been changed by
+ * the client. This will automatically result in the corresponding damaged
+ * region of the actor @self being redrawn.
+ *
+ * If multiple regions are changed then this should be called multiple
+ * times with different damage rectangles.
+ *
+ * Since: 1.8
+ * Stability: unstable
+ */
+void
+clutter_wayland_surface_damage_buffer (ClutterWaylandSurface *self,
+                                       struct wl_resource *buffer,
+                                       gint32 x,
+                                       gint32 y,
+                                       gint32 width,
+                                       gint32 height)
+{
+  ClutterWaylandSurfacePrivate *priv;
+  struct wl_shm_buffer *shm_buffer;
+
+  g_return_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self));
+
+  priv = self->priv;
+
+  shm_buffer = wl_shm_buffer_get (buffer);
+
+  if (priv->buffer && shm_buffer)
+    {
+      CoglPixelFormat format;
+
+      switch (wl_shm_buffer_get_format (shm_buffer))
+        {
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+          case WL_SHM_FORMAT_ARGB8888:
+            format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
+            break;
+          case WL_SHM_FORMAT_XRGB8888:
+            format = COGL_PIXEL_FORMAT_ARGB_8888;
+            break;
+#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
+          case WL_SHM_FORMAT_ARGB8888:
+            format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
+            break;
+          case WL_SHM_FORMAT_XRGB8888:
+            format = COGL_PIXEL_FORMAT_BGRA_8888;
+            break;
+#endif
+          default:
+            g_warn_if_reached ();
+            format = COGL_PIXEL_FORMAT_ARGB_8888;
+        }
+
+      cogl_texture_set_region (COGL_TEXTURE (priv->buffer),
+                               x, y,
+                               x, y,
+                               width, height,
+                               width, height,
+                               format,
+                               wl_shm_buffer_get_stride (shm_buffer),
+                               wl_shm_buffer_get_data (shm_buffer));
+    }
+
+  g_signal_emit (self, signals[QUEUE_DAMAGE_REDRAW],
+                 0,
+                 x, y, width, height);
+}
+
+/**
+ * clutter_wayland_surface_get_cogl_texture:
+ * @self: a #ClutterWaylandSurface
+ *
+ * Retrieves the Cogl texture with the contents of the Wayland surface.
+ *
+ * Return value: (transfer none): a Cogl texture, or %NULL
+ *
+ * Since: 1.10
+ */
+CoglTexture *
+clutter_wayland_surface_get_cogl_texture (ClutterWaylandSurface *self)
+{
+  g_return_val_if_fail (CLUTTER_WAYLAND_IS_SURFACE (self), NULL);
+
+  return COGL_TEXTURE (self->priv->buffer);
+}

clutter/clutter/wayland/clutter-wayland-surface.h

@@ -0,0 +1,117 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Robert Bragg <robert@linux.intel.com>
+ *
+ */
+
+#ifndef __CLUTTER_WAYLAND_SURFACE_H__
+#define __CLUTTER_WAYLAND_SURFACE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <clutter/clutter.h>
+
+#include <wayland-server.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_WAYLAND_TYPE_SURFACE                 (clutter_wayland_surface_get_type ())
+#define CLUTTER_WAYLAND_SURFACE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurface))
+#define CLUTTER_WAYLAND_SURFACE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurfaceClass))
+#define CLUTTER_WAYLAND_IS_SURFACE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_WAYLAND_TYPE_SURFACE))
+#define CLUTTER_WAYLAND_IS_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_WAYLAND_TYPE_SURFACE))
+#define CLUTTER_WAYLAND_SURFACE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_WAYLAND_TYPE_SURFACE, ClutterWaylandSurfaceClass))
+
+typedef struct _ClutterWaylandSurface        ClutterWaylandSurface;
+typedef struct _ClutterWaylandSurfaceClass   ClutterWaylandSurfaceClass;
+typedef struct _ClutterWaylandSurfacePrivate ClutterWaylandSurfacePrivate;
+
+/**
+ * ClutterWaylandSurface:
+ *
+ * The #ClutterWaylandSurface structure contains only private data
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+struct _ClutterWaylandSurface
+{
+  /*< private >*/
+  ClutterActor parent;
+
+  ClutterWaylandSurfacePrivate *priv;
+};
+
+/**
+ * ClutterWaylandSurfaceClass:
+ * @queue_damage_redraw: class handler of the #ClutterWaylandSurface::queue-damage-redraw signal
+ *
+ * The #ClutterWaylandSurfaceClass structure contains only private data
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+struct _ClutterWaylandSurfaceClass
+{
+  /*< private >*/
+  ClutterActorClass parent_class;
+
+  /*< public >*/
+  void (*queue_damage_redraw) (ClutterWaylandSurface *texture,
+                               gint x,
+                               gint y,
+                               gint width,
+                               gint height);
+
+  /*< private >*/
+  /* padding for future expansion */
+  gpointer _padding_dummy[8];
+};
+
+CLUTTER_EXPORT
+GType clutter_wayland_surface_get_type (void) G_GNUC_CONST;
+
+CLUTTER_EXPORT
+ClutterActor *clutter_wayland_surface_new               (struct wl_surface *surface);
+CLUTTER_EXPORT
+void          clutter_wayland_surface_set_surface       (ClutterWaylandSurface *self,
+                                                         struct wl_surface *surface);
+CLUTTER_EXPORT
+struct wl_surface *clutter_wayland_surface_get_surface  (ClutterWaylandSurface *self);
+CLUTTER_EXPORT
+gboolean      clutter_wayland_surface_attach_buffer     (ClutterWaylandSurface *self,
+                                                         struct wl_resource *buffer,
+                                                         GError **error);
+CLUTTER_EXPORT
+void          clutter_wayland_surface_damage_buffer     (ClutterWaylandSurface *self,
+                                                         struct wl_resource *buffer,
+                                                         gint32 x,
+                                                         gint32 y,
+                                                         gint32 width,
+                                                         gint32 height);
+CLUTTER_EXPORT
+CoglTexture  *clutter_wayland_surface_get_cogl_texture  (ClutterWaylandSurface *self);
+
+G_END_DECLS
+
+#endif

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

@@ -89,6 +89,7 @@ static const gchar *atom_names[] = {
   "_NET_WM_PID",
   "_NET_WM_PING",
   "_NET_WM_STATE",
+  "_NET_WM_STATE_FULLSCREEN",
   "_NET_WM_USER_TIME",
   "WM_PROTOCOLS",
   "WM_DELETE_WINDOW",
@@ -440,13 +441,14 @@ clutter_backend_x11_post_parse (ClutterBackend  *backend,
   backend_x11->atom_NET_WM_PID = atoms[0];
   backend_x11->atom_NET_WM_PING = atoms[1];
   backend_x11->atom_NET_WM_STATE = atoms[2];
-  backend_x11->atom_NET_WM_USER_TIME = atoms[3];
-  backend_x11->atom_WM_PROTOCOLS = atoms[4];
-  backend_x11->atom_WM_DELETE_WINDOW = atoms[5];
-  backend_x11->atom_XEMBED = atoms[6];
-  backend_x11->atom_XEMBED_INFO = atoms[7];
-  backend_x11->atom_NET_WM_NAME = atoms[8];
-  backend_x11->atom_UTF8_STRING = atoms[9];
+  backend_x11->atom_NET_WM_STATE_FULLSCREEN = atoms[3];
+  backend_x11->atom_NET_WM_USER_TIME = atoms[4];
+  backend_x11->atom_WM_PROTOCOLS = atoms[5];
+  backend_x11->atom_WM_DELETE_WINDOW = atoms[6];
+  backend_x11->atom_XEMBED = atoms[7];
+  backend_x11->atom_XEMBED_INFO = atoms[8];
+  backend_x11->atom_NET_WM_NAME = atoms[9];
+  backend_x11->atom_UTF8_STRING = atoms[10];
 
   g_free (clutter_display_name);
 
@@ -561,7 +563,8 @@ clutter_backend_x11_dispose (GObject *gobject)
 static ClutterFeatureFlags
 clutter_backend_x11_get_features (ClutterBackend *backend)
 {
-  ClutterFeatureFlags flags = CLUTTER_FEATURE_STAGE_CURSOR;
+  ClutterFeatureFlags flags = CLUTTER_FEATURE_STAGE_USER_RESIZE
+                            | CLUTTER_FEATURE_STAGE_CURSOR;
 
   flags |= CLUTTER_BACKEND_CLASS (clutter_backend_x11_parent_class)->get_features (backend);
 

clutter/clutter/x11/clutter-backend-x11.h

@@ -89,6 +89,7 @@ struct _ClutterBackendX11
   Atom atom_NET_WM_PID;
   Atom atom_NET_WM_PING;
   Atom atom_NET_WM_STATE;
+  Atom atom_NET_WM_STATE_FULLSCREEN;
   Atom atom_NET_WM_USER_TIME;
   Atom atom_WM_PROTOCOLS;
   Atom atom_WM_DELETE_WINDOW;

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

@@ -30,7 +30,6 @@
 #include "clutter-backend-x11.h"
 #include "clutter-input-device-xi2.h"
 #include "clutter-input-device-tool-xi2.h"
-#include "clutter-input-pointer-a11y-private.h"
 #include "clutter-virtual-input-device-x11.h"
 #include "clutter-stage-x11.h"
 
@@ -1274,60 +1273,6 @@ translate_pad_event (ClutterEvent       *event,
   return TRUE;
 }
 
-static void
-handle_raw_event (ClutterDeviceManagerXI2 *manager_xi2,
-                  XEvent                  *xevent)
-{
-  ClutterInputDevice *device;
-  XGenericEventCookie *cookie;
-  XIEvent *xi_event;
-  XIRawEvent *xev;
-  float x,y;
-
-  cookie = &xevent->xcookie;
-  xi_event = (XIEvent *) cookie->data;
-  xev = (XIRawEvent *) xi_event;
-
-  device = g_hash_table_lookup (manager_xi2->devices_by_id,
-                                GINT_TO_POINTER (xev->deviceid));
-  if (device == NULL)
-    return;
-
-  if (!_clutter_is_input_pointer_a11y_enabled (device))
-    return;
-
-  switch (cookie->evtype)
-    {
-    case XI_RawMotion:
-      CLUTTER_NOTE (EVENT,
-                    "raw motion: device:%d '%s'",
-                    device->id,
-                    device->device_name);
-      /* We don't get actual pointer location with raw events, and we cannot
-       * rely on `clutter_input_device_get_coords()` either because of
-       * unreparented toplevels (like all client-side decoration windows),
-       * so we need to explicitely query the pointer here...
-       */
-      if (clutter_input_device_xi2_get_pointer_location (device, &x, &y))
-        _clutter_input_pointer_a11y_on_motion_event (device, x, y);
-      break;
-    case XI_RawButtonPress:
-    case XI_RawButtonRelease:
-      CLUTTER_NOTE (EVENT,
-                    "raw button %s: device:%d '%s' button %i",
-                    cookie->evtype == XI_RawButtonPress
-                      ? "press  "
-                      : "release",
-                    device->id,
-                    device->device_name,
-                    xev->detail);
-      _clutter_input_pointer_a11y_on_button_event (device,
-                                                  xev->detail,
-                                                  (cookie->evtype == XI_RawButtonPress));
-      break;
-    }
-}
-
 static ClutterTranslateReturn
 clutter_device_manager_xi2_translate_event (ClutterEventTranslator *translator,
                                             gpointer                native,
@@ -1358,14 +1303,6 @@ clutter_device_manager_xi2_translate_event (ClutterEventTranslator *translator,
   if (!xi_event)
     return CLUTTER_TRANSLATE_REMOVE;
 
-  if (cookie->evtype == XI_RawMotion ||
-      cookie->evtype == XI_RawButtonPress ||
-      cookie->evtype == XI_RawButtonRelease)
-    {
-      handle_raw_event (manager_xi2, xevent);
-      return CLUTTER_TRANSLATE_REMOVE;
-    }
-
   if (!(xi_event->evtype == XI_HierarchyChanged ||
         xi_event->evtype == XI_DeviceChanged ||
         xi_event->evtype == XI_PropertyEvent))
@@ -2094,7 +2031,7 @@ clutter_device_manager_xi2_constructed (GObject *gobject)
   GHashTable *masters, *slaves;
   XIDeviceInfo *info;
   XIEventMask event_mask;
-  unsigned char mask[(XI_LASTEVENT + 7) / 8] = { 0, };
+  unsigned char mask[2] = { 0, };
   int n_devices, i;
 
   backend_x11 =
@@ -2146,19 +2083,6 @@ clutter_device_manager_xi2_constructed (GObject *gobject)
   event_mask.mask_len = sizeof (mask);
   event_mask.mask = mask;
 
-  clutter_device_manager_xi2_select_events (manager,
-                                            clutter_x11_get_root_window (),
-                                            &event_mask);
-
-  memset(mask, 0, sizeof (mask));
-  XISetMask (mask, XI_RawMotion);
-  XISetMask (mask, XI_RawButtonPress);
-  XISetMask (mask, XI_RawButtonRelease);
-
-  event_mask.deviceid = XIAllMasterDevices;
-  event_mask.mask_len = sizeof (mask);
-  event_mask.mask = mask;
-
   clutter_device_manager_xi2_select_events (manager,
                                             clutter_x11_get_root_window (),
                                             &event_mask);

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

@@ -46,11 +46,6 @@ struct _ClutterInputDeviceXI2
   gint device_id;
   ClutterInputDeviceTool *current_tool;
 
-  guint inhibit_pointer_query_timer;
-  gboolean query_status;
-  float current_x;
-  float current_y;
-
 #ifdef HAVE_LIBWACOM
   WacomDevice *wacom_device;
   GArray *group_modes;
@@ -117,9 +112,6 @@ clutter_input_device_xi2_finalize (GObject *object)
 
   if (device_xi2->group_modes)
     g_array_unref (device_xi2->group_modes);
-
-  if (device_xi2->inhibit_pointer_query_timer)
-    g_source_remove (device_xi2->inhibit_pointer_query_timer);
 #endif
 
   G_OBJECT_CLASS (clutter_input_device_xi2_parent_class)->finalize (object);
@@ -301,75 +293,6 @@ clutter_input_device_xi2_get_current_tool (ClutterInputDevice *device)
   return device_xi2->current_tool;
 }
 
-static gboolean
-clutter_input_device_xi2_query_pointer_location (ClutterInputDeviceXI2 *device_xi2)
-{
-  Window xroot_window, xchild_window;
-  double xroot_x, xroot_y, xwin_x, xwin_y;
-  XIButtonState button_state;
-  XIModifierState mod_state;
-  XIGroupState group_state;
-  int result;
-
-  clutter_x11_trap_x_errors ();
-  result = XIQueryPointer (clutter_x11_get_default_display (),
-                           device_xi2->device_id,
-                           clutter_x11_get_root_window (),
-                           &xroot_window,
-                           &xchild_window,
-                           &xroot_x, &xroot_y,
-                           &xwin_x, &xwin_y,
-                           &button_state,
-                           &mod_state,
-                           &group_state);
-  clutter_x11_untrap_x_errors ();
-
-  if (!result)
-    return FALSE;
-
-  device_xi2->current_x = (float) xroot_x;
-  device_xi2->current_y = (float) xroot_y;
-
-  return TRUE;
-}
-
-static gboolean
-clear_inhibit_pointer_query_cb (gpointer data)
-{
-  ClutterInputDeviceXI2 *device_xi2 = CLUTTER_INPUT_DEVICE_XI2 (data);
-
-  device_xi2->inhibit_pointer_query_timer = 0;
-
-  return G_SOURCE_REMOVE;
-}
-
-gboolean
-clutter_input_device_xi2_get_pointer_location (ClutterInputDevice *device,
-                                               float              *x,
-                                               float              *y)
-
-{
-  ClutterInputDeviceXI2 *device_xi2 = CLUTTER_INPUT_DEVICE_XI2 (device);
-
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
-  g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE_XI2 (device_xi2), FALSE);
-  g_return_val_if_fail (device->device_type == CLUTTER_POINTER_DEVICE, FALSE);
-
-  /* Throttle XServer queries and roundtrips using an idle timeout */
-  if (device_xi2->inhibit_pointer_query_timer == 0)
-    {
-      device_xi2->query_status =
-        clutter_input_device_xi2_query_pointer_location (device_xi2);
-      device_xi2->inhibit_pointer_query_timer =
-        clutter_threads_add_idle (clear_inhibit_pointer_query_cb, device_xi2);
-    }
-
-  *x = device_xi2->current_x;
-  *y = device_xi2->current_y;
-
-  return device_xi2->query_status;
-}
-
 #ifdef HAVE_LIBWACOM
 void
 clutter_input_device_xi2_ensure_wacom_info (ClutterInputDevice  *device,

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

@@ -48,9 +48,6 @@ void  _clutter_input_device_xi2_translate_state (ClutterEvent    *event,
 void  clutter_input_device_xi2_update_tool      (ClutterInputDevice     *device,
                                                  ClutterInputDeviceTool *tool);
 ClutterInputDeviceTool * clutter_input_device_xi2_get_current_tool (ClutterInputDevice *device);
-gboolean clutter_input_device_xi2_get_pointer_location (ClutterInputDevice *device,
-                                                        float              *x,
-                                                        float              *y);
 
 #ifdef HAVE_LIBWACOM
 void clutter_input_device_xi2_ensure_wacom_info (ClutterInputDevice  *device,

clutter/clutter/x11/clutter-stage-x11.c

@@ -87,6 +87,60 @@ G_DEFINE_TYPE_WITH_CODE (ClutterStageX11,
   ButtonReleaseMask | \
   PointerMotionMask
 
+static void
+send_wmspec_change_state (ClutterBackendX11 *backend_x11,
+                          Window             window,
+                          Atom               state,
+                          gboolean           add)
+{
+  XClientMessageEvent xclient;
+
+  CLUTTER_NOTE (BACKEND, "%s NET_WM state", add ? "adding" : "removing");
+
+  memset (&xclient, 0, sizeof (xclient));
+
+  xclient.type         = ClientMessage;
+  xclient.window       = window;
+  xclient.message_type = backend_x11->atom_NET_WM_STATE;
+  xclient.format       = 32;
+
+  xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+  xclient.data.l[1] = state;
+  xclient.data.l[2] = 0;
+  xclient.data.l[3] = 0;
+  xclient.data.l[4] = 0;
+
+  XSendEvent (backend_x11->xdpy, 
+              DefaultRootWindow (backend_x11->xdpy),
+              False,
+              SubstructureRedirectMask | SubstructureNotifyMask,
+              (XEvent *)&xclient);
+}
+
+static void
+update_state (ClutterStageX11   *stage_x11,
+              ClutterBackendX11 *backend_x11,
+              Atom              *state,
+              gboolean           add)
+{
+  if (add)
+    {
+      /* FIXME: This wont work if we support more states */
+      XChangeProperty (backend_x11->xdpy,
+                       stage_x11->xwin,
+                       backend_x11->atom_NET_WM_STATE, XA_ATOM, 32,
+                       PropModeReplace,
+                       (unsigned char *) state, 1);
+    }
+  else
+    {
+       /* FIXME: This wont work if we support more states */
+       XDeleteProperty (backend_x11->xdpy,
+                        stage_x11->xwin,
+                        backend_x11->atom_NET_WM_STATE);
+    }
+}
+
 static void
 clutter_stage_x11_fix_window_size (ClutterStageX11 *stage_x11,
                                    gint             new_width,
@@ -99,6 +153,9 @@ clutter_stage_x11_fix_window_size (ClutterStageX11 *stage_x11,
     {
       guint min_width, min_height;
       XSizeHints *size_hints;
+      gboolean resize;
+
+      resize = clutter_stage_get_user_resizable (stage_cogl->wrapper);
 
       size_hints = XAllocSizeHints();
 
@@ -112,11 +169,27 @@ clutter_stage_x11_fix_window_size (ClutterStageX11 *stage_x11,
       if (new_height <= 0)
         new_height = min_height;
 
-      size_hints->min_width = new_width;
-      size_hints->min_height = new_height;
-      size_hints->max_width = new_width;
-      size_hints->max_height = new_height;
-      size_hints->flags = PMinSize | PMaxSize;
+      size_hints->flags = 0;
+
+      /* If we are going fullscreen then we don't want any
+         restrictions on the window size */
+      if (!stage_x11->fullscreening)
+        {
+          if (resize)
+            {
+              size_hints->min_width = min_width;
+              size_hints->min_height = min_height;
+              size_hints->flags = PMinSize;
+            }
+          else
+            {
+              size_hints->min_width = new_width;
+              size_hints->min_height = new_height;
+              size_hints->max_width = new_width;
+              size_hints->max_height = new_height;
+              size_hints->flags = PMinSize | PMaxSize;
+            }
+        }
 
       XSetWMNormalHints (backend_x11->xdpy, stage_x11->xwin, size_hints);
 
@@ -143,8 +216,28 @@ clutter_stage_x11_get_geometry (ClutterStageWindow    *stage_window,
                                 cairo_rectangle_int_t *geometry)
 {
   ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window);
+  ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_x11);
+  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (stage_cogl->backend);
 
   geometry->x = geometry->y = 0;
+
+  /* If we're fullscreen, return the size of the display.
+   *
+   * FIXME - this is utterly broken for anything that is not a single
+   * head set up; the window manager will give us the right size in a
+   * ConfigureNotify, but between the fullscreen signal emission on the
+   * stage and the following frame, the size returned by the stage will
+   * be wrong.
+   */
+  if (_clutter_stage_is_fullscreen (stage_cogl->wrapper) &&
+      stage_x11->fullscreening)
+    {
+      geometry->width = DisplayWidth (backend_x11->xdpy, backend_x11->xscreen_num);
+      geometry->height = DisplayHeight (backend_x11->xdpy, backend_x11->xscreen_num);
+
+      return;
+    }
+
   geometry->width = stage_x11->xwin_width;
   geometry->height = stage_x11->xwin_height;
 }
@@ -170,6 +263,10 @@ clutter_stage_x11_resize (ClutterStageWindow *stage_window,
       return;
     }
 
+  /* If we're going fullscreen, don't mess with the size */
+  if (stage_x11->fullscreening)
+    return;
+
   if (width == 0 || height == 0)
     {
       /* Should not happen, if this turns up we need to debug it and
@@ -363,6 +460,117 @@ _clutter_stage_x11_update_foreign_event_mask (CoglOnscreen *onscreen,
                            &attrs);
 }
 
+static void
+clutter_stage_x11_set_fullscreen (ClutterStageWindow *stage_window,
+                                  gboolean            is_fullscreen)
+{
+  ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window);
+  ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_x11);
+  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (stage_cogl->backend);
+  ClutterStage *stage = stage_cogl->wrapper;
+  gboolean was_fullscreen;
+
+  if (stage == NULL || CLUTTER_ACTOR_IN_DESTRUCTION (stage))
+    return;
+
+  was_fullscreen = _clutter_stage_is_fullscreen (stage);
+  is_fullscreen = !!is_fullscreen;
+
+  if (was_fullscreen == is_fullscreen)
+    return;
+
+  CLUTTER_NOTE (BACKEND, "%ssetting fullscreen", is_fullscreen ? "" : "un");
+
+  if (is_fullscreen)
+    {
+#if 0
+      int width, height;
+
+      /* FIXME: this will do the wrong thing for dual-headed
+         displays. This will return the size of the combined display
+         but Metacity (at least) will fullscreen to only one of the
+         displays. This will cause the actor to report the wrong size
+         until the ConfigureNotify for the correct size is received */
+      width  = DisplayWidth (backend_x11->xdpy, backend_x11->xscreen_num);
+      height = DisplayHeight (backend_x11->xdpy, backend_x11->xscreen_num);
+#endif
+
+      /* Set the fullscreen hint so we can retain the old size of the window. */
+      stage_x11->fullscreening = TRUE;
+
+      if (stage_x11->xwin != None)
+        {
+          /* if the actor is not mapped we resize the stage window to match
+           * the size of the screen; this is useful for e.g. EGLX to avoid
+           * a resize when calling clutter_stage_fullscreen() before showing
+           * the stage
+           */
+          if (!STAGE_X11_IS_MAPPED (stage_x11))
+            {
+              CLUTTER_NOTE (BACKEND, "Fullscreening unmapped stage");
+
+              update_state (stage_x11, backend_x11,
+                            &backend_x11->atom_NET_WM_STATE_FULLSCREEN,
+                            TRUE);
+            }
+          else
+            {
+              CLUTTER_NOTE (BACKEND, "Fullscreening mapped stage");
+
+              /* We need to fix the window size so that it will remove
+                 the maximum and minimum window hints. Otherwise
+                 metacity will honour the restrictions and not
+                 fullscreen correctly. */
+              clutter_stage_x11_fix_window_size (stage_x11, -1, -1);
+
+              send_wmspec_change_state (backend_x11, stage_x11->xwin,
+                                        backend_x11->atom_NET_WM_STATE_FULLSCREEN,
+                                        TRUE);
+            }
+        }
+      else
+        stage_x11->fullscreen_on_realize = TRUE;
+    }
+  else
+    {
+      stage_x11->fullscreening = FALSE;
+
+      if (stage_x11->xwin != None)
+        {
+          if (!STAGE_X11_IS_MAPPED (stage_x11))
+            {
+              CLUTTER_NOTE (BACKEND, "Un-fullscreening unmapped stage");
+
+              update_state (stage_x11, backend_x11,
+                            &backend_x11->atom_NET_WM_STATE_FULLSCREEN,
+                            FALSE);
+            }
+          else
+            {
+              CLUTTER_NOTE (BACKEND, "Un-fullscreening mapped stage");
+
+              send_wmspec_change_state (backend_x11,
+                                        stage_x11->xwin,
+                                        backend_x11->atom_NET_WM_STATE_FULLSCREEN,
+                                        FALSE);
+
+              /* Fix the window size to restore the minimum/maximum
+                 restriction */
+              clutter_stage_x11_fix_window_size (stage_x11,
+                                                 stage_x11->xwin_width,
+                                                 stage_x11->xwin_height);
+            }
+        }
+      else
+        stage_x11->fullscreen_on_realize = FALSE;
+    }
+
+  /* XXX: Note we rely on the ConfigureNotify mechanism as the common
+   * mechanism to handle notifications of new X window sizes from the
+   * X server so we don't actively change the stage viewport here or
+   * queue a relayout etc. */
+}
+
 void
 _clutter_stage_x11_events_device_changed (ClutterStageX11 *stage_x11,
                                           ClutterInputDevice *device,
@@ -514,6 +722,13 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window)
                                      stage_x11->xwin_height);
   clutter_stage_x11_set_wm_protocols (stage_x11);
 
+  if (stage_x11->fullscreen_on_realize)
+    {
+      stage_x11->fullscreen_on_realize = FALSE;
+
+      clutter_stage_x11_set_fullscreen (stage_window, TRUE);
+    }
+
   CLUTTER_NOTE (BACKEND, "Successfully realized stage");
 
   return TRUE;
@@ -540,6 +755,17 @@ clutter_stage_x11_set_title (ClutterStageWindow *stage_window,
   set_wm_title (stage_x11);
 }
 
+static void
+clutter_stage_x11_set_user_resizable (ClutterStageWindow *stage_window,
+                                      gboolean            is_resizable)
+{
+  ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window);
+
+  clutter_stage_x11_fix_window_size (stage_x11,
+                                     stage_x11->xwin_width,
+                                     stage_x11->xwin_height);
+}
+
 static inline void
 update_wm_hints (ClutterStageX11 *stage_x11)
 {
@@ -614,6 +840,11 @@ clutter_stage_x11_show (ClutterStageWindow *stage_window,
           set_stage_x11_state (stage_x11, STAGE_X11_WITHDRAWN, 0);
 
           update_wm_hints (stage_x11);
+
+          if (stage_x11->fullscreening)
+            clutter_stage_x11_set_fullscreen (stage_window, TRUE);
+          else
+            clutter_stage_x11_set_fullscreen (stage_window, FALSE);
         }
 
       g_assert (STAGE_X11_IS_MAPPED (stage_x11));
@@ -735,6 +966,7 @@ clutter_stage_x11_init (ClutterStageX11 *stage)
   stage->wm_state = STAGE_X11_WITHDRAWN;
 
   stage->is_foreign_xwin = FALSE;
+  stage->fullscreening = FALSE;
   stage->is_cursor_visible = TRUE;
   stage->accept_focus = TRUE;
 
@@ -747,7 +979,9 @@ clutter_stage_window_iface_init (ClutterStageWindowInterface *iface)
   clutter_stage_window_parent_iface = g_type_interface_peek_parent (iface);
 
   iface->set_title = clutter_stage_x11_set_title;
+  iface->set_fullscreen = clutter_stage_x11_set_fullscreen;
   iface->set_cursor_visible = clutter_stage_x11_set_cursor_visible;
+  iface->set_user_resizable = clutter_stage_x11_set_user_resizable;
   iface->set_accept_focus = clutter_stage_x11_set_accept_focus;
   iface->show = clutter_stage_x11_show;
   iface->hide = clutter_stage_x11_hide;
@@ -867,8 +1101,13 @@ clutter_stage_x11_translate_event (ClutterEventTranslator *translator,
                         xevent->xconfigure.width,
                         xevent->xconfigure.height);
 
-          if ((stage_x11->xwin_width != xevent->xconfigure.width) ||
-              (stage_x11->xwin_height != xevent->xconfigure.height))
+          /* When fullscreen, we'll keep the xwin_width/height
+             variables to track the old size of the window and we'll
+             assume all ConfigureNotifies constitute a size change */
+          if (_clutter_stage_is_fullscreen (stage))
+            size_changed = TRUE;
+          else if ((stage_x11->xwin_width != xevent->xconfigure.width) ||
+                   (stage_x11->xwin_height != xevent->xconfigure.height))
             {
               size_changed = TRUE;
               stage_x11->xwin_width = xevent->xconfigure.width;
@@ -958,6 +1197,57 @@ clutter_stage_x11_translate_event (ClutterEventTranslator *translator,
         }
       break;
 
+    case PropertyNotify:
+      if (xevent->xproperty.atom == backend_x11->atom_NET_WM_STATE &&
+          xevent->xproperty.window == stage_xwindow &&
+          !stage_x11->is_foreign_xwin)
+        {
+          Atom     type;
+          gint     format;
+          gulong   n_items, bytes_after;
+          guchar  *data = NULL;
+          gboolean fullscreen_set = FALSE;
+
+          clutter_x11_trap_x_errors ();
+          XGetWindowProperty (backend_x11->xdpy, stage_xwindow,
+                              backend_x11->atom_NET_WM_STATE,
+                              0, G_MAXLONG,
+                              False, XA_ATOM,
+                              &type, &format, &n_items,
+                              &bytes_after, &data);
+          clutter_x11_untrap_x_errors ();
+
+          if (type != None && data != NULL)
+            {
+              gboolean is_fullscreen = FALSE;
+              Atom *atoms = (Atom *) data;
+              gulong i;
+
+              for (i = 0; i < n_items; i++)
+                {
+                  if (atoms[i] == backend_x11->atom_NET_WM_STATE_FULLSCREEN)
+                    fullscreen_set = TRUE;
+                }
+
+              is_fullscreen = _clutter_stage_is_fullscreen (stage_cogl->wrapper);
+
+              if (fullscreen_set != is_fullscreen)
+                {
+                  if (fullscreen_set)
+                    _clutter_stage_update_state (stage_cogl->wrapper,
+                                                 0,
+                                                 CLUTTER_STAGE_STATE_FULLSCREEN);
+                  else
+                    _clutter_stage_update_state (stage_cogl->wrapper,
+                                                 CLUTTER_STAGE_STATE_FULLSCREEN,
+                                                 0);
+                }
+
+              XFree (data);
+            }
+        }
+      break;
+
     case FocusIn:
       if (!_clutter_stage_is_activated (stage_cogl->wrapper))
         {

clutter/clutter/x11/clutter-stage-x11.h

@@ -70,9 +70,11 @@ struct _ClutterStageX11
   ClutterStageX11State wm_state;
 
   guint is_foreign_xwin       : 1;
+  guint fullscreening         : 1;
   guint is_cursor_visible     : 1;
   guint viewport_initialized  : 1;
   guint accept_focus          : 1;
+  guint fullscreen_on_realize : 1;
 };
 
 struct _ClutterStageX11Class

clutter/meson.build

@@ -12,19 +12,19 @@ clutter_c_args = [
 ]
 
 clutter_debug_c_args = []
-if get_option('debug')
-  clutter_debug_c_args += [
-    '-DCLUTTER_ENABLE_DEBUG',
-    '-fno-omit-frame-pointer'
-  ]
-elif buildtype != 'plain'
+if buildtype.startswith('debug')
+  clutter_debug_c_args += '-DG_DISABLE_CAST_CHECKS'
+  if buildtype == 'debug'
+    clutter_debug_c_args += '-DCLUTTER_ENABLE_DEBUG'
+  endif
+elif buildtype == 'release'
   clutter_debug_c_args += [
     '-DG_DISABLE_ASSERT',
     '-DG_DISABLE_CHECKS',
     '-DG_DISABLE_CAST_CHECKS',
   ]
 endif
-supported_clutter_debug_c_args = cc.get_supported_arguments(clutter_debug_c_args)
+
 clutter_c_args += clutter_debug_c_args
 
 clutter_pkg_deps = [

clutter/tests/conform/actor-destroy.c

@@ -114,12 +114,11 @@ test_destroy_destroy (ClutterActor *self)
       test->tex = NULL;
     }
 
-  g_assert_nonnull (test->children);
+  g_list_free_full (test->children, (GDestroyNotify) clutter_actor_destroy);
+  test->children = NULL;
 
   if (CLUTTER_ACTOR_CLASS (test_destroy_parent_class)->destroy)
     CLUTTER_ACTOR_CLASS (test_destroy_parent_class)->destroy (self);
-
-  g_assert_null (test->children);
 }
 
 static void

clutter/tests/conform/actor-shader-effect.c

@@ -209,16 +209,14 @@ make_actor (GType shader_type)
 }
 
 static guint32
-get_pixel (CoglFramebuffer *fb,
-           int              x,
-           int              y)
+get_pixel (int x, int y)
 {
   guint8 data[4];
 
-  cogl_framebuffer_read_pixels (fb,
-                                x, y, 1, 1,
-                                COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                                data);
+  cogl_read_pixels (x, y, 1, 1,
+                    COGL_READ_PIXELS_COLOR_BUFFER,
+                    COGL_PIXEL_FORMAT_RGBA_8888_PRE,
+                    data);
 
   return (((guint32) data[0] << 16) |
           ((guint32) data[1] << 8) |
@@ -226,21 +224,19 @@ get_pixel (CoglFramebuffer *fb,
 }
 
 static void
-view_painted_cb (ClutterStage     *stage,
-                 ClutterStageView *view,
-                 gpointer          data)
+paint_cb (ClutterStage *stage,
+          gpointer      data)
 {
-  CoglFramebuffer *fb = clutter_stage_view_get_framebuffer (view);
   gboolean *was_painted = data;
 
   /* old shader effect */
-  g_assert_cmpint (get_pixel (fb, 0, 25), ==, 0xff0000);
+  g_assert_cmpint (get_pixel (0, 25), ==, 0xff0000);
   /* new shader effect */
-  g_assert_cmpint (get_pixel (fb, 100, 25), ==, 0x00ffff);
+  g_assert_cmpint (get_pixel (100, 25), ==, 0x00ffff);
   /* another new shader effect */
-  g_assert_cmpint (get_pixel (fb, 200, 25), ==, 0xff00ff);
+  g_assert_cmpint (get_pixel (200, 25), ==, 0xff00ff);
   /* new shader effect */
-  g_assert_cmpint (get_pixel (fb, 300, 25), ==, 0x00ffff);
+  g_assert_cmpint (get_pixel (300, 25), ==, 0x00ffff);
 
   *was_painted = TRUE;
 }
@@ -275,9 +271,9 @@ actor_shader_effect (void)
   clutter_actor_show (stage);
 
   was_painted = FALSE;
-  g_signal_connect_after (stage, "paint-view",
-                          G_CALLBACK (view_painted_cb),
-                          &was_painted);
+  g_signal_connect (stage, "after-paint",
+                    G_CALLBACK (paint_cb),
+                    &was_painted);
 
   while (!was_painted)
     g_main_context_iteration (NULL, FALSE);

clutter/tests/interactive/test-actors.c

@@ -199,6 +199,7 @@ test_actors_main (int argc, char *argv[])
   g_signal_connect (oh->stage, "destroy", G_CALLBACK (stop_and_quit), oh);
 
   clutter_stage_set_title (CLUTTER_STAGE (oh->stage), "Actors");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (oh->stage), TRUE);
 
   /* Create a timeline to manage animation */
   oh->timeline = clutter_timeline_new (6000);

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

@@ -181,6 +181,7 @@ test_bind_constraint_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Constraints");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   clutter_actor_set_size (stage, 800, 600);
 
   /* main rectangle */

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

@@ -91,6 +91,7 @@ test_cairo_clock_main (int argc, char *argv[])
   /* create a resizable stage */
   stage = clutter_stage_new ();
   clutter_stage_set_title (CLUTTER_STAGE (stage), "2D Clock");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   clutter_actor_set_background_color (stage, CLUTTER_COLOR_LightSkyBlue);
   clutter_actor_set_size (stage, 300, 300);
   clutter_actor_show (stage);

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

@@ -13,7 +13,7 @@ G_BEGIN_DECLS
 
 #define TEST_COGLBOX(obj) \
   (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglbox))
+  TEST_TYPE_COGLBOX, TestCoglboxClass))
 
 #define TEST_COGLBOX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_CAST ((klass), \
@@ -77,7 +77,7 @@ struct _TestCoglboxPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
 
 #define TEST_COGLBOX_GET_PRIVATE(obj) \
-(test_coglbox_get_instance_private (TEST_COGLBOX ((obj))))
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
 
 /* Coglbox implementation
  *--------------------------------------------------*/

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

@@ -13,7 +13,7 @@ G_BEGIN_DECLS
 
 #define TEST_COGLBOX(obj) \
   (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglbox))
+  TEST_TYPE_COGLBOX, TestCoglboxClass))
 
 #define TEST_COGLBOX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_CAST ((klass), \
@@ -76,7 +76,7 @@ struct _TestCoglboxPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
 
 #define TEST_COGLBOX_GET_PRIVATE(obj) \
-(test_coglbox_get_instance_private (TEST_COGLBOX ((obj))))
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
 
 /* Coglbox implementation
  *--------------------------------------------------*/

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

@@ -13,7 +13,7 @@ G_BEGIN_DECLS
 
 #define TEST_COGLBOX(obj) \
   (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglbox))
+  TEST_TYPE_COGLBOX, TestCoglboxClass))
 
 #define TEST_COGLBOX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_CAST ((klass), \
@@ -78,7 +78,7 @@ struct _TestCoglboxPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
 
 #define TEST_COGLBOX_GET_PRIVATE(obj) \
-((TestCoglboxPrivate *)test_coglbox_get_instance_private (TEST_COGLBOX ((obj))))
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
 
 /* Coglbox implementation
  *--------------------------------------------------*/

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

@@ -14,7 +14,7 @@ G_BEGIN_DECLS
 
 #define TEST_COGLBOX(obj) \
   (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglbox))
+  TEST_TYPE_COGLBOX, TestCoglboxClass))
 
 #define TEST_COGLBOX_CLASS(klass) \
   (G_TYPE_CHECK_CLASS_CAST ((klass), \
@@ -77,7 +77,7 @@ struct _TestCoglboxPrivate
 G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
 
 #define TEST_COGLBOX_GET_PRIVATE(obj) \
-(test_coglbox_get_instance_private (TEST_COGLBOX ((obj))))
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
 
 /* Coglbox implementation
  *--------------------------------------------------*/

clutter/tests/interactive/test-content.c

@@ -181,6 +181,7 @@ test_content_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   clutter_actor_set_name (stage, "Stage");
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Content");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_actor_show (stage);
 

clutter/tests/interactive/test-events.c

@@ -2,7 +2,7 @@
 #include <clutter/clutter.h>
 #include <string.h>
 
-gboolean IsMotion = TRUE;
+gboolean IsFullScreen = FALSE, IsMotion = TRUE;
 
 int
 test_events_main (int argc, char *argv[]);
@@ -114,6 +114,28 @@ stage_state_cb (ClutterStage    *stage,
   printf("[stage signal] %s\n", detail);
 }
 
+static gboolean
+blue_button_cb (ClutterActor *actor,
+		ClutterEvent *event,
+		gpointer      data)
+{
+  ClutterActor *stage;
+
+  stage = clutter_actor_get_stage (actor);
+
+  if (IsFullScreen)
+    IsFullScreen = FALSE;
+  else
+    IsFullScreen = TRUE;
+
+  clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), IsFullScreen);
+
+  g_print ("*** Fullscreen %s ***\n",
+           IsFullScreen ? "enabled" : "disabled");
+
+  return FALSE;
+}
+
 static gboolean
 red_button_cb (ClutterActor *actor,
                ClutterEvent *event,
@@ -407,6 +429,10 @@ test_events_main (int argc, char *argv[])
   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), (char *) "stage");
+  g_signal_connect (stage, "fullscreen", 
+		    G_CALLBACK (stage_state_cb), (char *) "fullscreen");
+  g_signal_connect (stage, "unfullscreen", 
+		    G_CALLBACK (stage_state_cb), (char *) "unfullscreen");
   g_signal_connect (stage, "activate", 
 		    G_CALLBACK (stage_state_cb), (char *) "activate");
   g_signal_connect (stage, "deactivate", 
@@ -442,6 +468,19 @@ test_events_main (int argc, char *argv[])
 		    focus_box);
   g_signal_connect (actor, "captured-event", G_CALLBACK (capture_cb), NULL);
 
+  actor = clutter_rectangle_new_with_color (CLUTTER_COLOR_Blue);
+  clutter_actor_set_name (actor, "Blue Box");
+  clutter_actor_set_size (actor, 100, 100);
+  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), (char *) "blue box");
+  g_signal_connect (actor, "key-focus-in", G_CALLBACK (key_focus_in_cb),
+		    focus_box);
+  /* Fullscreen */
+  g_signal_connect (actor, "button-press-event",
+                    G_CALLBACK (blue_button_cb), NULL);
+
   /* non reactive */
   actor = clutter_rectangle_new_with_color (CLUTTER_COLOR_Black);
   clutter_actor_set_name (actor, "Black Box");

clutter/tests/interactive/test-grab.c

@@ -218,6 +218,10 @@ test_grab_main (int argc, char *argv[])
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   g_signal_connect (stage, "event",
                     G_CALLBACK (debug_event_cb), (char *) "stage");
+  g_signal_connect (stage, "fullscreen", 
+		    G_CALLBACK (stage_state_cb), (char *) "fullscreen");
+  g_signal_connect (stage, "unfullscreen", 
+		    G_CALLBACK (stage_state_cb), (char *) "unfullscreen");
   g_signal_connect (stage, "activate", 
 		    G_CALLBACK (stage_state_cb), (char *) "activate");
   g_signal_connect (stage, "deactivate", 

clutter/tests/interactive/test-image.c

@@ -189,6 +189,7 @@ test_image_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   clutter_actor_set_name (stage, "Stage");
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Content");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_actor_show (stage);
 

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

@@ -73,6 +73,7 @@ test_rotate_zoom_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Rotate and Zoom actions");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);
   clutter_actor_set_reactive (stage, FALSE);
   clutter_actor_show (stage);

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

@@ -8,6 +8,21 @@ test_stage_sizing_main (int argc, char *argv[]);
 const char *
 test_stage_sizing_describe (void);
 
+static gboolean
+fullscreen_clicked_cb (ClutterStage *stage)
+{
+  clutter_stage_set_fullscreen (stage, !clutter_stage_get_fullscreen (stage));
+  return CLUTTER_EVENT_STOP;
+}
+
+static gboolean
+resize_clicked_cb (ClutterStage *stage)
+{
+  clutter_stage_set_user_resizable (stage,
+                                    !clutter_stage_get_user_resizable (stage));
+  return CLUTTER_EVENT_STOP;
+}
+
 static gboolean
 shrink_clicked_cb (ClutterActor *stage)
 {
@@ -26,6 +41,22 @@ expand_clicked_cb (ClutterActor *stage)
   return CLUTTER_EVENT_STOP;
 }
 
+static void
+on_fullscreen (ClutterStage *stage)
+{
+  float width, height;
+  gboolean is_fullscreen;
+
+  is_fullscreen = clutter_stage_get_fullscreen (stage);
+
+  clutter_actor_get_size (CLUTTER_ACTOR (stage), &width, &height);
+
+  g_print ("Stage size [%s]: %d x %d\n",
+           is_fullscreen ? "fullscreen" : "not fullscreen",
+           (int) width,
+           (int) height);
+}
+
 G_MODULE_EXPORT int
 test_stage_sizing_main (int argc, char *argv[])
 {
@@ -38,12 +69,40 @@ test_stage_sizing_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Stage Sizing");
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
+  g_signal_connect_after (stage, "notify::fullscreen-set", G_CALLBACK (on_fullscreen), NULL);
 
   box = clutter_actor_new ();
   clutter_actor_set_layout_manager (box, clutter_box_layout_new ());
   clutter_actor_add_constraint (box, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5));
   clutter_actor_add_child (stage, box);
 
+  rect = clutter_actor_new ();
+  clutter_actor_set_layout_manager (rect,
+                                    clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
+                                                            CLUTTER_BIN_ALIGNMENT_CENTER));
+  clutter_actor_set_background_color (rect, CLUTTER_COLOR_LightScarletRed);
+  clutter_actor_set_reactive (rect, TRUE);
+  g_signal_connect_swapped (rect, "button-press-event",
+                            G_CALLBACK (fullscreen_clicked_cb),
+                            stage);
+  label = clutter_text_new_with_text ("Sans 16", "Toggle fullscreen");
+  clutter_actor_set_margin (label, &margin);
+  clutter_actor_add_child (rect, label);
+  clutter_actor_add_child (box, rect);
+
+  rect = clutter_actor_new ();
+  clutter_actor_set_layout_manager (rect,
+                                    clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
+                                                            CLUTTER_BIN_ALIGNMENT_CENTER));
+  clutter_actor_set_background_color (rect, CLUTTER_COLOR_Chameleon);
+  clutter_actor_set_reactive (rect, TRUE);
+  g_signal_connect_swapped (rect, "button-press-event",
+                            G_CALLBACK (resize_clicked_cb), stage);
+  label = clutter_text_new_with_text ("Sans 16", "Toggle resizable");
+  clutter_actor_set_margin (label, &margin);
+  clutter_actor_add_child (rect, label);
+  clutter_actor_add_child (box, rect);
+
   rect = clutter_actor_new ();
   clutter_actor_set_layout_manager (rect,
                                     clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,

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

@@ -28,6 +28,7 @@ test_state_script_main (int argc, char *argv[])
 
   stage = clutter_stage_new ();
   clutter_stage_set_title (CLUTTER_STAGE (stage), "State Script");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_actor_show (stage);
 

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

@@ -179,6 +179,7 @@ test_table_layout_main (int argc, char *argv[])
 
   stage = clutter_stage_new ();
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Table Layout");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   clutter_actor_set_size (stage, 640, 480);
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
 

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

@@ -146,7 +146,9 @@ test_texture_async_main (int argc, char *argv[])
                                     task, path,
                                     cleanup_task);
 
+  clutter_threads_enter ();
   clutter_main ();
+  clutter_threads_leave ();
 
   g_free (path);
 

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

@@ -146,6 +146,7 @@ test_touch_events_main (int argc, char *argv[])
   stage = clutter_stage_new ();
   g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
   clutter_stage_set_title (CLUTTER_STAGE (stage), "Touch events");
+  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
   clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);
   clutter_actor_set_reactive (stage, TRUE);
   clutter_actor_show (stage);

cogl/cogl-config.h.meson

@@ -4,9 +4,6 @@
 /* Have GLES 2.0 for rendering */
 #mesondefine HAVE_COGL_GLES2
 
-/* Building with Sysprof profiling suport */
-#mesondefine HAVE_TRACING
-
 /* Enable unit tests */
 #mesondefine ENABLE_UNIT_TESTS
 

cogl/cogl-pango/cogl-pango-fontmap.c

@@ -94,7 +94,7 @@ cogl_pango_font_map_new (void)
 PangoContext *
 cogl_pango_font_map_create_context (CoglPangoFontMap *fm)
 {
-  g_return_val_if_fail (COGL_PANGO_IS_FONT_MAP (fm), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (COGL_PANGO_IS_FONT_MAP (fm), NULL);
 
 #if PANGO_VERSION_CHECK (1, 22, 0)
   /* We can just directly use the pango context from the Cairo font
@@ -138,7 +138,7 @@ void
 cogl_pango_font_map_set_resolution (CoglPangoFontMap *font_map,
 				    double            dpi)
 {
-  g_return_if_fail (COGL_PANGO_IS_FONT_MAP (font_map));
+  _COGL_RETURN_IF_FAIL (COGL_PANGO_IS_FONT_MAP (font_map));
 
   pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (font_map), dpi);
 }

cogl/cogl-pango/cogl-pango-glyph-cache.c

@@ -217,7 +217,7 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
                                             CoglPangoGlyphCacheValue *value)
 {
   CoglAtlasTexture *texture;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
   if (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_SHARED_ATLAS))
     return FALSE;
@@ -232,7 +232,7 @@ cogl_pango_glyph_cache_add_to_global_atlas (CoglPangoGlyphCache *cache,
                                               value->draw_height);
   if (!cogl_texture_allocate (COGL_TEXTURE (texture), &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       return FALSE;
     }
 

cogl/cogl-pango/cogl-pango-render.c

@@ -39,13 +39,6 @@
 #define PANGO_ENABLE_BACKEND 1
 #endif
 
-#ifndef PANGO_UNKNOWN_GLYPH_WIDTH
-#define PANGO_UNKNOWN_GLYPH_WIDTH 10
-#endif
-#ifndef PANGO_UNKNOWN_GLYPH_HEIGHT
-#define PANGO_UNKNOWN_GLYPH_HEIGHT 14
-#endif
-
 #include <pango/pango-fontmap.h>
 #include <pango/pangocairo.h>
 #include <pango/pango-renderer.h>
@@ -160,7 +153,7 @@ cogl_pango_renderer_draw_glyph (CoglPangoRenderer        *priv,
 {
   CoglPangoRendererSliceCbData data;
 
-  g_return_if_fail (priv->display_list != NULL);
+  _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
 
   data.display_list = priv->display_list;
   data.x1 = x1;
@@ -584,7 +577,7 @@ cogl_pango_renderer_set_dirty_glyph (PangoFont *font,
   /* Glyphs that don't take up any space will end up without a
      texture. These should never become dirty so they shouldn't end up
      here */
-  g_return_if_fail (value->texture != NULL);
+  _COGL_RETURN_IF_FAIL (value->texture != NULL);
 
   if (_cogl_texture_get_format (value->texture) == COGL_PIXEL_FORMAT_A_8)
     {
@@ -712,7 +705,7 @@ cogl_pango_ensure_glyph_cache_for_layout (PangoLayout *layout)
   context = pango_layout_get_context (layout);
   priv = cogl_pango_get_renderer_from_context (context);
 
-  g_return_if_fail (PANGO_IS_LAYOUT (layout));
+  _COGL_RETURN_IF_FAIL (PANGO_IS_LAYOUT (layout));
 
   if ((iter = pango_layout_get_iter (layout)) == NULL)
     return;
@@ -766,7 +759,7 @@ cogl_pango_renderer_draw_box (PangoRenderer *renderer,
 {
   CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
 
-  g_return_if_fail (priv->display_list != NULL);
+  _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
 
   _cogl_pango_display_list_add_rectangle (priv->display_list,
                                           x,
@@ -810,7 +803,7 @@ cogl_pango_renderer_draw_rectangle (PangoRenderer   *renderer,
   CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
   float x1, x2, y1, y2;
 
-  g_return_if_fail (priv->display_list != NULL);
+  _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
 
   cogl_pango_renderer_set_color_for_part (renderer, part);
 
@@ -837,7 +830,7 @@ cogl_pango_renderer_draw_trapezoid (PangoRenderer   *renderer,
 {
   CoglPangoRenderer *priv = COGL_PANGO_RENDERER (renderer);
 
-  g_return_if_fail (priv->display_list != NULL);
+  _COGL_RETURN_IF_FAIL (priv->display_list != NULL);
 
   cogl_pango_renderer_set_color_for_part (renderer, part);
 

cogl/cogl-path/cogl-path-enum-types.h.in

@@ -9,7 +9,7 @@ G_BEGIN_DECLS
 /*** END file-header ***/
 
 /*** BEGIN file-production ***/
-/* enumerations from "@basename@" */
+/* enumerations from "@filename@" */
 /*** END file-production ***/
 
 /*** BEGIN file-tail ***/

cogl/cogl-path/cogl-path-functions.h

@@ -460,7 +460,9 @@ cogl_path_fill (CoglPath *path);
  * use while filling a path.</note>
  *
  * Stability: unstable
+ * Deprecated: 1.16: Use cogl_path_fill() instead
  */
+COGL_DEPRECATED_FOR (cogl_path_fill)
 void
 cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
                             CoglPipeline *pipeline,
@@ -490,7 +492,9 @@ cogl_path_stroke (CoglPath *path);
  * regardless of the current transformation matrix.
  *
  * Stability: unstable
+ * Deprecated: 1.16: Use cogl_path_stroke() instead
  */
+COGL_DEPRECATED_FOR (cogl_path_stroke)
 void
 cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
                               CoglPipeline *pipeline,
@@ -525,7 +529,9 @@ cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
  *
  * Since: 1.8
  * Stability: Unstable
+ * Deprecated: 1.16: Use cogl_framebuffer_push_path_clip() instead
  */
+COGL_DEPRECATED_FOR (cogl_framebuffer_push_path_clip)
 void
 cogl_clip_push_from_path (CoglPath *path);
 

cogl/cogl-path/cogl-path.c

@@ -149,7 +149,7 @@ void
 cogl2_path_set_fill_rule (CoglPath *path,
                           CoglPathFillRule fill_rule)
 {
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   if (path->data->fill_rule != fill_rule)
     {
@@ -162,7 +162,7 @@ cogl2_path_set_fill_rule (CoglPath *path,
 CoglPathFillRule
 cogl2_path_get_fill_rule (CoglPath *path)
 {
-  g_return_val_if_fail (cogl_is_path (path), COGL_PATH_FILL_RULE_NON_ZERO);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_path (path), COGL_PATH_FILL_RULE_NON_ZERO);
 
   return path->data->fill_rule;
 }
@@ -225,9 +225,9 @@ _cogl_path_stroke_nodes (CoglPath *path,
   int path_num = 0;
   CoglPathNode *node;
 
-  g_return_if_fail (cogl_is_path (path));
-  g_return_if_fail (cogl_is_framebuffer (framebuffer));
-  g_return_if_fail (cogl_is_pipeline (pipeline));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
 
   data = path->data;
 
@@ -392,7 +392,7 @@ _cogl_path_fill_nodes (CoglPath *path,
 void
 cogl2_path_fill (CoglPath *path)
 {
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_fill_nodes (path,
                          cogl_get_draw_framebuffer (),
@@ -407,7 +407,7 @@ cogl2_path_fill (CoglPath *path)
 void
 cogl2_path_stroke (CoglPath *path)
 {
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   if (path->data->path_nodes->len == 0)
     return;
@@ -424,7 +424,7 @@ cogl2_path_move_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_add_node (path, TRUE, x, y);
 
@@ -443,7 +443,7 @@ cogl2_path_rel_move_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   data = path->data;
 
@@ -459,7 +459,7 @@ cogl2_path_line_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_add_node (path, FALSE, x, y);
 
@@ -476,7 +476,7 @@ cogl2_path_rel_line_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   data = path->data;
 
@@ -488,7 +488,7 @@ cogl2_path_rel_line_to (CoglPath *path,
 void
 cogl2_path_close (CoglPath *path)
 {
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_add_node (path, FALSE, path->data->path_start.x,
                        path->data->path_start.y);
@@ -514,7 +514,7 @@ cogl2_path_polyline (CoglPath *path,
 {
   int c = 0;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   cogl2_path_move_to (path, coords[0], coords[1]);
 
@@ -639,7 +639,7 @@ cogl2_path_arc (CoglPath *path,
 {
   float angle_step = 10;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   /* it is documented that a move to is needed to create a freestanding
    * arc
@@ -683,7 +683,7 @@ cogl2_path_ellipse (CoglPath *path,
 {
   float angle_step = 10;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   /* FIXME: if shows to be slow might be optimized
    * by mirroring just a quarter of it */
@@ -709,7 +709,7 @@ cogl2_path_round_rectangle (CoglPath *path,
   float inner_width = x_2 - x_1 - radius * 2;
   float inner_height = y_2 - y_1 - radius * 2;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   cogl2_path_move_to (path, x_1, y_1 + radius);
   _cogl_path_rel_arc (path,
@@ -860,7 +860,7 @@ cogl2_path_curve_to (CoglPath *path,
 {
   CoglBezCubic cubic;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   /* Prepare cubic curve */
   cubic.p1 = path->data->path_pen;
@@ -890,7 +890,7 @@ cogl2_path_rel_curve_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   data = path->data;
 
@@ -932,7 +932,7 @@ cogl_path_copy (CoglPath *old_path)
 {
   CoglPath *new_path;
 
-  g_return_val_if_fail (cogl_is_path (old_path), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_path (old_path), NULL);
 
   new_path = g_slice_new (CoglPath);
   new_path->data = old_path->data;
@@ -1053,7 +1053,7 @@ cogl_rel_curve2_to (CoglPath *path,
 {
   CoglPathData *data;
 
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   data = path->data;
 
@@ -1504,6 +1504,7 @@ cogl_framebuffer_push_path_clip (CoglFramebuffer *framebuffer,
       COGL_FRAMEBUFFER_STATE_CLIP;
 }
 
+/* XXX: deprecated */
 void
 cogl_clip_push_from_path (CoglPath *path)
 {
@@ -1574,26 +1575,28 @@ _cogl_path_build_stroke_attribute_buffer (CoglPath *path)
   data->stroke_n_attributes = n_attributes;
 }
 
+/* XXX: deprecated */
 void
 cogl_framebuffer_fill_path (CoglFramebuffer *framebuffer,
                             CoglPipeline *pipeline,
                             CoglPath *path)
 {
-  g_return_if_fail (cogl_is_framebuffer (framebuffer));
-  g_return_if_fail (cogl_is_pipeline (pipeline));
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_fill_nodes (path, framebuffer, pipeline, 0 /* flags */);
 }
 
+/* XXX: deprecated */
 void
 cogl_framebuffer_stroke_path (CoglFramebuffer *framebuffer,
                               CoglPipeline *pipeline,
                               CoglPath *path)
 {
-  g_return_if_fail (cogl_is_framebuffer (framebuffer));
-  g_return_if_fail (cogl_is_pipeline (pipeline));
-  g_return_if_fail (cogl_is_path (path));
+  _COGL_RETURN_IF_FAIL (cogl_is_framebuffer (framebuffer));
+  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
+  _COGL_RETURN_IF_FAIL (cogl_is_path (path));
 
   _cogl_path_stroke_nodes (path, framebuffer, pipeline);
 }

cogl/cogl/cogl-atlas-texture.c

@@ -47,6 +47,7 @@
 #include "cogl-atlas.h"
 #include "cogl1-context.h"
 #include "cogl-sub-texture.h"
+#include "cogl-error-private.h"
 #include "cogl-gtype-private.h"
 #include "driver/gl/cogl-pipeline-opengl-private.h"
 #include "driver/gl/cogl-texture-gl-private.h"
@@ -452,7 +453,7 @@ _cogl_atlas_texture_set_region_with_border (CoglAtlasTexture *atlas_tex,
                                             int dst_width,
                                             int dst_height,
                                             CoglBitmap *bmp,
-                                            GError **error)
+                                            CoglError **error)
 {
   CoglAtlas *atlas = atlas_tex->atlas;
 
@@ -523,7 +524,7 @@ _cogl_atlas_texture_convert_bitmap_for_upload (CoglAtlasTexture *atlas_tex,
                                                CoglBitmap *bmp,
                                                CoglPixelFormat internal_format,
                                                gboolean can_convert_in_place,
-                                               GError **error)
+                                               CoglError **error)
 {
   CoglBitmap *upload_bmp;
   CoglBitmap *override_bmp;
@@ -573,7 +574,7 @@ _cogl_atlas_texture_set_region (CoglTexture *tex,
                                 int dst_height,
                                 int level,
                                 CoglBitmap *bmp,
-                                GError **error)
+                                CoglError **error)
 {
   CoglAtlasTexture  *atlas_tex = COGL_ATLAS_TEXTURE (tex);
 
@@ -693,7 +694,7 @@ cogl_atlas_texture_new_with_size (CoglContext *ctx,
 
   /* We can't atlas zero-sized textures because it breaks the atlas
    * data structure */
-  g_return_val_if_fail (width > 0 && height > 0, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (width > 0 && height > 0, NULL);
 
   loader = _cogl_texture_create_loader ();
   loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZED;
@@ -710,7 +711,7 @@ allocate_space (CoglAtlasTexture *atlas_tex,
                 int width,
                 int height,
                 CoglPixelFormat internal_format,
-                GError **error)
+                CoglError **error)
 {
   CoglTexture *tex = COGL_TEXTURE (atlas_tex);
   CoglContext *ctx = tex->context;
@@ -722,10 +723,10 @@ allocate_space (CoglAtlasTexture *atlas_tex,
     {
       COGL_NOTE (ATLAS, "Texture can not be added because the "
                  "format is unsupported");
-      g_set_error_literal (error,
-                           COGL_TEXTURE_ERROR,
-                           COGL_TEXTURE_ERROR_FORMAT,
-                           "Texture format unsuitable for atlasing");
+      _cogl_set_error (error,
+                       COGL_TEXTURE_ERROR,
+                       COGL_TEXTURE_ERROR_FORMAT,
+                       "Texture format unsuitable for atlasing");
       return FALSE;
     }
 
@@ -733,11 +734,11 @@ allocate_space (CoglAtlasTexture *atlas_tex,
      and we shouldn't use the atlas */
   if (!cogl_has_feature (ctx, COGL_FEATURE_ID_OFFSCREEN))
     {
-      g_set_error_literal (error,
-                           COGL_SYSTEM_ERROR,
-                           COGL_SYSTEM_ERROR_UNSUPPORTED,
-                           "Atlasing disabled because migrations "
-                           "would be too slow");
+      _cogl_set_error (error,
+                       COGL_SYSTEM_ERROR,
+                       COGL_SYSTEM_ERROR_UNSUPPORTED,
+                       "Atlasing disabled because migrations "
+                       "would be too slow");
       return FALSE;
     }
 
@@ -776,10 +777,10 @@ allocate_space (CoglAtlasTexture *atlas_tex,
           /* Ok, this means we really can't add it to the atlas */
           cogl_object_unref (atlas);
 
-          g_set_error_literal (error,
-                               COGL_SYSTEM_ERROR,
-                               COGL_SYSTEM_ERROR_NO_MEMORY,
-                               "Not enough memory to atlas texture");
+          _cogl_set_error (error,
+                           COGL_SYSTEM_ERROR,
+                           COGL_SYSTEM_ERROR_NO_MEMORY,
+                           "Not enough memory to atlas texture");
           return FALSE;
         }
     }
@@ -794,7 +795,7 @@ allocate_space (CoglAtlasTexture *atlas_tex,
 static gboolean
 allocate_with_size (CoglAtlasTexture *atlas_tex,
                     CoglTextureLoader *loader,
-                    GError **error)
+                    CoglError **error)
 {
   CoglTexture *tex = COGL_TEXTURE (atlas_tex);
   CoglPixelFormat internal_format =
@@ -819,7 +820,7 @@ allocate_with_size (CoglAtlasTexture *atlas_tex,
 static gboolean
 allocate_from_bitmap (CoglAtlasTexture *atlas_tex,
                       CoglTextureLoader *loader,
-                      GError **error)
+                      CoglError **error)
 {
   CoglTexture *tex = COGL_TEXTURE (atlas_tex);
   CoglBitmap *bmp = loader->src.bitmap.bitmap;
@@ -830,7 +831,7 @@ allocate_from_bitmap (CoglAtlasTexture *atlas_tex,
   CoglPixelFormat internal_format;
   CoglBitmap *upload_bmp;
 
-  g_return_val_if_fail (atlas_tex->atlas == NULL, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (atlas_tex->atlas == NULL, FALSE);
 
   internal_format = _cogl_texture_determine_internal_format (tex, bmp_format);
 
@@ -879,12 +880,12 @@ allocate_from_bitmap (CoglAtlasTexture *atlas_tex,
 
 static gboolean
 _cogl_atlas_texture_allocate (CoglTexture *tex,
-                              GError **error)
+                              CoglError **error)
 {
   CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
   CoglTextureLoader *loader = tex->loader;
 
-  g_return_val_if_fail (loader, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (loader, FALSE);
 
   switch (loader->src_type)
     {
@@ -905,7 +906,7 @@ _cogl_atlas_texture_new_from_bitmap (CoglBitmap *bmp,
 {
   CoglTextureLoader *loader;
 
-  g_return_val_if_fail (cogl_is_bitmap (bmp), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_bitmap (bmp), NULL);
 
   loader = _cogl_texture_create_loader ();
   loader->src_type = COGL_TEXTURE_SOURCE_TYPE_BITMAP;
@@ -932,13 +933,13 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
                                   CoglPixelFormat format,
                                   int rowstride,
                                   const uint8_t *data,
-                                  GError **error)
+                                  CoglError **error)
 {
   CoglBitmap *bmp;
   CoglAtlasTexture *atlas_tex;
 
-  g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, NULL);
-  g_return_val_if_fail (data != NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (format != COGL_PIXEL_FORMAT_ANY, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (data != NULL, NULL);
 
   /* Rowstride from width if not given */
   if (rowstride == 0)
@@ -968,12 +969,12 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
 CoglAtlasTexture *
 cogl_atlas_texture_new_from_file (CoglContext *ctx,
                                   const char *filename,
-                                  GError **error)
+                                  CoglError **error)
 {
   CoglBitmap *bmp;
   CoglAtlasTexture *atlas_tex = NULL;
 
-  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (error == NULL || *error == NULL, NULL);
 
   bmp = cogl_bitmap_new_from_file (filename, error);
   if (bmp == NULL)

cogl/cogl/cogl-atlas-texture.h

@@ -117,7 +117,7 @@ cogl_atlas_texture_new_with_size (CoglContext *ctx,
  * cogl_atlas_texture_new_from_file:
  * @ctx: A #CoglContext
  * @filename: the file to load
- * @error: A #GError to catch exceptional errors or %NULL
+ * @error: A #CoglError to catch exceptional errors or %NULL
  *
  * Creates a #CoglAtlasTexture from an image file. A #CoglAtlasTexture
  * represents a sub-region within one of Cogl's shared texture
@@ -149,7 +149,7 @@ cogl_atlas_texture_new_with_size (CoglContext *ctx,
 CoglAtlasTexture *
 cogl_atlas_texture_new_from_file (CoglContext *ctx,
                                   const char *filename,
-                                  GError **error);
+                                  CoglError **error);
 
 /**
  * cogl_atlas_texture_new_from_data:
@@ -161,7 +161,7 @@ cogl_atlas_texture_new_from_file (CoglContext *ctx,
  *    row in @data. A value of 0 will make Cogl automatically
  *    calculate @rowstride from @width and @format.
  * @data: pointer to the memory region where the source buffer resides
- * @error: A #GError to catch exceptional errors or %NULL
+ * @error: A #CoglError to catch exceptional errors or %NULL
  *
  * Creates a new #CoglAtlasTexture texture based on data residing in
  * memory. A #CoglAtlasTexture represents a sub-region within one of
@@ -198,7 +198,7 @@ cogl_atlas_texture_new_from_data (CoglContext *ctx,
                                   CoglPixelFormat format,
                                   int rowstride,
                                   const uint8_t *data,
-                                  GError **error);
+                                  CoglError **error);
 
 /**
  * cogl_atlas_texture_new_from_bitmap:

cogl/cogl/cogl-atlas.c

@@ -283,7 +283,7 @@ _cogl_atlas_create_texture (CoglAtlas *atlas,
                             int height)
 {
   CoglTexture2D *tex;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
   _COGL_GET_CONTEXT (ctx, NULL);
 
@@ -309,7 +309,7 @@ _cogl_atlas_create_texture (CoglAtlas *atlas,
 
       if (!cogl_texture_allocate (COGL_TEXTURE (tex), &ignore_error))
         {
-          g_error_free (ignore_error);
+          cogl_error_free (ignore_error);
           cogl_object_unref (tex);
           tex = NULL;
         }
@@ -327,7 +327,7 @@ _cogl_atlas_create_texture (CoglAtlas *atlas,
 
       if (!cogl_texture_allocate (COGL_TEXTURE (tex), &ignore_error))
         {
-          g_error_free (ignore_error);
+          cogl_error_free (ignore_error);
           cogl_object_unref (tex);
           tex = NULL;
         }
@@ -560,7 +560,7 @@ create_migration_texture (CoglContext *ctx,
                           CoglPixelFormat internal_format)
 {
   CoglTexture *tex;
-  GError *skip_error = NULL;
+  CoglError *skip_error = NULL;
 
   /* First try creating a fast-path non-sliced texture */
   tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
@@ -573,7 +573,7 @@ create_migration_texture (CoglContext *ctx,
    * lazily when uploading data. */
   if (!cogl_texture_allocate (tex, &skip_error))
     {
-      g_error_free (skip_error);
+      cogl_error_free (skip_error);
       cogl_object_unref (tex);
       tex = NULL;
     }
@@ -605,7 +605,7 @@ _cogl_atlas_copy_rectangle (CoglAtlas *atlas,
 {
   CoglTexture *tex;
   CoglBlitData blit_data;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
   _COGL_GET_CONTEXT (ctx, NULL);
 
@@ -613,7 +613,7 @@ _cogl_atlas_copy_rectangle (CoglAtlas *atlas,
   tex = create_migration_texture (ctx, width, height, internal_format);
   if (!cogl_texture_allocate (tex, &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       cogl_object_unref (tex);
       return NULL;
     }

cogl/cogl/cogl-attribute-buffer.c

@@ -71,7 +71,7 @@ cogl_attribute_buffer_new (CoglContext *context,
   buffer = cogl_attribute_buffer_new_with_size (context, bytes);
 
   /* Note: to keep the common cases simple this API doesn't throw
-   * GErrors, so developers can assume this function never returns
+   * CoglErrors, so developers can assume this function never returns
    * NULL and we will simply abort on error.
    *
    * Developers wanting to catch errors can use

cogl/cogl/cogl-attribute.c

@@ -309,7 +309,7 @@ _cogl_attribute_new_const (CoglContext *context,
       /* FIXME: Up until GL[ES] 3 only square matrices were supported
        * and we don't currently expose non-square matrices in Cogl.
        */
-      g_return_val_if_fail (n_columns == n_components, NULL);
+      _COGL_RETURN_VAL_IF_FAIL (n_columns == n_components, NULL);
       _cogl_boxed_value_set_matrix (&attribute->d.constant.boxed,
                                     n_columns,
                                     1,
@@ -469,7 +469,7 @@ cogl_attribute_new_const_4x4fv (CoglContext *context,
 gboolean
 cogl_attribute_get_normalized (CoglAttribute *attribute)
 {
-  g_return_val_if_fail (cogl_is_attribute (attribute), FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_attribute (attribute), FALSE);
 
   return attribute->normalized;
 }
@@ -490,7 +490,7 @@ void
 cogl_attribute_set_normalized (CoglAttribute *attribute,
                                       gboolean normalized)
 {
-  g_return_if_fail (cogl_is_attribute (attribute));
+  _COGL_RETURN_IF_FAIL (cogl_is_attribute (attribute));
 
   if (G_UNLIKELY (attribute->immutable_ref))
     warn_about_midscene_changes ();
@@ -501,8 +501,8 @@ cogl_attribute_set_normalized (CoglAttribute *attribute,
 CoglAttributeBuffer *
 cogl_attribute_get_buffer (CoglAttribute *attribute)
 {
-  g_return_val_if_fail (cogl_is_attribute (attribute), NULL);
-  g_return_val_if_fail (attribute->is_buffered, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_attribute (attribute), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (attribute->is_buffered, NULL);
 
   return attribute->d.buffered.attribute_buffer;
 }
@@ -511,8 +511,8 @@ void
 cogl_attribute_set_buffer (CoglAttribute *attribute,
                            CoglAttributeBuffer *attribute_buffer)
 {
-  g_return_if_fail (cogl_is_attribute (attribute));
-  g_return_if_fail (attribute->is_buffered);
+  _COGL_RETURN_IF_FAIL (cogl_is_attribute (attribute));
+  _COGL_RETURN_IF_FAIL (attribute->is_buffered);
 
   if (G_UNLIKELY (attribute->immutable_ref))
     warn_about_midscene_changes ();
@@ -528,7 +528,7 @@ _cogl_attribute_immutable_ref (CoglAttribute *attribute)
 {
   CoglBuffer *buffer = COGL_BUFFER (attribute->d.buffered.attribute_buffer);
 
-  g_return_val_if_fail (cogl_is_attribute (attribute), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_attribute (attribute), NULL);
 
   attribute->immutable_ref++;
   _cogl_buffer_immutable_ref (buffer);
@@ -540,8 +540,8 @@ _cogl_attribute_immutable_unref (CoglAttribute *attribute)
 {
   CoglBuffer *buffer = COGL_BUFFER (attribute->d.buffered.attribute_buffer);
 
-  g_return_if_fail (cogl_is_attribute (attribute));
-  g_return_if_fail (attribute->immutable_ref > 0);
+  _COGL_RETURN_IF_FAIL (cogl_is_attribute (attribute));
+  _COGL_RETURN_IF_FAIL (attribute->immutable_ref > 0);
 
   attribute->immutable_ref--;
   _cogl_buffer_immutable_unref (buffer);

cogl/cogl/cogl-bitmap-conversion.c

@@ -361,7 +361,7 @@ _cogl_bitmap_needs_short_temp_buffer (CoglPixelFormat format)
 gboolean
 _cogl_bitmap_convert_into_bitmap (CoglBitmap *src_bmp,
                                   CoglBitmap *dst_bmp,
-                                  GError **error)
+                                  CoglError **error)
 {
   uint8_t *src_data;
   uint8_t *dst_data;
@@ -384,8 +384,8 @@ _cogl_bitmap_convert_into_bitmap (CoglBitmap *src_bmp,
   width = cogl_bitmap_get_width (src_bmp);
   height = cogl_bitmap_get_height (src_bmp);
 
-  g_return_val_if_fail (width == cogl_bitmap_get_width (dst_bmp), FALSE);
-  g_return_val_if_fail (height == cogl_bitmap_get_height (dst_bmp), FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (width == cogl_bitmap_get_width (dst_bmp), FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (height == cogl_bitmap_get_height (dst_bmp), FALSE);
 
   need_premult
     = ((src_format & COGL_PREMULT_BIT) != (dst_format & COGL_PREMULT_BIT) &&
@@ -488,7 +488,7 @@ _cogl_bitmap_convert_into_bitmap (CoglBitmap *src_bmp,
 CoglBitmap *
 _cogl_bitmap_convert (CoglBitmap *src_bmp,
                       CoglPixelFormat dst_format,
-                      GError **error)
+                      CoglError **error)
 {
   CoglBitmap *dst_bmp;
   int width, height;
@@ -547,13 +547,13 @@ CoglBitmap *
 _cogl_bitmap_convert_for_upload (CoglBitmap *src_bmp,
                                  CoglPixelFormat internal_format,
                                  gboolean can_convert_in_place,
-                                 GError **error)
+                                 CoglError **error)
 {
   CoglContext *ctx = _cogl_bitmap_get_context (src_bmp);
   CoglPixelFormat src_format = cogl_bitmap_get_format (src_bmp);
   CoglBitmap *dst_bmp;
 
-  g_return_val_if_fail (internal_format != COGL_PIXEL_FORMAT_ANY, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (internal_format != COGL_PIXEL_FORMAT_ANY, NULL);
 
   /* OpenGL supports specifying a different format for the internal
      format when uploading texture data. We should use this to convert
@@ -616,7 +616,7 @@ _cogl_bitmap_convert_for_upload (CoglBitmap *src_bmp,
 
 gboolean
 _cogl_bitmap_unpremult (CoglBitmap *bmp,
-                        GError **error)
+                        CoglError **error)
 {
   uint8_t *p, *data;
   uint16_t *tmp_row;
@@ -684,7 +684,7 @@ _cogl_bitmap_unpremult (CoglBitmap *bmp,
 
 gboolean
 _cogl_bitmap_premult (CoglBitmap *bmp,
-                      GError **error)
+                      CoglError **error)
 {
   uint8_t *p, *data;
   uint16_t *tmp_row;

cogl/cogl/cogl-bitmap-pixbuf.c

@@ -34,6 +34,7 @@
 #include "cogl-bitmap-private.h"
 #include "cogl-context-private.h"
 #include "cogl-private.h"
+#include "cogl-error-private.h"
 
 #include <string.h>
 
@@ -44,7 +45,7 @@ _cogl_bitmap_get_size_from_file (const char *filename,
                                  int        *width,
                                  int        *height)
 {
-  g_return_val_if_fail (filename != NULL, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (filename != NULL, FALSE);
 
   if (gdk_pixbuf_get_file_info (filename, width, height) != NULL)
     return TRUE;
@@ -55,7 +56,7 @@ _cogl_bitmap_get_size_from_file (const char *filename,
 CoglBitmap *
 _cogl_bitmap_from_file (CoglContext *ctx,
                         const char *filename,
-                        GError **error)
+			CoglError **error)
 {
   static CoglUserDataKey pixbuf_key;
   GdkPixbuf *pixbuf;
@@ -74,7 +75,7 @@ _cogl_bitmap_from_file (CoglContext *ctx,
   pixbuf = gdk_pixbuf_new_from_file (filename, &glib_error);
   if (pixbuf == NULL)
     {
-      g_propagate_error (error, glib_error);
+      _cogl_propagate_gerror (error, glib_error);
       return FALSE;
     }
 

cogl/cogl/cogl-bitmap-private.h

@@ -70,7 +70,7 @@ struct _CoglBitmap
  * @width: width of the bitmap in pixels
  * @height: height of the bitmap in pixels
  * @format: the format of the pixels the array will store
- * @error: A #GError for catching exceptional errors or %NULL
+ * @error: A #CoglError for catching exceptional errors or %NULL
  *
  * This is equivalent to cogl_bitmap_new_with_size() except that it
  * allocated the buffer using g_malloc() instead of creating a
@@ -87,7 +87,7 @@ _cogl_bitmap_new_with_malloc_buffer (CoglContext *context,
                                      unsigned int width,
                                      unsigned int height,
                                      CoglPixelFormat format,
-                                     GError **error);
+                                     CoglError **error);
 
 /* The idea of this function is that it will create a bitmap that
    shares the actual data with another bitmap. This is needed for the
@@ -103,53 +103,53 @@ _cogl_bitmap_new_shared (CoglBitmap      *shared_bmp,
 
 CoglBitmap *
 _cogl_bitmap_convert (CoglBitmap *bmp,
-                      CoglPixelFormat dst_format,
-                      GError **error);
+		      CoglPixelFormat dst_format,
+                      CoglError **error);
 
 CoglBitmap *
 _cogl_bitmap_convert_for_upload (CoglBitmap *src_bmp,
                                  CoglPixelFormat internal_format,
                                  gboolean can_convert_in_place,
-                                 GError **error);
+                                 CoglError **error);
 
 gboolean
 _cogl_bitmap_convert_into_bitmap (CoglBitmap *src_bmp,
                                   CoglBitmap *dst_bmp,
-                                  GError **error);
+                                  CoglError **error);
 
 CoglBitmap *
 _cogl_bitmap_from_file (CoglContext *ctx,
                         const char *filename,
-                        GError **error);
+			CoglError **error);
 
 gboolean
 _cogl_bitmap_unpremult (CoglBitmap *dst_bmp,
-                        GError **error);
+                        CoglError **error);
 
 gboolean
 _cogl_bitmap_premult (CoglBitmap *dst_bmp,
-                      GError **error);
+                      CoglError **error);
 
 gboolean
 _cogl_bitmap_convert_premult_status (CoglBitmap *bmp,
                                      CoglPixelFormat dst_format,
-                                     GError **error);
+                                     CoglError **error);
 
 gboolean
 _cogl_bitmap_copy_subregion (CoglBitmap *src,
-                             CoglBitmap *dst,
-                             int src_x,
-                             int src_y,
-                             int dst_x,
-                             int dst_y,
-                             int width,
-                             int height,
-                             GError **error);
+			     CoglBitmap *dst,
+			     int src_x,
+			     int src_y,
+			     int dst_x,
+			     int dst_y,
+			     int width,
+			     int height,
+                             CoglError **error);
 
 /* Creates a deep copy of the source bitmap */
 CoglBitmap *
 _cogl_bitmap_copy (CoglBitmap *src_bmp,
-                   GError **error);
+                   CoglError **error);
 
 gboolean
 _cogl_bitmap_get_size_from_file (const char *filename,
@@ -172,7 +172,7 @@ uint8_t *
 _cogl_bitmap_map (CoglBitmap *bitmap,
                   CoglBufferAccess access,
                   CoglBufferMapHint hints,
-                  GError **error);
+                  CoglError **error);
 
 void
 _cogl_bitmap_unmap (CoglBitmap *bitmap);
@@ -190,7 +190,7 @@ uint8_t *
 _cogl_bitmap_gl_bind (CoglBitmap *bitmap,
                       CoglBufferAccess access,
                       CoglBufferMapHint hints,
-                      GError **error);
+                      CoglError **error);
 
 void
 _cogl_bitmap_gl_unbind (CoglBitmap *bitmap);

cogl/cogl/cogl-bitmap.c

@@ -37,6 +37,7 @@
 #include "cogl-buffer-private.h"
 #include "cogl-pixel-buffer.h"
 #include "cogl-context-private.h"
+#include "cogl-error-private.h"
 #include "cogl-gtype-private.h"
 #include "driver/gl/cogl-buffer-gl-private.h"
 
@@ -65,7 +66,7 @@ _cogl_bitmap_free (CoglBitmap *bmp)
 gboolean
 _cogl_bitmap_convert_premult_status (CoglBitmap *bmp,
                                      CoglPixelFormat dst_format,
-                                     GError **error)
+                                     CoglError **error)
 {
   /* Do we need to unpremultiply? */
   if ((bmp->format & COGL_PREMULT_BIT) > 0 &&
@@ -85,7 +86,7 @@ _cogl_bitmap_convert_premult_status (CoglBitmap *bmp,
 
 CoglBitmap *
 _cogl_bitmap_copy (CoglBitmap *src_bmp,
-                   GError **error)
+                   CoglError **error)
 {
   CoglBitmap *dst_bmp;
   CoglPixelFormat src_format = cogl_bitmap_get_format (src_bmp);
@@ -123,7 +124,7 @@ _cogl_bitmap_copy_subregion (CoglBitmap *src,
 			     int dst_y,
 			     int width,
 			     int height,
-                             GError **error)
+                             CoglError **error)
 {
   uint8_t *srcdata;
   uint8_t *dstdata;
@@ -132,9 +133,9 @@ _cogl_bitmap_copy_subregion (CoglBitmap *src,
   gboolean succeeded = FALSE;
 
   /* Intended only for fast copies when format is equal! */
-  g_return_val_if_fail ((src->format & ~COGL_PREMULT_BIT) ==
-                        (dst->format & ~COGL_PREMULT_BIT),
-                        FALSE);
+  _COGL_RETURN_VAL_IF_FAIL ((src->format & ~COGL_PREMULT_BIT) ==
+                            (dst->format & ~COGL_PREMULT_BIT),
+                            FALSE);
 
   bpp = _cogl_pixel_format_get_bytes_per_pixel (src->format);
 
@@ -208,7 +209,7 @@ _cogl_bitmap_new_with_malloc_buffer (CoglContext *context,
                                      unsigned int width,
                                      unsigned int height,
                                      CoglPixelFormat format,
-                                     GError **error)
+                                     CoglError **error)
 {
   static CoglUserDataKey bitmap_free_key;
   int bpp = _cogl_pixel_format_get_bytes_per_pixel (format);
@@ -218,9 +219,10 @@ _cogl_bitmap_new_with_malloc_buffer (CoglContext *context,
 
   if (!data)
     {
-      g_set_error_literal (error, COGL_SYSTEM_ERROR,
-                           COGL_SYSTEM_ERROR_NO_MEMORY,
-                           "Failed to allocate memory for bitmap");
+      _cogl_set_error (error,
+                       COGL_SYSTEM_ERROR,
+                       COGL_SYSTEM_ERROR_NO_MEMORY,
+                       "Failed to allocate memory for bitmap");
       return NULL;
     }
 
@@ -259,12 +261,12 @@ _cogl_bitmap_new_shared (CoglBitmap              *shared_bmp,
 
 CoglBitmap *
 cogl_bitmap_new_from_file (const char *filename,
-                           GError **error)
+                           CoglError **error)
 {
   _COGL_GET_CONTEXT (ctx, NULL);
 
-  g_return_val_if_fail (filename != NULL, NULL);
-  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (filename != NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (error == NULL || *error == NULL, NULL);
 
   return _cogl_bitmap_from_file (ctx, filename, error);
 }
@@ -279,7 +281,7 @@ cogl_bitmap_new_from_buffer (CoglBuffer *buffer,
 {
   CoglBitmap *bmp;
 
-  g_return_val_if_fail (cogl_is_buffer (buffer), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_buffer (buffer), NULL);
 
   bmp = cogl_bitmap_new_for_data (buffer->context,
                                   width, height,
@@ -304,7 +306,7 @@ cogl_bitmap_new_with_size (CoglContext *context,
   unsigned int rowstride;
 
   /* creating a buffer to store "any" format does not make sense */
-  g_return_val_if_fail (format != COGL_PIXEL_FORMAT_ANY, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (format != COGL_PIXEL_FORMAT_ANY, NULL);
 
   /* for now we fallback to cogl_pixel_buffer_new, later, we could ask
    * libdrm a tiled buffer for instance */
@@ -315,7 +317,7 @@ cogl_bitmap_new_with_size (CoglContext *context,
                            height * rowstride,
                            NULL); /* data */
 
-  g_return_val_if_fail (pixel_buffer != NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (pixel_buffer != NULL, NULL);
 
   bitmap = cogl_bitmap_new_from_buffer (COGL_BUFFER (pixel_buffer),
                                         format,
@@ -378,7 +380,7 @@ uint8_t *
 _cogl_bitmap_map (CoglBitmap *bitmap,
                   CoglBufferAccess access,
                   CoglBufferMapHint hints,
-                  GError **error)
+                  CoglError **error)
 {
   /* Divert to another bitmap if this data is shared */
   if (bitmap->shared_bmp)
@@ -435,10 +437,10 @@ uint8_t *
 _cogl_bitmap_gl_bind (CoglBitmap *bitmap,
                       CoglBufferAccess access,
                       CoglBufferMapHint hints,
-                      GError **error)
+                      CoglError **error)
 {
   uint8_t *ptr;
-  GError *internal_error = NULL;
+  CoglError *internal_error = NULL;
 
   g_return_val_if_fail (access & (COGL_BUFFER_ACCESS_READ |
                                   COGL_BUFFER_ACCESS_WRITE),
@@ -448,7 +450,7 @@ _cogl_bitmap_gl_bind (CoglBitmap *bitmap,
   if (bitmap->shared_bmp)
     return _cogl_bitmap_gl_bind (bitmap->shared_bmp, access, hints, error);
 
-  g_return_val_if_fail (!bitmap->bound, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (!bitmap->bound, NULL);
 
   /* If the bitmap wasn't created from a buffer then the
      implementation of bind is the same as map */
@@ -480,7 +482,7 @@ _cogl_bitmap_gl_bind (CoglBitmap *bitmap,
    * if an exception was thrown */
   if (internal_error)
     {
-      g_propagate_error (error, internal_error);
+      _cogl_propagate_error (error, internal_error);
       return NULL;
     }
 

cogl/cogl/cogl-bitmap.h

@@ -70,7 +70,7 @@ GType cogl_bitmap_get_gtype (void);
 /**
  * cogl_bitmap_new_from_file:
  * @filename: the file to load.
- * @error: a #GError or %NULL.
+ * @error: a #CoglError or %NULL.
  *
  * Loads an image file from disk. This function can be safely called from
  * within a thread.
@@ -82,7 +82,7 @@ GType cogl_bitmap_get_gtype (void);
  */
 CoglBitmap *
 cogl_bitmap_new_from_file (const char *filename,
-                           GError **error);
+                           CoglError **error);
 
 /**
  * cogl_bitmap_new_from_buffer: (skip)
@@ -269,7 +269,7 @@ cogl_is_bitmap (void *object);
 /**
  * COGL_BITMAP_ERROR:
  *
- * #GError domain for bitmap errors.
+ * #CoglError domain for bitmap errors.
  *
  * Since: 1.4
  */

cogl/cogl/cogl-blend-string.c

@@ -41,6 +41,7 @@
 #include "cogl-context-private.h"
 #include "cogl-debug.h"
 #include "cogl-blend-string.h"
+#include "cogl-error-private.h"
 
 typedef enum _ParserState
 {
@@ -165,7 +166,7 @@ _cogl_blend_string_split_rgba_statement (CoglBlendStringStatement *statement,
 static gboolean
 validate_tex_combine_statements (CoglBlendStringStatement *statements,
                                  int n_statements,
-                                 GError **error)
+                                 CoglError **error)
 {
   int i, j;
   const char *error_string;
@@ -194,8 +195,11 @@ validate_tex_combine_statements (CoglBlendStringStatement *statements,
   return TRUE;
 
 error:
-  g_set_error (error, COGL_BLEND_STRING_ERROR, detail,
-               "Invalid texture combine string: %s", error_string);
+  _cogl_set_error (error,
+                   COGL_BLEND_STRING_ERROR,
+                   detail,
+                   "Invalid texture combine string: %s",
+                   error_string);
 
   if (COGL_DEBUG_ENABLED (COGL_DEBUG_BLEND_STRINGS))
     {
@@ -208,7 +212,7 @@ error:
 static gboolean
 validate_blend_statements (CoglBlendStringStatement *statements,
                            int n_statements,
-                           GError **error)
+                           CoglError **error)
 {
   int i, j;
   const char *error_string;
@@ -261,8 +265,11 @@ validate_blend_statements (CoglBlendStringStatement *statements,
   return TRUE;
 
 error:
-  g_set_error (error, COGL_BLEND_STRING_ERROR, detail,
-               "Invalid blend string: %s", error_string);
+  _cogl_set_error (error,
+                   COGL_BLEND_STRING_ERROR,
+                   detail,
+                   "Invalid blend string: %s",
+                   error_string);
   return FALSE;
 }
 
@@ -270,7 +277,7 @@ static gboolean
 validate_statements_for_context (CoglBlendStringStatement *statements,
                                  int n_statements,
                                  CoglBlendStringContext context,
-                                 GError **error)
+                                 CoglError **error)
 {
   const char *error_string;
 
@@ -296,12 +303,13 @@ validate_statements_for_context (CoglBlendStringStatement *statements,
     return validate_tex_combine_statements (statements, n_statements, error);
 
 error:
-  g_set_error (error, COGL_BLEND_STRING_ERROR,
-               COGL_BLEND_STRING_ERROR_INVALID_ERROR,
-               "Invalid %s string: %s",
-               context == COGL_BLEND_STRING_CONTEXT_BLENDING ?
-               "blend" : "texture combine",
-               error_string);
+  _cogl_set_error (error,
+                   COGL_BLEND_STRING_ERROR,
+                   COGL_BLEND_STRING_ERROR_INVALID_ERROR,
+                   "Invalid %s string: %s",
+                   context == COGL_BLEND_STRING_CONTEXT_BLENDING ?
+                   "blend" : "texture combine",
+                   error_string);
 
   if (COGL_DEBUG_ENABLED (COGL_DEBUG_BLEND_STRINGS))
     {
@@ -456,7 +464,7 @@ parse_argument (const char *string, /* original user string */
                 int current_arg,
                 CoglBlendStringArgument *arg, /* OUT */
                 CoglBlendStringContext context,
-                GError **error)
+                CoglError **error)
 {
   const char *p = *ret_p;
   const char *mark = NULL;
@@ -725,13 +733,13 @@ parse_argument (const char *string, /* original user string */
 error:
   {
     int offset = p - string;
-    g_set_error (error,
-                 COGL_BLEND_STRING_ERROR,
-                 COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR,
-                 "Syntax error for argument %d at offset %d: %s",
-                 current_arg,
-                 offset,
-                 error_string);
+    _cogl_set_error (error,
+                     COGL_BLEND_STRING_ERROR,
+                     COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR,
+                     "Syntax error for argument %d at offset %d: %s",
+                     current_arg,
+                     offset,
+                     error_string);
 
     if (COGL_DEBUG_ENABLED (COGL_DEBUG_BLEND_STRINGS))
       {
@@ -746,7 +754,7 @@ int
 _cogl_blend_string_compile (const char *string,
                             CoglBlendStringContext context,
                             CoglBlendStringStatement *statements,
-                            GError **error)
+                            CoglError **error)
 {
   const char *p = string;
   const char *mark = NULL;
@@ -906,12 +914,12 @@ finished:
 error:
     {
       int offset = p - string;
-      g_set_error (error,
-                   COGL_BLEND_STRING_ERROR,
-                   COGL_BLEND_STRING_ERROR_PARSE_ERROR,
-                   "Syntax error at offset %d: %s",
-                   offset,
-                   error_string);
+      _cogl_set_error (error,
+                       COGL_BLEND_STRING_ERROR,
+                       COGL_BLEND_STRING_ERROR_PARSE_ERROR,
+                       "Syntax error at offset %d: %s",
+                       offset,
+                       error_string);
 
       if (COGL_DEBUG_ENABLED (COGL_DEBUG_BLEND_STRINGS))
         {
@@ -963,7 +971,7 @@ _cogl_blend_string_test (void)
   };
   int i;
 
-  GError *error = NULL;
+  CoglError *error = NULL;
   for (i = 0; strings[i].string; i++)
     {
       CoglBlendStringStatement statements[2];
@@ -976,7 +984,7 @@ _cogl_blend_string_test (void)
           g_print ("Failed to parse string:\n%s\n%s\n",
                    strings[i].string,
                    error->message);
-          g_error_free (error);
+          cogl_error_free (error);
           error = NULL;
           continue;
         }

cogl/cogl/cogl-blend-string.h

@@ -133,7 +133,7 @@ gboolean
 _cogl_blend_string_compile (const char *string,
                             CoglBlendStringContext context,
                             CoglBlendStringStatement *statements,
-                            GError **error);
+                            CoglError **error);
 
 void
 _cogl_blend_string_split_rgba_statement (CoglBlendStringStatement *statement,

cogl/cogl/cogl-blit.c

@@ -4,7 +4,6 @@
  * A Low Level GPU Graphics and Utilities API
  *
  * Copyright (C) 2011 Intel Corporation.
- * Copyright (C) 2019 DisplayLink (UK) Ltd.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -53,7 +52,7 @@ _cogl_blit_texture_render_begin (CoglBlitData *data)
   CoglFramebuffer *fb;
   CoglPipeline *pipeline;
   unsigned int dst_width, dst_height;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
   offscreen = _cogl_offscreen_new_with_texture_full
     (data->dst_tex, COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL, 0 /* level */);
@@ -61,7 +60,7 @@ _cogl_blit_texture_render_begin (CoglBlitData *data)
   fb = COGL_FRAMEBUFFER (offscreen);
   if (!cogl_framebuffer_allocate (fb, &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       cogl_object_unref (fb);
       return FALSE;
     }
@@ -151,14 +150,13 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
   CoglContext *ctx = data->src_tex->context;
   CoglOffscreen *dst_offscreen = NULL, *src_offscreen = NULL;
   CoglFramebuffer *dst_fb, *src_fb;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
-  /* We can only blit between FBOs if both textures have the same
-     premult convention and the blit framebuffer extension is
-     supported. */
-  if ((_cogl_texture_get_format (data->src_tex) & COGL_PREMULT_BIT) !=
-      (_cogl_texture_get_format (data->dst_tex) & COGL_PREMULT_BIT) ||
-      !_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_BLIT_FRAMEBUFFER))
+  /* We can only blit between FBOs if both textures are the same
+     format and the blit framebuffer extension is supported */
+  if ((_cogl_texture_get_format (data->src_tex) & ~COGL_A_BIT) !=
+      (_cogl_texture_get_format (data->dst_tex) & ~COGL_A_BIT) ||
+      !_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT))
     return FALSE;
 
   dst_offscreen = _cogl_offscreen_new_with_texture_full
@@ -167,7 +165,7 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
   dst_fb = COGL_FRAMEBUFFER (dst_offscreen);
   if (!cogl_framebuffer_allocate (dst_fb, &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       goto error;
     }
 
@@ -179,7 +177,7 @@ _cogl_blit_framebuffer_begin (CoglBlitData *data)
   src_fb = COGL_FRAMEBUFFER (src_offscreen);
   if (!cogl_framebuffer_allocate (src_fb, &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       goto error;
     }
 
@@ -207,12 +205,11 @@ _cogl_blit_framebuffer_blit (CoglBlitData *data,
                              int width,
                              int height)
 {
-  cogl_blit_framebuffer (data->src_fb,
-                         data->dest_fb,
-                         src_x, src_y,
-                         dst_x, dst_y,
-                         width, height,
-                         NULL);
+  _cogl_blit_framebuffer (data->src_fb,
+                          data->dest_fb,
+                          src_x, src_y,
+                          dst_x, dst_y,
+                          width, height);
 }
 
 static void
@@ -227,7 +224,7 @@ _cogl_blit_copy_tex_sub_image_begin (CoglBlitData *data)
 {
   CoglOffscreen *offscreen;
   CoglFramebuffer *fb;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
   /* This will only work if the target texture is a CoglTexture2D */
   if (!cogl_is_texture_2d (data->dst_tex))
@@ -239,7 +236,7 @@ _cogl_blit_copy_tex_sub_image_begin (CoglBlitData *data)
   fb = COGL_FRAMEBUFFER (offscreen);
   if (!cogl_framebuffer_allocate (fb, &ignore_error))
     {
-      g_error_free (ignore_error);
+      cogl_error_free (ignore_error);
       cogl_object_unref (fb);
       return FALSE;
     }
@@ -295,7 +292,7 @@ _cogl_blit_get_tex_data_blit (CoglBlitData *data,
                               int width,
                               int height)
 {
-  GError *ignore = NULL;
+  CoglError *ignore = NULL;
   int rowstride = data->src_width * data->bpp;
   int offset = rowstride * src_y + src_x * data->bpp;
 
@@ -412,7 +409,7 @@ _cogl_blit_begin (CoglBlitData *data,
                      _cogl_blit_modes[i].name);
 
       /* The last blit mode can't fail so this should never happen */
-      g_return_if_fail (i < G_N_ELEMENTS (_cogl_blit_modes));
+      _COGL_RETURN_IF_FAIL (i < G_N_ELEMENTS (_cogl_blit_modes));
     }
 
   data->blit_mode = _cogl_blit_default_mode;

cogl/cogl/cogl-buffer-private.h

@@ -53,7 +53,7 @@ struct _CoglBufferVtable
                         size_t size,
                         CoglBufferAccess access,
                         CoglBufferMapHint hints,
-                        GError **error);
+                        CoglError **error);
 
   void (* unmap) (CoglBuffer *buffer);
 
@@ -61,7 +61,7 @@ struct _CoglBufferVtable
                          unsigned int offset,
                          const void *data,
                          unsigned int size,
-                         GError **error);
+                         CoglError **error);
 };
 
 typedef enum _CoglBufferFlags
@@ -153,13 +153,13 @@ _cogl_buffer_set_data (CoglBuffer *buffer,
                        size_t offset,
                        const void *data,
                        size_t size,
-                       GError **error);
+                       CoglError **error);
 
 void *
 _cogl_buffer_map (CoglBuffer *buffer,
                   CoglBufferAccess access,
                   CoglBufferMapHint hints,
-                  GError **error);
+                  CoglError **error);
 
 /* This is a wrapper around cogl_buffer_map_range for internal use
    when we want to map the buffer for write only to replace the entire

cogl/cogl/cogl-buffer.c

@@ -88,7 +88,7 @@ malloc_map_range (CoglBuffer *buffer,
                   size_t size,
                   CoglBufferAccess access,
                   CoglBufferMapHint hints,
-                  GError **error)
+                  CoglError **error)
 {
   buffer->flags |= COGL_BUFFER_FLAG_MAPPED;
   return buffer->data + offset;
@@ -105,7 +105,7 @@ malloc_set_data (CoglBuffer *buffer,
                  unsigned int offset,
                  const void *data,
                  unsigned int size,
-                 GError **error)
+                 CoglError **error)
 {
   memcpy (buffer->data + offset, data, size);
   return TRUE;
@@ -167,8 +167,8 @@ _cogl_buffer_initialize (CoglBuffer *buffer,
 void
 _cogl_buffer_fini (CoglBuffer *buffer)
 {
-  g_return_if_fail (!(buffer->flags & COGL_BUFFER_FLAG_MAPPED));
-  g_return_if_fail (buffer->immutable_ref == 0);
+  _COGL_RETURN_IF_FAIL (!(buffer->flags & COGL_BUFFER_FLAG_MAPPED));
+  _COGL_RETURN_IF_FAIL (buffer->immutable_ref == 0);
 
   if (buffer->flags & COGL_BUFFER_FLAG_BUFFER_OBJECT)
     buffer->context->driver_vtable->buffer_destroy (buffer);
@@ -223,9 +223,9 @@ void *
 _cogl_buffer_map (CoglBuffer *buffer,
                   CoglBufferAccess access,
                   CoglBufferMapHint hints,
-                  GError **error)
+                  CoglError **error)
 {
-  g_return_val_if_fail (cogl_is_buffer (buffer), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_buffer (buffer), NULL);
 
   return cogl_buffer_map_range (buffer, 0, buffer->size, access, hints, error);
 }
@@ -235,11 +235,12 @@ cogl_buffer_map (CoglBuffer *buffer,
                  CoglBufferAccess access,
                  CoglBufferMapHint hints)
 {
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
   void *ptr =
     cogl_buffer_map_range (buffer, 0, buffer->size, access, hints,
                            &ignore_error);
-  g_clear_error (&ignore_error);
+  if (!ptr)
+    cogl_error_free (ignore_error);
   return ptr;
 }
 
@@ -249,10 +250,10 @@ cogl_buffer_map_range (CoglBuffer *buffer,
                        size_t size,
                        CoglBufferAccess access,
                        CoglBufferMapHint hints,
-                       GError **error)
+                       CoglError **error)
 {
-  g_return_val_if_fail (cogl_is_buffer (buffer), NULL);
-  g_return_val_if_fail (!(buffer->flags & COGL_BUFFER_FLAG_MAPPED), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_buffer (buffer), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (!(buffer->flags & COGL_BUFFER_FLAG_MAPPED), NULL);
 
   if (G_UNLIKELY (buffer->immutable_ref))
     warn_about_midscene_changes ();
@@ -292,9 +293,9 @@ _cogl_buffer_map_range_for_fill_or_fallback (CoglBuffer *buffer,
 {
   CoglContext *ctx = buffer->context;
   void *ret;
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
 
-  g_return_val_if_fail (!ctx->buffer_map_fallback_in_use, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (!ctx->buffer_map_fallback_in_use, NULL);
 
   ctx->buffer_map_fallback_in_use = TRUE;
 
@@ -308,7 +309,7 @@ _cogl_buffer_map_range_for_fill_or_fallback (CoglBuffer *buffer,
   if (ret)
     return ret;
 
-  g_error_free (ignore_error);
+  cogl_error_free (ignore_error);
 
   /* If the map fails then we'll use a temporary buffer to fill
      the data and then upload it using cogl_buffer_set_data when
@@ -327,7 +328,7 @@ _cogl_buffer_unmap_for_fill_or_fallback (CoglBuffer *buffer)
 {
   CoglContext *ctx = buffer->context;
 
-  g_return_if_fail (ctx->buffer_map_fallback_in_use);
+  _COGL_RETURN_IF_FAIL (ctx->buffer_map_fallback_in_use);
 
   ctx->buffer_map_fallback_in_use = FALSE;
 
@@ -363,10 +364,10 @@ _cogl_buffer_set_data (CoglBuffer *buffer,
                        size_t offset,
                        const void *data,
                        size_t size,
-                       GError **error)
+                       CoglError **error)
 {
-  g_return_val_if_fail (cogl_is_buffer (buffer), FALSE);
-  g_return_val_if_fail ((offset + size) <= buffer->size, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_buffer (buffer), FALSE);
+  _COGL_RETURN_VAL_IF_FAIL ((offset + size) <= buffer->size, FALSE);
 
   if (G_UNLIKELY (buffer->immutable_ref))
     warn_about_midscene_changes ();
@@ -380,17 +381,18 @@ cogl_buffer_set_data (CoglBuffer *buffer,
                       const void *data,
                       size_t size)
 {
-  GError *ignore_error = NULL;
+  CoglError *ignore_error = NULL;
   gboolean status =
     _cogl_buffer_set_data (buffer, offset, data, size, &ignore_error);
-  g_clear_error (&ignore_error);
+  if (!status)
+    cogl_error_free (ignore_error);
   return status;
 }
 
 CoglBuffer *
 _cogl_buffer_immutable_ref (CoglBuffer *buffer)
 {
-  g_return_val_if_fail (cogl_is_buffer (buffer), NULL);
+  _COGL_RETURN_VAL_IF_FAIL (cogl_is_buffer (buffer), NULL);
 
   buffer->immutable_ref++;
   return buffer;
@@ -399,8 +401,8 @@ _cogl_buffer_immutable_ref (CoglBuffer *buffer)
 void
 _cogl_buffer_immutable_unref (CoglBuffer *buffer)
 {
-  g_return_if_fail (cogl_is_buffer (buffer));
-  g_return_if_fail (buffer->immutable_ref > 0);
+  _COGL_RETURN_IF_FAIL (cogl_is_buffer (buffer));
+  _COGL_RETURN_IF_FAIL (buffer->immutable_ref > 0);
 
   buffer->immutable_ref--;
 }

cogl/cogl/cogl-buffer.h

@@ -40,6 +40,7 @@
 #define __COGL_BUFFER_H__
 
 #include <cogl/cogl-types.h>
+#include <cogl/cogl-error.h>
 
 G_BEGIN_DECLS
 
@@ -257,7 +258,7 @@ cogl_buffer_map (CoglBuffer *buffer,
  * @access: how the mapped buffer will be used by the application
  * @hints: A mask of #CoglBufferMapHint<!-- -->s that tell Cogl how
  *   the data will be modified once mapped.
- * @error: A #GError for catching exceptional errors
+ * @error: A #CoglError for catching exceptional errors
  *
  * Maps a sub-region of the buffer into the application's address space
  * for direct access.
@@ -287,7 +288,7 @@ cogl_buffer_map_range (CoglBuffer *buffer,
                        size_t size,
                        CoglBufferAccess access,
                        CoglBufferMapHint hints,
-                       GError **error);
+                       CoglError **error);
 
 /**
  * cogl_buffer_unmap:

cogl/cogl/cogl-clip-stack.c

@@ -350,7 +350,7 @@ _cogl_clip_stack_pop (CoglClipStack *stack)
 {
   CoglClipStack *new_top;
 
-  g_return_val_if_fail (stack != NULL, NULL);
+  _COGL_RETURN_VAL_IF_FAIL (stack != NULL, NULL);
 
   /* To pop we are moving the top of the stack to the old top's parent
      node. The stack always needs to have a reference to the top entry

cogl/cogl/cogl-color.c

@@ -68,7 +68,7 @@ cogl_color_init_from_4ub (CoglColor *color,
                           uint8_t blue,
                           uint8_t alpha)
 {
-  g_return_if_fail (color != NULL);
+  _COGL_RETURN_IF_FAIL (color != NULL);
 
   color->red   = red;
   color->green = green;
@@ -94,7 +94,7 @@ cogl_color_init_from_4f (CoglColor *color,
                          float blue,
                          float alpha)
 {
-  g_return_if_fail (color != NULL);
+  _COGL_RETURN_IF_FAIL (color != NULL);
 
   color->red   =  (red * 255);
   color->green =  (green * 255);
@@ -117,7 +117,7 @@ void
 cogl_color_init_from_4fv (CoglColor *color,
                           const float *color_array)
 {
-  g_return_if_fail (color != NULL);
+  _COGL_RETURN_IF_FAIL (color != NULL);
 
   color->red   =  (color_array[0] * 255);
   color->green =  (color_array[1] * 255);
@@ -305,8 +305,8 @@ cogl_color_equal (const void *v1, const void *v2)
 {
   const uint32_t *c1 = v1, *c2 = v2;
 
-  g_return_val_if_fail (v1 != NULL, FALSE);
-  g_return_val_if_fail (v2 != NULL, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
+  _COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
 
   /* XXX: We don't compare the padding */
   return *c1 == *c2 ? TRUE : FALSE;

cogl/cogl/cogl-context-private.h

@@ -363,7 +363,7 @@ _cogl_context_get_winsys (CoglContext *context);
  * return FALSE and set @error */
 gboolean
 _cogl_context_update_features (CoglContext *context,
-                               GError **error);
+                               CoglError **error);
 
 /* Obtains the context and returns retval if NULL */
 #define _COGL_GET_CONTEXT(ctxvar, retval) \

cogl/cogl/cogl-context.c

@@ -47,6 +47,7 @@
 #include "cogl1-context.h"
 #include "cogl-gpu-info-private.h"
 #include "cogl-config-private.h"
+#include "cogl-error-private.h"
 #include "cogl-gtype-private.h"
 #include "driver/gl/cogl-pipeline-opengl-private.h"
 #include "driver/gl/cogl-util-gl-private.h"
@@ -122,7 +123,7 @@ _cogl_context_get_winsys (CoglContext *context)
  */
 CoglContext *
 cogl_context_new (CoglDisplay *display,
-                  GError **error)
+                  CoglError **error)
 {
   CoglContext *context;
   uint8_t white_pixel[] = { 0xff, 0xff, 0xff, 0xff };
@@ -527,7 +528,7 @@ _cogl_context_free (CoglContext *context)
 CoglContext *
 _cogl_context_get_default (void)
 {
-  GError *error = NULL;
+  CoglError *error = NULL;
   /* Create if doesn't exist yet */
   if (_cogl_context == NULL)
     {
@@ -536,7 +537,7 @@ _cogl_context_get_default (void)
         {
           g_warning ("Failed to create default context: %s",
                      error->message);
-          g_error_free (error);
+          cogl_error_free (error);
         }
     }
 
@@ -557,7 +558,7 @@ cogl_context_get_renderer (CoglContext *context)
 
 gboolean
 _cogl_context_update_features (CoglContext *context,
-                               GError **error)
+                               CoglError **error)
 {
   return context->driver_vtable->update_features (context, error);
 }