#define PY_SSIZE_T_CLEAN

#include <Cocoa/Cocoa.h>

#include <ApplicationServices/ApplicationServices.h>

#include <Python.h>

#if !__has_feature(objc_arc_fields)

#error "The macOS backend requires ARC C struct fields support (objc_arc_fields)."

#endif

#define STOP_EVENT_LOOP 2

#define BEGIN_OBJC_ENTRY \

@autoreleasepool { @try {

#define END_OBJC_ENTRY \

} @catch (NSException *e) { errSetException(e); } }

#define RETURN_NULL_OR_NONE \

if (PyErr_Occurred()) { \

return NULL; \

} else { \

Py_RETURN_NONE; \

}

static id<NSApplicationDelegate> appDelegate = nil;

static BOOL IsRunningFromShow = NO;

static NSHashTable<NSWindow *> *FigureWindowHashTable = nil;

static bool lastCommand = false;

static bool lastControl = false;

static bool lastShift = false;

static bool lastOption = false;

static bool lastCapsLock = false;

static bool keyChangeCommand = false;

static bool keyChangeControl = false;

static bool keyChangeShift = false;

static bool keyChangeOption = false;

static bool keyChangeCapsLock = false;

static bool leftMouseGrabbing = false;

static PyOS_sighandler_t originalSigintAction = NULL;

static void errSetException(NSException *exception) {

PyErr_SetString(PyExc_RuntimeError, [[exception reason] UTF8String]);

}

static void stopWithEvent() {

[NSApp stop: nil];

// Post an event to trigger the actual stopping.

// +[NSEvent otherEventWithType:...] is declared nullable but will not return

// nil for these constant, valid arguments; guard defensively anyway.

NSEvent* event = [NSEvent otherEventWithType: NSEventTypeApplicationDefined

location: NSZeroPoint

modifierFlags: 0

timestamp: 0

windowNumber: 0

context: nil

subtype: 0

data1: 0

data2: 0];

if (event) {

[NSApp postEvent: event atStart: YES];

}

}

static void handleSigint(int signal) {

stopWithEvent();

}

static void flushEvents() {

while (true) {

@autoreleasepool {

NSEvent* event = [NSApp nextEventMatchingMask: NSEventMaskAny

untilDate: [NSDate distantPast]

inMode: NSDefaultRunLoopMode

dequeue: YES];

if (!event) {

break;

}

[NSApp sendEvent:event];

}

}

}

static int wait_for_stdin() {

BEGIN_OBJC_ENTRY

// Short circuit if no windows are active

// Rely on Python's input handling to manage CPU usage

// This queries the NSApp, rather than using our FigureWindowHashTable because that is modified when events still

// need to be processed to properly close the windows.

@autoreleasepool {

if (![[NSApp windows] count]) {

flushEvents();

return 1;

}

}

// Set up a SIGINT handler to interrupt the event loop if ctrl+c comes in too

originalSigintAction = PyOS_setsig(SIGINT, handleSigint);

// Create an NSFileHandle for standard input

NSFileHandle *stdinHandle = [NSFileHandle fileHandleWithStandardInput];

// Register for data available notifications on standard input

id notificationID = [[NSNotificationCenter defaultCenter] addObserverForName: NSFileHandleDataAvailableNotification

object: stdinHandle

queue: [NSOperationQueue mainQueue] // Use the main queue

usingBlock: ^(NSNotification *notification) {stopWithEvent();}

];

// Wait in the background for anything that happens to stdin

[stdinHandle waitForDataInBackgroundAndNotify];

// Run the application's event loop, which will be interrupted on stdin or SIGINT

[NSApp run];

// Remove the input handler as an observer

[[NSNotificationCenter defaultCenter] removeObserver: notificationID];

// Restore the original SIGINT handler upon exiting the function

PyOS_setsig(SIGINT, originalSigintAction);

return 1;

END_OBJC_ENTRY

return 0;

}

@interface MatplotlibAppDelegate : NSObject <NSApplicationDelegate>

- (BOOL)applicationSupportsSecureRestorableState:(NSApplication *)app;

@interface Window : NSWindow

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

@property (nonatomic, assign) PyObject* manager;

@interface View : NSView <NSWindowDelegate>

{ NSRect rubberband;

@public double device_scale;

}

- (void)drawRect:(NSRect)rect;

- (void)updateDevicePixelRatio:(double)scale;

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

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

- (instancetype)initWithFrame:(NSRect)rect;

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

- (NSString*)convertKeyEvent:(NSEvent*)event;

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

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

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

- (BOOL)acceptsFirstResponder;

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

@property (nonatomic, assign) PyObject* canvas;

static void gil_call_method(PyObject* obj, const char* name)

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyObject* result = PyObject_CallMethod(obj, name, NULL);

if (result) {

Py_DECREF(result);

} else {

PyErr_Print();

}

PyGILState_Release(gstate);

}

void process_event(char const* cls_name, char const* fmt, ...)

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyObject* module = NULL, * cls = NULL,

* args = NULL, * kwargs = NULL,

* event = NULL, * result = NULL;

va_list argp;

va_start(argp, fmt);

if (!(module = PyImport_ImportModule("matplotlib.backend_bases"))

|| !(cls = PyObject_GetAttrString(module, cls_name))

|| !(args = PyTuple_New(0))

|| !(kwargs = Py_VaBuildValue(fmt, argp))

|| !(event = PyObject_Call(cls, args, kwargs))

|| !(result = PyObject_CallMethod(event, "_process", ""))) {

PyErr_Print();

}

va_end(argp);

Py_XDECREF(module);

Py_XDECREF(cls);

Py_XDECREF(args);

Py_XDECREF(kwargs);

Py_XDECREF(event);

Py_XDECREF(result);

PyGILState_Release(gstate);

}

static bool backend_inited = false;

static void lazy_init(void) {

if (backend_inited) { return; }

backend_inited = true;

NSApp = [NSApplication sharedApplication];

[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];

appDelegate = [[MatplotlibAppDelegate alloc] init];

[NSApp setDelegate:appDelegate];

// Run our own event loop while waiting for stdin on the Python side

// this is needed to keep the application responsive while waiting for input

PyOS_InputHook = wait_for_stdin;

}

static PyObject*

event_loop_is_running(PyObject* self)

{

BEGIN_OBJC_ENTRY

if (backend_inited) {

Py_RETURN_TRUE;

} else {

Py_RETURN_FALSE;

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

wake_on_fd_write(PyObject* unused, PyObject* args)

{

BEGIN_OBJC_ENTRY

int fd;

if (!PyArg_ParseTuple(args, "i", &fd)) { return NULL; }

NSFileHandle* fh = [[NSFileHandle alloc] initWithFileDescriptor: fd];

__block id notificationID = [[NSNotificationCenter defaultCenter]

addObserverForName: NSFileHandleDataAvailableNotification

object: fh

queue: nil

usingBlock: ^(NSNotification* note) {

NSFileHandle* strongFileHandle __attribute__((unused)) = fh;

PyGILState_STATE gstate = PyGILState_Ensure();

PyErr_CheckSignals();

PyGILState_Release(gstate);

[[NSNotificationCenter defaultCenter] removeObserver:notificationID];

}];

[fh waitForDataInBackgroundAndNotify];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

stop(PyObject* self, PyObject* _ /* ignored */)

{

BEGIN_OBJC_ENTRY

stopWithEvent();

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static CGFloat _get_device_scale(CGContextRef cr)

{

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

return pixelSize.width;

}

bool mpl_check_button(bool present, PyObject* set, char const* name) {

PyObject* module = NULL, * cls = NULL, * button = NULL;

bool failed = (

present

&& (!(module = PyImport_ImportModule("matplotlib.backend_bases"))

|| !(cls = PyObject_GetAttrString(module, "MouseButton"))

|| !(button = PyObject_GetAttrString(cls, name))

|| PySet_Add(set, button)));

Py_XDECREF(module);

Py_XDECREF(cls);

Py_XDECREF(button);

return failed;

}

PyObject* mpl_buttons()

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyObject* set = NULL;

NSUInteger buttons = [NSEvent pressedMouseButtons];

if (!(set = PySet_New(NULL))

|| mpl_check_button(buttons & (1 << 0), set, "LEFT")

|| mpl_check_button(buttons & (1 << 1), set, "RIGHT")

|| mpl_check_button(buttons & (1 << 2), set, "MIDDLE")

|| mpl_check_button(buttons & (1 << 3), set, "BACK")

|| mpl_check_button(buttons & (1 << 4), set, "FORWARD")) {

Py_CLEAR(set); // On failure, return NULL with an exception set.

}

PyGILState_Release(gstate);

return set;

}

bool mpl_check_modifier(bool present, PyObject* list, char const* name)

{

PyObject* py_name = NULL;

bool failed = (

present

&& (!(py_name = PyUnicode_FromString(name))

|| (PyList_Append(list, py_name))));

Py_XDECREF(py_name);

return failed;

}

PyObject* mpl_modifiers(NSEvent* event)

{

PyGILState_STATE gstate = PyGILState_Ensure();

PyObject* list = NULL;

NSUInteger modifiers = [event modifierFlags];

if (!(list = PyList_New(0))

|| mpl_check_modifier(modifiers & NSEventModifierFlagControl, list, "ctrl")

|| mpl_check_modifier(modifiers & NSEventModifierFlagOption, list, "alt")

|| mpl_check_modifier(modifiers & NSEventModifierFlagShift, list, "shift")

|| mpl_check_modifier(modifiers & NSEventModifierFlagCommand, list, "cmd")) {

Py_CLEAR(list); // On failure, return NULL with an exception set.

}

PyGILState_Release(gstate);

return list;

}

typedef struct {

PyObject_HEAD

__strong View* view;

} FigureCanvas;

static PyTypeObject FigureCanvasType;

static PyObject*

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

{

BEGIN_OBJC_ENTRY

lazy_init();

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

return (PyObject*)self;

END_OBJC_ENTRY

return NULL;

}

static int

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

{

BEGIN_OBJC_ENTRY

View *view;

NSTrackingArea *trackingArea;

PyObject *builtins = NULL,

*super_obj = NULL,

*super_init = NULL,

*init_res = NULL,

*wh = NULL;

// super(FigureCanvasMac, self).__init__(*args, **kwargs)

if (!(builtins = PyImport_AddModule("builtins")) // borrowed.

|| !(super_obj = PyObject_CallMethod(builtins, "super", "OO", &FigureCanvasType, self))

|| !(super_init = PyObject_GetAttrString(super_obj, "__init__"))

|| !(init_res = PyObject_Call(super_init, args, kwds))) {

goto exit;

}

int width, height;

if (!(wh = PyObject_CallMethod((PyObject*)self, "get_width_height", ""))

|| !PyArg_ParseTuple(wh, "ii", &width, &height)) {

goto exit;

}

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

view = [[View alloc] initWithFrame: rect];

view.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;

int opts = (NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |

NSTrackingActiveInKeyWindow | NSTrackingInVisibleRect);

trackingArea = [[NSTrackingArea alloc] initWithRect: rect

options: opts

owner: view

userInfo: nil];

[view addTrackingArea:trackingArea];

[view setCanvas: (PyObject*)self];

self->view = view;

exit:

Py_XDECREF(super_obj);

Py_XDECREF(super_init);

Py_XDECREF(init_res);

Py_XDECREF(wh);

END_OBJC_ENTRY

return PyErr_Occurred() ? -1 : 0;

}

static void

FigureCanvas_dealloc(FigureCanvas* self)

{

BEGIN_OBJC_ENTRY

[self->view setCanvas: NULL];

self->view = nil;

END_OBJC_ENTRY

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

}

static PyObject*

FigureCanvas_repr(FigureCanvas* self)

{

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

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

}

static PyObject*

FigureCanvas_update(FigureCanvas* self)

{

BEGIN_OBJC_ENTRY

[self->view setNeedsDisplay: YES];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE;

}

static PyObject*

FigureCanvas_flush_events(FigureCanvas* self)

{

BEGIN_OBJC_ENTRY

// We run the app, matching any events that are waiting in the queue

// to process, breaking out of the loop when no events remain and

// displaying the canvas if needed.

Py_BEGIN_ALLOW_THREADS

flushEvents();

Py_END_ALLOW_THREADS

[self->view displayIfNeeded];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureCanvas_set_cursor(PyObject* unused, PyObject* args)

{

BEGIN_OBJC_ENTRY

int i;

if (!PyArg_ParseTuple(args, "i", &i)) { return NULL; }

switch (i) {

case 1: [[NSCursor arrowCursor] set]; break;

case 2: [[NSCursor pointingHandCursor] set]; break;

case 3: [[NSCursor crosshairCursor] set]; break;

case 4:

if (leftMouseGrabbing) {

[[NSCursor closedHandCursor] set];

} else {

[[NSCursor openHandCursor] set];

}

break;

/* macOS handles busy state itself so no need to set a cursor here */

case 5: break;

case 6: [[NSCursor resizeLeftRightCursor] set]; break;

case 7: [[NSCursor resizeUpDownCursor] set]; break;

default: return NULL;

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureCanvas_set_rubberband(FigureCanvas* self, PyObject *args)

{

BEGIN_OBJC_ENTRY

View* view = self->view;

if (!view) {

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

return NULL;

}

int x0, y0, x1, y1;

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;

NSRect rubberband = NSMakeRect(x0 < x1 ? x0 : x1, y0 < y1 ? y0 : y1,

abs(x1 - x0), abs(y1 - y0));

[view setRubberband: rubberband];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureCanvas_remove_rubberband(FigureCanvas* self)

{

BEGIN_OBJC_ENTRY

[self->view removeRubberband];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

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

{

BEGIN_OBJC_ENTRY

float timeout = 0.0;

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

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

return NULL;

}

Py_BEGIN_ALLOW_THREADS

NSDate* date =

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

: [NSDate distantFuture];

while (true) {

@autoreleasepool {

NSEvent* event = [NSApp nextEventMatchingMask: NSEventMaskAny

untilDate: date

inMode: NSDefaultRunLoopMode

dequeue: YES];

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

[NSApp sendEvent: event];

}

}

Py_END_ALLOW_THREADS

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureCanvas_stop_event_loop(FigureCanvas* self)

{

BEGIN_OBJC_ENTRY

// +[NSEvent otherEventWithType:...] is declared nullable but will not return

// nil for these constant, valid arguments; guard defensively anyway.

NSEvent* event = [NSEvent otherEventWithType: NSEventTypeApplicationDefined

location: NSZeroPoint

modifierFlags: 0

timestamp: 0.0

windowNumber: 0

context: nil

subtype: STOP_EVENT_LOOP

data1: 0

data2: 0];

if (event) {

[NSApp postEvent: event atStart: true];

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyTypeObject FigureCanvasType = {

PyVarObject_HEAD_INIT(NULL, 0)

.tp_name = "matplotlib.backends._macosx.FigureCanvas",

.tp_doc = PyDoc_STR("A FigureCanvas object wraps a Cocoa NSView object."),

.tp_basicsize = sizeof(FigureCanvas),

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

.tp_new = (newfunc)FigureCanvas_new,

.tp_init = (initproc)FigureCanvas_init,

.tp_dealloc = (destructor)FigureCanvas_dealloc,

.tp_repr = (reprfunc)FigureCanvas_repr,

.tp_methods = (PyMethodDef[]){

{"update",

(PyCFunction)FigureCanvas_update,

METH_NOARGS,

NULL}, // docstring inherited

{"flush_events",

(PyCFunction)FigureCanvas_flush_events,

METH_NOARGS,

NULL}, // docstring inherited

{"set_cursor",

(PyCFunction)FigureCanvas_set_cursor,

METH_VARARGS,

PyDoc_STR("Set the active cursor.")},

{"set_rubberband",

(PyCFunction)FigureCanvas_set_rubberband,

METH_VARARGS,

PyDoc_STR("Specify a new rubberband rectangle and invalidate it.")},

{"remove_rubberband",

(PyCFunction)FigureCanvas_remove_rubberband,

METH_NOARGS,

PyDoc_STR("Remove the current rubberband rectangle.")},

{"_start_event_loop",

(PyCFunction)FigureCanvas__start_event_loop,

METH_KEYWORDS | METH_VARARGS,

NULL}, // docstring inherited

{"stop_event_loop",

(PyCFunction)FigureCanvas_stop_event_loop,

METH_NOARGS,

NULL}, // docstring inherited

{} // sentinel

},

};

static PyTypeObject FigureManagerType; // forward declaration, needed in destroy()

typedef struct {

PyObject_HEAD

__strong Window* window;

} FigureManager;

static PyObject*

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

{

BEGIN_OBJC_ENTRY

if (![NSThread isMainThread]) {

PyErr_SetString(

PyExc_RuntimeError,

"Cannot create a GUI FigureManager outside the main thread "

"using the MacOS backend. Use a non-interactive "

"backend like 'agg' to make plots on worker threads."

);

return NULL;

}

lazy_init();

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

if (!self) {

return NULL;

}

return (PyObject*)self;

END_OBJC_ENTRY

return NULL;

}

static int

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

{

BEGIN_OBJC_ENTRY

PyObject* canvas;

if (!PyArg_ParseTuple(args, "O", &canvas)) {

return -1;

}

View* view = ((FigureCanvas*)canvas)->view;

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

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

return -1;

}

PyObject* size = PyObject_CallMethod(canvas, "get_width_height", "");

int width, height;

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

Py_XDECREF(size);

return -1;

}

Py_DECREF(size);

NSRect rect = NSMakeRect( /* x */ 100, /* y */ 350, width, height);

Window* window = [[Window alloc] initWithContentRect: rect

styleMask: NSWindowStyleMaskTitled

| NSWindowStyleMaskClosable

| NSWindowStyleMaskResizable

| NSWindowStyleMaskMiniaturizable

backing: NSBackingStoreBuffered

defer: YES];

[window setDelegate: view];

[window setManager: (PyObject*)self];

[window makeFirstResponder: view];

[window setReleasedWhenClosed:NO];

[[window contentView] addSubview: view];

[view updateDevicePixelRatio: [window backingScaleFactor]];

self->window = window;

if (!FigureWindowHashTable) {

FigureWindowHashTable = [NSHashTable weakObjectsHashTable];

}

[FigureWindowHashTable addObject:window];

END_OBJC_ENTRY

return 0;

}

static PyObject*

FigureManager__set_window_mode(FigureManager* self, PyObject* args)

{

BEGIN_OBJC_ENTRY

const char* window_mode;

if (!PyArg_ParseTuple(args, "s", &window_mode) || !self->window) {

return NULL;

}

NSString* window_mode_str = [NSString stringWithUTF8String: window_mode];

if ([window_mode_str isEqualToString: @"tab"]) {

[self->window setTabbingMode: NSWindowTabbingModePreferred];

} else if ([window_mode_str isEqualToString: @"window"]) {

[self->window setTabbingMode: NSWindowTabbingModeDisallowed];

} else { // system settings

[self->window setTabbingMode: NSWindowTabbingModeAutomatic];

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_repr(FigureManager* self)

{

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

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

}

static void

FigureManager__closeAndClearWindow(FigureManager* self)

{

if (self->window) {

[self->window close];

[self->window setDelegate:nil];

[self->window setManager:NULL];

[FigureWindowHashTable removeObject:self->window];

self->window = nil;

if ([FigureWindowHashTable count] == 0 && IsRunningFromShow) {

[NSApp stop:nil];

}

}

}

static void

FigureManager_dealloc(FigureManager* self)

{

BEGIN_OBJC_ENTRY

FigureManager__closeAndClearWindow(self);

END_OBJC_ENTRY

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

}

static PyObject*

FigureManager__show(FigureManager* self)

{

BEGIN_OBJC_ENTRY

[self->window makeKeyAndOrderFront: nil];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager__raise(FigureManager* self)

{

BEGIN_OBJC_ENTRY

[self->window orderFrontRegardless];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_destroy(FigureManager* self)

{

BEGIN_OBJC_ENTRY

FigureManager__closeAndClearWindow(self);

// call super(self, FigureManager).destroy() - it seems we need the

// explicit arguments, and just super() doesn't work in the C API.

PyObject *super_obj = PyObject_CallFunctionObjArgs(

(PyObject *)&PySuper_Type,

(PyObject *)&FigureManagerType,

self,

NULL

);

if (super_obj == NULL) {

return NULL; // error

}

PyObject *result = PyObject_CallMethod(super_obj, "destroy", NULL);

Py_DECREF(super_obj);

if (result == NULL) {

return NULL; // error

}

Py_DECREF(result);

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_set_icon(PyObject* null, PyObject* args) {

BEGIN_OBJC_ENTRY

PyObject* icon_path;

if (!PyArg_ParseTuple(args, "O&", &PyUnicode_FSDecoder, &icon_path)) {

return NULL;

}

const char* icon_path_ptr = PyUnicode_AsUTF8(icon_path);

if (!icon_path_ptr) {

Py_DECREF(icon_path);

return NULL;

}

NSString* ns_icon_path = [NSString stringWithUTF8String: icon_path_ptr];

Py_DECREF(icon_path);

if (!ns_icon_path) {

PyErr_SetString(PyExc_RuntimeError, "Could not convert to NSString*");

return NULL;

}

NSImage* image = [[NSImage alloc] initByReferencingFile: ns_icon_path];

if (!image) {

PyErr_SetString(PyExc_RuntimeError, "Could not create NSImage*");

return NULL;

}

if (!image.valid) {

PyErr_SetString(PyExc_RuntimeError, "Image is not valid");

return NULL;

}

NSApplication* app = [NSApplication sharedApplication];

app.applicationIconImage = image;

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_set_window_title(FigureManager* self,

PyObject *args, PyObject *kwds)

{

BEGIN_OBJC_ENTRY

const char* title;

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

return NULL;

}

// PyArg_ParseTuple "s" guarantees valid UTF-8, so stringWithUTF8String: will

// not return nil here; the nullable annotation is a false positive.

// NOLINTNEXTLINE(clang-analyzer-nullability.NullablePassedToNonnull)

[self->window setTitle: [NSString stringWithUTF8String: title]];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_get_window_title(FigureManager* self)

{

BEGIN_OBJC_ENTRY

NSString* title = [self->window title];

if (title) {

return PyUnicode_FromString([title UTF8String]);

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

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

{

BEGIN_OBJC_ENTRY

int width, height;

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

return NULL;

}

Window* window = self->window;

if (window) {

CGFloat device_pixel_ratio = [window backingScaleFactor];

width /= device_pixel_ratio;

height /= device_pixel_ratio;

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

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

}

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyObject*

FigureManager_full_screen_toggle(FigureManager* self)

{

BEGIN_OBJC_ENTRY

[self->window toggleFullScreen: nil];

END_OBJC_ENTRY

RETURN_NULL_OR_NONE

}

static PyTypeObject FigureManagerType = {

PyVarObject_HEAD_INIT(NULL, 0)

.tp_name = "matplotlib.backends._macosx.FigureManager",

.tp_doc = PyDoc_STR("A FigureManager object wraps a Cocoa NSWindow object."),

.tp_basicsize = sizeof(FigureManager),

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

.tp_new = (newfunc)FigureManager_new,

.tp_init = (initproc)FigureManager_init,

.tp_dealloc = (destructor)FigureManager_dealloc,

.tp_repr = (reprfunc)FigureManager_repr,

.tp_methods = (PyMethodDef[]){ // All docstrings are inherited.

{"_show",

(PyCFunction)FigureManager__show,

METH_NOARGS},

{"_raise",

(PyCFunction)FigureManager__raise,

METH_NOARGS},

{"destroy",

(PyCFunction)FigureManager_destroy,

METH_NOARGS},

{"_set_window_mode",

(PyCFunction)FigureManager__set_window_mode,

METH_VARARGS,

PyDoc_STR("Set the window open mode (system, tab, window)")},

{"set_icon",

(PyCFunction)FigureManager_set_icon,

METH_STATIC | METH_VARARGS,

PyDoc_STR("Set application icon")},

{"set_window_title",

(PyCFunction)FigureManager_set_window_title,

METH_VARARGS},

{"get_window_title",

(PyCFunction)FigureManager_get_window_title,

METH_NOARGS},

{"resize",

(PyCFunction)FigureManager_resize,

METH_VARARGS},

{"full_screen_toggle",

(PyCFunction)FigureManager_full_screen_toggle,

METH_NOARGS},

{} // sentinel

},

};

@implementation MatplotlibAppDelegate

- (BOOL)applicationSupportsSecureRestorableState:(NSApplication *)app {

return YES;

}

@interface NavigationToolbar2Handler : NSObject

- (void)installCallbacks:(SEL[7])actions forButtons:(__strong 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;

@property (nonatomic, assign) PyObject *toolbar;

@property (nonatomic, readonly) NSButton *panButton;

@property (nonatomic, readonly) NSButton *zoomButton;

typedef struct {

PyObject_HEAD

__strong NSTextView* messagebox;

__strong NavigationToolbar2Handler* handler;

int height;

} NavigationToolbar2;

@implementation NavigationToolbar2Handler

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

{

for (int 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; }