/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.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.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Oracle Corporation code.
 *
 * The Initial Developer of the Original Code is Oracle Corporation.
 * Portions created by the Initial Developer are Copyright (C) 2005
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Stuart Parmenter <pavlov@pavlov.net>
 *   Vladimir Vukicevic <vladimir@pobox.com>
 *
 *   Chris Yuen <chris@websupergoo.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <math.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#include "cairo.h"
#include "cairo-win32.h"

#include "gfxContext.h"

#include "gfxColor.h"
#include "gfxMatrix.h"
#include "gfxASurface.h"
#include "gfxPattern.h"
#include "gfxPlatform.h"
#include "gfxPattern.h"
#include "gfxTeeSurface.h"
#include "gfxWindowsSurface.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"

#include "K2ICrystalService.h"
#include "K2CrystalService.h"



#include "K2ICrystalCallback.h"

inline PRBool
gfxContext::IsPrintingPDF() const
{
    return mSurface.get()->GetType() == gfxASurface::SurfaceTypePDF;
}

namespace
{
	struct CairoPathAutoPtr {
		CairoPathAutoPtr(cairo_path_t * path) : path(path)
		{ NS_ASSERTION(path, "Null path, bah!"); }

        operator cairo_path_t *() { return path; }
        ~CairoPathAutoPtr()       { cairo_path_destroy(path); }

		cairo_path_t * path;
	};
}



gfxContext::gfxContext(gfxASurface *surface) : mSurface(surface)
{
    MOZ_COUNT_CTOR(gfxContext);

    mCairo = cairo_create(surface->CairoSurface());
    mFlags = surface->GetDefaultContextFlags();

    if(IsPrintingPDF())
		mCrystalCallback = GetCurrentCrystalCallback();
}

gfxContext::~gfxContext()
{
    cairo_destroy(mCairo);
    MOZ_COUNT_DTOR(gfxContext);
}





gfxASurface *
gfxContext::OriginalSurface()
{
    return mSurface;
}

already_AddRefed<gfxASurface>
gfxContext::CurrentSurface(gfxFloat *dx, gfxFloat *dy)
{
    cairo_surface_t *s = cairo_get_group_target(mCairo);
    if (s == mSurface->CairoSurface()) {
        if (dx && dy)
            cairo_surface_get_device_offset(s, dx, dy);
        gfxASurface *ret = mSurface;
        NS_ADDREF(ret);
        return ret;
    }

    if (dx && dy)
        cairo_surface_get_device_offset(s, dx, dy);
    return gfxASurface::Wrap(s);
}

void
gfxContext::Save()
{
    if(mCrystalCallback) mCrystalCallback->OnSave();
    cairo_save(mCairo);
}

void
gfxContext::Restore()
{
    if(mCrystalCallback) mCrystalCallback->OnRestore();
    cairo_restore(mCairo);
}


// drawing
void
gfxContext::NewPath()
{
    if(mCrystalCallback) mCrystalCallback->OnNewPath();
    cairo_new_path(mCairo);
}

void
gfxContext::ClosePath()
{
    if(mCrystalCallback) mCrystalCallback->OnClosePath();
    cairo_close_path(mCairo);
}

already_AddRefed<gfxPath> gfxContext::CopyPath() const
{
    nsRefPtr<gfxPath> path = new gfxPath(cairo_copy_path(mCairo));
    return path.forget();
}

void gfxContext::AppendPath(gfxPath* path)
{
    if (path->mPath->status == CAIRO_STATUS_SUCCESS && path->mPath->num_data != 0) {
        if(mCrystalCallback) mCrystalCallback->OnAppendPath();
        cairo_append_path(mCairo, path->mPath);
    }
}

gfxPoint
gfxContext::CurrentPoint() const
{
    double x, y;
    cairo_get_current_point(mCairo, &x, &y);
    return gfxPoint(x, y);
}

namespace
{

	// Get the clip extents from a surface by creating a 
	// temporary cairo_t
	void CairoGetSurfaceClipExtents(cairo_surface_t * surf,
	    double * x1, double * y1, double * x2, double * y2)
	{
	    cairo_t * cr = cairo_create(surf);
	    cairo_clip_extents(cr, x1, y1, x2, y2);
	    cairo_destroy(cr);
	}

	struct CairoImageContainer 	{
		CairoImageContainer() : cr(), surf(), width(), height(), data(),
			ownsData(false) { }

		~CairoImageContainer() {
			if(cr) cairo_destroy(cr);
			if(surf) cairo_surface_destroy(surf);
			if(ownsData) delete[] data;
		}

		void AllocateDataNoThrow(size_t size) {
			data = new (std::nothrow) unsigned char[size];
			if (data)
				ownsData = true;
		}

		static int GetDimensionFromDouble(double v) {
			return !(v > 0)? 0: v >= INT_MAX? INT_MAX: NS_lround(v);
		}
		void SetWidthFromDouble(double v) { width = GetDimensionFromDouble(v); }
		void SetHeightFromDouble(double v) { height = GetDimensionFromDouble(v); }

		unsigned char * data;
		int width, height;

		bool ownsData;

		cairo_t * cr;
		cairo_surface_t * surf;
		PRUint16 pixelFormat;
	};

	inline PRUint16 ToCrystalPixelFormat(cairo_format_t t) {
		switch(t) {
		case CAIRO_FORMAT_ARGB32: return K2ICrystalCallback::CRYSTAL_PIXEL_BGRA;
		case CAIRO_FORMAT_A8: return K2ICrystalCallback::CRYSTAL_PIXEL_A;
		}

		return K2ICrystalCallback::CRYSTAL_PIXEL_BGRA;
	}

	nsAutoPtr<CairoImageContainer> JustExtractImage(cairo_surface_t * surf) {
		cairo_surface_type_t type = cairo_surface_get_type(surf);
		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

		if(type != CAIRO_SURFACE_TYPE_IMAGE) return ret;

		cairo_surface_flush(surf);
		ret->data = cairo_image_surface_get_data(surf);
		ret->width = cairo_image_surface_get_width(surf);
		ret->height = cairo_image_surface_get_height(surf);
		ret->pixelFormat = ToCrystalPixelFormat(
			cairo_image_surface_get_format(surf));

		return ret;
	}

	nsAutoPtr<CairoImageContainer> ConvertToImageSurfaceWithFormat(
		cairo_surface_t * surf, cairo_format_t t)
	{
		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

        double x1, y1, x2, y2;
		CairoGetSurfaceClipExtents(surf, &x1, &y1, &x2, &y2);

        ret->SetWidthFromDouble(x2 - x1);
        ret->SetHeightFromDouble(y2 - y1);

        ret->surf = cairo_image_surface_create(t, ret->width, ret->height);
        ret->cr = cairo_create(ret->surf);

		if(!ret->surf || !ret->cr) return ret;
		if(cairo_status(ret->cr) != CAIRO_STATUS_SUCCESS) return ret;

        ret->data = cairo_image_surface_get_data(ret->surf);
		cairo_surface_flush(surf);

        // Blit the pattern on to our temp image surface
        cairo_set_source_surface(ret->cr, surf, -x1, -y1);
        cairo_paint(ret->cr);

		cairo_surface_flush(ret->surf);
		ret->pixelFormat = ToCrystalPixelFormat(
			cairo_image_surface_get_format(ret->surf));

		return ret;
	}

	nsAutoPtr<CairoImageContainer> ExtractImageToFormat(
		cairo_surface_t * surf, cairo_format_t fmt)
	{
		cairo_surface_type_t type = cairo_surface_get_type(surf);
		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

		if(type == CAIRO_SURFACE_TYPE_IMAGE &&
			cairo_image_surface_get_format(surf) == fmt)
			return JustExtractImage(surf);

		return ConvertToImageSurfaceWithFormat(surf, fmt);
	}

	//nsAutoPtr<CairoImageContainer> ExtractImageToFormat(
	//	cairo_pattern_t * pattern, cairo_format_t fmt)
    //{
	//	nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

    //    cairo_surface_t * src;
    //    cairo_status_t st = cairo_pattern_get_surface(pattern, &src);
    //    if(st != CAIRO_STATUS_SUCCESS) return ret;

	//	return ExtractImageToFormat(src, fmt);
    //}

	// This comes without any stride
	nsAutoPtr<CairoImageContainer> ExtractAlpha(cairo_surface_t * surf) {
		if(cairo_surface_get_type(surf) != CAIRO_SURFACE_TYPE_IMAGE ||
			cairo_image_surface_get_format(surf) != CAIRO_FORMAT_A8)
		{
			// HACK Just obviously plain hack
			return ExtractAlpha(ConvertToImageSurfaceWithFormat(surf,
				CAIRO_FORMAT_A8)->surf);
		}

		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

        double x1, y1, x2, y2;
		CairoGetSurfaceClipExtents(surf, &x1, &y1, &x2, &y2);
        ret->SetWidthFromDouble(x2 - x1);
        ret->SetHeightFromDouble(y2 - y1);

		int stride = cairo_image_surface_get_stride(surf);

		ret->AllocateDataNoThrow((size_t)ret->width * ret->height);
		if(!ret->data) return ret;

		size_t curr = 0;

		unsigned char * src = cairo_image_surface_get_data(surf);
		cairo_surface_flush(surf);

		// For some reason, painting on a new image surface doesn't work
		// We'll do a hand rolled loop here
		for(int row = 0; row < ret->height; row++) {
			for(int col = 0; col < ret->width; col++)
				ret->data[curr++] = src[col];

			src += stride;
		}

		ret->pixelFormat = CAIRO_FORMAT_A8;
		return ret;
	}

	nsAutoPtr<CairoImageContainer> ExtractAlpha(
		cairo_pattern_t * pattern)
    {
		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());

        cairo_surface_t * src;
        cairo_status_t st = cairo_pattern_get_surface(pattern, &src);
        if(st != CAIRO_STATUS_SUCCESS) return ret;

		return ExtractAlpha(src);
    }

	inline gfxRect GetUserPathExtents(cairo_t * cr) {
	    double xmin, ymin, xmax, ymax;
	    cairo_path_extents(cr, &xmin, &ymin, &xmax, &ymax);
	    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
	}

	// RAII reset a patterns' matrix
	struct PatternMatrixReset {
		PatternMatrixReset(cairo_pattern_t * pat) : pat(pat) {
			cairo_pattern_get_matrix(pat, &mat0);

			cairo_matrix_t id;
			cairo_matrix_init_identity(&id);
			cairo_pattern_set_matrix(pat, &id);
		}

		~PatternMatrixReset() {
			cairo_pattern_set_matrix(pat, &mat0);
		}

		cairo_pattern_t * pat;
		cairo_matrix_t mat0;
	};

	// RAII translate the pattern by offsets within scope
	struct PatternNudge {
		PatternNudge(cairo_pattern_t * pat, double dx, double dy) : pat(pat) {
			cairo_matrix_t mat1;

			cairo_pattern_get_matrix(pat, &mat0);
			cairo_pattern_get_matrix(pat, &mat1);

			cairo_matrix_translate(&mat1, dx, dy);
			cairo_pattern_set_matrix(pat, &mat1);
		}

		~PatternNudge() {
			cairo_pattern_set_matrix(pat, &mat0);
		}

		cairo_pattern_t * pat;
		cairo_matrix_t mat0;
	};

	template <typename T>
	inline T Max(T a, T b) {
		return a > b ? a : b;
	}

	nsAutoPtr<CairoImageContainer> RasterizePatternToImage(
		cairo_t * cr, cairo_pattern_t * pat)
	{
		nsAutoPtr<CairoImageContainer> ret(new CairoImageContainer());
		if(!pat) return ret;
		if(!cr) return ret;

		gfxRect rect(GetUserPathExtents(cr));

		ret->SetWidthFromDouble(Max(rect.Width(), 1.0));
		ret->SetHeightFromDouble(Max(rect.Height(), 1.0));

		ret->surf = cairo_image_surface_create(
			CAIRO_FORMAT_ARGB32, ret->width, ret->height);
		ret->cr = cairo_create(ret->surf);

		if(!ret->surf || !ret->cr) return ret;

		PatternNudge n(pat, rect.X(), rect.Y());

		cairo_set_source(ret->cr, pat);
		cairo_paint(ret->cr);
		ret->data = cairo_image_surface_get_data(ret->surf);
		ret->pixelFormat = ToCrystalPixelFormat(CAIRO_FORMAT_ARGB32);

		cairo_surface_flush(ret->surf);

		return ret;
	}

	struct CairoGradientContainer {
		int count;
		double * offsets;
		double * rgbas;
		cairo_matrix_t mat;

		// x0 y0 r0 x1 y1 r1
		double point3s[6];

		CairoGradientContainer() : offsets(), rgbas(), count(0) { }

		~CairoGradientContainer() {
			if(count > 0 ) {
				if(offsets) delete [] offsets;
				if(rgbas) delete [] rgbas;
			}
		}
	};

	nsAutoPtr<CairoGradientContainer> ExtractGradient(cairo_pattern_t * pattern) {
		cairo_pattern_type_t type = cairo_pattern_get_type(pattern);
		nsAutoPtr<CairoGradientContainer> ret(new CairoGradientContainer());

		if(type != CAIRO_PATTERN_TYPE_LINEAR && type != CAIRO_PATTERN_TYPE_RADIAL)
			return ret;

		cairo_status_t st;

		st = cairo_pattern_get_color_stop_count(pattern, &ret->count);
		if(st != CAIRO_STATUS_SUCCESS) return ret;

		ret->offsets = new double[ret->count];
		ret->rgbas = new double[ret->count * 4];

		for(int i = 0, j = 0; i < ret->count; i++, j += 4) {
			cairo_pattern_get_color_stop_rgba(pattern, i,
				&ret->offsets[i],
				&ret->rgbas[j + 0],
				&ret->rgbas[j + 1],
				&ret->rgbas[j + 2],
				&ret->rgbas[j + 3]);
		}

		if(type == CAIRO_PATTERN_TYPE_LINEAR) {
			cairo_pattern_get_linear_points(pattern,
				&ret->point3s[0],
				&ret->point3s[1],
				&ret->point3s[3],
				&ret->point3s[4]);
		}
		else if(type == CAIRO_PATTERN_TYPE_RADIAL) {
			cairo_pattern_get_radial_circles(pattern,
				&ret->point3s[0],
				&ret->point3s[1],
				&ret->point3s[2],
				&ret->point3s[3],
				&ret->point3s[4],
				&ret->point3s[5]);
		}

		cairo_pattern_get_matrix(pattern, &ret->mat);

		return ret;
	}

	inline PRUint16 ToCrystalExtend(cairo_extend_t t) {
		// A small check because I'm going to cast it directly
		NS_ASSERTION(CAIRO_EXTEND_NONE == K2ICrystalCallback::CRYSTAL_EXTEND_NONE, "");
		NS_ASSERTION(CAIRO_EXTEND_REPEAT == K2ICrystalCallback::CRYSTAL_EXTEND_REPEAT, "");
		NS_ASSERTION(CAIRO_EXTEND_REFLECT == K2ICrystalCallback::CRYSTAL_EXTEND_REFLECT, "");
		NS_ASSERTION(CAIRO_EXTEND_PAD == K2ICrystalCallback::CRYSTAL_EXTEND_PAD, "");

		return static_cast<PRUint16>(t);
	}

	inline gfxMatrix & ToGfxMatrix(cairo_matrix_t & t)
	{ return reinterpret_cast<gfxMatrix &>(t); }


	inline PRUint16 ToCrystalGradientType(cairo_pattern_type_t t) {
		return t == CAIRO_PATTERN_TYPE_LINEAR ? 
			K2ICrystalCallback::CRYSTAL_GRADIENT_LINEAR : 
			K2ICrystalCallback::CRYSTAL_GRADIENT_RADIAL;
	}

	void SetCrystalSourceForPattern(K2ICrystalCallback & crystal,
		cairo_t * cr, cairo_pattern_t * pat)
	{
		cairo_pattern_type_t type = cairo_pattern_get_type (pat);
		PRUint16 ext = ToCrystalExtend(cairo_pattern_get_extend(pat));

		switch(type) {
		case CAIRO_PATTERN_TYPE_SURFACE:
			{
				nsAutoPtr<CairoImageContainer> image;
				
				// HACK Rasterize for repeating
				// This is needed for crystal to pick up the correct 
				// position of the pattern, and it may also drastically 
				// reduce the amount of data transferred. Actually, rasterizing 
				// is a good default. The disadvantage is that 
				// the picture may come out blurred when down-sampling so 
				// we sholud avaoid it for simple images (heuristically 
				// detected by when ext is PAD)
				
				if(ext == K2ICrystalCallback::CRYSTAL_EXTEND_PAD) {
					cairo_surface_t * surf;
					cairo_pattern_get_surface(pat, &surf);
					image = ExtractImageToFormat(surf, CAIRO_FORMAT_ARGB32).forget();
				}
				else
					image = RasterizePatternToImage(cr, pat).forget();

				if(image->data) {
					crystal.OnSetSourceImage(
						image->pixelFormat, ext,
						image->width, image->height, image->data);
				}
				else crystal.OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);
			} break;

		case CAIRO_PATTERN_TYPE_LINEAR:
		case CAIRO_PATTERN_TYPE_RADIAL:
			// Rasterize repeat/reflect radial because they're difficult 
			// to reproduce in PDF
			if((ext == CAIRO_EXTEND_REFLECT || ext == CAIRO_EXTEND_REPEAT) &&
				cairo_pattern_get_type(pat) == CAIRO_PATTERN_TYPE_RADIAL)
			{
				nsAutoPtr<CairoImageContainer> image = RasterizePatternToImage(
					cr, pat).forget();

				if(image->data) {
					crystal.OnSetSourceImage(
						image->pixelFormat,
						K2ICrystalCallback::CRYSTAL_EXTEND_NONE,
						image->width, image->height, image->data);
				}
				else crystal.OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);
			}
			else {
				nsAutoPtr<CairoGradientContainer> grad(ExtractGradient(pat));

				crystal.OnSetSourceGradient(
					ToCrystalGradientType(type), ext,
					grad->count, grad->offsets,
					grad->rgbas, grad->point3s,
					ToGfxMatrix(grad->mat));
			}
			break;

		case CAIRO_PATTERN_TYPE_SOLID:
		default:
			break;
		}
	}
}


void
gfxContext::Stroke()
{
	if(mCrystalCallback) {
		nsRefPtr<gfxPattern> pat = GetPattern();
		SetCrystalSourceForPattern(*mCrystalCallback,
				mCairo, pat->CairoPattern());
		mCrystalCallback->OnStroke(CairoPathAutoPtr(cairo_copy_path(mCairo)));
	}
    cairo_stroke_preserve(mCairo);
}


void
gfxContext::Fill()
{
	if(mCrystalCallback) {
		nsRefPtr<gfxPattern> pat = GetPattern();
		SetCrystalSourceForPattern(*mCrystalCallback,
				mCairo, pat->CairoPattern());
		mCrystalCallback->OnFill(CairoPathAutoPtr(cairo_copy_path(mCairo)));
	}

    cairo_fill_preserve(mCairo);
}

void
gfxContext::FillWithOpacity(gfxFloat aOpacity)
{
	// This method exists in the hope that one day cairo gets a direct
	// API for this, and then we would change this method to use that
	// API instead.
	if (aOpacity != 1.0) {
		gfxContextAutoSaveRestore saveRestore(this);
		Clip();
		Paint(aOpacity);
	} else {
		Fill();
	}
}

void
gfxContext::MoveTo(const gfxPoint& pt)
{
    if(mCrystalCallback) mCrystalCallback->OnMoveTo(pt.x, pt.y);
    cairo_move_to(mCairo, pt.x, pt.y);
}

void
gfxContext::NewSubPath()
{
    if(mCrystalCallback) mCrystalCallback->OnNewSubPath();
    cairo_new_sub_path(mCairo);
}

void
gfxContext::LineTo(const gfxPoint& pt)
{
    if(mCrystalCallback) mCrystalCallback->OnLineTo(pt.x, pt.y);
    cairo_line_to(mCairo, pt.x, pt.y);
}

void
gfxContext::CurveTo(const gfxPoint& pt1, const gfxPoint& pt2, const gfxPoint& pt3)
{
    if(mCrystalCallback) mCrystalCallback->OnCurveTo(pt1.x, pt1.y,
        pt2.x, pt2.y, pt3.x, pt3.y);
    cairo_curve_to(mCairo, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y);
}

void
gfxContext::QuadraticCurveTo(const gfxPoint& pt1, const gfxPoint& pt2)
{
    double cx, cy;
    cairo_get_current_point(mCairo, &cx, &cy);

    if(mCrystalCallback) {
        mCrystalCallback->OnCurveTo((cx + pt1.x * 2.0) / 3.0,
            (cy + pt1.y * 2.0) / 3.0,
            (pt1.x * 2.0 + pt2.x) / 3.0,
            (pt1.y * 2.0 + pt2.y) / 3.0,
            pt2.x,
            pt2.y);
    }

    cairo_curve_to(mCairo,
                   (cx + pt1.x * 2.0) / 3.0,
                   (cy + pt1.y * 2.0) / 3.0,
                   (pt1.x * 2.0 + pt2.x) / 3.0,
                   (pt1.y * 2.0 + pt2.y) / 3.0,
                   pt2.x,
                   pt2.y);
}

void
gfxContext::Arc(const gfxPoint& center, gfxFloat radius,
                gfxFloat angle1, gfxFloat angle2)
{
    if(mCrystalCallback) {
        mCrystalCallback->OnArc(center.x, center.y,
            radius, angle1, angle2);
    }
    cairo_arc(mCairo, center.x, center.y, radius, angle1, angle2);
}

void
gfxContext::NegativeArc(const gfxPoint& center, gfxFloat radius,
                        gfxFloat angle1, gfxFloat angle2)
{
    if(mCrystalCallback) {
        mCrystalCallback->OnNegativeArc(center.x, center.y,
            radius, angle1, angle2);
    }
    cairo_arc_negative(mCairo, center.x, center.y, radius, angle1, angle2);
}

void
gfxContext::Line(const gfxPoint& start, const gfxPoint& end)
{
    MoveTo(start);
    LineTo(end);
}

// XXX snapToPixels is only valid when snapping for filled
// rectangles and for even-width stroked rectangles.
// For odd-width stroked rectangles, we need to offset x/y by
// 0.5...
void
gfxContext::Rectangle(const gfxRect& rect, PRBool snapToPixels)
{
    if (snapToPixels) {
        gfxRect snappedRect(rect);

        if (UserToDevicePixelSnapped(snappedRect, PR_TRUE)) {
            gfxMatrix mat = CurrentMatrix();
            IdentityMatrix();
            Rectangle(snappedRect);
            SetMatrix(mat);

            return;
        }
    }

    if(mCrystalCallback) {
        mCrystalCallback->OnRectangle(rect.pos.x, rect.pos.y,
            rect.size.width, rect.size.height);
    }

    cairo_rectangle(mCairo, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
}

void
gfxContext::Ellipse(const gfxPoint& center, const gfxSize& dimensions)
{

    if(mCrystalCallback) {
        mCrystalCallback->OnEllipse(center.x, center.y,
            dimensions.width, dimensions.height);
    }

	gfxSize halfDim = dimensions / 2.0;
	gfxRect r(center - halfDim, dimensions);
	gfxCornerSizes c(halfDim, halfDim, halfDim, halfDim);

	RoundedRectangle (r, c);
}

void
gfxContext::Polygon(const gfxPoint *points, PRUint32 numPoints)
{
    if (numPoints == 0) return;
    MoveTo(points[0]);
    for (PRUint32 i = 1; i < numPoints; ++i)
        LineTo(points[i]);
}

void
gfxContext::DrawSurface(gfxASurface *surface, const gfxSize& size)
{
    if(mCrystalCallback) {
        mCrystalCallback->OnSave();
        //mCrystalCallback->OnSetSource();
        mCrystalCallback->OnNewPath();
    }
    cairo_save(mCairo);
    cairo_set_source_surface(mCairo, surface->CairoSurface(), 0, 0);
    cairo_new_path(mCairo);

    // pixel-snap this
    Rectangle(gfxRect(gfxPoint(0.0, 0.0), size), PR_TRUE);

	if(mCrystalCallback) {
		nsAutoPtr<CairoImageContainer> image = ExtractImageToFormat(
					surface->CairoSurface(), CAIRO_FORMAT_ARGB32).forget();
		if(image->data) {
			mCrystalCallback->OnSetSourceImage(image->pixelFormat,
					K2ICrystalCallback::CRYSTAL_EXTEND_NONE,
					image->width, image->height, image->data);
			mCrystalCallback->OnFill(CairoPathAutoPtr(cairo_copy_path(mCairo)));
		}
		else mCrystalCallback->OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);

		mCrystalCallback->OnRestore();
	}

    cairo_fill(mCairo);
    cairo_restore(mCairo);
}

// transform stuff
void
gfxContext::Translate(const gfxPoint& pt)
{
    if(mCrystalCallback)
        mCrystalCallback->OnTranslate(pt.x, pt.y);
    cairo_translate(mCairo, pt.x, pt.y);
}

void
gfxContext::Scale(gfxFloat x, gfxFloat y)
{
    if(mCrystalCallback)
        mCrystalCallback->OnScale(x, y);
    cairo_scale(mCairo, x, y);
}

void
gfxContext::Rotate(gfxFloat angle)
{
    if(mCrystalCallback)
        mCrystalCallback->OnRotate(angle);
    cairo_rotate(mCairo, angle);
}

void
gfxContext::Multiply(const gfxMatrix& matrix)
{
    const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);
    if(mCrystalCallback)
        mCrystalCallback->OnMultiply(const_cast<gfxMatrix &>(matrix));
    cairo_transform(mCairo, &mat);
}

void
gfxContext::SetMatrix(const gfxMatrix& matrix)
{
    const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);
    if(mCrystalCallback)
        mCrystalCallback->OnSetMatrix(const_cast<gfxMatrix &>(matrix));
    cairo_set_matrix(mCairo, &mat);
}

void
gfxContext::IdentityMatrix()
{
    if(mCrystalCallback)
        mCrystalCallback->OnIdentityMatrix();
    cairo_identity_matrix(mCairo);
}

gfxMatrix
gfxContext::CurrentMatrix() const
{
    cairo_matrix_t mat;
    cairo_get_matrix(mCairo, &mat);
    return gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat));
}

void
gfxContext::NudgeCurrentMatrixToIntegers()
{
    cairo_matrix_t mat;
    cairo_get_matrix(mCairo, &mat);
    gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat)).NudgeToIntegers();

    if(mCrystalCallback) {
        mCrystalCallback->OnSetMatrix(gfxMatrix(mat.xx, mat.xy,
            mat.yx, mat.yy, mat.x0, mat.y0));
    }


    cairo_set_matrix(mCairo, &mat);
}

gfxPoint
gfxContext::DeviceToUser(const gfxPoint& point) const
{
    gfxPoint ret = point;
    cairo_device_to_user(mCairo, &ret.x, &ret.y);
    return ret;
}

gfxSize
gfxContext::DeviceToUser(const gfxSize& size) const
{
    gfxSize ret = size;
    cairo_device_to_user_distance(mCairo, &ret.width, &ret.height);
    return ret;
}

gfxRect
gfxContext::DeviceToUser(const gfxRect& rect) const
{
    gfxRect ret = rect;
    cairo_device_to_user(mCairo, &ret.pos.x, &ret.pos.y);
    cairo_device_to_user_distance(mCairo, &ret.size.width, &ret.size.height);
    return ret;
}

gfxPoint
gfxContext::UserToDevice(const gfxPoint& point) const
{
    gfxPoint ret = point;
    cairo_user_to_device(mCairo, &ret.x, &ret.y);
    return ret;
}

gfxSize
gfxContext::UserToDevice(const gfxSize& size) const
{
    gfxSize ret = size;
    cairo_user_to_device_distance(mCairo, &ret.width, &ret.height);
    return ret;
}

gfxRect
gfxContext::UserToDevice(const gfxRect& rect) const
{
    double xmin, ymin, xmax, ymax;
    xmin = rect.pos.x;
    ymin = rect.pos.y;
    xmax = rect.pos.x + rect.size.width;
    ymax = rect.pos.y + rect.size.height;

    double x[3], y[3];
    x[0] = xmin;  y[0] = ymax;
    x[1] = xmax;  y[1] = ymax;
    x[2] = xmax;  y[2] = ymin;

    cairo_user_to_device(mCairo, &xmin, &ymin);
    xmax = xmin;
    ymax = ymin;
    for (int i = 0; i < 3; i++) {
        cairo_user_to_device(mCairo, &x[i], &y[i]);
        xmin = PR_MIN(xmin, x[i]);
        xmax = PR_MAX(xmax, x[i]);
        ymin = PR_MIN(ymin, y[i]);
        ymax = PR_MAX(ymax, y[i]);
    }

    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
}

PRBool
gfxContext::UserToDevicePixelSnapped(gfxRect& rect, PRBool ignoreScale) const
{
    if (GetFlags() & FLAG_DISABLE_SNAPPING)
        return PR_FALSE;

    // if we're not at 1.0 scale, don't snap, unless we're
    // ignoring the scale.  If we're not -just- a scale,
    // never snap.
    const gfxFloat epsilon = 0.0000001;
#define WITHIN_E(a,b) (fabs((a)-(b)) < epsilon)
    cairo_matrix_t mat;
    cairo_get_matrix(mCairo, &mat);
    if (!ignoreScale &&
        (!WITHIN_E(mat.xx,1.0) || !WITHIN_E(mat.yy,1.0) ||
         !WITHIN_E(mat.xy,0.0) || !WITHIN_E(mat.yx,0.0)))
        return PR_FALSE;
#undef WITHIN_E

    gfxPoint p1 = UserToDevice(rect.pos);
    gfxPoint p2 = UserToDevice(rect.pos + gfxSize(rect.size.width, 0.0));
    gfxPoint p3 = UserToDevice(rect.pos + rect.size);

    // Check that the rectangle is axis-aligned. For an axis-aligned rectangle,
    // two opposite corners define the entire rectangle. So check if
    // the axis-aligned rectangle with opposite corners p1 and p3
    // define an axis-aligned rectangle whose other corners are p2 and p4.
    // We actually only need to check one of p2 and p4, since an affine
    // transform maps parallelograms to parallelograms.
    if (p2 == gfxPoint(p1.x, p3.y) || p2 == gfxPoint(p3.x, p1.y)) {
        p1.Round();
        p3.Round();

        rect.pos = gfxPoint(NS_MIN(p1.x, p3.x), NS_MIN(p1.y, p3.y));
        rect.size = gfxSize(NS_MAX(p1.x, p3.x) - rect.pos.x,
                            NS_MAX(p1.y, p3.y) - rect.pos.y);
        return PR_TRUE;
    }

    return PR_FALSE;
}

PRBool
gfxContext::UserToDevicePixelSnapped(gfxPoint& pt, PRBool ignoreScale) const
{
    if (GetFlags() & FLAG_DISABLE_SNAPPING)
        return PR_FALSE;

    // if we're not at 1.0 scale, don't snap, unless we're
    // ignoring the scale.  If we're not -just- a scale,
    // never snap.
    cairo_matrix_t mat;
    cairo_get_matrix(mCairo, &mat);
    if ((!ignoreScale && (mat.xx != 1.0 || mat.yy != 1.0)) ||
        (mat.xy != 0.0 || mat.yx != 0.0))
        return PR_FALSE;

    pt = UserToDevice(pt);
    pt.Round();
    return PR_TRUE;
}

void
gfxContext::PixelSnappedRectangleAndSetPattern(const gfxRect& rect,
                                               gfxPattern *pattern)
{
    gfxRect r(rect);

    // Bob attempts to pixel-snap the rectangle, and returns true if
    // the snapping succeeds.  If it does, we need to set up an
    // identity matrix, because the rectangle given back is in device
    // coordinates.
    //
    // We then have to call a translate to dr.pos afterwards, to make
    // sure the image lines up in the right place with our pixel
    // snapped rectangle.
    //
    // If snapping wasn't successful, we just translate to where the
    // pattern would normally start (in app coordinates) and do the
    // same thing.

    gfxMatrix mat = CurrentMatrix();
    if (UserToDevicePixelSnapped(r)) {
        IdentityMatrix();
    }

    Translate(r.pos);
    r.pos.x = r.pos.y = 0;
    Rectangle(r);
    SetPattern(pattern);

    SetMatrix(mat);
}

void
gfxContext::SetAntialiasMode(AntialiasMode mode)
{
    if (mode == MODE_ALIASED) {
        cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_NONE);
    } else if (mode == MODE_COVERAGE) {
        cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_DEFAULT);
    }
}

gfxContext::AntialiasMode
gfxContext::CurrentAntialiasMode() const
{
    cairo_antialias_t aa = cairo_get_antialias(mCairo);
    if (aa == CAIRO_ANTIALIAS_NONE)
        return MODE_ALIASED;
    return MODE_COVERAGE;
}

void
gfxContext::SetDash(gfxLineType ltype)
{
    static double dash[] = {5.0, 5.0};
    static double dot[] = {1.0, 1.0};

    switch (ltype) {
        case gfxLineDashed:
            SetDash(dash, 2, 0.0);
            break;
        case gfxLineDotted:
            SetDash(dot, 2, 0.0);
            break;
        case gfxLineSolid:
        default:
            SetDash(nsnull, 0, 0.0);
            break;
    }
}

void
gfxContext::SetDash(gfxFloat *dashes, int ndash, gfxFloat offset)
{
    if(mCrystalCallback) mCrystalCallback->OnSetDash(dashes, ndash, offset);
    cairo_set_dash(mCairo, dashes, ndash, offset);
}
//void getDash() const;

void
gfxContext::SetLineWidth(gfxFloat width)
{
    if(mCrystalCallback) mCrystalCallback->OnSetLineWidth(width);
    cairo_set_line_width(mCairo, width);
}

gfxFloat
gfxContext::CurrentLineWidth() const
{
    return cairo_get_line_width(mCairo);
}

void
gfxContext::SetOperator(GraphicsOperator op)
{
    if (mFlags & FLAG_SIMPLIFY_OPERATORS) {
        if (op != OPERATOR_SOURCE &&
            op != OPERATOR_CLEAR &&
            op != OPERATOR_OVER)
            op = OPERATOR_OVER;
    }

    if(mCrystalCallback) mCrystalCallback->OnSetOperator(op);
    cairo_set_operator(mCairo, (cairo_operator_t)op);
}

gfxContext::GraphicsOperator
gfxContext::CurrentOperator() const
{
    return (GraphicsOperator)cairo_get_operator(mCairo);
}

void
gfxContext::SetLineCap(GraphicsLineCap cap)
{
    if(mCrystalCallback) mCrystalCallback->OnSetLineCap(cap);
    cairo_set_line_cap(mCairo, (cairo_line_cap_t)cap);
}

gfxContext::GraphicsLineCap
gfxContext::CurrentLineCap() const
{
    return (GraphicsLineCap)cairo_get_line_cap(mCairo);
}

void
gfxContext::SetLineJoin(GraphicsLineJoin join)
{
    if(mCrystalCallback) mCrystalCallback->OnSetLineJoin(join);
    cairo_set_line_join(mCairo, (cairo_line_join_t)join);
}

gfxContext::GraphicsLineJoin
gfxContext::CurrentLineJoin() const
{
    return (GraphicsLineJoin)cairo_get_line_join(mCairo);
}

void
gfxContext::SetMiterLimit(gfxFloat limit)
{
    if(mCrystalCallback) mCrystalCallback->OnSetMiterLimit(limit);
    cairo_set_miter_limit(mCairo, limit);
}

gfxFloat
gfxContext::CurrentMiterLimit() const
{
    return cairo_get_miter_limit(mCairo);
}

void
gfxContext::SetFillRule(FillRule rule)
{
    if(mCrystalCallback) mCrystalCallback->OnSetFillRule(rule);
    cairo_set_fill_rule(mCairo, (cairo_fill_rule_t)rule);
}

gfxContext::FillRule
gfxContext::CurrentFillRule() const
{
    return (FillRule)cairo_get_fill_rule(mCairo);
}

// clipping
void
gfxContext::Clip(const gfxRect& rect)
{
    if(mCrystalCallback) {
        mCrystalCallback->OnNewPath();
        mCrystalCallback->OnRectangle(rect.pos.x, rect.pos.y,
            rect.size.width, rect.size.height);
	}

    cairo_new_path(mCairo);
    cairo_rectangle(mCairo, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);

	if(mCrystalCallback)
        mCrystalCallback->OnClip(CairoPathAutoPtr(cairo_copy_path(mCairo)));

    cairo_clip(mCairo);
}

void
gfxContext::Clip()
{
    if(mCrystalCallback) mCrystalCallback->OnClip(CairoPathAutoPtr(cairo_copy_path(mCairo)));
    cairo_clip_preserve(mCairo);
}

void
gfxContext::ResetClip()
{
    if(mCrystalCallback)
        mCrystalCallback->OnResetClip();
    cairo_reset_clip(mCairo);
}

void
gfxContext::UpdateSurfaceClip()
{
    NewPath();
    // we paint an empty rectangle to ensure the clip is propagated to
    // the destination surface
    SetDeviceColor(gfxRGBA(0,0,0,0));
    Rectangle(gfxRect(0,1,1,0));
    Fill();
}

gfxRect
gfxContext::GetClipExtents()
{
    double xmin, ymin, xmax, ymax;
    cairo_clip_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
}

// rendering sources

void
gfxContext::SetColor(const gfxRGBA& c)
{

    if (gfxPlatform::GetCMSMode() == eCMSMode_All) {

        gfxRGBA cms;
        gfxPlatform::TransformPixel(c, cms, gfxPlatform::GetCMSRGBTransform());

        if(mCrystalCallback)
            mCrystalCallback->OnSetSourceColor(cms.r, cms.g, cms.b, c.a);

        // Use the original alpha to avoid unnecessary float->byte->float
        // conversion errors
        cairo_set_source_rgba(mCairo, cms.r, cms.g, cms.b, c.a);
    }
    else {
        if(mCrystalCallback)
            mCrystalCallback->OnSetSourceColor(c.r, c.g, c.b, c.a);
        cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);
    }
}

void
gfxContext::SetDeviceColor(const gfxRGBA& c)
{
    if(mCrystalCallback)
        mCrystalCallback->OnSetSourceColor(c.r, c.g, c.b, c.a);

    cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);
}

PRBool
gfxContext::GetDeviceColor(gfxRGBA& c)
{
    return cairo_pattern_get_rgba(cairo_get_source(mCairo),
                                  &c.r,
                                  &c.g,
                                  &c.b,
                                  &c.a) == CAIRO_STATUS_SUCCESS;
}

void
gfxContext::SetSource(gfxASurface *surface, const gfxPoint& offset)
{
    NS_ASSERTION(surface->GetAllowUseAsSource(), "Surface not allowed to be used as source!");

	if(mCrystalCallback) {
		nsAutoPtr<CairoImageContainer> image = ExtractImageToFormat(
					surface->CairoSurface(), CAIRO_FORMAT_ARGB32).forget();

		if(image->data) {
			mCrystalCallback->OnSetSourceImage(image->pixelFormat,
					K2ICrystalCallback::CRYSTAL_EXTEND_NONE,
					image->width, image->height, image->data);
		}
		else mCrystalCallback->OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);
	}

    cairo_set_source_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);
}

void
gfxContext::SetPattern(gfxPattern *pattern)
{
    cairo_set_source(mCairo, pattern->CairoPattern());
}

already_AddRefed<gfxPattern>
gfxContext::GetPattern()
{
    cairo_pattern_t *pat = cairo_get_source(mCairo);
    NS_ASSERTION(pat, "I was told this couldn't be null");

    gfxPattern *wrapper = nsnull;
    if (pat)
        wrapper = new gfxPattern(pat);
    else
        wrapper = new gfxPattern(gfxRGBA(0,0,0,0));

    NS_IF_ADDREF(wrapper);
    return wrapper;
}


// masking

void
gfxContext::Mask(gfxPattern *pattern)
{
	if(mCrystalCallback) {
		cairo_pattern_t * pat = pattern->CairoPattern();
		cairo_pattern_type_t type = cairo_pattern_get_type(pat);
		PRUint16 ext = ToCrystalExtend(cairo_pattern_get_extend(pat));

		switch(type) {
		case CAIRO_PATTERN_TYPE_LINEAR:
		case CAIRO_PATTERN_TYPE_RADIAL:
			{
				nsAutoPtr<CairoGradientContainer> grad(ExtractGradient(pat));
				mCrystalCallback->OnMaskGradient(
					ToCrystalGradientType(type), ext,
					grad->count, grad->offsets, grad->rgbas, grad->point3s,
					ToGfxMatrix(grad->mat));
			}

		default:
			{
				cairo_surface_t * s;
				cairo_pattern_get_surface(pat, &s);
				double x1, y1, x2, y2;
				CairoGetSurfaceClipExtents(s, &x1, &y1, &x2, &y2);

				cairo_matrix_t cm, pm;
				cairo_get_matrix(mCairo, &cm);
				cairo_pattern_get_matrix(pat, &pm);

				PatternMatrixReset reset(pat);
				nsAutoPtr<CairoImageContainer> image(ExtractAlpha(pat));
				if(image->data) {
					mCrystalCallback->OnMaskImage(
						image->pixelFormat, ext, x1, y1,
						image->width, image->height, image->data);
				}
				else mCrystalCallback->OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);
			}
		}
	}

    cairo_mask(mCairo, pattern->CairoPattern());
}

void
gfxContext::Mask(gfxASurface *surface, const gfxPoint& offset)
{
    if(mCrystalCallback) {
		nsAutoPtr<CairoImageContainer> image(ExtractAlpha(
			surface->CairoSurface()));
		if(image->data) {
			mCrystalCallback->OnMaskImage(
				image->pixelFormat,
				K2ICrystalCallback::CRYSTAL_EXTEND_NONE,
				offset.x, offset.y,
				image->width, image->height, image->data);
		}
		else mCrystalCallback->OnError(K2ICrystalCallback::CRYSTAL_ERROR_RENDER);
	}
    cairo_mask_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);
}

void
gfxContext::Paint(gfxFloat alpha)
{
	if(mCrystalCallback) mCrystalCallback->OnPaint(alpha);

	// TODO The below is needed for SVG. To be continued.
    //if(mCrystalCallback) {
    //    nsRefPtr<gfxPattern> pattern = GetPattern();
    //    CairoPatternImageExtractor e(pattern->CairoPattern());
    //    if(e.IsSurfacePattern()) {
    //        e.Extract();
    //        mCrystalCallback->OnFillPattern(CairoPathAutoPtr(cairo_copy_path(mCairo)),
    //            e.Width(), e.Height(), e.Data(), e.AlphaMap());
    //    }
    //    else mCrystalCallback->OnPaint(alpha);
    //}

    cairo_paint_with_alpha(mCairo, alpha);
}

// groups

void
gfxContext::PushGroup(gfxASurface::gfxContentType content)
{
    if(mCrystalCallback) mCrystalCallback->OnPushGroup();
    cairo_push_group_with_content(mCairo, (cairo_content_t) content);
}

static gfxRect
GetRoundOutDeviceClipExtents(gfxContext* aCtx)
{
    gfxContextMatrixAutoSaveRestore save(aCtx);
    aCtx->IdentityMatrix();
    gfxRect r = aCtx->GetClipExtents();
    r.RoundOut();
    return r;
}

/**
 * Copy the contents of aSrc to aDest, translated by aTranslation.
 */
static void
CopySurface(gfxASurface* aSrc, gfxASurface* aDest, const gfxPoint& aTranslation)
{
  cairo_t *cr = cairo_create(aDest->CairoSurface());
  cairo_set_source_surface(cr, aSrc->CairoSurface(), aTranslation.x, aTranslation.y);
  cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
  cairo_paint(cr);
  cairo_destroy(cr);
}

void
gfxContext::PushGroupAndCopyBackground(gfxASurface::gfxContentType content)
{
    if (content == gfxASurface::CONTENT_COLOR_ALPHA &&
        !(GetFlags() & FLAG_DISABLE_COPY_BACKGROUND)) {
        nsRefPtr<gfxASurface> s = CurrentSurface();
        if ((s->GetAllowUseAsSource() || s->GetType() == gfxASurface::SurfaceTypeTee) &&
            (s->GetContentType() == gfxASurface::CONTENT_COLOR ||
             s->GetOpaqueRect().Contains(GetRoundOutDeviceClipExtents(this)))) {
			PushGroup(gfxASurface::CONTENT_COLOR);
            nsRefPtr<gfxASurface> d = CurrentSurface();

            if (d->GetType() == gfxASurface::SurfaceTypeTee) {
                NS_ASSERTION(s->GetType() == gfxASurface::SurfaceTypeTee, "Mismatched types");
                nsAutoTArray<nsRefPtr<gfxASurface>,2> ss;
                nsAutoTArray<nsRefPtr<gfxASurface>,2> ds;
                static_cast<gfxTeeSurface*>(s.get())->GetSurfaces(&ss);
                static_cast<gfxTeeSurface*>(d.get())->GetSurfaces(&ds);
                NS_ASSERTION(ss.Length() == ds.Length(), "Mismatched lengths");
                gfxPoint translation = d->GetDeviceOffset() - s->GetDeviceOffset();
                for (PRUint32 i = 0; i < ss.Length(); ++i) {
                    CopySurface(ss[i], ds[i], translation);
                }
            } else {
                CopySurface(s, d, gfxPoint(0, 0));
            }
            d->SetOpaqueRect(s->GetOpaqueRect());
            return;
        }
    }
	PushGroup(content);
}

already_AddRefed<gfxPattern>
gfxContext::PopGroup()
{
    if(mCrystalCallback) mCrystalCallback->OnPopGroup();
    cairo_pattern_t *pat = cairo_pop_group(mCairo);
    gfxPattern *wrapper = new gfxPattern(pat);
    cairo_pattern_destroy(pat);
    NS_IF_ADDREF(wrapper);
    return wrapper;
}

void
gfxContext::PopGroupToSource()
{
    if(mCrystalCallback) mCrystalCallback->OnPopGroupToSource();
    cairo_pop_group_to_source(mCairo);
}

PRBool
gfxContext::PointInFill(const gfxPoint& pt)
{
    return cairo_in_fill(mCairo, pt.x, pt.y);
}

PRBool
gfxContext::PointInStroke(const gfxPoint& pt)
{
    return cairo_in_stroke(mCairo, pt.x, pt.y);
}

gfxRect
gfxContext::GetUserPathExtent()
{
    double xmin, ymin, xmax, ymax;
    cairo_path_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
}

gfxRect
gfxContext::GetUserFillExtent()
{
    double xmin, ymin, xmax, ymax;
    cairo_fill_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
}

gfxRect
gfxContext::GetUserStrokeExtent()
{
    double xmin, ymin, xmax, ymax;
    cairo_stroke_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
    return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
}

already_AddRefed<gfxFlattenedPath>
gfxContext::GetFlattenedPath()
{
    gfxFlattenedPath *path =
        new gfxFlattenedPath(cairo_copy_path_flat(mCairo));
    NS_IF_ADDREF(path);
    return path;
}

PRBool
gfxContext::HasError()
{
     return cairo_status(mCairo) != CAIRO_STATUS_SUCCESS;
}

void
gfxContext::RoundedRectangle(const gfxRect& rect,
                             const gfxCornerSizes& corners,
                             PRBool draw_clockwise)
{
    if(mCrystalCallback) {
        mCrystalCallback->OnRoundedRectangle(rect.pos.x,
            rect.pos.y, rect.size.width, rect.size.height,
            const_cast<gfxCornerSizes &>(corners));
    }

    //
    // For CW drawing, this looks like:
    //
    //  ...******0**      1    C
    //              ****
    //                  ***    2
    //                     **
    //                       *
    //                        *
    //                         3
    //                         *
    //                         *
    //
    // Where 0, 1, 2, 3 are the control points of the Bezier curve for
    // the corner, and C is the actual corner point.
    //
    // At the start of the loop, the current point is assumed to be
    // the point adjacent to the top left corner on the top
    // horizontal.  Note that corner indices start at the top left and
    // continue clockwise, whereas in our loop i = 0 refers to the top
    // right corner.
    //
    // When going CCW, the control points are swapped, and the first
    // corner that's drawn is the top left (along with the top segment).
    //
    // There is considerable latitude in how one chooses the four
    // control points for a Bezier curve approximation to an ellipse.
    // For the overall path to be continuous and show no corner at the
    // endpoints of the arc, points 0 and 3 must be at the ends of the
    // straight segments of the rectangle; points 0, 1, and C must be
    // collinear; and points 3, 2, and C must also be collinear.  This
    // leaves only two free parameters: the ratio of the line segments
    // 01 and 0C, and the ratio of the line segments 32 and 3C.  See
    // the following papers for extensive discussion of how to choose
    // these ratios:
    //
    //   Dokken, Tor, et al. "Good approximation of circles by
    //      curvature-continuous Bezier curves."  Computer-Aided
    //      Geometric Design 7(1990) 33--41.
    //   Goldapp, Michael. "Approximation of circular arcs by cubic
    //      polynomials." Computer-Aided Geometric Design 8(1991) 227--238.
    //   Maisonobe, Luc. "Drawing an elliptical arc using polylines,
    //      quadratic, or cubic Bezier curves."
    //      http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
    //
    // We follow the approach in section 2 of Goldapp (least-error,
    // Hermite-type approximation) and make both ratios equal to
    //
    //          2   2 + n - sqrt(2n + 28)
    //  alpha = - * ---------------------
    //          3           n - 4
    //
    // where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ).
    //
    // This is the result of Goldapp's equation (10b) when the angle
    // swept out by the arc is pi/2, and the parameter "a-bar" is the
    // expression given immediately below equation (21).
    //
    // Using this value, the maximum radial error for a circle, as a
    // fraction of the radius, is on the order of 0.2 x 10^-3.
    // Neither Dokken nor Goldapp discusses error for a general
    // ellipse; Maisonobe does, but his choice of control points
    // follows different constraints, and Goldapp's expression for
    // 'alpha' gives much smaller radial error, even for very flat
    // ellipses, than Maisonobe's equivalent.
    //
    // For the various corners and for each axis, the sign of this
    // constant changes, or it might be 0 -- it's multiplied by the
    // appropriate multiplier from the list before using.
    const gfxFloat alpha = 0.55191497064665766025;

    typedef struct { gfxFloat a, b; } twoFloats;

    twoFloats cwCornerMults[4] = { { -1,  0 },
                                   {  0, -1 },
                                   { +1,  0 },
                                   {  0, +1 } };
    twoFloats ccwCornerMults[4] = { { +1,  0 },
                                    {  0, -1 },
                                    { -1,  0 },
                                    {  0, +1 } };

    twoFloats *cornerMults = draw_clockwise ? cwCornerMults : ccwCornerMults;

    gfxPoint pc, p0, p1, p2, p3;

    if (draw_clockwise)
        cairo_move_to(mCairo, rect.pos.x + corners[NS_CORNER_TOP_LEFT].width, rect.pos.y);
    else
        cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[NS_CORNER_TOP_RIGHT].width, rect.pos.y);

    NS_FOR_CSS_CORNERS(i) {
        // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
        mozilla::css::Corner c = mozilla::css::Corner(draw_clockwise ? ((i+1) % 4) : ((4-i) % 4));

        // i+2 and i+3 respectively.  These are used to index into the corner
        // multiplier table, and were deduced by calculating out the long form
        // of each corner and finding a pattern in the signs and values.
        int i2 = (i+2) % 4;
        int i3 = (i+3) % 4;

        pc = rect.AtCorner(c);

        if (corners[c].width > 0.0 && corners[c].height > 0.0) {
            p0.x = pc.x + cornerMults[i].a * corners[c].width;
            p0.y = pc.y + cornerMults[i].b * corners[c].height;

            p3.x = pc.x + cornerMults[i3].a * corners[c].width;
            p3.y = pc.y + cornerMults[i3].b * corners[c].height;

            p1.x = p0.x + alpha * cornerMults[i2].a * corners[c].width;
            p1.y = p0.y + alpha * cornerMults[i2].b * corners[c].height;

            p2.x = p3.x - alpha * cornerMults[i3].a * corners[c].width;
            p2.y = p3.y - alpha * cornerMults[i3].b * corners[c].height;

            cairo_line_to (mCairo, p0.x, p0.y);
            cairo_curve_to (mCairo,
                            p1.x, p1.y,
                            p2.x, p2.y,
                            p3.x, p3.y);
        } else {
            cairo_line_to (mCairo, pc.x, pc.y);
        }
    }

    cairo_close_path (mCairo);
}
