diff options
| -rw-r--r-- | Mac/Modules/carbonevt/CarbonEvtsupport.py | 9 | ||||
| -rw-r--r-- | Mac/Modules/carbonevt/_CarbonEvt.c | 1596 |
2 files changed, 1600 insertions, 5 deletions
diff --git a/Mac/Modules/carbonevt/CarbonEvtsupport.py b/Mac/Modules/carbonevt/CarbonEvtsupport.py index da674fc..2609611 100644 --- a/Mac/Modules/carbonevt/CarbonEvtsupport.py +++ b/Mac/Modules/carbonevt/CarbonEvtsupport.py @@ -2,7 +2,7 @@ from macsupport import * -from CarbonEventsscan import RefObjectTypes +from CarbonEvtscan import RefObjectTypes # where should this go? macsupport.py? CFStringRef = OpaqueByValueType('CFStringRef') @@ -172,8 +172,7 @@ execfile('CarbonEventsgen.py') for f in functions: module.add(f) # add all the functions carboneventsgen put in the list for typ in RefObjectTypes: ## go thru all ObjectTypes as defined in CarbonEventsscan.py - methods = eval(typ + 'methods') ## get a reference to the method list -from the main namespace + methods = eval(typ + 'methods') ## get a reference to the method list from the main namespace obj = eval(typ + 'object') ## get a reference to the object for m in methods: obj.add(m) ## add each method in the list to the object @@ -227,5 +226,5 @@ module.add(f) SetOutputFileName('_CarbonEvt.c') module.generate() -import os -os.system("python setup.py build") +##import os +##os.system("python setup.py build") diff --git a/Mac/Modules/carbonevt/_CarbonEvt.c b/Mac/Modules/carbonevt/_CarbonEvt.c new file mode 100644 index 0000000..aab735b --- /dev/null +++ b/Mac/Modules/carbonevt/_CarbonEvt.c @@ -0,0 +1,1596 @@ + +/* ====================== Module CarbonEvents ======================= */ + +#include "Python.h" + + + +#include <Carbon/Carbon.h> +#include "macglue.h" + +#define USE_MAC_MP_MULTITHREADING 1 + +#if USE_MAC_MP_MULTITHREADING +static PyThreadState *_save; +static MPCriticalRegionID reentrantLock; +#endif /* USE_MAC_MP_MULTITHREADING */ + +extern int CFStringRef_New(CFStringRef *); + +extern int CFStringRef_Convert(PyObject *, CFStringRef *); +extern int CFBundleRef_Convert(PyObject *, CFBundleRef *); + +int EventTargetRef_Convert(PyObject *, EventTargetRef *); +PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself); +PyObject *EventRef_New(EventRef itself); + +/********** EventTypeSpec *******/ +static PyObject* +EventTypeSpec_New(EventTypeSpec *in) +{ + return Py_BuildValue("ll", in->eventClass, in->eventKind); +} + +static int +EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out) +{ + if (PyArg_ParseTuple(v, "ll", &(out->eventClass), &(out->eventKind))) + return 1; + return NULL; +} + +/********** end EventTypeSpec *******/ + +/********** HIPoint *******/ + +static PyObject* +HIPoint_New(HIPoint *in) +{ + return Py_BuildValue("ff", in->x, in->y); +} + +static int +HIPoint_Convert(PyObject *v, HIPoint *out) +{ + if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y))) + return 1; + return NULL; +} + +/********** end HIPoint *******/ + +/********** EventHotKeyID *******/ + +static PyObject* +EventHotKeyID_New(EventHotKeyID *in) +{ + return Py_BuildValue("ll", in->signature, in->id); +} + +static int +EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out) +{ + if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id)) + return 1; + return NULL; +} + +/********** end EventHotKeyID *******/ + +/******** handlecommand ***********/ + +pascal OSStatus CarbonEvents_HandleCommand(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) { + PyObject *retValue; + int status; + +#if USE_MAC_MP_MULTITHREADING + MPEnterCriticalRegion(reentrantLock, kDurationForever); + PyEval_RestoreThread(_save); +#endif /* USE_MAC_MP_MULTITHREADING */ + + retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&", EventHandlerCallRef_New, handlerRef, EventRef_New, event); + status = PyInt_AsLong(retValue); + +#if USE_MAC_MP_MULTITHREADING + _save = PyEval_SaveThread(); + MPExitCriticalRegion(reentrantLock); +#endif /* USE_MAC_MP_MULTITHREADING */ + + return status; +} + +/******** end handlecommand ***********/ + + +static PyObject *CarbonEvents_Error; + +/* ---------------------- Object type EventRef ---------------------- */ + +PyTypeObject EventRef_Type; + +#define EventRef_Check(x) ((x)->ob_type == &EventRef_Type) + +typedef struct EventRefObject { + PyObject_HEAD + EventRef ob_itself; +} EventRefObject; + +PyObject *EventRef_New(EventRef itself) +{ + EventRefObject *it; + it = PyObject_NEW(EventRefObject, &EventRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventRef_Convert(PyObject *v, EventRef *p_itself) +{ + if (!EventRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventRef required"); + return 0; + } + *p_itself = ((EventRefObject *)v)->ob_itself; + return 1; +} + +static void EventRef_dealloc(EventRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = RetainEvent(_self->ob_itself); + _res = Py_BuildValue("O&", + EventRef_New, _rv); + return _res; +} + +static PyObject *EventRef_GetEventRetainCount(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetEventRetainCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *EventRef_ReleaseEvent(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + ReleaseEvent(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventRef_SetEventParameter(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + OSType inName; + OSType inType; + UInt32 inSize; + char* inDataPtr; + if (!PyArg_ParseTuple(_args, "O&O&ls", + PyMac_GetOSType, &inName, + PyMac_GetOSType, &inType, + &inSize, + &inDataPtr)) + return NULL; + _err = SetEventParameter(_self->ob_itself, + inName, + inType, + inSize, + inDataPtr); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventRef_GetEventClass(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetEventClass(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *EventRef_GetEventKind(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetEventKind(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *EventRef_GetEventTime(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + double _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetEventTime(_self->ob_itself); + _res = Py_BuildValue("d", + _rv); + return _res; +} + +static PyObject *EventRef_SetEventTime(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + double inTime; + if (!PyArg_ParseTuple(_args, "d", + &inTime)) + return NULL; + _err = SetEventTime(_self->ob_itself, + inTime); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventRef_IsUserCancelEventRef(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = IsUserCancelEventRef(_self->ob_itself); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *EventRef_ConvertEventRefToEventRecord(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + EventRecord outEvent; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = ConvertEventRefToEventRecord(_self->ob_itself, + &outEvent); + _res = Py_BuildValue("bO&", + _rv, + PyMac_BuildEventRecord, &outEvent); + return _res; +} + +static PyObject *EventRef_IsEventInMask(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + UInt16 inMask; + if (!PyArg_ParseTuple(_args, "H", + &inMask)) + return NULL; + _rv = IsEventInMask(_self->ob_itself, + inMask); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyObject *EventRef_SendEventToEventTarget(EventRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + EventTargetRef inTarget; + if (!PyArg_ParseTuple(_args, "O&", + EventTargetRef_Convert, &inTarget)) + return NULL; + _err = SendEventToEventTarget(_self->ob_itself, + inTarget); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef EventRef_methods[] = { + {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1, + "() -> (EventRef _rv)"}, + {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1, + "() -> (UInt32 _rv)"}, + {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1, + "() -> None"}, + {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1, + "(OSType inName, OSType inType, UInt32 inSize, char* inDataPtr) -> None"}, + {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1, + "() -> (UInt32 _rv)"}, + {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1, + "() -> (UInt32 _rv)"}, + {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1, + "() -> (double _rv)"}, + {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1, + "(double inTime) -> None"}, + {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1, + "() -> (Boolean _rv)"}, + {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1, + "() -> (Boolean _rv, EventRecord outEvent)"}, + {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1, + "(UInt16 inMask) -> (Boolean _rv)"}, + {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1, + "(EventTargetRef inTarget) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventRef_chain = { EventRef_methods, NULL }; + +static PyObject *EventRef_getattr(EventRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventRef_chain, (PyObject *)self, name); +} + +#define EventRef_setattr NULL + +#define EventRef_compare NULL + +#define EventRef_repr NULL + +#define EventRef_hash NULL + +PyTypeObject EventRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventRef", /*tp_name*/ + sizeof(EventRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventRef_getattr, /*tp_getattr*/ + (setattrfunc) EventRef_setattr, /*tp_setattr*/ + (cmpfunc) EventRef_compare, /*tp_compare*/ + (reprfunc) EventRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventRef_hash, /*tp_hash*/ +}; + +/* -------------------- End object type EventRef -------------------- */ + + +/* ------------------- Object type EventQueueRef -------------------- */ + +PyTypeObject EventQueueRef_Type; + +#define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type) + +typedef struct EventQueueRefObject { + PyObject_HEAD + EventQueueRef ob_itself; +} EventQueueRefObject; + +PyObject *EventQueueRef_New(EventQueueRef itself) +{ + EventQueueRefObject *it; + it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself) +{ + if (!EventQueueRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventQueueRef required"); + return 0; + } + *p_itself = ((EventQueueRefObject *)v)->ob_itself; + return 1; +} + +static void EventQueueRef_dealloc(EventQueueRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + EventRef inEvent; + SInt16 inPriority; + if (!PyArg_ParseTuple(_args, "O&h", + EventRef_Convert, &inEvent, + &inPriority)) + return NULL; + _err = PostEventToQueue(_self->ob_itself, + inEvent, + inPriority); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UInt32 inNumTypes; + EventTypeSpec * inList; + if (!PyArg_ParseTuple(_args, "lO&", + &inNumTypes, + EventTypeSpec_Convert, &inList)) + return NULL; + _err = FlushEventsMatchingListFromQueue(_self->ob_itself, + inNumTypes, + &inList); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventQueueRef_FlushEventQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = FlushEventQueue(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventQueueRef_GetNumEventsInQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetNumEventsInQueue(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *EventQueueRef_RemoveEventFromQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + EventRef inEvent; + if (!PyArg_ParseTuple(_args, "O&", + EventRef_Convert, &inEvent)) + return NULL; + _err = RemoveEventFromQueue(_self->ob_itself, + inEvent); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + EventRef inEvent; + if (!PyArg_ParseTuple(_args, "O&", + EventRef_Convert, &inEvent)) + return NULL; + _rv = IsEventInQueue(_self->ob_itself, + inEvent); + _res = Py_BuildValue("b", + _rv); + return _res; +} + +static PyMethodDef EventQueueRef_methods[] = { + {"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1, + "(EventRef inEvent, SInt16 inPriority) -> None"}, + {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1, + "(UInt32 inNumTypes, EventTypeSpec * inList) -> None"}, + {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1, + "() -> None"}, + {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1, + "() -> (UInt32 _rv)"}, + {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1, + "(EventRef inEvent) -> None"}, + {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1, + "(EventRef inEvent) -> (Boolean _rv)"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventQueueRef_chain = { EventQueueRef_methods, NULL }; + +static PyObject *EventQueueRef_getattr(EventQueueRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventQueueRef_chain, (PyObject *)self, name); +} + +#define EventQueueRef_setattr NULL + +#define EventQueueRef_compare NULL + +#define EventQueueRef_repr NULL + +#define EventQueueRef_hash NULL + +PyTypeObject EventQueueRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventQueueRef", /*tp_name*/ + sizeof(EventQueueRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventQueueRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventQueueRef_getattr, /*tp_getattr*/ + (setattrfunc) EventQueueRef_setattr, /*tp_setattr*/ + (cmpfunc) EventQueueRef_compare, /*tp_compare*/ + (reprfunc) EventQueueRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventQueueRef_hash, /*tp_hash*/ +}; + +/* ----------------- End object type EventQueueRef ------------------ */ + + +/* -------------------- Object type EventLoopRef -------------------- */ + +PyTypeObject EventLoopRef_Type; + +#define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type) + +typedef struct EventLoopRefObject { + PyObject_HEAD + EventLoopRef ob_itself; +} EventLoopRefObject; + +PyObject *EventLoopRef_New(EventLoopRef itself) +{ + EventLoopRefObject *it; + it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself) +{ + if (!EventLoopRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventLoopRef required"); + return 0; + } + *p_itself = ((EventLoopRefObject *)v)->ob_itself; + return 1; +} + +static void EventLoopRef_dealloc(EventLoopRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = QuitEventLoop(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef EventLoopRef_methods[] = { + {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1, + "() -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventLoopRef_chain = { EventLoopRef_methods, NULL }; + +static PyObject *EventLoopRef_getattr(EventLoopRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventLoopRef_chain, (PyObject *)self, name); +} + +#define EventLoopRef_setattr NULL + +#define EventLoopRef_compare NULL + +#define EventLoopRef_repr NULL + +#define EventLoopRef_hash NULL + +PyTypeObject EventLoopRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventLoopRef", /*tp_name*/ + sizeof(EventLoopRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventLoopRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventLoopRef_getattr, /*tp_getattr*/ + (setattrfunc) EventLoopRef_setattr, /*tp_setattr*/ + (cmpfunc) EventLoopRef_compare, /*tp_compare*/ + (reprfunc) EventLoopRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventLoopRef_hash, /*tp_hash*/ +}; + +/* ------------------ End object type EventLoopRef ------------------ */ + + +/* ----------------- Object type EventLoopTimerRef ------------------ */ + +PyTypeObject EventLoopTimerRef_Type; + +#define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type) + +typedef struct EventLoopTimerRefObject { + PyObject_HEAD + EventLoopTimerRef ob_itself; +} EventLoopTimerRefObject; + +PyObject *EventLoopTimerRef_New(EventLoopTimerRef itself) +{ + EventLoopTimerRefObject *it; + it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself) +{ + if (!EventLoopTimerRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required"); + return 0; + } + *p_itself = ((EventLoopTimerRefObject *)v)->ob_itself; + return 1; +} + +static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = RemoveEventLoopTimer(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + double inNextFire; + if (!PyArg_ParseTuple(_args, "d", + &inNextFire)) + return NULL; + _err = SetEventLoopTimerNextFireTime(_self->ob_itself, + inNextFire); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef EventLoopTimerRef_methods[] = { + {"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1, + "() -> None"}, + {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1, + "(double inNextFire) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventLoopTimerRef_chain = { EventLoopTimerRef_methods, NULL }; + +static PyObject *EventLoopTimerRef_getattr(EventLoopTimerRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventLoopTimerRef_chain, (PyObject *)self, name); +} + +#define EventLoopTimerRef_setattr NULL + +#define EventLoopTimerRef_compare NULL + +#define EventLoopTimerRef_repr NULL + +#define EventLoopTimerRef_hash NULL + +PyTypeObject EventLoopTimerRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventLoopTimerRef", /*tp_name*/ + sizeof(EventLoopTimerRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventLoopTimerRef_getattr, /*tp_getattr*/ + (setattrfunc) EventLoopTimerRef_setattr, /*tp_setattr*/ + (cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/ + (reprfunc) EventLoopTimerRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventLoopTimerRef_hash, /*tp_hash*/ +}; + +/* --------------- End object type EventLoopTimerRef ---------------- */ + + +/* ------------------ Object type EventHandlerRef ------------------- */ + +PyTypeObject EventHandlerRef_Type; + +#define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type) + +typedef struct EventHandlerRefObject { + PyObject_HEAD + EventHandlerRef ob_itself; +} EventHandlerRefObject; + +PyObject *EventHandlerRef_New(EventHandlerRef itself) +{ + EventHandlerRefObject *it; + it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventHandlerRef_Convert(PyObject *v, EventHandlerRef *p_itself) +{ + if (!EventHandlerRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventHandlerRef required"); + return 0; + } + *p_itself = ((EventHandlerRefObject *)v)->ob_itself; + return 1; +} + +static void EventHandlerRef_dealloc(EventHandlerRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = RemoveEventHandler(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UInt32 inNumTypes; + EventTypeSpec * inList; + if (!PyArg_ParseTuple(_args, "lO&", + &inNumTypes, + EventTypeSpec_Convert, &inList)) + return NULL; + _err = AddEventTypesToHandler(_self->ob_itself, + inNumTypes, + &inList); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UInt32 inNumTypes; + EventTypeSpec * inList; + if (!PyArg_ParseTuple(_args, "lO&", + &inNumTypes, + EventTypeSpec_Convert, &inList)) + return NULL; + _err = RemoveEventTypesFromHandler(_self->ob_itself, + inNumTypes, + &inList); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef EventHandlerRef_methods[] = { + {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1, + "() -> None"}, + {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1, + "(UInt32 inNumTypes, EventTypeSpec * inList) -> None"}, + {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1, + "(UInt32 inNumTypes, EventTypeSpec * inList) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventHandlerRef_chain = { EventHandlerRef_methods, NULL }; + +static PyObject *EventHandlerRef_getattr(EventHandlerRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventHandlerRef_chain, (PyObject *)self, name); +} + +#define EventHandlerRef_setattr NULL + +#define EventHandlerRef_compare NULL + +#define EventHandlerRef_repr NULL + +#define EventHandlerRef_hash NULL + +PyTypeObject EventHandlerRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventHandlerRef", /*tp_name*/ + sizeof(EventHandlerRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventHandlerRef_getattr, /*tp_getattr*/ + (setattrfunc) EventHandlerRef_setattr, /*tp_setattr*/ + (cmpfunc) EventHandlerRef_compare, /*tp_compare*/ + (reprfunc) EventHandlerRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventHandlerRef_hash, /*tp_hash*/ +}; + +/* ---------------- End object type EventHandlerRef ----------------- */ + + +/* ---------------- Object type EventHandlerCallRef ----------------- */ + +PyTypeObject EventHandlerCallRef_Type; + +#define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type) + +typedef struct EventHandlerCallRefObject { + PyObject_HEAD + EventHandlerCallRef ob_itself; +} EventHandlerCallRefObject; + +PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself) +{ + EventHandlerCallRefObject *it; + it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself) +{ + if (!EventHandlerCallRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required"); + return 0; + } + *p_itself = ((EventHandlerCallRefObject *)v)->ob_itself; + return 1; +} + +static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + EventRef inEvent; + if (!PyArg_ParseTuple(_args, "O&", + EventRef_Convert, &inEvent)) + return NULL; + _err = CallNextEventHandler(_self->ob_itself, + inEvent); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef EventHandlerCallRef_methods[] = { + {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1, + "(EventRef inEvent) -> None"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventHandlerCallRef_chain = { EventHandlerCallRef_methods, NULL }; + +static PyObject *EventHandlerCallRef_getattr(EventHandlerCallRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventHandlerCallRef_chain, (PyObject *)self, name); +} + +#define EventHandlerCallRef_setattr NULL + +#define EventHandlerCallRef_compare NULL + +#define EventHandlerCallRef_repr NULL + +#define EventHandlerCallRef_hash NULL + +PyTypeObject EventHandlerCallRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventHandlerCallRef", /*tp_name*/ + sizeof(EventHandlerCallRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventHandlerCallRef_getattr, /*tp_getattr*/ + (setattrfunc) EventHandlerCallRef_setattr, /*tp_setattr*/ + (cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/ + (reprfunc) EventHandlerCallRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventHandlerCallRef_hash, /*tp_hash*/ +}; + +/* -------------- End object type EventHandlerCallRef --------------- */ + + +/* ------------------- Object type EventTargetRef ------------------- */ + +PyTypeObject EventTargetRef_Type; + +#define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type) + +typedef struct EventTargetRefObject { + PyObject_HEAD + EventTargetRef ob_itself; +} EventTargetRefObject; + +PyObject *EventTargetRef_New(EventTargetRef itself) +{ + EventTargetRefObject *it; + it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself) +{ + if (!EventTargetRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventTargetRef required"); + return 0; + } + *p_itself = ((EventTargetRefObject *)v)->ob_itself; + return 1; +} + +static void EventTargetRef_dealloc(EventTargetRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = InstallStandardEventHandler(_self->ob_itself); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + EventTypeSpec inSpec; + PyObject *callback; + EventHandlerRef outRef; + OSStatus _err; + EventHandlerUPP event; + + if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback)) + return NULL; + + event = NewEventHandlerUPP(CarbonEvents_HandleCommand); + _err = InstallEventHandler(_self->ob_itself, event, 1, &inSpec, (void *)callback, &outRef); + if (_err != noErr) return PyMac_Error(_err); + + return Py_BuildValue("l", outRef); + +} + +static PyMethodDef EventTargetRef_methods[] = { + {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1, + "() -> None"}, + {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1, + "(EventTargetRef inTarget, EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)"}, + {NULL, NULL, 0} +}; + +PyMethodChain EventTargetRef_chain = { EventTargetRef_methods, NULL }; + +static PyObject *EventTargetRef_getattr(EventTargetRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventTargetRef_chain, (PyObject *)self, name); +} + +#define EventTargetRef_setattr NULL + +#define EventTargetRef_compare NULL + +#define EventTargetRef_repr NULL + +#define EventTargetRef_hash NULL + +PyTypeObject EventTargetRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventTargetRef", /*tp_name*/ + sizeof(EventTargetRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventTargetRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventTargetRef_getattr, /*tp_getattr*/ + (setattrfunc) EventTargetRef_setattr, /*tp_setattr*/ + (cmpfunc) EventTargetRef_compare, /*tp_compare*/ + (reprfunc) EventTargetRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventTargetRef_hash, /*tp_hash*/ +}; + +/* ----------------- End object type EventTargetRef ----------------- */ + + +/* ------------------- Object type EventHotKeyRef ------------------- */ + +PyTypeObject EventHotKeyRef_Type; + +#define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type) + +typedef struct EventHotKeyRefObject { + PyObject_HEAD + EventHotKeyRef ob_itself; +} EventHotKeyRefObject; + +PyObject *EventHotKeyRef_New(EventHotKeyRef itself) +{ + EventHotKeyRefObject *it; + it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + return (PyObject *)it; +} +int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself) +{ + if (!EventHotKeyRef_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required"); + return 0; + } + *p_itself = ((EventHotKeyRefObject *)v)->ob_itself; + return 1; +} + +static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self) +{ + /* Cleanup of self->ob_itself goes here */ + PyMem_DEL(self); +} + +static PyMethodDef EventHotKeyRef_methods[] = { + {NULL, NULL, 0} +}; + +PyMethodChain EventHotKeyRef_chain = { EventHotKeyRef_methods, NULL }; + +static PyObject *EventHotKeyRef_getattr(EventHotKeyRefObject *self, char *name) +{ + return Py_FindMethodInChain(&EventHotKeyRef_chain, (PyObject *)self, name); +} + +#define EventHotKeyRef_setattr NULL + +#define EventHotKeyRef_compare NULL + +#define EventHotKeyRef_repr NULL + +#define EventHotKeyRef_hash NULL + +PyTypeObject EventHotKeyRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "EventHotKeyRef", /*tp_name*/ + sizeof(EventHotKeyRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) EventHotKeyRef_getattr, /*tp_getattr*/ + (setattrfunc) EventHotKeyRef_setattr, /*tp_setattr*/ + (cmpfunc) EventHotKeyRef_compare, /*tp_compare*/ + (reprfunc) EventHotKeyRef_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) EventHotKeyRef_hash, /*tp_hash*/ +}; + +/* ----------------- End object type EventHotKeyRef ----------------- */ + + +static PyObject *CarbonEvents_GetCurrentEventLoop(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventLoopRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetCurrentEventLoop(); + _res = Py_BuildValue("O&", + EventLoopRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetMainEventLoop(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventLoopRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMainEventLoop(); + _res = Py_BuildValue("O&", + EventLoopRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_RunCurrentEventLoop(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + double inTimeout; + if (!PyArg_ParseTuple(_args, "d", + &inTimeout)) + return NULL; + _err = RunCurrentEventLoop(inTimeout); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CarbonEvents_ReceiveNextEvent(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + UInt32 inNumTypes; + EventTypeSpec * inList; + double inTimeout; + Boolean inPullEvent; + EventRef outEvent; + if (!PyArg_ParseTuple(_args, "lO&db", + &inNumTypes, + EventTypeSpec_Convert, &inList, + &inTimeout, + &inPullEvent)) + return NULL; + _err = ReceiveNextEvent(inNumTypes, + &inList, + inTimeout, + inPullEvent, + &outEvent); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + EventRef_New, outEvent); + return _res; +} + +static PyObject *CarbonEvents_GetCurrentEventQueue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventQueueRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetCurrentEventQueue(); + _res = Py_BuildValue("O&", + EventQueueRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetMainEventQueue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventQueueRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetMainEventQueue(); + _res = Py_BuildValue("O&", + EventQueueRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetCurrentEventTime(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + double _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetCurrentEventTime(); + _res = Py_BuildValue("d", + _rv); + return _res; +} + +static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + double _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetLastUserEventTime(); + _res = Py_BuildValue("d", + _rv); + return _res; +} + +static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventTargetRef _rv; + WindowPtr inWindow; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &inWindow)) + return NULL; + _rv = GetWindowEventTarget(inWindow); + _res = Py_BuildValue("O&", + EventTargetRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetControlEventTarget(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventTargetRef _rv; + ControlHandle inControl; + if (!PyArg_ParseTuple(_args, "O&", + CtlObj_Convert, &inControl)) + return NULL; + _rv = GetControlEventTarget(inControl); + _res = Py_BuildValue("O&", + EventTargetRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetMenuEventTarget(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventTargetRef _rv; + MenuHandle inMenu; + if (!PyArg_ParseTuple(_args, "O&", + MenuObj_Convert, &inMenu)) + return NULL; + _rv = GetMenuEventTarget(inMenu); + _res = Py_BuildValue("O&", + EventTargetRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetApplicationEventTarget(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventTargetRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetApplicationEventTarget(); + _res = Py_BuildValue("O&", + EventTargetRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_GetUserFocusEventTarget(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + EventTargetRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetUserFocusEventTarget(); + _res = Py_BuildValue("O&", + EventTargetRef_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_QuitApplicationEventLoop(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + QuitApplicationEventLoop(); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CarbonEvents_SetUserFocusWindow(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &inWindow)) + return NULL; + _err = SetUserFocusWindow(inWindow); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CarbonEvents_GetUserFocusWindow(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + WindowPtr _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = GetUserFocusWindow(); + _res = Py_BuildValue("O&", + WinObj_New, _rv); + return _res; +} + +static PyObject *CarbonEvents_SetWindowDefaultButton(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + ControlHandle inControl; + if (!PyArg_ParseTuple(_args, "O&O&", + WinObj_Convert, &inWindow, + CtlObj_Convert, &inControl)) + return NULL; + _err = SetWindowDefaultButton(inWindow, + inControl); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CarbonEvents_SetWindowCancelButton(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + ControlHandle inControl; + if (!PyArg_ParseTuple(_args, "O&O&", + WinObj_Convert, &inWindow, + CtlObj_Convert, &inControl)) + return NULL; + _err = SetWindowCancelButton(inWindow, + inControl); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CarbonEvents_GetWindowDefaultButton(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + ControlHandle outControl; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &inWindow)) + return NULL; + _err = GetWindowDefaultButton(inWindow, + &outControl); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CtlObj_New, outControl); + return _res; +} + +static PyObject *CarbonEvents_GetWindowCancelButton(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + WindowPtr inWindow; + ControlHandle outControl; + if (!PyArg_ParseTuple(_args, "O&", + WinObj_Convert, &inWindow)) + return NULL; + _err = GetWindowCancelButton(inWindow, + &outControl); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + CtlObj_New, outControl); + return _res; +} + +static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + +#if USE_MAC_MP_MULTITHREADING + if (MPCreateCriticalRegion(&reentrantLock) != noErr) { + printf("lock failure + "); + return NULL; + } + _save = PyEval_SaveThread(); +#endif /* USE_MAC_MP_MULTITHREADING */ + + RunApplicationEventLoop(); + +#if USE_MAC_MP_MULTITHREADING + PyEval_RestoreThread(_save); + + MPDeleteCriticalRegion(reentrantLock); +#endif /* USE_MAC_MP_MULTITHREADING */ + + Py_INCREF(Py_None); + + return Py_None; + +} + +static PyMethodDef CarbonEvents_methods[] = { + {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1, + "() -> (EventLoopRef _rv)"}, + {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1, + "() -> (EventLoopRef _rv)"}, + {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1, + "(double inTimeout) -> None"}, + {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1, + "(UInt32 inNumTypes, EventTypeSpec * inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)"}, + {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1, + "() -> (EventQueueRef _rv)"}, + {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1, + "() -> (EventQueueRef _rv)"}, + {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1, + "() -> (double _rv)"}, + {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1, + "() -> (double _rv)"}, + {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1, + "(WindowPtr inWindow) -> (EventTargetRef _rv)"}, + {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1, + "(ControlHandle inControl) -> (EventTargetRef _rv)"}, + {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1, + "(MenuHandle inMenu) -> (EventTargetRef _rv)"}, + {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1, + "() -> (EventTargetRef _rv)"}, + {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1, + "() -> (EventTargetRef _rv)"}, + {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1, + "() -> None"}, + {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1, + "(WindowPtr inWindow) -> None"}, + {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1, + "() -> (WindowPtr _rv)"}, + {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1, + "(WindowPtr inWindow, ControlHandle inControl) -> None"}, + {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1, + "(WindowPtr inWindow, ControlHandle inControl) -> None"}, + {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1, + "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1, + "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1, + "() -> ()"}, + {NULL, NULL, 0} +}; + + + + +void initCarbonEvents(void) +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("CarbonEvents", CarbonEvents_methods); + d = PyModule_GetDict(m); + CarbonEvents_Error = PyMac_GetOSErrException(); + if (CarbonEvents_Error == NULL || + PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0) + return; + EventRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventRef_Type); + if (PyDict_SetItemString(d, "EventRefType", (PyObject *)&EventRef_Type) != 0) + Py_FatalError("can't initialize EventRefType"); + EventQueueRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventQueueRef_Type); + if (PyDict_SetItemString(d, "EventQueueRefType", (PyObject *)&EventQueueRef_Type) != 0) + Py_FatalError("can't initialize EventQueueRefType"); + EventLoopRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventLoopRef_Type); + if (PyDict_SetItemString(d, "EventLoopRefType", (PyObject *)&EventLoopRef_Type) != 0) + Py_FatalError("can't initialize EventLoopRefType"); + EventLoopTimerRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventLoopTimerRef_Type); + if (PyDict_SetItemString(d, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type) != 0) + Py_FatalError("can't initialize EventLoopTimerRefType"); + EventHandlerRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventHandlerRef_Type); + if (PyDict_SetItemString(d, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type) != 0) + Py_FatalError("can't initialize EventHandlerRefType"); + EventHandlerCallRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventHandlerCallRef_Type); + if (PyDict_SetItemString(d, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type) != 0) + Py_FatalError("can't initialize EventHandlerCallRefType"); + EventTargetRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventTargetRef_Type); + if (PyDict_SetItemString(d, "EventTargetRefType", (PyObject *)&EventTargetRef_Type) != 0) + Py_FatalError("can't initialize EventTargetRefType"); + EventHotKeyRef_Type.ob_type = &PyType_Type; + Py_INCREF(&EventHotKeyRef_Type); + if (PyDict_SetItemString(d, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type) != 0) + Py_FatalError("can't initialize EventHotKeyRefType"); +} + +/* ==================== End module CarbonEvents ===================== */ + |