Mac/Modules/carbonevt/_CarbonEvtmodule.c

   1
   2 /* ======================= Module _CarbonEvt ======================== */
   3
   4 #include "Python.h"
   5
   6 #ifndef __LP64__
   7
   8 #include "pymactoolbox.h"
   9
  10 /* Macro to test whether a weak-loaded CFM function exists */
  11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
  12         PyErr_SetString(PyExc_NotImplementedError, \
  13         "Not available in this shared library/OS version"); \
  14         return NULL; \
  15     }} while(0)
  16
  17
  18 #include <Carbon/Carbon.h>
  19
  20 extern int CFStringRef_New(CFStringRef *);
  21
  22 extern int CFStringRef_Convert(PyObject *, CFStringRef *);
  23 extern int CFBundleRef_Convert(PyObject *, CFBundleRef *);
  24
  25 int EventTargetRef_Convert(PyObject *, EventTargetRef *);
  26 PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself);
  27 PyObject *EventRef_New(EventRef itself);
  28
  29 /********** EventTypeSpec *******/
  30 static int
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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_DECREF(_self->ob_callback);
1055         _self->ob_callback = NULL;
1056         Py_INCREF(Py_None);
1057         _res = Py_None;
1058         return _res;
1059 }
1060
1061 static 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
1083 static 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
1098 PyTypeObject 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
1147 PyTypeObject EventHandlerCallRef_Type;
1148
1149 #define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type || PyObject_TypeCheck((x), &EventHandlerCallRef_Type))
1150
1151 typedef struct EventHandlerCallRefObject {
1152         PyObject_HEAD
1153         EventHandlerCallRef ob_itself;
1154 } EventHandlerCallRefObject;
1155
1156 PyObject *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
1165 int 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
1176 static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
1177 {
1178         /* Cleanup of self->ob_itself goes here */
1179         self->ob_type->tp_free((PyObject *)self);
1180 }
1181
1182 static 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
1198 static 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
1216 static 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
1231 PyTypeObject 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
1280 PyTypeObject EventTargetRef_Type;
1281
1282 #define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type || PyObject_TypeCheck((x), &EventTargetRef_Type))
1283
1284 typedef struct EventTargetRefObject {
1285         PyObject_HEAD
1286         EventTargetRef ob_itself;
1287 } EventTargetRefObject;
1288
1289 PyObject *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
1298 int 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
1309 static void EventTargetRef_dealloc(EventTargetRefObject *self)
1310 {
1311         /* Cleanup of self->ob_itself goes here */
1312         self->ob_type->tp_free((PyObject *)self);
1313 }
1314
1315 static 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
1328 static 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
1351 static 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
1371 static 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
1386 PyTypeObject 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
1435 PyTypeObject EventHotKeyRef_Type;
1436
1437 #define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type || PyObject_TypeCheck((x), &EventHotKeyRef_Type))
1438
1439 typedef struct EventHotKeyRefObject {
1440         PyObject_HEAD
1441         EventHotKeyRef ob_itself;
1442 } EventHotKeyRefObject;
1443
1444 PyObject *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
1453 int 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
1464 static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
1465 {
1466         /* Cleanup of self->ob_itself goes here */
1467         self->ob_type->tp_free((PyObject *)self);
1468 }
1469
1470 static 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
1483 static 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
1501 static 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
1516 PyTypeObject 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
1563 static 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
1575 static 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
1587 static 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
1602 static 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
1628 static 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
1640 static 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
1652 static 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
1664 static 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
1684 static 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
1713 static 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
1737 static 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
1749 static 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
1761 static 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
1778 static 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
1792 static 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
1806 static 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
1820 static 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
1832 static 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
1844 static 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
1856 static 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
1867 static 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
1878 static 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
1893 static 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
1908 static 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
1923 static 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
1938 static 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
1953 static 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
1965 static 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
1983 static 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
2001 static 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
2018 static 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
2035 static 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
2064 static 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
2134 static PyMethodDef CarbonEvents_methods[] = {
2135         {NULL, NULL, 0}
2136 };
2137
2138 #endif /* __LP64__ */
2139
2140
2141
2142 void 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