WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo.c

 /* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
 /* cairo - a vector graphics library with display and print output
+ *
  * Copyright © 2002 University of Southern California
  * Copyright © 2005 Red Hat, Inc.
+ * Copyright © 2011 Intel Corporation
+ *
  * This library is free software; you can redistribute it and/or
  * modify it either under the terms of the GNU Lesser General Public
  * License version 2.1 as published by the Free Software Foundation
  * (the "LGPL") or, at your option, under the terms of the Mozilla
  * The Initial Developer of the Original Code is University of Southern
  * California.
+ *
  * Contributor(s):
  *	Carl D. Worth
+ *	Chris Wilson
  */
 #include "cairoint.h"
 #include "cairo-private.h"
-#include "cairo-arc-private.h"
+#include "cairo-backend-private.h"
+#include "cairo-error-private.h"
+#include "cairo-path-private.h"
+#include "cairo-pattern-private.h"
+#include "cairo-surface-private.h"
+#include "cairo-surface-backend-private.h"
 #include "cairo-error-private.h"
-#include "cairo-path-private.h"
+#include
 /**
  * and drawing options for the #cairo_t, create shapes with
  * functions like cairo_move_to() and cairo_line_to(), and then
  * draw shapes with cairo_stroke() or cairo_fill().
+ *
  * #cairo_t's can be pushed to a stack via cairo_save().
- * They may then safely be changed, without loosing the current state.
+ * They may then safely be changed, without losing the current state.
  * Use cairo_restore() to restore to the saved state.
- */
+ **/
 /**
  * SECTION:cairo-text
  * @Title: text
  * the user to convert text to a set of glyph indexes and positions.  This
  * is a very hard problem and is best handled by external libraries, like
  * the pangocairo that is part of the Pango text layout and rendering library.
  * Pango is available from
  * url="http://www.pango.org/">http://www.pango.org/.
- */
+ **/
 /**
  * SECTION:cairo-transforms
  * @Title: Transformations
  * The current transformation matrix, ctm, is a
  * two-dimensional affine transformation that maps all coordinates and other
  * drawing instruments from the user space into the
  * surface's canonical coordinate system, also known as the device
  * space.
- */
-#define CAIRO_TOLERANCE_MINIMUM	_cairo_fixed_to_double(1)
-#if !defined(INFINITY)
-#define INFINITY HUGE_VAL
-#endif
-static const cairo_t _cairo_nil = {
-  CAIRO_REFERENCE_COUNT_INVALID,	/* ref_count */
-  CAIRO_STATUS_NO_MEMORY,	/* status */
-  { 0, 0, 0, NULL },		/* user_data */
-  NULL,				/* gstate */
-  {{ 0 }, { 0 }},		/* gstate_tail */
-  NULL,				/* gstate_freelist */
-  {{				/* path */
-    { 0, 0 },			/* last_move_point */
-    { 0, 0 },			/* current point */
-    FALSE,			/* has_current_point */
-    FALSE,			/* has_last_move_point */
-    FALSE,			/* has_curve_to */
-    FALSE,			/* is_box */
-    FALSE,			/* maybe_fill_region */
-    TRUE,			/* is_empty_fill */
-    { {0, 0}, {0, 0}},		/* extents */
-    {{{NULL,NULL}}}		/* link */
-  }}
-};
-static const cairo_t _cairo_nil__null_pointer = {
-  CAIRO_REFERENCE_COUNT_INVALID,	/* ref_count */
-  CAIRO_STATUS_NULL_POINTER,	/* status */
-  { 0, 0, 0, NULL },		/* user_data */
-  NULL,				/* gstate */
-  {{ 0 }, { 0 }},		/* gstate_tail */
-  NULL,				/* gstate_freelist */
-  {{				/* path */
-    { 0, 0 },			/* last_move_point */
-    { 0, 0 },			/* current point */
-    FALSE,			/* has_current_point */
-    FALSE,			/* has_last_move_point */
-    FALSE,			/* has_curve_to */
-    FALSE,			/* is_box */
-    FALSE,			/* maybe_fill_region */
-    TRUE,			/* is_empty_fill */
-    { {0, 0}, {0, 0}},		/* extents */
-    {{{NULL,NULL}}}		/* link */
-  }}
-};
-#include
-/**
- * _cairo_error:
- * @status: a status value indicating an error, (eg. not
- * %CAIRO_STATUS_SUCCESS)
- *
- * Checks that status is an error status, but does nothing else.
- *
- * All assignments of an error status to any user-visible object
- * within the cairo application should result in a call to
- * _cairo_error().
- *
- * The purpose of this function is to allow the user to set a
- * breakpoint in _cairo_error() to generate a stack trace for when the
- * user causes cairo to detect an error.
- *
- * Return value: the error status.
  **/
-cairo_status_t
-_cairo_error (cairo_status_t status)
-{
-    CAIRO_ENSURE_UNIQUE;
-    assert (_cairo_status_is_error (status));
+#define DEFINE_NIL_CONTEXT(status)					\
+    {									\
+	CAIRO_REFERENCE_COUNT_INVALID,	/* ref_count */			\
+	status,				/* status */			\
+	{ 0, 0, 0, NULL },		/* user_data */			\
+	NULL								\
+    }
+static const cairo_t _cairo_nil[] = {
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_NO_MEMORY),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_RESTORE),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_POP_GROUP),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_NO_CURRENT_POINT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_MATRIX),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_STATUS),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_NULL_POINTER),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_STRING),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_PATH_DATA),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_READ_ERROR),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_WRITE_ERROR),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_SURFACE_FINISHED),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_SURFACE_TYPE_MISMATCH),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_PATTERN_TYPE_MISMATCH),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_CONTENT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_FORMAT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_VISUAL),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_FILE_NOT_FOUND),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_DASH),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_DSC_COMMENT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_INDEX),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_CLIP_NOT_REPRESENTABLE),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_TEMP_FILE_ERROR),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_STRIDE),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_FONT_TYPE_MISMATCH),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_USER_FONT_IMMUTABLE),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_USER_FONT_ERROR),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_NEGATIVE_COUNT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_CLUSTERS),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_SLANT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_WEIGHT),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_SIZE),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_DEVICE_TYPE_MISMATCH),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_DEVICE_ERROR),
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_INVALID_MESH_CONSTRUCTION),
-    return status;
+    DEFINE_NIL_CONTEXT (CAIRO_STATUS_DEVICE_FINISHED)
+};
 COMPILE_TIME_ASSERT (ARRAY_LENGTH (_cairo_nil) == CAIRO_STATUS_LAST_STATUS - 1);
 /**
  * _cairo_set_error:
     /* Don't overwrite an existing error. This preserves the first
      * error, which is the most significant. */
     _cairo_status_set_error (&cr->status, _cairo_error (status));
+}
-/* We keep a small stash of contexts to reduce malloc pressure */
-#define CAIRO_STASH_SIZE 4
-#if CAIRO_NO_MUTEX
-static struct {
-    cairo_t pool[CAIRO_STASH_SIZE];
-    int occupied;
-} _context_stash;
-static cairo_t *
-_context_get (void)
-{
-    int avail;
-    avail = ffs (~_context_stash.occupied) - 1;
-    if (avail >= CAIRO_STASH_SIZE)
-	return malloc (sizeof (cairo_t));
-    _context_stash.occupied |= 1 << avail;
-    return &_context_stash.pool[avail];
-}
-static void
-_context_put (cairo_t *cr)
-{
-    if (cr < &_context_stash.pool[0] ||
-	cr >= &_context_stash.pool[CAIRO_STASH_SIZE])
-    {
-	free (cr);
-	return;
-    }
-    _context_stash.occupied &= ~(1 << (cr - &_context_stash.pool[0]));
-}
-#elif HAS_ATOMIC_OPS
-static struct {
-    cairo_t pool[CAIRO_STASH_SIZE];
-    cairo_atomic_int_t occupied;
-} _context_stash;
-static cairo_t *
-_context_get (void)
-{
-    cairo_atomic_int_t avail, old, new;
-    do {
-	old = _cairo_atomic_int_get (&_context_stash.occupied);
-	avail = ffs (~old) - 1;
-	if (avail >= CAIRO_STASH_SIZE)
-	    return malloc (sizeof (cairo_t));
-	new = old | (1 << avail);
-    } while (! _cairo_atomic_int_cmpxchg (&_context_stash.occupied, old, new));
-    return &_context_stash.pool[avail];
-}
-static void
-_context_put (cairo_t *cr)
-{
-    cairo_atomic_int_t old, new, avail;
-    if (cr < &_context_stash.pool[0] ||
-	cr >= &_context_stash.pool[CAIRO_STASH_SIZE])
-    {
-	free (cr);
-	return;
-    }
-    avail = ~(1 << (cr - &_context_stash.pool[0]));
-    do {
-	old = _cairo_atomic_int_get (&_context_stash.occupied);
-	new = old & avail;
-    } while (! _cairo_atomic_int_cmpxchg (&_context_stash.occupied, old, new));
-}
-#else
-#define _context_get() malloc (sizeof (cairo_t))
-#define _context_put(cr) free (cr)
-#endif
-/* XXX This should disappear in favour of a common pool of error objects. */
-static cairo_t *_cairo_nil__objects[CAIRO_STATUS_LAST_STATUS + 1];
-static cairo_t *
+cairo_t *
 _cairo_create_in_error (cairo_status_t status)
+{
     cairo_t *cr;
-    assert (status != CAIRO_STATUS_SUCCESS);
-    /* special case OOM in order to avoid another allocation */
-    switch ((int) status) {
-    case CAIRO_STATUS_NO_MEMORY:
-	return (cairo_t *) &_cairo_nil;
-    case CAIRO_STATUS_NULL_POINTER:
-	return (cairo_t *) &_cairo_nil__null_pointer;
-    }
-    CAIRO_MUTEX_LOCK (_cairo_error_mutex);
-    cr = _cairo_nil__objects[status];
-    if (cr == NULL) {
-	cr = malloc (sizeof (cairo_t));
-	if (unlikely (cr == NULL)) {
-	    CAIRO_MUTEX_UNLOCK (_cairo_error_mutex);
-	    _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
-	    return (cairo_t *) &_cairo_nil;
-	}
+    assert (status != CAIRO_STATUS_SUCCESS);
-	*cr = _cairo_nil;
-	cr->status = status;
 	_cairo_nil__objects[status] = cr;
     cr = (cairo_t *) &_cairo_nil[status - CAIRO_STATUS_NO_MEMORY];
-    CAIRO_MUTEX_UNLOCK (_cairo_error_mutex);
-    return cr;
-}
-void
-_cairo_reset_static_data (void)
-{
-    int status;
-    CAIRO_MUTEX_LOCK (_cairo_error_mutex);
-    for (status = CAIRO_STATUS_SUCCESS;
-	 status <= CAIRO_STATUS_LAST_STATUS;
-	 status++)
-    {
-	if (_cairo_nil__objects[status] != NULL) {
-	    free (_cairo_nil__objects[status]);
-	    _cairo_nil__objects[status] = NULL;
     assert (status == cr->status);
-    CAIRO_MUTEX_UNLOCK (_cairo_error_mutex);
+    return cr;
+}
 /**
  * cairo_create:
  * @target: target surface for the context
  *
+ * Creates a new #cairo_t with all graphics state parameters set to
- * Creates a new #cairo_t with all graphics state parameters set to
+ * default values and with @target as a target surface. The target
- * default values and with @target as a target surface. The target
+ * surface should be constructed with a backend-specific function such
- * surface should be constructed with a backend-specific function such
+ * as cairo_image_surface_create() (or any other
- * as cairo_image_surface_create() (or any other
+ * cairo_backend_surface_create()
- * cairo_backend_surface_create() variant).
+ * variant).
+ *
  * This function references @target, so you can immediately
  * call cairo_surface_destroy() on it if you don't need to
  * maintain a separate reference to it.
+ *
  * Return value: a newly allocated #cairo_t with a reference
+ *  count of 1. The initial reference count should be released
+ *  with cairo_destroy() when you are done using the #cairo_t.
+ *  This function never returns %NULL. If memory cannot be
- *  count of 1. The initial reference count should be released
+ *  allocated, a special #cairo_t object will be returned on
+ *  which cairo_status() returns %CAIRO_STATUS_NO_MEMORY. If
- *  with cairo_destroy() when you are done using the #cairo_t.
+ *  you attempt to target a surface which does not support
- *  This function never returns %NULL. If memory cannot be
+ *  writing (such as #cairo_mime_surface_t) then a
- *  allocated, a special #cairo_t object will be returned on
+ *  %CAIRO_STATUS_WRITE_ERROR will be raised.  You can use this
- *  which cairo_status() returns %CAIRO_STATUS_NO_MEMORY.
+ *  object normally, but no drawing will be done.
  *  You can use this object normally, but no drawing will
- *  be done.
- **/
-cairo_t *
-cairo_create (cairo_surface_t *target)
+ * Since: 1.0
  **/
-    cairo_t *cr;
+cairo_t *
-    cairo_status_t status;
+cairo_create (cairo_surface_t *target)
-    if (unlikely (target == NULL))
+{
-	return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NULL_POINTER));
+    if (unlikely (target == NULL))
-    if (unlikely (target->status))
+	return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NULL_POINTER));
+    if (unlikely (target->status))
 	return _cairo_create_in_error (target->status);
+    if (target->backend->create_context == NULL)
+	return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_WRITE_ERROR));
+    return target->backend->create_context (target);
+}
-    cr = _context_get ();
-    if (unlikely (cr == NULL))
-	return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
-    CAIRO_REFERENCE_COUNT_INIT (&cr->ref_count, 1);
-    cr->status = CAIRO_STATUS_SUCCESS;
-    _cairo_user_data_array_init (&cr->user_data);
-    _cairo_path_fixed_init (cr->path);
-    cr->gstate = &cr->gstate_tail[0];
+slim_hidden_def (cairo_create);
     cr->gstate_freelist = &cr->gstate_tail[1];
-    cr->gstate_tail[1].next = NULL;
 void
-    status = _cairo_gstate_init (cr->gstate, target);
+_cairo_init (cairo_t *cr,
-    if (unlikely (status)) {
+	     const cairo_backend_t *backend)
 	_context_put (cr);
+ *
  * The number of references to a #cairo_t can be get using
  * cairo_get_reference_count().
+ *
  * Return value: the referenced #cairo_t.
+ *
+ * Since: 1.0
  **/
 cairo_t *
 cairo_reference (cairo_t *cr)
+{
     if (cr == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&cr->ref_count))
     _cairo_reference_count_inc (&cr->ref_count);
     return cr;
+}
+void
+_cairo_fini (cairo_t *cr)
+{
+    _cairo_user_data_array_fini (&cr->user_data);
+}
 /**
  * cairo_destroy:
  * @cr: a #cairo_t
+ *
  * Decreases the reference count on @cr by one. If the result
+ * is zero, then @cr and all associated resources are freed.
+ * See cairo_reference().
  * is zero, then @cr and all associated resources are freed.
- * See cairo_reference().
+ * Since: 1.0
  **/
 void
 cairo_destroy (cairo_t *cr)
     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&cr->ref_count));
     if (! _cairo_reference_count_dec_and_test (&cr->ref_count))
-	return;
-    while (cr->gstate != &cr->gstate_tail[0]) {
-	if (_cairo_gstate_restore (&cr->gstate, &cr->gstate_freelist))
-	    break;
-    }
-    _cairo_gstate_fini (cr->gstate);
-    cr->gstate_freelist = cr->gstate_freelist->next; /* skip over tail[1] */
-    while (cr->gstate_freelist != NULL) {
-	cairo_gstate_t *gstate = cr->gstate_freelist;
-	cr->gstate_freelist = gstate->next;
-	free (gstate);
-    }
-    _cairo_path_fixed_fini (cr->path);
-    _cairo_user_data_array_fini (&cr->user_data);
-    /* mark the context as invalid to protect against misuse */
-    cr->status = CAIRO_STATUS_NULL_POINTER;
+	return;
-    _context_put (cr);
+    cr->backend->destroy (cr);
+}
 slim_hidden_def (cairo_destroy);
  **/
 void *
 cairo_get_user_data (cairo_t			 *cr,
 		     const cairo_user_data_key_t *key)
+{
-    return _cairo_user_data_array_get_data (&cr->user_data,
+    return _cairo_user_data_array_get_data (&cr->user_data, key);
-					    key);
+}
 /**
  * cairo_set_user_data:
+ *
  * It isn't necessary to clear all saved states before
  * a #cairo_t is freed. If the reference count of a #cairo_t
  * drops to zero in response to a call to cairo_destroy(),
  * any saved states will be freed along with the #cairo_t.
+ *
+ * Since: 1.0
  **/
 void
 cairo_save (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_save (&cr->gstate, &cr->gstate_freelist);
+    status = cr->backend->save (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @cr: a #cairo_t
+ *
  * Restores @cr to the state saved by a preceding call to
  * cairo_save() and removes that state from the stack of
  * saved states.
+ *
+ * Since: 1.0
  **/
 void
 cairo_restore (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_restore (&cr->gstate, &cr->gstate_freelist);
+    status = cr->backend->restore (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * cairo_pop_group_to_source (cr);
  * cairo_paint_with_alpha (cr, alpha);
+ *
+ *
  * Since: 1.2
- */
+ **/
 void
 cairo_push_group (cairo_t *cr)
+{
     cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA);
+}
  * control this content type is the only distinction between this
  * function and cairo_push_group() which you should see for a more
  * detailed description of group rendering.
+ *
  * Since: 1.2
- */
+ **/
 void
 cairo_push_group_with_content (cairo_t *cr, cairo_content_t content)
+{
-    cairo_surface_t *group_surface;
-    cairo_clip_t *clip;
     cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    clip = _cairo_gstate_get_clip (cr->gstate);
-    if (clip->all_clipped) {
-	group_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
-	status = group_surface->status;
-	if (unlikely (status))
-	    goto bail;
-    } else {
-	cairo_surface_t *parent_surface;
-	const cairo_rectangle_int_t *clip_extents;
-	cairo_rectangle_int_t extents;
-        cairo_matrix_t matrix;
-	cairo_bool_t is_empty;
-	parent_surface = _cairo_gstate_get_target (cr->gstate);
-	/* Get the extents that we'll use in creating our new group surface */
-	is_empty = _cairo_surface_get_extents (parent_surface, &extents);
-	clip_extents = _cairo_clip_get_extents (_cairo_gstate_get_clip (cr->gstate));
-	if (clip_extents != NULL)
-	    is_empty = _cairo_rectangle_intersect (&extents, clip_extents);
-	group_surface = _cairo_surface_create_similar_solid (parent_surface,
-							     content,
-							     extents.width,
-							     extents.height,
-							     CAIRO_COLOR_TRANSPARENT,
-							     TRUE);
-	status = group_surface->status;
-	if (unlikely (status))
-	    goto bail;
-	/* Set device offsets on the new surface so that logically it appears at
-	 * the same location on the parent surface -- when we pop_group this,
-	 * the source pattern will get fixed up for the appropriate target surface
-	 * device offsets, so we want to set our own surface offsets from /that/,
-	 * and not from the device origin. */
-	cairo_surface_set_device_offset (group_surface,
-					 parent_surface->device_transform.x0 - extents.x,
-					 parent_surface->device_transform.y0 - extents.y);
-	/* If we have a current path, we need to adjust it to compensate for
-	 * the device offset just applied. */
-        cairo_matrix_init_translate (&matrix, -extents.x, -extents.y);
-	_cairo_path_fixed_transform (cr->path, &matrix);
-    }
-    /* create a new gstate for the redirect */
-    cairo_save (cr);
-    if (unlikely (cr->status))
-	goto bail;
-    status = _cairo_gstate_redirect_target (cr->gstate, group_surface);
+	return;
 bail:
-    cairo_surface_destroy (group_surface);
+    status = cr->backend->push_group (cr, content);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * Since: 1.2
  **/
 cairo_pattern_t *
 cairo_pop_group (cairo_t *cr)
+{
-    cairo_surface_t *group_surface, *parent_target;
     cairo_pattern_t *group_pattern;
-    cairo_matrix_t group_matrix, device_transform_matrix;
-    cairo_status_t status;
     if (unlikely (cr->status))
-	return _cairo_pattern_create_in_error (cr->status);
-    /* Grab the active surfaces */
-    group_surface = _cairo_gstate_get_target (cr->gstate);
-    parent_target = _cairo_gstate_get_parent_target (cr->gstate);
-    /* Verify that we are at the right nesting level */
-    if (parent_target == NULL) {
-	_cairo_set_error (cr, CAIRO_STATUS_INVALID_POP_GROUP);
-	return _cairo_pattern_create_in_error (CAIRO_STATUS_INVALID_POP_GROUP);
-    }
-    /* We need to save group_surface before we restore; we don't need
-     * to reference parent_target and original_target, since the
-     * gstate will still hold refs to them once we restore. */
-    group_surface = cairo_surface_reference (group_surface);
-    cairo_restore (cr);
-    if (unlikely (cr->status)) {
-	group_pattern = _cairo_pattern_create_in_error (cr->status);
-	goto done;
-    }
+	return _cairo_pattern_create_in_error (cr->status);
-    group_pattern = cairo_pattern_create_for_surface (group_surface);
-    status = group_pattern->status;
+    group_pattern = cr->backend->pop_group (cr);
-    if (unlikely (status)) {
-	_cairo_set_error (cr, status);
-        goto done;
-    }
-    _cairo_gstate_get_matrix (cr->gstate, &group_matrix);
-    /* Transform by group_matrix centered around device_transform so that when
-     * we call _cairo_gstate_copy_transformed_pattern the result is a pattern
-     * with a matrix equivalent to the device_transform of group_surface. */
-    if (_cairo_surface_has_device_transform (group_surface)) {
-	cairo_pattern_set_matrix (group_pattern, &group_surface->device_transform);
-	_cairo_pattern_transform (group_pattern, &group_matrix);
-	_cairo_pattern_transform (group_pattern, &group_surface->device_transform_inverse);
-    } else {
-	cairo_pattern_set_matrix (group_pattern, &group_matrix);
-    }
-    /* If we have a current path, we need to adjust it to compensate for
-     * the device offset just removed. */
-    cairo_matrix_multiply (&device_transform_matrix,
-                           &_cairo_gstate_get_target (cr->gstate)->device_transform,
-			   &group_surface->device_transform_inverse);
-    _cairo_path_fixed_transform (cr->path, &device_transform_matrix);
-done:
+    if (unlikely (group_pattern->status))
-    cairo_surface_destroy (group_surface);
+	_cairo_set_error (cr, group_pattern->status);
+ *
  * The behavior of this function is equivalent to the sequence of
  * operations:
+ *
+ *
- * #cairo_pattern_t *group = cairo_pop_group (cr);
+ * cairo_pattern_t *group = cairo_pop_group (cr);
  * cairo_set_source (cr, group);
  * cairo_pattern_destroy (group);
+ *
+ *
  * but is more convenient as their is no need for a variable to store
  * Sets the compositing operator to be used for all drawing
  * operations. See #cairo_operator_t for details on the semantics of
  * each available compositing operator.
+ *
  * The default operator is %CAIRO_OPERATOR_OVER.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_operator (cairo_t *cr, cairo_operator_t op)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_operator (cr->gstate, op);
+    status = cr->backend->set_operator (cr, op);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+}
+slim_hidden_def (cairo_set_operator);
-}
+#if 0
+/**
+ * cairo_set_opacity:
-slim_hidden_def (cairo_set_operator);
+ * @cr: a #cairo_t
+ * @opacity: the level of opacity to use when compositing
+ *
+ * Sets the compositing opacity to be used for all drawing
+ * operations. The effect is to fade out the operations
-static cairo_bool_t
+ * using the alpha value.
+ *
+ * The default opacity is 1.
-_current_source_matches_solid (cairo_t *cr,
+ *
-			       double red,
+ * Since: TBD
-			       double green,
-			       double blue,
+ **/
-			       double alpha)
-{
-    const cairo_pattern_t *current;
-    cairo_color_t color;
+void
-    current = cr->gstate->source;
+cairo_set_opacity (cairo_t *cr, double opacity)
-    if (current->type != CAIRO_PATTERN_TYPE_SOLID)
-	return FALSE;
+{
-    red   = _cairo_restrict_value (red,   0.0, 1.0);
+    cairo_status_t status;
-    green = _cairo_restrict_value (green, 0.0, 1.0);
-    blue  = _cairo_restrict_value (blue,  0.0, 1.0);
+    if (unlikely (cr->status))
+	return;
-    alpha = _cairo_restrict_value (alpha, 0.0, 1.0);
+    status = cr->backend->set_opacity (cr, opacity);
+    if (unlikely (status))
-    _cairo_color_init_rgba (&color, red, green, blue, alpha);
+	_cairo_set_error (cr, status);
     return _cairo_color_equal (&color,
-			       &((cairo_solid_pattern_t *) current)->color);
+#endif
 /**
  * 1. If the values passed in are outside that range, they will be
  * clamped.
+ *
  * The default source pattern is opaque black, (that is, it is
  * equivalent to cairo_set_source_rgb(cr, 0.0, 0.0, 0.0)).
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_source_rgb (cairo_t *cr, double red, double green, double blue)
+{
-    cairo_pattern_t *pattern;
+    cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    if (_current_source_matches_solid (cr, red, green, blue, 1.))
-	return;
-    /* push the current pattern to the freed lists */
-    cairo_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
-    pattern = cairo_pattern_create_rgb (red, green, blue);
+    status = cr->backend->set_source_rgba (cr, red, green, blue, 1.);
-    cairo_set_source (cr, pattern);
+    if (unlikely (status))
-    cairo_pattern_destroy (pattern);
+	_cairo_set_error (cr, status);
+}
 slim_hidden_def (cairo_set_source_rgb);
  * range 0 to 1. If the values passed in are outside that range, they
  * will be clamped.
+ *
  * The default source pattern is opaque black, (that is, it is
  * equivalent to cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0)).
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_source_rgba (cairo_t *cr,
 		       double red, double green, double blue,
 		       double alpha)
+{
-    cairo_pattern_t *pattern;
+    cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    if (_current_source_matches_solid (cr, red, green, blue, alpha))
-	return;
-    /* push the current pattern to the freed lists */
-    cairo_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
+	return;
-    pattern = cairo_pattern_create_rgba (red, green, blue, alpha);
+    status = cr->backend->set_source_rgba (cr, red, green, blue, alpha);
-    cairo_set_source (cr, pattern);
+    if (unlikely (status))
-    cairo_pattern_destroy (pattern);
+	_cairo_set_error (cr, status);
+}
  * above, all other pattern attributes, (such as its extend mode), are
  * set to the default values as in cairo_pattern_create_for_surface().
  * The resulting pattern can be queried with cairo_get_source() so
  * that these attributes can be modified if desired, (eg. to create a
  * repeating pattern with cairo_pattern_set_extend()).
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_source_surface (cairo_t	  *cr,
 			  cairo_surface_t *surface,
 			  double	   x,
 			  double	   y)
+{
-    cairo_pattern_t *pattern;
-    cairo_matrix_t matrix;
+    cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    /* push the current pattern to the freed lists */
+    if (unlikely (surface == NULL)) {
-    cairo_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
+	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
-    pattern = cairo_pattern_create_for_surface (surface);
+	return;
-    cairo_matrix_init_translate (&matrix, -x, -y);
+    }
-    cairo_pattern_set_matrix (pattern, &matrix);
     status = cr->backend->set_source_surface (cr, surface, x, y);
-    cairo_set_source (cr, pattern);
+    if (unlikely (status))
-    cairo_pattern_destroy (pattern);
+	_cairo_set_error (cr, status);
 }
 slim_hidden_def (cairo_set_source_surface);
 /**
- * cairo_set_source
+ * cairo_set_source:
  * @cr: a cairo context
  * will not affect the source pattern. See cairo_pattern_set_matrix().
+ *
  * The default source pattern is a solid pattern that is opaque black,
  * (that is, it is equivalent to cairo_set_source_rgb(cr, 0.0, 0.0,
  * 0.0)).
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_source (cairo_t *cr, cairo_pattern_t *source)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    if (source == NULL) {
+    if (unlikely (source == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
 	return;
+    }
-    if (source->status) {
+    if (unlikely (source->status)) {
 	_cairo_set_error (cr, source->status);
 	return;
+    }
-    status = _cairo_gstate_set_source (cr->gstate, source);
+    status = cr->backend->set_source (cr, source);
  * Gets the current source pattern for @cr.
+ *
  * Return value: the current source pattern. This object is owned by
  * cairo. To keep a reference to it, you must call
  * cairo_pattern_reference().
+ *
+ * Since: 1.0
  **/
 cairo_pattern_t *
 cairo_get_source (cairo_t *cr)
+{
     if (unlikely (cr->status))
 	return _cairo_pattern_create_in_error (cr->status);
-    return _cairo_gstate_get_source (cr->gstate);
+    return cr->backend->get_source (cr);
+}
 /**
  * appearance. (Reducing the value from the default value of 0.1
  * is unlikely to improve appearance significantly.)  The accuracy of paths
  * within Cairo is limited by the precision of its internal arithmetic, and
  * the prescribed @tolerance is restricted to the smallest
  * representable internal value.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_tolerance (cairo_t *cr, double tolerance)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    if (tolerance < CAIRO_TOLERANCE_MINIMUM)
-	tolerance = CAIRO_TOLERANCE_MINIMUM;
+	return;
-    status = _cairo_gstate_set_tolerance (cr->gstate, tolerance);
+    status = cr->backend->set_tolerance (cr, tolerance);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * a particular value.  At the current time, no backend supports
  * %CAIRO_ANTIALIAS_SUBPIXEL when drawing shapes.
+ *
  * Note that this option does not affect text rendering, instead see
  * cairo_font_options_set_antialias().
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_antialias (cairo_t *cr, cairo_antialias_t antialias)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_antialias (cr->gstate, antialias);
+    status = cr->backend->set_antialias (cr, antialias);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * (potentially self-intersecting) path. The current fill rule affects
  * both cairo_fill() and cairo_clip(). See #cairo_fill_rule_t for details
  * on the semantics of each available fill rule.
+ *
  * The default fill rule is %CAIRO_FILL_RULE_WINDING.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_fill_rule (cairo_t *cr, cairo_fill_rule_t fill_rule)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_fill_rule (cr->gstate, fill_rule);
+    status = cr->backend->set_fill_rule (cr, fill_rule);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * examined by cairo_stroke(), cairo_stroke_extents(), and
  * cairo_stroke_to_path(), but does not have any effect during path
  * construction.
+ *
  * The default line width value is 2.0.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_line_width (cairo_t *cr, double width)
+{
     cairo_status_t status;
 	return;
     if (width < 0.)
 	width = 0.;
-    status = _cairo_gstate_set_line_width (cr->gstate, width);
+    status = cr->backend->set_line_width (cr, width);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * examined by cairo_stroke(), cairo_stroke_extents(), and
  * cairo_stroke_to_path(), but does not have any effect during path
  * construction.
+ *
  * The default line cap style is %CAIRO_LINE_CAP_BUTT.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_line_cap (cairo_t *cr, cairo_line_cap_t line_cap)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_line_cap (cr->gstate, line_cap);
+    status = cr->backend->set_line_cap (cr, line_cap);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * examined by cairo_stroke(), cairo_stroke_extents(), and
  * cairo_stroke_to_path(), but does not have any effect during path
  * construction.
+ *
  * The default line join style is %CAIRO_LINE_JOIN_MITER.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_line_join (cairo_t *cr, cairo_line_join_t line_join)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_line_join (cr->gstate, line_join);
+    status = cr->backend->set_line_join (cr, line_join);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @dashes.
+ *
  * If any value in @dashes is negative, or if all values are 0, then
  * @cr will be put into an error state with a status of
  * %CAIRO_STATUS_INVALID_DASH.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_dash (cairo_t	     *cr,
 		const double *dashes,
 		int	      num_dashes,
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
     status = _cairo_gstate_set_dash (cr->gstate,
-				     dashes, num_dashes, offset);
+    status = cr->backend->set_dash (cr, dashes, num_dashes, offset);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * See also cairo_set_dash() and cairo_get_dash().
+ *
  * Return value: the length of the dash array, or 0 if no dash array set.
+ *
  * Since: 1.4
- */
+ **/
 int
 cairo_get_dash_count (cairo_t *cr)
+{
     int num_dashes;
     if (unlikely (cr->status))
 	return 0;
-    _cairo_gstate_get_dash (cr->gstate, NULL, &num_dashes, NULL);
+    cr->backend->get_dash (cr, NULL, &num_dashes, NULL);
 		double  *offset)
+{
     if (unlikely (cr->status))
 	return;
-    _cairo_gstate_get_dash (cr->gstate, dashes, NULL, offset);
+    cr->backend->get_dash (cr, dashes, NULL, offset);
+}
 /**
  * at 60 degrees, and a miter limit of 1.414 makes the cutoff at 90
  * degrees.
+ *
  * A miter limit for a desired angle can be computed as: miter limit =
  * 1/sin(angle/2)
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_miter_limit (cairo_t *cr, double limit)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_miter_limit (cr->gstate, limit);
+    status = cr->backend->set_miter_limit (cr, limit);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * Modifies the current transformation matrix (CTM) by translating the
  * user-space origin by (@tx, @ty). This offset is interpreted as a
  * user-space coordinate according to the CTM in place before the new
  * call to cairo_translate(). In other words, the translation of the
  * user-space origin takes place after any existing transformation.
+ *
+ * Since: 1.0
  **/
 void
 cairo_translate (cairo_t *cr, double tx, double ty)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_translate (cr->gstate, tx, ty);
+    status = cr->backend->translate (cr, tx, ty);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+ *
  * Modifies the current transformation matrix (CTM) by scaling the X
  * and Y user-space axes by @sx and @sy respectively. The scaling of
  * the axes takes place after any existing transformation of user
  * space.
+ *
+ * Since: 1.0
  **/
 void
 cairo_scale (cairo_t *cr, double sx, double sy)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_scale (cr->gstate, sx, sy);
+    status = cr->backend->scale (cr, sx, sy);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * Modifies the current transformation matrix (CTM) by rotating the
  * user-space axes by @angle radians. The rotation of the axes takes
  * places after any existing transformation of user space. The
  * rotation direction for positive angles is from the positive X axis
  * toward the positive Y axis.
+ *
+ * Since: 1.0
  **/
 void
 cairo_rotate (cairo_t *cr, double angle)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_rotate (cr->gstate, angle);
+    status = cr->backend->rotate (cr, angle);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @matrix: a transformation to be applied to the user-space axes
+ *
  * Modifies the current transformation matrix (CTM) by applying
  * @matrix as an additional transformation. The new transformation of
  * user space takes place after any existing transformation.
+ *
+ * Since: 1.0
  **/
 void
 cairo_transform (cairo_t	      *cr,
 		 const cairo_matrix_t *matrix)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_transform (cr->gstate, matrix);
+    status = cr->backend->transform (cr, matrix);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @cr: a cairo context
  * @matrix: a transformation matrix from user space to device space
+ *
  * Modifies the current transformation matrix (CTM) by setting it
  * equal to @matrix.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_matrix (cairo_t	       *cr,
 		  const cairo_matrix_t *matrix)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_matrix (cr->gstate, matrix);
+    status = cr->backend->set_matrix (cr, matrix);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+ *
  * Resets the current transformation matrix (CTM) by setting it equal
  * to the identity matrix. That is, the user-space and device-space
  * axes will be aligned and one user-space unit will transform to one
  * device-space unit.
+ *
+ * Since: 1.0
  **/
 void
 cairo_identity_matrix (cairo_t *cr)
+{
+    cairo_status_t status;
     if (unlikely (cr->status))
 	return;
+    status = cr->backend->set_identity_matrix (cr);
+    if (unlikely (status))
-    _cairo_gstate_identity_matrix (cr->gstate);
+	_cairo_set_error (cr, status);
+}
 /**
  * @y: Y value of coordinate (in/out parameter)
+ *
  * Transform a coordinate from user space to device space by
  * multiplying the given point by the current transformation matrix
  * (CTM).
+ *
+ * Since: 1.0
  **/
 void
 cairo_user_to_device (cairo_t *cr, double *x, double *y)
+{
     if (unlikely (cr->status))
 	return;
-    _cairo_gstate_user_to_device (cr->gstate, x, y);
+    cr->backend->user_to_device (cr, x, y);
+}
 slim_hidden_def (cairo_user_to_device);
+ *
  * Transform a distance vector from user space to device space. This
  * function is similar to cairo_user_to_device() except that the
  * translation components of the CTM will be ignored when transforming
  * (@dx,@dy).
+ *
+ * Since: 1.0
  **/
 void
 cairo_user_to_device_distance (cairo_t *cr, double *dx, double *dy)
+{
     if (unlikely (cr->status))
 	return;
-    _cairo_gstate_user_to_device_distance (cr->gstate, dx, dy);
+    cr->backend->user_to_device_distance (cr, dx, dy);
+}
 slim_hidden_def (cairo_user_to_device_distance);
  * @y: Y value of coordinate (in/out parameter)
+ *
  * Transform a coordinate from device space to user space by
  * multiplying the given point by the inverse of the current
  * transformation matrix (CTM).
+ *
+ * Since: 1.0
  **/
 void
 cairo_device_to_user (cairo_t *cr, double *x, double *y)
+{
     if (unlikely (cr->status))
 	return;
-    _cairo_gstate_device_to_user (cr->gstate, x, y);
+    cr->backend->device_to_user (cr, x, y);
+}
 slim_hidden_def (cairo_device_to_user);
 /**
  * cairo_device_to_user_distance:
+ *
  * Transform a distance vector from device space to user space. This
  * function is similar to cairo_device_to_user() except that the
  * translation components of the inverse CTM will be ignored when
  * transforming (@dx,@dy).
+ *
+ * Since: 1.0
  **/
 void
 cairo_device_to_user_distance (cairo_t *cr, double *dx, double *dy)
+{
     if (unlikely (cr->status))
 	return;
-    _cairo_gstate_device_to_user_distance (cr->gstate, dx, dy);
+    cr->backend->device_to_user_distance (cr, dx, dy);
+}
 /**
  * cairo_new_path:
  * @cr: a cairo context
+ *
- * Clears the current path. After this call there will be no path and
- * no current point.
- **/
-void
-cairo_new_path (cairo_t *cr)
-{
-    if (unlikely (cr->status))
-	return;
-    _cairo_path_fixed_fini (cr->path);
-    _cairo_path_fixed_init (cr->path);
-}
-slim_hidden_def(cairo_new_path);
-/**
- * cairo_move_to:
- * @cr: a cairo context
- * @x: the X coordinate of the new position
+ * Clears the current path. After this call there will be no path and
- * @y: the Y coordinate of the new position
- *
+ * no current point.
  * Begin a new sub-path. After this call the current point will be (@x,
- * @y).
+ * Since: 1.0
  **/
 void
-cairo_move_to (cairo_t *cr, double x, double y)
+cairo_new_path (cairo_t *cr)
-{
     cairo_status_t status;
-    cairo_fixed_t x_fixed, y_fixed;
+    cairo_status_t status;
-    if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_backend (cr->gstate, &x, &y);
-    x_fixed = _cairo_fixed_from_double (x);
+    if (unlikely (cr->status))
-    y_fixed = _cairo_fixed_from_double (y);
+	return;
-    status = _cairo_path_fixed_move_to (cr->path, x_fixed, y_fixed);
+    status = cr->backend->new_path (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+}
-slim_hidden_def(cairo_move_to);
+slim_hidden_def(cairo_new_path);
  * Since: 1.2
  **/
 void
 cairo_new_sub_path (cairo_t *cr)
+{
+    cairo_status_t status;
     if (unlikely (cr->status))
 	return;
+    status = cr->backend->new_sub_path (cr);
+    if (unlikely (status))
-    _cairo_path_fixed_new_sub_path (cr->path);
+	_cairo_set_error (cr, status);
+}
+/**
+ * cairo_move_to:
+ * @cr: a cairo context
+ * @x: the X coordinate of the new position
+ * @y: the Y coordinate of the new position
+ *
+ * Begin a new sub-path. After this call the current point will be (@x,
+ * @y).
+ *
+ * Since: 1.0
+ **/
+void
+cairo_move_to (cairo_t *cr, double x, double y)
+{
+    cairo_status_t status;
+    if (unlikely (cr->status))
+	return;
+    status = cr->backend->move_to (cr, x, y);
+    if (unlikely (status))
+	_cairo_set_error (cr, status);
+}
+slim_hidden_def(cairo_move_to);
 /**
  * cairo_line_to:
  * @cr: a cairo context
  * @x: the X coordinate of the end of the new line
  * in user-space coordinates. After this call the current point
  * will be (@x, @y).
+ *
  * If there is no current point before the call to cairo_line_to()
  * this function will behave as cairo_move_to(@cr, @x, @y).
+ *
+ * Since: 1.0
  **/
 void
 cairo_line_to (cairo_t *cr, double x, double y)
+{
     cairo_status_t status;
-    cairo_fixed_t x_fixed, y_fixed;
     if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_backend (cr->gstate, &x, &y);
-    x_fixed = _cairo_fixed_from_double (x);
-    y_fixed = _cairo_fixed_from_double (y);
+	return;
-    status = _cairo_path_fixed_line_to (cr->path, x_fixed, y_fixed);
+    status = cr->backend->line_to (cr, x, y);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * will be (@x3, @y3).
+ *
  * If there is no current point before the call to cairo_curve_to()
  * this function will behave as if preceded by a call to
  * cairo_move_to(@cr, @x1, @y1).
+ *
+ * Since: 1.0
  **/
 void
 cairo_curve_to (cairo_t *cr,
 		double x1, double y1,
 		double x2, double y2,
 		double x3, double y3)
+{
     cairo_status_t status;
-    cairo_fixed_t x1_fixed, y1_fixed;
-    cairo_fixed_t x2_fixed, y2_fixed;
-    cairo_fixed_t x3_fixed, y3_fixed;
     if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_backend (cr->gstate, &x1, &y1);
-    _cairo_gstate_user_to_backend (cr->gstate, &x2, &y2);
-    _cairo_gstate_user_to_backend (cr->gstate, &x3, &y3);
-    x1_fixed = _cairo_fixed_from_double (x1);
-    y1_fixed = _cairo_fixed_from_double (y1);
-    x2_fixed = _cairo_fixed_from_double (x2);
-    y2_fixed = _cairo_fixed_from_double (y2);
-    x3_fixed = _cairo_fixed_from_double (x3);
-    y3_fixed = _cairo_fixed_from_double (y3);
+	return;
-    status = _cairo_path_fixed_curve_to (cr->path,
+    status = cr->backend->curve_to (cr,
-					 x1_fixed, y1_fixed,
+				    x1, y1,
-					 x2_fixed, y2_fixed,
+				    x2, y2,
-					 x3_fixed, y3_fixed);
+				    x3, y3);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @angle2: the end angle, in radians
+ *
  * Adds a circular arc of the given @radius to the current path.  The
  * arc is centered at (@xc, @yc), begins at @angle1 and proceeds in
  * the direction of increasing angles to end at @angle2. If @angle2 is
- * less than @angle1 it will be progressively increased by 2*M_PI
+ * less than @angle1 it will be progressively increased by
- * until it is greater than @angle1.
+ * 2*M_PI until it is greater than @angle1.
+ *
  * If there is a current point, an initial line segment will be added
  * to the path to connect the current point to the beginning of the
  * arc. If this initial line is undesired, it can be avoided by
  * calling cairo_new_sub_path() before calling cairo_arc().
+ *
  * Angles are measured in radians. An angle of 0.0 is in the direction
- * of the positive X axis (in user space). An angle of %M_PI/2.0 radians
+ * of the positive X axis (in user space). An angle of
+ * M_PI/2.0 radians (90 degrees) is in the
- * (90 degrees) is in the direction of the positive Y axis (in
+ * direction of the positive Y axis (in user space). Angles increase
- * user space). Angles increase in the direction from the positive X
+ * in the direction from the positive X axis toward the positive Y
- * axis toward the positive Y axis. So with the default transformation
+ * axis. So with the default transformation matrix, angles increase in
- * matrix, angles increase in a clockwise direction.
+ * a clockwise direction.
+ *
  * (To convert from degrees to radians, use degrees * (M_PI /
  * 180.).)
+ *
  * This function gives the arc in the direction of increasing angles;
  * cairo_translate (cr, x + width / 2., y + height / 2.);
  * cairo_scale (cr, width / 2., height / 2.);
  * cairo_arc (cr, 0., 0., 1., 0., 2 * M_PI);
  * cairo_restore (cr);
+ *
+ *
+ * Since: 1.0
  **/
 void
 cairo_arc (cairo_t *cr,
 	   double xc, double yc,
 	   double radius,
 	   double angle1, double angle2)
+{
-    if (unlikely (cr->status))
+    cairo_status_t status;
-	return;
-    /* Do nothing, successfully, if radius is <= 0 */
-    if (radius <= 0.0) {
-	cairo_line_to (cr, xc, yc); /* might become a move_to */
-	cairo_line_to (cr, xc, yc);
+    if (unlikely (cr->status))
-	return;
-    }
+	return;
+    if (angle2 < angle1) {
+	/* increase angle2 by multiples of full circle until it
+	 * satisfies angle2 >= angle1 */
 	angle2 = fmod (angle2 - angle1, 2 * M_PI);
+	if (angle2 < 0)
+	    angle2 += 2 * M_PI;
-    while (angle2 < angle1)
-	angle2 += 2 * M_PI;
+	angle2 += angle1;
+    }
-    cairo_line_to (cr,
-		   xc + radius * cos (angle1),
-		   yc + radius * sin (angle1));
     status = cr->backend->arc (cr, xc, yc, radius, angle1, angle2, TRUE);
-    _cairo_arc_path (cr, xc, yc, radius,
+    if (unlikely (status))
-		     angle1, angle2);
+	_cairo_set_error (cr, status);
+}
  * @angle2: the end angle, in radians
+ *
  * Adds a circular arc of the given @radius to the current path.  The
  * arc is centered at (@xc, @yc), begins at @angle1 and proceeds in
  * the direction of decreasing angles to end at @angle2. If @angle2 is
- * greater than @angle1 it will be progressively decreased by 2*M_PI
+ * greater than @angle1 it will be progressively decreased by
- * until it is less than @angle1.
+ * 2*M_PI until it is less than @angle1.
+ *
  * See cairo_arc() for more details. This function differs only in the
  * direction of the arc between the two angles.
+ *
+ * Since: 1.0
  **/
 void
 cairo_arc_negative (cairo_t *cr,
 		    double xc, double yc,
 		    double radius,
 		    double angle1, double angle2)
+{
-    if (unlikely (cr->status))
+    cairo_status_t status;
-	return;
-    /* Do nothing, successfully, if radius is <= 0 */
-    if (radius <= 0.0)
+    if (unlikely (cr->status))
 	return;
+    if (angle2 > angle1) {
+	/* decrease angle2 by multiples of full circle until it
+	 * satisfies angle2 <= angle1 */
 	angle2 = fmod (angle2 - angle1, 2 * M_PI);
+	if (angle2 > 0)
+	    angle2 -= 2 * M_PI;
-    while (angle2 > angle1)
-	angle2 -= 2 * M_PI;
+	angle2 += angle1;
+    }
-    cairo_line_to (cr,
-		   xc + radius * cos (angle1),
-		   yc + radius * sin (angle1));
     status = cr->backend->arc (cr, xc, yc, radius, angle1, angle2, FALSE);
-     _cairo_arc_path_negative (cr, xc, yc, radius,
+    if (unlikely (status))
-			       angle1, angle2);
+	_cairo_set_error (cr, status);
+}
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
+    status = cr->backend->arc_to (cr, x1, y1, x2, y2, radius);
+    if (unlikely (status))
+	_cairo_set_error (cr, status);
+}
+void
-    status = _cairo_gstate_arc_to (cr->gstate,
+cairo_rel_arc_to (cairo_t *cr,
-				   x1, y1,
+	      double dx1, double dy1,
+	      double dx2, double dy2,
+	      double radius)
+{
+    cairo_status_t status;
+    if (unlikely (cr->status))
+	return;
 				   x2, y2,
-				   radius);
+    status = cr->backend->rel_arc_to (cr, dx1, dy1, dx2, dy2, radius);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * is logically equivalent to cairo_move_to(@cr, x + @dx, y + @dy).
+ *
  * It is an error to call this function with no current point. Doing
  * so will cause @cr to shutdown with a status of
  * %CAIRO_STATUS_NO_CURRENT_POINT.
+ *
+ * Since: 1.0
  **/
 void
 cairo_rel_move_to (cairo_t *cr, double dx, double dy)
+{
-    cairo_fixed_t dx_fixed, dy_fixed;
     cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_device_distance (cr->gstate, &dx, &dy);
-    dx_fixed = _cairo_fixed_from_double (dx);
-    dy_fixed = _cairo_fixed_from_double (dy);
+	return;
-    status = _cairo_path_fixed_rel_move_to (cr->path, dx_fixed, dy_fixed);
+    status = cr->backend->rel_move_to (cr, dx, dy);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * is logically equivalent to cairo_line_to(@cr, x + @dx, y + @dy).
+ *
  * It is an error to call this function with no current point. Doing
  * so will cause @cr to shutdown with a status of
  * %CAIRO_STATUS_NO_CURRENT_POINT.
+ *
+ * Since: 1.0
  **/
 void
 cairo_rel_line_to (cairo_t *cr, double dx, double dy)
+{
-    cairo_fixed_t dx_fixed, dy_fixed;
     cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_device_distance (cr->gstate, &dx, &dy);
-    dx_fixed = _cairo_fixed_from_double (dx);
-    dy_fixed = _cairo_fixed_from_double (dy);
+	return;
-    status = _cairo_path_fixed_rel_line_to (cr->path, dx_fixed, dy_fixed);
+    status = cr->backend->rel_line_to (cr, dx, dy);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * cairo_curve_to(@cr, x+@dx1, y+@dy1, x+@dx2, y+@dy2, x+@dx3, y+@dy3).
+ *
  * It is an error to call this function with no current point. Doing
  * so will cause @cr to shutdown with a status of
  * %CAIRO_STATUS_NO_CURRENT_POINT.
+ *
+ * Since: 1.0
  **/
 void
 cairo_rel_curve_to (cairo_t *cr,
 		    double dx1, double dy1,
 		    double dx2, double dy2,
 		    double dx3, double dy3)
+{
-    cairo_fixed_t dx1_fixed, dy1_fixed;
-    cairo_fixed_t dx2_fixed, dy2_fixed;
-    cairo_fixed_t dx3_fixed, dy3_fixed;
     cairo_status_t status;
     if (unlikely (cr->status))
-	return;
-    _cairo_gstate_user_to_device_distance (cr->gstate, &dx1, &dy1);
-    _cairo_gstate_user_to_device_distance (cr->gstate, &dx2, &dy2);
-    _cairo_gstate_user_to_device_distance (cr->gstate, &dx3, &dy3);
-    dx1_fixed = _cairo_fixed_from_double (dx1);
-    dy1_fixed = _cairo_fixed_from_double (dy1);
-    dx2_fixed = _cairo_fixed_from_double (dx2);
-    dy2_fixed = _cairo_fixed_from_double (dy2);
-    dx3_fixed = _cairo_fixed_from_double (dx3);
-    dy3_fixed = _cairo_fixed_from_double (dy3);
+	return;
-    status = _cairo_path_fixed_rel_curve_to (cr->path,
+    status = cr->backend->rel_curve_to (cr,
-					     dx1_fixed, dy1_fixed,
+					dx1, dy1,
-					     dx2_fixed, dy2_fixed,
+					dx2, dy2,
-					     dx3_fixed, dy3_fixed);
+					dx3, dy3);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * cairo_rel_line_to (cr, width, 0);
  * cairo_rel_line_to (cr, 0, height);
  * cairo_rel_line_to (cr, -width, 0);
  * cairo_close_path (cr);
+ *
+ *
+ * Since: 1.0
  **/
 void
 cairo_rectangle (cairo_t *cr,
 		 double x, double y,
 		 double width, double height)
+{
+    cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    cairo_move_to (cr, x, y);
-    cairo_rel_line_to (cr, width, 0);
+    status = cr->backend->rectangle (cr, x, y, width, height);
-    cairo_rel_line_to (cr, 0, height);
+    if (unlikely (status))
-    cairo_rel_line_to (cr, -width, 0);
-    cairo_close_path (cr);
+	_cairo_set_error (cr, status);
+}
 #if 0
  * the CLOSE_PATH element, (which can be seen in cairo_copy_path() for
  * example). This can simplify path processing in some cases as it may
  * not be necessary to save the "last move_to point" during processing
  * as the MOVE_TO immediately after the CLOSE_PATH will provide that
  * point.
+ *
+ * Since: 1.0
  **/
 void
 cairo_close_path (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_path_fixed_close_path (cr->path);
+    status = cr->backend->close_path (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
 	    *y2 = 0.0;
 	return;
     }
-    _cairo_gstate_path_extents (cr->gstate,
 				cr->path,
-				x1, y1, x2, y2);
+    cr->backend->path_extents (cr, x1, y1, x2, y2);
+}
 /**
  * cairo_paint:
  * @cr: a cairo context
+ *
+ * A drawing operator that paints the current source everywhere within
  * the current clip region.
  * A drawing operator that paints the current source everywhere within
- * the current clip region.
+ * Since: 1.0
  **/
 void
 cairo_paint (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
+ *
  * A drawing operator that paints the current source everywhere within
  * the current clip region using a mask of constant alpha value
  * @alpha. The effect is similar to cairo_paint(), but the drawing
  * is faded out using the alpha value.
+ *
+ * Since: 1.0
  **/
 void
 cairo_paint_with_alpha (cairo_t *cr,
 			double   alpha)
+{
     cairo_status_t status;
-    cairo_color_t color;
-    cairo_solid_pattern_t pattern;
     if (unlikely (cr->status))
-	return;
-    if (CAIRO_ALPHA_IS_OPAQUE (alpha)) {
-	cairo_paint (cr);
-	return;
-    }
-    if (CAIRO_ALPHA_IS_ZERO (alpha) &&
-        _cairo_operator_bounded_by_mask (cr->gstate->op)) {
-	return;
-    }
-    _cairo_color_init_rgba (&color, 0., 0., 0., alpha);
-    _cairo_pattern_init_solid (&pattern, &color);
+	return;
-    status = _cairo_gstate_mask (cr->gstate, &pattern.base);
+    status = cr->backend->paint_with_alpha (cr, alpha);
-    if (unlikely (status))
-	_cairo_set_error (cr, status);
     if (unlikely (status))
-    _cairo_pattern_fini (&pattern.base);
+	_cairo_set_error (cr, status);
+}
+ *
  * A drawing operator that paints the current source
  * using the alpha channel of @pattern as a mask. (Opaque
  * areas of @pattern are painted with the source, transparent
  * areas are not painted.)
+ *
+ * Since: 1.0
- */
+ **/
 void
 cairo_mask (cairo_t         *cr,
 	    cairo_pattern_t *pattern)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    if (pattern == NULL) {
+    if (unlikely (pattern == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
 	return;
+    }
-    if (pattern->status) {
+    if (unlikely (pattern->status)) {
 	_cairo_set_error (cr, pattern->status);
 	return;
+    }
-    status = _cairo_gstate_mask (cr->gstate, pattern);
+    status = cr->backend->mask (cr, pattern);
+ *
  * A drawing operator that paints the current source
  * using the alpha channel of @surface as a mask. (Opaque
  * areas of @surface are painted with the source, transparent
  * areas are not painted.)
+ *
+ * Since: 1.0
- */
+ **/
 void
 cairo_mask_surface (cairo_t         *cr,
 		    cairo_surface_t *surface,
 		    double           surface_x,
 		    double           surface_y)
  * sub-path will not be drawn at all, (since the correct orientation
  * is indeterminate).
+ *
  * In no case will a cap style of %CAIRO_LINE_CAP_BUTT cause anything
  * to be drawn in the case of either degenerate segments or sub-paths.
+ *
+ * Since: 1.0
  **/
 void
 cairo_stroke (cairo_t *cr)
+{
-    cairo_stroke_preserve (cr);
+    cairo_status_t status;
+    if (unlikely (cr->status))
+	return;
+    status = cr->backend->stroke (cr);
+    if (unlikely (status))
-    cairo_new_path (cr);
+	_cairo_set_error (cr, status);
+}
 slim_hidden_def(cairo_stroke);
  * cairo context.
+ *
  * See cairo_set_line_width(), cairo_set_line_join(),
  * cairo_set_line_cap(), cairo_set_dash(), and
  * cairo_stroke_preserve().
+ *
+ * Since: 1.0
  **/
 void
 cairo_stroke_preserve (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_stroke (cr->gstate, cr->path);
+    status = cr->backend->stroke_preserve (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * A drawing operator that fills the current path according to the
  * current fill rule, (each sub-path is implicitly closed before being
  * filled). After cairo_fill(), the current path will be cleared from
  * the cairo context. See cairo_set_fill_rule() and
  * cairo_fill_preserve().
+ *
+ * Since: 1.0
  **/
 void
 cairo_fill (cairo_t *cr)
+{
-    cairo_fill_preserve (cr);
+    cairo_status_t status;
+    if (unlikely (cr->status))
+	return;
+    status = cr->backend->fill (cr);
+    if (unlikely (status))
-    cairo_new_path (cr);
+	_cairo_set_error (cr, status);
+}
 /**
  * current fill rule, (each sub-path is implicitly closed before being
  * filled). Unlike cairo_fill(), cairo_fill_preserve() preserves the
  * path within the cairo context.
+ *
  * See cairo_set_fill_rule() and cairo_fill().
+ *
+ * Since: 1.0
  **/
 void
 cairo_fill_preserve (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_fill (cr->gstate, cr->path);
+    status = cr->backend->fill_preserve (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * for the next page too.  Use cairo_show_page() if you want to get an
  * empty page after the emission.
+ *
  * This is a convenience function that simply calls
  * cairo_surface_copy_page() on @cr's target.
+ *
+ * Since: 1.0
  **/
 void
 cairo_copy_page (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_copy_page (cr->gstate);
+    status = cr->backend->copy_page (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * Emits and clears the current page for backends that support multiple
  * pages.  Use cairo_copy_page() if you don't want to clear the page.
+ *
  * This is a convenience function that simply calls
  * cairo_surface_show_page() on @cr's target.
+ *
+ * Since: 1.0
  **/
 void
 cairo_show_page (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_show_page (cr->gstate);
+    status = cr->backend->show_page (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * cairo_set_line_cap(), cairo_set_dash(), and
  * cairo_stroke_preserve().
+ *
  * Return value: A non-zero value if the point is inside, or zero if
  * outside.
+ *
+ * Since: 1.0
  **/
 cairo_bool_t
 cairo_in_stroke (cairo_t *cr, double x, double y)
+{
     cairo_status_t status;
     cairo_bool_t inside = FALSE;
     if (unlikely (cr->status))
 	return FALSE;
-    status = _cairo_gstate_in_stroke (cr->gstate,
 				      cr->path,
-				      x, y, &inside);
+    status = cr->backend->in_stroke (cr, x, y, &inside);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+ *
  * See cairo_fill(), cairo_set_fill_rule() and cairo_fill_preserve().
+ *
  * Return value: A non-zero value if the point is inside, or zero if
  * outside.
+ *
+ * Since: 1.0
  **/
 cairo_bool_t
 cairo_in_fill (cairo_t *cr, double x, double y)
+{
+    cairo_status_t status;
+    cairo_bool_t inside = FALSE;
     if (unlikely (cr->status))
 	return FALSE;
+    status = cr->backend->in_fill (cr, x, y, &inside);
+    if (unlikely (status))
+	_cairo_set_error (cr, status);
-    return _cairo_gstate_in_fill (cr->gstate, cr->path, x, y);
+    return inside;
+}
 /**
  * performance if non-inked path extents are desired.
+ *
  * See cairo_stroke(), cairo_set_line_width(), cairo_set_line_join(),
  * cairo_set_line_cap(), cairo_set_dash(), and
  * cairo_stroke_preserve().
+ *
+ * Since: 1.0
  **/
 void
 cairo_stroke_extents (cairo_t *cr,
                       double *x1, double *y1, double *x2, double *y2)
+{
 	    *y2 = 0.0;
 	return;
     }
-    status = _cairo_gstate_stroke_extents (cr->gstate,
 					   cr->path,
-					   x1, y1, x2, y2);
+    status = cr->backend->stroke_extents (cr, x1, y1, x2, y2);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * compute the precise inked areas in light of the fill rule, so
  * cairo_path_extents() may be more desirable for sake of performance
  * if the non-inked path extents are desired.
+ *
  * See cairo_fill(), cairo_set_fill_rule() and cairo_fill_preserve().
+ *
+ * Since: 1.0
  **/
 void
 cairo_fill_extents (cairo_t *cr,
                     double *x1, double *y1, double *x2, double *y2)
+{
 	    *y2 = 0.0;
 	return;
     }
-    status = _cairo_gstate_fill_extents (cr->gstate,
 					 cr->path,
-					 x1, y1, x2, y2);
+    status = cr->backend->fill_extents (cr, x1, y1, x2, y2);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * larger. But the current clip is part of the graphics state, so a
  * temporary restriction of the clip region can be achieved by
  * calling cairo_clip() within a cairo_save()/cairo_restore()
  * pair. The only other means of increasing the size of the clip
  * region is cairo_reset_clip().
+ *
+ * Since: 1.0
  **/
 void
 cairo_clip (cairo_t *cr)
+{
-    cairo_clip_preserve (cr);
+    cairo_status_t status;
+    if (unlikely (cr->status))
+	return;
+    status = cr->backend->clip (cr);
+    if (unlikely (status))
-    cairo_new_path (cr);
+	_cairo_set_error (cr, status);
+}
 /**
  * larger. But the current clip is part of the graphics state, so a
  * temporary restriction of the clip region can be achieved by
  * calling cairo_clip_preserve() within a cairo_save()/cairo_restore()
  * pair. The only other means of increasing the size of the clip
  * region is cairo_reset_clip().
+ *
+ * Since: 1.0
  **/
 void
 cairo_clip_preserve (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_clip (cr->gstate, cr->path);
+    status = cr->backend->clip_preserve (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * Note that code meant to be reusable should not call
  * cairo_reset_clip() as it will cause results unexpected by
  * higher-level code which calls cairo_clip(). Consider using
  * cairo_save() and cairo_restore() around cairo_clip() as a more
  * robust means of temporarily restricting the clip region.
+ *
+ * Since: 1.0
  **/
 void
 cairo_reset_clip (cairo_t *cr)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_reset_clip (cr->gstate);
+    status = cr->backend->reset_clip (cr);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
 void
 cairo_clip_extents (cairo_t *cr,
 		    double *x1, double *y1,
 		    double *x2, double *y2)
+{
-    if (unlikely (cr->status)) {
+    cairo_status_t status;
-	if (x1)
+    if (x1)
-	    *x1 = 0.0;
+	*x1 = 0.0;
-	if (y1)
+    if (y1)
-	    *y1 = 0.0;
+	*y1 = 0.0;
-	if (x2)
+    if (x2)
-	    *x2 = 0.0;
+	*x2 = 0.0;
-	if (y2)
+    if (y2)
-	    *y2 = 0.0;
+	*y2 = 0.0;
     if (unlikely (cr->status))
-	return;
-    }
+	return;
-    if (! _cairo_gstate_clip_extents (cr->gstate, x1, y1, x2, y2)) {
-	*x1 = -INFINITY;
-	*y1 = -INFINITY;
+    status = cr->backend->clip_extents (cr, x1, y1, x2, y2);
-	*x2 = +INFINITY;
-	*y2 = +INFINITY;
+    if (unlikely (status))
 	_cairo_set_error (cr, status);
+}
  * Since: 1.10
  **/
 cairo_bool_t
 cairo_in_clip (cairo_t *cr, double x, double y)
+{
+    cairo_status_t status;
+    cairo_bool_t inside = FALSE;
     if (unlikely (cr->status))
 	return FALSE;
-    return _cairo_gstate_in_clip (cr->gstate, x, y);
-}
-static cairo_rectangle_list_t *
-_cairo_rectangle_list_create_in_error (cairo_status_t status)
-{
-    cairo_rectangle_list_t *list;
-    if (status == CAIRO_STATUS_NO_MEMORY)
-        return (cairo_rectangle_list_t*) &_cairo_rectangles_nil;
-    list = malloc (sizeof (cairo_rectangle_list_t));
+    status = cr->backend->in_clip (cr, x, y, &inside);
-    if (unlikely (list == NULL)) {
+    if (unlikely (status))
-	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-        return (cairo_rectangle_list_t*) &_cairo_rectangles_nil;
-    }
-    list->status = status;
-    list->rectangles = NULL;
+	_cairo_set_error (cr, status);
     list->num_rectangles = 0;
-    return list;
+    return inside;
+}
 cairo_copy_clip_rectangle_list (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return _cairo_rectangle_list_create_in_error (cr->status);
-    return _cairo_gstate_copy_clip_rectangle_list (cr->gstate);
+    return cr->backend->clip_copy_rectangle_list (cr);
+}
 /**
  * Default slant is %CAIRO_FONT_SLANT_NORMAL, and default weight is
  * %CAIRO_FONT_WEIGHT_NORMAL.
+ *
  * This function is equivalent to a call to cairo_toy_font_face_create()
  * followed by cairo_set_font_face().
+ *
+ * Since: 1.0
  **/
 void
 cairo_select_font_face (cairo_t              *cr,
 			const char           *family,
 			cairo_font_slant_t    slant,
 			cairo_font_weight_t   weight)
+{
+    cairo_font_face_t *font_face;
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
+    font_face = cairo_toy_font_face_create (family, slant, weight);
+    if (unlikely (font_face->status)) {
+	_cairo_set_error (cr, font_face->status);
+	return;
+    }
+    status = cr->backend->set_font_face (cr, font_face);
     cairo_font_face_destroy (font_face);
     status = _cairo_gstate_select_font_face (cr->gstate, family, slant, weight);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @cr: a #cairo_t
  * @extents: a #cairo_font_extents_t object into which the results
  * will be stored.
+ *
  * Gets the font extents for the currently selected font.
+ *
+ * Since: 1.0
  **/
 void
 cairo_font_extents (cairo_t              *cr,
 		    cairo_font_extents_t *extents)
+{
     extents->max_y_advance = 0.0;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_get_font_extents (cr->gstate, extents);
+    status = cr->backend->font_extents (cr, extents);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * @font_face: a #cairo_font_face_t, or %NULL to restore to the default font
+ *
  * Replaces the current #cairo_font_face_t object in the #cairo_t with
  * @font_face. The replaced font face in the #cairo_t will be
  * destroyed if there are no other references to it.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_font_face (cairo_t           *cr,
 		     cairo_font_face_t *font_face)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_font_face (cr->gstate, font_face);
+    status = cr->backend->set_font_face (cr, font_face);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
  * cairo_font_face_status() returns %CAIRO_STATUS_NO_MEMORY. Using
  * this nil object will cause its error state to propagate to other
  * objects it is passed to, (for example, calling
  * cairo_set_font_face() with a nil font will trigger an error that
  * will shutdown the #cairo_t object).
+ *
+ * Since: 1.0
  **/
 cairo_font_face_t *
 cairo_get_font_face (cairo_t *cr)
+{
-    cairo_status_t status;
-    cairo_font_face_t *font_face;
     if (unlikely (cr->status))
 	return (cairo_font_face_t*) &_cairo_font_face_nil;
-    status = _cairo_gstate_get_font_face (cr->gstate, &font_face);
-    if (unlikely (status)) {
-	_cairo_set_error (cr, status);
-	return (cairo_font_face_t*) &_cairo_font_face_nil;
-    }
-    return font_face;
+    return cr->backend->get_font_face (cr);
+}
 /**
  * em-square being a @size by @size square in user space.)
+ *
  * If text is drawn without a call to cairo_set_font_size(), (nor
  * cairo_set_font_matrix() nor cairo_set_scaled_font()), the default
  * font size is 10.0.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_font_size (cairo_t *cr, double size)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    status = _cairo_gstate_set_font_size (cr->gstate, size);
+    status = cr->backend->set_font_size (cr, size);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+}
 slim_hidden_def (cairo_set_font_size);
 /**
- * cairo_set_font_matrix
+ * cairo_set_font_matrix:
  * @cr: a #cairo_t
  * @matrix: a #cairo_matrix_t describing a transform to be applied to
  * the current font.
+ *
  * Sets the current font matrix to @matrix. The font matrix gives a
  * transformation from the design space of the font (in this space,
  * the em-square is 1 unit by 1 unit) to user space. Normally, a
+ * simple scale is used (see cairo_set_font_size()), but a more
+ * complex font matrix can be used to shear the font
- * simple scale is used (see cairo_set_font_size()), but a more
+ * or stretch it unequally along the two axes
  * complex font matrix can be used to shear the font
- * or stretch it unequally along the two axes
+ * Since: 1.0
  **/
 void
 cairo_set_font_matrix (cairo_t		    *cr,
 		       const cairo_matrix_t *matrix)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
     status = cr->backend->set_font_matrix (cr, matrix);
-    status = _cairo_gstate_set_font_matrix (cr->gstate, matrix);
+    if (unlikely (status))
-    if (unlikely (status))
+	_cairo_set_error (cr, status);
 	_cairo_set_error (cr, status);
 slim_hidden_def (cairo_set_font_matrix);
 /**
+ * cairo_get_font_matrix:
+ * @cr: a #cairo_t
- * cairo_get_font_matrix
+ * @matrix: return value for the matrix
  * @cr: a #cairo_t
- * @matrix: return value for the matrix
+ * Stores the current font matrix into @matrix. See
  * cairo_set_font_matrix().
  * Stores the current font matrix into @matrix. See
- * cairo_set_font_matrix().
+ * Since: 1.0
  **/
 void
 cairo_get_font_matrix (cairo_t *cr, cairo_matrix_t *matrix)
+{
     if (unlikely (cr->status)) {
 	cairo_matrix_init_identity (matrix);
 	return;
  * Sets a set of custom font rendering options for the #cairo_t.
  * Rendering options are derived by merging these options with the
  * options derived from underlying surface; if the value in @options
  * has a default value (like %CAIRO_ANTIALIAS_DEFAULT), then the value
  * from the surface is used.
+ *
+ * Since: 1.0
  **/
 void
 cairo_set_font_options (cairo_t                    *cr,
 			const cairo_font_options_t *options)
+{
     if (unlikely (status)) {
 	_cairo_set_error (cr, status);
 	return;
+    }
+    status = cr->backend->set_font_options (cr, options);
+    if (unlikely (status))
-    _cairo_gstate_set_font_options (cr->gstate, options);
+	_cairo_set_error (cr, status);
+}
 slim_hidden_def (cairo_set_font_options);
+ *
  * Retrieves font rendering options set via #cairo_set_font_options.
  * Note that the returned options do not include any options derived
  * from the underlying surface; they are literally the options
  * passed to cairo_set_font_options().
+ *
+ * Since: 1.0
  **/
 void
 cairo_get_font_options (cairo_t              *cr,
 			cairo_font_options_t *options)
+{
     if (unlikely (cr->status)) {
 	_cairo_font_options_init_default (options);
 	return;
+    }
-    _cairo_gstate_get_font_options (cr->gstate, options);
+    cr->backend->get_font_options (cr, options);
+}
 /**
 void
 cairo_set_scaled_font (cairo_t                   *cr,
 		       const cairo_scaled_font_t *scaled_font)
+{
     cairo_status_t status;
-    cairo_bool_t was_previous;
     if (unlikely (cr->status))
 	return;
-    if (scaled_font == NULL) {
+    if ((scaled_font == NULL)) {
-	status = _cairo_error (CAIRO_STATUS_NULL_POINTER);
+	_cairo_set_error (cr, _cairo_error (CAIRO_STATUS_NULL_POINTER));
-	goto BAIL;
+	return;
     }
-    status = scaled_font->status;
-    if (unlikely (status))
-        goto BAIL;
+    status = scaled_font->status;
+    if (unlikely (status)) {
-    if (scaled_font == cr->gstate->scaled_font)
-	return;
+	_cairo_set_error (cr, status);
-    was_previous = scaled_font == cr->gstate->previous_scaled_font;
-    status = _cairo_gstate_set_font_face (cr->gstate, scaled_font->font_face);
-    if (unlikely (status))
+	return;
-        goto BAIL;
-    status = _cairo_gstate_set_font_matrix (cr->gstate, &scaled_font->font_matrix);
-    if (unlikely (status))
-        goto BAIL;
-    _cairo_gstate_set_font_options (cr->gstate, &scaled_font->options);
-    if (was_previous)
-	cr->gstate->scaled_font = cairo_scaled_font_reference ((cairo_scaled_font_t *) scaled_font);
+    }
     return;
     status = cr->backend->set_scaled_font (cr, (cairo_scaled_font_t *) scaled_font);
-BAIL:
+    if (unlikely (status))
  * Since: 1.4
  **/
 cairo_scaled_font_t *
 cairo_get_scaled_font (cairo_t *cr)
+{
-    cairo_status_t status;
-    cairo_scaled_font_t *scaled_font;
     if (unlikely (cr->status))
 	return _cairo_scaled_font_create_in_error (cr->status);
-    status = _cairo_gstate_get_scaled_font (cr->gstate, &scaled_font);
-    if (unlikely (status)) {
-	_cairo_set_error (cr, status);
-	return _cairo_scaled_font_create_in_error (status);
-    }
-    return scaled_font;
+    return cr->backend->get_scaled_font (cr);
+}
 slim_hidden_def (cairo_get_scaled_font);
 /**
  * cairo_text_extents:
  * size of the rectangle (extents.width and extents.height). They do
  * contribute indirectly by changing the position of non-whitespace
  * characters. In particular, trailing whitespace characters are
  * likely to not affect the size of the rectangle, though they will
  * affect the x_advance and y_advance values.
+ *
+ * Since: 1.0
  **/
 void
 cairo_text_extents (cairo_t              *cr,
 		    const char		 *utf8,
 		    cairo_text_extents_t *extents)
+{
     cairo_status_t status;
+    cairo_scaled_font_t *scaled_font;
     cairo_glyph_t *glyphs = NULL;
-    int num_glyphs;
+    int num_glyphs = 0;
     double x, y;
     extents->x_bearing = 0.0;
     extents->y_bearing = 0.0;
 	return;
     if (utf8 == NULL)
 	return;
+    scaled_font = cairo_get_scaled_font (cr);
+    if (unlikely (scaled_font->status)) {
+	_cairo_set_error (cr, scaled_font->status);
+	return;
+    }
     cairo_get_current_point (cr, &x, &y);
+    cairo_get_current_point (cr, &x, &y);
-    status = _cairo_gstate_text_to_glyphs (cr->gstate,
+    status = cairo_scaled_font_text_to_glyphs (scaled_font,
-					   x, y,
+					       x, y,
-					   utf8, strlen (utf8),
-					   &glyphs, &num_glyphs,
+					       utf8, -1,
-					   NULL, NULL,
+					       &glyphs, &num_glyphs,
-					   NULL);
+					       NULL, NULL, NULL);
+    if (likely (status == CAIRO_STATUS_SUCCESS)) {
-    if (status == CAIRO_STATUS_SUCCESS)
+	status = cr->backend->glyph_extents (cr,
-	status = _cairo_gstate_glyph_extents (cr->gstate,
+					     glyphs, num_glyphs,
-		                              glyphs, num_glyphs,
+					     extents);
 					      extents);
  * amount by which the current point would be advanced by
  * cairo_show_glyphs().
+ *
  * Note that whitespace glyphs do not contribute to the size of the
  * rectangle (extents.width and extents.height).
+ *
+ * Since: 1.0
  **/
 void
 cairo_glyph_extents (cairo_t                *cr,
 		     const cairo_glyph_t    *glyphs,
 		     int                    num_glyphs,
 	return;
     if (num_glyphs == 0)
 	return;
-    if (num_glyphs < 0) {
+    if (unlikely (num_glyphs < 0)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
 	return;
+    }
-    if (glyphs == NULL) {
+    if (unlikely (glyphs == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
-	return;
 	return;
+    }
     status = _cairo_gstate_glyph_extents (cr->gstate, glyphs, num_glyphs,
-					  extents);
+    status = cr->backend->glyph_extents (cr, glyphs, num_glyphs, extents);
  * Note: The cairo_show_text() function call is part of what the cairo
  * designers call the "toy" text API. It is convenient for short demos
  * and simple programs, but it is not expected to be adequate for
  * serious text-using applications. See cairo_show_glyphs() for the
  * "real" text display API in cairo.
+ *
+ * Since: 1.0
  **/
 void
 cairo_show_text (cairo_t *cr, const char *utf8)
+{
     cairo_text_extents_t extents;
     cairo_text_cluster_flags_t cluster_flags;
     double x, y;
     cairo_bool_t has_show_text_glyphs;
     cairo_glyph_t stack_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
     cairo_text_cluster_t stack_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)];
+    cairo_scaled_font_t *scaled_font;
+    cairo_glyph_text_info_t info, *i;
     if (unlikely (cr->status))
 	return;
     if (utf8 == NULL)
+	return;
+    scaled_font = cairo_get_scaled_font (cr);
+    if (unlikely (scaled_font->status)) {
-	return;
+	_cairo_set_error (cr, scaled_font->status);
 	return;
     cairo_get_current_point (cr, &x, &y);
     } else {
 	clusters = NULL;
 	num_clusters = 0;
+    }
+    cairo_get_current_point (cr, &x, &y);
-    status = _cairo_gstate_text_to_glyphs (cr->gstate,
+    status = cairo_scaled_font_text_to_glyphs (scaled_font,
-					   x, y,
+					       x, y,
-					   utf8, utf8_len,
+					       utf8, utf8_len,
-					   &glyphs, &num_glyphs,
+					       &glyphs, &num_glyphs,
-					   has_show_text_glyphs ? &clusters : NULL, &num_clusters,
+					       has_show_text_glyphs ? &clusters : NULL, &num_clusters,
 	goto BAIL;
     if (num_glyphs == 0)
+	return;
-	return;
+    i = NULL;
+    if (has_show_text_glyphs) {
-    status = _cairo_gstate_show_text_glyphs (cr->gstate,
+	info.utf8 = utf8;
-					     utf8, utf8_len,
+	info.utf8_len = utf8_len;
-					     glyphs, num_glyphs,
+	info.clusters = clusters;
+	info.num_clusters = num_clusters;
+	info.cluster_flags = cluster_flags;
+	i = &info;
+    }
 					     clusters, num_clusters,
-					     cluster_flags);
+    status = cr->backend->glyphs (cr, glyphs, num_glyphs, i);
     if (unlikely (status))
 	goto BAIL;
-    last_glyph = &glyphs[num_glyphs - 1];
     status = _cairo_gstate_glyph_extents (cr->gstate,
-					  last_glyph, 1,
+    last_glyph = &glyphs[num_glyphs - 1];
-					  &extents);
+    status = cr->backend->glyph_extents (cr, last_glyph, 1, &extents);
     if (unlikely (status))
 	goto BAIL;
     x = last_glyph->x + extents.x_advance;
     y = last_glyph->y + extents.y_advance;
-    cairo_move_to (cr, x, y);
+    cr->backend->move_to (cr, x, y);
  * @num_glyphs: number of glyphs to show
+ *
  * A drawing operator that generates the shape from an array of glyphs,
  * rendered according to the current font face, font size
  * (font matrix), and font options.
+ *
+ * Since: 1.0
  **/
 void
 cairo_show_glyphs (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)
+{
     cairo_status_t status;
     if (glyphs == NULL) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
 	return;
+    }
-    status = _cairo_gstate_show_text_glyphs (cr->gstate,
-					     NULL, 0,
-					     glyphs, num_glyphs,
-					     NULL, 0,
-					     FALSE);
+    status = cr->backend->glyphs (cr, glyphs, num_glyphs, NULL);
     if (unlikely (status))
 	_cairo_set_error (cr, status);
+}
     if (num_glyphs < 0 || utf8_len < 0 || num_clusters < 0) {
 	_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
 	return;
+    }
+    if (num_glyphs == 0 && utf8_len == 0)
+	return;
     if (utf8) {
-    /* Make sure clusters cover the entire glyphs and utf8 arrays,
+	/* Make sure clusters cover the entire glyphs and utf8 arrays,
-     * and that cluster boundaries are UTF-8 boundaries. */
+	 * and that cluster boundaries are UTF-8 boundaries. */
-    status = _cairo_validate_text_clusters (utf8, utf8_len,
+	status = _cairo_validate_text_clusters (utf8, utf8_len,
-					    glyphs, num_glyphs,
+						glyphs, num_glyphs,
-	cairo_status_t status2;
+	    cairo_status_t status2;
-	status2 = _cairo_utf8_to_ucs4 (utf8, utf8_len, NULL, NULL);
+	    status2 = _cairo_utf8_to_ucs4 (utf8, utf8_len, NULL, NULL);
-	if (status2)
+	    if (status2)
+		status = status2;
+	} else {
-	    status = status2;
+	    cairo_glyph_text_info_t info;
-	_cairo_set_error (cr, status);
+	    info.utf8 = utf8;
-	return;
-    }
+	    info.utf8_len = utf8_len;
+	    info.clusters = clusters;
-    if (num_glyphs == 0 && utf8_len == 0)
+	    info.num_clusters = num_clusters;
+	    info.cluster_flags = cluster_flags;
-	return;
+	    status = cr->backend->glyphs (cr, glyphs, num_glyphs, &info);
-    status = _cairo_gstate_show_text_glyphs (cr->gstate,
+	}
-					     utf8, utf8_len,
+    } else {
-					     glyphs, num_glyphs,
+	status = cr->backend->glyphs (cr, glyphs, num_glyphs, NULL);
 					     clusters, num_clusters, cluster_flags);
     if (unlikely (status))
  * Note: The cairo_text_path() function call is part of what the cairo
  * designers call the "toy" text API. It is convenient for short demos
  * and simple programs, but it is not expected to be adequate for
  * serious text-using applications. See cairo_glyph_path() for the
  * "real" text path API in cairo.
+ *
+ * Since: 1.0
  **/
 void
-cairo_text_path  (cairo_t *cr, const char *utf8)
+cairo_text_path (cairo_t *cr, const char *utf8)
+{
     cairo_status_t status;
     cairo_text_extents_t extents;
     cairo_glyph_t stack_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
     cairo_glyph_t *glyphs, *last_glyph;
+    cairo_scaled_font_t *scaled_font;
     int num_glyphs;
     double x, y;
     if (unlikely (cr->status))
 	return;
-    if (utf8 == NULL)
-	return;
+    if (utf8 == NULL)
 	return;
+    glyphs = stack_glyphs;
+    num_glyphs = ARRAY_LENGTH (stack_glyphs);
+    scaled_font = cairo_get_scaled_font (cr);
+    if (unlikely (scaled_font->status)) {
-    cairo_get_current_point (cr, &x, &y);
+	_cairo_set_error (cr, scaled_font->status);
 	return;
-    glyphs = stack_glyphs;
+    }
     num_glyphs = ARRAY_LENGTH (stack_glyphs);
+    cairo_get_current_point (cr, &x, &y);
-    status = _cairo_gstate_text_to_glyphs (cr->gstate,
-					   x, y,
-					   utf8, strlen (utf8),
-					   &glyphs, &num_glyphs,
-					   NULL, NULL,
+    status = cairo_scaled_font_text_to_glyphs (scaled_font,
-					   NULL);
+					       x, y,
+					       utf8, -1,
-    if (unlikely (status))
-	goto BAIL;
 					       &glyphs, &num_glyphs,
-    if (num_glyphs == 0)
+					       NULL, NULL, NULL);
 	return;
+    if (num_glyphs == 0)
-    status = _cairo_gstate_glyph_path (cr->gstate,
-				       glyphs, num_glyphs,
-				       cr->path);
+	return;
-    if (unlikely (status))
+    status = cr->backend->glyph_path (cr, glyphs, num_glyphs);
 	goto BAIL;
+    if (unlikely (status))
-    last_glyph = &glyphs[num_glyphs - 1];
+	goto BAIL;
     status = _cairo_gstate_glyph_extents (cr->gstate,
-					  last_glyph, 1,
+    last_glyph = &glyphs[num_glyphs - 1];
  * @num_glyphs: number of glyphs to show
+ *
  * Adds closed paths for the glyphs to the current path.  The generated
  * path if filled, achieves an effect similar to that of
  * cairo_show_glyphs().
+ *
+ * Since: 1.0
  **/
 void
 cairo_glyph_path (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)
+{
     cairo_status_t status;
 	return;
     if (num_glyphs == 0)
 	return;
-    if (num_glyphs < 0) {
+    if (unlikely (num_glyphs < 0)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NEGATIVE_COUNT);
 	return;
+    }
-    if (glyphs == NULL) {
+    if (unlikely (glyphs == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
-	return;
-    }
 	return;
     status = _cairo_gstate_glyph_path (cr->gstate,
 				       glyphs, num_glyphs,
-				       cr->path);
+    status = cr->backend->glyph_path (cr, glyphs, num_glyphs);
  * @cr: a cairo context
+ *
  * Gets the current compositing operator for a cairo context.
+ *
  * Return value: the current compositing operator.
+ *
+ * Since: 1.0
  **/
 cairo_operator_t
 cairo_get_operator (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_OPERATOR_DEFAULT;
+    return cr->backend->get_operator (cr);
+}
+#if 0
+/**
+ * cairo_get_opacity:
+ * @cr: a cairo context
+ *
+ * Gets the current compositing opacity for a cairo context.
+ *
+ * Return value: the current compositing opacity.
+ *
+ * Since: TBD
+ **/
+double
+cairo_get_opacity (cairo_t *cr)
+{
+    if (unlikely (cr->status))
+        return 1.;
-    return _cairo_gstate_get_operator (cr->gstate);
+    return cr->backend->get_opacity (cr);
+}
 #endif
 /**
  * cairo_get_tolerance:
  * @cr: a cairo context
+ *
  * Gets the current tolerance value, as set by cairo_set_tolerance().
+ *
+ * Return value: the current tolerance value.
+ *
- * Return value: the current tolerance value.
+ * Since: 1.0
  **/
 double
 cairo_get_tolerance (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_TOLERANCE_DEFAULT;
-    return _cairo_gstate_get_tolerance (cr->gstate);
+    return cr->backend->get_tolerance (cr);
+}
 slim_hidden_def (cairo_get_tolerance);
 /**
+ * cairo_get_antialias:
- * cairo_get_antialias:
+ * @cr: a cairo context
  * @cr: a cairo context
+ * Gets the current shape antialiasing mode, as set by
+ * cairo_set_antialias().
+ *
- * Gets the current shape antialiasing mode, as set by cairo_set_shape_antialias().
+ * Return value: the current shape antialiasing mode.
+ *
- * Return value: the current shape antialiasing mode.
+ * Since: 1.0
  **/
 cairo_antialias_t
 cairo_get_antialias (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_ANTIALIAS_DEFAULT;
 cairo_has_current_point (cairo_t *cr)
+{
     if (unlikely (cr->status))
-    return FALSE;
+	return FALSE;
-    return cr->path->has_current_point;
+    return cr->backend->has_current_point (cr);
+}
 /**
  * otherwise change current path:
  * cairo_show_text().
+ *
  * Some functions unset the current path and as a result, current point:
  * cairo_fill(), cairo_stroke().
+ *
+ * Since: 1.0
  **/
 void
 cairo_get_current_point (cairo_t *cr, double *x_ret, double *y_ret)
+{
-    cairo_fixed_t x_fixed, y_fixed;
     double x, y;
     x = y = 0;
     if (cr->status == CAIRO_STATUS_SUCCESS &&
-	_cairo_path_fixed_get_current_point (cr->path, &x_fixed, &y_fixed))
-    {
-	x = _cairo_fixed_to_double (x_fixed);
-	y = _cairo_fixed_to_double (y_fixed);
-	_cairo_gstate_backend_to_user (cr->gstate, &x, &y);
-    }
-    else
+	cr->backend->has_current_point (cr))
-    {
-	x = 0.0;
+    {
-	y = 0.0;
+	cr->backend->get_current_point (cr, &x, &y);
+    }
     if (x_ret)
  * @cr: a cairo context
+ *
  * Gets the current fill rule, as set by cairo_set_fill_rule().
+ *
  * Return value: the current fill rule.
+ *
+ * Since: 1.0
  **/
 cairo_fill_rule_t
 cairo_get_fill_rule (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_FILL_RULE_DEFAULT;
-    return _cairo_gstate_get_fill_rule (cr->gstate);
+    return cr->backend->get_fill_rule (cr);
+}
 /**
  * cairo_set_line_width(). Note that the value is unchanged even if
  * the CTM has changed between the calls to cairo_set_line_width() and
  * cairo_get_line_width().
+ *
  * Return value: the current line width.
+ *
+ * Since: 1.0
  **/
 double
 cairo_get_line_width (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_LINE_WIDTH_DEFAULT;
-    return _cairo_gstate_get_line_width (cr->gstate);
+    return cr->backend->get_line_width (cr);
+}
 slim_hidden_def (cairo_get_line_width);
 /**
  * cairo_get_line_cap:
  * @cr: a cairo context
+ *
  * Gets the current line cap style, as set by cairo_set_line_cap().
+ *
+ * Return value: the current line cap style.
+ *
- * Return value: the current line cap style.
+ * Since: 1.0
  **/
 cairo_line_cap_t
 cairo_get_line_cap (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_LINE_CAP_DEFAULT;
-    return _cairo_gstate_get_line_cap (cr->gstate);
+    return cr->backend->get_line_cap (cr);
+}
 /**
  * cairo_get_line_join:
  * @cr: a cairo context
+ *
+ * Gets the current line join style, as set by cairo_set_line_join().
+ *
- * Gets the current line join style, as set by cairo_set_line_join().
+ * Return value: the current line join style.
+ *
- * Return value: the current line join style.
+ * Since: 1.0
  **/
 cairo_line_join_t
 cairo_get_line_join (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_LINE_JOIN_DEFAULT;
-    return _cairo_gstate_get_line_join (cr->gstate);
+    return cr->backend->get_line_join (cr);
+}
 /**
+ * cairo_get_miter_limit:
+ * @cr: a cairo context
  * cairo_get_miter_limit:
- * @cr: a cairo context
+ * Gets the current miter limit, as set by cairo_set_miter_limit().
+ *
- * Gets the current miter limit, as set by cairo_set_miter_limit().
+ * Return value: the current miter limit.
+ *
- * Return value: the current miter limit.
+ * Since: 1.0
  **/
 double
 cairo_get_miter_limit (cairo_t *cr)
+{
     if (unlikely (cr->status))
         return CAIRO_GSTATE_MITER_LIMIT_DEFAULT;
-    return _cairo_gstate_get_miter_limit (cr->gstate);
+    return cr->backend->get_miter_limit (cr);
+}
 /**
  * cairo_get_matrix:
-/**
+ * @cr: a cairo context
- * cairo_get_matrix:
+ * @matrix: return value for the matrix
  * @cr: a cairo context
- * @matrix: return value for the matrix
+ * Stores the current transformation matrix (CTM) into @matrix.
+ *
- * Stores the current transformation matrix (CTM) into @matrix.
+ * Since: 1.0
  **/
 void
 cairo_get_matrix (cairo_t *cr, cairo_matrix_t *matrix)
+{
     if (unlikely (cr->status)) {
  * A nil surface is indicated by cairo_surface_status()
  * != %CAIRO_STATUS_SUCCESS.
+ *
  * Return value: the target surface. This object is owned by cairo. To
  * keep a reference to it, you must call cairo_surface_reference().
+ *
+ * Since: 1.0
  **/
 cairo_surface_t *
 cairo_get_target (cairo_t *cr)
+{
     if (unlikely (cr->status))
 	return _cairo_surface_create_in_error (cr->status);
-    return _cairo_gstate_get_original_target (cr->gstate);
+    return cr->backend->get_original_target (cr);
+}
 slim_hidden_def (cairo_get_target);
 cairo_get_group_target (cairo_t *cr)
+{
     if (unlikely (cr->status))
 	return _cairo_surface_create_in_error (cr->status);
-    return _cairo_gstate_get_target (cr->gstate);
+    return cr->backend->get_current_target (cr);
+}
 /**
+ *
+ *
  * Return value: the copy of the current path. The caller owns the
  * returned object and should call cairo_path_destroy() when finished
  * with it.
+ *
+ * Since: 1.0
  **/
 cairo_path_t *
 cairo_copy_path (cairo_t *cr)
+{
     if (unlikely (cr->status))
 	return _cairo_path_create_in_error (cr->status);
-    return _cairo_path_create (cr->path, cr->gstate);
+    return cr->backend->copy_path (cr);
+}
 /**
+ *
+ *
  * Return value: the copy of the current path. The caller owns the
  * returned object and should call cairo_path_destroy() when finished
  * with it.
+ *
+ * Since: 1.0
  **/
 cairo_path_t *
 cairo_copy_path_flat (cairo_t *cr)
+{
     if (unlikely (cr->status))
 	return _cairo_path_create_in_error (cr->status);
-    return _cairo_path_create_flat (cr->path, cr->gstate);
+    return cr->backend->copy_path_flat (cr);
+}
 /**
  * return value from one of cairo_copy_path() or
  * cairo_copy_path_flat() or it may be constructed manually.  See
  * #cairo_path_t for details on how the path data structure should be
  * initialized, and note that path->status must be
  * initialized to %CAIRO_STATUS_SUCCESS.
+ *
+ * Since: 1.0
  **/
 void
 cairo_append_path (cairo_t		*cr,
 		   const cairo_path_t	*path)
+{
     cairo_status_t status;
     if (unlikely (cr->status))
 	return;
-    if (path == NULL) {
+    if (unlikely (path == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
 	return;
+    }
-    if (path->status) {
+    if (unlikely (path->status)) {
 	if (path->status > CAIRO_STATUS_SUCCESS &&
 	    path->status <= CAIRO_STATUS_LAST_STATUS)
+    }
     if (path->num_data == 0)
 	return;
-    if (path->data == NULL) {
+    if (unlikely (path->data == NULL)) {
 	_cairo_set_error (cr, CAIRO_STATUS_NULL_POINTER);
 	return;
+    }
-    status = _cairo_path_append_to_context (path, cr);
+    status = cr->backend->append_path (cr, path);
     if (unlikely (status))
  * @cr: a cairo context
+ *
  * Checks whether an error has previously occurred for this context.
+ *
  * Returns: the current status of this context, see #cairo_status_t
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_status (cairo_t *cr)
+{
     return cr->status;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo.c – Rev 1892 → 3959