#include <Cocoa/Cocoa.h>

#include <ApplicationServices/ApplicationServices.h>

#include <sys/socket.h>

#include <Python.h>

#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION

#include "numpy/arrayobject.h"

#include "path_cleanup.h"

#define PYOSINPUTHOOK_REPETITIVE 1 /* Remove this once Python is fixed */

#if PY_MAJOR_VERSION >= 3

#define PY3K 1

#else

#define PY3K 0

#endif

#if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >=3)

#define PY33 1

#else

#define PY33 0

#endif

/* Must define Py_TYPE for Python 2.5 or older */

#ifndef Py_TYPE

# define Py_TYPE(o) ((o)->ob_type)

#endif

/* Must define PyVarObject_HEAD_INIT for Python 2.5 or older */

#ifndef PyVarObject_HEAD_INIT

#define PyVarObject_HEAD_INIT(type, size) \

PyObject_HEAD_INIT(type) size,

#endif

/* Proper way to check for the OS X version we are compiling for, from

http://developer.apple.com/documentation/DeveloperTools/Conceptual/cross_development */

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1050

#define COMPILING_FOR_10_5

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060

#define COMPILING_FOR_10_6

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 10100

#define COMPILING_FOR_10_10

#endif

/* Use Atsui for Mac OS X 10.4, CoreText for Mac OS X 10.5 */

#ifndef COMPILING_FOR_10_5

static int ngc = 0; /* The number of graphics contexts in use */

/* For drawing Unicode strings with ATSUI */

static ATSUStyle style = NULL;

static ATSUTextLayout layout = NULL;

#endif

/* CGFloat was defined in Mac OS X 10.5 */

#ifndef CGFLOAT_DEFINED

#define CGFloat float

#endif

/* Various NSApplicationDefined event subtypes */

#define STOP_EVENT_LOOP 2

#define WINDOW_CLOSING 3

/* Path definitions */

#define STOP 0

#define MOVETO 1

#define LINETO 2

#define CURVE3 3

#define CURVE4 4

#define CLOSEPOLY 0x4f

/* Hatching */

#define HATCH_SIZE 72

/* -------------------------- Helper function ---------------------------- */

static void

_stdin_callback(CFReadStreamRef stream, CFStreamEventType eventType, void* info)

{

CFRunLoopRef runloop = info;

CFRunLoopStop(runloop);

}

static int sigint_fd = -1;

static void _sigint_handler(int sig)

{

const char c = 'i';

write(sigint_fd, &c, 1);

}

static void _sigint_callback(CFSocketRef s,

CFSocketCallBackType type,

CFDataRef address,

const void * data,

void *info)

{

char c;

int* interrupted = info;

CFSocketNativeHandle handle = CFSocketGetNative(s);

CFRunLoopRef runloop = CFRunLoopGetCurrent();

read(handle, &c, 1);

*interrupted = 1;

CFRunLoopStop(runloop);

}

static CGEventRef _eventtap_callback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)

{

CFRunLoopRef runloop = refcon;

CFRunLoopStop(runloop);

return event;

}

static int wait_for_stdin(void)

{

int interrupted = 0;

const UInt8 buffer[] = "/dev/fd/0";

const CFIndex n = (CFIndex)strlen((char*)buffer);

CFRunLoopRef runloop = CFRunLoopGetCurrent();

CFURLRef url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,

buffer,

n,

false);

CFReadStreamRef stream = CFReadStreamCreateWithFile(kCFAllocatorDefault,

url);

CFRelease(url);

CFReadStreamOpen(stream);

#ifdef PYOSINPUTHOOK_REPETITIVE

if (!CFReadStreamHasBytesAvailable(stream))

/* This is possible because of how PyOS_InputHook is called from Python */

{

#endif

int error;

int channel[2];

CFSocketRef sigint_socket = NULL;

PyOS_sighandler_t py_sigint_handler = NULL;

CFStreamClientContext clientContext = {0, NULL, NULL, NULL, NULL};

clientContext.info = runloop;

CFReadStreamSetClient(stream,

kCFStreamEventHasBytesAvailable,

_stdin_callback,

&clientContext);

CFReadStreamScheduleWithRunLoop(stream, runloop, kCFRunLoopDefaultMode);

error = socketpair(AF_UNIX, SOCK_STREAM, 0, channel);

if (error==0)

{

CFSocketContext context;

context.version = 0;

context.info = &interrupted;

context.retain = NULL;

context.release = NULL;

context.copyDescription = NULL;

fcntl(channel[0], F_SETFL, O_WRONLY | O_NONBLOCK);

sigint_socket = CFSocketCreateWithNative(

kCFAllocatorDefault,

channel[1],

kCFSocketReadCallBack,

_sigint_callback,

&context);

if (sigint_socket)

{

CFRunLoopSourceRef source;

source = CFSocketCreateRunLoopSource(kCFAllocatorDefault,

sigint_socket,

0);

CFRelease(sigint_socket);

if (source)

{

CFRunLoopAddSource(runloop, source, kCFRunLoopDefaultMode);

CFRelease(source);

sigint_fd = channel[0];

py_sigint_handler = PyOS_setsig(SIGINT, _sigint_handler);

}

}

}

NSEvent* event;

NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

while (true) {

while (true) {

event = [NSApp nextEventMatchingMask: NSAnyEventMask

untilDate: [NSDate distantPast]

inMode: NSDefaultRunLoopMode

dequeue: YES];

if (!event) break;

[NSApp sendEvent: event];

}

CFRunLoopRun();

if (interrupted || CFReadStreamHasBytesAvailable(stream)) break;

}

[pool release];

if (py_sigint_handler) PyOS_setsig(SIGINT, py_sigint_handler);

CFReadStreamUnscheduleFromRunLoop(stream,

runloop,

kCFRunLoopCommonModes);

if (sigint_socket) CFSocketInvalidate(sigint_socket);

if (error==0) {

close(channel[0]);

close(channel[1]);

}

#ifdef PYOSINPUTHOOK_REPETITIVE

}

#endif

CFReadStreamClose(stream);

CFRelease(stream);

if (interrupted) {

errno = EINTR;

raise(SIGINT);

return -1;

}

return 1;

}

#ifndef COMPILING_FOR_10_5

static int _init_atsui(void)

{

OSStatus status;

status = ATSUCreateStyle(&style);

if (status!=noErr)

{

PyErr_SetString(PyExc_RuntimeError, "ATSUCreateStyle failed");

return 0;

}

status = ATSUCreateTextLayout(&layout);

if (status!=noErr)

{

status = ATSUDisposeStyle(style);

if (status!=noErr)

PyErr_WarnEx(PyExc_RuntimeWarning, "ATSUDisposeStyle failed", 1);

PyErr_SetString(PyExc_RuntimeError, "ATSUCreateTextLayout failed");

return 0;

}

return 1;

}

static void _dealloc_atsui(void)

{

OSStatus status;

status = ATSUDisposeStyle(style);

if (status!=noErr)

PyErr_WarnEx(PyExc_RuntimeWarning, "ATSUDisposeStyle failed", 1);

status = ATSUDisposeTextLayout(layout);

if (status!=noErr)

PyErr_WarnEx(PyExc_RuntimeWarning, "ATSUDisposeTextLayout failed", 1);

}

#endif

static int _draw_path(CGContextRef cr, void* iterator, int nmax)

{

double x1, y1, x2, y2;

static unsigned code = STOP;

static double xs, ys;

CGPoint current;

int n = 0;

if (code == MOVETO) CGContextMoveToPoint(cr, xs, ys);

while (true)

{

code = get_vertex(iterator, &x1, &y1);

if (code == CLOSEPOLY)

{

if (n > 0) CGContextClosePath(cr);

n++;

}

else if (code == STOP)

{

break;

}

else if (code == MOVETO)

{

CGContextMoveToPoint(cr, x1, y1);

}

else if (code==LINETO)

{

CGContextAddLineToPoint(cr, x1, y1);

n++;

}

else if (code==CURVE3)

{

get_vertex(iterator, &xs, &ys);

CGContextAddQuadCurveToPoint(cr, x1, y1, xs, ys);

n+=2;

}

else if (code==CURVE4)

{

get_vertex(iterator, &x2, &y2);

get_vertex(iterator, &xs, &ys);

CGContextAddCurveToPoint(cr, x1, y1, x2, y2, xs, ys);

n+=3;

}

if (n >= nmax)

{

switch (code)

{

case MOVETO:

case LINETO:

xs = x1;

ys = y1;

break;

case CLOSEPOLY:

current = CGContextGetPathCurrentPoint(cr);

xs = current.x;

ys = current.y;

break;

/* nothing needed for CURVE3, CURVE4 */

}

code = MOVETO;

return -n;

}

}

return n;

}

static void _draw_hatch(void *info, CGContextRef cr)

{

int n;

PyObject* hatchpath = (PyObject*)info;

PyObject* transform;

int nd = 2;

npy_intp dims[2] = {3, 3};

int typenum = NPY_DOUBLE;

double data[9] = {HATCH_SIZE, 0, 0, 0, HATCH_SIZE, 0, 0, 0, 1};

double rect[4] = { 0.0, 0.0, HATCH_SIZE, HATCH_SIZE};

transform = PyArray_SimpleNewFromData(nd, dims, typenum, data);

if (!transform)

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyErr_Print();

PyGILState_Release(gstate);

return;

}

void* iterator = get_path_iterator(hatchpath,

transform,

0,

0,

rect,

SNAP_FALSE,

1.0,

0);

Py_DECREF(transform);

if (!iterator)

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyErr_SetString(PyExc_RuntimeError, "failed to obtain path iterator for hatching");

PyErr_Print();

PyGILState_Release(gstate);

return;

}

n = _draw_path(cr, iterator, INT_MAX);

free_path_iterator(iterator);

if (n==0) return;

CGContextSetLineWidth(cr, 1.0);

CGContextSetLineCap(cr, kCGLineCapSquare);

CGContextDrawPath(cr, kCGPathFillStroke);

}

static void _release_hatch(void* info)

{

PyObject* hatchpath = (PyObject*)info;

Py_DECREF(hatchpath);

}

/* ---------------------------- Cocoa classes ---------------------------- */

@interface WindowServerConnectionManager : NSObject

{

}

+ (WindowServerConnectionManager*)sharedManager;

- (void)launch:(NSNotification*)notification;

@end

@interface Window : NSWindow

{ PyObject* manager;

}

- (Window*)initWithContentRect:(NSRect)rect styleMask:(unsigned int)mask backing:(NSBackingStoreType)bufferingType defer:(BOOL)deferCreation withManager: (PyObject*)theManager;

- (NSRect)constrainFrameRect:(NSRect)rect toScreen:(NSScreen*)screen;

- (BOOL)closeButtonPressed;

- (void)dealloc;

@end

@interface ToolWindow : NSWindow

{

}

- (ToolWindow*)initWithContentRect:(NSRect)rect master:(NSWindow*)window;

- (void)masterCloses:(NSNotification*)notification;

- (void)close;

@end

#ifdef COMPILING_FOR_10_6

@interface View : NSView <NSWindowDelegate>

#else

@interface View : NSView

#endif

{ PyObject* canvas;

NSRect rubberband;

BOOL inside;

NSTrackingRectTag tracking;

}

- (void)dealloc;

- (void)drawRect:(NSRect)rect;

- (void)windowDidResize:(NSNotification*)notification;

- (View*)initWithFrame:(NSRect)rect;

- (void)setCanvas: (PyObject*)newCanvas;

- (void)windowWillClose:(NSNotification*)notification;

- (BOOL)windowShouldClose:(NSNotification*)notification;

- (BOOL)isFlipped;

- (void)mouseEntered:(NSEvent*)event;

- (void)mouseExited:(NSEvent*)event;

- (void)mouseDown:(NSEvent*)event;

- (void)mouseUp:(NSEvent*)event;

- (void)mouseDragged:(NSEvent*)event;

- (void)mouseMoved:(NSEvent*)event;

- (void)rightMouseDown:(NSEvent*)event;

- (void)rightMouseUp:(NSEvent*)event;

- (void)rightMouseDragged:(NSEvent*)event;

- (void)otherMouseDown:(NSEvent*)event;

- (void)otherMouseUp:(NSEvent*)event;

- (void)otherMouseDragged:(NSEvent*)event;

- (void)setRubberband:(NSRect)rect;

- (void)removeRubberband;

- (const char*)convertKeyEvent:(NSEvent*)event;

- (void)keyDown:(NSEvent*)event;

- (void)keyUp:(NSEvent*)event;

- (void)scrollWheel:(NSEvent *)event;

- (BOOL)acceptsFirstResponder;

//- (void)flagsChanged:(NSEvent*)event;

@end

@interface ScrollableButton : NSButton

{

SEL scrollWheelUpAction;

SEL scrollWheelDownAction;

}

- (void)setScrollWheelUpAction:(SEL)action;

- (void)setScrollWheelDownAction:(SEL)action;

- (void)scrollWheel:(NSEvent *)event;

@end

@interface MenuItem: NSMenuItem

{ int index;

}

+ (MenuItem*)menuItemWithTitle:(NSString*)title;

+ (MenuItem*)menuItemSelectAll;

+ (MenuItem*)menuItemInvertAll;

+ (MenuItem*)menuItemForAxis:(int)i;

- (void)toggle:(id)sender;

- (void)selectAll:(id)sender;

- (void)invertAll:(id)sender;

- (int)index;

@end

/* ---------------------------- Python classes ---------------------------- */

typedef struct {

PyObject_HEAD

CGContextRef cr;

NSSize size;

int level;

BOOL forced_alpha;

CGFloat color[4];

float dpi;

} GraphicsContext;

static CGMutablePathRef _create_path(void* iterator)

{

unsigned code;

CGMutablePathRef p;

double x1, y1, x2, y2, x3, y3;

p = CGPathCreateMutable();

if (!p) return NULL;

while (true)

{

code = get_vertex(iterator, &x1, &y1);

if (code == CLOSEPOLY)

{

CGPathCloseSubpath(p);

}

else if (code == STOP)

{

break;

}

else if (code == MOVETO)

{

CGPathMoveToPoint(p, NULL, x1, y1);

}

else if (code==LINETO)

{

CGPathAddLineToPoint(p, NULL, x1, y1);

}

else if (code==CURVE3)

{

get_vertex(iterator, &x2, &y2);

CGPathAddQuadCurveToPoint(p, NULL, x1, y1, x2, y2);

}

else if (code==CURVE4)

{

get_vertex(iterator, &x2, &y2);

get_vertex(iterator, &x3, &y3);

CGPathAddCurveToPoint(p, NULL, x1, y1, x2, y2, x3, y3);

}

}

return p;

}

static int _get_snap(GraphicsContext* self, enum e_snap_mode* mode)

{

PyObject* snap = PyObject_CallMethod((PyObject*)self, "get_snap", "");

if(!snap) return 0;

if(snap==Py_None) *mode = SNAP_AUTO;

else if (PyBool_Check(snap)) *mode = SNAP_TRUE;

else *mode = SNAP_FALSE;

Py_DECREF(snap);

return 1;

}

static PyObject*

GraphicsContext_new(PyTypeObject* type, PyObject *args, PyObject *kwds)

{

GraphicsContext* self = (GraphicsContext*)type->tp_alloc(type, 0);

if (!self) return NULL;

self->cr = NULL;

self->level = 0;

self->forced_alpha = FALSE;

#ifndef COMPILING_FOR_10_5

if (ngc==0)

{

int ok = _init_atsui();

if (!ok)

{

return NULL;

}

}

ngc++;

#endif

return (PyObject*) self;

}

#ifndef COMPILING_FOR_10_5

static void

GraphicsContext_dealloc(GraphicsContext *self)

{

ngc--;

if (ngc==0) _dealloc_atsui();

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

}

#endif

static PyObject*

GraphicsContext_repr(GraphicsContext* self)

{

#if PY3K

return PyUnicode_FromFormat("GraphicsContext object %p wrapping the Quartz 2D graphics context %p", (void*)self, (void*)(self->cr));

#else

return PyString_FromFormat("GraphicsContext object %p wrapping the Quartz 2D graphics context %p", (void*)self, (void*)(self->cr));

#endif

}

static PyObject*

GraphicsContext_save (GraphicsContext* self)

{

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextSaveGState(cr);

self->level++;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_restore (GraphicsContext* self)

{

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if (self->level==0)

{

PyErr_SetString(PyExc_RuntimeError,

"Attempting to execute CGContextRestoreGState on an empty stack");

return NULL;

}

CGContextRestoreGState(cr);

self->level--;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_alpha (GraphicsContext* self, PyObject* args)

{

float alpha;

int forced = 0;

if (!PyArg_ParseTuple(args, "f|i", &alpha, &forced)) return NULL;

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextSetAlpha(cr, alpha);

self->forced_alpha = (BOOL)(forced || (alpha != 1.0));

Py_INCREF(Py_None);

return Py_None;

}

static BOOL

_set_antialiased(CGContextRef cr, PyObject* antialiased)

{

const int shouldAntialias = PyObject_IsTrue(antialiased);

if (shouldAntialias < 0)

{

PyErr_SetString(PyExc_ValueError,

"Failed to read antialiaseds variable");

return false;

}

CGContextSetShouldAntialias(cr, shouldAntialias);

return true;

}

static PyObject*

GraphicsContext_set_antialiased (GraphicsContext* self, PyObject* args)

{

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if (!_set_antialiased(cr, args)) return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_capstyle (GraphicsContext* self, PyObject* args)

{

char* string;

CGLineCap cap;

if (!PyArg_ParseTuple(args, "s", &string)) return NULL;

if (!strcmp(string, "butt")) cap = kCGLineCapButt;

else if (!strcmp(string, "round")) cap = kCGLineCapRound;

else if (!strcmp(string, "projecting")) cap = kCGLineCapSquare;

else

{

PyErr_SetString(PyExc_ValueError,

"capstyle should be 'butt', 'round', or 'projecting'");

return NULL;

}

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextSetLineCap(cr, cap);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_clip_rectangle (GraphicsContext* self, PyObject* args)

{

CGRect rect;

float x, y, width, height;

if (!PyArg_ParseTuple(args, "(ffff)", &x, &y, &width, &height)) return NULL;

rect.origin.x = x;

rect.origin.y = y;

rect.size.width = width;

rect.size.height = height;

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextClipToRect(cr, rect);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_clip_path (GraphicsContext* self, PyObject* args)

{

int n;

CGContextRef cr = self->cr;

PyObject* path;

int nd = 2;

npy_intp dims[2] = {3, 3};

int typenum = NPY_DOUBLE;

double data[] = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0};

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if(!PyArg_ParseTuple(args, "O", &path)) return NULL;

PyObject* transform = PyArray_SimpleNewFromData(nd, dims, typenum, data);

if (!transform) return NULL;

double rect[4] = {0.0, 0.0, self->size.width, self->size.height};

void* iterator = get_path_iterator(path,

transform,

0,

0,

rect,

SNAP_AUTO,

1.0,

0);

Py_DECREF(transform);

if (!iterator)

{

PyErr_SetString(PyExc_RuntimeError,

"set_clip_path: failed to obtain path iterator for clipping");

return NULL;

}

n = _draw_path(cr, iterator, INT_MAX);

free_path_iterator(iterator);

if (n > 0) CGContextClip(cr);

Py_INCREF(Py_None);

return Py_None;

}

static BOOL

_set_dashes(CGContextRef cr, PyObject* linestyle)

{

CGFloat phase = 0.0;

PyObject* offset;

PyObject* dashes;

if (!PyArg_ParseTuple(linestyle, "OO", &offset, &dashes))

{

PyErr_SetString(PyExc_TypeError,

"failed to obtain the offset and dashes from the linestyle");

return false;

}

if (offset!=Py_None)

{

if (PyFloat_Check(offset)) phase = PyFloat_AS_DOUBLE(offset);

#if PY3K

else if (PyLong_Check(offset)) phase = PyLong_AS_LONG(offset);

#else

else if (PyInt_Check(offset)) phase = PyInt_AS_LONG(offset);

#endif

else

{

PyErr_SetString(PyExc_TypeError,

"offset should be a floating point value");

return false;

}

}

if (dashes!=Py_None)

{

if (PyList_Check(dashes)) dashes = PyList_AsTuple(dashes);

else if (PyTuple_Check(dashes)) Py_INCREF(dashes);

else

{

PyErr_SetString(PyExc_TypeError,

"dashes should be a tuple or a list");

return false;

}

int n = PyTuple_GET_SIZE(dashes);

int i;

CGFloat* lengths = malloc(n*sizeof(CGFloat));

if(!lengths)

{

PyErr_SetString(PyExc_MemoryError, "Failed to store dashes");

Py_DECREF(dashes);

return false;

}

for (i = 0; i < n; i++)

{

PyObject* value = PyTuple_GET_ITEM(dashes, i);

if (PyFloat_Check(value))

lengths[i] = (CGFloat) PyFloat_AS_DOUBLE(value);

#if PY3K

else if (PyLong_Check(value))

lengths[i] = (CGFloat) PyLong_AS_LONG(value);

#else

else if (PyInt_Check(value))

lengths[i] = (CGFloat) PyInt_AS_LONG(value);

#endif

else break;

}

Py_DECREF(dashes);

if (i < n) /* break encountered */

{

free(lengths);

PyErr_SetString(PyExc_TypeError, "Failed to read dashes");

return false;

}

CGContextSetLineDash(cr, phase, lengths, n);

free(lengths);

}

else

CGContextSetLineDash(cr, phase, NULL, 0);

return true;

}

static PyObject*

GraphicsContext_set_dashes (GraphicsContext* self, PyObject* args)

{

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if (!_set_dashes(cr, args))

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_foreground(GraphicsContext* self, PyObject* args)

{

float r, g, b, a;

if(!PyArg_ParseTuple(args, "(ffff)", &r, &g, &b, &a)) return NULL;

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if (self->forced_alpha)

{

// Transparency is applied to layer

// Let it override (rather than multiply with) the alpha of the

// stroke/fill colors

a = 1.0;

}

CGContextSetRGBStrokeColor(cr, r, g, b, a);

CGContextSetRGBFillColor(cr, r, g, b, a);

self->color[0] = r;

self->color[1] = g;

self->color[2] = b;

self->color[3] = a;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_graylevel(GraphicsContext* self, PyObject* args)

{ float gray;

if(!PyArg_ParseTuple(args, "f", &gray)) return NULL;

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextSetGrayStrokeColor(cr, gray, 1.0);

CGContextSetGrayFillColor(cr, gray, 1.0);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_dpi (GraphicsContext* self, PyObject* args)

{

if (!PyArg_ParseTuple(args, "f", &(self->dpi))) return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_linewidth (GraphicsContext* self, PyObject* args)

{

float width;

if (!PyArg_ParseTuple(args, "f", &width)) return NULL;

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

// Convert points to pixels

width *= self->dpi / 72.0;

CGContextSetLineWidth(cr, width);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_set_joinstyle(GraphicsContext* self, PyObject* args)

{ char* string;

CGLineJoin join;

if (!PyArg_ParseTuple(args, "s", &string)) return NULL;

if (!strcmp(string, "miter")) join = kCGLineJoinMiter;

else if (!strcmp(string, "round")) join = kCGLineJoinRound;

else if (!strcmp(string, "bevel")) join = kCGLineJoinBevel;

else

{

PyErr_SetString(PyExc_ValueError,

"joinstyle should be 'miter', 'round', or 'bevel'");

return NULL;

}

CGContextRef cr = self->cr;

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

CGContextSetLineJoin(cr, join);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

GraphicsContext_draw_path (GraphicsContext* self, PyObject* args)

{

PyObject* path;

PyObject* transform;

PyObject* rgbFace;

float linewidth;

int n;

void* iterator;

CGContextRef cr = self->cr;

double rect[4] = { 0.0, 0.0, self->size.width, self->size.height};

if (!cr)

{

PyErr_SetString(PyExc_RuntimeError, "CGContextRef is NULL");

return NULL;

}

if(!PyArg_ParseTuple(args, "OOf|O",

&path,

&transform,

&linewidth,

&rgbFace)) return NULL;

if(rgbFace==Py_None) rgbFace = NULL;

iterator = get_path_iterator(path,

transform,

1,

0,

rect,

SNAP_AUTO,

linewidth,