1 
2 /* ======================= Module _CarbonEvt ======================== */
3 
4 #include "Python.h"
5 #include "pymactoolbox.h"
6 
7 #if APPLE_SUPPORTS_QUICKTIME
8 
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 int
EventTypeSpec_Convert(PyObject * v,EventTypeSpec * out)31 EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)
32 {
33     if (PyArg_Parse(v, "(O&l)",
34                     PyMac_GetOSType, &(out->eventClass),
35                     &(out->eventKind)))
36         return 1;
37     return 0;
38 }
39 
40 /********** end EventTypeSpec *******/
41 
42 /********** HIPoint *******/
43 
44 #if 0  /* XXX doesn't compile */
45 static PyObject*
46 HIPoint_New(HIPoint *in)
47 {
48     return Py_BuildValue("ff", in->x, in->y);
49 }
50 
51 static int
52 HIPoint_Convert(PyObject *v, HIPoint *out)
53 {
54     if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))
55         return 1;
56     return NULL;
57 }
58 #endif
59 
60 /********** end HIPoint *******/
61 
62 /********** EventHotKeyID *******/
63 
64 static int
EventHotKeyID_Convert(PyObject * v,EventHotKeyID * out)65 EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out)
66 {
67     if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))
68         return 1;
69     return 0;
70 }
71 
72 /********** end EventHotKeyID *******/
73 
74 /******** myEventHandler ***********/
75 
76 static EventHandlerUPP myEventHandlerUPP;
77 
78 static pascal OSStatus
myEventHandler(EventHandlerCallRef handlerRef,EventRef event,void * outPyObject)79 myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) {
80     PyObject *retValue;
81     int status;
82 
83     retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",
84                                      EventHandlerCallRef_New, handlerRef,
85                                      EventRef_New, event);
86     if (retValue == NULL) {
87         PySys_WriteStderr("Error in event handler callback:\n");
88         PyErr_Print();  /* this also clears the error */
89         status = noErr; /* complain? how? */
90     } else {
91         if (retValue == Py_None)
92             status = noErr;
93         else if (PyInt_Check(retValue)) {
94             status = PyInt_AsLong(retValue);
95         } else
96             status = noErr; /* wrong object type, complain? */
97         Py_DECREF(retValue);
98     }
99 
100     return status;
101 }
102 
103 /******** end myEventHandler ***********/
104 
105 
106 static PyObject *CarbonEvents_Error;
107 
108 /* ---------------------- Object type EventRef ---------------------- */
109 
110 PyTypeObject EventRef_Type;
111 
112 #define EventRef_Check(x) ((x)->ob_type == &EventRef_Type || PyObject_TypeCheck((x), &EventRef_Type))
113 
114 typedef struct EventRefObject {
115     PyObject_HEAD
116     EventRef ob_itself;
117 } EventRefObject;
118 
EventRef_New(EventRef itself)119 PyObject *EventRef_New(EventRef itself)
120 {
121     EventRefObject *it;
122     it = PyObject_NEW(EventRefObject, &EventRef_Type);
123     if (it == NULL) return NULL;
124     it->ob_itself = itself;
125     return (PyObject *)it;
126 }
127 
EventRef_Convert(PyObject * v,EventRef * p_itself)128 int EventRef_Convert(PyObject *v, EventRef *p_itself)
129 {
130     if (!EventRef_Check(v))
131     {
132         PyErr_SetString(PyExc_TypeError, "EventRef required");
133         return 0;
134     }
135     *p_itself = ((EventRefObject *)v)->ob_itself;
136     return 1;
137 }
138 
EventRef_dealloc(EventRefObject * self)139 static void EventRef_dealloc(EventRefObject *self)
140 {
141     /* Cleanup of self->ob_itself goes here */
142     self->ob_type->tp_free((PyObject *)self);
143 }
144 
EventRef_RetainEvent(EventRefObject * _self,PyObject * _args)145 static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args)
146 {
147     PyObject *_res = NULL;
148     EventRef _rv;
149     if (!PyArg_ParseTuple(_args, ""))
150         return NULL;
151     _rv = RetainEvent(_self->ob_itself);
152     _res = Py_BuildValue("O&",
153                          EventRef_New, _rv);
154     return _res;
155 }
156 
EventRef_GetEventRetainCount(EventRefObject * _self,PyObject * _args)157 static PyObject *EventRef_GetEventRetainCount(EventRefObject *_self, PyObject *_args)
158 {
159     PyObject *_res = NULL;
160     UInt32 _rv;
161     if (!PyArg_ParseTuple(_args, ""))
162         return NULL;
163     _rv = GetEventRetainCount(_self->ob_itself);
164     _res = Py_BuildValue("l",
165                          _rv);
166     return _res;
167 }
168 
EventRef_ReleaseEvent(EventRefObject * _self,PyObject * _args)169 static PyObject *EventRef_ReleaseEvent(EventRefObject *_self, PyObject *_args)
170 {
171     PyObject *_res = NULL;
172     if (!PyArg_ParseTuple(_args, ""))
173         return NULL;
174     ReleaseEvent(_self->ob_itself);
175     Py_INCREF(Py_None);
176     _res = Py_None;
177     return _res;
178 }
179 
EventRef_SetEventParameter(EventRefObject * _self,PyObject * _args)180 static PyObject *EventRef_SetEventParameter(EventRefObject *_self, PyObject *_args)
181 {
182     PyObject *_res = NULL;
183     OSStatus _err;
184     OSType inName;
185     OSType inType;
186     char *inDataPtr__in__;
187     long inDataPtr__len__;
188     int inDataPtr__in_len__;
189     if (!PyArg_ParseTuple(_args, "O&O&s#",
190                           PyMac_GetOSType, &inName,
191                           PyMac_GetOSType, &inType,
192                           &inDataPtr__in__, &inDataPtr__in_len__))
193         return NULL;
194     inDataPtr__len__ = inDataPtr__in_len__;
195     _err = SetEventParameter(_self->ob_itself,
196                              inName,
197                              inType,
198                              inDataPtr__len__, inDataPtr__in__);
199     if (_err != noErr) return PyMac_Error(_err);
200     Py_INCREF(Py_None);
201     _res = Py_None;
202     return _res;
203 }
204 
EventRef_GetEventClass(EventRefObject * _self,PyObject * _args)205 static PyObject *EventRef_GetEventClass(EventRefObject *_self, PyObject *_args)
206 {
207     PyObject *_res = NULL;
208     UInt32 _rv;
209     if (!PyArg_ParseTuple(_args, ""))
210         return NULL;
211     _rv = GetEventClass(_self->ob_itself);
212     _res = Py_BuildValue("l",
213                          _rv);
214     return _res;
215 }
216 
EventRef_GetEventKind(EventRefObject * _self,PyObject * _args)217 static PyObject *EventRef_GetEventKind(EventRefObject *_self, PyObject *_args)
218 {
219     PyObject *_res = NULL;
220     UInt32 _rv;
221     if (!PyArg_ParseTuple(_args, ""))
222         return NULL;
223     _rv = GetEventKind(_self->ob_itself);
224     _res = Py_BuildValue("l",
225                          _rv);
226     return _res;
227 }
228 
EventRef_GetEventTime(EventRefObject * _self,PyObject * _args)229 static PyObject *EventRef_GetEventTime(EventRefObject *_self, PyObject *_args)
230 {
231     PyObject *_res = NULL;
232     double _rv;
233     if (!PyArg_ParseTuple(_args, ""))
234         return NULL;
235     _rv = GetEventTime(_self->ob_itself);
236     _res = Py_BuildValue("d",
237                          _rv);
238     return _res;
239 }
240 
EventRef_SetEventTime(EventRefObject * _self,PyObject * _args)241 static PyObject *EventRef_SetEventTime(EventRefObject *_self, PyObject *_args)
242 {
243     PyObject *_res = NULL;
244     OSStatus _err;
245     double inTime;
246     if (!PyArg_ParseTuple(_args, "d",
247                           &inTime))
248         return NULL;
249     _err = SetEventTime(_self->ob_itself,
250                         inTime);
251     if (_err != noErr) return PyMac_Error(_err);
252     Py_INCREF(Py_None);
253     _res = Py_None;
254     return _res;
255 }
256 
EventRef_IsUserCancelEventRef(EventRefObject * _self,PyObject * _args)257 static PyObject *EventRef_IsUserCancelEventRef(EventRefObject *_self, PyObject *_args)
258 {
259     PyObject *_res = NULL;
260     Boolean _rv;
261     if (!PyArg_ParseTuple(_args, ""))
262         return NULL;
263     _rv = IsUserCancelEventRef(_self->ob_itself);
264     _res = Py_BuildValue("b",
265                          _rv);
266     return _res;
267 }
268 
EventRef_ConvertEventRefToEventRecord(EventRefObject * _self,PyObject * _args)269 static PyObject *EventRef_ConvertEventRefToEventRecord(EventRefObject *_self, PyObject *_args)
270 {
271     PyObject *_res = NULL;
272     Boolean _rv;
273     EventRecord outEvent;
274     if (!PyArg_ParseTuple(_args, ""))
275         return NULL;
276     _rv = ConvertEventRefToEventRecord(_self->ob_itself,
277                                        &outEvent);
278     _res = Py_BuildValue("bO&",
279                          _rv,
280                          PyMac_BuildEventRecord, &outEvent);
281     return _res;
282 }
283 
EventRef_IsEventInMask(EventRefObject * _self,PyObject * _args)284 static PyObject *EventRef_IsEventInMask(EventRefObject *_self, PyObject *_args)
285 {
286     PyObject *_res = NULL;
287     Boolean _rv;
288     UInt16 inMask;
289     if (!PyArg_ParseTuple(_args, "H",
290                           &inMask))
291         return NULL;
292     _rv = IsEventInMask(_self->ob_itself,
293                         inMask);
294     _res = Py_BuildValue("b",
295                          _rv);
296     return _res;
297 }
298 
EventRef_SendEventToEventTarget(EventRefObject * _self,PyObject * _args)299 static PyObject *EventRef_SendEventToEventTarget(EventRefObject *_self, PyObject *_args)
300 {
301     PyObject *_res = NULL;
302     OSStatus _err;
303     EventTargetRef inTarget;
304     if (!PyArg_ParseTuple(_args, "O&",
305                           EventTargetRef_Convert, &inTarget))
306         return NULL;
307     _err = SendEventToEventTarget(_self->ob_itself,
308                                   inTarget);
309     if (_err != noErr) return PyMac_Error(_err);
310     Py_INCREF(Py_None);
311     _res = Py_None;
312     return _res;
313 }
314 
EventRef_GetEventParameter(EventRefObject * _self,PyObject * _args)315 static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_args)
316 {
317     PyObject *_res = NULL;
318 
319     UInt32 bufferSize;
320     EventParamName inName;
321     EventParamType inType;
322     OSErr _err;
323     void * buffer;
324 
325     if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))
326           return NULL;
327 
328     /* Figure out the size by passing a null buffer to GetEventParameter */
329     _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);
330 
331     if (_err != noErr)
332           return PyMac_Error(_err);
333     buffer = PyMem_NEW(char, bufferSize);
334     if (buffer == NULL)
335           return PyErr_NoMemory();
336 
337     _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);
338 
339     if (_err != noErr) {
340           PyMem_DEL(buffer);
341           return PyMac_Error(_err);
342     }
343     _res = Py_BuildValue("s#", buffer, bufferSize);
344     PyMem_DEL(buffer);
345     return _res;
346 
347 }
348 
349 static PyMethodDef EventRef_methods[] = {
350     {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
351      PyDoc_STR("() -> (EventRef _rv)")},
352     {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
353      PyDoc_STR("() -> (UInt32 _rv)")},
354     {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
355      PyDoc_STR("() -> None")},
356     {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
357      PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
358     {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
359      PyDoc_STR("() -> (UInt32 _rv)")},
360     {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
361      PyDoc_STR("() -> (UInt32 _rv)")},
362     {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
363      PyDoc_STR("() -> (double _rv)")},
364     {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
365      PyDoc_STR("(double inTime) -> None")},
366     {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
367      PyDoc_STR("() -> (Boolean _rv)")},
368     {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
369      PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
370     {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
371      PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
372     {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
373      PyDoc_STR("(EventTargetRef inTarget) -> None")},
374     {"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
375      PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
376     {NULL, NULL, 0}
377 };
378 
379 #define EventRef_getsetlist NULL
380 
381 
382 #define EventRef_compare NULL
383 
384 #define EventRef_repr NULL
385 
386 #define EventRef_hash NULL
387 #define EventRef_tp_init 0
388 
389 #define EventRef_tp_alloc PyType_GenericAlloc
390 
EventRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)391 static PyObject *EventRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
392 {
393     PyObject *_self;
394     EventRef itself;
395     char *kw[] = {"itself", 0};
396 
397     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL;
398     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
399     ((EventRefObject *)_self)->ob_itself = itself;
400     return _self;
401 }
402 
403 #define EventRef_tp_free PyObject_Del
404 
405 
406 PyTypeObject EventRef_Type = {
407     PyObject_HEAD_INIT(NULL)
408     0, /*ob_size*/
409     "_CarbonEvt.EventRef", /*tp_name*/
410     sizeof(EventRefObject), /*tp_basicsize*/
411     0, /*tp_itemsize*/
412     /* methods */
413     (destructor) EventRef_dealloc, /*tp_dealloc*/
414     0, /*tp_print*/
415     (getattrfunc)0, /*tp_getattr*/
416     (setattrfunc)0, /*tp_setattr*/
417     (cmpfunc) EventRef_compare, /*tp_compare*/
418     (reprfunc) EventRef_repr, /*tp_repr*/
419     (PyNumberMethods *)0, /* tp_as_number */
420     (PySequenceMethods *)0, /* tp_as_sequence */
421     (PyMappingMethods *)0, /* tp_as_mapping */
422     (hashfunc) EventRef_hash, /*tp_hash*/
423     0, /*tp_call*/
424     0, /*tp_str*/
425     PyObject_GenericGetAttr, /*tp_getattro*/
426     PyObject_GenericSetAttr, /*tp_setattro */
427     0, /*tp_as_buffer*/
428     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
429     0, /*tp_doc*/
430     0, /*tp_traverse*/
431     0, /*tp_clear*/
432     0, /*tp_richcompare*/
433     0, /*tp_weaklistoffset*/
434     0, /*tp_iter*/
435     0, /*tp_iternext*/
436     EventRef_methods, /* tp_methods */
437     0, /*tp_members*/
438     EventRef_getsetlist, /*tp_getset*/
439     0, /*tp_base*/
440     0, /*tp_dict*/
441     0, /*tp_descr_get*/
442     0, /*tp_descr_set*/
443     0, /*tp_dictoffset*/
444     EventRef_tp_init, /* tp_init */
445     EventRef_tp_alloc, /* tp_alloc */
446     EventRef_tp_new, /* tp_new */
447     EventRef_tp_free, /* tp_free */
448 };
449 
450 /* -------------------- End object type EventRef -------------------- */
451 
452 
453 /* ------------------- Object type EventQueueRef -------------------- */
454 
455 PyTypeObject EventQueueRef_Type;
456 
457 #define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type || PyObject_TypeCheck((x), &EventQueueRef_Type))
458 
459 typedef struct EventQueueRefObject {
460     PyObject_HEAD
461     EventQueueRef ob_itself;
462 } EventQueueRefObject;
463 
EventQueueRef_New(EventQueueRef itself)464 PyObject *EventQueueRef_New(EventQueueRef itself)
465 {
466     EventQueueRefObject *it;
467     it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type);
468     if (it == NULL) return NULL;
469     it->ob_itself = itself;
470     return (PyObject *)it;
471 }
472 
EventQueueRef_Convert(PyObject * v,EventQueueRef * p_itself)473 int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself)
474 {
475     if (!EventQueueRef_Check(v))
476     {
477         PyErr_SetString(PyExc_TypeError, "EventQueueRef required");
478         return 0;
479     }
480     *p_itself = ((EventQueueRefObject *)v)->ob_itself;
481     return 1;
482 }
483 
EventQueueRef_dealloc(EventQueueRefObject * self)484 static void EventQueueRef_dealloc(EventQueueRefObject *self)
485 {
486     /* Cleanup of self->ob_itself goes here */
487     self->ob_type->tp_free((PyObject *)self);
488 }
489 
EventQueueRef_PostEventToQueue(EventQueueRefObject * _self,PyObject * _args)490 static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args)
491 {
492     PyObject *_res = NULL;
493     OSStatus _err;
494     EventRef inEvent;
495     SInt16 inPriority;
496     if (!PyArg_ParseTuple(_args, "O&h",
497                           EventRef_Convert, &inEvent,
498                           &inPriority))
499         return NULL;
500     _err = PostEventToQueue(_self->ob_itself,
501                             inEvent,
502                             inPriority);
503     if (_err != noErr) return PyMac_Error(_err);
504     Py_INCREF(Py_None);
505     _res = Py_None;
506     return _res;
507 }
508 
EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject * _self,PyObject * _args)509 static PyObject *EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject *_self, PyObject *_args)
510 {
511     PyObject *_res = NULL;
512     OSStatus _err;
513     UInt32 inNumTypes;
514     EventTypeSpec inList;
515     if (!PyArg_ParseTuple(_args, "lO&",
516                           &inNumTypes,
517                           EventTypeSpec_Convert, &inList))
518         return NULL;
519     _err = FlushEventsMatchingListFromQueue(_self->ob_itself,
520                                             inNumTypes,
521                                             &inList);
522     if (_err != noErr) return PyMac_Error(_err);
523     Py_INCREF(Py_None);
524     _res = Py_None;
525     return _res;
526 }
527 
EventQueueRef_FlushEventQueue(EventQueueRefObject * _self,PyObject * _args)528 static PyObject *EventQueueRef_FlushEventQueue(EventQueueRefObject *_self, PyObject *_args)
529 {
530     PyObject *_res = NULL;
531     OSStatus _err;
532     if (!PyArg_ParseTuple(_args, ""))
533         return NULL;
534     _err = FlushEventQueue(_self->ob_itself);
535     if (_err != noErr) return PyMac_Error(_err);
536     Py_INCREF(Py_None);
537     _res = Py_None;
538     return _res;
539 }
540 
EventQueueRef_GetNumEventsInQueue(EventQueueRefObject * _self,PyObject * _args)541 static PyObject *EventQueueRef_GetNumEventsInQueue(EventQueueRefObject *_self, PyObject *_args)
542 {
543     PyObject *_res = NULL;
544     UInt32 _rv;
545     if (!PyArg_ParseTuple(_args, ""))
546         return NULL;
547     _rv = GetNumEventsInQueue(_self->ob_itself);
548     _res = Py_BuildValue("l",
549                          _rv);
550     return _res;
551 }
552 
EventQueueRef_RemoveEventFromQueue(EventQueueRefObject * _self,PyObject * _args)553 static PyObject *EventQueueRef_RemoveEventFromQueue(EventQueueRefObject *_self, PyObject *_args)
554 {
555     PyObject *_res = NULL;
556     OSStatus _err;
557     EventRef inEvent;
558     if (!PyArg_ParseTuple(_args, "O&",
559                           EventRef_Convert, &inEvent))
560         return NULL;
561     _err = RemoveEventFromQueue(_self->ob_itself,
562                                 inEvent);
563     if (_err != noErr) return PyMac_Error(_err);
564     Py_INCREF(Py_None);
565     _res = Py_None;
566     return _res;
567 }
568 
EventQueueRef_IsEventInQueue(EventQueueRefObject * _self,PyObject * _args)569 static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObject *_args)
570 {
571     PyObject *_res = NULL;
572     Boolean _rv;
573     EventRef inEvent;
574     if (!PyArg_ParseTuple(_args, "O&",
575                           EventRef_Convert, &inEvent))
576         return NULL;
577     _rv = IsEventInQueue(_self->ob_itself,
578                          inEvent);
579     _res = Py_BuildValue("b",
580                          _rv);
581     return _res;
582 }
583 
584 static PyMethodDef EventQueueRef_methods[] = {
585     {"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
586      PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
587     {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
588      PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
589     {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
590      PyDoc_STR("() -> None")},
591     {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
592      PyDoc_STR("() -> (UInt32 _rv)")},
593     {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
594      PyDoc_STR("(EventRef inEvent) -> None")},
595     {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
596      PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
597     {NULL, NULL, 0}
598 };
599 
600 #define EventQueueRef_getsetlist NULL
601 
602 
603 #define EventQueueRef_compare NULL
604 
605 #define EventQueueRef_repr NULL
606 
607 #define EventQueueRef_hash NULL
608 #define EventQueueRef_tp_init 0
609 
610 #define EventQueueRef_tp_alloc PyType_GenericAlloc
611 
EventQueueRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)612 static PyObject *EventQueueRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
613 {
614     PyObject *_self;
615     EventQueueRef itself;
616     char *kw[] = {"itself", 0};
617 
618     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL;
619     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
620     ((EventQueueRefObject *)_self)->ob_itself = itself;
621     return _self;
622 }
623 
624 #define EventQueueRef_tp_free PyObject_Del
625 
626 
627 PyTypeObject EventQueueRef_Type = {
628     PyObject_HEAD_INIT(NULL)
629     0, /*ob_size*/
630     "_CarbonEvt.EventQueueRef", /*tp_name*/
631     sizeof(EventQueueRefObject), /*tp_basicsize*/
632     0, /*tp_itemsize*/
633     /* methods */
634     (destructor) EventQueueRef_dealloc, /*tp_dealloc*/
635     0, /*tp_print*/
636     (getattrfunc)0, /*tp_getattr*/
637     (setattrfunc)0, /*tp_setattr*/
638     (cmpfunc) EventQueueRef_compare, /*tp_compare*/
639     (reprfunc) EventQueueRef_repr, /*tp_repr*/
640     (PyNumberMethods *)0, /* tp_as_number */
641     (PySequenceMethods *)0, /* tp_as_sequence */
642     (PyMappingMethods *)0, /* tp_as_mapping */
643     (hashfunc) EventQueueRef_hash, /*tp_hash*/
644     0, /*tp_call*/
645     0, /*tp_str*/
646     PyObject_GenericGetAttr, /*tp_getattro*/
647     PyObject_GenericSetAttr, /*tp_setattro */
648     0, /*tp_as_buffer*/
649     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
650     0, /*tp_doc*/
651     0, /*tp_traverse*/
652     0, /*tp_clear*/
653     0, /*tp_richcompare*/
654     0, /*tp_weaklistoffset*/
655     0, /*tp_iter*/
656     0, /*tp_iternext*/
657     EventQueueRef_methods, /* tp_methods */
658     0, /*tp_members*/
659     EventQueueRef_getsetlist, /*tp_getset*/
660     0, /*tp_base*/
661     0, /*tp_dict*/
662     0, /*tp_descr_get*/
663     0, /*tp_descr_set*/
664     0, /*tp_dictoffset*/
665     EventQueueRef_tp_init, /* tp_init */
666     EventQueueRef_tp_alloc, /* tp_alloc */
667     EventQueueRef_tp_new, /* tp_new */
668     EventQueueRef_tp_free, /* tp_free */
669 };
670 
671 /* ----------------- End object type EventQueueRef ------------------ */
672 
673 
674 /* -------------------- Object type EventLoopRef -------------------- */
675 
676 PyTypeObject EventLoopRef_Type;
677 
678 #define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type || PyObject_TypeCheck((x), &EventLoopRef_Type))
679 
680 typedef struct EventLoopRefObject {
681     PyObject_HEAD
682     EventLoopRef ob_itself;
683 } EventLoopRefObject;
684 
EventLoopRef_New(EventLoopRef itself)685 PyObject *EventLoopRef_New(EventLoopRef itself)
686 {
687     EventLoopRefObject *it;
688     it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type);
689     if (it == NULL) return NULL;
690     it->ob_itself = itself;
691     return (PyObject *)it;
692 }
693 
EventLoopRef_Convert(PyObject * v,EventLoopRef * p_itself)694 int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself)
695 {
696     if (!EventLoopRef_Check(v))
697     {
698         PyErr_SetString(PyExc_TypeError, "EventLoopRef required");
699         return 0;
700     }
701     *p_itself = ((EventLoopRefObject *)v)->ob_itself;
702     return 1;
703 }
704 
EventLoopRef_dealloc(EventLoopRefObject * self)705 static void EventLoopRef_dealloc(EventLoopRefObject *self)
706 {
707     /* Cleanup of self->ob_itself goes here */
708     self->ob_type->tp_free((PyObject *)self);
709 }
710 
EventLoopRef_QuitEventLoop(EventLoopRefObject * _self,PyObject * _args)711 static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args)
712 {
713     PyObject *_res = NULL;
714     OSStatus _err;
715     if (!PyArg_ParseTuple(_args, ""))
716         return NULL;
717     _err = QuitEventLoop(_self->ob_itself);
718     if (_err != noErr) return PyMac_Error(_err);
719     Py_INCREF(Py_None);
720     _res = Py_None;
721     return _res;
722 }
723 
724 static PyMethodDef EventLoopRef_methods[] = {
725     {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
726      PyDoc_STR("() -> None")},
727     {NULL, NULL, 0}
728 };
729 
730 #define EventLoopRef_getsetlist NULL
731 
732 
733 #define EventLoopRef_compare NULL
734 
735 #define EventLoopRef_repr NULL
736 
737 #define EventLoopRef_hash NULL
738 #define EventLoopRef_tp_init 0
739 
740 #define EventLoopRef_tp_alloc PyType_GenericAlloc
741 
EventLoopRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)742 static PyObject *EventLoopRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
743 {
744     PyObject *_self;
745     EventLoopRef itself;
746     char *kw[] = {"itself", 0};
747 
748     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL;
749     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
750     ((EventLoopRefObject *)_self)->ob_itself = itself;
751     return _self;
752 }
753 
754 #define EventLoopRef_tp_free PyObject_Del
755 
756 
757 PyTypeObject EventLoopRef_Type = {
758     PyObject_HEAD_INIT(NULL)
759     0, /*ob_size*/
760     "_CarbonEvt.EventLoopRef", /*tp_name*/
761     sizeof(EventLoopRefObject), /*tp_basicsize*/
762     0, /*tp_itemsize*/
763     /* methods */
764     (destructor) EventLoopRef_dealloc, /*tp_dealloc*/
765     0, /*tp_print*/
766     (getattrfunc)0, /*tp_getattr*/
767     (setattrfunc)0, /*tp_setattr*/
768     (cmpfunc) EventLoopRef_compare, /*tp_compare*/
769     (reprfunc) EventLoopRef_repr, /*tp_repr*/
770     (PyNumberMethods *)0, /* tp_as_number */
771     (PySequenceMethods *)0, /* tp_as_sequence */
772     (PyMappingMethods *)0, /* tp_as_mapping */
773     (hashfunc) EventLoopRef_hash, /*tp_hash*/
774     0, /*tp_call*/
775     0, /*tp_str*/
776     PyObject_GenericGetAttr, /*tp_getattro*/
777     PyObject_GenericSetAttr, /*tp_setattro */
778     0, /*tp_as_buffer*/
779     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
780     0, /*tp_doc*/
781     0, /*tp_traverse*/
782     0, /*tp_clear*/
783     0, /*tp_richcompare*/
784     0, /*tp_weaklistoffset*/
785     0, /*tp_iter*/
786     0, /*tp_iternext*/
787     EventLoopRef_methods, /* tp_methods */
788     0, /*tp_members*/
789     EventLoopRef_getsetlist, /*tp_getset*/
790     0, /*tp_base*/
791     0, /*tp_dict*/
792     0, /*tp_descr_get*/
793     0, /*tp_descr_set*/
794     0, /*tp_dictoffset*/
795     EventLoopRef_tp_init, /* tp_init */
796     EventLoopRef_tp_alloc, /* tp_alloc */
797     EventLoopRef_tp_new, /* tp_new */
798     EventLoopRef_tp_free, /* tp_free */
799 };
800 
801 /* ------------------ End object type EventLoopRef ------------------ */
802 
803 
804 /* ----------------- Object type EventLoopTimerRef ------------------ */
805 
806 PyTypeObject EventLoopTimerRef_Type;
807 
808 #define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type || PyObject_TypeCheck((x), &EventLoopTimerRef_Type))
809 
810 typedef struct EventLoopTimerRefObject {
811     PyObject_HEAD
812     EventLoopTimerRef ob_itself;
813 } EventLoopTimerRefObject;
814 
EventLoopTimerRef_New(EventLoopTimerRef itself)815 PyObject *EventLoopTimerRef_New(EventLoopTimerRef itself)
816 {
817     EventLoopTimerRefObject *it;
818     it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type);
819     if (it == NULL) return NULL;
820     it->ob_itself = itself;
821     return (PyObject *)it;
822 }
823 
EventLoopTimerRef_Convert(PyObject * v,EventLoopTimerRef * p_itself)824 int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself)
825 {
826     if (!EventLoopTimerRef_Check(v))
827     {
828         PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required");
829         return 0;
830     }
831     *p_itself = ((EventLoopTimerRefObject *)v)->ob_itself;
832     return 1;
833 }
834 
EventLoopTimerRef_dealloc(EventLoopTimerRefObject * self)835 static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)
836 {
837     /* Cleanup of self->ob_itself goes here */
838     self->ob_type->tp_free((PyObject *)self);
839 }
840 
EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject * _self,PyObject * _args)841 static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args)
842 {
843     PyObject *_res = NULL;
844     OSStatus _err;
845     if (!PyArg_ParseTuple(_args, ""))
846         return NULL;
847     _err = RemoveEventLoopTimer(_self->ob_itself);
848     if (_err != noErr) return PyMac_Error(_err);
849     Py_INCREF(Py_None);
850     _res = Py_None;
851     return _res;
852 }
853 
EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject * _self,PyObject * _args)854 static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject *_self, PyObject *_args)
855 {
856     PyObject *_res = NULL;
857     OSStatus _err;
858     double inNextFire;
859     if (!PyArg_ParseTuple(_args, "d",
860                           &inNextFire))
861         return NULL;
862     _err = SetEventLoopTimerNextFireTime(_self->ob_itself,
863                                          inNextFire);
864     if (_err != noErr) return PyMac_Error(_err);
865     Py_INCREF(Py_None);
866     _res = Py_None;
867     return _res;
868 }
869 
870 static PyMethodDef EventLoopTimerRef_methods[] = {
871     {"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
872      PyDoc_STR("() -> None")},
873     {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
874      PyDoc_STR("(double inNextFire) -> None")},
875     {NULL, NULL, 0}
876 };
877 
878 #define EventLoopTimerRef_getsetlist NULL
879 
880 
881 #define EventLoopTimerRef_compare NULL
882 
883 #define EventLoopTimerRef_repr NULL
884 
885 #define EventLoopTimerRef_hash NULL
886 #define EventLoopTimerRef_tp_init 0
887 
888 #define EventLoopTimerRef_tp_alloc PyType_GenericAlloc
889 
EventLoopTimerRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)890 static PyObject *EventLoopTimerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
891 {
892     PyObject *_self;
893     EventLoopTimerRef itself;
894     char *kw[] = {"itself", 0};
895 
896     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL;
897     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
898     ((EventLoopTimerRefObject *)_self)->ob_itself = itself;
899     return _self;
900 }
901 
902 #define EventLoopTimerRef_tp_free PyObject_Del
903 
904 
905 PyTypeObject EventLoopTimerRef_Type = {
906     PyObject_HEAD_INIT(NULL)
907     0, /*ob_size*/
908     "_CarbonEvt.EventLoopTimerRef", /*tp_name*/
909     sizeof(EventLoopTimerRefObject), /*tp_basicsize*/
910     0, /*tp_itemsize*/
911     /* methods */
912     (destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/
913     0, /*tp_print*/
914     (getattrfunc)0, /*tp_getattr*/
915     (setattrfunc)0, /*tp_setattr*/
916     (cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/
917     (reprfunc) EventLoopTimerRef_repr, /*tp_repr*/
918     (PyNumberMethods *)0, /* tp_as_number */
919     (PySequenceMethods *)0, /* tp_as_sequence */
920     (PyMappingMethods *)0, /* tp_as_mapping */
921     (hashfunc) EventLoopTimerRef_hash, /*tp_hash*/
922     0, /*tp_call*/
923     0, /*tp_str*/
924     PyObject_GenericGetAttr, /*tp_getattro*/
925     PyObject_GenericSetAttr, /*tp_setattro */
926     0, /*tp_as_buffer*/
927     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
928     0, /*tp_doc*/
929     0, /*tp_traverse*/
930     0, /*tp_clear*/
931     0, /*tp_richcompare*/
932     0, /*tp_weaklistoffset*/
933     0, /*tp_iter*/
934     0, /*tp_iternext*/
935     EventLoopTimerRef_methods, /* tp_methods */
936     0, /*tp_members*/
937     EventLoopTimerRef_getsetlist, /*tp_getset*/
938     0, /*tp_base*/
939     0, /*tp_dict*/
940     0, /*tp_descr_get*/
941     0, /*tp_descr_set*/
942     0, /*tp_dictoffset*/
943     EventLoopTimerRef_tp_init, /* tp_init */
944     EventLoopTimerRef_tp_alloc, /* tp_alloc */
945     EventLoopTimerRef_tp_new, /* tp_new */
946     EventLoopTimerRef_tp_free, /* tp_free */
947 };
948 
949 /* --------------- End object type EventLoopTimerRef ---------------- */
950 
951 
952 /* ------------------ Object type EventHandlerRef ------------------- */
953 
954 PyTypeObject EventHandlerRef_Type;
955 
956 #define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type || PyObject_TypeCheck((x), &EventHandlerRef_Type))
957 
958 typedef struct EventHandlerRefObject {
959     PyObject_HEAD
960     EventHandlerRef ob_itself;
961     PyObject *ob_callback;
962 } EventHandlerRefObject;
963 
EventHandlerRef_New(EventHandlerRef itself)964 PyObject *EventHandlerRef_New(EventHandlerRef itself)
965 {
966     EventHandlerRefObject *it;
967     it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type);
968     if (it == NULL) return NULL;
969     it->ob_itself = itself;
970     it->ob_callback = NULL;
971     return (PyObject *)it;
972 }
973 
EventHandlerRef_Convert(PyObject * v,EventHandlerRef * p_itself)974 int EventHandlerRef_Convert(PyObject *v, EventHandlerRef *p_itself)
975 {
976     if (!EventHandlerRef_Check(v))
977     {
978         PyErr_SetString(PyExc_TypeError, "EventHandlerRef required");
979         return 0;
980     }
981     *p_itself = ((EventHandlerRefObject *)v)->ob_itself;
982     return 1;
983 }
984 
EventHandlerRef_dealloc(EventHandlerRefObject * self)985 static void EventHandlerRef_dealloc(EventHandlerRefObject *self)
986 {
987     if (self->ob_itself != NULL) {
988         RemoveEventHandler(self->ob_itself);
989         Py_DECREF(self->ob_callback);
990     }
991     self->ob_type->tp_free((PyObject *)self);
992 }
993 
EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject * _self,PyObject * _args)994 static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args)
995 {
996     PyObject *_res = NULL;
997     OSStatus _err;
998     UInt32 inNumTypes;
999     EventTypeSpec inList;
1000     if (_self->ob_itself == NULL) {
1001         PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
1002         return NULL;
1003     }
1004     if (!PyArg_ParseTuple(_args, "lO&",
1005                           &inNumTypes,
1006                           EventTypeSpec_Convert, &inList))
1007         return NULL;
1008     _err = AddEventTypesToHandler(_self->ob_itself,
1009                                   inNumTypes,
1010                                   &inList);
1011     if (_err != noErr) return PyMac_Error(_err);
1012     Py_INCREF(Py_None);
1013     _res = Py_None;
1014     return _res;
1015 }
1016 
EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject * _self,PyObject * _args)1017 static PyObject *EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject *_self, PyObject *_args)
1018 {
1019     PyObject *_res = NULL;
1020     OSStatus _err;
1021     UInt32 inNumTypes;
1022     EventTypeSpec inList;
1023     if (_self->ob_itself == NULL) {
1024         PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
1025         return NULL;
1026     }
1027     if (!PyArg_ParseTuple(_args, "lO&",
1028                           &inNumTypes,
1029                           EventTypeSpec_Convert, &inList))
1030         return NULL;
1031     _err = RemoveEventTypesFromHandler(_self->ob_itself,
1032                                        inNumTypes,
1033                                        &inList);
1034     if (_err != noErr) return PyMac_Error(_err);
1035     Py_INCREF(Py_None);
1036     _res = Py_None;
1037     return _res;
1038 }
1039 
EventHandlerRef_RemoveEventHandler(EventHandlerRefObject * _self,PyObject * _args)1040 static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args)
1041 {
1042     PyObject *_res = NULL;
1043 
1044     OSStatus _err;
1045     if (_self->ob_itself == NULL) {
1046         PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
1047         return NULL;
1048     }
1049     if (!PyArg_ParseTuple(_args, ""))
1050         return NULL;
1051     _err = RemoveEventHandler(_self->ob_itself);
1052     if (_err != noErr) return PyMac_Error(_err);
1053     _self->ob_itself = NULL;
1054     Py_CLEAR(_self->ob_callback);
1055     Py_INCREF(Py_None);
1056     _res = Py_None;
1057     return _res;
1058 }
1059 
1060 static PyMethodDef EventHandlerRef_methods[] = {
1061     {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
1062      PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
1063     {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
1064      PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
1065     {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
1066      PyDoc_STR("() -> None")},
1067     {NULL, NULL, 0}
1068 };
1069 
1070 #define EventHandlerRef_getsetlist NULL
1071 
1072 
1073 #define EventHandlerRef_compare NULL
1074 
1075 #define EventHandlerRef_repr NULL
1076 
1077 #define EventHandlerRef_hash NULL
1078 #define EventHandlerRef_tp_init 0
1079 
1080 #define EventHandlerRef_tp_alloc PyType_GenericAlloc
1081 
EventHandlerRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)1082 static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1083 {
1084     PyObject *_self;
1085     EventHandlerRef itself;
1086     char *kw[] = {"itself", 0};
1087 
1088     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;
1089     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1090     ((EventHandlerRefObject *)_self)->ob_itself = itself;
1091     return _self;
1092 }
1093 
1094 #define EventHandlerRef_tp_free PyObject_Del
1095 
1096 
1097 PyTypeObject EventHandlerRef_Type = {
1098     PyObject_HEAD_INIT(NULL)
1099     0, /*ob_size*/
1100     "_CarbonEvt.EventHandlerRef", /*tp_name*/
1101     sizeof(EventHandlerRefObject), /*tp_basicsize*/
1102     0, /*tp_itemsize*/
1103     /* methods */
1104     (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/
1105     0, /*tp_print*/
1106     (getattrfunc)0, /*tp_getattr*/
1107     (setattrfunc)0, /*tp_setattr*/
1108     (cmpfunc) EventHandlerRef_compare, /*tp_compare*/
1109     (reprfunc) EventHandlerRef_repr, /*tp_repr*/
1110     (PyNumberMethods *)0, /* tp_as_number */
1111     (PySequenceMethods *)0, /* tp_as_sequence */
1112     (PyMappingMethods *)0, /* tp_as_mapping */
1113     (hashfunc) EventHandlerRef_hash, /*tp_hash*/
1114     0, /*tp_call*/
1115     0, /*tp_str*/
1116     PyObject_GenericGetAttr, /*tp_getattro*/
1117     PyObject_GenericSetAttr, /*tp_setattro */
1118     0, /*tp_as_buffer*/
1119     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1120     0, /*tp_doc*/
1121     0, /*tp_traverse*/
1122     0, /*tp_clear*/
1123     0, /*tp_richcompare*/
1124     0, /*tp_weaklistoffset*/
1125     0, /*tp_iter*/
1126     0, /*tp_iternext*/
1127     EventHandlerRef_methods, /* tp_methods */
1128     0, /*tp_members*/
1129     EventHandlerRef_getsetlist, /*tp_getset*/
1130     0, /*tp_base*/
1131     0, /*tp_dict*/
1132     0, /*tp_descr_get*/
1133     0, /*tp_descr_set*/
1134     0, /*tp_dictoffset*/
1135     EventHandlerRef_tp_init, /* tp_init */
1136     EventHandlerRef_tp_alloc, /* tp_alloc */
1137     EventHandlerRef_tp_new, /* tp_new */
1138     EventHandlerRef_tp_free, /* tp_free */
1139 };
1140 
1141 /* ---------------- End object type EventHandlerRef ----------------- */
1142 
1143 
1144 /* ---------------- Object type EventHandlerCallRef ----------------- */
1145 
1146 PyTypeObject EventHandlerCallRef_Type;
1147 
1148 #define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type || PyObject_TypeCheck((x), &EventHandlerCallRef_Type))
1149 
1150 typedef struct EventHandlerCallRefObject {
1151     PyObject_HEAD
1152     EventHandlerCallRef ob_itself;
1153 } EventHandlerCallRefObject;
1154 
EventHandlerCallRef_New(EventHandlerCallRef itself)1155 PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself)
1156 {
1157     EventHandlerCallRefObject *it;
1158     it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type);
1159     if (it == NULL) return NULL;
1160     it->ob_itself = itself;
1161     return (PyObject *)it;
1162 }
1163 
EventHandlerCallRef_Convert(PyObject * v,EventHandlerCallRef * p_itself)1164 int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself)
1165 {
1166     if (!EventHandlerCallRef_Check(v))
1167     {
1168         PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required");
1169         return 0;
1170     }
1171     *p_itself = ((EventHandlerCallRefObject *)v)->ob_itself;
1172     return 1;
1173 }
1174 
EventHandlerCallRef_dealloc(EventHandlerCallRefObject * self)1175 static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
1176 {
1177     /* Cleanup of self->ob_itself goes here */
1178     self->ob_type->tp_free((PyObject *)self);
1179 }
1180 
EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject * _self,PyObject * _args)1181 static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args)
1182 {
1183     PyObject *_res = NULL;
1184     OSStatus _err;
1185     EventRef inEvent;
1186     if (!PyArg_ParseTuple(_args, "O&",
1187                           EventRef_Convert, &inEvent))
1188         return NULL;
1189     _err = CallNextEventHandler(_self->ob_itself,
1190                                 inEvent);
1191     if (_err != noErr) return PyMac_Error(_err);
1192     Py_INCREF(Py_None);
1193     _res = Py_None;
1194     return _res;
1195 }
1196 
1197 static PyMethodDef EventHandlerCallRef_methods[] = {
1198     {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
1199      PyDoc_STR("(EventRef inEvent) -> None")},
1200     {NULL, NULL, 0}
1201 };
1202 
1203 #define EventHandlerCallRef_getsetlist NULL
1204 
1205 
1206 #define EventHandlerCallRef_compare NULL
1207 
1208 #define EventHandlerCallRef_repr NULL
1209 
1210 #define EventHandlerCallRef_hash NULL
1211 #define EventHandlerCallRef_tp_init 0
1212 
1213 #define EventHandlerCallRef_tp_alloc PyType_GenericAlloc
1214 
EventHandlerCallRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)1215 static PyObject *EventHandlerCallRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1216 {
1217     PyObject *_self;
1218     EventHandlerCallRef itself;
1219     char *kw[] = {"itself", 0};
1220 
1221     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL;
1222     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1223     ((EventHandlerCallRefObject *)_self)->ob_itself = itself;
1224     return _self;
1225 }
1226 
1227 #define EventHandlerCallRef_tp_free PyObject_Del
1228 
1229 
1230 PyTypeObject EventHandlerCallRef_Type = {
1231     PyObject_HEAD_INIT(NULL)
1232     0, /*ob_size*/
1233     "_CarbonEvt.EventHandlerCallRef", /*tp_name*/
1234     sizeof(EventHandlerCallRefObject), /*tp_basicsize*/
1235     0, /*tp_itemsize*/
1236     /* methods */
1237     (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/
1238     0, /*tp_print*/
1239     (getattrfunc)0, /*tp_getattr*/
1240     (setattrfunc)0, /*tp_setattr*/
1241     (cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/
1242     (reprfunc) EventHandlerCallRef_repr, /*tp_repr*/
1243     (PyNumberMethods *)0, /* tp_as_number */
1244     (PySequenceMethods *)0, /* tp_as_sequence */
1245     (PyMappingMethods *)0, /* tp_as_mapping */
1246     (hashfunc) EventHandlerCallRef_hash, /*tp_hash*/
1247     0, /*tp_call*/
1248     0, /*tp_str*/
1249     PyObject_GenericGetAttr, /*tp_getattro*/
1250     PyObject_GenericSetAttr, /*tp_setattro */
1251     0, /*tp_as_buffer*/
1252     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1253     0, /*tp_doc*/
1254     0, /*tp_traverse*/
1255     0, /*tp_clear*/
1256     0, /*tp_richcompare*/
1257     0, /*tp_weaklistoffset*/
1258     0, /*tp_iter*/
1259     0, /*tp_iternext*/
1260     EventHandlerCallRef_methods, /* tp_methods */
1261     0, /*tp_members*/
1262     EventHandlerCallRef_getsetlist, /*tp_getset*/
1263     0, /*tp_base*/
1264     0, /*tp_dict*/
1265     0, /*tp_descr_get*/
1266     0, /*tp_descr_set*/
1267     0, /*tp_dictoffset*/
1268     EventHandlerCallRef_tp_init, /* tp_init */
1269     EventHandlerCallRef_tp_alloc, /* tp_alloc */
1270     EventHandlerCallRef_tp_new, /* tp_new */
1271     EventHandlerCallRef_tp_free, /* tp_free */
1272 };
1273 
1274 /* -------------- End object type EventHandlerCallRef --------------- */
1275 
1276 
1277 /* ------------------- Object type EventTargetRef ------------------- */
1278 
1279 PyTypeObject EventTargetRef_Type;
1280 
1281 #define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type || PyObject_TypeCheck((x), &EventTargetRef_Type))
1282 
1283 typedef struct EventTargetRefObject {
1284     PyObject_HEAD
1285     EventTargetRef ob_itself;
1286 } EventTargetRefObject;
1287 
EventTargetRef_New(EventTargetRef itself)1288 PyObject *EventTargetRef_New(EventTargetRef itself)
1289 {
1290     EventTargetRefObject *it;
1291     it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type);
1292     if (it == NULL) return NULL;
1293     it->ob_itself = itself;
1294     return (PyObject *)it;
1295 }
1296 
EventTargetRef_Convert(PyObject * v,EventTargetRef * p_itself)1297 int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself)
1298 {
1299     if (!EventTargetRef_Check(v))
1300     {
1301         PyErr_SetString(PyExc_TypeError, "EventTargetRef required");
1302         return 0;
1303     }
1304     *p_itself = ((EventTargetRefObject *)v)->ob_itself;
1305     return 1;
1306 }
1307 
EventTargetRef_dealloc(EventTargetRefObject * self)1308 static void EventTargetRef_dealloc(EventTargetRefObject *self)
1309 {
1310     /* Cleanup of self->ob_itself goes here */
1311     self->ob_type->tp_free((PyObject *)self);
1312 }
1313 
EventTargetRef_InstallStandardEventHandler(EventTargetRefObject * _self,PyObject * _args)1314 static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args)
1315 {
1316     PyObject *_res = NULL;
1317     OSStatus _err;
1318     if (!PyArg_ParseTuple(_args, ""))
1319         return NULL;
1320     _err = InstallStandardEventHandler(_self->ob_itself);
1321     if (_err != noErr) return PyMac_Error(_err);
1322     Py_INCREF(Py_None);
1323     _res = Py_None;
1324     return _res;
1325 }
1326 
EventTargetRef_InstallEventHandler(EventTargetRefObject * _self,PyObject * _args)1327 static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, PyObject *_args)
1328 {
1329     PyObject *_res = NULL;
1330 
1331     EventTypeSpec inSpec;
1332     PyObject *callback;
1333     EventHandlerRef outRef;
1334     OSStatus _err;
1335 
1336     if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))
1337         return NULL;
1338 
1339     _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);
1340     if (_err != noErr) return PyMac_Error(_err);
1341 
1342     _res = EventHandlerRef_New(outRef);
1343     if (_res != NULL) {
1344         ((EventHandlerRefObject*)_res)->ob_callback = callback;
1345         Py_INCREF(callback);
1346     }
1347     return _res;
1348 }
1349 
1350 static PyMethodDef EventTargetRef_methods[] = {
1351     {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
1352      PyDoc_STR("() -> None")},
1353     {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
1354      PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
1355     {NULL, NULL, 0}
1356 };
1357 
1358 #define EventTargetRef_getsetlist NULL
1359 
1360 
1361 #define EventTargetRef_compare NULL
1362 
1363 #define EventTargetRef_repr NULL
1364 
1365 #define EventTargetRef_hash NULL
1366 #define EventTargetRef_tp_init 0
1367 
1368 #define EventTargetRef_tp_alloc PyType_GenericAlloc
1369 
EventTargetRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)1370 static PyObject *EventTargetRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1371 {
1372     PyObject *_self;
1373     EventTargetRef itself;
1374     char *kw[] = {"itself", 0};
1375 
1376     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL;
1377     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1378     ((EventTargetRefObject *)_self)->ob_itself = itself;
1379     return _self;
1380 }
1381 
1382 #define EventTargetRef_tp_free PyObject_Del
1383 
1384 
1385 PyTypeObject EventTargetRef_Type = {
1386     PyObject_HEAD_INIT(NULL)
1387     0, /*ob_size*/
1388     "_CarbonEvt.EventTargetRef", /*tp_name*/
1389     sizeof(EventTargetRefObject), /*tp_basicsize*/
1390     0, /*tp_itemsize*/
1391     /* methods */
1392     (destructor) EventTargetRef_dealloc, /*tp_dealloc*/
1393     0, /*tp_print*/
1394     (getattrfunc)0, /*tp_getattr*/
1395     (setattrfunc)0, /*tp_setattr*/
1396     (cmpfunc) EventTargetRef_compare, /*tp_compare*/
1397     (reprfunc) EventTargetRef_repr, /*tp_repr*/
1398     (PyNumberMethods *)0, /* tp_as_number */
1399     (PySequenceMethods *)0, /* tp_as_sequence */
1400     (PyMappingMethods *)0, /* tp_as_mapping */
1401     (hashfunc) EventTargetRef_hash, /*tp_hash*/
1402     0, /*tp_call*/
1403     0, /*tp_str*/
1404     PyObject_GenericGetAttr, /*tp_getattro*/
1405     PyObject_GenericSetAttr, /*tp_setattro */
1406     0, /*tp_as_buffer*/
1407     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1408     0, /*tp_doc*/
1409     0, /*tp_traverse*/
1410     0, /*tp_clear*/
1411     0, /*tp_richcompare*/
1412     0, /*tp_weaklistoffset*/
1413     0, /*tp_iter*/
1414     0, /*tp_iternext*/
1415     EventTargetRef_methods, /* tp_methods */
1416     0, /*tp_members*/
1417     EventTargetRef_getsetlist, /*tp_getset*/
1418     0, /*tp_base*/
1419     0, /*tp_dict*/
1420     0, /*tp_descr_get*/
1421     0, /*tp_descr_set*/
1422     0, /*tp_dictoffset*/
1423     EventTargetRef_tp_init, /* tp_init */
1424     EventTargetRef_tp_alloc, /* tp_alloc */
1425     EventTargetRef_tp_new, /* tp_new */
1426     EventTargetRef_tp_free, /* tp_free */
1427 };
1428 
1429 /* ----------------- End object type EventTargetRef ----------------- */
1430 
1431 
1432 /* ------------------- Object type EventHotKeyRef ------------------- */
1433 
1434 PyTypeObject EventHotKeyRef_Type;
1435 
1436 #define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type || PyObject_TypeCheck((x), &EventHotKeyRef_Type))
1437 
1438 typedef struct EventHotKeyRefObject {
1439     PyObject_HEAD
1440     EventHotKeyRef ob_itself;
1441 } EventHotKeyRefObject;
1442 
EventHotKeyRef_New(EventHotKeyRef itself)1443 PyObject *EventHotKeyRef_New(EventHotKeyRef itself)
1444 {
1445     EventHotKeyRefObject *it;
1446     it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type);
1447     if (it == NULL) return NULL;
1448     it->ob_itself = itself;
1449     return (PyObject *)it;
1450 }
1451 
EventHotKeyRef_Convert(PyObject * v,EventHotKeyRef * p_itself)1452 int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself)
1453 {
1454     if (!EventHotKeyRef_Check(v))
1455     {
1456         PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required");
1457         return 0;
1458     }
1459     *p_itself = ((EventHotKeyRefObject *)v)->ob_itself;
1460     return 1;
1461 }
1462 
EventHotKeyRef_dealloc(EventHotKeyRefObject * self)1463 static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
1464 {
1465     /* Cleanup of self->ob_itself goes here */
1466     self->ob_type->tp_free((PyObject *)self);
1467 }
1468 
EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject * _self,PyObject * _args)1469 static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args)
1470 {
1471     PyObject *_res = NULL;
1472     OSStatus _err;
1473     if (!PyArg_ParseTuple(_args, ""))
1474         return NULL;
1475     _err = UnregisterEventHotKey(_self->ob_itself);
1476     if (_err != noErr) return PyMac_Error(_err);
1477     Py_INCREF(Py_None);
1478     _res = Py_None;
1479     return _res;
1480 }
1481 
1482 static PyMethodDef EventHotKeyRef_methods[] = {
1483     {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
1484      PyDoc_STR("() -> None")},
1485     {NULL, NULL, 0}
1486 };
1487 
1488 #define EventHotKeyRef_getsetlist NULL
1489 
1490 
1491 #define EventHotKeyRef_compare NULL
1492 
1493 #define EventHotKeyRef_repr NULL
1494 
1495 #define EventHotKeyRef_hash NULL
1496 #define EventHotKeyRef_tp_init 0
1497 
1498 #define EventHotKeyRef_tp_alloc PyType_GenericAlloc
1499 
EventHotKeyRef_tp_new(PyTypeObject * type,PyObject * _args,PyObject * _kwds)1500 static PyObject *EventHotKeyRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1501 {
1502     PyObject *_self;
1503     EventHotKeyRef itself;
1504     char *kw[] = {"itself", 0};
1505 
1506     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL;
1507     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1508     ((EventHotKeyRefObject *)_self)->ob_itself = itself;
1509     return _self;
1510 }
1511 
1512 #define EventHotKeyRef_tp_free PyObject_Del
1513 
1514 
1515 PyTypeObject EventHotKeyRef_Type = {
1516     PyObject_HEAD_INIT(NULL)
1517     0, /*ob_size*/
1518     "_CarbonEvt.EventHotKeyRef", /*tp_name*/
1519     sizeof(EventHotKeyRefObject), /*tp_basicsize*/
1520     0, /*tp_itemsize*/
1521     /* methods */
1522     (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/
1523     0, /*tp_print*/
1524     (getattrfunc)0, /*tp_getattr*/
1525     (setattrfunc)0, /*tp_setattr*/
1526     (cmpfunc) EventHotKeyRef_compare, /*tp_compare*/
1527     (reprfunc) EventHotKeyRef_repr, /*tp_repr*/
1528     (PyNumberMethods *)0, /* tp_as_number */
1529     (PySequenceMethods *)0, /* tp_as_sequence */
1530     (PyMappingMethods *)0, /* tp_as_mapping */
1531     (hashfunc) EventHotKeyRef_hash, /*tp_hash*/
1532     0, /*tp_call*/
1533     0, /*tp_str*/
1534     PyObject_GenericGetAttr, /*tp_getattro*/
1535     PyObject_GenericSetAttr, /*tp_setattro */
1536     0, /*tp_as_buffer*/
1537     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1538     0, /*tp_doc*/
1539     0, /*tp_traverse*/
1540     0, /*tp_clear*/
1541     0, /*tp_richcompare*/
1542     0, /*tp_weaklistoffset*/
1543     0, /*tp_iter*/
1544     0, /*tp_iternext*/
1545     EventHotKeyRef_methods, /* tp_methods */
1546     0, /*tp_members*/
1547     EventHotKeyRef_getsetlist, /*tp_getset*/
1548     0, /*tp_base*/
1549     0, /*tp_dict*/
1550     0, /*tp_descr_get*/
1551     0, /*tp_descr_set*/
1552     0, /*tp_dictoffset*/
1553     EventHotKeyRef_tp_init, /* tp_init */
1554     EventHotKeyRef_tp_alloc, /* tp_alloc */
1555     EventHotKeyRef_tp_new, /* tp_new */
1556     EventHotKeyRef_tp_free, /* tp_free */
1557 };
1558 
1559 /* ----------------- End object type EventHotKeyRef ----------------- */
1560 
1561 
CarbonEvents_GetCurrentEventLoop(PyObject * _self,PyObject * _args)1562 static PyObject *CarbonEvents_GetCurrentEventLoop(PyObject *_self, PyObject *_args)
1563 {
1564     PyObject *_res = NULL;
1565     EventLoopRef _rv;
1566     if (!PyArg_ParseTuple(_args, ""))
1567         return NULL;
1568     _rv = GetCurrentEventLoop();
1569     _res = Py_BuildValue("O&",
1570                          EventLoopRef_New, _rv);
1571     return _res;
1572 }
1573 
CarbonEvents_GetMainEventLoop(PyObject * _self,PyObject * _args)1574 static PyObject *CarbonEvents_GetMainEventLoop(PyObject *_self, PyObject *_args)
1575 {
1576     PyObject *_res = NULL;
1577     EventLoopRef _rv;
1578     if (!PyArg_ParseTuple(_args, ""))
1579         return NULL;
1580     _rv = GetMainEventLoop();
1581     _res = Py_BuildValue("O&",
1582                          EventLoopRef_New, _rv);
1583     return _res;
1584 }
1585 
CarbonEvents_RunCurrentEventLoop(PyObject * _self,PyObject * _args)1586 static PyObject *CarbonEvents_RunCurrentEventLoop(PyObject *_self, PyObject *_args)
1587 {
1588     PyObject *_res = NULL;
1589     OSStatus _err;
1590     double inTimeout;
1591     if (!PyArg_ParseTuple(_args, "d",
1592                           &inTimeout))
1593         return NULL;
1594     _err = RunCurrentEventLoop(inTimeout);
1595     if (_err != noErr) return PyMac_Error(_err);
1596     Py_INCREF(Py_None);
1597     _res = Py_None;
1598     return _res;
1599 }
1600 
CarbonEvents_ReceiveNextEvent(PyObject * _self,PyObject * _args)1601 static PyObject *CarbonEvents_ReceiveNextEvent(PyObject *_self, PyObject *_args)
1602 {
1603     PyObject *_res = NULL;
1604     OSStatus _err;
1605     UInt32 inNumTypes;
1606     EventTypeSpec inList;
1607     double inTimeout;
1608     Boolean inPullEvent;
1609     EventRef outEvent;
1610     if (!PyArg_ParseTuple(_args, "lO&db",
1611                           &inNumTypes,
1612                           EventTypeSpec_Convert, &inList,
1613                           &inTimeout,
1614                           &inPullEvent))
1615         return NULL;
1616     _err = ReceiveNextEvent(inNumTypes,
1617                             &inList,
1618                             inTimeout,
1619                             inPullEvent,
1620                             &outEvent);
1621     if (_err != noErr) return PyMac_Error(_err);
1622     _res = Py_BuildValue("O&",
1623                          EventRef_New, outEvent);
1624     return _res;
1625 }
1626 
CarbonEvents_GetCurrentEventQueue(PyObject * _self,PyObject * _args)1627 static PyObject *CarbonEvents_GetCurrentEventQueue(PyObject *_self, PyObject *_args)
1628 {
1629     PyObject *_res = NULL;
1630     EventQueueRef _rv;
1631     if (!PyArg_ParseTuple(_args, ""))
1632         return NULL;
1633     _rv = GetCurrentEventQueue();
1634     _res = Py_BuildValue("O&",
1635                          EventQueueRef_New, _rv);
1636     return _res;
1637 }
1638 
CarbonEvents_GetMainEventQueue(PyObject * _self,PyObject * _args)1639 static PyObject *CarbonEvents_GetMainEventQueue(PyObject *_self, PyObject *_args)
1640 {
1641     PyObject *_res = NULL;
1642     EventQueueRef _rv;
1643     if (!PyArg_ParseTuple(_args, ""))
1644         return NULL;
1645     _rv = GetMainEventQueue();
1646     _res = Py_BuildValue("O&",
1647                          EventQueueRef_New, _rv);
1648     return _res;
1649 }
1650 
CarbonEvents_GetCurrentEventTime(PyObject * _self,PyObject * _args)1651 static PyObject *CarbonEvents_GetCurrentEventTime(PyObject *_self, PyObject *_args)
1652 {
1653     PyObject *_res = NULL;
1654     double _rv;
1655     if (!PyArg_ParseTuple(_args, ""))
1656         return NULL;
1657     _rv = GetCurrentEventTime();
1658     _res = Py_BuildValue("d",
1659                          _rv);
1660     return _res;
1661 }
1662 
CarbonEvents_TrackMouseLocation(PyObject * _self,PyObject * _args)1663 static PyObject *CarbonEvents_TrackMouseLocation(PyObject *_self, PyObject *_args)
1664 {
1665     PyObject *_res = NULL;
1666     OSStatus _err;
1667     GrafPtr inPort;
1668     Point outPt;
1669     UInt16 outResult;
1670     if (!PyArg_ParseTuple(_args, "O&",
1671                           GrafObj_Convert, &inPort))
1672         return NULL;
1673     _err = TrackMouseLocation(inPort,
1674                               &outPt,
1675                               &outResult);
1676     if (_err != noErr) return PyMac_Error(_err);
1677     _res = Py_BuildValue("O&H",
1678                          PyMac_BuildPoint, outPt,
1679                          outResult);
1680     return _res;
1681 }
1682 
CarbonEvents_TrackMouseLocationWithOptions(PyObject * _self,PyObject * _args)1683 static PyObject *CarbonEvents_TrackMouseLocationWithOptions(PyObject *_self, PyObject *_args)
1684 {
1685     PyObject *_res = NULL;
1686     OSStatus _err;
1687     GrafPtr inPort;
1688     OptionBits inOptions;
1689     double inTimeout;
1690     Point outPt;
1691     UInt32 outModifiers;
1692     UInt16 outResult;
1693     if (!PyArg_ParseTuple(_args, "O&ld",
1694                           GrafObj_Convert, &inPort,
1695                           &inOptions,
1696                           &inTimeout))
1697         return NULL;
1698     _err = TrackMouseLocationWithOptions(inPort,
1699                                          inOptions,
1700                                          inTimeout,
1701                                          &outPt,
1702                                          &outModifiers,
1703                                          &outResult);
1704     if (_err != noErr) return PyMac_Error(_err);
1705     _res = Py_BuildValue("O&lH",
1706                          PyMac_BuildPoint, outPt,
1707                          outModifiers,
1708                          outResult);
1709     return _res;
1710 }
1711 
CarbonEvents_TrackMouseRegion(PyObject * _self,PyObject * _args)1712 static PyObject *CarbonEvents_TrackMouseRegion(PyObject *_self, PyObject *_args)
1713 {
1714     PyObject *_res = NULL;
1715     OSStatus _err;
1716     GrafPtr inPort;
1717     RgnHandle inRegion;
1718     Boolean ioWasInRgn;
1719     UInt16 outResult;
1720     if (!PyArg_ParseTuple(_args, "O&O&b",
1721                           GrafObj_Convert, &inPort,
1722                           ResObj_Convert, &inRegion,
1723                           &ioWasInRgn))
1724         return NULL;
1725     _err = TrackMouseRegion(inPort,
1726                             inRegion,
1727                             &ioWasInRgn,
1728                             &outResult);
1729     if (_err != noErr) return PyMac_Error(_err);
1730     _res = Py_BuildValue("bH",
1731                          ioWasInRgn,
1732                          outResult);
1733     return _res;
1734 }
1735 
CarbonEvents_GetLastUserEventTime(PyObject * _self,PyObject * _args)1736 static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_args)
1737 {
1738     PyObject *_res = NULL;
1739     double _rv;
1740     if (!PyArg_ParseTuple(_args, ""))
1741         return NULL;
1742     _rv = GetLastUserEventTime();
1743     _res = Py_BuildValue("d",
1744                          _rv);
1745     return _res;
1746 }
1747 
CarbonEvents_IsMouseCoalescingEnabled(PyObject * _self,PyObject * _args)1748 static PyObject *CarbonEvents_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
1749 {
1750     PyObject *_res = NULL;
1751     Boolean _rv;
1752     if (!PyArg_ParseTuple(_args, ""))
1753         return NULL;
1754     _rv = IsMouseCoalescingEnabled();
1755     _res = Py_BuildValue("b",
1756                          _rv);
1757     return _res;
1758 }
1759 
CarbonEvents_SetMouseCoalescingEnabled(PyObject * _self,PyObject * _args)1760 static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
1761 {
1762     PyObject *_res = NULL;
1763     OSStatus _err;
1764     Boolean inNewState;
1765     Boolean outOldState;
1766     if (!PyArg_ParseTuple(_args, "b",
1767                           &inNewState))
1768         return NULL;
1769     _err = SetMouseCoalescingEnabled(inNewState,
1770                                      &outOldState);
1771     if (_err != noErr) return PyMac_Error(_err);
1772     _res = Py_BuildValue("b",
1773                          outOldState);
1774     return _res;
1775 }
1776 
CarbonEvents_GetWindowEventTarget(PyObject * _self,PyObject * _args)1777 static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args)
1778 {
1779     PyObject *_res = NULL;
1780     EventTargetRef _rv;
1781     WindowPtr inWindow;
1782     if (!PyArg_ParseTuple(_args, "O&",
1783                           WinObj_Convert, &inWindow))
1784         return NULL;
1785     _rv = GetWindowEventTarget(inWindow);
1786     _res = Py_BuildValue("O&",
1787                          EventTargetRef_New, _rv);
1788     return _res;
1789 }
1790 
CarbonEvents_GetControlEventTarget(PyObject * _self,PyObject * _args)1791 static PyObject *CarbonEvents_GetControlEventTarget(PyObject *_self, PyObject *_args)
1792 {
1793     PyObject *_res = NULL;
1794     EventTargetRef _rv;
1795     ControlHandle inControl;
1796     if (!PyArg_ParseTuple(_args, "O&",
1797                           CtlObj_Convert, &inControl))
1798         return NULL;
1799     _rv = GetControlEventTarget(inControl);
1800     _res = Py_BuildValue("O&",
1801                          EventTargetRef_New, _rv);
1802     return _res;
1803 }
1804 
CarbonEvents_GetMenuEventTarget(PyObject * _self,PyObject * _args)1805 static PyObject *CarbonEvents_GetMenuEventTarget(PyObject *_self, PyObject *_args)
1806 {
1807     PyObject *_res = NULL;
1808     EventTargetRef _rv;
1809     MenuHandle inMenu;
1810     if (!PyArg_ParseTuple(_args, "O&",
1811                           MenuObj_Convert, &inMenu))
1812         return NULL;
1813     _rv = GetMenuEventTarget(inMenu);
1814     _res = Py_BuildValue("O&",
1815                          EventTargetRef_New, _rv);
1816     return _res;
1817 }
1818 
CarbonEvents_GetApplicationEventTarget(PyObject * _self,PyObject * _args)1819 static PyObject *CarbonEvents_GetApplicationEventTarget(PyObject *_self, PyObject *_args)
1820 {
1821     PyObject *_res = NULL;
1822     EventTargetRef _rv;
1823     if (!PyArg_ParseTuple(_args, ""))
1824         return NULL;
1825     _rv = GetApplicationEventTarget();
1826     _res = Py_BuildValue("O&",
1827                          EventTargetRef_New, _rv);
1828     return _res;
1829 }
1830 
CarbonEvents_GetUserFocusEventTarget(PyObject * _self,PyObject * _args)1831 static PyObject *CarbonEvents_GetUserFocusEventTarget(PyObject *_self, PyObject *_args)
1832 {
1833     PyObject *_res = NULL;
1834     EventTargetRef _rv;
1835     if (!PyArg_ParseTuple(_args, ""))
1836         return NULL;
1837     _rv = GetUserFocusEventTarget();
1838     _res = Py_BuildValue("O&",
1839                          EventTargetRef_New, _rv);
1840     return _res;
1841 }
1842 
CarbonEvents_GetEventDispatcherTarget(PyObject * _self,PyObject * _args)1843 static PyObject *CarbonEvents_GetEventDispatcherTarget(PyObject *_self, PyObject *_args)
1844 {
1845     PyObject *_res = NULL;
1846     EventTargetRef _rv;
1847     if (!PyArg_ParseTuple(_args, ""))
1848         return NULL;
1849     _rv = GetEventDispatcherTarget();
1850     _res = Py_BuildValue("O&",
1851                          EventTargetRef_New, _rv);
1852     return _res;
1853 }
1854 
CarbonEvents_RunApplicationEventLoop(PyObject * _self,PyObject * _args)1855 static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args)
1856 {
1857     PyObject *_res = NULL;
1858     if (!PyArg_ParseTuple(_args, ""))
1859         return NULL;
1860     RunApplicationEventLoop();
1861     Py_INCREF(Py_None);
1862     _res = Py_None;
1863     return _res;
1864 }
1865 
CarbonEvents_QuitApplicationEventLoop(PyObject * _self,PyObject * _args)1866 static PyObject *CarbonEvents_QuitApplicationEventLoop(PyObject *_self, PyObject *_args)
1867 {
1868     PyObject *_res = NULL;
1869     if (!PyArg_ParseTuple(_args, ""))
1870         return NULL;
1871     QuitApplicationEventLoop();
1872     Py_INCREF(Py_None);
1873     _res = Py_None;
1874     return _res;
1875 }
1876 
CarbonEvents_RunAppModalLoopForWindow(PyObject * _self,PyObject * _args)1877 static PyObject *CarbonEvents_RunAppModalLoopForWindow(PyObject *_self, PyObject *_args)
1878 {
1879     PyObject *_res = NULL;
1880     OSStatus _err;
1881     WindowPtr inWindow;
1882     if (!PyArg_ParseTuple(_args, "O&",
1883                           WinObj_Convert, &inWindow))
1884         return NULL;
1885     _err = RunAppModalLoopForWindow(inWindow);
1886     if (_err != noErr) return PyMac_Error(_err);
1887     Py_INCREF(Py_None);
1888     _res = Py_None;
1889     return _res;
1890 }
1891 
CarbonEvents_QuitAppModalLoopForWindow(PyObject * _self,PyObject * _args)1892 static PyObject *CarbonEvents_QuitAppModalLoopForWindow(PyObject *_self, PyObject *_args)
1893 {
1894     PyObject *_res = NULL;
1895     OSStatus _err;
1896     WindowPtr inWindow;
1897     if (!PyArg_ParseTuple(_args, "O&",
1898                           WinObj_Convert, &inWindow))
1899         return NULL;
1900     _err = QuitAppModalLoopForWindow(inWindow);
1901     if (_err != noErr) return PyMac_Error(_err);
1902     Py_INCREF(Py_None);
1903     _res = Py_None;
1904     return _res;
1905 }
1906 
CarbonEvents_BeginAppModalStateForWindow(PyObject * _self,PyObject * _args)1907 static PyObject *CarbonEvents_BeginAppModalStateForWindow(PyObject *_self, PyObject *_args)
1908 {
1909     PyObject *_res = NULL;
1910     OSStatus _err;
1911     WindowPtr inWindow;
1912     if (!PyArg_ParseTuple(_args, "O&",
1913                           WinObj_Convert, &inWindow))
1914         return NULL;
1915     _err = BeginAppModalStateForWindow(inWindow);
1916     if (_err != noErr) return PyMac_Error(_err);
1917     Py_INCREF(Py_None);
1918     _res = Py_None;
1919     return _res;
1920 }
1921 
CarbonEvents_EndAppModalStateForWindow(PyObject * _self,PyObject * _args)1922 static PyObject *CarbonEvents_EndAppModalStateForWindow(PyObject *_self, PyObject *_args)
1923 {
1924     PyObject *_res = NULL;
1925     OSStatus _err;
1926     WindowPtr inWindow;
1927     if (!PyArg_ParseTuple(_args, "O&",
1928                           WinObj_Convert, &inWindow))
1929         return NULL;
1930     _err = EndAppModalStateForWindow(inWindow);
1931     if (_err != noErr) return PyMac_Error(_err);
1932     Py_INCREF(Py_None);
1933     _res = Py_None;
1934     return _res;
1935 }
1936 
CarbonEvents_SetUserFocusWindow(PyObject * _self,PyObject * _args)1937 static PyObject *CarbonEvents_SetUserFocusWindow(PyObject *_self, PyObject *_args)
1938 {
1939     PyObject *_res = NULL;
1940     OSStatus _err;
1941     WindowPtr inWindow;
1942     if (!PyArg_ParseTuple(_args, "O&",
1943                           WinObj_Convert, &inWindow))
1944         return NULL;
1945     _err = SetUserFocusWindow(inWindow);
1946     if (_err != noErr) return PyMac_Error(_err);
1947     Py_INCREF(Py_None);
1948     _res = Py_None;
1949     return _res;
1950 }
1951 
CarbonEvents_GetUserFocusWindow(PyObject * _self,PyObject * _args)1952 static PyObject *CarbonEvents_GetUserFocusWindow(PyObject *_self, PyObject *_args)
1953 {
1954     PyObject *_res = NULL;
1955     WindowPtr _rv;
1956     if (!PyArg_ParseTuple(_args, ""))
1957         return NULL;
1958     _rv = GetUserFocusWindow();
1959     _res = Py_BuildValue("O&",
1960                          WinObj_New, _rv);
1961     return _res;
1962 }
1963 
CarbonEvents_SetWindowDefaultButton(PyObject * _self,PyObject * _args)1964 static PyObject *CarbonEvents_SetWindowDefaultButton(PyObject *_self, PyObject *_args)
1965 {
1966     PyObject *_res = NULL;
1967     OSStatus _err;
1968     WindowPtr inWindow;
1969     ControlHandle inControl;
1970     if (!PyArg_ParseTuple(_args, "O&O&",
1971                           WinObj_Convert, &inWindow,
1972                           CtlObj_Convert, &inControl))
1973         return NULL;
1974     _err = SetWindowDefaultButton(inWindow,
1975                                   inControl);
1976     if (_err != noErr) return PyMac_Error(_err);
1977     Py_INCREF(Py_None);
1978     _res = Py_None;
1979     return _res;
1980 }
1981 
CarbonEvents_SetWindowCancelButton(PyObject * _self,PyObject * _args)1982 static PyObject *CarbonEvents_SetWindowCancelButton(PyObject *_self, PyObject *_args)
1983 {
1984     PyObject *_res = NULL;
1985     OSStatus _err;
1986     WindowPtr inWindow;
1987     ControlHandle inControl;
1988     if (!PyArg_ParseTuple(_args, "O&O&",
1989                           WinObj_Convert, &inWindow,
1990                           CtlObj_Convert, &inControl))
1991         return NULL;
1992     _err = SetWindowCancelButton(inWindow,
1993                                  inControl);
1994     if (_err != noErr) return PyMac_Error(_err);
1995     Py_INCREF(Py_None);
1996     _res = Py_None;
1997     return _res;
1998 }
1999 
CarbonEvents_GetWindowDefaultButton(PyObject * _self,PyObject * _args)2000 static PyObject *CarbonEvents_GetWindowDefaultButton(PyObject *_self, PyObject *_args)
2001 {
2002     PyObject *_res = NULL;
2003     OSStatus _err;
2004     WindowPtr inWindow;
2005     ControlHandle outControl;
2006     if (!PyArg_ParseTuple(_args, "O&",
2007                           WinObj_Convert, &inWindow))
2008         return NULL;
2009     _err = GetWindowDefaultButton(inWindow,
2010                                   &outControl);
2011     if (_err != noErr) return PyMac_Error(_err);
2012     _res = Py_BuildValue("O&",
2013                          CtlObj_New, outControl);
2014     return _res;
2015 }
2016 
CarbonEvents_GetWindowCancelButton(PyObject * _self,PyObject * _args)2017 static PyObject *CarbonEvents_GetWindowCancelButton(PyObject *_self, PyObject *_args)
2018 {
2019     PyObject *_res = NULL;
2020     OSStatus _err;
2021     WindowPtr inWindow;
2022     ControlHandle outControl;
2023     if (!PyArg_ParseTuple(_args, "O&",
2024                           WinObj_Convert, &inWindow))
2025         return NULL;
2026     _err = GetWindowCancelButton(inWindow,
2027                                  &outControl);
2028     if (_err != noErr) return PyMac_Error(_err);
2029     _res = Py_BuildValue("O&",
2030                          CtlObj_New, outControl);
2031     return _res;
2032 }
2033 
CarbonEvents_RegisterEventHotKey(PyObject * _self,PyObject * _args)2034 static PyObject *CarbonEvents_RegisterEventHotKey(PyObject *_self, PyObject *_args)
2035 {
2036     PyObject *_res = NULL;
2037     OSStatus _err;
2038     UInt32 inHotKeyCode;
2039     UInt32 inHotKeyModifiers;
2040     EventHotKeyID inHotKeyID;
2041     EventTargetRef inTarget;
2042     OptionBits inOptions;
2043     EventHotKeyRef outRef;
2044     if (!PyArg_ParseTuple(_args, "llO&O&l",
2045                           &inHotKeyCode,
2046                           &inHotKeyModifiers,
2047                           EventHotKeyID_Convert, &inHotKeyID,
2048                           EventTargetRef_Convert, &inTarget,
2049                           &inOptions))
2050         return NULL;
2051     _err = RegisterEventHotKey(inHotKeyCode,
2052                                inHotKeyModifiers,
2053                                inHotKeyID,
2054                                inTarget,
2055                                inOptions,
2056                                &outRef);
2057     if (_err != noErr) return PyMac_Error(_err);
2058     _res = Py_BuildValue("O&",
2059                          EventHotKeyRef_New, outRef);
2060     return _res;
2061 }
2062 
2063 static PyMethodDef CarbonEvents_methods[] = {
2064     {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
2065      PyDoc_STR("() -> (EventLoopRef _rv)")},
2066     {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
2067      PyDoc_STR("() -> (EventLoopRef _rv)")},
2068     {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
2069      PyDoc_STR("(double inTimeout) -> None")},
2070     {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
2071      PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
2072     {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
2073      PyDoc_STR("() -> (EventQueueRef _rv)")},
2074     {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
2075      PyDoc_STR("() -> (EventQueueRef _rv)")},
2076     {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
2077      PyDoc_STR("() -> (double _rv)")},
2078     {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
2079      PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
2080     {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
2081      PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
2082     {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
2083      PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
2084     {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
2085      PyDoc_STR("() -> (double _rv)")},
2086     {"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
2087      PyDoc_STR("() -> (Boolean _rv)")},
2088     {"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
2089      PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
2090     {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
2091      PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
2092     {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
2093      PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
2094     {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
2095      PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
2096     {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
2097      PyDoc_STR("() -> (EventTargetRef _rv)")},
2098     {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
2099      PyDoc_STR("() -> (EventTargetRef _rv)")},
2100     {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
2101      PyDoc_STR("() -> (EventTargetRef _rv)")},
2102     {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
2103      PyDoc_STR("() -> None")},
2104     {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
2105      PyDoc_STR("() -> None")},
2106     {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
2107      PyDoc_STR("(WindowPtr inWindow) -> None")},
2108     {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
2109      PyDoc_STR("(WindowPtr inWindow) -> None")},
2110     {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
2111      PyDoc_STR("(WindowPtr inWindow) -> None")},
2112     {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
2113      PyDoc_STR("(WindowPtr inWindow) -> None")},
2114     {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
2115      PyDoc_STR("(WindowPtr inWindow) -> None")},
2116     {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
2117      PyDoc_STR("() -> (WindowPtr _rv)")},
2118     {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
2119      PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
2120     {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
2121      PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
2122     {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
2123      PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
2124     {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
2125      PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
2126     {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
2127      PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
2128     {NULL, NULL, 0}
2129 };
2130 
2131 #else /* APPLE_SUPPORTS_QUICKTIME */
2132 
2133 static PyMethodDef CarbonEvents_methods[] = {
2134     {NULL, NULL, 0}
2135 };
2136 
2137 #endif /* APPLE_SUPPORTS_QUICKTIME */
2138 
2139 
2140 
init_CarbonEvt(void)2141 void init_CarbonEvt(void)
2142 {
2143     PyObject *m;
2144 #if APPLE_SUPPORTS_QUICKTIME
2145     PyObject *d;
2146 #endif /* !APPLE_SUPPORTS_QUICKTIME */
2147 
2148 
2149     m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
2150 
2151 #if APPLE_SUPPORTS_QUICKTIME
2152     myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
2153     d = PyModule_GetDict(m);
2154     CarbonEvents_Error = PyMac_GetOSErrException();
2155     if (CarbonEvents_Error == NULL ||
2156         PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
2157         return;
2158     EventRef_Type.ob_type = &PyType_Type;
2159     if (PyType_Ready(&EventRef_Type) < 0) return;
2160     Py_INCREF(&EventRef_Type);
2161     PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
2162     /* Backward-compatible name */
2163     Py_INCREF(&EventRef_Type);
2164     PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
2165     EventQueueRef_Type.ob_type = &PyType_Type;
2166     if (PyType_Ready(&EventQueueRef_Type) < 0) return;
2167     Py_INCREF(&EventQueueRef_Type);
2168     PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
2169     /* Backward-compatible name */
2170     Py_INCREF(&EventQueueRef_Type);
2171     PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
2172     EventLoopRef_Type.ob_type = &PyType_Type;
2173     if (PyType_Ready(&EventLoopRef_Type) < 0) return;
2174     Py_INCREF(&EventLoopRef_Type);
2175     PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
2176     /* Backward-compatible name */
2177     Py_INCREF(&EventLoopRef_Type);
2178     PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
2179     EventLoopTimerRef_Type.ob_type = &PyType_Type;
2180     if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
2181     Py_INCREF(&EventLoopTimerRef_Type);
2182     PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
2183     /* Backward-compatible name */
2184     Py_INCREF(&EventLoopTimerRef_Type);
2185     PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
2186     EventHandlerRef_Type.ob_type = &PyType_Type;
2187     if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
2188     Py_INCREF(&EventHandlerRef_Type);
2189     PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
2190     /* Backward-compatible name */
2191     Py_INCREF(&EventHandlerRef_Type);
2192     PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
2193     EventHandlerCallRef_Type.ob_type = &PyType_Type;
2194     if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
2195     Py_INCREF(&EventHandlerCallRef_Type);
2196     PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
2197     /* Backward-compatible name */
2198     Py_INCREF(&EventHandlerCallRef_Type);
2199     PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
2200     EventTargetRef_Type.ob_type = &PyType_Type;
2201     if (PyType_Ready(&EventTargetRef_Type) < 0) return;
2202     Py_INCREF(&EventTargetRef_Type);
2203     PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
2204     /* Backward-compatible name */
2205     Py_INCREF(&EventTargetRef_Type);
2206     PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
2207     EventHotKeyRef_Type.ob_type = &PyType_Type;
2208     if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
2209     Py_INCREF(&EventHotKeyRef_Type);
2210     PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
2211     /* Backward-compatible name */
2212     Py_INCREF(&EventHotKeyRef_Type);
2213     PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type);
2214 #endif /* APPLE_SUPPORTS_QUICKTIME */
2215 }
2216 
2217 /* ===================== End module _CarbonEvt ====================== */
2218 
2219