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