| |
| /* ======================= Module _CarbonEvt ======================== */ |
| |
| #include "Python.h" |
| |
| #ifndef __LP64__ |
| |
| #include "pymactoolbox.h" |
| |
| /* Macro to test whether a weak-loaded CFM function exists */ |
| #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ |
| PyErr_SetString(PyExc_NotImplementedError, \ |
| "Not available in this shared library/OS version"); \ |
| return NULL; \ |
| }} while(0) |
| |
| |
| #include <Carbon/Carbon.h> |
| |
| 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 int |
| EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out) |
| { |
| if (PyArg_Parse(v, "(O&l)", |
| PyMac_GetOSType, &(out->eventClass), |
| &(out->eventKind))) |
| return 1; |
| return 0; |
| } |
| |
| /********** end EventTypeSpec *******/ |
| |
| /********** HIPoint *******/ |
| |
| #if 0 /* XXX doesn't compile */ |
| 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; |
| } |
| #endif |
| |
| /********** end HIPoint *******/ |
| |
| /********** EventHotKeyID *******/ |
| |
| static int |
| EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out) |
| { |
| if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id)) |
| return 1; |
| return 0; |
| } |
| |
| /********** end EventHotKeyID *******/ |
| |
| /******** myEventHandler ***********/ |
| |
| static EventHandlerUPP myEventHandlerUPP; |
| |
| static pascal OSStatus |
| myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) { |
| PyObject *retValue; |
| int status; |
| |
| retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&", |
| EventHandlerCallRef_New, handlerRef, |
| EventRef_New, event); |
| if (retValue == NULL) { |
| PySys_WriteStderr("Error in event handler callback:\n"); |
| PyErr_Print(); /* this also clears the error */ |
| status = noErr; /* complain? how? */ |
| } else { |
| if (retValue == Py_None) |
| status = noErr; |
| else if (PyInt_Check(retValue)) { |
| status = PyInt_AsLong(retValue); |
| } else |
| status = noErr; /* wrong object type, complain? */ |
| Py_DECREF(retValue); |
| } |
| |
| return status; |
| } |
| |
| /******** end myEventHandler ***********/ |
| |
| |
| static PyObject *CarbonEvents_Error; |
| |
| /* ---------------------- Object type EventRef ---------------------- */ |
| |
| PyTypeObject EventRef_Type; |
| |
| #define EventRef_Check(x) ((x)->ob_type == &EventRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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; |
| char *inDataPtr__in__; |
| long inDataPtr__len__; |
| int inDataPtr__in_len__; |
| if (!PyArg_ParseTuple(_args, "O&O&s#", |
| PyMac_GetOSType, &inName, |
| PyMac_GetOSType, &inType, |
| &inDataPtr__in__, &inDataPtr__in_len__)) |
| return NULL; |
| inDataPtr__len__ = inDataPtr__in_len__; |
| _err = SetEventParameter(_self->ob_itself, |
| inName, |
| inType, |
| inDataPtr__len__, inDataPtr__in__); |
| 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 PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| UInt32 bufferSize; |
| EventParamName inName; |
| EventParamType inType; |
| OSErr _err; |
| void * buffer; |
| |
| if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType)) |
| return NULL; |
| |
| /* Figure out the size by passing a null buffer to GetEventParameter */ |
| _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL); |
| |
| if (_err != noErr) |
| return PyMac_Error(_err); |
| buffer = PyMem_NEW(char, bufferSize); |
| if (buffer == NULL) |
| return PyErr_NoMemory(); |
| |
| _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer); |
| |
| if (_err != noErr) { |
| PyMem_DEL(buffer); |
| return PyMac_Error(_err); |
| } |
| _res = Py_BuildValue("s#", buffer, bufferSize); |
| PyMem_DEL(buffer); |
| return _res; |
| |
| } |
| |
| static PyMethodDef EventRef_methods[] = { |
| {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1, |
| PyDoc_STR("() -> (EventRef _rv)")}, |
| {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1, |
| PyDoc_STR("() -> (UInt32 _rv)")}, |
| {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1, |
| PyDoc_STR("() -> None")}, |
| {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1, |
| PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")}, |
| {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1, |
| PyDoc_STR("() -> (UInt32 _rv)")}, |
| {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1, |
| PyDoc_STR("() -> (UInt32 _rv)")}, |
| {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1, |
| PyDoc_STR("() -> (double _rv)")}, |
| {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1, |
| PyDoc_STR("(double inTime) -> None")}, |
| {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1, |
| PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")}, |
| {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1, |
| PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")}, |
| {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1, |
| PyDoc_STR("(EventTargetRef inTarget) -> None")}, |
| {"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1, |
| PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventRef_getsetlist NULL |
| |
| |
| #define EventRef_compare NULL |
| |
| #define EventRef_repr NULL |
| |
| #define EventRef_hash NULL |
| #define EventRef_tp_init 0 |
| |
| #define EventRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventRef", /*tp_name*/ |
| sizeof(EventRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventRef_tp_init, /* tp_init */ |
| EventRef_tp_alloc, /* tp_alloc */ |
| EventRef_tp_new, /* tp_new */ |
| EventRef_tp_free, /* tp_free */ |
| }; |
| |
| /* -------------------- End object type EventRef -------------------- */ |
| |
| |
| /* ------------------- Object type EventQueueRef -------------------- */ |
| |
| PyTypeObject EventQueueRef_Type; |
| |
| #define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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, |
| PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")}, |
| {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1, |
| PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, |
| {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1, |
| PyDoc_STR("() -> None")}, |
| {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1, |
| PyDoc_STR("() -> (UInt32 _rv)")}, |
| {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1, |
| PyDoc_STR("(EventRef inEvent) -> None")}, |
| {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1, |
| PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventQueueRef_getsetlist NULL |
| |
| |
| #define EventQueueRef_compare NULL |
| |
| #define EventQueueRef_repr NULL |
| |
| #define EventQueueRef_hash NULL |
| #define EventQueueRef_tp_init 0 |
| |
| #define EventQueueRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventQueueRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventQueueRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventQueueRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventQueueRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventQueueRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventQueueRef", /*tp_name*/ |
| sizeof(EventQueueRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventQueueRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventQueueRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventQueueRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventQueueRef_tp_init, /* tp_init */ |
| EventQueueRef_tp_alloc, /* tp_alloc */ |
| EventQueueRef_tp_new, /* tp_new */ |
| EventQueueRef_tp_free, /* tp_free */ |
| }; |
| |
| /* ----------------- End object type EventQueueRef ------------------ */ |
| |
| |
| /* -------------------- Object type EventLoopRef -------------------- */ |
| |
| PyTypeObject EventLoopRef_Type; |
| |
| #define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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, |
| PyDoc_STR("() -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventLoopRef_getsetlist NULL |
| |
| |
| #define EventLoopRef_compare NULL |
| |
| #define EventLoopRef_repr NULL |
| |
| #define EventLoopRef_hash NULL |
| #define EventLoopRef_tp_init 0 |
| |
| #define EventLoopRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventLoopRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventLoopRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventLoopRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventLoopRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventLoopRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventLoopRef", /*tp_name*/ |
| sizeof(EventLoopRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventLoopRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventLoopRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventLoopRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventLoopRef_tp_init, /* tp_init */ |
| EventLoopRef_tp_alloc, /* tp_alloc */ |
| EventLoopRef_tp_new, /* tp_new */ |
| EventLoopRef_tp_free, /* tp_free */ |
| }; |
| |
| /* ------------------ End object type EventLoopRef ------------------ */ |
| |
| |
| /* ----------------- Object type EventLoopTimerRef ------------------ */ |
| |
| PyTypeObject EventLoopTimerRef_Type; |
| |
| #define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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, |
| PyDoc_STR("() -> None")}, |
| {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1, |
| PyDoc_STR("(double inNextFire) -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventLoopTimerRef_getsetlist NULL |
| |
| |
| #define EventLoopTimerRef_compare NULL |
| |
| #define EventLoopTimerRef_repr NULL |
| |
| #define EventLoopTimerRef_hash NULL |
| #define EventLoopTimerRef_tp_init 0 |
| |
| #define EventLoopTimerRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventLoopTimerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventLoopTimerRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventLoopTimerRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventLoopTimerRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventLoopTimerRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventLoopTimerRef", /*tp_name*/ |
| sizeof(EventLoopTimerRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventLoopTimerRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventLoopTimerRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventLoopTimerRef_tp_init, /* tp_init */ |
| EventLoopTimerRef_tp_alloc, /* tp_alloc */ |
| EventLoopTimerRef_tp_new, /* tp_new */ |
| EventLoopTimerRef_tp_free, /* tp_free */ |
| }; |
| |
| /* --------------- End object type EventLoopTimerRef ---------------- */ |
| |
| |
| /* ------------------ Object type EventHandlerRef ------------------- */ |
| |
| PyTypeObject EventHandlerRef_Type; |
| |
| #define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type || PyObject_TypeCheck((x), &EventHandlerRef_Type)) |
| |
| typedef struct EventHandlerRefObject { |
| PyObject_HEAD |
| EventHandlerRef ob_itself; |
| PyObject *ob_callback; |
| } EventHandlerRefObject; |
| |
| PyObject *EventHandlerRef_New(EventHandlerRef itself) |
| { |
| EventHandlerRefObject *it; |
| it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type); |
| if (it == NULL) return NULL; |
| it->ob_itself = itself; |
| it->ob_callback = NULL; |
| 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) |
| { |
| if (self->ob_itself != NULL) { |
| RemoveEventHandler(self->ob_itself); |
| Py_DECREF(self->ob_callback); |
| } |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 inNumTypes; |
| EventTypeSpec inList; |
| if (_self->ob_itself == NULL) { |
| PyErr_SetString(CarbonEvents_Error, "Handler has been removed"); |
| return NULL; |
| } |
| 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 (_self->ob_itself == NULL) { |
| PyErr_SetString(CarbonEvents_Error, "Handler has been removed"); |
| return NULL; |
| } |
| 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 PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| |
| OSStatus _err; |
| if (_self->ob_itself == NULL) { |
| PyErr_SetString(CarbonEvents_Error, "Handler has been removed"); |
| return NULL; |
| } |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = RemoveEventHandler(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| _self->ob_itself = NULL; |
| Py_DECREF(_self->ob_callback); |
| _self->ob_callback = NULL; |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyMethodDef EventHandlerRef_methods[] = { |
| {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1, |
| PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, |
| {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1, |
| PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, |
| {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1, |
| PyDoc_STR("() -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventHandlerRef_getsetlist NULL |
| |
| |
| #define EventHandlerRef_compare NULL |
| |
| #define EventHandlerRef_repr NULL |
| |
| #define EventHandlerRef_hash NULL |
| #define EventHandlerRef_tp_init 0 |
| |
| #define EventHandlerRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventHandlerRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventHandlerRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventHandlerRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventHandlerRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventHandlerRef", /*tp_name*/ |
| sizeof(EventHandlerRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventHandlerRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventHandlerRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventHandlerRef_tp_init, /* tp_init */ |
| EventHandlerRef_tp_alloc, /* tp_alloc */ |
| EventHandlerRef_tp_new, /* tp_new */ |
| EventHandlerRef_tp_free, /* tp_free */ |
| }; |
| |
| /* ---------------- End object type EventHandlerRef ----------------- */ |
| |
| |
| /* ---------------- Object type EventHandlerCallRef ----------------- */ |
| |
| PyTypeObject EventHandlerCallRef_Type; |
| |
| #define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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, |
| PyDoc_STR("(EventRef inEvent) -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventHandlerCallRef_getsetlist NULL |
| |
| |
| #define EventHandlerCallRef_compare NULL |
| |
| #define EventHandlerCallRef_repr NULL |
| |
| #define EventHandlerCallRef_hash NULL |
| #define EventHandlerCallRef_tp_init 0 |
| |
| #define EventHandlerCallRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventHandlerCallRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventHandlerCallRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventHandlerCallRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventHandlerCallRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventHandlerCallRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventHandlerCallRef", /*tp_name*/ |
| sizeof(EventHandlerCallRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventHandlerCallRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventHandlerCallRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventHandlerCallRef_tp_init, /* tp_init */ |
| EventHandlerCallRef_tp_alloc, /* tp_alloc */ |
| EventHandlerCallRef_tp_new, /* tp_new */ |
| EventHandlerCallRef_tp_free, /* tp_free */ |
| }; |
| |
| /* -------------- End object type EventHandlerCallRef --------------- */ |
| |
| |
| /* ------------------- Object type EventTargetRef ------------------- */ |
| |
| PyTypeObject EventTargetRef_Type; |
| |
| #define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)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; |
| |
| if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback)) |
| return NULL; |
| |
| _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef); |
| if (_err != noErr) return PyMac_Error(_err); |
| |
| _res = EventHandlerRef_New(outRef); |
| if (_res != NULL) { |
| ((EventHandlerRefObject*)_res)->ob_callback = callback; |
| Py_INCREF(callback); |
| } |
| return _res; |
| } |
| |
| static PyMethodDef EventTargetRef_methods[] = { |
| {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1, |
| PyDoc_STR("() -> None")}, |
| {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1, |
| PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventTargetRef_getsetlist NULL |
| |
| |
| #define EventTargetRef_compare NULL |
| |
| #define EventTargetRef_repr NULL |
| |
| #define EventTargetRef_hash NULL |
| #define EventTargetRef_tp_init 0 |
| |
| #define EventTargetRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventTargetRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventTargetRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventTargetRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventTargetRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventTargetRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventTargetRef", /*tp_name*/ |
| sizeof(EventTargetRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventTargetRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventTargetRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventTargetRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventTargetRef_tp_init, /* tp_init */ |
| EventTargetRef_tp_alloc, /* tp_alloc */ |
| EventTargetRef_tp_new, /* tp_new */ |
| EventTargetRef_tp_free, /* tp_free */ |
| }; |
| |
| /* ----------------- End object type EventTargetRef ----------------- */ |
| |
| |
| /* ------------------- Object type EventHotKeyRef ------------------- */ |
| |
| PyTypeObject EventHotKeyRef_Type; |
| |
| #define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type || PyObject_TypeCheck((x), &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 */ |
| self->ob_type->tp_free((PyObject *)self); |
| } |
| |
| static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _err = UnregisterEventHotKey(_self->ob_itself); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyMethodDef EventHotKeyRef_methods[] = { |
| {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1, |
| PyDoc_STR("() -> None")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #define EventHotKeyRef_getsetlist NULL |
| |
| |
| #define EventHotKeyRef_compare NULL |
| |
| #define EventHotKeyRef_repr NULL |
| |
| #define EventHotKeyRef_hash NULL |
| #define EventHotKeyRef_tp_init 0 |
| |
| #define EventHotKeyRef_tp_alloc PyType_GenericAlloc |
| |
| static PyObject *EventHotKeyRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) |
| { |
| PyObject *_self; |
| EventHotKeyRef itself; |
| char *kw[] = {"itself", 0}; |
| |
| if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL; |
| if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL; |
| ((EventHotKeyRefObject *)_self)->ob_itself = itself; |
| return _self; |
| } |
| |
| #define EventHotKeyRef_tp_free PyObject_Del |
| |
| |
| PyTypeObject EventHotKeyRef_Type = { |
| PyObject_HEAD_INIT(NULL) |
| 0, /*ob_size*/ |
| "_CarbonEvt.EventHotKeyRef", /*tp_name*/ |
| sizeof(EventHotKeyRefObject), /*tp_basicsize*/ |
| 0, /*tp_itemsize*/ |
| /* methods */ |
| (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/ |
| 0, /*tp_print*/ |
| (getattrfunc)0, /*tp_getattr*/ |
| (setattrfunc)0, /*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*/ |
| 0, /*tp_call*/ |
| 0, /*tp_str*/ |
| PyObject_GenericGetAttr, /*tp_getattro*/ |
| PyObject_GenericSetAttr, /*tp_setattro */ |
| 0, /*tp_as_buffer*/ |
| Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ |
| 0, /*tp_doc*/ |
| 0, /*tp_traverse*/ |
| 0, /*tp_clear*/ |
| 0, /*tp_richcompare*/ |
| 0, /*tp_weaklistoffset*/ |
| 0, /*tp_iter*/ |
| 0, /*tp_iternext*/ |
| EventHotKeyRef_methods, /* tp_methods */ |
| 0, /*tp_members*/ |
| EventHotKeyRef_getsetlist, /*tp_getset*/ |
| 0, /*tp_base*/ |
| 0, /*tp_dict*/ |
| 0, /*tp_descr_get*/ |
| 0, /*tp_descr_set*/ |
| 0, /*tp_dictoffset*/ |
| EventHotKeyRef_tp_init, /* tp_init */ |
| EventHotKeyRef_tp_alloc, /* tp_alloc */ |
| EventHotKeyRef_tp_new, /* tp_new */ |
| EventHotKeyRef_tp_free, /* tp_free */ |
| }; |
| |
| /* ----------------- 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_TrackMouseLocation(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| GrafPtr inPort; |
| Point outPt; |
| UInt16 outResult; |
| if (!PyArg_ParseTuple(_args, "O&", |
| GrafObj_Convert, &inPort)) |
| return NULL; |
| _err = TrackMouseLocation(inPort, |
| &outPt, |
| &outResult); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&H", |
| PyMac_BuildPoint, outPt, |
| outResult); |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_TrackMouseLocationWithOptions(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| GrafPtr inPort; |
| OptionBits inOptions; |
| double inTimeout; |
| Point outPt; |
| UInt32 outModifiers; |
| UInt16 outResult; |
| if (!PyArg_ParseTuple(_args, "O&ld", |
| GrafObj_Convert, &inPort, |
| &inOptions, |
| &inTimeout)) |
| return NULL; |
| _err = TrackMouseLocationWithOptions(inPort, |
| inOptions, |
| inTimeout, |
| &outPt, |
| &outModifiers, |
| &outResult); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&lH", |
| PyMac_BuildPoint, outPt, |
| outModifiers, |
| outResult); |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_TrackMouseRegion(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| GrafPtr inPort; |
| RgnHandle inRegion; |
| Boolean ioWasInRgn; |
| UInt16 outResult; |
| if (!PyArg_ParseTuple(_args, "O&O&b", |
| GrafObj_Convert, &inPort, |
| ResObj_Convert, &inRegion, |
| &ioWasInRgn)) |
| return NULL; |
| _err = TrackMouseRegion(inPort, |
| inRegion, |
| &ioWasInRgn, |
| &outResult); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("bH", |
| ioWasInRgn, |
| outResult); |
| 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_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| Boolean _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = IsMouseCoalescingEnabled(); |
| _res = Py_BuildValue("b", |
| _rv); |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| Boolean inNewState; |
| Boolean outOldState; |
| if (!PyArg_ParseTuple(_args, "b", |
| &inNewState)) |
| return NULL; |
| _err = SetMouseCoalescingEnabled(inNewState, |
| &outOldState); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("b", |
| outOldState); |
| 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_GetEventDispatcherTarget(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| EventTargetRef _rv; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| _rv = GetEventDispatcherTarget(); |
| _res = Py_BuildValue("O&", |
| EventTargetRef_New, _rv); |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| if (!PyArg_ParseTuple(_args, "")) |
| return NULL; |
| RunApplicationEventLoop(); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| 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_RunAppModalLoopForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = RunAppModalLoopForWindow(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_QuitAppModalLoopForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = QuitAppModalLoopForWindow(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_BeginAppModalStateForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = BeginAppModalStateForWindow(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| Py_INCREF(Py_None); |
| _res = Py_None; |
| return _res; |
| } |
| |
| static PyObject *CarbonEvents_EndAppModalStateForWindow(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| WindowPtr inWindow; |
| if (!PyArg_ParseTuple(_args, "O&", |
| WinObj_Convert, &inWindow)) |
| return NULL; |
| _err = EndAppModalStateForWindow(inWindow); |
| if (_err != noErr) return PyMac_Error(_err); |
| 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_RegisterEventHotKey(PyObject *_self, PyObject *_args) |
| { |
| PyObject *_res = NULL; |
| OSStatus _err; |
| UInt32 inHotKeyCode; |
| UInt32 inHotKeyModifiers; |
| EventHotKeyID inHotKeyID; |
| EventTargetRef inTarget; |
| OptionBits inOptions; |
| EventHotKeyRef outRef; |
| if (!PyArg_ParseTuple(_args, "llO&O&l", |
| &inHotKeyCode, |
| &inHotKeyModifiers, |
| EventHotKeyID_Convert, &inHotKeyID, |
| EventTargetRef_Convert, &inTarget, |
| &inOptions)) |
| return NULL; |
| _err = RegisterEventHotKey(inHotKeyCode, |
| inHotKeyModifiers, |
| inHotKeyID, |
| inTarget, |
| inOptions, |
| &outRef); |
| if (_err != noErr) return PyMac_Error(_err); |
| _res = Py_BuildValue("O&", |
| EventHotKeyRef_New, outRef); |
| return _res; |
| } |
| |
| static PyMethodDef CarbonEvents_methods[] = { |
| {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1, |
| PyDoc_STR("() -> (EventLoopRef _rv)")}, |
| {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1, |
| PyDoc_STR("() -> (EventLoopRef _rv)")}, |
| {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1, |
| PyDoc_STR("(double inTimeout) -> None")}, |
| {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1, |
| PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")}, |
| {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1, |
| PyDoc_STR("() -> (EventQueueRef _rv)")}, |
| {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1, |
| PyDoc_STR("() -> (EventQueueRef _rv)")}, |
| {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1, |
| PyDoc_STR("() -> (double _rv)")}, |
| {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1, |
| PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")}, |
| {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1, |
| PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")}, |
| {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1, |
| PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")}, |
| {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1, |
| PyDoc_STR("() -> (double _rv)")}, |
| {"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1, |
| PyDoc_STR("() -> (Boolean _rv)")}, |
| {"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1, |
| PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")}, |
| {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")}, |
| {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1, |
| PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")}, |
| {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1, |
| PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")}, |
| {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1, |
| PyDoc_STR("() -> (EventTargetRef _rv)")}, |
| {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1, |
| PyDoc_STR("() -> (EventTargetRef _rv)")}, |
| {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1, |
| PyDoc_STR("() -> (EventTargetRef _rv)")}, |
| {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1, |
| PyDoc_STR("() -> None")}, |
| {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1, |
| PyDoc_STR("() -> None")}, |
| {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> None")}, |
| {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1, |
| PyDoc_STR("() -> (WindowPtr _rv)")}, |
| {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1, |
| PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")}, |
| {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1, |
| PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")}, |
| {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, |
| {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1, |
| PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, |
| {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1, |
| PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")}, |
| {NULL, NULL, 0} |
| }; |
| |
| #else /* __LP64__ */ |
| |
| static PyMethodDef CarbonEvents_methods[] = { |
| {NULL, NULL, 0} |
| }; |
| |
| #endif /* __LP64__ */ |
| |
| |
| |
| void init_CarbonEvt(void) |
| { |
| PyObject *m; |
| #ifndef __LP64__ |
| PyObject *d; |
| #endif /* !__LP64__ */ |
| |
| |
| m = Py_InitModule("_CarbonEvt", CarbonEvents_methods); |
| |
| #ifndef __LP64__ |
| myEventHandlerUPP = NewEventHandlerUPP(myEventHandler); |
| 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; |
| if (PyType_Ready(&EventRef_Type) < 0) return; |
| Py_INCREF(&EventRef_Type); |
| PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventRef_Type); |
| PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type); |
| EventQueueRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventQueueRef_Type) < 0) return; |
| Py_INCREF(&EventQueueRef_Type); |
| PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventQueueRef_Type); |
| PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type); |
| EventLoopRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventLoopRef_Type) < 0) return; |
| Py_INCREF(&EventLoopRef_Type); |
| PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventLoopRef_Type); |
| PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type); |
| EventLoopTimerRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return; |
| Py_INCREF(&EventLoopTimerRef_Type); |
| PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventLoopTimerRef_Type); |
| PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type); |
| EventHandlerRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventHandlerRef_Type) < 0) return; |
| Py_INCREF(&EventHandlerRef_Type); |
| PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventHandlerRef_Type); |
| PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type); |
| EventHandlerCallRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return; |
| Py_INCREF(&EventHandlerCallRef_Type); |
| PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventHandlerCallRef_Type); |
| PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type); |
| EventTargetRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventTargetRef_Type) < 0) return; |
| Py_INCREF(&EventTargetRef_Type); |
| PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventTargetRef_Type); |
| PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type); |
| EventHotKeyRef_Type.ob_type = &PyType_Type; |
| if (PyType_Ready(&EventHotKeyRef_Type) < 0) return; |
| Py_INCREF(&EventHotKeyRef_Type); |
| PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type); |
| /* Backward-compatible name */ |
| Py_INCREF(&EventHotKeyRef_Type); |
| PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type); |
| #endif /* !__LP64__ */ |
| } |
| |
| /* ===================== End module _CarbonEvt ====================== */ |
| |
