Staging
v0.5.1
v0.5.1
https://github.com/python/cpython
Tip revision: f5069b2f62ee8d7beb6b56d0ce38a5b1e8b01f8d authored by cvs2svn on 14 October 2002, 20:11:50 UTC
This commit was manufactured by cvs2svn to create tag 'r222'.
This commit was manufactured by cvs2svn to create tag 'r222'.
Tip revision: f5069b2
_CarbonEvtmodule.c
/* ======================= Module _CarbonEvt ======================== */
#include "Python.h"
#ifdef WITHOUT_FRAMEWORKS
#include <CarbonEvents.h>
#else
#include <Carbon/Carbon.h>
#endif
#include "macglue.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; \
}} while(0)
#define USE_MAC_MP_MULTITHREADING 0
#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_Parse(v, "(O&l)",
PyMac_GetOSType, &(out->eventClass),
&(out->eventKind)))
return 1;
return NULL;
}
/********** 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 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 *******/
/******** myEventHandler ***********/
static EventHandlerUPP myEventHandlerUPP;
static pascal OSStatus
myEventHandler(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);
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);
}
#if USE_MAC_MP_MULTITHREADING
_save = PyEval_SaveThread();
MPExitCriticalRegion(reentrantLock);
#endif /* USE_MAC_MP_MULTITHREADING */
return status;
}
/******** end myEventHandler ***********/
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;
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,
"() -> (EventRef _rv)"},
{"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
"() -> (UInt32 _rv)"},
{"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
"() -> None"},
{"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
"(OSType inName, OSType inType, Buffer 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"},
{"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
"(EventParamName eventName, EventParamType eventType) -> (String eventParamData)"},
{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(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) 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(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) 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(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) 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(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) 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;
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);
}
PyMem_DEL(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,
"(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
{"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
"(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
{"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
"() -> 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(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) 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(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) 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;
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,
"() -> None"},
{"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
"(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(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) 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 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,
"() -> None"},
{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(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) 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_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_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_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 PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
#if USE_MAC_MP_MULTITHREADING
if (MPCreateCriticalRegion(&reentrantLock) != noErr) {
PySys_WriteStderr("lock failure\n");
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)"},
{"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
"(GrafPtr inPort) -> (Point outPt, UInt16 outResult)"},
{"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
"(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)"},
{"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
"(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)"},
{"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)"},
{"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
"() -> (EventTargetRef _rv)"},
{"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
"() -> None"},
{"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
"(WindowPtr inWindow) -> None"},
{"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
"(WindowPtr inWindow) -> None"},
{"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
"(WindowPtr inWindow) -> None"},
{"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
"(WindowPtr inWindow) -> 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)"},
{"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
"(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)"},
{"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
"() -> ()"},
{NULL, NULL, 0}
};
void init_CarbonEvt(void)
{
PyObject *m;
PyObject *d;
PyMac_PRECHECK(NewEventHandlerUPP); /* This can fail if CarbonLib is too old */
myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
m = Py_InitModule("_CarbonEvt", 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 _CarbonEvt ====================== */
