/* cairo - a vector graphics library with display and print output
 *
 * 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
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.og/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * Contributor(s):
 *      Robert Bragg <robert@linux.intel.com>
 */

/* so long as we can verify that the ctm doesn't change multiple times
 * during the construction of a path we can build a shadow
 * #cairo_path_fixed_t in user coordinates that we can use to create a
 * hash value for caching tessellations of that path.
 *
 * We need to hook into all the points where the ctm can be changed
 * so we can bump a cr->path_ctm_age counter.
 *
 * We need to hook into all the points where the path can be modified
 * so we can catch the start of a path and reset the cr->path_ctm_age
 * counter at that point.
 *
 * When a draw operation is hit we can then check that the
 * path_ctm_age == 0 and if so we create a hash of the path.
 *
 * We use this hash to lookup a #cairo_cogl_path_meta_t struct which
 * may contain tessellated triangles for the path or may just contain
 * a count of how many times the path has been re-seen (we only cache
 * tessellated triangles if there is evidence that the path is being
 * used multiple times because there is a cost involved in allocating
 * a separate buffer for the triangles).
 */

#include "cairoint.h"

#include "cairo-cogl-context-private.h"
#include "cairo-freed-pool-private.h"
#include "cairo-arc-private.h"
#include "cairo-path-fixed-private.h"

#include <glib.h>

static freed_pool_t context_pool;

void
_cairo_cogl_context_reset_static_data (void)
{
    _freed_pool_reset (&context_pool);
}

static cairo_status_t
_cairo_cogl_context_rectangle_real (cairo_cogl_context_t *cr,
				    double x, double y,
				    double width, double height)
{
    cairo_status_t status;
    status = cr->dev->backend_parent.rectangle (cr, x, y, width, height);
    if (unlikely (status))
	return status;

    return _cairo_cogl_path_fixed_rectangle (&cr->user_path,
					     _cairo_fixed_from_double (x),
					     _cairo_fixed_from_double (y),
					     _cairo_fixed_from_double (width),
					     _cairo_fixed_from_double (height));
}

/* The idea here is that we have a simplified way of tracking rectangle paths
 * because rectangles are perhaps the most common shape drawn with cairo.
 *
 * Basically we have a speculative store for a rectangle path that doesn't
 * need to use the #cairo_path_fixed_t api to describe a rectangle in terms of
 * (move_to,rel_line_to,rel_line_to,_rel_line_to,close) because if you profile
 * heavy rectangle drawing with Cairo that process can be overly expensive.
 *
 * If the user asks to add more than just a rectangle to their current path
 * then we "flush" any speculative rectangle stored into the current path
 * before continuing to append their operations.
 *
 * In addition to the speculative store cairo-cogl also has a fast-path
 * fill_rectangle drawing operation that further aims to minimize the cost
 * of drawing rectangles.
 */
static cairo_status_t
_flush_cr_rectangle (cairo_cogl_context_t *cr)
{
    if (!cr->path_is_rectangle)
	return CAIRO_STATUS_SUCCESS;

    cr->path_is_rectangle = FALSE;
    return _cairo_cogl_context_rectangle_real (cr, cr->x, cr->y, cr->width, cr->height);
}

static cairo_status_t
_cairo_cogl_context_restore (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.restore (abstract_cr);
}

static cairo_status_t
_cairo_cogl_context_translate (void *abstract_cr, double tx, double ty)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.translate (abstract_cr, tx, ty);
}

static cairo_status_t
_cairo_cogl_context_scale (void *abstract_cr, double sx, double sy)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.scale (abstract_cr, sx, sy);
}

static cairo_status_t
_cairo_cogl_context_rotate (void *abstract_cr, double theta)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.rotate (abstract_cr, theta);
}

static cairo_status_t
_cairo_cogl_context_transform (void *abstract_cr, const cairo_matrix_t *matrix)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.transform (abstract_cr, matrix);
}

static cairo_status_t
_cairo_cogl_context_set_matrix (void *abstract_cr, const cairo_matrix_t *matrix)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.set_matrix (abstract_cr, matrix);
}

static cairo_status_t
_cairo_cogl_context_set_identity_matrix (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    cr->path_ctm_age++;
    return cr->dev->backend_parent.set_identity_matrix (abstract_cr);
}

static cairo_status_t
_cairo_cogl_context_new_path (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.new_path (abstract_cr);
    if (unlikely (status))
	return status;

    _cairo_path_fixed_fini (&cr->user_path);
    _cairo_path_fixed_init (&cr->user_path);
    cr->path_is_rectangle = FALSE;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_new_sub_path (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.new_sub_path (abstract_cr);
    if (unlikely (status))
	return status;

    _cairo_path_fixed_new_sub_path (&cr->user_path);

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_move_to (void *abstract_cr, double x, double y)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_fixed_t x_fixed, y_fixed;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.move_to (abstract_cr, x, y);
    if (unlikely (status))
	return status;

    x_fixed = _cairo_fixed_from_double (x);
    y_fixed = _cairo_fixed_from_double (y);

    return _cairo_path_fixed_move_to (&cr->user_path, x_fixed, y_fixed);
}

static cairo_status_t
_cairo_cogl_context_line_to (void *abstract_cr, double x, double y)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_fixed_t x_fixed, y_fixed;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.line_to (abstract_cr, x, y);
    if (unlikely (status))
	return status;

    x_fixed = _cairo_fixed_from_double (x);
    y_fixed = _cairo_fixed_from_double (y);

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    return _cairo_path_fixed_line_to (&cr->user_path, x_fixed, y_fixed);
}

static cairo_status_t
_cairo_cogl_context_curve_to (void *abstract_cr,
			       double x1, double y1,
			       double x2, double y2,
			       double x3, double y3)
{
    cairo_cogl_context_t *cr = abstract_cr;
    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 (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.curve_to (abstract_cr, x1, y1, x2, y2, x3, y3);
    if (unlikely (status))
	return status;

    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);

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    return _cairo_path_fixed_curve_to (&cr->user_path,
				       x1_fixed, y1_fixed,
				       x2_fixed, y2_fixed,
				       x3_fixed, y3_fixed);
}

static cairo_status_t
_cairo_cogl_context_arc (void *abstract_cr,
			  double xc, double yc, double radius,
			  double angle1, double angle2,
			  cairo_bool_t forward)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.arc (abstract_cr, xc, yc, radius, angle1, angle2, forward);
    if (unlikely (status))
	return status;

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    /* Do nothing, successfully, if radius is <= 0 */
    if (radius <= 0.0) {
	cairo_fixed_t x_fixed, y_fixed;

	x_fixed = _cairo_fixed_from_double (xc);
	y_fixed = _cairo_fixed_from_double (yc);
	status = _cairo_path_fixed_line_to (&cr->user_path, x_fixed, y_fixed);
	if (unlikely (status))
	    return status;

	status = _cairo_path_fixed_line_to (&cr->user_path, x_fixed, y_fixed);
	if (unlikely (status))
	    return status;

	return CAIRO_STATUS_SUCCESS;
    }

    status = _cairo_cogl_context_line_to (cr,
					  xc + radius * cos (angle1),
					  yc + radius * sin (angle1));

    if (unlikely (status))
	return status;

    if (forward)
	_cairo_arc_path (&cr->base.base, xc, yc, radius, angle1, angle2);
    else
	_cairo_arc_path_negative (&cr->base.base, xc, yc, radius, angle1, angle2);

    return CAIRO_STATUS_SUCCESS; /* any error will have already been set on cr */
}

static cairo_status_t
_cairo_cogl_context_rel_move_to (void *abstract_cr, double dx, double dy)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_fixed_t dx_fixed, dy_fixed;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.rel_move_to (abstract_cr, dx, dy);
    if (unlikely (status))
	return status;

    dx_fixed = _cairo_fixed_from_double (dx);
    dy_fixed = _cairo_fixed_from_double (dy);

    return _cairo_path_fixed_rel_move_to (&cr->user_path, dx_fixed, dy_fixed);
}

static cairo_status_t
_cairo_cogl_context_rel_line_to (void *abstract_cr, double dx, double dy)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_fixed_t dx_fixed, dy_fixed;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.rel_line_to (abstract_cr, dx, dy);
    if (unlikely (status))
	return status;

    dx_fixed = _cairo_fixed_from_double (dx);
    dy_fixed = _cairo_fixed_from_double (dy);

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    return _cairo_path_fixed_rel_line_to (&cr->user_path, dx_fixed, dy_fixed);
}


static cairo_status_t
_cairo_cogl_context_rel_curve_to (void *abstract_cr,
				   double dx1, double dy1,
				   double dx2, double dy2,
				   double dx3, double dy3)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_fixed_t dx1_fixed, dy1_fixed;
    cairo_fixed_t dx2_fixed, dy2_fixed;
    cairo_fixed_t dx3_fixed, dy3_fixed;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.rel_curve_to (abstract_cr, dx1, dy1, dx2, dy2, dx3, dy3);
    if (unlikely (status))
	return status;

    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);

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    return _cairo_path_fixed_rel_curve_to (&cr->user_path,
					   dx1_fixed, dy1_fixed,
					   dx2_fixed, dy2_fixed,
					   dx3_fixed, dy3_fixed);
}

#if 0
static cairo_status_t
_cairo_cogl_context_arc_to (void *abstract_cr,
			    double x1, double y1,
			    double x2, double y2,
			    double radius)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.arc_to (abstract_cr, x1, y1, x2, y2, radius);
    if (unlikely (status))
	return status;
#warning "FIXME"
}

static cairo_status_t
_cairo_cogl_rel_arc_to (void *cr,
			double dx1, double dy1,
			double dx2, double dy2,
			double radius)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.rel_arc_to (abstract_cr, dx1, dy2, dx2, dy2, radius);
    if (unlikely (status))
	return status;
#warning "FIXME"
}
#endif

static cairo_status_t
_cairo_cogl_context_close_path (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    if (cr->path_is_rectangle) {
	status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    status = cr->dev->backend_parent.close_path (abstract_cr);
    if (unlikely (status))
	return status;

    if (cr->user_path.buf.base.num_ops == 0)
	cr->path_ctm_age = 0;

    return _cairo_path_fixed_close_path (&cr->user_path);
}

static cairo_status_t
_cairo_cogl_context_rectangle (void *abstract_cr,
			       double x, double y,
			       double width, double height)
{
    cairo_cogl_context_t *cr = abstract_cr;

    if (cr->user_path.buf.base.num_ops == 0) {
	cr->path_ctm_age = 0;

#if 1
	/* XXX: Since drawing rectangles is so common we have a
	 * fast-path for drawing a single rectangle. */
	cr->x = x;
	cr->y = y;
	cr->width = width;
	cr->height = height;
	cr->path_is_rectangle = TRUE;
	return CAIRO_STATUS_SUCCESS;
#endif
    }

    if (cr->path_is_rectangle) {
	cairo_status_t status = _flush_cr_rectangle (cr);
	if (unlikely (status))
	    return status;
    }

    return _cairo_cogl_context_rectangle_real (cr, x, y, width, height);
}

/* Since the surface backend drawing operator functions don't get
 * passed the current #cairo_t context we don't have a good way
 * to get our user-coordinates path into our surface operator
 * functions.
 *
 * For now we use this function to set side band data on the surface
 * itself.
 */
static void
_cairo_cogl_surface_set_side_band_state (cairo_cogl_surface_t *surface,
					 cairo_cogl_context_t *cr)
{

    if (cr->path_ctm_age <= 1) {
	surface->user_path = &cr->user_path;
	surface->ctm = &cr->base.gstate->ctm;
	surface->ctm_inverse = &cr->base.gstate->ctm_inverse;
	surface->path_is_rectangle = cr->path_is_rectangle;
	if (surface->path_is_rectangle) {
	    surface->path_rectangle_x = cr->x;
	    surface->path_rectangle_y = cr->y;
	    surface->path_rectangle_width = cr->width;
	    surface->path_rectangle_height = cr->height;
	}
    } else {
	surface->user_path = NULL;
	surface->path_is_rectangle = FALSE;
    }
}

static cairo_status_t
_cairo_cogl_context_fill (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)cr->base.gstate->target;

    if (cr->path_is_rectangle) {
	status = _cairo_cogl_surface_fill_rectangle (cr->base.gstate->target,
						     cr->base.gstate->op,
						     cr->base.gstate->source,
						     cr->x,
						     cr->y,
						     cr->width,
						     cr->height,
						     &cr->base.gstate->ctm,
						     cr->base.gstate->clip);
	if (status == CAIRO_STATUS_SUCCESS)
	    goto DONE;
	_flush_cr_rectangle (cr);
    }

    _cairo_cogl_surface_set_side_band_state (surface, cr);

    status = cr->dev->backend_parent.fill (abstract_cr);
    if (unlikely (status))
	return status;

DONE:
    _cairo_path_fixed_fini (&cr->user_path);
    _cairo_path_fixed_init (&cr->user_path);
    cr->path_is_rectangle = FALSE;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_fill_preserve (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)cr->base.gstate->target;

    _cairo_cogl_surface_set_side_band_state (surface, cr);

    status = cr->dev->backend_parent.fill_preserve (abstract_cr);
    if (unlikely (status))
	return status;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_stroke (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)cr->base.gstate->target;

    _cairo_cogl_surface_set_side_band_state (surface, cr);

    status = cr->dev->backend_parent.stroke (abstract_cr);
    if (unlikely (status))
	return status;

    _cairo_path_fixed_fini (&cr->user_path);
    _cairo_path_fixed_init (&cr->user_path);
    cr->path_is_rectangle = FALSE;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_stroke_preserve (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;
    cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)cr->base.gstate->target;

    _cairo_cogl_surface_set_side_band_state (surface, cr);

    status = cr->dev->backend_parent.stroke_preserve (abstract_cr);
    if (unlikely (status))
	return status;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t
_cairo_cogl_context_clip (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;
    cairo_status_t status;

    status = cr->dev->backend_parent.clip (abstract_cr);
    if (unlikely (status))
	return status;

    _cairo_path_fixed_fini (&cr->user_path);
    _cairo_path_fixed_init (&cr->user_path);
    cr->path_is_rectangle = FALSE;

    return CAIRO_STATUS_SUCCESS;
}

static void
_cairo_cogl_context_destroy (void *abstract_cr)
{
    cairo_cogl_context_t *cr = abstract_cr;

    _cairo_default_context_fini (&cr->base);

    _cairo_path_fixed_fini (&cr->user_path);

    /* mark the context as invalid to protect against misuse */
    cr->base.base.status = CAIRO_STATUS_NULL_POINTER;
    _freed_pool_put (&context_pool, cr);
}

/* We want to hook into the frontend of the path construction APIs so
 * we can build up a path description in user coordinates instead of
 * backend coordinates so that we can recognize user coordinate
 * rectangles and so we can hash a user path independent of its
 * transform. (With some care to catch unusual cases where the ctm
 * changes mid-path) */
cairo_t *
_cairo_cogl_context_create (void *target)
{
    cairo_cogl_surface_t *surface = target;
    cairo_cogl_context_t *cr;
    cairo_status_t status;

    cr = _freed_pool_get (&context_pool);
    if (unlikely (cr == NULL)) {
	cr = _cairo_malloc (sizeof (cairo_cogl_context_t));
	if (unlikely (cr == NULL))
	    return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
    }

    status = _cairo_default_context_init (&cr->base, target);
    if (unlikely (status)) {
	_freed_pool_put (&context_pool, cr);
	return _cairo_create_in_error (status);
    }

    cr->dev = (cairo_cogl_device_t *)surface->base.device;

    if (unlikely (cr->dev->backend_vtable_initialized == FALSE)) {
	cairo_backend_t *backend = &cr->dev->backend;
	memcpy (backend, cr->base.base.backend, sizeof (cairo_backend_t));
	memcpy (&cr->dev->backend_parent, cr->base.base.backend, sizeof (cairo_backend_t));

	backend->destroy = _cairo_cogl_context_destroy;

	backend->restore = _cairo_cogl_context_restore;
	backend->translate = _cairo_cogl_context_translate;
	backend->scale = _cairo_cogl_context_scale;
	backend->rotate = _cairo_cogl_context_rotate;
	backend->transform = _cairo_cogl_context_transform;
	backend->set_matrix = _cairo_cogl_context_set_matrix;
	backend->set_identity_matrix = _cairo_cogl_context_set_identity_matrix;

	backend->new_path = _cairo_cogl_context_new_path;
	backend->new_sub_path = _cairo_cogl_context_new_sub_path;
	backend->move_to = _cairo_cogl_context_move_to;
	backend->rel_move_to = _cairo_cogl_context_rel_move_to;
	backend->line_to = _cairo_cogl_context_line_to;
	backend->rel_line_to = _cairo_cogl_context_rel_line_to;
	backend->curve_to = _cairo_cogl_context_curve_to;
	backend->rel_curve_to = _cairo_cogl_context_rel_curve_to;
#if 0
	backend->arc_to = _cairo_cogl_context_arc_to;
	backend->rel_arc_to = _cairo_cogl_context_rel_arc_to;
#endif
	backend->close_path = _cairo_cogl_context_close_path;
	//backend->arc = _cairo_cogl_context_arc;
	backend->rectangle = _cairo_cogl_context_rectangle;

	/* Try to automatically catch if any new path APIs are added that mean
	 * we may need to overload more functions... */
	assert (((char *)&backend->path_extents - (char *)&backend->device_to_user_distance)
		== (sizeof (void *) * 14));

	backend->fill = _cairo_cogl_context_fill;
	backend->fill_preserve = _cairo_cogl_context_fill_preserve;
	backend->stroke = _cairo_cogl_context_stroke;
	backend->stroke_preserve = _cairo_cogl_context_stroke_preserve;
	backend->clip = _cairo_cogl_context_clip;

	cr->dev->backend_vtable_initialized = TRUE;
    }

    cr->base.base.backend = &cr->dev->backend;

    _cairo_path_fixed_init (&cr->user_path);
    cr->path_is_rectangle = FALSE;

    return &cr->base.base;
}