mutter/clutter/clutter/deprecated/clutter-cairo-texture.c

/*
 * Clutter
 *
 * An OpenGL based 'interactive canvas' library.
 *
 * Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
 *              Matthew Allum <mallum@o-hand.com>
 *              Chris Lord <chris@o-hand.com>
 *              Iain Holmes <iain@o-hand.com>
 *              Neil Roberts <neil@linux.intel.com>
 *
 * Copyright (C) 2008, 2009, 2010, 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/>.
 */

/**
 * SECTION:clutter-cairo-texture
 * @short_description: Texture with Cairo integration
 *
 * #ClutterCairoTexture is a #ClutterTexture that displays the contents
 * of a Cairo context. The #ClutterCairoTexture actor will create a
 * Cairo image surface which will then be uploaded to a GL texture when
 * needed.
 *
 * Since #ClutterCairoTexture uses a Cairo image surface
 * internally all the drawing operations will be performed in
 * software and not using hardware acceleration. This can lead to
 * performance degradation if the contents of the texture change
 * frequently.
 *
 * In order to use a #ClutterCairoTexture you should connect to the
 * #ClutterCairoTexture::draw signal; the signal is emitted each time
 * the #ClutterCairoTexture has been told to invalidate its contents,
 * by using clutter_cairo_texture_invalidate_rectangle() or its
 * sister function, clutter_cairo_texture_invalidate().
 *
 * Each callback to the #ClutterCairoTexture::draw signal will receive
 * a #cairo_t context which can be used for drawing; the Cairo context
 * is owned by the #ClutterCairoTexture and should not be destroyed
 * explicitly.
 *
 * #ClutterCairoTexture is available since Clutter 1.0.
 *
 * #ClutterCairoTexture is deprecated since Clutter 1.12. You should
 * use #ClutterCanvas instead.
 */

#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif

#include <math.h>

#include <cairo-gobject.h>

#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-texture.h"
#include "deprecated/clutter-cairo-texture.h"

#include "clutter-cairo-texture.h"

#include "clutter-actor-private.h"
#include "clutter-cairo.h"
#include "clutter-color.h"
#include "clutter-debug.h"
#include "clutter-marshal.h"
#include "clutter-private.h"

struct _ClutterCairoTexturePrivate
{
  cairo_surface_t *cr_surface;

  guint surface_width;
  guint surface_height;

  cairo_t *cr_context;

  guint auto_resize : 1;
};

enum
{
  PROP_0,

  PROP_SURFACE_WIDTH,
  PROP_SURFACE_HEIGHT,
  PROP_AUTO_RESIZE,

  PROP_LAST
};

enum
{
  CREATE_SURFACE,
  DRAW,

  LAST_SIGNAL
};

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

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

G_DEFINE_TYPE_WITH_PRIVATE (ClutterCairoTexture,
                            clutter_cairo_texture,
                            CLUTTER_TYPE_TEXTURE)

#ifdef CLUTTER_ENABLE_DEBUG
#define clutter_warn_if_paint_fail(obj)                 G_STMT_START {  \
  if (CLUTTER_ACTOR_IN_PAINT (obj)) {                                   \
    g_warning ("%s should not be called during the paint sequence "     \
               "of a ClutterCairoTexture as it will likely cause "      \
               "performance issues.", G_STRFUNC);                       \
  }                                                     } G_STMT_END
#else
#define clutter_warn_if_paint_fail(obj)         /* void */
#endif /* CLUTTER_ENABLE_DEBUG */

typedef struct {
  ClutterCairoTexture *texture;

  cairo_rectangle_int_t rect;

  guint is_clipped : 1;
} DrawContext;

static const cairo_user_data_key_t clutter_cairo_texture_context_key;

static DrawContext *
draw_context_create (ClutterCairoTexture *texture)
{
  DrawContext *context = g_slice_new0 (DrawContext);

  context->texture = g_object_ref (texture);

  return context;
}

static void
draw_context_destroy (gpointer data)
{
  if (G_LIKELY (data != NULL))
    {
      DrawContext *context = data;

      g_object_unref (context->texture);

      g_slice_free (DrawContext, data);
    }
}

static void
clutter_cairo_texture_set_property (GObject      *object,
                                    guint         prop_id,
                                    const GValue *value,
                                    GParamSpec   *pspec)
{
  ClutterCairoTexturePrivate *priv;

  priv = CLUTTER_CAIRO_TEXTURE (object)->priv;

  switch (prop_id)
    {
    case PROP_SURFACE_WIDTH:
      /* we perform the resize on notify to coalesce separate
       * surface-width/surface-height property set
       */
      priv->surface_width = g_value_get_uint (value);
      break;

    case PROP_SURFACE_HEIGHT:
      priv->surface_height = g_value_get_uint (value);
      break;

    case PROP_AUTO_RESIZE:
      clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (object),
                                             g_value_get_boolean (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
clutter_cairo_texture_get_property (GObject    *object,
                                    guint       prop_id,
                                    GValue     *value,
                                    GParamSpec *pspec)
{
  ClutterCairoTexturePrivate *priv;

  priv = CLUTTER_CAIRO_TEXTURE (object)->priv;

  switch (prop_id)
    {
    case PROP_SURFACE_WIDTH:
      g_value_set_uint (value, priv->surface_width);
      break;

    case PROP_SURFACE_HEIGHT:
      g_value_set_uint (value, priv->surface_height);
      break;

    case PROP_AUTO_RESIZE:
      g_value_set_boolean (value, priv->auto_resize);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
clutter_cairo_texture_finalize (GObject *object)
{
  ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (object)->priv;

  if (priv->cr_surface != NULL)
    {
      cairo_surface_t *surface = priv->cr_surface;

      priv->cr_surface = NULL;

      cairo_surface_finish (surface);
      cairo_surface_destroy (surface);
    }

  G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->finalize (object);
}

static cairo_surface_t *
get_surface (ClutterCairoTexture *self)
{
  ClutterCairoTexturePrivate *priv = self->priv;

  if (priv->cr_surface == NULL)
    {
      g_signal_emit (self, cairo_signals[CREATE_SURFACE], 0,
                     priv->surface_width,
                     priv->surface_height,
                     &priv->cr_surface);
    }

  return priv->cr_surface;
}

static void
clutter_cairo_texture_context_destroy (void *data)
{
  DrawContext *ctxt = data;
  ClutterCairoTexture *cairo = ctxt->texture;
  ClutterCairoTexturePrivate *priv = cairo->priv;
  guint8 *cairo_data;
  gint cairo_width, cairo_height, cairo_stride;
  gint surface_width, surface_height;
  CoglHandle cogl_texture;

  if (priv->cr_surface == NULL)
    {
      /* the surface went away before we could use it */
      draw_context_destroy (ctxt);
      return;
    }

  /* for any other surface type, we presume that there exists a native
   * communication between Cairo and GL that is triggered by cairo_destroy().
   *
   * for instance, cairo-drm will flush the outstanding modifications to the
   * surface upon context destruction and so the texture is automatically
   * updated.
   */
  if (cairo_surface_get_type (priv->cr_surface) != CAIRO_SURFACE_TYPE_IMAGE)
    goto out;

  surface_width  = cairo_image_surface_get_width (priv->cr_surface);
  surface_height = cairo_image_surface_get_height (priv->cr_surface);

  cairo_width  = MIN (ctxt->rect.width, surface_width);
  cairo_height = MIN (ctxt->rect.height, surface_height);

  cogl_texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (cairo));
  if (cairo_width == 0 ||
      cairo_height == 0 ||
      cogl_texture == COGL_INVALID_HANDLE)
    {
      draw_context_destroy (ctxt);
      return;
    }

  cairo_stride = cairo_image_surface_get_stride (priv->cr_surface);
  cairo_data = cairo_image_surface_get_data (priv->cr_surface);
  cairo_data += cairo_stride * ctxt->rect.y;
  cairo_data += 4 * ctxt->rect.x;

  cogl_texture_set_region (cogl_texture,
                           0, 0,
                           ctxt->rect.x, ctxt->rect.y,
                           cairo_width, cairo_height,
                           cairo_width, cairo_height,
                           CLUTTER_CAIRO_FORMAT_ARGB32,
                           cairo_stride,
                           cairo_data);

out:
  draw_context_destroy (ctxt);
  clutter_actor_queue_redraw (CLUTTER_ACTOR (cairo));
}

static inline void
clutter_cairo_texture_emit_draw (ClutterCairoTexture        *self,
                                 DrawContext *ctxt)
{
  gboolean result;
  cairo_t *cr;

  /* 0x0 surfaces don't need a ::draw */
  if (self->priv->surface_width == 0 ||
      self->priv->surface_height == 0)
    return;

  /* if the size is !0 then we must have a surface */
  g_assert (self->priv->cr_surface != NULL);

  cr = cairo_create (self->priv->cr_surface);

  if (ctxt->is_clipped)
    {
      cairo_rectangle (cr,
                       ctxt->rect.x,
                       ctxt->rect.y,
                       ctxt->rect.width,
                       ctxt->rect.height);
      cairo_clip (cr);
    }

  /* store the cairo_t as a guard */
  self->priv->cr_context = cr;

  g_signal_emit (self, cairo_signals[DRAW], 0, cr, &result);

  self->priv->cr_context = NULL;

  clutter_cairo_texture_context_destroy (ctxt);

  cairo_destroy (cr);
}

static inline void
clutter_cairo_texture_surface_resize_internal (ClutterCairoTexture *cairo)
{
  ClutterCairoTexturePrivate *priv = cairo->priv;

  if (priv->cr_surface != NULL)
    {
      cairo_surface_t *surface = priv->cr_surface;

      /* if the surface is an image one, and the size is already the
       * same, then we don't need to do anything
       */
      if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE)
        {
          gint surface_width = cairo_image_surface_get_width (surface);
          gint surface_height = cairo_image_surface_get_height (surface);

          if (priv->surface_width == surface_width &&
              priv->surface_height == surface_height)
            return;
        }

      cairo_surface_finish (surface);
      cairo_surface_destroy (surface);
      priv->cr_surface = NULL;
    }

  if (priv->surface_width == 0 ||
      priv->surface_height == 0)
    return;

  g_signal_emit (cairo, cairo_signals[CREATE_SURFACE], 0,
                 priv->surface_width,
                 priv->surface_height,
                 &priv->cr_surface);
}

static void
clutter_cairo_texture_notify (GObject    *object,
                              GParamSpec *pspec)
{
  /* When the surface width or height changes then resize the cairo
     surface. This is done here instead of directly in set_property so
     that if both the width and height properties are set using a
     single call to g_object_set then the surface will only be resized
     once because the notifications will be frozen in between */

  if (obj_props[PROP_SURFACE_WIDTH]->name == pspec->name ||
      obj_props[PROP_SURFACE_HEIGHT]->name == pspec->name)
    {
      ClutterCairoTexture *cairo = CLUTTER_CAIRO_TEXTURE (object);

      clutter_cairo_texture_surface_resize_internal (cairo);
    }

  if (G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->notify)
    G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->notify (object, pspec);
}

static void
clutter_cairo_texture_get_preferred_width (ClutterActor *actor,
                                           gfloat        for_height,
                                           gfloat       *min_width,
                                           gfloat       *natural_width)
{
  ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;

  if (min_width)
    *min_width = 0;

  if (natural_width)
    *natural_width = (gfloat) priv->surface_width;
}

static void
clutter_cairo_texture_get_preferred_height (ClutterActor *actor,
                                            gfloat        for_width,
                                            gfloat       *min_height,
                                            gfloat       *natural_height)
{
  ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;

  if (min_height)
    *min_height = 0;

  if (natural_height)
    *natural_height = (gfloat) priv->surface_height;
}

static void
clutter_cairo_texture_allocate (ClutterActor           *self,
                                const ClutterActorBox  *allocation,
                                ClutterAllocationFlags  flags)
{
  ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (self)->priv;
  ClutterActorClass *parent_class;

  parent_class = CLUTTER_ACTOR_CLASS (clutter_cairo_texture_parent_class);
  parent_class->allocate (self, allocation, flags);

  if (priv->auto_resize)
    {
      ClutterCairoTexture *texture = CLUTTER_CAIRO_TEXTURE (self);
      gfloat width, height;

      clutter_actor_box_get_size (allocation, &width, &height);

      priv->surface_width = ceilf (width);
      priv->surface_height = ceilf (height);

      clutter_cairo_texture_surface_resize_internal (texture);
      clutter_cairo_texture_invalidate (texture);
    }
}

static gboolean
clutter_cairo_texture_get_paint_volume (ClutterActor       *self,
                                        ClutterPaintVolume *volume)
{
  return _clutter_actor_set_default_paint_volume (self,
                                                  CLUTTER_TYPE_CAIRO_TEXTURE,
                                                  volume);
}

static cairo_surface_t *
clutter_cairo_texture_create_surface (ClutterCairoTexture *self,
                                      guint                width,
                                      guint                height)
{
  cairo_surface_t *surface;
  guint cairo_stride;
  guint8 *cairo_data;
  CoglHandle cogl_texture;

  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
                                        width,
                                        height);

  cairo_stride = cairo_image_surface_get_stride (surface);
  cairo_data = cairo_image_surface_get_data (surface);

  /* create a backing Cogl texture */
  cogl_texture = cogl_texture_new_from_data (width, height,
                                             COGL_TEXTURE_NONE,
                                             CLUTTER_CAIRO_FORMAT_ARGB32,
                                             COGL_PIXEL_FORMAT_ANY,
                                             cairo_stride,
                                             cairo_data);
  clutter_texture_set_cogl_texture (CLUTTER_TEXTURE (self), cogl_texture);
  cogl_handle_unref (cogl_texture);

  return surface;
}

static gboolean
create_surface_accum (GSignalInvocationHint *ihint,
                      GValue                *return_accu,
                      const GValue          *handler_return,
                      gpointer               data)
{
  g_value_copy (handler_return, return_accu);

  /* stop on the first non-NULL return value */
  return g_value_get_boxed (handler_return) == NULL;
}

static void
clutter_cairo_texture_draw_marshaller (GClosure     *closure,
                                       GValue       *return_value,
                                       guint         n_param_values,
                                       const GValue *param_values,
                                       gpointer      invocation_hint,
                                       gpointer      marshal_data)
{
  cairo_t *cr = g_value_get_boxed (&param_values[1]);

  cairo_save (cr);

  _clutter_marshal_BOOLEAN__BOXED (closure,
                                   return_value,
                                   n_param_values,
                                   param_values,
                                   invocation_hint,
                                   marshal_data);

  cairo_restore (cr);
}

static void
clutter_cairo_texture_class_init (ClutterCairoTextureClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);

  gobject_class->finalize     = clutter_cairo_texture_finalize;
  gobject_class->set_property = clutter_cairo_texture_set_property;
  gobject_class->get_property = clutter_cairo_texture_get_property;
  gobject_class->notify       = clutter_cairo_texture_notify;

  actor_class->get_paint_volume =
    clutter_cairo_texture_get_paint_volume;
  actor_class->get_preferred_width =
    clutter_cairo_texture_get_preferred_width;
  actor_class->get_preferred_height =
    clutter_cairo_texture_get_preferred_height;
  actor_class->allocate =
    clutter_cairo_texture_allocate;

  klass->create_surface = clutter_cairo_texture_create_surface;

  /**
   * ClutterCairoTexture:surface-width:
   *
   * The width of the Cairo surface used by the #ClutterCairoTexture
   * actor, in pixels.
   *
   * Since: 1.0
   *
   * Deprecated: 1.12
   */
  obj_props[PROP_SURFACE_WIDTH] =
    g_param_spec_uint ("surface-width",
                       P_("Surface Width"),
                       P_("The width of the Cairo surface"),
                       0, G_MAXUINT,
                       0,
                       CLUTTER_PARAM_READWRITE |
                       G_PARAM_DEPRECATED);
  /**
   * ClutterCairoTexture:surface-height:
   *
   * The height of the Cairo surface used by the #ClutterCairoTexture
   * actor, in pixels.
   *
   * Since: 1.0
   *
   * Deprecated: 1.12
   */
  obj_props[PROP_SURFACE_HEIGHT] =
    g_param_spec_uint ("surface-height",
                       P_("Surface Height"),
                       P_("The height of the Cairo surface"),
                       0, G_MAXUINT,
                       0,
                       CLUTTER_PARAM_READWRITE |
                       G_PARAM_DEPRECATED);

  /**
   * ClutterCairoTexture:auto-resize:
   *
   * Controls whether the #ClutterCairoTexture should automatically
   * resize the Cairo surface whenever the actor's allocation changes.
   * If :auto-resize is set to %TRUE the surface contents will also
   * be invalidated automatically.
   *
   * Since: 1.8
   *
   * Deprecated: 1.12
   */
  obj_props[PROP_AUTO_RESIZE] =
    g_param_spec_boolean ("auto-resize",
                          P_("Auto Resize"),
                          P_("Whether the surface should match the allocation"),
                          FALSE,
                          CLUTTER_PARAM_READWRITE |
                          G_PARAM_DEPRECATED);

  g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);

  /**
   * ClutterCairoTexture::create-surface:
   * @texture: the #ClutterCairoTexture that emitted the signal
   * @width: the width of the surface to create
   * @height: the height of the surface to create
   *
   * The ::create-surface signal is emitted when a #ClutterCairoTexture
   * news its surface (re)created, which happens either when the Cairo
   * context is created with clutter_cairo_texture_create() or
   * clutter_cairo_texture_create_region(), or when the surface is resized
   * through clutter_cairo_texture_set_surface_size().
   *
   * The first signal handler that returns a non-%NULL, valid surface will
   * stop any further signal emission, and the returned surface will be
   * the one used.
   *
   * Return value: the newly created #cairo_surface_t for the texture
   *
   * Since: 1.6
   *
   * Deprecated: 1.12
   */
  cairo_signals[CREATE_SURFACE] =
    g_signal_new (I_("create-surface"),
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
                  G_STRUCT_OFFSET (ClutterCairoTextureClass, create_surface),
                  create_surface_accum, NULL,
                  _clutter_marshal_BOXED__UINT_UINT,
                  CAIRO_GOBJECT_TYPE_SURFACE, 2,
                  G_TYPE_UINT,
                  G_TYPE_UINT);

  /**
   * ClutterCairoTexture::draw:
   * @texture: the #ClutterCairoTexture that emitted the signal
   * @cr: the Cairo context to use to draw
   *
   * The ::draw signal is emitted each time a #ClutterCairoTexture has
   * been invalidated.
   *
   * The passed Cairo context passed will be clipped to the invalidated
   * area.
   *
   * It is safe to connect multiple callbacks to this signals; the state
   * of the Cairo context passed to each callback is automatically saved
   * and restored, so it's not necessary to call cairo_save() and
   * cairo_restore().
   *
   * Return value: %TRUE if the signal emission should stop, and %FALSE
   *   to continue
   *
   * Since: 1.8
   *
   * Deprecated: 1.12
   */
  cairo_signals[DRAW] =
    g_signal_new (I_("draw"),
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
                  G_STRUCT_OFFSET (ClutterCairoTextureClass, draw),
                  _clutter_boolean_handled_accumulator, NULL,
                  clutter_cairo_texture_draw_marshaller,
                  G_TYPE_BOOLEAN, 1,
                  CAIRO_GOBJECT_TYPE_CONTEXT);
}

static void
clutter_cairo_texture_init (ClutterCairoTexture *self)
{
  self->priv = clutter_cairo_texture_get_instance_private (self);

  /* FIXME - we are hardcoding the format; it would be good to have
   * a :surface-format construct-only property for creating
   * textures with a different format and have the cairo surface
   * match that format
   *
   * priv->format = CAIRO_FORMAT_ARGB32;
   */

  /* the Cairo surface is responsible for driving the size of
   * the texture; if we let sync_size to its default of TRUE,
   * the Texture will try to queue a relayout every time we
   * change the size of the Cairo surface - which is not what
   * we want
   */
  clutter_texture_set_sync_size (CLUTTER_TEXTURE (self), FALSE);
}

/**
 * clutter_cairo_texture_new:
 * @width: the width of the surface
 * @height: the height of the surface
 *
 * Creates a new #ClutterCairoTexture actor, with a surface of @width by
 * @height pixels.
 *
 * Return value: the newly created #ClutterCairoTexture actor
 *
 * Since: 1.0
 *
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
ClutterActor*
clutter_cairo_texture_new (guint width,
                           guint height)
{
  return g_object_new (CLUTTER_TYPE_CAIRO_TEXTURE,
                       "surface-width", width,
                       "surface-height", height,
                       NULL);
}

static void
intersect_rectangles (cairo_rectangle_int_t *a,
		      cairo_rectangle_int_t *b,
		      cairo_rectangle_int_t *inter)
{
  gint dest_x, dest_y;
  gint dest_width, dest_height;

  dest_x = MAX (a->x, b->x);
  dest_y = MAX (a->y, b->y);
  dest_width = MIN (a->x + a->width, b->x + b->width) - dest_x;
  dest_height = MIN (a->y + a->height, b->y + b->height) - dest_y;

  if (dest_width > 0 && dest_height > 0)
    {
      inter->x = dest_x;
      inter->y = dest_y;
      inter->width = dest_width;
      inter->height = dest_height;
    }
  else
    {
      inter->x = 0;
      inter->y = 0;
      inter->width = 0;
      inter->height = 0;
    }
}

static cairo_t *
clutter_cairo_texture_create_region_internal (ClutterCairoTexture *self,
                                              gint                 x_offset,
                                              gint                 y_offset,
                                              gint                 width,
                                              gint                 height)
{
  ClutterCairoTexturePrivate *priv = self->priv;
  cairo_rectangle_int_t region, area, inter;
  cairo_surface_t *surface;
  DrawContext *ctxt;
  cairo_t *cr;

  if (width < 0)
    width = priv->surface_width;

  if (height < 0)
    height = priv->surface_height;

  if (width == 0 || height == 0)
    {
      g_warning ("Unable to create a context for an image surface of "
                 "width %d and height %d. Set the surface size to be "
                 "at least 1 pixel by 1 pixel.",
                 width, height);
      return NULL;
    }

  surface = get_surface (self);

  ctxt = draw_context_create (self);

  region.x = x_offset;
  region.y = y_offset;
  region.width = width;
  region.height = height;

  area.x = 0;
  area.y = 0;
  area.width = priv->surface_width;
  area.height = priv->surface_height;

  /* Limit the region to the visible rectangle */
  intersect_rectangles (&area, &region, &inter);

  ctxt->rect = inter;

  cr = cairo_create (surface);
  cairo_set_user_data (cr, &clutter_cairo_texture_context_key,
		       ctxt,
                       clutter_cairo_texture_context_destroy);

  return cr;
}

/**
 * clutter_cairo_texture_create_region:
 * @self: a #ClutterCairoTexture
 * @x_offset: offset of the region on the X axis
 * @y_offset: offset of the region on the Y axis
 * @width: width of the region, or -1 for the full surface width
 * @height: height of the region, or -1 for the full surface height
 *
 * Creates a new Cairo context that will updat the region defined
 * by @x_offset, @y_offset, @width and @height.
 *
 * Do not call this function within the paint virtual
 * function or from a callback to the #ClutterActor::paint
 * signal.
 *
 * Return value: a newly created Cairo context. Use cairo_destroy()
 *   to upload the contents of the context when done drawing
 *
 * Since: 1.0
 *
 * Deprecated: 1.8: Use the #ClutterCairoTexture::draw signal and
 *   clutter_cairo_texture_invalidate_rectangle() to obtain a
 *   clipped Cairo context for 2D drawing.
 */
cairo_t *
clutter_cairo_texture_create_region (ClutterCairoTexture *self,
                                     gint                 x_offset,
                                     gint                 y_offset,
                                     gint                 width,
                                     gint                 height)
{
  g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), NULL);

  clutter_warn_if_paint_fail (self);

  return clutter_cairo_texture_create_region_internal (self,
                                                       x_offset, y_offset,
                                                       width, height);
}

/**
 * clutter_cairo_texture_invalidate_rectangle:
 * @self: a #ClutterCairoTexture
 * @rect: (allow-none): a rectangle with the area to invalida,
 *   or %NULL to perform an unbounded invalidation
 *
 * Invalidates a rectangular region of a #ClutterCairoTexture.
 *
 * The invalidation will cause the #ClutterCairoTexture::draw signal
 * to be emitted.
 *
 * See also: clutter_cairo_texture_invalidate()
 *
 * Since: 1.8
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_invalidate_rectangle (ClutterCairoTexture   *self,
                                            cairo_rectangle_int_t *rect)
{
  DrawContext *ctxt = NULL;

  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  if (self->priv->cr_context != NULL)
    {
      g_warning ("It is not possible to invalidate a Cairo texture"
                 "while drawing into it.");
      return;
    }

  ctxt = draw_context_create (self);

  if (rect != NULL)
    {
      cairo_rectangle_int_t area, inter;

      area.x = 0;
      area.y = 0;
      area.width = self->priv->surface_width;
      area.height = self->priv->surface_height;

      /* Limit the region to the visible rectangle */
      intersect_rectangles (&area, rect, &inter);

      ctxt->is_clipped = TRUE;
      ctxt->rect = inter;
    }
  else
    {
      ctxt->is_clipped = FALSE;
      ctxt->rect.x = ctxt->rect.y = 0;
      ctxt->rect.width = self->priv->surface_width;
      ctxt->rect.height = self->priv->surface_height;
    }

  /* XXX - it might be good to move the emission inside the paint cycle
   * using a repaint function, to avoid blocking inside this function
   */
  clutter_cairo_texture_emit_draw (self, ctxt);
}

/**
 * clutter_cairo_texture_invalidate:
 * @self: a #ClutterCairoTexture
 *
 * Invalidates the whole surface of a #ClutterCairoTexture.
 *
 * This function will cause the #ClutterCairoTexture::draw signal
 * to be emitted.
 *
 * See also: clutter_cairo_texture_invalidate_rectangle()
 *
 * Since: 1.8
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_invalidate (ClutterCairoTexture *self)
{
  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  clutter_cairo_texture_invalidate_rectangle (self, NULL);
}

/**
 * clutter_cairo_texture_create:
 * @self: a #ClutterCairoTexture
 *
 * Creates a new Cairo context for the @cairo texture. It is
 * similar to using clutter_cairo_texture_create_region() with @x_offset
 * and @y_offset of 0, @width equal to the @cairo texture surface width
 * and @height equal to the @cairo texture surface height.
 *
 * Do not call this function within the paint virtual
 * function or from a callback to the #ClutterActor::paint
 * signal.
 *
 * Return value: a newly created Cairo context. Use cairo_destroy()
 *   to upload the contents of the context when done drawing
 *
 * Since: 1.0
 *
 * Deprecated: 1.8: Use the #ClutterCairoTexture::draw signal and
 *   the clutter_cairo_texture_invalidate() function to obtain a
 *   Cairo context for 2D drawing.
 */
cairo_t *
clutter_cairo_texture_create (ClutterCairoTexture *self)
{
  g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), NULL);

  clutter_warn_if_paint_fail (self);

  return clutter_cairo_texture_create_region_internal (self, 0, 0, -1, -1);
}

/**
 * clutter_cairo_texture_set_surface_size:
 * @self: a #ClutterCairoTexture
 * @width: the new width of the surface
 * @height: the new height of the surface
 *
 * Resizes the Cairo surface used by @self to @width and @height.
 *
 * This function will not invalidate the contents of the Cairo
 * texture: you will have to explicitly call either
 * clutter_cairo_texture_invalidate_rectangle() or
 * clutter_cairo_texture_invalidate().
 *
 * Since: 1.0
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_set_surface_size (ClutterCairoTexture *self,
                                        guint                width,
                                        guint                height)
{
  ClutterCairoTexturePrivate *priv;

  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  priv = self->priv;

  if (width == priv->surface_width &&
      height == priv->surface_height)
    return;

  g_object_freeze_notify (G_OBJECT (self));

  if (priv->surface_width != width)
    {
      priv->surface_width = width;
      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_WIDTH]);
    }

  if (priv->surface_height != height)
    {
      priv->surface_height = height;
      g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_HEIGHT]);
    }

  clutter_cairo_texture_surface_resize_internal (self);

  g_object_thaw_notify (G_OBJECT (self));
}

/**
 * clutter_cairo_texture_get_surface_size:
 * @self: a #ClutterCairoTexture
 * @width: (out): return location for the surface width, or %NULL
 * @height: (out): return location for the surface height, or %NULL
 *
 * Retrieves the surface width and height for @self.
 *
 * Since: 1.0
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_get_surface_size (ClutterCairoTexture *self,
                                        guint               *width,
                                        guint               *height)
{
  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  if (width)
    *width = self->priv->surface_width;

  if (height)
    *height = self->priv->surface_height;
}

/**
 * clutter_cairo_texture_clear:
 * @self: a #ClutterCairoTexture
 *
 * Clears @self's internal drawing surface, so that the next upload
 * will replace the previous contents of the #ClutterCairoTexture
 * rather than adding to it.
 *
 * Calling this function from within a #ClutterCairoTexture::draw
 * signal handler will clear the invalidated area.
 *
 * Since: 1.0
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_clear (ClutterCairoTexture *self)
{
  ClutterCairoTexturePrivate *priv;
  cairo_t *cr;

  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  priv = self->priv;

  /* if we got called outside of a ::draw signal handler
   * then we clear the whole surface by creating a temporary
   * cairo_t; otherwise, we clear the current cairo_t, which
   * will take into account the clip region.
   */
  if (priv->cr_context == NULL)
    {
      cairo_surface_t *surface;

      surface = get_surface (self);

      cr = cairo_create (surface);
    }
  else
    cr = priv->cr_context;

  cairo_save (cr);

  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
  cairo_paint (cr);

  cairo_restore (cr);

  if (priv->cr_context == NULL)
    cairo_destroy (cr);
}

/**
 * clutter_cairo_texture_set_auto_resize:
 * @self: a #ClutterCairoTexture
 * @value: %TRUE if the #ClutterCairoTexture should bind the surface
 *   size to the allocation
 *
 * Sets whether the #ClutterCairoTexture should ensure that the
 * backing Cairo surface used matches the allocation assigned to
 * the actor. If the allocation changes, the contents of the
 * #ClutterCairoTexture will also be invalidated automatically.
 *
 * Since: 1.8
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
void
clutter_cairo_texture_set_auto_resize (ClutterCairoTexture *self,
                                       gboolean             value)
{
  ClutterCairoTexturePrivate *priv;

  g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));

  value = !!value;

  priv = self->priv;

  if (priv->auto_resize == value)
    return;

  priv->auto_resize = value;

  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));

  g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_AUTO_RESIZE]);
}

/**
 * clutter_cairo_texture_get_auto_resize:
 * @self: a #ClutterCairoTexture
 *
 * Retrieves the value set using clutter_cairo_texture_set_auto_resize().
 *
 * Return value: %TRUE if the #ClutterCairoTexture should track the
 *   allocation, and %FALSE otherwise
 *
 * Since: 1.8
 * Deprecated: 1.12: Use #ClutterCanvas instead
 */
gboolean
clutter_cairo_texture_get_auto_resize (ClutterCairoTexture *self)
{
  g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), FALSE);

  return self->priv->auto_resize;
}