| |
| /* =========================== 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)) |
| return NULL; |
| CGContextDrawPath(_self->ob_itself, |
| mode); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextFillPath(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextFillPath(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextEOFillPath(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextEOFillPath(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextStrokePath(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextStrokePath(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextFillRect(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGRect rect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CGRect_Convert, &rect)) |
| return NULL; |
| CGContextFillRect(_self->ob_itself, |
| rect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextStrokeRect(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGRect rect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CGRect_Convert, &rect)) |
| return NULL; |
| CGContextStrokeRect(_self->ob_itself, |
| rect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextStrokeRectWithWidth(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGRect rect; |
| float width; |
| if (!PyArg_ParseTuple(_args, "O&f", |
| CGRect_Convert, &rect, |
| &width)) |
| return NULL; |
| CGContextStrokeRectWithWidth(_self->ob_itself, |
| rect, |
| width); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextClearRect(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGRect rect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CGRect_Convert, &rect)) |
| return NULL; |
| CGContextClearRect(_self->ob_itself, |
| rect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextClip(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextClip(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextEOClip(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextEOClip(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextClipToRect(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGRect rect; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CGRect_Convert, &rect)) |
| return NULL; |
| CGContextClipToRect(_self->ob_itself, |
| rect); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetGrayFillColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float gray; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "ff", |
| &gray, |
| &alpha)) |
| return NULL; |
| CGContextSetGrayFillColor(_self->ob_itself, |
| gray, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetGrayStrokeColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float gray; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "ff", |
| &gray, |
| &alpha)) |
| return NULL; |
| CGContextSetGrayStrokeColor(_self->ob_itself, |
| gray, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetRGBFillColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float red; |
| float green; |
| float blue; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "ffff", |
| &red, |
| &green, |
| &blue, |
| &alpha)) |
| return NULL; |
| CGContextSetRGBFillColor(_self->ob_itself, |
| red, |
| green, |
| blue, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetRGBStrokeColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float red; |
| float green; |
| float blue; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "ffff", |
| &red, |
| &green, |
| &blue, |
| &alpha)) |
| return NULL; |
| CGContextSetRGBStrokeColor(_self->ob_itself, |
| red, |
| green, |
| blue, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetCMYKFillColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float cyan; |
| float magenta; |
| float yellow; |
| float black; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "fffff", |
| &cyan, |
| &magenta, |
| &yellow, |
| &black, |
| &alpha)) |
| return NULL; |
| CGContextSetCMYKFillColor(_self->ob_itself, |
| cyan, |
| magenta, |
| yellow, |
| black, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetCMYKStrokeColor(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float cyan; |
| float magenta; |
| float yellow; |
| float black; |
| float alpha; |
| if (!PyArg_ParseTuple(_args, "fffff", |
| &cyan, |
| &magenta, |
| &yellow, |
| &black, |
| &alpha)) |
| return NULL; |
| CGContextSetCMYKStrokeColor(_self->ob_itself, |
| cyan, |
| magenta, |
| yellow, |
| black, |
| alpha); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextGetInterpolationQuality(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| int _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CGContextGetInterpolationQuality(_self->ob_itself); |
| _res = Py_BuildValue("i", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetInterpolationQuality(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| int quality; |
| if (!PyArg_ParseTuple(_args, "i", |
| &quality)) |
| return NULL; |
| CGContextSetInterpolationQuality(_self->ob_itself, |
| quality); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetCharacterSpacing(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float spacing; |
| if (!PyArg_ParseTuple(_args, "f", |
| &spacing)) |
| return NULL; |
| CGContextSetCharacterSpacing(_self->ob_itself, |
| spacing); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetTextPosition(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float x; |
| float y; |
| if (!PyArg_ParseTuple(_args, "ff", |
| &x, |
| &y)) |
| return NULL; |
| CGContextSetTextPosition(_self->ob_itself, |
| x, |
| y); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextGetTextPosition(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGPoint _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CGContextGetTextPosition(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CGPoint_New, &_rv); |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetTextMatrix(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGAffineTransform transform; |
| if (!PyArg_ParseTuple(_args, "O&", |
| CGAffineTransform_Convert, &transform)) |
| return NULL; |
| CGContextSetTextMatrix(_self->ob_itself, |
| transform); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextGetTextMatrix(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGAffineTransform _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = CGContextGetTextMatrix(_self->ob_itself); |
| _res = Py_BuildValue("O&", |
| CGAffineTransform_New, &_rv); |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetTextDrawingMode(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| int mode; |
| if (!PyArg_ParseTuple(_args, "i", |
| &mode)) |
| return NULL; |
| CGContextSetTextDrawingMode(_self->ob_itself, |
| mode); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetFontSize(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float size; |
| if (!PyArg_ParseTuple(_args, "f", |
| &size)) |
| return NULL; |
| CGContextSetFontSize(_self->ob_itself, |
| size); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSelectFont(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| char * name; |
| float size; |
| int textEncoding; |
| if (!PyArg_ParseTuple(_args, "sfi", |
| &name, |
| &size, |
| &textEncoding)) |
| return NULL; |
| CGContextSelectFont(_self->ob_itself, |
| name, |
| size, |
| textEncoding); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextShowText(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| char *cstring__in__; |
| long cstring__len__; |
| int cstring__in_len__; |
| if (!PyArg_ParseTuple(_args, "s#", |
| &cstring__in__, &cstring__in_len__)) |
| return NULL; |
| cstring__len__ = cstring__in_len__; |
| CGContextShowText(_self->ob_itself, |
| cstring__in__, cstring__len__); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextShowTextAtPoint(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| float x; |
| float y; |
| char *cstring__in__; |
| long cstring__len__; |
| int cstring__in_len__; |
| if (!PyArg_ParseTuple(_args, "ffs#", |
| &x, |
| &y, |
| &cstring__in__, &cstring__in_len__)) |
| return NULL; |
| cstring__len__ = cstring__in_len__; |
| CGContextShowTextAtPoint(_self->ob_itself, |
| x, |
| y, |
| cstring__in__, cstring__len__); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextEndPage(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextEndPage(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextFlush(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextFlush(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSynchronize(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| CGContextSynchronize(_self->ob_itself); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_CGContextSetShouldAntialias(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| int shouldAntialias; |
| if (!PyArg_ParseTuple(_args, "i", |
| &shouldAntialias)) |
| return NULL; |
| CGContextSetShouldAntialias(_self->ob_itself, |
| shouldAntialias); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| #ifndef __LP64__ |
| static PyObject *CGContextRefObj_SyncCGContextOriginWithPort(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| CGrafPtr port; |
| if (!PyArg_ParseTuple(_args, "O&", |
| GrafObj_Convert, &port)) |
| return NULL; |
| SyncCGContextOriginWithPort(_self->ob_itself, |
| port); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Rect portRect; |
| RgnHandle region; |
| if (!PyArg_ParseTuple(_args, "O&O&", |
| PyMac_GetRect, &portRect, |
| ResObj_Convert, ®ion)) |
| return NULL; |
| ClipCGContextToRegion(_self->ob_itself, |
| &portRect, |
| region); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| #endif |
| |
| static PyMethodDef CGContextRefObj_methods[] = { |
| {"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1, |
| PyDoc_STR("(float sx, float sy) -> None")}, |
| {"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1, |
| PyDoc_STR("(float tx, float ty) -> None")}, |
| {"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1, |
| PyDoc_STR("(float angle) -> None")}, |
| {"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1, |
| PyDoc_STR("(CGAffineTransform transform) -> None")}, |
| {"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1, |
| PyDoc_STR("() -> (CGAffineTransform _rv)")}, |
| {"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1, |
| PyDoc_STR("(float width) -> None")}, |
| {"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1, |
| PyDoc_STR("(int cap) -> None")}, |
| {"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1, |
| PyDoc_STR("(int join) -> None")}, |
| {"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1, |
| PyDoc_STR("(float limit) -> None")}, |
| {"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1, |
| PyDoc_STR("(float flatness) -> None")}, |
| {"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1, |
| PyDoc_STR("(float alpha) -> None")}, |
| {"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1, |
| PyDoc_STR("(float x, float y) -> None")}, |
| {"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1, |
| PyDoc_STR("(float x, float y) -> None")}, |
| {"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1, |
| PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")}, |
| {"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1, |
| PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")}, |
| {"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1, |
| PyDoc_STR("(CGRect rect) -> None")}, |
| {"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1, |
| PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")}, |
| {"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1, |
| PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")}, |
| {"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1, |
| PyDoc_STR("() -> (int _rv)")}, |
| {"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1, |
| PyDoc_STR("() -> (CGPoint _rv)")}, |
| {"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1, |
| PyDoc_STR("() -> (CGRect _rv)")}, |
| {"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1, |
| PyDoc_STR("(int mode) -> None")}, |
| {"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1, |
| PyDoc_STR("(CGRect rect) -> None")}, |
| {"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1, |
| PyDoc_STR("(CGRect rect) -> None")}, |
| {"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1, |
| PyDoc_STR("(CGRect rect, float width) -> None")}, |
| {"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1, |
| PyDoc_STR("(CGRect rect) -> None")}, |
| {"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1, |
| PyDoc_STR("(CGRect rect) -> None")}, |
| {"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1, |
| PyDoc_STR("(float gray, float alpha) -> None")}, |
| {"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1, |
| PyDoc_STR("(float gray, float alpha) -> None")}, |
| {"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1, |
| PyDoc_STR("(float red, float green, float blue, float alpha) -> None")}, |
| {"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1, |
| PyDoc_STR("(float red, float green, float blue, float alpha) -> None")}, |
| {"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1, |
| PyDoc_STR("(float cyan, float magenta, float yellow, float black, float alpha) -> None")}, |
| {"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1, |
| PyDoc_STR("(float cyan, float magenta, float yellow, float black, float alpha) -> None")}, |
| {"CGContextGetInterpolationQuality", (PyCFunction)CGContextRefObj_CGContextGetInterpolationQuality, 1, |
| PyDoc_STR("() -> (int _rv)")}, |
| {"CGContextSetInterpolationQuality", (PyCFunction)CGContextRefObj_CGContextSetInterpolationQuality, 1, |
| PyDoc_STR("(int quality) -> None")}, |
| {"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1, |
| PyDoc_STR("(float spacing) -> None")}, |
| {"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1, |
| PyDoc_STR("(float x, float y) -> None")}, |
| {"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1, |
| PyDoc_STR("() -> (CGPoint _rv)")}, |
| {"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1, |
| PyDoc_STR("(CGAffineTransform transform) -> None")}, |
| {"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1, |
| PyDoc_STR("() -> (CGAffineTransform _rv)")}, |
| {"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1, |
| PyDoc_STR("(int mode) -> None")}, |
| {"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1, |
| PyDoc_STR("(float size) -> None")}, |
| {"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1, |
| PyDoc_STR("(char * name, float size, int textEncoding) -> None")}, |
| {"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1, |
| PyDoc_STR("(Buffer cstring) -> None")}, |
| {"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1, |
| PyDoc_STR("(float x, float y, Buffer cstring) -> None")}, |
| {"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1, |
| PyDoc_STR("() -> None")}, |
| {"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1, |
| PyDoc_STR("(int shouldAntialias) -> None")}, |
| #ifndef __LP64__ |
| {"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1, |
| PyDoc_STR("(CGrafPtr port) -> None")}, |
| {"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1, |
| PyDoc_STR("(Rect portRect, RgnHandle region) -> None")}, |
| #endif |
| {NULL, NULL, 0} |
| }; |
| |
| #define CGContextRefObj_getsetlist NULL |
| |
| |
| #define CGContextRefObj_compare NULL |
| |
| #define CGContextRefObj_repr NULL |
| |
| #define CGContextRefObj_hash NULL |
| #define CGContextRefObj_tp_init 0 |
| |
| #define CGContextRefObj_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *CGContextRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| CGContextRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CGContextRefObj_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((CGContextRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define CGContextRefObj_tp_free PyObject_Del |
| |
| |
| PyTypeObject CGContextRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CG.CGContextRef", /*tp_name*/ |
| sizeof(CGContextRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) CGContextRefObj_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*tp_setattr*/ |
| (cmpfunc) CGContextRefObj_compare, /*tp_compare*/ |
| (reprfunc) CGContextRefObj_repr, /*tp_repr*/ |
| (PyNumberMethods *)0, /* tp_as_number */ |
| (PySequenceMethods *)0, /* tp_as_sequence */ |
| (PyMappingMethods *)0, /* tp_as_mapping */ |
| (hashfunc) CGContextRefObj_hash, /*tp_hash*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| CGContextRefObj_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| CGContextRefObj_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| CGContextRefObj_tp_init, /* tp_init */ |
| CGContextRefObj_tp_alloc, /* tp_alloc */ |
| CGContextRefObj_tp_new, /* tp_new */ |
| CGContextRefObj_tp_free, /* tp_free */ |
| }; |
| |
| /* ------------------ End object type CGContextRef ------------------ */ |
| |
| |
| #ifndef __LP64__ |
| static PyObject *CG_CreateCGContextForPort(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| GrafPtr port; |
| CGContextRef ctx; |
| OSStatus _err; |
| |
| if (!PyArg_ParseTuple(_args, "O&", GrafObj_Convert, &port)) |
| return NULL; |
| |
| _err = CreateCGContextForPort(port, &ctx); |
| if (_err != noErr) |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", CGContextRefObj_New, ctx); |
| return _res; |
| |
| } |
| #endif |
| |
| static PyMethodDef CG_methods[] = { |
| #ifndef __LP64__ |
| {"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1, |
| PyDoc_STR("(CGrafPtr) -> CGContextRef")}, |
| #endif |
| {NULL, NULL, 0} |
| }; |
| |
| |
| |
| |
| void init_CG(void) |
| { |
| PyObject *m; |
| PyObject *d; |
| |
| |
| |
| |
| m = Py_InitModule("_CG", CG_methods); |
| d = PyModule_GetDict(m); |
| CG_Error = PyMac_GetOSErrException(); |
| if (CG_Error == NULL || |
| PyDict_SetItemString(d, "Error", CG_Error) != 0) |
| return; |
| CGContextRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&CGContextRef_Type) < 0) return; |
| Py_INCREF(&CGContextRef_Type); |
| PyModule_AddObject(m, "CGContextRef", (PyObject *)&CGContextRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&CGContextRef_Type); |
| PyModule_AddObject(m, "CGContextRefType", (PyObject *)&CGContextRef_Type); |
| } |
| |
| /* ========================= End module _CG ========================= */ |
| |