mirror of
https://github.com/python/cpython.git
synced 2025-11-04 07:31:38 +00:00
1411 lines
39 KiB
C
Executable file
1411 lines
39 KiB
C
Executable file
|
|
/* =========================== Module _CG =========================== */
|
|
|
|
#include "Python.h"
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
#include "pywintoolbox.h"
|
|
#else
|
|
#include "macglue.h"
|
|
#include "pymactoolbox.h"
|
|
#endif
|
|
|
|
/* 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 <ApplicationServices/ApplicationServices.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 || 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 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 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;
|
|
}
|
|
|
|
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 r, float g, float b, float alpha) -> None")},
|
|
{"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1,
|
|
PyDoc_STR("(float r, float g, float b, float alpha) -> None")},
|
|
{"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1,
|
|
PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")},
|
|
{"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1,
|
|
PyDoc_STR("(float c, float m, float y, float k, float alpha) -> 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")},
|
|
{"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1,
|
|
PyDoc_STR("(CGrafPtr port) -> None")},
|
|
{"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1,
|
|
PyDoc_STR("(Rect portRect, RgnHandle region) -> None")},
|
|
{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 ------------------ */
|
|
|
|
|
|
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,
|
|
PyDoc_STR("(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;
|
|
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 ========================= */
|
|
|