#include <Cocoa/Cocoa.h>

#include <ApplicationServices/ApplicationServices.h>

#include <sys/socket.h>

#include <Python.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

#ifndef Py_TYPE

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

#endif

#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 >= 1070

#define COMPILING_FOR_10_7

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 10100

#define COMPILING_FOR_10_10

#endif

#ifndef COMPILING_FOR_10_5

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

#include <Carbon/Carbon.h>

#endif

#ifndef CGFLOAT_DEFINED

#define CGFloat float

#endif

#define STOP_EVENT_LOOP 2

#define WINDOW_CLOSING 3

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;

}

@interface WindowServerConnectionManager : NSObject

{

}

+ (WindowServerConnectionManager*)sharedManager;

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

@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;

@interface ToolWindow : NSWindow

{

}

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

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

- (void)close;

#ifdef COMPILING_FOR_10_6

@interface View : NSView <NSWindowDelegate>

#else

@interface View : NSView

#endif

{ PyObject* canvas;

NSRect rubberband;

BOOL inside;

NSTrackingRectTag tracking;

@public double device_scale;

}

- (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;

@interface ScrollableButton : NSButton

{

SEL scrollWheelUpAction;

SEL scrollWheelDownAction;

}

- (void)setScrollWheelUpAction:(SEL)action;

- (void)setScrollWheelDownAction:(SEL)action;

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

@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;

static CGFloat _get_device_scale(CGContextRef cr)

{

CGSize pixelSize = CGContextConvertSizeToDeviceSpace(cr, CGSizeMake(1, 1));

return pixelSize.width;

}

typedef struct {

PyObject_HEAD

View* view;

} FigureCanvas;

static PyObject*

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

{

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

if (!self) return NULL;

self->view = [View alloc];

return (PyObject*)self;

}

static int

FigureCanvas_init(FigureCanvas *self, PyObject *args, PyObject *kwds)

{

int width;

int height;

if(!self->view)

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return -1;

}

if(!PyArg_ParseTuple(args, "ii", &width, &height)) return -1;

NSRect rect = NSMakeRect(0.0, 0.0, width, height);

self->view = [self->view initWithFrame: rect];

[self->view setCanvas: (PyObject*)self];

return 0;

}

static void

FigureCanvas_dealloc(FigureCanvas* self)

{

if (self->view)

{

[self->view setCanvas: NULL];

[self->view release];

}

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

}

static PyObject*

FigureCanvas_repr(FigureCanvas* self)

{

#if PY3K

return PyUnicode_FromFormat("FigureCanvas object %p wrapping NSView %p",

(void*)self, (void*)(self->view));

#else

return PyString_FromFormat("FigureCanvas object %p wrapping NSView %p",

(void*)self, (void*)(self->view));

#endif

}

static PyObject*

FigureCanvas_draw(FigureCanvas* self)

{

View* view = self->view;

if(view) /* The figure may have been closed already */

{

/* Whereas drawRect creates its own autorelease pool, apparently

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

[view display];

[pool release];

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureCanvas_invalidate(FigureCanvas* self)

{

View* view = self->view;

if(!view)

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return NULL;

}

[view setNeedsDisplay: YES];

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureCanvas_flush_events(FigureCanvas* self)

{

View* view = self->view;

if(!view)

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return NULL;

}

[view displayIfNeeded];

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureCanvas_set_rubberband(FigureCanvas* self, PyObject *args)

{

View* view = self->view;

int x0, y0, x1, y1;

NSRect rubberband;

if(!view)

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return NULL;

}

if(!PyArg_ParseTuple(args, "iiii", &x0, &y0, &x1, &y1)) return NULL;

x0 /= view->device_scale;

x1 /= view->device_scale;

y0 /= view->device_scale;

y1 /= view->device_scale;

if (x1 > x0)

{

rubberband.origin.x = x0;

rubberband.size.width = x1 - x0;

}

else

{

rubberband.origin.x = x1;

rubberband.size.width = x0 - x1;

}

if (y1 > y0)

{

rubberband.origin.y = y0;

rubberband.size.height = y1 - y0;

}

else

{

rubberband.origin.y = y1;

rubberband.size.height = y0 - y1;

}

[view setRubberband: rubberband];

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureCanvas_remove_rubberband(FigureCanvas* self)

{

View* view = self->view;

if(!view)

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return NULL;

}

[view removeRubberband];

Py_INCREF(Py_None);

return Py_None;

}

static NSImage* _read_ppm_image(PyObject* obj)

{

int width;

int height;

const char* data;

int n;

int i;

NSBitmapImageRep* bitmap;

unsigned char* bitmapdata;

if (!obj) return NULL;

if (!PyTuple_Check(obj)) return NULL;

if (!PyArg_ParseTuple(obj, "iit#", &width, &height, &data, &n)) return NULL;

if (width*height*3 != n) return NULL; /* RGB image uses 3 colors / pixel */

bitmap = [[NSBitmapImageRep alloc]

initWithBitmapDataPlanes: NULL

pixelsWide: width

pixelsHigh: height

bitsPerSample: 8

samplesPerPixel: 3

hasAlpha: NO

isPlanar: NO

colorSpaceName: NSDeviceRGBColorSpace

bitmapFormat: 0

bytesPerRow: width*3

bitsPerPixel: 24];

if (!bitmap) return NULL;

bitmapdata = [bitmap bitmapData];

for (i = 0; i < n; i++) bitmapdata[i] = data[i];

NSSize size = NSMakeSize(width, height);

NSImage* image = [[NSImage alloc] initWithSize: size];

if (image) [image addRepresentation: bitmap];

[bitmap release];

return image;

}

static PyObject*

FigureCanvas_start_event_loop(FigureCanvas* self, PyObject* args, PyObject* keywords)

{

float timeout = 0.0;

static char* kwlist[] = {"timeout", NULL};

if(!PyArg_ParseTupleAndKeywords(args, keywords, "f", kwlist, &timeout))

return NULL;

int error;

int interrupted = 0;

int channel[2];

CFSocketRef sigint_socket = NULL;

PyOS_sighandler_t py_sigint_handler = NULL;

CFRunLoopRef runloop = CFRunLoopGetCurrent();

error = pipe(channel);

if (error==0)

{

CFSocketContext context = {0, NULL, NULL, NULL, NULL};

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

context.info = &interrupted;

sigint_socket = CFSocketCreateWithNative(kCFAllocatorDefault,

channel[0],

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[1];

py_sigint_handler = PyOS_setsig(SIGINT, _sigint_handler);

}

}

else

close(channel[0]);

}

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

NSDate* date =

(timeout > 0.0) ? [NSDate dateWithTimeIntervalSinceNow: timeout]

: [NSDate distantFuture];

while (true)

{ NSEvent* event = [NSApp nextEventMatchingMask: NSAnyEventMask

untilDate: date

inMode: NSDefaultRunLoopMode

dequeue: YES];

if (!event || [event type]==NSApplicationDefined) break;

[NSApp sendEvent: event];

}

[pool release];

if (py_sigint_handler) PyOS_setsig(SIGINT, py_sigint_handler);

if (sigint_socket) CFSocketInvalidate(sigint_socket);

if (error==0) close(channel[1]);

if (interrupted) raise(SIGINT);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureCanvas_stop_event_loop(FigureCanvas* self)

{

NSEvent* event = [NSEvent otherEventWithType: NSApplicationDefined

location: NSZeroPoint

modifierFlags: 0

timestamp: 0.0

windowNumber: 0

context: nil

subtype: STOP_EVENT_LOOP

data1: 0

data2: 0];

[NSApp postEvent: event atStart: true];

Py_INCREF(Py_None);

return Py_None;

}

static PyMethodDef FigureCanvas_methods[] = {

{"draw",

(PyCFunction)FigureCanvas_draw,

METH_NOARGS,

"Draws the canvas."

},

{"invalidate",

(PyCFunction)FigureCanvas_invalidate,

METH_NOARGS,

"Invalidates the canvas."

},

{"flush_events",

(PyCFunction)FigureCanvas_flush_events,

METH_NOARGS,

"Flush the GUI events for the figure."

},

{"set_rubberband",

(PyCFunction)FigureCanvas_set_rubberband,

METH_VARARGS,

"Specifies a new rubberband rectangle and invalidates it."

},

{"remove_rubberband",

(PyCFunction)FigureCanvas_remove_rubberband,

METH_NOARGS,

"Removes the current rubberband rectangle."

},

{"start_event_loop",

(PyCFunction)FigureCanvas_start_event_loop,

METH_KEYWORDS | METH_VARARGS,

"Runs the event loop until the timeout or until stop_event_loop is called.\n",

},

{"stop_event_loop",

(PyCFunction)FigureCanvas_stop_event_loop,

METH_NOARGS,

"Stops the event loop that was started by start_event_loop.\n",

},

{NULL} /* Sentinel */

};

static char FigureCanvas_doc[] =

"A FigureCanvas object wraps a Cocoa NSView object.\n";

static PyTypeObject FigureCanvasType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_macosx.FigureCanvas", /*tp_name*/

sizeof(FigureCanvas), /*tp_basicsize*/

0, /*tp_itemsize*/

(destructor)FigureCanvas_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare*/

(reprfunc)FigureCanvas_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/

FigureCanvas_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

FigureCanvas_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)FigureCanvas_init, /* tp_init */

0, /* tp_alloc */

FigureCanvas_new, /* tp_new */

};

typedef struct {

PyObject_HEAD

Window* window;

} FigureManager;

static PyObject*

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

{

Window* window = [Window alloc];

if (!window) return NULL;

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

if (!self)

{

[window release];

return NULL;

}

self->window = window;

return (PyObject*)self;

}

static int

FigureManager_init(FigureManager *self, PyObject *args, PyObject *kwds)

{

NSRect rect;

Window* window;

View* view;

const char* title;

PyObject* size;

int width, height;

PyObject* obj;

FigureCanvas* canvas;

if(!self->window)

{

PyErr_SetString(PyExc_RuntimeError, "NSWindow* is NULL");

return -1;

}

if(!PyArg_ParseTuple(args, "Os", &obj, &title)) return -1;

canvas = (FigureCanvas*)obj;

view = canvas->view;

if (!view) /* Something really weird going on */

{

PyErr_SetString(PyExc_RuntimeError, "NSView* is NULL");

return -1;

}

size = PyObject_CallMethod(obj, "get_width_height", "");

if(!size) return -1;

if(!PyArg_ParseTuple(size, "ii", &width, &height))

{ Py_DECREF(size);

return -1;

}

Py_DECREF(size);

rect.origin.x = 100;

rect.origin.y = 350;

rect.size.height = height;

rect.size.width = width;

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

self->window = [self->window initWithContentRect: rect

styleMask: NSTitledWindowMask

| NSClosableWindowMask

| NSResizableWindowMask

| NSMiniaturizableWindowMask

backing: NSBackingStoreBuffered

defer: YES

withManager: (PyObject*)self];

window = self->window;

[window setTitle: [NSString stringWithCString: title

encoding: NSASCIIStringEncoding]];

[window setAcceptsMouseMovedEvents: YES];

[window setDelegate: view];

[window makeFirstResponder: view];

[[window contentView] addSubview: view];

[pool release];

return 0;

}

static PyObject*

FigureManager_repr(FigureManager* self)

{

#if PY3K

return PyUnicode_FromFormat("FigureManager object %p wrapping NSWindow %p",

(void*) self, (void*)(self->window));

#else

return PyString_FromFormat("FigureManager object %p wrapping NSWindow %p",

(void*) self, (void*)(self->window));

#endif

}

static void

FigureManager_dealloc(FigureManager* self)

{

Window* window = self->window;

if(window)

{

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

[window close];

[pool release];

}

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

}

static PyObject*

FigureManager_show(FigureManager* self)

{

Window* window = self->window;

if(window)

{

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

[window makeKeyAndOrderFront: nil];

[window orderFrontRegardless];

[pool release];

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureManager_destroy(FigureManager* self)

{

Window* window = self->window;

if(window)

{

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

[window close];

[pool release];

self->window = NULL;

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureManager_set_window_title(FigureManager* self,

PyObject *args, PyObject *kwds)

{

char* title;

if(!PyArg_ParseTuple(args, "es", "UTF-8", &title))

return NULL;

Window* window = self->window;

if(window)

{

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

NSString* ns_title = [[[NSString alloc]

initWithCString: title

encoding: NSUTF8StringEncoding] autorelease];

[window setTitle: ns_title];

[pool release];

}

PyMem_Free(title);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject*

FigureManager_get_window_title(FigureManager* self)

{

Window* window = self->window;

PyObject* result = NULL;

if(window)

{

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

NSString* title = [window title];

if (title) {

const char* cTitle = [title UTF8String];

result = PyUnicode_FromString(cTitle);

}

[pool release];

}

if (result) {

return result;

} else {

Py_INCREF(Py_None);

return Py_None;

}

}

static PyMethodDef FigureManager_methods[] = {

{"show",

(PyCFunction)FigureManager_show,

METH_NOARGS,

"Shows the window associated with the figure manager."

},

{"destroy",

(PyCFunction)FigureManager_destroy,

METH_NOARGS,

"Closes the window associated with the figure manager."

},

{"set_window_title",

(PyCFunction)FigureManager_set_window_title,

METH_VARARGS,

"Sets the title of the window associated with the figure manager."

},

{"get_window_title",

(PyCFunction)FigureManager_get_window_title,

METH_NOARGS,

"Returns the title of the window associated with the figure manager."

},

{NULL} /* Sentinel */

};

static char FigureManager_doc[] =

"A FigureManager object wraps a Cocoa NSWindow object.\n";

static PyTypeObject FigureManagerType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_macosx.FigureManager", /*tp_name*/

sizeof(FigureManager), /*tp_basicsize*/

0, /*tp_itemsize*/

(destructor)FigureManager_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare*/

(reprfunc)FigureManager_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/

FigureManager_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

FigureManager_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)FigureManager_init, /* tp_init */

0, /* tp_alloc */

FigureManager_new, /* tp_new */

};

@interface NavigationToolbarHandler : NSObject

{ PyObject* toolbar;

}

- (NavigationToolbarHandler*)initWithToolbar:(PyObject*)toolbar;

-(void)left:(id)sender;

-(void)right:(id)sender;

-(void)up:(id)sender;

-(void)down:(id)sender;

-(void)zoominx:(id)sender;

-(void)zoominy:(id)sender;

-(void)zoomoutx:(id)sender;

-(void)zoomouty:(id)sender;

typedef struct {

PyObject_HEAD

NSPopUpButton* menu;

NavigationToolbarHandler* handler;

} NavigationToolbar;

@implementation NavigationToolbarHandler

- (NavigationToolbarHandler*)initWithToolbar:(PyObject*)theToolbar

{ [self init];

toolbar = theToolbar;

return self;

}

-(void)left:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "panx", "i", -1);

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)right:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "panx", "i", 1);

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)up:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "pany", "i", 1);

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)down:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "pany", "i", -1);

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)zoominx:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "zoomx", "i", 1);