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