1 

     2 /* ======================= Module _CarbonEvt ======================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 #include "pymactoolbox.h"

     9 

    10 /* Macro to test whether a weak-loaded CFM function exists */

    11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    12         PyErr_SetString(PyExc_NotImplementedError, \

    13         "Not available in this shared library/OS version"); \

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #include <Carbon/Carbon.h>

    19 

    20 extern int CFStringRef_New(CFStringRef *);

    21 

    22 extern int CFStringRef_Convert(PyObject *, CFStringRef *);

    23 extern int CFBundleRef_Convert(PyObject *, CFBundleRef *);

    24 

    25 int EventTargetRef_Convert(PyObject *, EventTargetRef *);

    26 PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself);

    27 PyObject *EventRef_New(EventRef itself);

    28 

    29 /********** EventTypeSpec *******/

    30 static PyObject*

    31 EventTypeSpec_New(EventTypeSpec *in)

    32 {

    33         return Py_BuildValue("ll", in->eventClass, in->eventKind);

    34 }

    35 

    36 static int

    37 EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)

    38 {

    39         if (PyArg_Parse(v, "(O&l)",

    40                         PyMac_GetOSType, &(out->eventClass),

    41                         &(out->eventKind)))

    42                 return 1;

    43         return 0;

    44 }

    45 

    46 /********** end EventTypeSpec *******/

    47 

    48 /********** HIPoint *******/

    49 

    50 #if 0  /* XXX doesn't compile */

    51 static PyObject*

    52 HIPoint_New(HIPoint *in)

    53 {

    54         return Py_BuildValue("ff", in->x, in->y);

    55 }

    56 

    57 static int

    58 HIPoint_Convert(PyObject *v, HIPoint *out)

    59 {

    60         if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))

    61                 return 1;

    62         return NULL;

    63 }

    64 #endif

    65 

    66 /********** end HIPoint *******/

    67 

    68 /********** EventHotKeyID *******/

    69 

    70 static PyObject*

    71 EventHotKeyID_New(EventHotKeyID *in)

    72 {

    73         return Py_BuildValue("ll", in->signature, in->id);

    74 }

    75 

    76 static int

    77 EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out)

    78 {

    79         if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))

    80                 return 1;

    81         return 0;

    82 }

    83 

    84 /********** end EventHotKeyID *******/

    85 

    86 /******** myEventHandler ***********/

    87 

    88 static EventHandlerUPP myEventHandlerUPP;

    89 

    90 static pascal OSStatus

    91 myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) {

    92         PyObject *retValue;

    93         int status;

    94 

    95         retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",

    96                                          EventHandlerCallRef_New, handlerRef,

    97                                          EventRef_New, event);

    98         if (retValue == NULL) {

    99                 PySys_WriteStderr("Error in event handler callback:\n");

   100                 PyErr_Print();  /* this also clears the error */

   101                 status = noErr; /* complain? how? */

   102         } else {

   103                 if (retValue == Py_None)

   104                         status = noErr;

   105                 else if (PyInt_Check(retValue)) {

   106                         status = PyInt_AsLong(retValue);

   107                 } else

   108                         status = noErr; /* wrong object type, complain? */

   109                 Py_DECREF(retValue);

   110         }

   111 

   112         return status;

   113 }

   114 

   115 /******** end myEventHandler ***********/

   116 

   117 

   118 static PyObject *CarbonEvents_Error;

   119 

   120 /* ---------------------- Object type EventRef ---------------------- */

   121 

   122 PyTypeObject EventRef_Type;

   123 

   124 #define EventRef_Check(x) ((x)->ob_type == &EventRef_Type || PyObject_TypeCheck((x), &EventRef_Type))

   125 

   126 typedef struct EventRefObject {

   127 	PyObject_HEAD

   128 	EventRef ob_itself;

   129 } EventRefObject;

   130 

   131 PyObject *EventRef_New(EventRef itself)

   132 {

   133 	EventRefObject *it;

   134 	it = PyObject_NEW(EventRefObject, &EventRef_Type);

   135 	if (it == NULL) return NULL;

   136 	it->ob_itself = itself;

   137 	return (PyObject *)it;

   138 }

   139 

   140 int EventRef_Convert(PyObject *v, EventRef *p_itself)

   141 {

   142 	if (!EventRef_Check(v))

   143 	{

   144 		PyErr_SetString(PyExc_TypeError, "EventRef required");

   145 		return 0;

   146 	}

   147 	*p_itself = ((EventRefObject *)v)->ob_itself;

   148 	return 1;

   149 }

   150 

   151 static void EventRef_dealloc(EventRefObject *self)

   152 {

   153 	/* Cleanup of self->ob_itself goes here */

   154 	self->ob_type->tp_free((PyObject *)self);

   155 }

   156 

   157 static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args)

   158 {

   159 	PyObject *_res = NULL;

   160 	EventRef _rv;

   161 	if (!PyArg_ParseTuple(_args, ""))

   162 		return NULL;

   163 	_rv = RetainEvent(_self->ob_itself);

   164 	_res = Py_BuildValue("O&",

   165 	                     EventRef_New, _rv);

   166 	return _res;

   167 }

   168 

   169 static PyObject *EventRef_GetEventRetainCount(EventRefObject *_self, PyObject *_args)

   170 {

   171 	PyObject *_res = NULL;

   172 	UInt32 _rv;

   173 	if (!PyArg_ParseTuple(_args, ""))

   174 		return NULL;

   175 	_rv = GetEventRetainCount(_self->ob_itself);

   176 	_res = Py_BuildValue("l",

   177 	                     _rv);

   178 	return _res;

   179 }

   180 

   181 static PyObject *EventRef_ReleaseEvent(EventRefObject *_self, PyObject *_args)

   182 {

   183 	PyObject *_res = NULL;

   184 	if (!PyArg_ParseTuple(_args, ""))

   185 		return NULL;

   186 	ReleaseEvent(_self->ob_itself);

   187 	Py_INCREF(Py_None);

   188 	_res = Py_None;

   189 	return _res;

   190 }

   191 

   192 static PyObject *EventRef_SetEventParameter(EventRefObject *_self, PyObject *_args)

   193 {

   194 	PyObject *_res = NULL;

   195 	OSStatus _err;

   196 	OSType inName;

   197 	OSType inType;

   198 	char *inDataPtr__in__;

   199 	long inDataPtr__len__;

   200 	int inDataPtr__in_len__;

   201 	if (!PyArg_ParseTuple(_args, "O&O&s#",

   202 	                      PyMac_GetOSType, &inName,

   203 	                      PyMac_GetOSType, &inType,

   204 	                      &inDataPtr__in__, &inDataPtr__in_len__))

   205 		return NULL;

   206 	inDataPtr__len__ = inDataPtr__in_len__;

   207 	_err = SetEventParameter(_self->ob_itself,

   208 	                         inName,

   209 	                         inType,

   210 	                         inDataPtr__len__, inDataPtr__in__);

   211 	if (_err != noErr) return PyMac_Error(_err);

   212 	Py_INCREF(Py_None);

   213 	_res = Py_None;

   214 	return _res;

   215 }

   216 

   217 static PyObject *EventRef_GetEventClass(EventRefObject *_self, PyObject *_args)

   218 {

   219 	PyObject *_res = NULL;

   220 	UInt32 _rv;

   221 	if (!PyArg_ParseTuple(_args, ""))

   222 		return NULL;

   223 	_rv = GetEventClass(_self->ob_itself);

   224 	_res = Py_BuildValue("l",

   225 	                     _rv);

   226 	return _res;

   227 }

   228 

   229 static PyObject *EventRef_GetEventKind(EventRefObject *_self, PyObject *_args)

   230 {

   231 	PyObject *_res = NULL;

   232 	UInt32 _rv;

   233 	if (!PyArg_ParseTuple(_args, ""))

   234 		return NULL;

   235 	_rv = GetEventKind(_self->ob_itself);

   236 	_res = Py_BuildValue("l",

   237 	                     _rv);

   238 	return _res;

   239 }

   240 

   241 static PyObject *EventRef_GetEventTime(EventRefObject *_self, PyObject *_args)

   242 {

   243 	PyObject *_res = NULL;

   244 	double _rv;

   245 	if (!PyArg_ParseTuple(_args, ""))

   246 		return NULL;

   247 	_rv = GetEventTime(_self->ob_itself);

   248 	_res = Py_BuildValue("d",

   249 	                     _rv);

   250 	return _res;

   251 }

   252 

   253 static PyObject *EventRef_SetEventTime(EventRefObject *_self, PyObject *_args)

   254 {

   255 	PyObject *_res = NULL;

   256 	OSStatus _err;

   257 	double inTime;

   258 	if (!PyArg_ParseTuple(_args, "d",

   259 	                      &inTime))

   260 		return NULL;

   261 	_err = SetEventTime(_self->ob_itself,

   262 	                    inTime);

   263 	if (_err != noErr) return PyMac_Error(_err);

   264 	Py_INCREF(Py_None);

   265 	_res = Py_None;

   266 	return _res;

   267 }

   268 

   269 static PyObject *EventRef_IsUserCancelEventRef(EventRefObject *_self, PyObject *_args)

   270 {

   271 	PyObject *_res = NULL;

   272 	Boolean _rv;

   273 	if (!PyArg_ParseTuple(_args, ""))

   274 		return NULL;

   275 	_rv = IsUserCancelEventRef(_self->ob_itself);

   276 	_res = Py_BuildValue("b",

   277 	                     _rv);

   278 	return _res;

   279 }

   280 

   281 static PyObject *EventRef_ConvertEventRefToEventRecord(EventRefObject *_self, PyObject *_args)

   282 {

   283 	PyObject *_res = NULL;

   284 	Boolean _rv;

   285 	EventRecord outEvent;

   286 	if (!PyArg_ParseTuple(_args, ""))

   287 		return NULL;

   288 	_rv = ConvertEventRefToEventRecord(_self->ob_itself,

   289 	                                   &outEvent);

   290 	_res = Py_BuildValue("bO&",

   291 	                     _rv,

   292 	                     PyMac_BuildEventRecord, &outEvent);

   293 	return _res;

   294 }

   295 

   296 static PyObject *EventRef_IsEventInMask(EventRefObject *_self, PyObject *_args)

   297 {

   298 	PyObject *_res = NULL;

   299 	Boolean _rv;

   300 	UInt16 inMask;

   301 	if (!PyArg_ParseTuple(_args, "H",

   302 	                      &inMask))

   303 		return NULL;

   304 	_rv = IsEventInMask(_self->ob_itself,

   305 	                    inMask);

   306 	_res = Py_BuildValue("b",

   307 	                     _rv);

   308 	return _res;

   309 }

   310 

   311 static PyObject *EventRef_SendEventToEventTarget(EventRefObject *_self, PyObject *_args)

   312 {

   313 	PyObject *_res = NULL;

   314 	OSStatus _err;

   315 	EventTargetRef inTarget;

   316 	if (!PyArg_ParseTuple(_args, "O&",

   317 	                      EventTargetRef_Convert, &inTarget))

   318 		return NULL;

   319 	_err = SendEventToEventTarget(_self->ob_itself,

   320 	                              inTarget);

   321 	if (_err != noErr) return PyMac_Error(_err);

   322 	Py_INCREF(Py_None);

   323 	_res = Py_None;

   324 	return _res;

   325 }

   326 

   327 static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_args)

   328 {

   329 	PyObject *_res = NULL;

   330 

   331 	UInt32 bufferSize;

   332 	EventParamName inName;

   333 	EventParamType inType;

   334 	OSErr _err;

   335 	void * buffer;

   336 

   337 	if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))

   338 	      return NULL;

   339 

   340 	/* Figure out the size by passing a null buffer to GetEventParameter */

   341 	_err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);

   342 

   343 	if (_err != noErr)

   344 	      return PyMac_Error(_err);

   345 	buffer = PyMem_NEW(char, bufferSize);

   346 	if (buffer == NULL)

   347 	      return PyErr_NoMemory();

   348 

   349 	_err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);

   350 

   351 	if (_err != noErr) {

   352 	      PyMem_DEL(buffer);

   353 	      return PyMac_Error(_err);

   354 	}

   355 	_res = Py_BuildValue("s#", buffer, bufferSize);

   356 	PyMem_DEL(buffer);

   357 	return _res;

   358 

   359 }

   360 

   361 static PyMethodDef EventRef_methods[] = {

   362 	{"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,

   363 	 PyDoc_STR("() -> (EventRef _rv)")},

   364 	{"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,

   365 	 PyDoc_STR("() -> (UInt32 _rv)")},

   366 	{"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,

   367 	 PyDoc_STR("() -> None")},

   368 	{"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,

   369 	 PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},

   370 	{"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,

   371 	 PyDoc_STR("() -> (UInt32 _rv)")},

   372 	{"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,

   373 	 PyDoc_STR("() -> (UInt32 _rv)")},

   374 	{"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,

   375 	 PyDoc_STR("() -> (double _rv)")},

   376 	{"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,

   377 	 PyDoc_STR("(double inTime) -> None")},

   378 	{"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,

   379 	 PyDoc_STR("() -> (Boolean _rv)")},

   380 	{"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,

   381 	 PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},

   382 	{"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,

   383 	 PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},

   384 	{"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,

   385 	 PyDoc_STR("(EventTargetRef inTarget) -> None")},

   386 	{"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,

   387 	 PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},

   388 	{NULL, NULL, 0}

   389 };

   390 

   391 #define EventRef_getsetlist NULL

   392 

   393 

   394 #define EventRef_compare NULL

   395 

   396 #define EventRef_repr NULL

   397 

   398 #define EventRef_hash NULL

   399 #define EventRef_tp_init 0

   400 

   401 #define EventRef_tp_alloc PyType_GenericAlloc

   402 

   403 static PyObject *EventRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   404 {

   405 	PyObject *_self;

   406 	EventRef itself;

   407 	char *kw[] = {"itself", 0};

   408 

   409 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL;

   410 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   411 	((EventRefObject *)_self)->ob_itself = itself;

   412 	return _self;

   413 }

   414 

   415 #define EventRef_tp_free PyObject_Del

   416 

   417 

   418 PyTypeObject EventRef_Type = {

   419 	PyObject_HEAD_INIT(NULL)

   420 	0, /*ob_size*/

   421 	"_CarbonEvt.EventRef", /*tp_name*/

   422 	sizeof(EventRefObject), /*tp_basicsize*/

   423 	0, /*tp_itemsize*/

   424 	/* methods */

   425 	(destructor) EventRef_dealloc, /*tp_dealloc*/

   426 	0, /*tp_print*/

   427 	(getattrfunc)0, /*tp_getattr*/

   428 	(setattrfunc)0, /*tp_setattr*/

   429 	(cmpfunc) EventRef_compare, /*tp_compare*/

   430 	(reprfunc) EventRef_repr, /*tp_repr*/

   431 	(PyNumberMethods *)0, /* tp_as_number */

   432 	(PySequenceMethods *)0, /* tp_as_sequence */

   433 	(PyMappingMethods *)0, /* tp_as_mapping */

   434 	(hashfunc) EventRef_hash, /*tp_hash*/

   435 	0, /*tp_call*/

   436 	0, /*tp_str*/

   437 	PyObject_GenericGetAttr, /*tp_getattro*/

   438 	PyObject_GenericSetAttr, /*tp_setattro */

   439 	0, /*tp_as_buffer*/

   440 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   441 	0, /*tp_doc*/

   442 	0, /*tp_traverse*/

   443 	0, /*tp_clear*/

   444 	0, /*tp_richcompare*/

   445 	0, /*tp_weaklistoffset*/

   446 	0, /*tp_iter*/

   447 	0, /*tp_iternext*/

   448 	EventRef_methods, /* tp_methods */

   449 	0, /*tp_members*/

   450 	EventRef_getsetlist, /*tp_getset*/

   451 	0, /*tp_base*/

   452 	0, /*tp_dict*/

   453 	0, /*tp_descr_get*/

   454 	0, /*tp_descr_set*/

   455 	0, /*tp_dictoffset*/

   456 	EventRef_tp_init, /* tp_init */

   457 	EventRef_tp_alloc, /* tp_alloc */

   458 	EventRef_tp_new, /* tp_new */

   459 	EventRef_tp_free, /* tp_free */

   460 };

   461 

   462 /* -------------------- End object type EventRef -------------------- */

   463 

   464 

   465 /* ------------------- Object type EventQueueRef -------------------- */

   466 

   467 PyTypeObject EventQueueRef_Type;

   468 

   469 #define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type || PyObject_TypeCheck((x), &EventQueueRef_Type))

   470 

   471 typedef struct EventQueueRefObject {

   472 	PyObject_HEAD

   473 	EventQueueRef ob_itself;

   474 } EventQueueRefObject;

   475 

   476 PyObject *EventQueueRef_New(EventQueueRef itself)

   477 {

   478 	EventQueueRefObject *it;

   479 	it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type);

   480 	if (it == NULL) return NULL;

   481 	it->ob_itself = itself;

   482 	return (PyObject *)it;

   483 }

   484 

   485 int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself)

   486 {

   487 	if (!EventQueueRef_Check(v))

   488 	{

   489 		PyErr_SetString(PyExc_TypeError, "EventQueueRef required");

   490 		return 0;

   491 	}

   492 	*p_itself = ((EventQueueRefObject *)v)->ob_itself;

   493 	return 1;

   494 }

   495 

   496 static void EventQueueRef_dealloc(EventQueueRefObject *self)

   497 {

   498 	/* Cleanup of self->ob_itself goes here */

   499 	self->ob_type->tp_free((PyObject *)self);

   500 }

   501 

   502 static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args)

   503 {

   504 	PyObject *_res = NULL;

   505 	OSStatus _err;

   506 	EventRef inEvent;

   507 	SInt16 inPriority;

   508 	if (!PyArg_ParseTuple(_args, "O&h",

   509 	                      EventRef_Convert, &inEvent,

   510 	                      &inPriority))

   511 		return NULL;

   512 	_err = PostEventToQueue(_self->ob_itself,

   513 	                        inEvent,

   514 	                        inPriority);

   515 	if (_err != noErr) return PyMac_Error(_err);

   516 	Py_INCREF(Py_None);

   517 	_res = Py_None;

   518 	return _res;

   519 }

   520 

   521 static PyObject *EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject *_self, PyObject *_args)

   522 {

   523 	PyObject *_res = NULL;

   524 	OSStatus _err;

   525 	UInt32 inNumTypes;

   526 	EventTypeSpec inList;

   527 	if (!PyArg_ParseTuple(_args, "lO&",

   528 	                      &inNumTypes,

   529 	                      EventTypeSpec_Convert, &inList))

   530 		return NULL;

   531 	_err = FlushEventsMatchingListFromQueue(_self->ob_itself,

   532 	                                        inNumTypes,

   533 	                                        &inList);

   534 	if (_err != noErr) return PyMac_Error(_err);

   535 	Py_INCREF(Py_None);

   536 	_res = Py_None;

   537 	return _res;

   538 }

   539 

   540 static PyObject *EventQueueRef_FlushEventQueue(EventQueueRefObject *_self, PyObject *_args)

   541 {

   542 	PyObject *_res = NULL;

   543 	OSStatus _err;

   544 	if (!PyArg_ParseTuple(_args, ""))

   545 		return NULL;

   546 	_err = FlushEventQueue(_self->ob_itself);

   547 	if (_err != noErr) return PyMac_Error(_err);

   548 	Py_INCREF(Py_None);

   549 	_res = Py_None;

   550 	return _res;

   551 }

   552 

   553 static PyObject *EventQueueRef_GetNumEventsInQueue(EventQueueRefObject *_self, PyObject *_args)

   554 {

   555 	PyObject *_res = NULL;

   556 	UInt32 _rv;

   557 	if (!PyArg_ParseTuple(_args, ""))

   558 		return NULL;

   559 	_rv = GetNumEventsInQueue(_self->ob_itself);

   560 	_res = Py_BuildValue("l",

   561 	                     _rv);

   562 	return _res;

   563 }

   564 

   565 static PyObject *EventQueueRef_RemoveEventFromQueue(EventQueueRefObject *_self, PyObject *_args)

   566 {

   567 	PyObject *_res = NULL;

   568 	OSStatus _err;

   569 	EventRef inEvent;

   570 	if (!PyArg_ParseTuple(_args, "O&",

   571 	                      EventRef_Convert, &inEvent))

   572 		return NULL;

   573 	_err = RemoveEventFromQueue(_self->ob_itself,

   574 	                            inEvent);

   575 	if (_err != noErr) return PyMac_Error(_err);

   576 	Py_INCREF(Py_None);

   577 	_res = Py_None;

   578 	return _res;

   579 }

   580 

   581 static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObject *_args)

   582 {

   583 	PyObject *_res = NULL;

   584 	Boolean _rv;

   585 	EventRef inEvent;

   586 	if (!PyArg_ParseTuple(_args, "O&",

   587 	                      EventRef_Convert, &inEvent))

   588 		return NULL;

   589 	_rv = IsEventInQueue(_self->ob_itself,

   590 	                     inEvent);

   591 	_res = Py_BuildValue("b",

   592 	                     _rv);

   593 	return _res;

   594 }

   595 

   596 static PyMethodDef EventQueueRef_methods[] = {

   597 	{"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,

   598 	 PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},

   599 	{"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,

   600 	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},

   601 	{"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,

   602 	 PyDoc_STR("() -> None")},

   603 	{"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,

   604 	 PyDoc_STR("() -> (UInt32 _rv)")},

   605 	{"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,

   606 	 PyDoc_STR("(EventRef inEvent) -> None")},

   607 	{"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,

   608 	 PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},

   609 	{NULL, NULL, 0}

   610 };

   611 

   612 #define EventQueueRef_getsetlist NULL

   613 

   614 

   615 #define EventQueueRef_compare NULL

   616 

   617 #define EventQueueRef_repr NULL

   618 

   619 #define EventQueueRef_hash NULL

   620 #define EventQueueRef_tp_init 0

   621 

   622 #define EventQueueRef_tp_alloc PyType_GenericAlloc

   623 

   624 static PyObject *EventQueueRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   625 {

   626 	PyObject *_self;

   627 	EventQueueRef itself;

   628 	char *kw[] = {"itself", 0};

   629 

   630 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL;

   631 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   632 	((EventQueueRefObject *)_self)->ob_itself = itself;

   633 	return _self;

   634 }

   635 

   636 #define EventQueueRef_tp_free PyObject_Del

   637 

   638 

   639 PyTypeObject EventQueueRef_Type = {

   640 	PyObject_HEAD_INIT(NULL)

   641 	0, /*ob_size*/

   642 	"_CarbonEvt.EventQueueRef", /*tp_name*/

   643 	sizeof(EventQueueRefObject), /*tp_basicsize*/

   644 	0, /*tp_itemsize*/

   645 	/* methods */

   646 	(destructor) EventQueueRef_dealloc, /*tp_dealloc*/

   647 	0, /*tp_print*/

   648 	(getattrfunc)0, /*tp_getattr*/

   649 	(setattrfunc)0, /*tp_setattr*/

   650 	(cmpfunc) EventQueueRef_compare, /*tp_compare*/

   651 	(reprfunc) EventQueueRef_repr, /*tp_repr*/

   652 	(PyNumberMethods *)0, /* tp_as_number */

   653 	(PySequenceMethods *)0, /* tp_as_sequence */

   654 	(PyMappingMethods *)0, /* tp_as_mapping */

   655 	(hashfunc) EventQueueRef_hash, /*tp_hash*/

   656 	0, /*tp_call*/

   657 	0, /*tp_str*/

   658 	PyObject_GenericGetAttr, /*tp_getattro*/

   659 	PyObject_GenericSetAttr, /*tp_setattro */

   660 	0, /*tp_as_buffer*/

   661 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   662 	0, /*tp_doc*/

   663 	0, /*tp_traverse*/

   664 	0, /*tp_clear*/

   665 	0, /*tp_richcompare*/

   666 	0, /*tp_weaklistoffset*/

   667 	0, /*tp_iter*/

   668 	0, /*tp_iternext*/

   669 	EventQueueRef_methods, /* tp_methods */

   670 	0, /*tp_members*/

   671 	EventQueueRef_getsetlist, /*tp_getset*/

   672 	0, /*tp_base*/

   673 	0, /*tp_dict*/

   674 	0, /*tp_descr_get*/

   675 	0, /*tp_descr_set*/

   676 	0, /*tp_dictoffset*/

   677 	EventQueueRef_tp_init, /* tp_init */

   678 	EventQueueRef_tp_alloc, /* tp_alloc */

   679 	EventQueueRef_tp_new, /* tp_new */

   680 	EventQueueRef_tp_free, /* tp_free */

   681 };

   682 

   683 /* ----------------- End object type EventQueueRef ------------------ */

   684 

   685 

   686 /* -------------------- Object type EventLoopRef -------------------- */

   687 

   688 PyTypeObject EventLoopRef_Type;

   689 

   690 #define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type || PyObject_TypeCheck((x), &EventLoopRef_Type))

   691 

   692 typedef struct EventLoopRefObject {

   693 	PyObject_HEAD

   694 	EventLoopRef ob_itself;

   695 } EventLoopRefObject;

   696 

   697 PyObject *EventLoopRef_New(EventLoopRef itself)

   698 {

   699 	EventLoopRefObject *it;

   700 	it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type);

   701 	if (it == NULL) return NULL;

   702 	it->ob_itself = itself;

   703 	return (PyObject *)it;

   704 }

   705 

   706 int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself)

   707 {

   708 	if (!EventLoopRef_Check(v))

   709 	{

   710 		PyErr_SetString(PyExc_TypeError, "EventLoopRef required");

   711 		return 0;

   712 	}

   713 	*p_itself = ((EventLoopRefObject *)v)->ob_itself;

   714 	return 1;

   715 }

   716 

   717 static void EventLoopRef_dealloc(EventLoopRefObject *self)

   718 {

   719 	/* Cleanup of self->ob_itself goes here */

   720 	self->ob_type->tp_free((PyObject *)self);

   721 }

   722 

   723 static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args)

   724 {

   725 	PyObject *_res = NULL;

   726 	OSStatus _err;

   727 	if (!PyArg_ParseTuple(_args, ""))

   728 		return NULL;

   729 	_err = QuitEventLoop(_self->ob_itself);

   730 	if (_err != noErr) return PyMac_Error(_err);

   731 	Py_INCREF(Py_None);

   732 	_res = Py_None;

   733 	return _res;

   734 }

   735 

   736 static PyMethodDef EventLoopRef_methods[] = {

   737 	{"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,

   738 	 PyDoc_STR("() -> None")},

   739 	{NULL, NULL, 0}

   740 };

   741 

   742 #define EventLoopRef_getsetlist NULL

   743 

   744 

   745 #define EventLoopRef_compare NULL

   746 

   747 #define EventLoopRef_repr NULL

   748 

   749 #define EventLoopRef_hash NULL

   750 #define EventLoopRef_tp_init 0

   751 

   752 #define EventLoopRef_tp_alloc PyType_GenericAlloc

   753 

   754 static PyObject *EventLoopRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   755 {

   756 	PyObject *_self;

   757 	EventLoopRef itself;

   758 	char *kw[] = {"itself", 0};

   759 

   760 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL;

   761 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   762 	((EventLoopRefObject *)_self)->ob_itself = itself;

   763 	return _self;

   764 }

   765 

   766 #define EventLoopRef_tp_free PyObject_Del

   767 

   768 

   769 PyTypeObject EventLoopRef_Type = {

   770 	PyObject_HEAD_INIT(NULL)

   771 	0, /*ob_size*/

   772 	"_CarbonEvt.EventLoopRef", /*tp_name*/

   773 	sizeof(EventLoopRefObject), /*tp_basicsize*/

   774 	0, /*tp_itemsize*/

   775 	/* methods */

   776 	(destructor) EventLoopRef_dealloc, /*tp_dealloc*/

   777 	0, /*tp_print*/

   778 	(getattrfunc)0, /*tp_getattr*/

   779 	(setattrfunc)0, /*tp_setattr*/

   780 	(cmpfunc) EventLoopRef_compare, /*tp_compare*/

   781 	(reprfunc) EventLoopRef_repr, /*tp_repr*/

   782 	(PyNumberMethods *)0, /* tp_as_number */

   783 	(PySequenceMethods *)0, /* tp_as_sequence */

   784 	(PyMappingMethods *)0, /* tp_as_mapping */

   785 	(hashfunc) EventLoopRef_hash, /*tp_hash*/

   786 	0, /*tp_call*/

   787 	0, /*tp_str*/

   788 	PyObject_GenericGetAttr, /*tp_getattro*/

   789 	PyObject_GenericSetAttr, /*tp_setattro */

   790 	0, /*tp_as_buffer*/

   791 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   792 	0, /*tp_doc*/

   793 	0, /*tp_traverse*/

   794 	0, /*tp_clear*/

   795 	0, /*tp_richcompare*/

   796 	0, /*tp_weaklistoffset*/

   797 	0, /*tp_iter*/

   798 	0, /*tp_iternext*/

   799 	EventLoopRef_methods, /* tp_methods */

   800 	0, /*tp_members*/

   801 	EventLoopRef_getsetlist, /*tp_getset*/

   802 	0, /*tp_base*/

   803 	0, /*tp_dict*/

   804 	0, /*tp_descr_get*/

   805 	0, /*tp_descr_set*/

   806 	0, /*tp_dictoffset*/

   807 	EventLoopRef_tp_init, /* tp_init */

   808 	EventLoopRef_tp_alloc, /* tp_alloc */

   809 	EventLoopRef_tp_new, /* tp_new */

   810 	EventLoopRef_tp_free, /* tp_free */

   811 };

   812 

   813 /* ------------------ End object type EventLoopRef ------------------ */

   814 

   815 

   816 /* ----------------- Object type EventLoopTimerRef ------------------ */

   817 

   818 PyTypeObject EventLoopTimerRef_Type;

   819 

   820 #define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type || PyObject_TypeCheck((x), &EventLoopTimerRef_Type))

   821 

   822 typedef struct EventLoopTimerRefObject {

   823 	PyObject_HEAD

   824 	EventLoopTimerRef ob_itself;

   825 } EventLoopTimerRefObject;

   826 

   827 PyObject *EventLoopTimerRef_New(EventLoopTimerRef itself)

   828 {

   829 	EventLoopTimerRefObject *it;

   830 	it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type);

   831 	if (it == NULL) return NULL;

   832 	it->ob_itself = itself;

   833 	return (PyObject *)it;

   834 }

   835 

   836 int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself)

   837 {

   838 	if (!EventLoopTimerRef_Check(v))

   839 	{

   840 		PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required");

   841 		return 0;

   842 	}

   843 	*p_itself = ((EventLoopTimerRefObject *)v)->ob_itself;

   844 	return 1;

   845 }

   846 

   847 static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)

   848 {

   849 	/* Cleanup of self->ob_itself goes here */

   850 	self->ob_type->tp_free((PyObject *)self);

   851 }

   852 

   853 static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args)

   854 {

   855 	PyObject *_res = NULL;

   856 	OSStatus _err;

   857 	if (!PyArg_ParseTuple(_args, ""))

   858 		return NULL;

   859 	_err = RemoveEventLoopTimer(_self->ob_itself);

   860 	if (_err != noErr) return PyMac_Error(_err);

   861 	Py_INCREF(Py_None);

   862 	_res = Py_None;

   863 	return _res;

   864 }

   865 

   866 static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject *_self, PyObject *_args)

   867 {

   868 	PyObject *_res = NULL;

   869 	OSStatus _err;

   870 	double inNextFire;

   871 	if (!PyArg_ParseTuple(_args, "d",

   872 	                      &inNextFire))

   873 		return NULL;

   874 	_err = SetEventLoopTimerNextFireTime(_self->ob_itself,

   875 	                                     inNextFire);

   876 	if (_err != noErr) return PyMac_Error(_err);

   877 	Py_INCREF(Py_None);

   878 	_res = Py_None;

   879 	return _res;

   880 }

   881 

   882 static PyMethodDef EventLoopTimerRef_methods[] = {

   883 	{"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,

   884 	 PyDoc_STR("() -> None")},

   885 	{"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,

   886 	 PyDoc_STR("(double inNextFire) -> None")},

   887 	{NULL, NULL, 0}

   888 };

   889 

   890 #define EventLoopTimerRef_getsetlist NULL

   891 

   892 

   893 #define EventLoopTimerRef_compare NULL

   894 

   895 #define EventLoopTimerRef_repr NULL

   896 

   897 #define EventLoopTimerRef_hash NULL

   898 #define EventLoopTimerRef_tp_init 0

   899 

   900 #define EventLoopTimerRef_tp_alloc PyType_GenericAlloc

   901 

   902 static PyObject *EventLoopTimerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   903 {

   904 	PyObject *_self;

   905 	EventLoopTimerRef itself;

   906 	char *kw[] = {"itself", 0};

   907 

   908 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL;

   909 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

   910 	((EventLoopTimerRefObject *)_self)->ob_itself = itself;

   911 	return _self;

   912 }

   913 

   914 #define EventLoopTimerRef_tp_free PyObject_Del

   915 

   916 

   917 PyTypeObject EventLoopTimerRef_Type = {

   918 	PyObject_HEAD_INIT(NULL)

   919 	0, /*ob_size*/

   920 	"_CarbonEvt.EventLoopTimerRef", /*tp_name*/

   921 	sizeof(EventLoopTimerRefObject), /*tp_basicsize*/

   922 	0, /*tp_itemsize*/

   923 	/* methods */

   924 	(destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/

   925 	0, /*tp_print*/

   926 	(getattrfunc)0, /*tp_getattr*/

   927 	(setattrfunc)0, /*tp_setattr*/

   928 	(cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/

   929 	(reprfunc) EventLoopTimerRef_repr, /*tp_repr*/

   930 	(PyNumberMethods *)0, /* tp_as_number */

   931 	(PySequenceMethods *)0, /* tp_as_sequence */

   932 	(PyMappingMethods *)0, /* tp_as_mapping */

   933 	(hashfunc) EventLoopTimerRef_hash, /*tp_hash*/

   934 	0, /*tp_call*/

   935 	0, /*tp_str*/

   936 	PyObject_GenericGetAttr, /*tp_getattro*/

   937 	PyObject_GenericSetAttr, /*tp_setattro */

   938 	0, /*tp_as_buffer*/

   939 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   940 	0, /*tp_doc*/

   941 	0, /*tp_traverse*/

   942 	0, /*tp_clear*/

   943 	0, /*tp_richcompare*/

   944 	0, /*tp_weaklistoffset*/

   945 	0, /*tp_iter*/

   946 	0, /*tp_iternext*/

   947 	EventLoopTimerRef_methods, /* tp_methods */

   948 	0, /*tp_members*/

   949 	EventLoopTimerRef_getsetlist, /*tp_getset*/

   950 	0, /*tp_base*/

   951 	0, /*tp_dict*/

   952 	0, /*tp_descr_get*/

   953 	0, /*tp_descr_set*/

   954 	0, /*tp_dictoffset*/

   955 	EventLoopTimerRef_tp_init, /* tp_init */

   956 	EventLoopTimerRef_tp_alloc, /* tp_alloc */

   957 	EventLoopTimerRef_tp_new, /* tp_new */

   958 	EventLoopTimerRef_tp_free, /* tp_free */

   959 };

   960 

   961 /* --------------- End object type EventLoopTimerRef ---------------- */

   962 

   963 

   964 /* ------------------ Object type EventHandlerRef ------------------- */

   965 

   966 PyTypeObject EventHandlerRef_Type;

   967 

   968 #define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type || PyObject_TypeCheck((x), &EventHandlerRef_Type))

   969 

   970 typedef struct EventHandlerRefObject {

   971 	PyObject_HEAD

   972 	EventHandlerRef ob_itself;

   973 	PyObject *ob_callback;

   974 } EventHandlerRefObject;

   975 

   976 PyObject *EventHandlerRef_New(EventHandlerRef itself)

   977 {

   978 	EventHandlerRefObject *it;

   979 	it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type);

   980 	if (it == NULL) return NULL;

   981 	it->ob_itself = itself;

   982 	it->ob_callback = NULL;

   983 	return (PyObject *)it;

   984 }

   985 

   986 int EventHandlerRef_Convert(PyObject *v, EventHandlerRef *p_itself)

   987 {

   988 	if (!EventHandlerRef_Check(v))

   989 	{

   990 		PyErr_SetString(PyExc_TypeError, "EventHandlerRef required");

   991 		return 0;

   992 	}

   993 	*p_itself = ((EventHandlerRefObject *)v)->ob_itself;

   994 	return 1;

   995 }

   996 

   997 static void EventHandlerRef_dealloc(EventHandlerRefObject *self)

   998 {

   999 	if (self->ob_itself != NULL) {

  1000 		RemoveEventHandler(self->ob_itself);

  1001 		Py_DECREF(self->ob_callback);

  1002 	}

  1003 	self->ob_type->tp_free((PyObject *)self);

  1004 }

  1005 

  1006 static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args)

  1007 {

  1008 	PyObject *_res = NULL;

  1009 	OSStatus _err;

  1010 	UInt32 inNumTypes;

  1011 	EventTypeSpec inList;

  1012 	if (_self->ob_itself == NULL) {

  1013 		PyErr_SetString(CarbonEvents_Error, "Handler has been removed");

  1014 		return NULL;

  1015 	}

  1016 	if (!PyArg_ParseTuple(_args, "lO&",

  1017 	                      &inNumTypes,

  1018 	                      EventTypeSpec_Convert, &inList))

  1019 		return NULL;

  1020 	_err = AddEventTypesToHandler(_self->ob_itself,

  1021 	                              inNumTypes,

  1022 	                              &inList);

  1023 	if (_err != noErr) return PyMac_Error(_err);

  1024 	Py_INCREF(Py_None);

  1025 	_res = Py_None;

  1026 	return _res;

  1027 }

  1028 

  1029 static PyObject *EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject *_self, PyObject *_args)

  1030 {

  1031 	PyObject *_res = NULL;

  1032 	OSStatus _err;

  1033 	UInt32 inNumTypes;

  1034 	EventTypeSpec inList;

  1035 	if (_self->ob_itself == NULL) {

  1036 		PyErr_SetString(CarbonEvents_Error, "Handler has been removed");

  1037 		return NULL;

  1038 	}

  1039 	if (!PyArg_ParseTuple(_args, "lO&",

  1040 	                      &inNumTypes,

  1041 	                      EventTypeSpec_Convert, &inList))

  1042 		return NULL;

  1043 	_err = RemoveEventTypesFromHandler(_self->ob_itself,

  1044 	                                   inNumTypes,

  1045 	                                   &inList);

  1046 	if (_err != noErr) return PyMac_Error(_err);

  1047 	Py_INCREF(Py_None);

  1048 	_res = Py_None;

  1049 	return _res;

  1050 }

  1051 

  1052 static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args)

  1053 {

  1054 	PyObject *_res = NULL;

  1055 

  1056 	OSStatus _err;

  1057 	if (_self->ob_itself == NULL) {

  1058 	        PyErr_SetString(CarbonEvents_Error, "Handler has been removed");

  1059 	        return NULL;

  1060 	}

  1061 	if (!PyArg_ParseTuple(_args, ""))

  1062 	        return NULL;

  1063 	_err = RemoveEventHandler(_self->ob_itself);

  1064 	if (_err != noErr) return PyMac_Error(_err);

  1065 	_self->ob_itself = NULL;

  1066 	Py_DECREF(_self->ob_callback);

  1067 	_self->ob_callback = NULL;

  1068 	Py_INCREF(Py_None);

  1069 	_res = Py_None;

  1070 	return _res;

  1071 }

  1072 

  1073 static PyMethodDef EventHandlerRef_methods[] = {

  1074 	{"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,

  1075 	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},

  1076 	{"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,

  1077 	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},

  1078 	{"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,

  1079 	 PyDoc_STR("() -> None")},

  1080 	{NULL, NULL, 0}

  1081 };

  1082 

  1083 #define EventHandlerRef_getsetlist NULL

  1084 

  1085 

  1086 #define EventHandlerRef_compare NULL

  1087 

  1088 #define EventHandlerRef_repr NULL

  1089 

  1090 #define EventHandlerRef_hash NULL

  1091 #define EventHandlerRef_tp_init 0

  1092 

  1093 #define EventHandlerRef_tp_alloc PyType_GenericAlloc

  1094 

  1095 static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

  1096 {

  1097 	PyObject *_self;

  1098 	EventHandlerRef itself;

  1099 	char *kw[] = {"itself", 0};

  1100 

  1101 	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;

  1102 	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;

  1103 	((EventHandlerRefObject *)_self)->ob_itself = itself;

  1104 	return _self;

  1105 }

  1106 

  1107 #define EventHandlerRef_tp_free PyObject_Del

  1108 

  1109 

  1110 PyTypeObject EventHandlerRef_Type = {

  1111 	PyObject_HEAD_INIT(NULL)

  1112 	0, /*ob_size*/

  1113 	"_CarbonEvt.EventHandlerRef", /*tp_name*/

  1114 	sizeof(EventHandlerRefObject), /*tp_basicsize*/

  1115 	0, /*tp_itemsize*/

  1116 	/* methods */

  1117 	(destructor) EventHandlerRef_dealloc, /*tp_dealloc*/

  1118 	0, /*tp_print*/

  1119 	(getattrfunc)0, /*tp_getattr*/

  1120 	(setattrfunc)0, /*tp_setattr*/

  1121 	(cmpfunc) EventHandlerRef_compare, /*tp_compare*/

  1122 	(reprfunc) EventHandlerRef_repr, /*tp_repr*/

  1123 	(PyNumberMethods *)0, /* tp_as_number */

  1124 	(PySequenceMethods *)0, /* tp_as_sequence */

  1125 	(PyMappingMethods *)0, /* tp_as_mapping */

  1126 	(hashfunc) EventHandlerRef_hash, /*tp_hash*/

  1127 	0, /*tp_call*/

  1128 	0, /*tp_str*/

  1129 	PyObject_GenericGetAttr, /*tp_getattro*/

  1130 	PyObject_GenericSetAttr, /*tp_setattro */

  1131 	0, /*tp_as_buffer*/

  1132 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

  1133 	0, /*tp_doc*/

  1134 	0, /*tp_traverse*/

  1135 	0, /*tp_clear*/