diff options
Diffstat (limited to 'Mac/Modules/cg/_CGmodule.c')
| -rwxr-xr-x | Mac/Modules/cg/_CGmodule.c | 1332 |
1 files changed, 1332 insertions, 0 deletions
diff --git a/Mac/Modules/cg/_CGmodule.c b/Mac/Modules/cg/_CGmodule.c new file mode 100755 index 0000000..6523e71 --- /dev/null +++ b/Mac/Modules/cg/_CGmodule.c @@ -0,0 +1,1332 @@ + +/* =========================== Module _CG =========================== */ + +#include "Python.h" + + + +#include "macglue.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) + + +#ifdef WITHOUT_FRAMEWORKS +#include <Quickdraw.h> +#include <CGContext.h> +#else +#include <CoreGraphics/CoreGraphics.h> +#endif + +#if !TARGET_API_MAC_OSX + /* This code is adapted from the CallMachOFramework demo at: + http://developer.apple.com/samplecode/Sample_Code/Runtime_Architecture/CallMachOFramework.htm + It allows us to call Mach-O functions from CFM apps. */ + + #include <Folders.h> + #include "CFMLateImport.h" + + static OSStatus LoadFrameworkBundle(CFStringRef framework, CFBundleRef *bundlePtr) + // This routine finds a the named framework and creates a CFBundle + // object for it. It looks for the framework in the frameworks folder, + // as defined by the Folder Manager. Currently this is + // "/System/Library/Frameworks", but we recommend that you avoid hard coded + // paths to ensure future compatibility. + // + // You might think that you could use CFBundleGetBundleWithIdentifier but + // that only finds bundles that are already loaded into your context. + // That would work in the case of the System framework but it wouldn't + // work if you're using some other, less-obvious, framework. + { + OSStatus err; + FSRef frameworksFolderRef; + CFURLRef baseURL; + CFURLRef bundleURL; + + *bundlePtr = nil; + + baseURL = nil; + bundleURL = nil; + + // Find the frameworks folder and create a URL for it. + + err = FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, true, &frameworksFolderRef); + if (err == noErr) { + baseURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &frameworksFolderRef); + if (baseURL == nil) { + err = coreFoundationUnknownErr; + } + } + + // Append the name of the framework to the URL. + + if (err == noErr) { + bundleURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, framework, false); + if (bundleURL == nil) { + err = coreFoundationUnknownErr; + } + } + + // Create a bundle based on that URL and load the bundle into memory. + // We never unload the bundle, which is reasonable in this case because + // the sample assumes that you'll be calling functions from this + // framework throughout the life of your application. + + if (err == noErr) { + *bundlePtr = CFBundleCreate(kCFAllocatorSystemDefault, bundleURL); + if (*bundlePtr == nil) { + err = coreFoundationUnknownErr; + } + } + if (err == noErr) { + if ( ! CFBundleLoadExecutable( *bundlePtr ) ) { + err = coreFoundationUnknownErr; + } + } + + // Clean up. + + if (err != noErr && *bundlePtr != nil) { + CFRelease(*bundlePtr); + *bundlePtr = nil; + } + if (bundleURL != nil) { + CFRelease(bundleURL); + } + if (baseURL != nil) { + CFRelease(baseURL); + } + + return err; + } + + + + // The CFMLateImport approach requires that you define a fragment + // initialisation routine that latches the fragment's connection + // ID and locator. If your code already has a fragment initialiser + // you will have to integrate the following into it. + + static CFragConnectionID gFragToFixConnID; + static FSSpec gFragToFixFile; + static CFragSystem7DiskFlatLocator gFragToFixLocator; + + extern OSErr FragmentInit(const CFragInitBlock *initBlock); + extern OSErr FragmentInit(const CFragInitBlock *initBlock) + { + __initialize(initBlock); /* call the "original" initializer */ + gFragToFixConnID = (CFragConnectionID) initBlock->closureID; + gFragToFixFile = *(initBlock->fragLocator.u.onDisk.fileSpec); + gFragToFixLocator = initBlock->fragLocator.u.onDisk; + gFragToFixLocator.fileSpec = &gFragToFixFile; + + return noErr; + } + +#endif + +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) + +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); + PyMem_DEL(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 r; + float g; + float b; + float alpha; + if (!PyArg_ParseTuple(_args, "ffff", + &r, + &g, + &b, + &alpha)) + return NULL; + CGContextSetRGBFillColor(_self->ob_itself, + r, + g, + b, + alpha); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CGContextRefObj_CGContextSetRGBStrokeColor(CGContextRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + float r; + float g; + float b; + float alpha; + if (!PyArg_ParseTuple(_args, "ffff", + &r, + &g, + &b, + &alpha)) + return NULL; + CGContextSetRGBStrokeColor(_self->ob_itself, + r, + g, + b, + alpha); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CGContextRefObj_CGContextSetCMYKFillColor(CGContextRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + float c; + float m; + float y; + float k; + float alpha; + if (!PyArg_ParseTuple(_args, "fffff", + &c, + &m, + &y, + &k, + &alpha)) + return NULL; + CGContextSetCMYKFillColor(_self->ob_itself, + c, + m, + y, + k, + alpha); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CGContextRefObj_CGContextSetCMYKStrokeColor(CGContextRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + float c; + float m; + float y; + float k; + float alpha; + if (!PyArg_ParseTuple(_args, "fffff", + &c, + &m, + &y, + &k, + &alpha)) + return NULL; + CGContextSetCMYKStrokeColor(_self->ob_itself, + c, + m, + y, + k, + alpha); + 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; +} + +static PyMethodDef CGContextRefObj_methods[] = { + {"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1, + "() -> None"}, + {"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1, + "() -> None"}, + {"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1, + "(float sx, float sy) -> None"}, + {"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1, + "(float tx, float ty) -> None"}, + {"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1, + "(float angle) -> None"}, + {"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1, + "(CGAffineTransform transform) -> None"}, + {"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1, + "() -> (CGAffineTransform _rv)"}, + {"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1, + "(float width) -> None"}, + {"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1, + "(int cap) -> None"}, + {"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1, + "(int join) -> None"}, + {"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1, + "(float limit) -> None"}, + {"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1, + "(float flatness) -> None"}, + {"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1, + "(float alpha) -> None"}, + {"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1, + "() -> None"}, + {"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1, + "(float x, float y) -> None"}, + {"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1, + "(float x, float y) -> None"}, + {"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1, + "(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None"}, + {"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1, + "(float cpx, float cpy, float x, float y) -> None"}, + {"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1, + "() -> None"}, + {"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1, + "(CGRect rect) -> None"}, + {"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1, + "(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None"}, + {"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1, + "(float x1, float y1, float x2, float y2, float radius) -> None"}, + {"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1, + "() -> (int _rv)"}, + {"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1, + "() -> (CGPoint _rv)"}, + {"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1, + "() -> (CGRect _rv)"}, + {"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1, + "(int mode) -> None"}, + {"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1, + "() -> None"}, + {"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1, + "() -> None"}, + {"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1, + "() -> None"}, + {"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1, + "(CGRect rect) -> None"}, + {"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1, + "(CGRect rect) -> None"}, + {"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1, + "(CGRect rect, float width) -> None"}, + {"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1, + "(CGRect rect) -> None"}, + {"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1, + "() -> None"}, + {"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1, + "() -> None"}, + {"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1, + "(CGRect rect) -> None"}, + {"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1, + "(float gray, float alpha) -> None"}, + {"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1, + "(float gray, float alpha) -> None"}, + {"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1, + "(float r, float g, float b, float alpha) -> None"}, + {"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1, + "(float r, float g, float b, float alpha) -> None"}, + {"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1, + "(float c, float m, float y, float k, float alpha) -> None"}, + {"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1, + "(float c, float m, float y, float k, float alpha) -> None"}, + {"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1, + "(float spacing) -> None"}, + {"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1, + "(float x, float y) -> None"}, + {"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1, + "() -> (CGPoint _rv)"}, + {"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1, + "(CGAffineTransform transform) -> None"}, + {"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1, + "() -> (CGAffineTransform _rv)"}, + {"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1, + "(int mode) -> None"}, + {"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1, + "(float size) -> None"}, + {"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1, + "(char * name, float size, int textEncoding) -> None"}, + {"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1, + "(Buffer cstring) -> None"}, + {"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1, + "(float x, float y, Buffer cstring) -> None"}, + {"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1, + "() -> None"}, + {"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1, + "() -> None"}, + {"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1, + "() -> None"}, + {"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1, + "(int shouldAntialias) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain CGContextRefObj_chain = { CGContextRefObj_methods, NULL }; + +static PyObject *CGContextRefObj_getattr(CGContextRefObject *self, char *name) +{ + return Py_FindMethodInChain(&CGContextRefObj_chain, (PyObject *)self, name); +} + +#define CGContextRefObj_setattr NULL + +#define CGContextRefObj_compare NULL + +#define CGContextRefObj_repr NULL + +#define CGContextRefObj_hash NULL + +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) CGContextRefObj_getattr, /*tp_getattr*/ + (setattrfunc) CGContextRefObj_setattr, /*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*/ +}; + +/* ------------------ End object type CGContextRef ------------------ */ + + +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; + +} + +static PyMethodDef CG_methods[] = { + {"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1, + "(CGrafPtr) -> CGContextRef"}, + {NULL, NULL, 0} +}; + + + + +void init_CG(void) +{ + PyObject *m; + PyObject *d; + + + +#if !TARGET_API_MAC_OSX + CFBundleRef sysBundle; + OSStatus err; + + if (&LoadFrameworkBundle == NULL) { + PyErr_SetString(PyExc_ImportError, "CoreCraphics not supported"); + return; + } + err = LoadFrameworkBundle(CFSTR("ApplicationServices.framework"), &sysBundle); + if (err == noErr) + err = CFMLateImportBundle(&gFragToFixLocator, gFragToFixConnID, FragmentInit, "\pCGStubLib", sysBundle); + if (err != noErr) { + PyErr_SetString(PyExc_ImportError, "CoreCraphics not supported"); + return; + }; +#endif /* !TARGET_API_MAC_OSX */ + + + 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; + Py_INCREF(&CGContextRef_Type); + if (PyDict_SetItemString(d, "CGContextRefType", (PyObject *)&CGContextRef_Type) != 0) + Py_FatalError("can't initialize CGContextRefType"); +} + +/* ========================= End module _CG ========================= */ + |