/* =========================== Module _CG =========================== */

#include "Python.h"

#include "pymactoolbox.h"

/* Macro to test whether a weak-loaded CFM function exists */

#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

        PyErr_SetString(PyExc_NotImplementedError, \

        "Not available in this shared library/OS version"); \

        return NULL; \

    }} while(0)

#include <ApplicationServices/ApplicationServices.h>

extern int GrafObj_Convert(PyObject *, GrafPtr *);

/*

** Manual converters

*/

PyObject *CGPoint_New(CGPoint *itself)

{

        return Py_BuildValue("(ff)",

                        itself->x,

                        itself->y);

}

int

CGPoint_Convert(PyObject *v, CGPoint *p_itself)

{

        if( !PyArg_Parse(v, "(ff)",

                        &p_itself->x,

                        &p_itself->y) )

                return 0;

        return 1;

}

PyObject *CGRect_New(CGRect *itself)

{

        return Py_BuildValue("(ffff)",

                        itself->origin.x,

                        itself->origin.y,

                        itself->size.width,

                        itself->size.height);

}

int

CGRect_Convert(PyObject *v, CGRect *p_itself)

{

        if( !PyArg_Parse(v, "(ffff)",

                        &p_itself->origin.x,

                        &p_itself->origin.y,

                        &p_itself->size.width,

                        &p_itself->size.height) )

                return 0;

        return 1;

}

PyObject *CGAffineTransform_New(CGAffineTransform *itself)

{

        return Py_BuildValue("(ffffff)",

                        itself->a,

                        itself->b,

                        itself->c,

                        itself->d,

                        itself->tx,

                        itself->ty);

}

int

CGAffineTransform_Convert(PyObject *v, CGAffineTransform *p_itself)

{

        if( !PyArg_Parse(v, "(ffffff)",

                        &p_itself->a,

                        &p_itself->b,

                        &p_itself->c,

                        &p_itself->d,

                        &p_itself->tx,

                        &p_itself->ty) )

                return 0;

        return 1;

}

static PyObject *CG_Error;

/* -------------------- Object type CGContextRef -------------------- */

PyTypeObject CGContextRef_Type;

#define CGContextRefObj_Check(x) ((x)->ob_type == &CGContextRef_Type || PyObject_TypeCheck((x), &CGContextRef_Type))

typedef struct CGContextRefObject {

	PyObject_HEAD

	CGContextRef ob_itself;

} CGContextRefObject;

PyObject *CGContextRefObj_New(CGContextRef itself)

{

	CGContextRefObject *it;

	it = PyObject_NEW(CGContextRefObject, &CGContextRef_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	return (PyObject *)it;

}

int CGContextRefObj_Convert(PyObject *v, CGContextRef *p_itself)

{

	if (!CGContextRefObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "CGContextRef required");

		return 0;

	}

	*p_itself = ((CGContextRefObject *)v)->ob_itself;

	return 1;

}

static void CGContextRefObj_dealloc(CGContextRefObject *self)

{

	CGContextRelease(self->ob_itself);

	self->ob_type->tp_free((PyObject *)self);

}

static PyObject *CGContextRefObj_CGContextSaveGState(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CGContextSaveGState(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextRestoreGState(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CGContextRestoreGState(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextScaleCTM(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float sx;

	float sy;

	if (!PyArg_ParseTuple(_args, "ff",

	                      &sx,

	                      &sy))

		return NULL;

	CGContextScaleCTM(_self->ob_itself,

	                  sx,

	                  sy);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextTranslateCTM(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float tx;

	float ty;

	if (!PyArg_ParseTuple(_args, "ff",

	                      &tx,

	                      &ty))

		return NULL;

	CGContextTranslateCTM(_self->ob_itself,

	                      tx,

	                      ty);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextRotateCTM(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float angle;

	if (!PyArg_ParseTuple(_args, "f",

	                      &angle))

		return NULL;

	CGContextRotateCTM(_self->ob_itself,

	                   angle);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextConcatCTM(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGAffineTransform transform;

	if (!PyArg_ParseTuple(_args, "O&",

	                      CGAffineTransform_Convert, &transform))

		return NULL;

	CGContextConcatCTM(_self->ob_itself,

	                   transform);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextGetCTM(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGAffineTransform _rv;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CGContextGetCTM(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CGAffineTransform_New, &_rv);

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetLineWidth(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float width;

	if (!PyArg_ParseTuple(_args, "f",

	                      &width))

		return NULL;

	CGContextSetLineWidth(_self->ob_itself,

	                      width);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetLineCap(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	int cap;

	if (!PyArg_ParseTuple(_args, "i",

	                      &cap))

		return NULL;

	CGContextSetLineCap(_self->ob_itself,

	                    cap);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetLineJoin(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	int join;

	if (!PyArg_ParseTuple(_args, "i",

	                      &join))

		return NULL;

	CGContextSetLineJoin(_self->ob_itself,

	                     join);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetMiterLimit(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float limit;

	if (!PyArg_ParseTuple(_args, "f",

	                      &limit))

		return NULL;

	CGContextSetMiterLimit(_self->ob_itself,

	                       limit);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetFlatness(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float flatness;

	if (!PyArg_ParseTuple(_args, "f",

	                      &flatness))

		return NULL;

	CGContextSetFlatness(_self->ob_itself,

	                     flatness);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextSetAlpha(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float alpha;

	if (!PyArg_ParseTuple(_args, "f",

	                      &alpha))

		return NULL;

	CGContextSetAlpha(_self->ob_itself,

	                  alpha);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextBeginPath(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CGContextBeginPath(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextMoveToPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float x;

	float y;

	if (!PyArg_ParseTuple(_args, "ff",

	                      &x,

	                      &y))

		return NULL;

	CGContextMoveToPoint(_self->ob_itself,

	                     x,

	                     y);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddLineToPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float x;

	float y;

	if (!PyArg_ParseTuple(_args, "ff",

	                      &x,

	                      &y))

		return NULL;

	CGContextAddLineToPoint(_self->ob_itself,

	                        x,

	                        y);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddCurveToPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float cp1x;

	float cp1y;

	float cp2x;

	float cp2y;

	float x;

	float y;

	if (!PyArg_ParseTuple(_args, "ffffff",

	                      &cp1x,

	                      &cp1y,

	                      &cp2x,

	                      &cp2y,

	                      &x,

	                      &y))

		return NULL;

	CGContextAddCurveToPoint(_self->ob_itself,

	                         cp1x,

	                         cp1y,

	                         cp2x,

	                         cp2y,

	                         x,

	                         y);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddQuadCurveToPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float cpx;

	float cpy;

	float x;

	float y;

	if (!PyArg_ParseTuple(_args, "ffff",

	                      &cpx,

	                      &cpy,

	                      &x,

	                      &y))

		return NULL;

	CGContextAddQuadCurveToPoint(_self->ob_itself,

	                             cpx,

	                             cpy,

	                             x,

	                             y);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextClosePath(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CGContextClosePath(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddRect(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGRect rect;

	if (!PyArg_ParseTuple(_args, "O&",

	                      CGRect_Convert, &rect))

		return NULL;

	CGContextAddRect(_self->ob_itself,

	                 rect);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddArc(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float x;

	float y;

	float radius;

	float startAngle;

	float endAngle;

	int clockwise;

	if (!PyArg_ParseTuple(_args, "fffffi",

	                      &x,

	                      &y,

	                      &radius,

	                      &startAngle,

	                      &endAngle,

	                      &clockwise))

		return NULL;

	CGContextAddArc(_self->ob_itself,

	                x,

	                y,

	                radius,

	                startAngle,

	                endAngle,

	                clockwise);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextAddArcToPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	float x1;

	float y1;

	float x2;

	float y2;

	float radius;

	if (!PyArg_ParseTuple(_args, "fffff",

	                      &x1,

	                      &y1,

	                      &x2,

	                      &y2,

	                      &radius))

		return NULL;

	CGContextAddArcToPoint(_self->ob_itself,

	                       x1,

	                       y1,

	                       x2,

	                       y2,

	                       radius);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CGContextRefObj_CGContextIsPathEmpty(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	int _rv;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CGContextIsPathEmpty(_self->ob_itself);

	_res = Py_BuildValue("i",

	                     _rv);

	return _res;

}

static PyObject *CGContextRefObj_CGContextGetPathCurrentPoint(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGPoint _rv;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CGContextGetPathCurrentPoint(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CGPoint_New, &_rv);

	return _res;

}

static PyObject *CGContextRefObj_CGContextGetPathBoundingBox(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CGRect _rv;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CGContextGetPathBoundingBox(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CGRect_New, &_rv);

	return _res;

}

static PyObject *CGContextRefObj_CGContextDrawPath(CGContextRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	int mode;

	if (!PyArg_ParseTuple(_args, "i",

	                      &mode))