Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (12 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Mac/Modules/carbonevt/_CarbonEvtmodule.c

    r2 r391  
    1010/* Macro to test whether a weak-loaded CFM function exists */
    1111#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; \
     12    PyErr_SetString(PyExc_NotImplementedError, \
     13    "Not available in this shared library/OS version"); \
     14    return NULL; \
    1515    }} while(0)
    1616
    … …  
    2828
    2929/********** EventTypeSpec *******/
    30 static PyObject*
    31 EventTypeSpec_New(EventTypeSpec *in)
    32 {
    33         return Py_BuildValue("ll", in->eventClass, in->eventKind);
    34 }
    35 
    3630static int
    3731EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)
    3832{
    39         if (PyArg_Parse(v, "(O&l)",
    40                         PyMac_GetOSType, &(out->eventClass),
    41                         &(out->eventKind)))
    42                 return 1;
    43         return 0;
     33    if (PyArg_Parse(v, "(O&l)",
     34                    PyMac_GetOSType, &(out->eventClass),
     35                    &(out->eventKind)))
     36        return 1;
     37    return 0;
    4438}
    4539
    … …  
    5246HIPoint_New(HIPoint *in)
    5347{
    54         return Py_BuildValue("ff", in->x, in->y);
     48    return Py_BuildValue("ff", in->x, in->y);
    5549}
    5650
    … …  
    5852HIPoint_Convert(PyObject *v, HIPoint *out)
    5953{
    60         if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))
    61                 return 1;
    62         return NULL;
     54    if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))
     55        return 1;
     56    return NULL;
    6357}
    6458#endif
    … …  
    6761
    6862/********** EventHotKeyID *******/
    69 
    70 static PyObject*
    71 EventHotKeyID_New(EventHotKeyID *in)
    72 {
    73         return Py_BuildValue("ll", in->signature, in->id);
    74 }
    7563
    7664static int
    7765EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out)
    7866{
    79         if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))
    80                 return 1;
    81         return 0;
     67    if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))
     68        return 1;
     69    return 0;
    8270}
    8371
    … …  
    9078static pascal OSStatus
    9179myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) {
    92         PyObject *retValue;
    93         int status;
    94 
    95         retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",
    96                                          EventHandlerCallRef_New, handlerRef,
    97                                          EventRef_New, event);
    98         if (retValue == NULL) {
    99                 PySys_WriteStderr("Error in event handler callback:\n");
    100                 PyErr_Print();  /* this also clears the error */
    101                 status = noErr; /* complain? how? */
    102         } else {
    103                 if (retValue == Py_None)
    104                         status = noErr;
    105                 else if (PyInt_Check(retValue)) {
    106                         status = PyInt_AsLong(retValue);
    107                 } else
    108                         status = noErr; /* wrong object type, complain? */
    109                 Py_DECREF(retValue);
    110         }
    111 
    112         return status;
     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;
    113101}
    114102
    … …  
    125113
    126114typedef struct EventRefObject {
    127         PyObject_HEAD
    128         EventRef ob_itself;
     115    PyObject_HEAD
     116    EventRef ob_itself;
    129117} EventRefObject;
    130118
    131119PyObject *EventRef_New(EventRef itself)
    132120{
    133         EventRefObject *it;
    134         it = PyObject_NEW(EventRefObject, &EventRef_Type);
    135         if (it == NULL) return NULL;
    136         it->ob_itself = itself;
    137         return (PyObject *)it;
     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;
    138126}
    139127
    140128int EventRef_Convert(PyObject *v, EventRef *p_itself)
    141129{
    142         if (!EventRef_Check(v))
    143         {
    144                 PyErr_SetString(PyExc_TypeError, "EventRef required");
    145                 return 0;
    146         }
    147         *p_itself = ((EventRefObject *)v)->ob_itself;
    148         return 1;
     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;
    149137}
    150138
    151139static void EventRef_dealloc(EventRefObject *self)
    152140{
    153         /* Cleanup of self->ob_itself goes here */
    154         self->ob_type->tp_free((PyObject *)self);
     141    /* Cleanup of self->ob_itself goes here */
     142    self->ob_type->tp_free((PyObject *)self);
    155143}
    156144
    157145static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args)
    158146{
    159         PyObject *_res = NULL;
    160         EventRef _rv;
    161         if (!PyArg_ParseTuple(_args, ""))
    162                 return NULL;
    163         _rv = RetainEvent(_self->ob_itself);
    164         _res = Py_BuildValue("O&",
    165                              EventRef_New, _rv);
    166         return _res;
     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;
    167155}
    168156
    169157static PyObject *EventRef_GetEventRetainCount(EventRefObject *_self, PyObject *_args)
    170158{
    171         PyObject *_res = NULL;
    172         UInt32 _rv;
    173         if (!PyArg_ParseTuple(_args, ""))
    174                 return NULL;
    175         _rv = GetEventRetainCount(_self->ob_itself);
    176         _res = Py_BuildValue("l",
    177                              _rv);
    178         return _res;
     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;
    179167}
    180168
    181169static PyObject *EventRef_ReleaseEvent(EventRefObject *_self, PyObject *_args)
    182170{
    183         PyObject *_res = NULL;
    184         if (!PyArg_ParseTuple(_args, ""))
    185                 return NULL;
    186         ReleaseEvent(_self->ob_itself);
    187         Py_INCREF(Py_None);
    188         _res = Py_None;
    189         return _res;
     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;
    190178}
    191179
    192180static PyObject *EventRef_SetEventParameter(EventRefObject *_self, PyObject *_args)
    193181{
    194         PyObject *_res = NULL;
    195         OSStatus _err;
    196         OSType inName;
    197         OSType inType;
    198         char *inDataPtr__in__;
    199         long inDataPtr__len__;
    200         int inDataPtr__in_len__;
    201         if (!PyArg_ParseTuple(_args, "O&O&s#",
    202                               PyMac_GetOSType, &inName,
    203                               PyMac_GetOSType, &inType,
    204                               &inDataPtr__in__, &inDataPtr__in_len__))
    205                 return NULL;
    206         inDataPtr__len__ = inDataPtr__in_len__;
    207         _err = SetEventParameter(_self->ob_itself,
    208                                  inName,
    209                                  inType,
    210                                  inDataPtr__len__, inDataPtr__in__);
    211         if (_err != noErr) return PyMac_Error(_err);
    212         Py_INCREF(Py_None);
    213         _res = Py_None;
    214         return _res;
     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;
    215203}
    216204
    217205static PyObject *EventRef_GetEventClass(EventRefObject *_self, PyObject *_args)
    218206{
    219         PyObject *_res = NULL;
    220         UInt32 _rv;
    221         if (!PyArg_ParseTuple(_args, ""))
    222                 return NULL;
    223         _rv = GetEventClass(_self->ob_itself);
    224         _res = Py_BuildValue("l",
    225                              _rv);
    226         return _res;
     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;
    227215}
    228216
    229217static PyObject *EventRef_GetEventKind(EventRefObject *_self, PyObject *_args)
    230218{
    231         PyObject *_res = NULL;
    232         UInt32 _rv;
    233         if (!PyArg_ParseTuple(_args, ""))
    234                 return NULL;
    235         _rv = GetEventKind(_self->ob_itself);
    236         _res = Py_BuildValue("l",
    237                              _rv);
    238         return _res;
     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;
    239227}
    240228
    241229static PyObject *EventRef_GetEventTime(EventRefObject *_self, PyObject *_args)
    242230{
    243         PyObject *_res = NULL;
    244         double _rv;
    245         if (!PyArg_ParseTuple(_args, ""))
    246                 return NULL;
    247         _rv = GetEventTime(_self->ob_itself);
    248         _res = Py_BuildValue("d",
    249                              _rv);
    250         return _res;
     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;
    251239}
    252240
    253241static PyObject *EventRef_SetEventTime(EventRefObject *_self, PyObject *_args)
    254242{
    255         PyObject *_res = NULL;
    256         OSStatus _err;
    257         double inTime;
    258         if (!PyArg_ParseTuple(_args, "d",
    259                               &inTime))
    260                 return NULL;
    261         _err = SetEventTime(_self->ob_itself,
    262                             inTime);
    263         if (_err != noErr) return PyMac_Error(_err);
    264         Py_INCREF(Py_None);
    265         _res = Py_None;
    266         return _res;
     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;
    267255}
    268256
    269257static PyObject *EventRef_IsUserCancelEventRef(EventRefObject *_self, PyObject *_args)
    270258{
    271         PyObject *_res = NULL;
    272         Boolean _rv;
    273         if (!PyArg_ParseTuple(_args, ""))
    274                 return NULL;
    275         _rv = IsUserCancelEventRef(_self->ob_itself);
    276         _res = Py_BuildValue("b",
    277                              _rv);
    278         return _res;
     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;
    279267}
    280268
    281269static PyObject *EventRef_ConvertEventRefToEventRecord(EventRefObject *_self, PyObject *_args)
    282270{
    283         PyObject *_res = NULL;
    284         Boolean _rv;
    285         EventRecord outEvent;
    286         if (!PyArg_ParseTuple(_args, ""))
    287                 return NULL;
    288         _rv = ConvertEventRefToEventRecord(_self->ob_itself,
    289                                            &outEvent);
    290         _res = Py_BuildValue("bO&",
    291                              _rv,
    292                              PyMac_BuildEventRecord, &outEvent);
    293         return _res;
     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;
    294282}
    295283
    296284static PyObject *EventRef_IsEventInMask(EventRefObject *_self, PyObject *_args)
    297285{
    298         PyObject *_res = NULL;
    299         Boolean _rv;
    300         UInt16 inMask;
    301         if (!PyArg_ParseTuple(_args, "H",
    302                               &inMask))
    303                 return NULL;
    304         _rv = IsEventInMask(_self->ob_itself,
    305                             inMask);
    306         _res = Py_BuildValue("b",
    307                              _rv);
    308         return _res;
     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;
    309297}
    310298
    311299static PyObject *EventRef_SendEventToEventTarget(EventRefObject *_self, PyObject *_args)
    312300{
    313         PyObject *_res = NULL;
    314         OSStatus _err;
    315         EventTargetRef inTarget;
    316         if (!PyArg_ParseTuple(_args, "O&",
    317                               EventTargetRef_Convert, &inTarget))
    318                 return NULL;
    319         _err = SendEventToEventTarget(_self->ob_itself,
    320                                       inTarget);
    321         if (_err != noErr) return PyMac_Error(_err);
    322         Py_INCREF(Py_None);
    323         _res = Py_None;
    324         return _res;
     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;
    325313}
    326314
    327315static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_args)
    328316{
    329         PyObject *_res = NULL;
    330 
    331         UInt32 bufferSize;
    332         EventParamName inName;
    333         EventParamType inType;
    334         OSErr _err;
    335         void * buffer;
    336 
    337         if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))
    338               return NULL;
    339 
    340         /* Figure out the size by passing a null buffer to GetEventParameter */
    341         _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);
    342 
    343         if (_err != noErr)
    344               return PyMac_Error(_err);
    345         buffer = PyMem_NEW(char, bufferSize);
    346         if (buffer == NULL)
    347               return PyErr_NoMemory();
    348 
    349         _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);
    350 
    351         if (_err != noErr) {
    352               PyMem_DEL(buffer);
    353               return PyMac_Error(_err);
    354         }
    355         _res = Py_BuildValue("s#", buffer, bufferSize);
    356         PyMem_DEL(buffer);
    357         return _res;
     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;
    358346
    359347}
    360348
    361349static PyMethodDef EventRef_methods[] = {
    362         {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
    363         PyDoc_STR("() -> (EventRef _rv)")},
    364         {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
    365         PyDoc_STR("() -> (UInt32 _rv)")},
    366         {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
    367         PyDoc_STR("() -> None")},
    368         {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
    369         PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
    370         {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
    371         PyDoc_STR("() -> (UInt32 _rv)")},
    372         {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
    373         PyDoc_STR("() -> (UInt32 _rv)")},
    374         {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
    375         PyDoc_STR("() -> (double _rv)")},
    376         {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
    377         PyDoc_STR("(double inTime) -> None")},
    378         {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
    379         PyDoc_STR("() -> (Boolean _rv)")},
    380         {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
    381         PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
    382         {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
    383         PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
    384         {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
    385         PyDoc_STR("(EventTargetRef inTarget) -> None")},
    386         {"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
    387         PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
    388         {NULL, NULL, 0}
     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}
    389377};
    390378
    … …  
    403391static PyObject *EventRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    404392{
    405         PyObject *_self;
    406         EventRef itself;
    407         char *kw[] = {"itself", 0};
    408 
    409         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL;
    410         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    411         ((EventRefObject *)_self)->ob_itself = itself;
    412         return _self;
     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;
    413401}
    414402
    … …  
    417405
    418406PyTypeObject EventRef_Type = {
    419         PyObject_HEAD_INIT(NULL)
    420         0, /*ob_size*/
    421         "_CarbonEvt.EventRef", /*tp_name*/
    422         sizeof(EventRefObject), /*tp_basicsize*/
    423         0, /*tp_itemsize*/
    424         /* methods */
    425         (destructor) EventRef_dealloc, /*tp_dealloc*/
    426         0, /*tp_print*/
    427         (getattrfunc)0, /*tp_getattr*/
    428         (setattrfunc)0, /*tp_setattr*/
    429         (cmpfunc) EventRef_compare, /*tp_compare*/
    430         (reprfunc) EventRef_repr, /*tp_repr*/
    431         (PyNumberMethods *)0, /* tp_as_number */
    432         (PySequenceMethods *)0, /* tp_as_sequence */
    433         (PyMappingMethods *)0, /* tp_as_mapping */
    434         (hashfunc) EventRef_hash, /*tp_hash*/
    435         0, /*tp_call*/
    436         0, /*tp_str*/
    437         PyObject_GenericGetAttr, /*tp_getattro*/
    438         PyObject_GenericSetAttr, /*tp_setattro */
    439         0, /*tp_as_buffer*/
    440         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    441         0, /*tp_doc*/
    442         0, /*tp_traverse*/
    443         0, /*tp_clear*/
    444         0, /*tp_richcompare*/
    445         0, /*tp_weaklistoffset*/
    446         0, /*tp_iter*/
    447         0, /*tp_iternext*/
    448         EventRef_methods, /* tp_methods */
    449         0, /*tp_members*/
    450         EventRef_getsetlist, /*tp_getset*/
    451         0, /*tp_base*/
    452         0, /*tp_dict*/
    453         0, /*tp_descr_get*/
    454         0, /*tp_descr_set*/
    455         0, /*tp_dictoffset*/
    456         EventRef_tp_init, /* tp_init */
    457         EventRef_tp_alloc, /* tp_alloc */
    458         EventRef_tp_new, /* tp_new */
    459         EventRef_tp_free, /* tp_free */
     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 */
    460448};
    461449
    … …  
    470458
    471459typedef struct EventQueueRefObject {
    472         PyObject_HEAD
    473         EventQueueRef ob_itself;
     460    PyObject_HEAD
     461    EventQueueRef ob_itself;
    474462} EventQueueRefObject;
    475463
    476464PyObject *EventQueueRef_New(EventQueueRef itself)
    477465{
    478         EventQueueRefObject *it;
    479         it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type);
    480         if (it == NULL) return NULL;
    481         it->ob_itself = itself;
    482         return (PyObject *)it;
     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;
    483471}
    484472
    485473int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself)
    486474{
    487         if (!EventQueueRef_Check(v))
    488         {
    489                 PyErr_SetString(PyExc_TypeError, "EventQueueRef required");
    490                 return 0;
    491         }
    492         *p_itself = ((EventQueueRefObject *)v)->ob_itself;
    493         return 1;
     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;
    494482}
    495483
    496484static void EventQueueRef_dealloc(EventQueueRefObject *self)
    497485{
    498         /* Cleanup of self->ob_itself goes here */
    499         self->ob_type->tp_free((PyObject *)self);
     486    /* Cleanup of self->ob_itself goes here */
     487    self->ob_type->tp_free((PyObject *)self);
    500488}
    501489
    502490static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args)
    503491{
    504         PyObject *_res = NULL;
    505         OSStatus _err;
    506         EventRef inEvent;
    507         SInt16 inPriority;
    508         if (!PyArg_ParseTuple(_args, "O&h",
    509                               EventRef_Convert, &inEvent,
    510                               &inPriority))
    511                 return NULL;
    512         _err = PostEventToQueue(_self->ob_itself,
    513                                 inEvent,
    514                                 inPriority);
    515         if (_err != noErr) return PyMac_Error(_err);
    516         Py_INCREF(Py_None);
    517         _res = Py_None;
    518         return _res;
     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;
    519507}
    520508
    521509static PyObject *EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject *_self, PyObject *_args)
    522510{
    523         PyObject *_res = NULL;
    524         OSStatus _err;
    525         UInt32 inNumTypes;
    526         EventTypeSpec inList;
    527         if (!PyArg_ParseTuple(_args, "lO&",
    528                               &inNumTypes,
    529                               EventTypeSpec_Convert, &inList))
    530                 return NULL;
    531         _err = FlushEventsMatchingListFromQueue(_self->ob_itself,
    532                                                 inNumTypes,
    533                                                 &inList);
    534         if (_err != noErr) return PyMac_Error(_err);
    535         Py_INCREF(Py_None);
    536         _res = Py_None;
    537         return _res;
     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;
    538526}
    539527
    540528static PyObject *EventQueueRef_FlushEventQueue(EventQueueRefObject *_self, PyObject *_args)
    541529{
    542         PyObject *_res = NULL;
    543         OSStatus _err;
    544         if (!PyArg_ParseTuple(_args, ""))
    545                 return NULL;
    546         _err = FlushEventQueue(_self->ob_itself);
    547         if (_err != noErr) return PyMac_Error(_err);
    548         Py_INCREF(Py_None);
    549         _res = Py_None;
    550         return _res;
     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;
    551539}
    552540
    553541static PyObject *EventQueueRef_GetNumEventsInQueue(EventQueueRefObject *_self, PyObject *_args)
    554542{
    555         PyObject *_res = NULL;
    556         UInt32 _rv;
    557         if (!PyArg_ParseTuple(_args, ""))
    558                 return NULL;
    559         _rv = GetNumEventsInQueue(_self->ob_itself);
    560         _res = Py_BuildValue("l",
    561                              _rv);
    562         return _res;
     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;
    563551}
    564552
    565553static PyObject *EventQueueRef_RemoveEventFromQueue(EventQueueRefObject *_self, PyObject *_args)
    566554{
    567         PyObject *_res = NULL;
    568         OSStatus _err;
    569         EventRef inEvent;
    570         if (!PyArg_ParseTuple(_args, "O&",
    571                               EventRef_Convert, &inEvent))
    572                 return NULL;
    573         _err = RemoveEventFromQueue(_self->ob_itself,
    574                                     inEvent);
    575         if (_err != noErr) return PyMac_Error(_err);
    576         Py_INCREF(Py_None);
    577         _res = Py_None;
    578         return _res;
     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;
    579567}
    580568
    581569static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObject *_args)
    582570{
    583         PyObject *_res = NULL;
    584         Boolean _rv;
    585         EventRef inEvent;
    586         if (!PyArg_ParseTuple(_args, "O&",
    587                               EventRef_Convert, &inEvent))
    588                 return NULL;
    589         _rv = IsEventInQueue(_self->ob_itself,
    590                              inEvent);
    591         _res = Py_BuildValue("b",
    592                              _rv);
    593         return _res;
     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;
    594582}
    595583
    596584static PyMethodDef EventQueueRef_methods[] = {
    597         {"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
    598         PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
    599         {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
    600         PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
    601         {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
    602         PyDoc_STR("() -> None")},
    603         {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
    604         PyDoc_STR("() -> (UInt32 _rv)")},
    605         {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
    606         PyDoc_STR("(EventRef inEvent) -> None")},
    607         {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
    608         PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
    609         {NULL, NULL, 0}
     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}
    610598};
    611599
    … …  
    624612static PyObject *EventQueueRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    625613{
    626         PyObject *_self;
    627         EventQueueRef itself;
    628         char *kw[] = {"itself", 0};
    629 
    630         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL;
    631         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    632         ((EventQueueRefObject *)_self)->ob_itself = itself;
    633         return _self;
     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;
    634622}
    635623
    … …  
    638626
    639627PyTypeObject EventQueueRef_Type = {
    640         PyObject_HEAD_INIT(NULL)
    641         0, /*ob_size*/
    642         "_CarbonEvt.EventQueueRef", /*tp_name*/
    643         sizeof(EventQueueRefObject), /*tp_basicsize*/
    644         0, /*tp_itemsize*/
    645         /* methods */
    646         (destructor) EventQueueRef_dealloc, /*tp_dealloc*/
    647         0, /*tp_print*/
    648         (getattrfunc)0, /*tp_getattr*/
    649         (setattrfunc)0, /*tp_setattr*/
    650         (cmpfunc) EventQueueRef_compare, /*tp_compare*/
    651         (reprfunc) EventQueueRef_repr, /*tp_repr*/
    652         (PyNumberMethods *)0, /* tp_as_number */
    653         (PySequenceMethods *)0, /* tp_as_sequence */
    654         (PyMappingMethods *)0, /* tp_as_mapping */
    655         (hashfunc) EventQueueRef_hash, /*tp_hash*/
    656         0, /*tp_call*/
    657         0, /*tp_str*/
    658         PyObject_GenericGetAttr, /*tp_getattro*/
    659         PyObject_GenericSetAttr, /*tp_setattro */
    660         0, /*tp_as_buffer*/
    661         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    662         0, /*tp_doc*/
    663         0, /*tp_traverse*/
    664         0, /*tp_clear*/
    665         0, /*tp_richcompare*/
    666         0, /*tp_weaklistoffset*/
    667         0, /*tp_iter*/
    668         0, /*tp_iternext*/
    669         EventQueueRef_methods, /* tp_methods */
    670         0, /*tp_members*/
    671         EventQueueRef_getsetlist, /*tp_getset*/
    672         0, /*tp_base*/
    673         0, /*tp_dict*/
    674         0, /*tp_descr_get*/
    675         0, /*tp_descr_set*/
    676         0, /*tp_dictoffset*/
    677         EventQueueRef_tp_init, /* tp_init */
    678         EventQueueRef_tp_alloc, /* tp_alloc */
    679         EventQueueRef_tp_new, /* tp_new */
    680         EventQueueRef_tp_free, /* tp_free */
     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 */
    681669};
    682670
    … …  
    691679
    692680typedef struct EventLoopRefObject {
    693         PyObject_HEAD
    694         EventLoopRef ob_itself;
     681    PyObject_HEAD
     682    EventLoopRef ob_itself;
    695683} EventLoopRefObject;
    696684
    697685PyObject *EventLoopRef_New(EventLoopRef itself)
    698686{
    699         EventLoopRefObject *it;
    700         it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type);
    701         if (it == NULL) return NULL;
    702         it->ob_itself = itself;
    703         return (PyObject *)it;
     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;
    704692}
    705693
    706694int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself)
    707695{
    708         if (!EventLoopRef_Check(v))
    709         {
    710                 PyErr_SetString(PyExc_TypeError, "EventLoopRef required");
    711                 return 0;
    712         }
    713         *p_itself = ((EventLoopRefObject *)v)->ob_itself;
    714         return 1;
     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;
    715703}
    716704
    717705static void EventLoopRef_dealloc(EventLoopRefObject *self)
    718706{
    719         /* Cleanup of self->ob_itself goes here */
    720         self->ob_type->tp_free((PyObject *)self);
     707    /* Cleanup of self->ob_itself goes here */
     708    self->ob_type->tp_free((PyObject *)self);
    721709}
    722710
    723711static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args)
    724712{
    725         PyObject *_res = NULL;
    726         OSStatus _err;
    727         if (!PyArg_ParseTuple(_args, ""))
    728                 return NULL;
    729         _err = QuitEventLoop(_self->ob_itself);
    730         if (_err != noErr) return PyMac_Error(_err);
    731         Py_INCREF(Py_None);
    732         _res = Py_None;
    733         return _res;
     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;
    734722}
    735723
    736724static PyMethodDef EventLoopRef_methods[] = {
    737         {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
    738         PyDoc_STR("() -> None")},
    739         {NULL, NULL, 0}
     725    {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
     726    PyDoc_STR("() -> None")},
     727    {NULL, NULL, 0}
    740728};
    741729
    … …  
    754742static PyObject *EventLoopRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    755743{
    756         PyObject *_self;
    757         EventLoopRef itself;
    758         char *kw[] = {"itself", 0};
    759 
    760         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL;
    761         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    762         ((EventLoopRefObject *)_self)->ob_itself = itself;
    763         return _self;
     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;
    764752}
    765753
    … …  
    768756
    769757PyTypeObject EventLoopRef_Type = {
    770         PyObject_HEAD_INIT(NULL)
    771         0, /*ob_size*/
    772         "_CarbonEvt.EventLoopRef", /*tp_name*/
    773         sizeof(EventLoopRefObject), /*tp_basicsize*/
    774         0, /*tp_itemsize*/
    775         /* methods */
    776         (destructor) EventLoopRef_dealloc, /*tp_dealloc*/
    777         0, /*tp_print*/
    778         (getattrfunc)0, /*tp_getattr*/
    779         (setattrfunc)0, /*tp_setattr*/
    780         (cmpfunc) EventLoopRef_compare, /*tp_compare*/
    781         (reprfunc) EventLoopRef_repr, /*tp_repr*/
    782         (PyNumberMethods *)0, /* tp_as_number */
    783         (PySequenceMethods *)0, /* tp_as_sequence */
    784         (PyMappingMethods *)0, /* tp_as_mapping */
    785         (hashfunc) EventLoopRef_hash, /*tp_hash*/
    786         0, /*tp_call*/
    787         0, /*tp_str*/
    788         PyObject_GenericGetAttr, /*tp_getattro*/
    789         PyObject_GenericSetAttr, /*tp_setattro */
    790         0, /*tp_as_buffer*/
    791         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    792         0, /*tp_doc*/
    793         0, /*tp_traverse*/
    794         0, /*tp_clear*/
    795         0, /*tp_richcompare*/
    796         0, /*tp_weaklistoffset*/
    797         0, /*tp_iter*/
    798         0, /*tp_iternext*/
    799         EventLoopRef_methods, /* tp_methods */
    800         0, /*tp_members*/
    801         EventLoopRef_getsetlist, /*tp_getset*/
    802         0, /*tp_base*/
    803         0, /*tp_dict*/
    804         0, /*tp_descr_get*/
    805         0, /*tp_descr_set*/
    806         0, /*tp_dictoffset*/
    807         EventLoopRef_tp_init, /* tp_init */
    808         EventLoopRef_tp_alloc, /* tp_alloc */
    809         EventLoopRef_tp_new, /* tp_new */
    810         EventLoopRef_tp_free, /* tp_free */
     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 */
    811799};
    812800
    … …  
    821809
    822810typedef struct EventLoopTimerRefObject {
    823         PyObject_HEAD
    824         EventLoopTimerRef ob_itself;
     811    PyObject_HEAD
     812    EventLoopTimerRef ob_itself;
    825813} EventLoopTimerRefObject;
    826814
    827815PyObject *EventLoopTimerRef_New(EventLoopTimerRef itself)
    828816{
    829         EventLoopTimerRefObject *it;
    830         it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type);
    831         if (it == NULL) return NULL;
    832         it->ob_itself = itself;
    833         return (PyObject *)it;
     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;
    834822}
    835823
    836824int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself)
    837825{
    838         if (!EventLoopTimerRef_Check(v))
    839         {
    840                 PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required");
    841                 return 0;
    842         }
    843         *p_itself = ((EventLoopTimerRefObject *)v)->ob_itself;
    844         return 1;
     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;
    845833}
    846834
    847835static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)
    848836{
    849         /* Cleanup of self->ob_itself goes here */
    850         self->ob_type->tp_free((PyObject *)self);
     837    /* Cleanup of self->ob_itself goes here */
     838    self->ob_type->tp_free((PyObject *)self);
    851839}
    852840
    853841static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args)
    854842{
    855         PyObject *_res = NULL;
    856         OSStatus _err;
    857         if (!PyArg_ParseTuple(_args, ""))
    858                 return NULL;
    859         _err = RemoveEventLoopTimer(_self->ob_itself);
    860         if (_err != noErr) return PyMac_Error(_err);
    861         Py_INCREF(Py_None);
    862         _res = Py_None;
    863         return _res;
     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;
    864852}
    865853
    866854static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject *_self, PyObject *_args)
    867855{
    868         PyObject *_res = NULL;
    869         OSStatus _err;
    870         double inNextFire;
    871         if (!PyArg_ParseTuple(_args, "d",
    872                               &inNextFire))
    873                 return NULL;
    874         _err = SetEventLoopTimerNextFireTime(_self->ob_itself,
    875                                              inNextFire);
    876         if (_err != noErr) return PyMac_Error(_err);
    877         Py_INCREF(Py_None);
    878         _res = Py_None;
    879         return _res;
     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;
    880868}
    881869
    882870static PyMethodDef EventLoopTimerRef_methods[] = {
    883         {"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
    884         PyDoc_STR("() -> None")},
    885         {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
    886         PyDoc_STR("(double inNextFire) -> None")},
    887         {NULL, NULL, 0}
     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}
    888876};
    889877
    … …  
    902890static PyObject *EventLoopTimerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    903891{
    904         PyObject *_self;
    905         EventLoopTimerRef itself;
    906         char *kw[] = {"itself", 0};
    907 
    908         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL;
    909         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    910         ((EventLoopTimerRefObject *)_self)->ob_itself = itself;
    911         return _self;
     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;
    912900}
    913901
    … …  
    916904
    917905PyTypeObject EventLoopTimerRef_Type = {
    918         PyObject_HEAD_INIT(NULL)
    919         0, /*ob_size*/
    920         "_CarbonEvt.EventLoopTimerRef", /*tp_name*/
    921         sizeof(EventLoopTimerRefObject), /*tp_basicsize*/
    922         0, /*tp_itemsize*/
    923         /* methods */
    924         (destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/
    925         0, /*tp_print*/
    926         (getattrfunc)0, /*tp_getattr*/
    927         (setattrfunc)0, /*tp_setattr*/
    928         (cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/
    929         (reprfunc) EventLoopTimerRef_repr, /*tp_repr*/
    930         (PyNumberMethods *)0, /* tp_as_number */
    931         (PySequenceMethods *)0, /* tp_as_sequence */
    932         (PyMappingMethods *)0, /* tp_as_mapping */
    933         (hashfunc) EventLoopTimerRef_hash, /*tp_hash*/
    934         0, /*tp_call*/
    935         0, /*tp_str*/
    936         PyObject_GenericGetAttr, /*tp_getattro*/
    937         PyObject_GenericSetAttr, /*tp_setattro */
    938         0, /*tp_as_buffer*/
    939         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    940         0, /*tp_doc*/
    941         0, /*tp_traverse*/
    942         0, /*tp_clear*/
    943         0, /*tp_richcompare*/
    944         0, /*tp_weaklistoffset*/
    945         0, /*tp_iter*/
    946         0, /*tp_iternext*/
    947         EventLoopTimerRef_methods, /* tp_methods */
    948         0, /*tp_members*/
    949         EventLoopTimerRef_getsetlist, /*tp_getset*/
    950         0, /*tp_base*/
    951         0, /*tp_dict*/
    952         0, /*tp_descr_get*/
    953         0, /*tp_descr_set*/
    954         0, /*tp_dictoffset*/
    955         EventLoopTimerRef_tp_init, /* tp_init */
    956         EventLoopTimerRef_tp_alloc, /* tp_alloc */
    957         EventLoopTimerRef_tp_new, /* tp_new */
    958         EventLoopTimerRef_tp_free, /* tp_free */
     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 */
    959947};
    960948
    … …  
    969957
    970958typedef struct EventHandlerRefObject {
    971         PyObject_HEAD
    972         EventHandlerRef ob_itself;
    973         PyObject *ob_callback;
     959    PyObject_HEAD
     960    EventHandlerRef ob_itself;
     961    PyObject *ob_callback;
    974962} EventHandlerRefObject;
    975963
    976964PyObject *EventHandlerRef_New(EventHandlerRef itself)
    977965{
    978         EventHandlerRefObject *it;
    979         it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type);
    980         if (it == NULL) return NULL;
    981         it->ob_itself = itself;
    982         it->ob_callback = NULL;
    983         return (PyObject *)it;
     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;
    984972}
    985973
    986974int EventHandlerRef_Convert(PyObject *v, EventHandlerRef *p_itself)
    987975{
    988         if (!EventHandlerRef_Check(v))
    989         {
    990                 PyErr_SetString(PyExc_TypeError, "EventHandlerRef required");
    991                 return 0;
    992         }
    993         *p_itself = ((EventHandlerRefObject *)v)->ob_itself;
    994         return 1;
     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;
    995983}
    996984
    997985static void EventHandlerRef_dealloc(EventHandlerRefObject *self)
    998986{
    999         if (self->ob_itself != NULL) {
    1000                 RemoveEventHandler(self->ob_itself);
    1001                 Py_DECREF(self->ob_callback);
    1002         }
    1003         self->ob_type->tp_free((PyObject *)self);
     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);
    1004992}
    1005993
    1006994static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args)
    1007995{
    1008         PyObject *_res = NULL;
    1009         OSStatus _err;
    1010         UInt32 inNumTypes;
    1011         EventTypeSpec inList;
    1012         if (_self->ob_itself == NULL) {
    1013                 PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
    1014                 return NULL;
    1015         }
    1016         if (!PyArg_ParseTuple(_args, "lO&",
    1017                               &inNumTypes,
    1018                               EventTypeSpec_Convert, &inList))
    1019                 return NULL;
    1020         _err = AddEventTypesToHandler(_self->ob_itself,
    1021                                       inNumTypes,
    1022                                       &inList);
    1023         if (_err != noErr) return PyMac_Error(_err);
    1024         Py_INCREF(Py_None);
    1025         _res = Py_None;
    1026         return _res;
     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;
    10271015}
    10281016
    10291017static PyObject *EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject *_self, PyObject *_args)
    10301018{
    1031         PyObject *_res = NULL;
    1032         OSStatus _err;
    1033         UInt32 inNumTypes;
    1034         EventTypeSpec inList;
    1035         if (_self->ob_itself == NULL) {
    1036                 PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
    1037                 return NULL;
    1038         }
    1039         if (!PyArg_ParseTuple(_args, "lO&",
    1040                               &inNumTypes,
    1041                               EventTypeSpec_Convert, &inList))
    1042                 return NULL;
    1043         _err = RemoveEventTypesFromHandler(_self->ob_itself,
    1044                                            inNumTypes,
    1045                                            &inList);
    1046         if (_err != noErr) return PyMac_Error(_err);
    1047         Py_INCREF(Py_None);
    1048         _res = Py_None;
    1049         return _res;
     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;
    10501038}
    10511039
    10521040static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args)
    10531041{
    1054         PyObject *_res = NULL;
    1055 
    1056         OSStatus _err;
    1057         if (_self->ob_itself == NULL) {
    1058                 PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
    1059                 return NULL;
    1060         }
    1061         if (!PyArg_ParseTuple(_args, ""))
    1062                 return NULL;
    1063         _err = RemoveEventHandler(_self->ob_itself);
    1064         if (_err != noErr) return PyMac_Error(_err);
    1065         _self->ob_itself = NULL;
    1066         Py_DECREF(_self->ob_callback);
    1067         _self->ob_callback = NULL;
    1068         Py_INCREF(Py_None);
    1069         _res = Py_None;
    1070         return _res;
     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;
    10711059}
    10721060
    10731061static PyMethodDef EventHandlerRef_methods[] = {
    1074         {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
    1075         PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
    1076         {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
    1077         PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
    1078         {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
    1079         PyDoc_STR("() -> None")},
    1080         {NULL, NULL, 0}
     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}
    10811069};
    10821070
    … …  
    10951083static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    10961084{
    1097         PyObject *_self;
    1098         EventHandlerRef itself;
    1099         char *kw[] = {"itself", 0};
    1100 
    1101         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;
    1102         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    1103         ((EventHandlerRefObject *)_self)->ob_itself = itself;
    1104         return _self;
     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;
    11051093}
    11061094
    … …  
    11091097
    11101098PyTypeObject EventHandlerRef_Type = {
    1111         PyObject_HEAD_INIT(NULL)
    1112         0, /*ob_size*/
    1113         "_CarbonEvt.EventHandlerRef", /*tp_name*/
    1114         sizeof(EventHandlerRefObject), /*tp_basicsize*/
    1115         0, /*tp_itemsize*/
    1116         /* methods */
    1117         (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/
    1118         0, /*tp_print*/
    1119         (getattrfunc)0, /*tp_getattr*/
    1120         (setattrfunc)0, /*tp_setattr*/
    1121         (cmpfunc) EventHandlerRef_compare, /*tp_compare*/
    1122         (reprfunc) EventHandlerRef_repr, /*tp_repr*/
    1123         (PyNumberMethods *)0, /* tp_as_number */
    1124         (PySequenceMethods *)0, /* tp_as_sequence */
    1125         (PyMappingMethods *)0, /* tp_as_mapping */
    1126         (hashfunc) EventHandlerRef_hash, /*tp_hash*/
    1127         0, /*tp_call*/
    1128         0, /*tp_str*/
    1129         PyObject_GenericGetAttr, /*tp_getattro*/
    1130         PyObject_GenericSetAttr, /*tp_setattro */
    1131         0, /*tp_as_buffer*/
    1132         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    1133         0, /*tp_doc*/
    1134         0, /*tp_traverse*/
    1135         0, /*tp_clear*/
    1136         0, /*tp_richcompare*/
    1137         0, /*tp_weaklistoffset*/
    1138         0, /*tp_iter*/
    1139         0, /*tp_iternext*/
    1140         EventHandlerRef_methods, /* tp_methods */
    1141         0, /*tp_members*/
    1142         EventHandlerRef_getsetlist, /*tp_getset*/
    1143         0, /*tp_base*/
    1144         0, /*tp_dict*/
    1145         0, /*tp_descr_get*/
    1146         0, /*tp_descr_set*/
    1147         0, /*tp_dictoffset*/
    1148         EventHandlerRef_tp_init, /* tp_init */
    1149         EventHandlerRef_tp_alloc, /* tp_alloc */
    1150         EventHandlerRef_tp_new, /* tp_new */
    1151         EventHandlerRef_tp_free, /* tp_free */
     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 */
    11521140};
    11531141
    … …  
    11621150
    11631151typedef struct EventHandlerCallRefObject {
    1164         PyObject_HEAD
    1165         EventHandlerCallRef ob_itself;
     1152    PyObject_HEAD
     1153    EventHandlerCallRef ob_itself;
    11661154} EventHandlerCallRefObject;
    11671155
    11681156PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself)
    11691157{
    1170         EventHandlerCallRefObject *it;
    1171         it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type);
    1172         if (it == NULL) return NULL;
    1173         it->ob_itself = itself;
    1174         return (PyObject *)it;
     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;
    11751163}
    11761164
    11771165int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself)
    11781166{
    1179         if (!EventHandlerCallRef_Check(v))
    1180         {
    1181                 PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required");
    1182                 return 0;
    1183         }
    1184         *p_itself = ((EventHandlerCallRefObject *)v)->ob_itself;
    1185         return 1;
     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;
    11861174}
    11871175
    11881176static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
    11891177{
    1190         /* Cleanup of self->ob_itself goes here */
    1191         self->ob_type->tp_free((PyObject *)self);
     1178    /* Cleanup of self->ob_itself goes here */
     1179    self->ob_type->tp_free((PyObject *)self);
    11921180}
    11931181
    11941182static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args)
    11951183{
    1196         PyObject *_res = NULL;
    1197         OSStatus _err;
    1198         EventRef inEvent;
    1199         if (!PyArg_ParseTuple(_args, "O&",
    1200                               EventRef_Convert, &inEvent))
    1201                 return NULL;
    1202         _err = CallNextEventHandler(_self->ob_itself,
    1203                                     inEvent);
    1204         if (_err != noErr) return PyMac_Error(_err);
    1205         Py_INCREF(Py_None);
    1206         _res = Py_None;
    1207         return _res;
     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;
    12081196}
    12091197
    12101198static PyMethodDef EventHandlerCallRef_methods[] = {
    1211         {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
    1212         PyDoc_STR("(EventRef inEvent) -> None")},
    1213         {NULL, NULL, 0}
     1199    {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
     1200    PyDoc_STR("(EventRef inEvent) -> None")},
     1201    {NULL, NULL, 0}
    12141202};
    12151203
    … …  
    12281216static PyObject *EventHandlerCallRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    12291217{
    1230         PyObject *_self;
    1231         EventHandlerCallRef itself;
    1232         char *kw[] = {"itself", 0};
    1233 
    1234         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL;
    1235         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    1236         ((EventHandlerCallRefObject *)_self)->ob_itself = itself;
    1237         return _self;
     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;
    12381226}
    12391227
    … …  
    12421230
    12431231PyTypeObject EventHandlerCallRef_Type = {
    1244         PyObject_HEAD_INIT(NULL)
    1245         0, /*ob_size*/
    1246         "_CarbonEvt.EventHandlerCallRef", /*tp_name*/
    1247         sizeof(EventHandlerCallRefObject), /*tp_basicsize*/
    1248         0, /*tp_itemsize*/
    1249         /* methods */
    1250         (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/
    1251         0, /*tp_print*/
    1252         (getattrfunc)0, /*tp_getattr*/
    1253         (setattrfunc)0, /*tp_setattr*/
    1254         (cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/
    1255         (reprfunc) EventHandlerCallRef_repr, /*tp_repr*/
    1256         (PyNumberMethods *)0, /* tp_as_number */
    1257         (PySequenceMethods *)0, /* tp_as_sequence */
    1258         (PyMappingMethods *)0, /* tp_as_mapping */
    1259         (hashfunc) EventHandlerCallRef_hash, /*tp_hash*/
    1260         0, /*tp_call*/
    1261         0, /*tp_str*/
    1262         PyObject_GenericGetAttr, /*tp_getattro*/
    1263         PyObject_GenericSetAttr, /*tp_setattro */
    1264         0, /*tp_as_buffer*/
    1265         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    1266         0, /*tp_doc*/
    1267         0, /*tp_traverse*/
    1268         0, /*tp_clear*/
    1269         0, /*tp_richcompare*/
    1270         0, /*tp_weaklistoffset*/
    1271         0, /*tp_iter*/
    1272         0, /*tp_iternext*/
    1273         EventHandlerCallRef_methods, /* tp_methods */
    1274         0, /*tp_members*/
    1275         EventHandlerCallRef_getsetlist, /*tp_getset*/
    1276         0, /*tp_base*/
    1277         0, /*tp_dict*/
    1278         0, /*tp_descr_get*/
    1279         0, /*tp_descr_set*/
    1280         0, /*tp_dictoffset*/
    1281         EventHandlerCallRef_tp_init, /* tp_init */
    1282         EventHandlerCallRef_tp_alloc, /* tp_alloc */
    1283         EventHandlerCallRef_tp_new, /* tp_new */
    1284         EventHandlerCallRef_tp_free, /* tp_free */
     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 */
    12851273};
    12861274
    … …  
    12951283
    12961284typedef struct EventTargetRefObject {
    1297         PyObject_HEAD
    1298         EventTargetRef ob_itself;
     1285    PyObject_HEAD
     1286    EventTargetRef ob_itself;
    12991287} EventTargetRefObject;
    13001288
    13011289PyObject *EventTargetRef_New(EventTargetRef itself)
    13021290{
    1303         EventTargetRefObject *it;
    1304         it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type);
    1305         if (it == NULL) return NULL;
    1306         it->ob_itself = itself;
    1307         return (PyObject *)it;
     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;
    13081296}
    13091297
    13101298int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself)
    13111299{
    1312         if (!EventTargetRef_Check(v))
    1313         {
    1314                 PyErr_SetString(PyExc_TypeError, "EventTargetRef required");
    1315                 return 0;
    1316         }
    1317         *p_itself = ((EventTargetRefObject *)v)->ob_itself;
    1318         return 1;
     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;
    13191307}
    13201308
    13211309static void EventTargetRef_dealloc(EventTargetRefObject *self)
    13221310{
    1323         /* Cleanup of self->ob_itself goes here */
    1324         self->ob_type->tp_free((PyObject *)self);
     1311    /* Cleanup of self->ob_itself goes here */
     1312    self->ob_type->tp_free((PyObject *)self);
    13251313}
    13261314
    13271315static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args)
    13281316{
    1329         PyObject *_res = NULL;
    1330         OSStatus _err;
    1331         if (!PyArg_ParseTuple(_args, ""))
    1332                 return NULL;
    1333         _err = InstallStandardEventHandler(_self->ob_itself);
    1334         if (_err != noErr) return PyMac_Error(_err);
    1335         Py_INCREF(Py_None);
    1336         _res = Py_None;
    1337         return _res;
     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;
    13381326}
    13391327
    13401328static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, PyObject *_args)
    13411329{
    1342         PyObject *_res = NULL;
    1343 
    1344         EventTypeSpec inSpec;
    1345         PyObject *callback;
    1346         EventHandlerRef outRef;
    1347         OSStatus _err;
    1348 
    1349         if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))
    1350                 return NULL;
    1351 
    1352         _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);
    1353         if (_err != noErr) return PyMac_Error(_err);
    1354 
    1355         _res = EventHandlerRef_New(outRef);
    1356         if (_res != NULL) {
    1357                 ((EventHandlerRefObject*)_res)->ob_callback = callback;
    1358                 Py_INCREF(callback);
    1359         }
    1360         return _res;
     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;
    13611349}
    13621350
    13631351static PyMethodDef EventTargetRef_methods[] = {
    1364         {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
    1365         PyDoc_STR("() -> None")},
    1366         {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
    1367         PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
    1368         {NULL, NULL, 0}
     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}
    13691357};
    13701358
    … …  
    13831371static PyObject *EventTargetRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    13841372{
    1385         PyObject *_self;
    1386         EventTargetRef itself;
    1387         char *kw[] = {"itself", 0};
    1388 
    1389         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL;
    1390         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    1391         ((EventTargetRefObject *)_self)->ob_itself = itself;
    1392         return _self;
     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;
    13931381}
    13941382
    … …  
    13971385
    13981386PyTypeObject EventTargetRef_Type = {
    1399         PyObject_HEAD_INIT(NULL)
    1400         0, /*ob_size*/
    1401         "_CarbonEvt.EventTargetRef", /*tp_name*/
    1402         sizeof(EventTargetRefObject), /*tp_basicsize*/
    1403         0, /*tp_itemsize*/
    1404         /* methods */
    1405         (destructor) EventTargetRef_dealloc, /*tp_dealloc*/
    1406         0, /*tp_print*/
    1407         (getattrfunc)0, /*tp_getattr*/
    1408         (setattrfunc)0, /*tp_setattr*/
    1409         (cmpfunc) EventTargetRef_compare, /*tp_compare*/
    1410         (reprfunc) EventTargetRef_repr, /*tp_repr*/
    1411         (PyNumberMethods *)0, /* tp_as_number */
    1412         (PySequenceMethods *)0, /* tp_as_sequence */
    1413         (PyMappingMethods *)0, /* tp_as_mapping */
    1414         (hashfunc) EventTargetRef_hash, /*tp_hash*/
    1415         0, /*tp_call*/
    1416         0, /*tp_str*/
    1417         PyObject_GenericGetAttr, /*tp_getattro*/
    1418         PyObject_GenericSetAttr, /*tp_setattro */
    1419         0, /*tp_as_buffer*/
    1420         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    1421         0, /*tp_doc*/
    1422         0, /*tp_traverse*/
    1423         0, /*tp_clear*/
    1424         0, /*tp_richcompare*/
    1425         0, /*tp_weaklistoffset*/
    1426         0, /*tp_iter*/
    1427         0, /*tp_iternext*/
    1428         EventTargetRef_methods, /* tp_methods */
    1429         0, /*tp_members*/
    1430         EventTargetRef_getsetlist, /*tp_getset*/
    1431         0, /*tp_base*/
    1432         0, /*tp_dict*/
    1433         0, /*tp_descr_get*/
    1434         0, /*tp_descr_set*/
    1435         0, /*tp_dictoffset*/
    1436         EventTargetRef_tp_init, /* tp_init */
    1437         EventTargetRef_tp_alloc, /* tp_alloc */
    1438         EventTargetRef_tp_new, /* tp_new */
    1439         EventTargetRef_tp_free, /* tp_free */
     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 */
    14401428};
    14411429
    … …  
    14501438
    14511439typedef struct EventHotKeyRefObject {
    1452         PyObject_HEAD
    1453         EventHotKeyRef ob_itself;
     1440    PyObject_HEAD
     1441    EventHotKeyRef ob_itself;
    14541442} EventHotKeyRefObject;
    14551443
    14561444PyObject *EventHotKeyRef_New(EventHotKeyRef itself)
    14571445{
    1458         EventHotKeyRefObject *it;
    1459         it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type);
    1460         if (it == NULL) return NULL;
    1461         it->ob_itself = itself;
    1462         return (PyObject *)it;
     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;
    14631451}
    14641452
    14651453int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself)
    14661454{
    1467         if (!EventHotKeyRef_Check(v))
    1468         {
    1469                 PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required");
    1470                 return 0;
    1471         }
    1472         *p_itself = ((EventHotKeyRefObject *)v)->ob_itself;
    1473         return 1;
     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;
    14741462}
    14751463
    14761464static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
    14771465{
    1478         /* Cleanup of self->ob_itself goes here */
    1479         self->ob_type->tp_free((PyObject *)self);
     1466    /* Cleanup of self->ob_itself goes here */
     1467    self->ob_type->tp_free((PyObject *)self);
    14801468}
    14811469
    14821470static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args)
    14831471{
    1484         PyObject *_res = NULL;
    1485         OSStatus _err;
    1486         if (!PyArg_ParseTuple(_args, ""))
    1487                 return NULL;
    1488         _err = UnregisterEventHotKey(_self->ob_itself);
    1489         if (_err != noErr) return PyMac_Error(_err);
    1490         Py_INCREF(Py_None);
    1491         _res = Py_None;
    1492         return _res;
     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;
    14931481}
    14941482
    14951483static PyMethodDef EventHotKeyRef_methods[] = {
    1496         {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
    1497         PyDoc_STR("() -> None")},
    1498         {NULL, NULL, 0}
     1484    {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
     1485    PyDoc_STR("() -> None")},
     1486    {NULL, NULL, 0}
    14991487};
    15001488
    … …  
    15131501static PyObject *EventHotKeyRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
    15141502{
    1515         PyObject *_self;
    1516         EventHotKeyRef itself;
    1517         char *kw[] = {"itself", 0};
    1518 
    1519         if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL;
    1520         if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
    1521         ((EventHotKeyRefObject *)_self)->ob_itself = itself;
    1522         return _self;
     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;
    15231511}
    15241512
    … …  
    15271515
    15281516PyTypeObject EventHotKeyRef_Type = {
    1529         PyObject_HEAD_INIT(NULL)
    1530         0, /*ob_size*/
    1531         "_CarbonEvt.EventHotKeyRef", /*tp_name*/
    1532         sizeof(EventHotKeyRefObject), /*tp_basicsize*/
    1533         0, /*tp_itemsize*/
    1534         /* methods */
    1535         (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/
    1536         0, /*tp_print*/
    1537         (getattrfunc)0, /*tp_getattr*/
    1538         (setattrfunc)0, /*tp_setattr*/
    1539         (cmpfunc) EventHotKeyRef_compare, /*tp_compare*/
    1540         (reprfunc) EventHotKeyRef_repr, /*tp_repr*/
    1541         (PyNumberMethods *)0, /* tp_as_number */
    1542         (PySequenceMethods *)0, /* tp_as_sequence */
    1543         (PyMappingMethods *)0, /* tp_as_mapping */
    1544         (hashfunc) EventHotKeyRef_hash, /*tp_hash*/
    1545         0, /*tp_call*/
    1546         0, /*tp_str*/
    1547         PyObject_GenericGetAttr, /*tp_getattro*/
    1548         PyObject_GenericSetAttr, /*tp_setattro */
    1549         0, /*tp_as_buffer*/
    1550         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    1551         0, /*tp_doc*/
    1552         0, /*tp_traverse*/
    1553         0, /*tp_clear*/
    1554         0, /*tp_richcompare*/
    1555         0, /*tp_weaklistoffset*/
    1556         0, /*tp_iter*/
    1557         0, /*tp_iternext*/
    1558         EventHotKeyRef_methods, /* tp_methods */
    1559         0, /*tp_members*/
    1560         EventHotKeyRef_getsetlist, /*tp_getset*/
    1561         0, /*tp_base*/
    1562         0, /*tp_dict*/
    1563         0, /*tp_descr_get*/
    1564         0, /*tp_descr_set*/
    1565         0, /*tp_dictoffset*/
    1566         EventHotKeyRef_tp_init, /* tp_init */
    1567         EventHotKeyRef_tp_alloc, /* tp_alloc */
    1568         EventHotKeyRef_tp_new, /* tp_new */
    1569         EventHotKeyRef_tp_free, /* tp_free */
     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 */
    15701558};
    15711559
    … …  
    15751563static PyObject *CarbonEvents_GetCurrentEventLoop(PyObject *_self, PyObject *_args)
    15761564{
    1577         PyObject *_res = NULL;
    1578         EventLoopRef _rv;
    1579         if (!PyArg_ParseTuple(_args, ""))
    1580                 return NULL;
    1581         _rv = GetCurrentEventLoop();
    1582         _res = Py_BuildValue("O&",
    1583                              EventLoopRef_New, _rv);
    1584         return _res;
     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;
    15851573}
    15861574
    15871575static PyObject *CarbonEvents_GetMainEventLoop(PyObject *_self, PyObject *_args)
    15881576{
    1589         PyObject *_res = NULL;
    1590         EventLoopRef _rv;
    1591         if (!PyArg_ParseTuple(_args, ""))
    1592                 return NULL;
    1593         _rv = GetMainEventLoop();
    1594         _res = Py_BuildValue("O&",
    1595                              EventLoopRef_New, _rv);
    1596         return _res;
     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;
    15971585}
    15981586
    15991587static PyObject *CarbonEvents_RunCurrentEventLoop(PyObject *_self, PyObject *_args)
    16001588{
    1601         PyObject *_res = NULL;
    1602         OSStatus _err;
    1603         double inTimeout;
    1604         if (!PyArg_ParseTuple(_args, "d",
    1605                               &inTimeout))
    1606                 return NULL;
    1607         _err = RunCurrentEventLoop(inTimeout);
    1608         if (_err != noErr) return PyMac_Error(_err);
    1609         Py_INCREF(Py_None);
    1610         _res = Py_None;
    1611         return _res;
     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;
    16121600}
    16131601
    16141602static PyObject *CarbonEvents_ReceiveNextEvent(PyObject *_self, PyObject *_args)
    16151603{
    1616         PyObject *_res = NULL;
    1617         OSStatus _err;
    1618         UInt32 inNumTypes;
    1619         EventTypeSpec inList;
    1620         double inTimeout;
    1621         Boolean inPullEvent;
    1622         EventRef outEvent;
    1623         if (!PyArg_ParseTuple(_args, "lO&db",
    1624                               &inNumTypes,
    1625                               EventTypeSpec_Convert, &inList,
    1626                               &inTimeout,
    1627                               &inPullEvent))
    1628                 return NULL;
    1629         _err = ReceiveNextEvent(inNumTypes,
    1630                                 &inList,
    1631                                 inTimeout,
    1632                                 inPullEvent,
    1633                                 &outEvent);
    1634         if (_err != noErr) return PyMac_Error(_err);
    1635         _res = Py_BuildValue("O&",
    1636                              EventRef_New, outEvent);
    1637         return _res;
     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;
    16381626}
    16391627
    16401628static PyObject *CarbonEvents_GetCurrentEventQueue(PyObject *_self, PyObject *_args)
    16411629{
    1642         PyObject *_res = NULL;
    1643         EventQueueRef _rv;
    1644         if (!PyArg_ParseTuple(_args, ""))
    1645                 return NULL;
    1646         _rv = GetCurrentEventQueue();
    1647         _res = Py_BuildValue("O&",
    1648                              EventQueueRef_New, _rv);
    1649         return _res;
     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;
    16501638}
    16511639
    16521640static PyObject *CarbonEvents_GetMainEventQueue(PyObject *_self, PyObject *_args)
    16531641{
    1654         PyObject *_res = NULL;
    1655         EventQueueRef _rv;
    1656         if (!PyArg_ParseTuple(_args, ""))
    1657                 return NULL;
    1658         _rv = GetMainEventQueue();
    1659         _res = Py_BuildValue("O&",
    1660                              EventQueueRef_New, _rv);
    1661         return _res;
     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;
    16621650}
    16631651
    16641652static PyObject *CarbonEvents_GetCurrentEventTime(PyObject *_self, PyObject *_args)
    16651653{
    1666         PyObject *_res = NULL;
    1667         double _rv;
    1668         if (!PyArg_ParseTuple(_args, ""))
    1669                 return NULL;
    1670         _rv = GetCurrentEventTime();
    1671         _res = Py_BuildValue("d",
    1672                              _rv);
    1673         return _res;
     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;
    16741662}
    16751663
    16761664static PyObject *CarbonEvents_TrackMouseLocation(PyObject *_self, PyObject *_args)
    16771665{
    1678         PyObject *_res = NULL;
    1679         OSStatus _err;
    1680         GrafPtr inPort;
    1681         Point outPt;
    1682         UInt16 outResult;
    1683         if (!PyArg_ParseTuple(_args, "O&",
    1684                               GrafObj_Convert, &inPort))
    1685                 return NULL;
    1686         _err = TrackMouseLocation(inPort,
    1687                                   &outPt,
    1688                                   &outResult);
    1689         if (_err != noErr) return PyMac_Error(_err);
    1690         _res = Py_BuildValue("O&H",
    1691                              PyMac_BuildPoint, outPt,
    1692                              outResult);
    1693         return _res;
     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;
    16941682}
    16951683
    16961684static PyObject *CarbonEvents_TrackMouseLocationWithOptions(PyObject *_self, PyObject *_args)
    16971685{
    1698         PyObject *_res = NULL;
    1699         OSStatus _err;
    1700         GrafPtr inPort;
    1701         OptionBits inOptions;
    1702         double inTimeout;
    1703         Point outPt;
    1704         UInt32 outModifiers;
    1705         UInt16 outResult;
    1706         if (!PyArg_ParseTuple(_args, "O&ld",
    1707                               GrafObj_Convert, &inPort,
    1708                               &inOptions,
    1709                               &inTimeout))
    1710                 return NULL;
    1711         _err = TrackMouseLocationWithOptions(inPort,
    1712                                              inOptions,
    1713                                              inTimeout,
    1714                                              &outPt,
    1715                                              &outModifiers,
    1716                                              &outResult);
    1717         if (_err != noErr) return PyMac_Error(_err);
    1718         _res = Py_BuildValue("O&lH",
    1719                              PyMac_BuildPoint, outPt,
    1720                              outModifiers,
    1721                              outResult);
    1722         return _res;
     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;
    17231711}
    17241712
    17251713static PyObject *CarbonEvents_TrackMouseRegion(PyObject *_self, PyObject *_args)
    17261714{
    1727         PyObject *_res = NULL;
    1728         OSStatus _err;
    1729         GrafPtr inPort;
    1730         RgnHandle inRegion;
    1731         Boolean ioWasInRgn;
    1732         UInt16 outResult;
    1733         if (!PyArg_ParseTuple(_args, "O&O&b",
    1734                               GrafObj_Convert, &inPort,
    1735                               ResObj_Convert, &inRegion,
    1736                               &ioWasInRgn))
    1737                 return NULL;
    1738         _err = TrackMouseRegion(inPort,
    1739                                 inRegion,
    1740                                 &ioWasInRgn,
    1741                                 &outResult);
    1742         if (_err != noErr) return PyMac_Error(_err);
    1743         _res = Py_BuildValue("bH",
    1744                              ioWasInRgn,
    1745                              outResult);
    1746         return _res;
     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;
    17471735}
    17481736
    17491737static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_args)
    17501738{
    1751         PyObject *_res = NULL;
    1752         double _rv;
    1753         if (!PyArg_ParseTuple(_args, ""))
    1754                 return NULL;
    1755         _rv = GetLastUserEventTime();
    1756         _res = Py_BuildValue("d",
    1757                              _rv);
    1758         return _res;
     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;
    17591747}
    17601748
    17611749static PyObject *CarbonEvents_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
    17621750{
    1763         PyObject *_res = NULL;
    1764         Boolean _rv;
    1765         if (!PyArg_ParseTuple(_args, ""))
    1766                 return NULL;
    1767         _rv = IsMouseCoalescingEnabled();
    1768         _res = Py_BuildValue("b",
    1769                              _rv);
    1770         return _res;
     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;
    17711759}
    17721760
    17731761static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
    17741762{
    1775         PyObject *_res = NULL;
    1776         OSStatus _err;
    1777         Boolean inNewState;
    1778         Boolean outOldState;
    1779         if (!PyArg_ParseTuple(_args, "b",
    1780                               &inNewState))
    1781                 return NULL;
    1782         _err = SetMouseCoalescingEnabled(inNewState,
    1783                                          &outOldState);
    1784         if (_err != noErr) return PyMac_Error(_err);
    1785         _res = Py_BuildValue("b",
    1786                              outOldState);
    1787         return _res;
     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;
    17881776}
    17891777
    17901778static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args)
    17911779{
    1792         PyObject *_res = NULL;
    1793         EventTargetRef _rv;
    1794         WindowPtr inWindow;
    1795         if (!PyArg_ParseTuple(_args, "O&",
    1796                               WinObj_Convert, &inWindow))
    1797                 return NULL;
    1798         _rv = GetWindowEventTarget(inWindow);
    1799         _res = Py_BuildValue("O&",
    1800                              EventTargetRef_New, _rv);
    1801         return _res;
     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;
    18021790}
    18031791
    18041792static PyObject *CarbonEvents_GetControlEventTarget(PyObject *_self, PyObject *_args)
    18051793{
    1806         PyObject *_res = NULL;
    1807         EventTargetRef _rv;
    1808         ControlHandle inControl;
    1809         if (!PyArg_ParseTuple(_args, "O&",
    1810                               CtlObj_Convert, &inControl))
    1811                 return NULL;
    1812         _rv = GetControlEventTarget(inControl);
    1813         _res = Py_BuildValue("O&",
    1814                              EventTargetRef_New, _rv);
    1815         return _res;
     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;
    18161804}
    18171805
    18181806static PyObject *CarbonEvents_GetMenuEventTarget(PyObject *_self, PyObject *_args)
    18191807{
    1820         PyObject *_res = NULL;
    1821         EventTargetRef _rv;
    1822         MenuHandle inMenu;
    1823         if (!PyArg_ParseTuple(_args, "O&",
    1824                               MenuObj_Convert, &inMenu))
    1825                 return NULL;
    1826         _rv = GetMenuEventTarget(inMenu);
    1827         _res = Py_BuildValue("O&",
    1828                              EventTargetRef_New, _rv);
    1829         return _res;
     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;
    18301818}
    18311819
    18321820static PyObject *CarbonEvents_GetApplicationEventTarget(PyObject *_self, PyObject *_args)
    18331821{
    1834         PyObject *_res = NULL;
    1835         EventTargetRef _rv;
    1836         if (!PyArg_ParseTuple(_args, ""))
    1837                 return NULL;
    1838         _rv = GetApplicationEventTarget();
    1839         _res = Py_BuildValue("O&",
    1840                              EventTargetRef_New, _rv);
    1841         return _res;
     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;
    18421830}
    18431831
    18441832static PyObject *CarbonEvents_GetUserFocusEventTarget(PyObject *_self, PyObject *_args)
    18451833{
    1846         PyObject *_res = NULL;
    1847         EventTargetRef _rv;
    1848         if (!PyArg_ParseTuple(_args, ""))
    1849                 return NULL;
    1850         _rv = GetUserFocusEventTarget();
    1851         _res = Py_BuildValue("O&",
    1852                              EventTargetRef_New, _rv);
    1853         return _res;
     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;
    18541842}
    18551843
    18561844static PyObject *CarbonEvents_GetEventDispatcherTarget(PyObject *_self, PyObject *_args)
    18571845{
    1858         PyObject *_res = NULL;
    1859         EventTargetRef _rv;
    1860         if (!PyArg_ParseTuple(_args, ""))
    1861                 return NULL;
    1862         _rv = GetEventDispatcherTarget();
    1863         _res = Py_BuildValue("O&",
    1864                              EventTargetRef_New, _rv);
    1865         return _res;
     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;
    18661854}
    18671855
    18681856static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args)
    18691857{
    1870         PyObject *_res = NULL;
    1871         if (!PyArg_ParseTuple(_args, ""))
    1872                 return NULL;
    1873         RunApplicationEventLoop();
    1874         Py_INCREF(Py_None);
    1875         _res = Py_None;
    1876         return _res;
     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;
    18771865}
    18781866
    18791867static PyObject *CarbonEvents_QuitApplicationEventLoop(PyObject *_self, PyObject *_args)
    18801868{
    1881         PyObject *_res = NULL;
    1882         if (!PyArg_ParseTuple(_args, ""))
    1883                 return NULL;
    1884         QuitApplicationEventLoop();
    1885         Py_INCREF(Py_None);
    1886         _res = Py_None;
    1887         return _res;
     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;
    18881876}
    18891877
    18901878static PyObject *CarbonEvents_RunAppModalLoopForWindow(PyObject *_self, PyObject *_args)
    18911879{
    1892         PyObject *_res = NULL;
    1893         OSStatus _err;
    1894         WindowPtr inWindow;
    1895         if (!PyArg_ParseTuple(_args, "O&",
    1896                               WinObj_Convert, &inWindow))
    1897                 return NULL;
    1898         _err = RunAppModalLoopForWindow(inWindow);
    1899         if (_err != noErr) return PyMac_Error(_err);
    1900         Py_INCREF(Py_None);
    1901         _res = Py_None;
    1902         return _res;
     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;
    19031891}
    19041892
    19051893static PyObject *CarbonEvents_QuitAppModalLoopForWindow(PyObject *_self, PyObject *_args)
    19061894{
    1907         PyObject *_res = NULL;
    1908         OSStatus _err;
    1909         WindowPtr inWindow;
    1910         if (!PyArg_ParseTuple(_args, "O&",
    1911                               WinObj_Convert, &inWindow))
    1912                 return NULL;
    1913         _err = QuitAppModalLoopForWindow(inWindow);
    1914         if (_err != noErr) return PyMac_Error(_err);
    1915         Py_INCREF(Py_None);
    1916         _res = Py_None;
    1917         return _res;
     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;
    19181906}
    19191907
    19201908static PyObject *CarbonEvents_BeginAppModalStateForWindow(PyObject *_self, PyObject *_args)
    19211909{
    1922         PyObject *_res = NULL;
    1923         OSStatus _err;
    1924         WindowPtr inWindow;
    1925         if (!PyArg_ParseTuple(_args, "O&",
    1926                               WinObj_Convert, &inWindow))
    1927                 return NULL;
    1928         _err = BeginAppModalStateForWindow(inWindow);
    1929         if (_err != noErr) return PyMac_Error(_err);
    1930         Py_INCREF(Py_None);
    1931         _res = Py_None;
    1932         return _res;
     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;
    19331921}
    19341922
    19351923static PyObject *CarbonEvents_EndAppModalStateForWindow(PyObject *_self, PyObject *_args)
    19361924{
    1937         PyObject *_res = NULL;
    1938         OSStatus _err;
    1939         WindowPtr inWindow;
    1940         if (!PyArg_ParseTuple(_args, "O&",
    1941                               WinObj_Convert, &inWindow))
    1942                 return NULL;
    1943         _err = EndAppModalStateForWindow(inWindow);
    1944         if (_err != noErr) return PyMac_Error(_err);
    1945         Py_INCREF(Py_None);
    1946         _res = Py_None;
    1947         return _res;
     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;
    19481936}
    19491937
    19501938static PyObject *CarbonEvents_SetUserFocusWindow(PyObject *_self, PyObject *_args)
    19511939{
    1952         PyObject *_res = NULL;
    1953         OSStatus _err;
    1954         WindowPtr inWindow;
    1955         if (!PyArg_ParseTuple(_args, "O&",
    1956                               WinObj_Convert, &inWindow))
    1957                 return NULL;
    1958         _err = SetUserFocusWindow(inWindow);
    1959         if (_err != noErr) return PyMac_Error(_err);
    1960         Py_INCREF(Py_None);
    1961         _res = Py_None;
    1962         return _res;
     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;
    19631951}
    19641952
    19651953static PyObject *CarbonEvents_GetUserFocusWindow(PyObject *_self, PyObject *_args)
    19661954{
    1967         PyObject *_res = NULL;
    1968         WindowPtr _rv;
    1969         if (!PyArg_ParseTuple(_args, ""))
    1970                 return NULL;
    1971         _rv = GetUserFocusWindow();
    1972         _res = Py_BuildValue("O&",
    1973                              WinObj_New, _rv);
    1974         return _res;
     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;
    19751963}
    19761964
    19771965static PyObject *CarbonEvents_SetWindowDefaultButton(PyObject *_self, PyObject *_args)
    19781966{
    1979         PyObject *_res = NULL;
    1980         OSStatus _err;
    1981         WindowPtr inWindow;
    1982         ControlHandle inControl;
    1983         if (!PyArg_ParseTuple(_args, "O&O&",
    1984                               WinObj_Convert, &inWindow,
    1985                               CtlObj_Convert, &inControl))
    1986                 return NULL;
    1987         _err = SetWindowDefaultButton(inWindow,
    1988                                       inControl);
    1989         if (_err != noErr) return PyMac_Error(_err);
    1990         Py_INCREF(Py_None);
    1991         _res = Py_None;
    1992         return _res;
     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;
    19931981}
    19941982
    19951983static PyObject *CarbonEvents_SetWindowCancelButton(PyObject *_self, PyObject *_args)
    19961984{
    1997         PyObject *_res = NULL;
    1998         OSStatus _err;
    1999         WindowPtr inWindow;
    2000         ControlHandle inControl;
    2001         if (!PyArg_ParseTuple(_args, "O&O&",
    2002                               WinObj_Convert, &inWindow,
    2003                               CtlObj_Convert, &inControl))
    2004                 return NULL;
    2005         _err = SetWindowCancelButton(inWindow,
    2006                                      inControl);
    2007         if (_err != noErr) return PyMac_Error(_err);
    2008         Py_INCREF(Py_None);
    2009         _res = Py_None;
    2010         return _res;
     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;
    20111999}
    20122000
    20132001static PyObject *CarbonEvents_GetWindowDefaultButton(PyObject *_self, PyObject *_args)
    20142002{
    2015         PyObject *_res = NULL;
    2016         OSStatus _err;
    2017         WindowPtr inWindow;
    2018         ControlHandle outControl;
    2019         if (!PyArg_ParseTuple(_args, "O&",
    2020                               WinObj_Convert, &inWindow))
    2021                 return NULL;
    2022         _err = GetWindowDefaultButton(inWindow,
    2023                                       &outControl);
    2024         if (_err != noErr) return PyMac_Error(_err);
    2025         _res = Py_BuildValue("O&",
    2026                              CtlObj_New, outControl);
    2027         return _res;
     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;
    20282016}
    20292017
    20302018static PyObject *CarbonEvents_GetWindowCancelButton(PyObject *_self, PyObject *_args)
    20312019{
    2032         PyObject *_res = NULL;
    2033         OSStatus _err;
    2034         WindowPtr inWindow;
    2035         ControlHandle outControl;
    2036         if (!PyArg_ParseTuple(_args, "O&",
    2037                               WinObj_Convert, &inWindow))
    2038                 return NULL;
    2039         _err = GetWindowCancelButton(inWindow,
    2040                                      &outControl);
    2041         if (_err != noErr) return PyMac_Error(_err);
    2042         _res = Py_BuildValue("O&",
    2043                              CtlObj_New, outControl);
    2044         return _res;
     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;
    20452033}
    20462034
    20472035static PyObject *CarbonEvents_RegisterEventHotKey(PyObject *_self, PyObject *_args)
    20482036{
    2049         PyObject *_res = NULL;
    2050         OSStatus _err;
    2051         UInt32 inHotKeyCode;
    2052         UInt32 inHotKeyModifiers;
    2053         EventHotKeyID inHotKeyID;
    2054         EventTargetRef inTarget;
    2055         OptionBits inOptions;
    2056         EventHotKeyRef outRef;
    2057         if (!PyArg_ParseTuple(_args, "llO&O&l",
    2058                               &inHotKeyCode,
    2059                               &inHotKeyModifiers,
    2060                               EventHotKeyID_Convert, &inHotKeyID,
    2061                               EventTargetRef_Convert, &inTarget,
    2062                               &inOptions))
    2063                 return NULL;
    2064         _err = RegisterEventHotKey(inHotKeyCode,
    2065                                    inHotKeyModifiers,
    2066                                    inHotKeyID,
    2067                                    inTarget,
    2068                                    inOptions,
    2069                                    &outRef);
    2070         if (_err != noErr) return PyMac_Error(_err);
    2071         _res = Py_BuildValue("O&",
    2072                              EventHotKeyRef_New, outRef);
    2073         return _res;
     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;
    20742062}
    20752063
    20762064static PyMethodDef CarbonEvents_methods[] = {
    2077         {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
    2078         PyDoc_STR("() -> (EventLoopRef _rv)")},
    2079         {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
    2080         PyDoc_STR("() -> (EventLoopRef _rv)")},
    2081         {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
    2082         PyDoc_STR("(double inTimeout) -> None")},
    2083         {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
    2084         PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
    2085         {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
    2086         PyDoc_STR("() -> (EventQueueRef _rv)")},
    2087         {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
    2088         PyDoc_STR("() -> (EventQueueRef _rv)")},
    2089         {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
    2090         PyDoc_STR("() -> (double _rv)")},
    2091         {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
    2092         PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
    2093         {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
    2094         PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
    2095         {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
    2096         PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
    2097         {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
    2098         PyDoc_STR("() -> (double _rv)")},
    2099         {"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
    2100         PyDoc_STR("() -> (Boolean _rv)")},
    2101         {"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
    2102         PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
    2103         {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
    2104         PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
    2105         {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
    2106         PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
    2107         {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
    2108         PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
    2109         {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
    2110         PyDoc_STR("() -> (EventTargetRef _rv)")},
    2111         {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
    2112         PyDoc_STR("() -> (EventTargetRef _rv)")},
    2113         {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
    2114         PyDoc_STR("() -> (EventTargetRef _rv)")},
    2115         {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
    2116         PyDoc_STR("() -> None")},
    2117         {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
    2118         PyDoc_STR("() -> None")},
    2119         {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
    2120         PyDoc_STR("(WindowPtr inWindow) -> None")},
    2121         {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
    2122         PyDoc_STR("(WindowPtr inWindow) -> None")},
    2123         {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
    2124         PyDoc_STR("(WindowPtr inWindow) -> None")},
    2125         {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
    2126         PyDoc_STR("(WindowPtr inWindow) -> None")},
    2127         {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
    2128         PyDoc_STR("(WindowPtr inWindow) -> None")},
    2129         {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
    2130         PyDoc_STR("() -> (WindowPtr _rv)")},
    2131         {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
    2132         PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
    2133         {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
    2134         PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
    2135         {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
    2136         PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
    2137         {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
    2138         PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
    2139         {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
    2140         PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
    2141         {NULL, NULL, 0}
     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}
    21422130};
    21432131
    … …  
    21452133
    21462134static PyMethodDef CarbonEvents_methods[] = {
    2147         {NULL, NULL, 0}
     2135    {NULL, NULL, 0}
    21482136};
    21492137
    … …  
    21542142void init_CarbonEvt(void)
    21552143{
    2156         PyObject *m;
     2144    PyObject *m;
    21572145#ifndef __LP64__
    2158         PyObject *d;
     2146    PyObject *d;
    21592147#endif /* !__LP64__ */
    21602148
    21612149
    2162         m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
     2150    m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
    21632151
    21642152#ifndef __LP64__
    2165         myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
    2166         d = PyModule_GetDict(m);
    2167         CarbonEvents_Error = PyMac_GetOSErrException();
    2168         if (CarbonEvents_Error == NULL ||
    2169             PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
    2170                 return;
    2171         EventRef_Type.ob_type = &PyType_Type;
    2172         if (PyType_Ready(&EventRef_Type) < 0) return;
    2173         Py_INCREF(&EventRef_Type);
    2174         PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
    2175         /* Backward-compatible name */
    2176         Py_INCREF(&EventRef_Type);
    2177         PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
    2178         EventQueueRef_Type.ob_type = &PyType_Type;
    2179         if (PyType_Ready(&EventQueueRef_Type) < 0) return;
    2180         Py_INCREF(&EventQueueRef_Type);
    2181         PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
    2182         /* Backward-compatible name */
    2183         Py_INCREF(&EventQueueRef_Type);
    2184         PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
    2185         EventLoopRef_Type.ob_type = &PyType_Type;
    2186         if (PyType_Ready(&EventLoopRef_Type) < 0) return;
    2187         Py_INCREF(&EventLoopRef_Type);
    2188         PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
    2189         /* Backward-compatible name */
    2190         Py_INCREF(&EventLoopRef_Type);
    2191         PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
    2192         EventLoopTimerRef_Type.ob_type = &PyType_Type;
    2193         if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
    2194         Py_INCREF(&EventLoopTimerRef_Type);
    2195         PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
    2196         /* Backward-compatible name */
    2197         Py_INCREF(&EventLoopTimerRef_Type);
    2198         PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
    2199         EventHandlerRef_Type.ob_type = &PyType_Type;
    2200         if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
    2201         Py_INCREF(&EventHandlerRef_Type);
    2202         PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
    2203         /* Backward-compatible name */
    2204         Py_INCREF(&EventHandlerRef_Type);
    2205         PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
    2206         EventHandlerCallRef_Type.ob_type = &PyType_Type;
    2207         if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
    2208         Py_INCREF(&EventHandlerCallRef_Type);
    2209         PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
    2210         /* Backward-compatible name */
    2211         Py_INCREF(&EventHandlerCallRef_Type);
    2212         PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
    2213         EventTargetRef_Type.ob_type = &PyType_Type;
    2214         if (PyType_Ready(&EventTargetRef_Type) < 0) return;
    2215         Py_INCREF(&EventTargetRef_Type);
    2216         PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
    2217         /* Backward-compatible name */
    2218         Py_INCREF(&EventTargetRef_Type);
    2219         PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
    2220         EventHotKeyRef_Type.ob_type = &PyType_Type;
    2221         if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
    2222         Py_INCREF(&EventHotKeyRef_Type);
    2223         PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
    2224         /* Backward-compatible name */
    2225         Py_INCREF(&EventHotKeyRef_Type);
    2226         PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type);
     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);
    22272215#endif /* !__LP64__ */
    22282216}
Note: See TracChangeset for help on using the changeset viewer.