#define PY_SSIZE_T_CLEAN

#include <Cocoa/Cocoa.h>

#include <ApplicationServices/ApplicationServices.h>

#include <sys/socket.h>

#include <Python.h>

#ifndef PYPY

/* Remove this once Python is fixed: https://bugs.python.org/issue23237 */

#define PYOSINPUTHOOK_REPETITIVE 1

#endif

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

* https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/cross_development/Using/using.html

*/

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

#define COMPILING_FOR_10_7

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000

#define COMPILING_FOR_10_10

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED < 101200

/* A lot of symbols were renamed in Sierra and cause deprecation warnings

so define macros for the new names if we are compiling on an older SDK */

#define NSEventMaskAny NSAnyEventMask

#define NSEventTypeApplicationDefined NSApplicationDefined

#define NSEventModifierFlagCommand NSCommandKeyMask

#define NSEventModifierFlagControl NSControlKeyMask

#define NSEventModifierFlagOption NSAlternateKeyMask

#define NSEventModifierFlagShift NSShiftKeyMask

#define NSEventTypeKeyUp NSKeyUp

#define NSEventTypeKeyDown NSKeyDown

#define NSEventTypeMouseMoved NSMouseMoved

#define NSEventTypeLeftMouseDown NSLeftMouseDown

#define NSEventTypeRightMouseDown NSRightMouseDown

#define NSEventTypeOtherMouseDown NSOtherMouseDown

#define NSEventTypeLeftMouseDragged NSLeftMouseDragged

#define NSEventTypeRightMouseDragged NSRightMouseDragged

#define NSEventTypeOtherMouseDragged NSOtherMouseDragged

#define NSEventTypeLeftMouseUp NSLeftMouseUp

#define NSEventTypeRightMouseUp NSRightMouseUp

#define NSEventTypeOtherMouseUp NSOtherMouseUp

#define NSWindowStyleMaskClosable NSClosableWindowMask

#define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask

#define NSWindowStyleMaskResizable NSResizableWindowMask

#define NSWindowStyleMaskTitled NSTitledWindowMask

#endif

#if __MAC_OS_X_VERSION_MIN_REQUIRED < 101400

/* A few more deprecations in Mojave */

#define NSButtonTypeMomentaryLight NSMomentaryLightButton

#define NSButtonTypePushOnPushOff NSPushOnPushOffButton

#define NSBezelStyleShadowlessSquare NSShadowlessSquareBezelStyle

#define CGContext graphicsPort

#endif

/* Various NSApplicationDefined event subtypes */

#define STOP_EVENT_LOOP 2

#define WINDOW_CLOSING 3

/* Keep track of number of windows present

Needed to know when to stop the NSApp */

static long FigureWindowCount = 0;

/* -------------------------- 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;

while (true) {

while (true) {

event = [NSApp nextEventMatchingMask: NSEventMaskAny

untilDate: [NSDate distantPast]

inMode: NSDefaultRunLoopMode

dequeue: YES];

if (!event) break;

[NSApp sendEvent: event];

}

CFRunLoopRun();

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

}

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;

}

/* ---------------------------- 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

@interface View : NSView <NSWindowDelegate>

{ PyObject* canvas;

NSRect rubberband;

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;

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

@end

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

static bool backend_inited = false;

static void lazy_init(void) {

if (backend_inited) {

return;

}

backend_inited = true;

NSApp = [NSApplication sharedApplication];

[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];

#ifndef PYPY

/* TODO: remove ifndef after the new PyPy with the PyOS_InputHook implementation

get released: https://bitbucket.org/pypy/pypy/commits/caaf91a */

PyOS_InputHook = wait_for_stdin;

#endif

WindowServerConnectionManager* connectionManager = [WindowServerConnectionManager sharedManager];

NSWorkspace* workspace = [NSWorkspace sharedWorkspace];

NSNotificationCenter* notificationCenter = [workspace notificationCenter];

[notificationCenter addObserver: connectionManager

selector: @selector(launch:)

name: NSWorkspaceDidLaunchApplicationNotification

object: nil];

}

static PyObject*

event_loop_is_running(PyObject* self)

{

if (backend_inited) {

Py_RETURN_TRUE;

} else {

Py_RETURN_FALSE;

}

}

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)

{

lazy_init();

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.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;

int opts = (NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |

NSTrackingActiveInKeyWindow | NSTrackingInVisibleRect);

[self->view addTrackingArea: [

[NSTrackingArea alloc] initWithRect: rect

options: opts

owner: self->view

userInfo: nil]];

[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)

{

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

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

}

static PyObject*

FigureCanvas_draw(FigureCanvas* self)

{

View* view = self->view;

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

{

[view display];

}

Py_RETURN_NONE;

}

static PyObject*

FigureCanvas_draw_idle(FigureCanvas* self)

{

View* view = self->view;

if(!view)

{

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

return NULL;

}

[view setNeedsDisplay: YES];

Py_RETURN_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_RETURN_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_RETURN_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_RETURN_NONE;

}

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]);

}

NSDate* date =

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

: [NSDate distantFuture];

while (true)

{ NSEvent* event = [NSApp nextEventMatchingMask: NSEventMaskAny

untilDate: date

inMode: NSDefaultRunLoopMode

dequeue: YES];

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

[NSApp sendEvent: event];

}

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

}

static PyObject*

FigureCanvas_stop_event_loop(FigureCanvas* self)

{

NSEvent* event = [NSEvent otherEventWithType: NSEventTypeApplicationDefined

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

}

static PyMethodDef FigureCanvas_methods[] = {

{"draw",

(PyCFunction)FigureCanvas_draw,

METH_NOARGS,

NULL, // docstring inherited.

},

{"draw_idle",

(PyCFunction)FigureCanvas_draw_idle,

METH_NOARGS,

NULL, // docstring inherited.

},

{"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)

{

lazy_init();

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;

++FigureWindowCount;

return (PyObject*)self;

}

static int

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

{

NSRect rect;

Window* window;

View* view;

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, "O", &obj)) 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;

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

styleMask: NSWindowStyleMaskTitled

| NSWindowStyleMaskClosable

| NSWindowStyleMaskResizable

| NSWindowStyleMaskMiniaturizable

backing: NSBackingStoreBuffered

defer: YES

withManager: (PyObject*)self];

window = self->window;

[window setDelegate: view];

[window makeFirstResponder: view];

[[window contentView] addSubview: view];

return 0;

}

static PyObject*

FigureManager_repr(FigureManager* self)

{

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

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

}

static void

FigureManager_dealloc(FigureManager* self)

{

Window* window = self->window;

if(window)

{

[window close];

}

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

}

static PyObject*

FigureManager_show(FigureManager* self)

{

Window* window = self->window;

if(window)

{

[window makeKeyAndOrderFront: nil];

[window orderFrontRegardless];

}

Py_RETURN_NONE;

}

static PyObject*

FigureManager_destroy(FigureManager* self)

{

Window* window = self->window;

if(window)

{

[window close];

self->window = NULL;

}

Py_RETURN_NONE;

}

static PyObject*

FigureManager_set_window_title(FigureManager* self,

PyObject *args, PyObject *kwds)

{

const char* title;

if (!PyArg_ParseTuple(args, "s", &title)) {

return NULL;

}

Window* window = self->window;

if(window)

{

NSString* ns_title = [[[NSString alloc]

initWithCString: title

encoding: NSUTF8StringEncoding] autorelease];

[window setTitle: ns_title];

}

Py_RETURN_NONE;

}

static PyObject*

FigureManager_get_window_title(FigureManager* self)

{

Window* window = self->window;

PyObject* result = NULL;

if(window)

{

NSString* title = [window title];

if (title) {

const char* cTitle = [title UTF8String];

result = PyUnicode_FromString(cTitle);

}

}

if (result) {

return result;

} else {

Py_RETURN_NONE;

}

}

static PyObject*

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

{

int width, height;

if (!PyArg_ParseTuple(args, "ii", &width, &height)) {

return NULL;

}

Window* window = self->window;

if(window)

{

// 36 comes from hard-coded size of toolbar later in code

[window setContentSize: NSMakeSize(width, height + 36.)];

}

Py_RETURN_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."

},

{"resize",

(PyCFunction)FigureManager_resize,

METH_VARARGS,

"Resize the window (in pixels)."

},

{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 NavigationToolbar2Handler : NSObject

{ PyObject* toolbar;

NSButton* panbutton;

NSButton* zoombutton;

}

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

- (void)installCallbacks:(SEL[7])actions forButtons: (NSButton*[7])buttons;

- (void)home:(id)sender;

- (void)back:(id)sender;

- (void)forward:(id)sender;

- (void)pan:(id)sender;

- (void)zoom:(id)sender;

- (void)configure_subplots:(id)sender;

- (void)save_figure:(id)sender;

@end

typedef struct {

PyObject_HEAD

NSPopUpButton* menu;

NSTextView* messagebox;

NavigationToolbar2Handler* handler;

int height;

} NavigationToolbar2;

@implementation NavigationToolbar2Handler

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

{ [self init];

toolbar = theToolbar;

return self;

}

- (void)installCallbacks:(SEL[7])actions forButtons: (NSButton*[7])buttons

{

int i;

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

{

SEL action = actions[i];

NSButton* button = buttons[i];

[button setTarget: self];

[button setAction: action];

if (action==@selector(pan:)) panbutton = button;

if (action==@selector(zoom:)) zoombutton = button;

}

}

-(void)home:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "home", "");

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)back:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "back", "");

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)forward:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "forward", "");

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)pan:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

if ([sender state])

{

if (zoombutton) [zoombutton setState: NO];

}

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "pan", "");

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)zoom:(id)sender

{ PyObject* result;

PyGILState_STATE gstate;

if ([sender state])

{

if (panbutton) [panbutton setState: NO];

}

gstate = PyGILState_Ensure();

result = PyObject_CallMethod(toolbar, "zoom", "");

if(result)

Py_DECREF(result);

else

PyErr_Print();

PyGILState_Release(gstate);

}

-(void)configure_subplots:(id)sender

{ PyObject* canvas;

View* view;

PyObject* size;

NSRect rect;