source: python/trunk/Mac/Modules/carbonevt/_CarbonEvtmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 68.3 KB
Line 
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
20extern int CFStringRef_New(CFStringRef *);
21
22extern int CFStringRef_Convert(PyObject *, CFStringRef *);
23extern int CFBundleRef_Convert(PyObject *, CFBundleRef *);
24
25int EventTargetRef_Convert(PyObject *, EventTargetRef *);
26PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself);
27PyObject *EventRef_New(EventRef itself);
28
29/********** EventTypeSpec *******/
30static int
31EventTypeSpec_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 */
45static PyObject*
46HIPoint_New(HIPoint *in)
47{
48 return Py_BuildValue("ff", in->x, in->y);
49}
50
51static int
52HIPoint_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
64static int
65EventHotKeyID_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
76static EventHandlerUPP myEventHandlerUPP;
77
78static pascal OSStatus
79myEventHandler(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
106static PyObject *CarbonEvents_Error;
107
108/* ---------------------- Object type EventRef ---------------------- */
109
110PyTypeObject EventRef_Type;
111
112#define EventRef_Check(x) ((x)->ob_type == &EventRef_Type || PyObject_TypeCheck((x), &EventRef_Type))
113
114typedef struct EventRefObject {
115 PyObject_HEAD
116 EventRef ob_itself;
117} EventRefObject;
118
119PyObject *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
128int 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
139static void EventRef_dealloc(EventRefObject *self)
140{
141 /* Cleanup of self->ob_itself goes here */
142 self->ob_type->tp_free((PyObject *)self);
143}
144
145static 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
157static 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
169static 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
180static 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
205static 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
217static 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
229static 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
241static 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
257static 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
269static 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
284static 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
299static 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
315static 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
349static 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
391static 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
406PyTypeObject 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
455PyTypeObject EventQueueRef_Type;
456
457#define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type || PyObject_TypeCheck((x), &EventQueueRef_Type))
458
459typedef struct EventQueueRefObject {
460 PyObject_HEAD
461 EventQueueRef ob_itself;
462} EventQueueRefObject;
463
464PyObject *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
473int 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
484static void EventQueueRef_dealloc(EventQueueRefObject *self)
485{
486 /* Cleanup of self->ob_itself goes here */
487 self->ob_type->tp_free((PyObject *)self);
488}
489
490static 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
509static 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
528static 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
541static 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
553static 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
569static 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
584static 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
612static 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
627PyTypeObject 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
676PyTypeObject EventLoopRef_Type;
677
678#define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type || PyObject_TypeCheck((x), &EventLoopRef_Type))
679
680typedef struct EventLoopRefObject {
681 PyObject_HEAD
682 EventLoopRef ob_itself;
683} EventLoopRefObject;
684
685PyObject *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
694int 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
705static void EventLoopRef_dealloc(EventLoopRefObject *self)
706{
707 /* Cleanup of self->ob_itself goes here */
708 self->ob_type->tp_free((PyObject *)self);
709}
710
711static 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
724static 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
742static 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
757PyTypeObject 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
806PyTypeObject EventLoopTimerRef_Type;
807
808#define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type || PyObject_TypeCheck((x), &EventLoopTimerRef_Type))
809
810typedef struct EventLoopTimerRefObject {
811 PyObject_HEAD
812 EventLoopTimerRef ob_itself;
813} EventLoopTimerRefObject;
814
815PyObject *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
824int 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
835static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)
836{
837 /* Cleanup of self->ob_itself goes here */
838 self->ob_type->tp_free((PyObject *)self);
839}
840
841static 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
854static 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
870static 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
890static 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
905PyTypeObject 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
954PyTypeObject EventHandlerRef_Type;
955
956#define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type || PyObject_TypeCheck((x), &EventHandlerRef_Type))
957
958typedef struct EventHandlerRefObject {
959 PyObject_HEAD
960 EventHandlerRef ob_itself;
961 PyObject *ob_callback;
962} EventHandlerRefObject;
963
964PyObject *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
974int 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
985static 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
994static 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
1017static 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
1040static 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_DECREF(_self->ob_callback);
1055 _self->ob_callback = NULL;
1056 Py_INCREF(Py_None);
1057 _res = Py_None;
1058 return _res;
1059}
1060
1061static PyMethodDef EventHandlerRef_methods[] = {
1062 {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
1063 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
1064 {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
1065 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
1066 {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
1067 PyDoc_STR("() -> None")},
1068 {NULL, NULL, 0}
1069};
1070
1071#define EventHandlerRef_getsetlist NULL
1072
1073
1074#define EventHandlerRef_compare NULL
1075
1076#define EventHandlerRef_repr NULL
1077
1078#define EventHandlerRef_hash NULL
1079#define EventHandlerRef_tp_init 0
1080
1081#define EventHandlerRef_tp_alloc PyType_GenericAlloc
1082
1083static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1084{
1085 PyObject *_self;
1086 EventHandlerRef itself;
1087 char *kw[] = {"itself", 0};
1088
1089 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;
1090 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1091 ((EventHandlerRefObject *)_self)->ob_itself = itself;
1092 return _self;
1093}
1094
1095#define EventHandlerRef_tp_free PyObject_Del
1096
1097
1098PyTypeObject EventHandlerRef_Type = {
1099 PyObject_HEAD_INIT(NULL)
1100 0, /*ob_size*/
1101 "_CarbonEvt.EventHandlerRef", /*tp_name*/
1102 sizeof(EventHandlerRefObject), /*tp_basicsize*/
1103 0, /*tp_itemsize*/
1104 /* methods */
1105 (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/
1106 0, /*tp_print*/
1107 (getattrfunc)0, /*tp_getattr*/
1108 (setattrfunc)0, /*tp_setattr*/
1109 (cmpfunc) EventHandlerRef_compare, /*tp_compare*/
1110 (reprfunc) EventHandlerRef_repr, /*tp_repr*/
1111 (PyNumberMethods *)0, /* tp_as_number */
1112 (PySequenceMethods *)0, /* tp_as_sequence */
1113 (PyMappingMethods *)0, /* tp_as_mapping */
1114 (hashfunc) EventHandlerRef_hash, /*tp_hash*/
1115 0, /*tp_call*/
1116 0, /*tp_str*/
1117 PyObject_GenericGetAttr, /*tp_getattro*/
1118 PyObject_GenericSetAttr, /*tp_setattro */
1119 0, /*tp_as_buffer*/
1120 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1121 0, /*tp_doc*/
1122 0, /*tp_traverse*/
1123 0, /*tp_clear*/
1124 0, /*tp_richcompare*/
1125 0, /*tp_weaklistoffset*/
1126 0, /*tp_iter*/
1127 0, /*tp_iternext*/
1128 EventHandlerRef_methods, /* tp_methods */
1129 0, /*tp_members*/
1130 EventHandlerRef_getsetlist, /*tp_getset*/
1131 0, /*tp_base*/
1132 0, /*tp_dict*/
1133 0, /*tp_descr_get*/
1134 0, /*tp_descr_set*/
1135 0, /*tp_dictoffset*/
1136 EventHandlerRef_tp_init, /* tp_init */
1137 EventHandlerRef_tp_alloc, /* tp_alloc */
1138 EventHandlerRef_tp_new, /* tp_new */
1139 EventHandlerRef_tp_free, /* tp_free */
1140};
1141
1142/* ---------------- End object type EventHandlerRef ----------------- */
1143
1144
1145/* ---------------- Object type EventHandlerCallRef ----------------- */
1146
1147PyTypeObject EventHandlerCallRef_Type;
1148
1149#define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type || PyObject_TypeCheck((x), &EventHandlerCallRef_Type))
1150
1151typedef struct EventHandlerCallRefObject {
1152 PyObject_HEAD
1153 EventHandlerCallRef ob_itself;
1154} EventHandlerCallRefObject;
1155
1156PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself)
1157{
1158 EventHandlerCallRefObject *it;
1159 it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type);
1160 if (it == NULL) return NULL;
1161 it->ob_itself = itself;
1162 return (PyObject *)it;
1163}
1164
1165int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself)
1166{
1167 if (!EventHandlerCallRef_Check(v))
1168 {
1169 PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required");
1170 return 0;
1171 }
1172 *p_itself = ((EventHandlerCallRefObject *)v)->ob_itself;
1173 return 1;
1174}
1175
1176static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
1177{
1178 /* Cleanup of self->ob_itself goes here */
1179 self->ob_type->tp_free((PyObject *)self);
1180}
1181
1182static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args)
1183{
1184 PyObject *_res = NULL;
1185 OSStatus _err;
1186 EventRef inEvent;
1187 if (!PyArg_ParseTuple(_args, "O&",
1188 EventRef_Convert, &inEvent))
1189 return NULL;
1190 _err = CallNextEventHandler(_self->ob_itself,
1191 inEvent);
1192 if (_err != noErr) return PyMac_Error(_err);
1193 Py_INCREF(Py_None);
1194 _res = Py_None;
1195 return _res;
1196}
1197
1198static PyMethodDef EventHandlerCallRef_methods[] = {
1199 {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
1200 PyDoc_STR("(EventRef inEvent) -> None")},
1201 {NULL, NULL, 0}
1202};
1203
1204#define EventHandlerCallRef_getsetlist NULL
1205
1206
1207#define EventHandlerCallRef_compare NULL
1208
1209#define EventHandlerCallRef_repr NULL
1210
1211#define EventHandlerCallRef_hash NULL
1212#define EventHandlerCallRef_tp_init 0
1213
1214#define EventHandlerCallRef_tp_alloc PyType_GenericAlloc
1215
1216static PyObject *EventHandlerCallRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1217{
1218 PyObject *_self;
1219 EventHandlerCallRef itself;
1220 char *kw[] = {"itself", 0};
1221
1222 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL;
1223 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1224 ((EventHandlerCallRefObject *)_self)->ob_itself = itself;
1225 return _self;
1226}
1227
1228#define EventHandlerCallRef_tp_free PyObject_Del
1229
1230
1231PyTypeObject EventHandlerCallRef_Type = {
1232 PyObject_HEAD_INIT(NULL)
1233 0, /*ob_size*/
1234 "_CarbonEvt.EventHandlerCallRef", /*tp_name*/
1235 sizeof(EventHandlerCallRefObject), /*tp_basicsize*/
1236 0, /*tp_itemsize*/
1237 /* methods */
1238 (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/
1239 0, /*tp_print*/
1240 (getattrfunc)0, /*tp_getattr*/
1241 (setattrfunc)0, /*tp_setattr*/
1242 (cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/
1243 (reprfunc) EventHandlerCallRef_repr, /*tp_repr*/
1244 (PyNumberMethods *)0, /* tp_as_number */
1245 (PySequenceMethods *)0, /* tp_as_sequence */
1246 (PyMappingMethods *)0, /* tp_as_mapping */
1247 (hashfunc) EventHandlerCallRef_hash, /*tp_hash*/
1248 0, /*tp_call*/
1249 0, /*tp_str*/
1250 PyObject_GenericGetAttr, /*tp_getattro*/
1251 PyObject_GenericSetAttr, /*tp_setattro */
1252 0, /*tp_as_buffer*/
1253 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1254 0, /*tp_doc*/
1255 0, /*tp_traverse*/
1256 0, /*tp_clear*/
1257 0, /*tp_richcompare*/
1258 0, /*tp_weaklistoffset*/
1259 0, /*tp_iter*/
1260 0, /*tp_iternext*/
1261 EventHandlerCallRef_methods, /* tp_methods */
1262 0, /*tp_members*/
1263 EventHandlerCallRef_getsetlist, /*tp_getset*/
1264 0, /*tp_base*/
1265 0, /*tp_dict*/
1266 0, /*tp_descr_get*/
1267 0, /*tp_descr_set*/
1268 0, /*tp_dictoffset*/
1269 EventHandlerCallRef_tp_init, /* tp_init */
1270 EventHandlerCallRef_tp_alloc, /* tp_alloc */
1271 EventHandlerCallRef_tp_new, /* tp_new */
1272 EventHandlerCallRef_tp_free, /* tp_free */
1273};
1274
1275/* -------------- End object type EventHandlerCallRef --------------- */
1276
1277
1278/* ------------------- Object type EventTargetRef ------------------- */
1279
1280PyTypeObject EventTargetRef_Type;
1281
1282#define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type || PyObject_TypeCheck((x), &EventTargetRef_Type))
1283
1284typedef struct EventTargetRefObject {
1285 PyObject_HEAD
1286 EventTargetRef ob_itself;
1287} EventTargetRefObject;
1288
1289PyObject *EventTargetRef_New(EventTargetRef itself)
1290{
1291 EventTargetRefObject *it;
1292 it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type);
1293 if (it == NULL) return NULL;
1294 it->ob_itself = itself;
1295 return (PyObject *)it;
1296}
1297
1298int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself)
1299{
1300 if (!EventTargetRef_Check(v))
1301 {
1302 PyErr_SetString(PyExc_TypeError, "EventTargetRef required");
1303 return 0;
1304 }
1305 *p_itself = ((EventTargetRefObject *)v)->ob_itself;
1306 return 1;
1307}
1308
1309static void EventTargetRef_dealloc(EventTargetRefObject *self)
1310{
1311 /* Cleanup of self->ob_itself goes here */
1312 self->ob_type->tp_free((PyObject *)self);
1313}
1314
1315static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args)
1316{
1317 PyObject *_res = NULL;
1318 OSStatus _err;
1319 if (!PyArg_ParseTuple(_args, ""))
1320 return NULL;
1321 _err = InstallStandardEventHandler(_self->ob_itself);
1322 if (_err != noErr) return PyMac_Error(_err);
1323 Py_INCREF(Py_None);
1324 _res = Py_None;
1325 return _res;
1326}
1327
1328static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, PyObject *_args)
1329{
1330 PyObject *_res = NULL;
1331
1332 EventTypeSpec inSpec;
1333 PyObject *callback;
1334 EventHandlerRef outRef;
1335 OSStatus _err;
1336
1337 if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))
1338 return NULL;
1339
1340 _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);
1341 if (_err != noErr) return PyMac_Error(_err);
1342
1343 _res = EventHandlerRef_New(outRef);
1344 if (_res != NULL) {
1345 ((EventHandlerRefObject*)_res)->ob_callback = callback;
1346 Py_INCREF(callback);
1347 }
1348 return _res;
1349}
1350
1351static PyMethodDef EventTargetRef_methods[] = {
1352 {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
1353 PyDoc_STR("() -> None")},
1354 {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
1355 PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
1356 {NULL, NULL, 0}
1357};
1358
1359#define EventTargetRef_getsetlist NULL
1360
1361
1362#define EventTargetRef_compare NULL
1363
1364#define EventTargetRef_repr NULL
1365
1366#define EventTargetRef_hash NULL
1367#define EventTargetRef_tp_init 0
1368
1369#define EventTargetRef_tp_alloc PyType_GenericAlloc
1370
1371static PyObject *EventTargetRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1372{
1373 PyObject *_self;
1374 EventTargetRef itself;
1375 char *kw[] = {"itself", 0};
1376
1377 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL;
1378 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1379 ((EventTargetRefObject *)_self)->ob_itself = itself;
1380 return _self;
1381}
1382
1383#define EventTargetRef_tp_free PyObject_Del
1384
1385
1386PyTypeObject EventTargetRef_Type = {
1387 PyObject_HEAD_INIT(NULL)
1388 0, /*ob_size*/
1389 "_CarbonEvt.EventTargetRef", /*tp_name*/
1390 sizeof(EventTargetRefObject), /*tp_basicsize*/
1391 0, /*tp_itemsize*/
1392 /* methods */
1393 (destructor) EventTargetRef_dealloc, /*tp_dealloc*/
1394 0, /*tp_print*/
1395 (getattrfunc)0, /*tp_getattr*/
1396 (setattrfunc)0, /*tp_setattr*/
1397 (cmpfunc) EventTargetRef_compare, /*tp_compare*/
1398 (reprfunc) EventTargetRef_repr, /*tp_repr*/
1399 (PyNumberMethods *)0, /* tp_as_number */
1400 (PySequenceMethods *)0, /* tp_as_sequence */
1401 (PyMappingMethods *)0, /* tp_as_mapping */
1402 (hashfunc) EventTargetRef_hash, /*tp_hash*/
1403 0, /*tp_call*/
1404 0, /*tp_str*/
1405 PyObject_GenericGetAttr, /*tp_getattro*/
1406 PyObject_GenericSetAttr, /*tp_setattro */
1407 0, /*tp_as_buffer*/
1408 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1409 0, /*tp_doc*/
1410 0, /*tp_traverse*/
1411 0, /*tp_clear*/
1412 0, /*tp_richcompare*/
1413 0, /*tp_weaklistoffset*/
1414 0, /*tp_iter*/
1415 0, /*tp_iternext*/
1416 EventTargetRef_methods, /* tp_methods */
1417 0, /*tp_members*/
1418 EventTargetRef_getsetlist, /*tp_getset*/
1419 0, /*tp_base*/
1420 0, /*tp_dict*/
1421 0, /*tp_descr_get*/
1422 0, /*tp_descr_set*/
1423 0, /*tp_dictoffset*/
1424 EventTargetRef_tp_init, /* tp_init */
1425 EventTargetRef_tp_alloc, /* tp_alloc */
1426 EventTargetRef_tp_new, /* tp_new */
1427 EventTargetRef_tp_free, /* tp_free */
1428};
1429
1430/* ----------------- End object type EventTargetRef ----------------- */
1431
1432
1433/* ------------------- Object type EventHotKeyRef ------------------- */
1434
1435PyTypeObject EventHotKeyRef_Type;
1436
1437#define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type || PyObject_TypeCheck((x), &EventHotKeyRef_Type))
1438
1439typedef struct EventHotKeyRefObject {
1440 PyObject_HEAD
1441 EventHotKeyRef ob_itself;
1442} EventHotKeyRefObject;
1443
1444PyObject *EventHotKeyRef_New(EventHotKeyRef itself)
1445{
1446 EventHotKeyRefObject *it;
1447 it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type);
1448 if (it == NULL) return NULL;
1449 it->ob_itself = itself;
1450 return (PyObject *)it;
1451}
1452
1453int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself)
1454{
1455 if (!EventHotKeyRef_Check(v))
1456 {
1457 PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required");
1458 return 0;
1459 }
1460 *p_itself = ((EventHotKeyRefObject *)v)->ob_itself;
1461 return 1;
1462}
1463
1464static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
1465{
1466 /* Cleanup of self->ob_itself goes here */
1467 self->ob_type->tp_free((PyObject *)self);
1468}
1469
1470static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args)
1471{
1472 PyObject *_res = NULL;
1473 OSStatus _err;
1474 if (!PyArg_ParseTuple(_args, ""))
1475 return NULL;
1476 _err = UnregisterEventHotKey(_self->ob_itself);
1477 if (_err != noErr) return PyMac_Error(_err);
1478 Py_INCREF(Py_None);
1479 _res = Py_None;
1480 return _res;
1481}
1482
1483static PyMethodDef EventHotKeyRef_methods[] = {
1484 {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
1485 PyDoc_STR("() -> None")},
1486 {NULL, NULL, 0}
1487};
1488
1489#define EventHotKeyRef_getsetlist NULL
1490
1491
1492#define EventHotKeyRef_compare NULL
1493
1494#define EventHotKeyRef_repr NULL
1495
1496#define EventHotKeyRef_hash NULL
1497#define EventHotKeyRef_tp_init 0
1498
1499#define EventHotKeyRef_tp_alloc PyType_GenericAlloc
1500
1501static PyObject *EventHotKeyRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1502{
1503 PyObject *_self;
1504 EventHotKeyRef itself;
1505 char *kw[] = {"itself", 0};
1506
1507 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL;
1508 if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1509 ((EventHotKeyRefObject *)_self)->ob_itself = itself;
1510 return _self;
1511}
1512
1513#define EventHotKeyRef_tp_free PyObject_Del
1514
1515
1516PyTypeObject EventHotKeyRef_Type = {
1517 PyObject_HEAD_INIT(NULL)
1518 0, /*ob_size*/
1519 "_CarbonEvt.EventHotKeyRef", /*tp_name*/
1520 sizeof(EventHotKeyRefObject), /*tp_basicsize*/
1521 0, /*tp_itemsize*/
1522 /* methods */
1523 (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/
1524 0, /*tp_print*/
1525 (getattrfunc)0, /*tp_getattr*/
1526 (setattrfunc)0, /*tp_setattr*/
1527 (cmpfunc) EventHotKeyRef_compare, /*tp_compare*/
1528 (reprfunc) EventHotKeyRef_repr, /*tp_repr*/
1529 (PyNumberMethods *)0, /* tp_as_number */
1530 (PySequenceMethods *)0, /* tp_as_sequence */
1531 (PyMappingMethods *)0, /* tp_as_mapping */
1532 (hashfunc) EventHotKeyRef_hash, /*tp_hash*/
1533 0, /*tp_call*/
1534 0, /*tp_str*/
1535 PyObject_GenericGetAttr, /*tp_getattro*/
1536 PyObject_GenericSetAttr, /*tp_setattro */
1537 0, /*tp_as_buffer*/
1538 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1539 0, /*tp_doc*/
1540 0, /*tp_traverse*/
1541 0, /*tp_clear*/
1542 0, /*tp_richcompare*/
1543 0, /*tp_weaklistoffset*/
1544 0, /*tp_iter*/
1545 0, /*tp_iternext*/
1546 EventHotKeyRef_methods, /* tp_methods */
1547 0, /*tp_members*/
1548 EventHotKeyRef_getsetlist, /*tp_getset*/
1549 0, /*tp_base*/
1550 0, /*tp_dict*/
1551 0, /*tp_descr_get*/
1552 0, /*tp_descr_set*/
1553 0, /*tp_dictoffset*/
1554 EventHotKeyRef_tp_init, /* tp_init */
1555 EventHotKeyRef_tp_alloc, /* tp_alloc */
1556 EventHotKeyRef_tp_new, /* tp_new */
1557 EventHotKeyRef_tp_free, /* tp_free */
1558};
1559
1560/* ----------------- End object type EventHotKeyRef ----------------- */
1561
1562
1563static PyObject *CarbonEvents_GetCurrentEventLoop(PyObject *_self, PyObject *_args)
1564{
1565 PyObject *_res = NULL;
1566 EventLoopRef _rv;
1567 if (!PyArg_ParseTuple(_args, ""))
1568 return NULL;
1569 _rv = GetCurrentEventLoop();
1570 _res = Py_BuildValue("O&",
1571 EventLoopRef_New, _rv);
1572 return _res;
1573}
1574
1575static PyObject *CarbonEvents_GetMainEventLoop(PyObject *_self, PyObject *_args)
1576{
1577 PyObject *_res = NULL;
1578 EventLoopRef _rv;
1579 if (!PyArg_ParseTuple(_args, ""))
1580 return NULL;
1581 _rv = GetMainEventLoop();
1582 _res = Py_BuildValue("O&",
1583 EventLoopRef_New, _rv);
1584 return _res;
1585}
1586
1587static PyObject *CarbonEvents_RunCurrentEventLoop(PyObject *_self, PyObject *_args)
1588{
1589 PyObject *_res = NULL;
1590 OSStatus _err;
1591 double inTimeout;
1592 if (!PyArg_ParseTuple(_args, "d",
1593 &inTimeout))
1594 return NULL;
1595 _err = RunCurrentEventLoop(inTimeout);
1596 if (_err != noErr) return PyMac_Error(_err);
1597 Py_INCREF(Py_None);
1598 _res = Py_None;
1599 return _res;
1600}
1601
1602static PyObject *CarbonEvents_ReceiveNextEvent(PyObject *_self, PyObject *_args)
1603{
1604 PyObject *_res = NULL;
1605 OSStatus _err;
1606 UInt32 inNumTypes;
1607 EventTypeSpec inList;
1608 double inTimeout;
1609 Boolean inPullEvent;
1610 EventRef outEvent;
1611 if (!PyArg_ParseTuple(_args, "lO&db",
1612 &inNumTypes,
1613 EventTypeSpec_Convert, &inList,
1614 &inTimeout,
1615 &inPullEvent))
1616 return NULL;
1617 _err = ReceiveNextEvent(inNumTypes,
1618 &inList,
1619 inTimeout,
1620 inPullEvent,
1621 &outEvent);
1622 if (_err != noErr) return PyMac_Error(_err);
1623 _res = Py_BuildValue("O&",
1624 EventRef_New, outEvent);
1625 return _res;
1626}
1627
1628static PyObject *CarbonEvents_GetCurrentEventQueue(PyObject *_self, PyObject *_args)
1629{
1630 PyObject *_res = NULL;
1631 EventQueueRef _rv;
1632 if (!PyArg_ParseTuple(_args, ""))
1633 return NULL;
1634 _rv = GetCurrentEventQueue();
1635 _res = Py_BuildValue("O&",
1636 EventQueueRef_New, _rv);
1637 return _res;
1638}
1639
1640static PyObject *CarbonEvents_GetMainEventQueue(PyObject *_self, PyObject *_args)
1641{
1642 PyObject *_res = NULL;
1643 EventQueueRef _rv;
1644 if (!PyArg_ParseTuple(_args, ""))
1645 return NULL;
1646 _rv = GetMainEventQueue();
1647 _res = Py_BuildValue("O&",
1648 EventQueueRef_New, _rv);
1649 return _res;
1650}
1651
1652static PyObject *CarbonEvents_GetCurrentEventTime(PyObject *_self, PyObject *_args)
1653{
1654 PyObject *_res = NULL;
1655 double _rv;
1656 if (!PyArg_ParseTuple(_args, ""))
1657 return NULL;
1658 _rv = GetCurrentEventTime();
1659 _res = Py_BuildValue("d",
1660 _rv);
1661 return _res;
1662}
1663
1664static PyObject *CarbonEvents_TrackMouseLocation(PyObject *_self, PyObject *_args)
1665{
1666 PyObject *_res = NULL;
1667 OSStatus _err;
1668 GrafPtr inPort;
1669 Point outPt;
1670 UInt16 outResult;
1671 if (!PyArg_ParseTuple(_args, "O&",
1672 GrafObj_Convert, &inPort))
1673 return NULL;
1674 _err = TrackMouseLocation(inPort,
1675 &outPt,
1676 &outResult);
1677 if (_err != noErr) return PyMac_Error(_err);
1678 _res = Py_BuildValue("O&H",
1679 PyMac_BuildPoint, outPt,
1680 outResult);
1681 return _res;
1682}
1683
1684static PyObject *CarbonEvents_TrackMouseLocationWithOptions(PyObject *_self, PyObject *_args)
1685{
1686 PyObject *_res = NULL;
1687 OSStatus _err;
1688 GrafPtr inPort;
1689 OptionBits inOptions;
1690 double inTimeout;
1691 Point outPt;
1692 UInt32 outModifiers;
1693 UInt16 outResult;
1694 if (!PyArg_ParseTuple(_args, "O&ld",
1695 GrafObj_Convert, &inPort,
1696 &inOptions,
1697 &inTimeout))
1698 return NULL;
1699 _err = TrackMouseLocationWithOptions(inPort,
1700 inOptions,
1701 inTimeout,
1702 &outPt,
1703 &outModifiers,
1704 &outResult);
1705 if (_err != noErr) return PyMac_Error(_err);
1706 _res = Py_BuildValue("O&lH",
1707 PyMac_BuildPoint, outPt,
1708 outModifiers,
1709 outResult);
1710 return _res;
1711}
1712
1713static PyObject *CarbonEvents_TrackMouseRegion(PyObject *_self, PyObject *_args)
1714{
1715 PyObject *_res = NULL;
1716 OSStatus _err;
1717 GrafPtr inPort;
1718 RgnHandle inRegion;
1719 Boolean ioWasInRgn;
1720 UInt16 outResult;
1721 if (!PyArg_ParseTuple(_args, "O&O&b",
1722 GrafObj_Convert, &inPort,
1723 ResObj_Convert, &inRegion,
1724 &ioWasInRgn))
1725 return NULL;
1726 _err = TrackMouseRegion(inPort,
1727 inRegion,
1728 &ioWasInRgn,
1729 &outResult);
1730 if (_err != noErr) return PyMac_Error(_err);
1731 _res = Py_BuildValue("bH",
1732 ioWasInRgn,
1733 outResult);
1734 return _res;
1735}
1736
1737static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_args)
1738{
1739 PyObject *_res = NULL;
1740 double _rv;
1741 if (!PyArg_ParseTuple(_args, ""))
1742 return NULL;
1743 _rv = GetLastUserEventTime();
1744 _res = Py_BuildValue("d",
1745 _rv);
1746 return _res;
1747}
1748
1749static PyObject *CarbonEvents_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
1750{
1751 PyObject *_res = NULL;
1752 Boolean _rv;
1753 if (!PyArg_ParseTuple(_args, ""))
1754 return NULL;
1755 _rv = IsMouseCoalescingEnabled();
1756 _res = Py_BuildValue("b",
1757 _rv);
1758 return _res;
1759}
1760
1761static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
1762{
1763 PyObject *_res = NULL;
1764 OSStatus _err;
1765 Boolean inNewState;
1766 Boolean outOldState;
1767 if (!PyArg_ParseTuple(_args, "b",
1768 &inNewState))
1769 return NULL;
1770 _err = SetMouseCoalescingEnabled(inNewState,
1771 &outOldState);
1772 if (_err != noErr) return PyMac_Error(_err);
1773 _res = Py_BuildValue("b",
1774 outOldState);
1775 return _res;
1776}
1777
1778static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args)
1779{
1780 PyObject *_res = NULL;
1781 EventTargetRef _rv;
1782 WindowPtr inWindow;
1783 if (!PyArg_ParseTuple(_args, "O&",
1784 WinObj_Convert, &inWindow))
1785 return NULL;
1786 _rv = GetWindowEventTarget(inWindow);
1787 _res = Py_BuildValue("O&",
1788 EventTargetRef_New, _rv);
1789 return _res;
1790}
1791
1792static PyObject *CarbonEvents_GetControlEventTarget(PyObject *_self, PyObject *_args)
1793{
1794 PyObject *_res = NULL;
1795 EventTargetRef _rv;
1796 ControlHandle inControl;
1797 if (!PyArg_ParseTuple(_args, "O&",
1798 CtlObj_Convert, &inControl))
1799 return NULL;
1800 _rv = GetControlEventTarget(inControl);
1801 _res = Py_BuildValue("O&",
1802 EventTargetRef_New, _rv);
1803 return _res;
1804}
1805
1806static PyObject *CarbonEvents_GetMenuEventTarget(PyObject *_self, PyObject *_args)
1807{
1808 PyObject *_res = NULL;
1809 EventTargetRef _rv;
1810 MenuHandle inMenu;
1811 if (!PyArg_ParseTuple(_args, "O&",
1812 MenuObj_Convert, &inMenu))
1813 return NULL;
1814 _rv = GetMenuEventTarget(inMenu);
1815 _res = Py_BuildValue("O&",
1816 EventTargetRef_New, _rv);
1817 return _res;
1818}
1819
1820static PyObject *CarbonEvents_GetApplicationEventTarget(PyObject *_self, PyObject *_args)
1821{
1822 PyObject *_res = NULL;
1823 EventTargetRef _rv;
1824 if (!PyArg_ParseTuple(_args, ""))
1825 return NULL;
1826 _rv = GetApplicationEventTarget();
1827 _res = Py_BuildValue("O&",
1828 EventTargetRef_New, _rv);
1829 return _res;
1830}
1831
1832static PyObject *CarbonEvents_GetUserFocusEventTarget(PyObject *_self, PyObject *_args)
1833{
1834 PyObject *_res = NULL;
1835 EventTargetRef _rv;
1836 if (!PyArg_ParseTuple(_args, ""))
1837 return NULL;
1838 _rv = GetUserFocusEventTarget();
1839 _res = Py_BuildValue("O&",
1840 EventTargetRef_New, _rv);
1841 return _res;
1842}
1843
1844static PyObject *CarbonEvents_GetEventDispatcherTarget(PyObject *_self, PyObject *_args)
1845{
1846 PyObject *_res = NULL;
1847 EventTargetRef _rv;
1848 if (!PyArg_ParseTuple(_args, ""))
1849 return NULL;
1850 _rv = GetEventDispatcherTarget();
1851 _res = Py_BuildValue("O&",
1852 EventTargetRef_New, _rv);
1853 return _res;
1854}
1855
1856static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args)
1857{
1858 PyObject *_res = NULL;
1859 if (!PyArg_ParseTuple(_args, ""))
1860 return NULL;
1861 RunApplicationEventLoop();
1862 Py_INCREF(Py_None);
1863 _res = Py_None;
1864 return _res;
1865}
1866
1867static PyObject *CarbonEvents_QuitApplicationEventLoop(PyObject *_self, PyObject *_args)
1868{
1869 PyObject *_res = NULL;
1870 if (!PyArg_ParseTuple(_args, ""))
1871 return NULL;
1872 QuitApplicationEventLoop();
1873 Py_INCREF(Py_None);
1874 _res = Py_None;
1875 return _res;
1876}
1877
1878static PyObject *CarbonEvents_RunAppModalLoopForWindow(PyObject *_self, PyObject *_args)
1879{
1880 PyObject *_res = NULL;
1881 OSStatus _err;
1882 WindowPtr inWindow;
1883 if (!PyArg_ParseTuple(_args, "O&",
1884 WinObj_Convert, &inWindow))
1885 return NULL;
1886 _err = RunAppModalLoopForWindow(inWindow);
1887 if (_err != noErr) return PyMac_Error(_err);
1888 Py_INCREF(Py_None);
1889 _res = Py_None;
1890 return _res;
1891}
1892
1893static PyObject *CarbonEvents_QuitAppModalLoopForWindow(PyObject *_self, PyObject *_args)
1894{
1895 PyObject *_res = NULL;
1896 OSStatus _err;
1897 WindowPtr inWindow;
1898 if (!PyArg_ParseTuple(_args, "O&",
1899 WinObj_Convert, &inWindow))
1900 return NULL;
1901 _err = QuitAppModalLoopForWindow(inWindow);
1902 if (_err != noErr) return PyMac_Error(_err);
1903 Py_INCREF(Py_None);
1904 _res = Py_None;
1905 return _res;
1906}
1907
1908static PyObject *CarbonEvents_BeginAppModalStateForWindow(PyObject *_self, PyObject *_args)
1909{
1910 PyObject *_res = NULL;
1911 OSStatus _err;
1912 WindowPtr inWindow;
1913 if (!PyArg_ParseTuple(_args, "O&",
1914 WinObj_Convert, &inWindow))
1915 return NULL;
1916 _err = BeginAppModalStateForWindow(inWindow);
1917 if (_err != noErr) return PyMac_Error(_err);
1918 Py_INCREF(Py_None);
1919 _res = Py_None;
1920 return _res;
1921}
1922
1923static PyObject *CarbonEvents_EndAppModalStateForWindow(PyObject *_self, PyObject *_args)
1924{
1925 PyObject *_res = NULL;
1926 OSStatus _err;
1927 WindowPtr inWindow;
1928 if (!PyArg_ParseTuple(_args, "O&",
1929 WinObj_Convert, &inWindow))
1930 return NULL;
1931 _err = EndAppModalStateForWindow(inWindow);
1932 if (_err != noErr) return PyMac_Error(_err);
1933 Py_INCREF(Py_None);
1934 _res = Py_None;
1935 return _res;
1936}
1937
1938static PyObject *CarbonEvents_SetUserFocusWindow(PyObject *_self, PyObject *_args)
1939{
1940 PyObject *_res = NULL;
1941 OSStatus _err;
1942 WindowPtr inWindow;
1943 if (!PyArg_ParseTuple(_args, "O&",
1944 WinObj_Convert, &inWindow))
1945 return NULL;
1946 _err = SetUserFocusWindow(inWindow);
1947 if (_err != noErr) return PyMac_Error(_err);
1948 Py_INCREF(Py_None);
1949 _res = Py_None;
1950 return _res;
1951}
1952
1953static PyObject *CarbonEvents_GetUserFocusWindow(PyObject *_self, PyObject *_args)
1954{
1955 PyObject *_res = NULL;
1956 WindowPtr _rv;
1957 if (!PyArg_ParseTuple(_args, ""))
1958 return NULL;
1959 _rv = GetUserFocusWindow();
1960 _res = Py_BuildValue("O&",
1961 WinObj_New, _rv);
1962 return _res;
1963}
1964
1965static PyObject *CarbonEvents_SetWindowDefaultButton(PyObject *_self, PyObject *_args)
1966{
1967 PyObject *_res = NULL;
1968 OSStatus _err;
1969 WindowPtr inWindow;
1970 ControlHandle inControl;
1971 if (!PyArg_ParseTuple(_args, "O&O&",
1972 WinObj_Convert, &inWindow,
1973 CtlObj_Convert, &inControl))
1974 return NULL;
1975 _err = SetWindowDefaultButton(inWindow,
1976 inControl);
1977 if (_err != noErr) return PyMac_Error(_err);
1978 Py_INCREF(Py_None);
1979 _res = Py_None;
1980 return _res;
1981}
1982
1983static PyObject *CarbonEvents_SetWindowCancelButton(PyObject *_self, PyObject *_args)
1984{
1985 PyObject *_res = NULL;
1986 OSStatus _err;
1987 WindowPtr inWindow;
1988 ControlHandle inControl;
1989 if (!PyArg_ParseTuple(_args, "O&O&",
1990 WinObj_Convert, &inWindow,
1991 CtlObj_Convert, &inControl))
1992 return NULL;
1993 _err = SetWindowCancelButton(inWindow,
1994 inControl);
1995 if (_err != noErr) return PyMac_Error(_err);
1996 Py_INCREF(Py_None);
1997 _res = Py_None;
1998 return _res;
1999}
2000
2001static PyObject *CarbonEvents_GetWindowDefaultButton(PyObject *_self, PyObject *_args)
2002{
2003 PyObject *_res = NULL;
2004 OSStatus _err;
2005 WindowPtr inWindow;
2006 ControlHandle outControl;
2007 if (!PyArg_ParseTuple(_args, "O&",
2008 WinObj_Convert, &inWindow))
2009 return NULL;
2010 _err = GetWindowDefaultButton(inWindow,
2011 &outControl);
2012 if (_err != noErr) return PyMac_Error(_err);
2013 _res = Py_BuildValue("O&",
2014 CtlObj_New, outControl);
2015 return _res;
2016}
2017
2018static PyObject *CarbonEvents_GetWindowCancelButton(PyObject *_self, PyObject *_args)
2019{
2020 PyObject *_res = NULL;
2021 OSStatus _err;
2022 WindowPtr inWindow;
2023 ControlHandle outControl;
2024 if (!PyArg_ParseTuple(_args, "O&",
2025 WinObj_Convert, &inWindow))
2026 return NULL;
2027 _err = GetWindowCancelButton(inWindow,
2028 &outControl);
2029 if (_err != noErr) return PyMac_Error(_err);
2030 _res = Py_BuildValue("O&",
2031 CtlObj_New, outControl);
2032 return _res;
2033}
2034
2035static PyObject *CarbonEvents_RegisterEventHotKey(PyObject *_self, PyObject *_args)
2036{
2037 PyObject *_res = NULL;
2038 OSStatus _err;
2039 UInt32 inHotKeyCode;
2040 UInt32 inHotKeyModifiers;
2041 EventHotKeyID inHotKeyID;
2042 EventTargetRef inTarget;
2043 OptionBits inOptions;
2044 EventHotKeyRef outRef;
2045 if (!PyArg_ParseTuple(_args, "llO&O&l",
2046 &inHotKeyCode,
2047 &inHotKeyModifiers,
2048 EventHotKeyID_Convert, &inHotKeyID,
2049 EventTargetRef_Convert, &inTarget,
2050 &inOptions))
2051 return NULL;
2052 _err = RegisterEventHotKey(inHotKeyCode,
2053 inHotKeyModifiers,
2054 inHotKeyID,
2055 inTarget,
2056 inOptions,
2057 &outRef);
2058 if (_err != noErr) return PyMac_Error(_err);
2059 _res = Py_BuildValue("O&",
2060 EventHotKeyRef_New, outRef);
2061 return _res;
2062}
2063
2064static PyMethodDef CarbonEvents_methods[] = {
2065 {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
2066 PyDoc_STR("() -> (EventLoopRef _rv)")},
2067 {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
2068 PyDoc_STR("() -> (EventLoopRef _rv)")},
2069 {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
2070 PyDoc_STR("(double inTimeout) -> None")},
2071 {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
2072 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
2073 {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
2074 PyDoc_STR("() -> (EventQueueRef _rv)")},
2075 {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
2076 PyDoc_STR("() -> (EventQueueRef _rv)")},
2077 {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
2078 PyDoc_STR("() -> (double _rv)")},
2079 {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
2080 PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
2081 {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
2082 PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
2083 {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
2084 PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
2085 {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
2086 PyDoc_STR("() -> (double _rv)")},
2087 {"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
2088 PyDoc_STR("() -> (Boolean _rv)")},
2089 {"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
2090 PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
2091 {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
2092 PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
2093 {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
2094 PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
2095 {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
2096 PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
2097 {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
2098 PyDoc_STR("() -> (EventTargetRef _rv)")},
2099 {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
2100 PyDoc_STR("() -> (EventTargetRef _rv)")},
2101 {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
2102 PyDoc_STR("() -> (EventTargetRef _rv)")},
2103 {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
2104 PyDoc_STR("() -> None")},
2105 {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
2106 PyDoc_STR("() -> None")},
2107 {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
2108 PyDoc_STR("(WindowPtr inWindow) -> None")},
2109 {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
2110 PyDoc_STR("(WindowPtr inWindow) -> None")},
2111 {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
2112 PyDoc_STR("(WindowPtr inWindow) -> None")},
2113 {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
2114 PyDoc_STR("(WindowPtr inWindow) -> None")},
2115 {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
2116 PyDoc_STR("(WindowPtr inWindow) -> None")},
2117 {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
2118 PyDoc_STR("() -> (WindowPtr _rv)")},
2119 {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
2120 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
2121 {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
2122 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
2123 {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
2124 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
2125 {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
2126 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
2127 {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
2128 PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
2129 {NULL, NULL, 0}
2130};
2131
2132#else /* __LP64__ */
2133
2134static PyMethodDef CarbonEvents_methods[] = {
2135 {NULL, NULL, 0}
2136};
2137
2138#endif /* __LP64__ */
2139
2140
2141
2142void init_CarbonEvt(void)
2143{
2144 PyObject *m;
2145#ifndef __LP64__
2146 PyObject *d;
2147#endif /* !__LP64__ */
2148
2149
2150 m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
2151
2152#ifndef __LP64__
2153 myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
2154 d = PyModule_GetDict(m);
2155 CarbonEvents_Error = PyMac_GetOSErrException();
2156 if (CarbonEvents_Error == NULL ||
2157 PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
2158 return;
2159 EventRef_Type.ob_type = &PyType_Type;
2160 if (PyType_Ready(&EventRef_Type) < 0) return;
2161 Py_INCREF(&EventRef_Type);
2162 PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
2163 /* Backward-compatible name */
2164 Py_INCREF(&EventRef_Type);
2165 PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
2166 EventQueueRef_Type.ob_type = &PyType_Type;
2167 if (PyType_Ready(&EventQueueRef_Type) < 0) return;
2168 Py_INCREF(&EventQueueRef_Type);
2169 PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
2170 /* Backward-compatible name */
2171 Py_INCREF(&EventQueueRef_Type);
2172 PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
2173 EventLoopRef_Type.ob_type = &PyType_Type;
2174 if (PyType_Ready(&EventLoopRef_Type) < 0) return;
2175 Py_INCREF(&EventLoopRef_Type);
2176 PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
2177 /* Backward-compatible name */
2178 Py_INCREF(&EventLoopRef_Type);
2179 PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
2180 EventLoopTimerRef_Type.ob_type = &PyType_Type;
2181 if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
2182 Py_INCREF(&EventLoopTimerRef_Type);
2183 PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
2184 /* Backward-compatible name */
2185 Py_INCREF(&EventLoopTimerRef_Type);
2186 PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
2187 EventHandlerRef_Type.ob_type = &PyType_Type;
2188 if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
2189 Py_INCREF(&EventHandlerRef_Type);
2190 PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
2191 /* Backward-compatible name */
2192 Py_INCREF(&EventHandlerRef_Type);
2193 PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
2194 EventHandlerCallRef_Type.ob_type = &PyType_Type;
2195 if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
2196 Py_INCREF(&EventHandlerCallRef_Type);
2197 PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
2198 /* Backward-compatible name */
2199 Py_INCREF(&EventHandlerCallRef_Type);
2200 PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
2201 EventTargetRef_Type.ob_type = &PyType_Type;
2202 if (PyType_Ready(&EventTargetRef_Type) < 0) return;
2203 Py_INCREF(&EventTargetRef_Type);
2204 PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
2205 /* Backward-compatible name */
2206 Py_INCREF(&EventTargetRef_Type);
2207 PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
2208 EventHotKeyRef_Type.ob_type = &PyType_Type;
2209 if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
2210 Py_INCREF(&EventHotKeyRef_Type);
2211 PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
2212 /* Backward-compatible name */
2213 Py_INCREF(&EventHotKeyRef_Type);
2214 PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type);
2215#endif /* !__LP64__ */
2216}
2217
2218/* ===================== End module _CarbonEvt ====================== */
2219
Note: See TracBrowser for help on using the repository browser.