Untabify C files. Will watch buildbots.

1 files changed, 1468 insertions, 1468 deletions

diff --git a/Mac/Modules/carbonevt/_CarbonEvtmodule.c b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
index 893beec..623a3e5 100755
--- a/Mac/Modules/carbonevt/_CarbonEvtmodule.c
+++ b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
@@ -9,9 +9,9 @@
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
-        PyErr_SetString(PyExc_NotImplementedError, \
-        "Not available in this shared library/OS version"); \
-        return NULL; \
+    PyErr_SetString(PyExc_NotImplementedError, \
+    "Not available in this shared library/OS version"); \
+    return NULL; \
     }} while(0)
 
 
@@ -30,11 +30,11 @@ PyObject *EventRef_New(EventRef itself);
 static int
 EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)
 {
-        if (PyArg_Parse(v, "(O&l)",
-                        PyMac_GetOSType, &(out->eventClass),
-                        &(out->eventKind)))
-                return 1;
-        return 0;
+    if (PyArg_Parse(v, "(O&l)",
+                    PyMac_GetOSType, &(out->eventClass),
+                    &(out->eventKind)))
+        return 1;
+    return 0;
 }
 
 /********** end EventTypeSpec *******/
@@ -45,15 +45,15 @@ EventTypeSpec_Convert(PyObject *v, EventTypeSpec *out)
 static PyObject*
 HIPoint_New(HIPoint *in)
 {
-        return Py_BuildValue("ff", in->x, in->y);
+    return Py_BuildValue("ff", in->x, in->y);
 }
 
 static int
 HIPoint_Convert(PyObject *v, HIPoint *out)
 {
-        if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))
-                return 1;
-        return NULL;
+    if (PyArg_ParseTuple(v, "ff", &(out->x), &(out->y)))
+        return 1;
+    return NULL;
 }
 #endif
 
@@ -64,9 +64,9 @@ HIPoint_Convert(PyObject *v, HIPoint *out)
 static int
 EventHotKeyID_Convert(PyObject *v, EventHotKeyID *out)
 {
-        if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))
-                return 1;
-        return 0;
+    if (PyArg_ParseTuple(v, "ll", &out->signature, &out->id))
+        return 1;
+    return 0;
 }
 
 /********** end EventHotKeyID *******/
@@ -77,27 +77,27 @@ static EventHandlerUPP myEventHandlerUPP;
 
 static pascal OSStatus
 myEventHandler(EventHandlerCallRef handlerRef, EventRef event, void *outPyObject) {
-        PyObject *retValue;
-        int status;
-
-        retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",
-                                         EventHandlerCallRef_New, handlerRef,
-                                         EventRef_New, event);
-        if (retValue == NULL) {
-                PySys_WriteStderr("Error in event handler callback:\n");
-                PyErr_Print();  /* this also clears the error */
-                status = noErr; /* complain? how? */
-        } else {
-                if (retValue == Py_None)
-                        status = noErr;
-                else if (PyInt_Check(retValue)) {
-                        status = PyInt_AsLong(retValue);
-                } else
-                        status = noErr; /* wrong object type, complain? */
-                Py_DECREF(retValue);
-        }
-
-        return status;
+    PyObject *retValue;
+    int status;
+
+    retValue = PyObject_CallFunction((PyObject *)outPyObject, "O&O&",
+                                     EventHandlerCallRef_New, handlerRef,
+                                     EventRef_New, event);
+    if (retValue == NULL) {
+        PySys_WriteStderr("Error in event handler callback:\n");
+        PyErr_Print();  /* this also clears the error */
+        status = noErr; /* complain? how? */
+    } else {
+        if (retValue == Py_None)
+            status = noErr;
+        else if (PyInt_Check(retValue)) {
+            status = PyInt_AsLong(retValue);
+        } else
+            status = noErr; /* wrong object type, complain? */
+        Py_DECREF(retValue);
+    }
+
+    return status;
 }
 
 /******** end myEventHandler ***********/
@@ -112,268 +112,268 @@ PyTypeObject EventRef_Type;
 #define EventRef_Check(x) ((x)->ob_type == &EventRef_Type || PyObject_TypeCheck((x), &EventRef_Type))
 
 typedef struct EventRefObject {
-	PyObject_HEAD
-	EventRef ob_itself;
+    PyObject_HEAD
+    EventRef ob_itself;
 } EventRefObject;
 
 PyObject *EventRef_New(EventRef itself)
 {
-	EventRefObject *it;
-	it = PyObject_NEW(EventRefObject, &EventRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventRefObject *it;
+    it = PyObject_NEW(EventRefObject, &EventRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventRef_Convert(PyObject *v, EventRef *p_itself)
 {
-	if (!EventRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventRef required");
-		return 0;
-	}
-	*p_itself = ((EventRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventRef required");
+        return 0;
+    }
+    *p_itself = ((EventRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventRef_dealloc(EventRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventRef_RetainEvent(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = RetainEvent(_self->ob_itself);
-	_res = Py_BuildValue("O&",
-	                     EventRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = RetainEvent(_self->ob_itself);
+    _res = Py_BuildValue("O&",
+                         EventRef_New, _rv);
+    return _res;
 }
 
 static PyObject *EventRef_GetEventRetainCount(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	UInt32 _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetEventRetainCount(_self->ob_itself);
-	_res = Py_BuildValue("l",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    UInt32 _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetEventRetainCount(_self->ob_itself);
+    _res = Py_BuildValue("l",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_ReleaseEvent(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	ReleaseEvent(_self->ob_itself);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    ReleaseEvent(_self->ob_itself);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventRef_SetEventParameter(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	OSType inName;
-	OSType inType;
-	char *inDataPtr__in__;
-	long inDataPtr__len__;
-	int inDataPtr__in_len__;
-	if (!PyArg_ParseTuple(_args, "O&O&s#",
-	                      PyMac_GetOSType, &inName,
-	                      PyMac_GetOSType, &inType,
-	                      &inDataPtr__in__, &inDataPtr__in_len__))
-		return NULL;
-	inDataPtr__len__ = inDataPtr__in_len__;
-	_err = SetEventParameter(_self->ob_itself,
-	                         inName,
-	                         inType,
-	                         inDataPtr__len__, inDataPtr__in__);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    OSType inName;
+    OSType inType;
+    char *inDataPtr__in__;
+    long inDataPtr__len__;
+    int inDataPtr__in_len__;
+    if (!PyArg_ParseTuple(_args, "O&O&s#",
+                          PyMac_GetOSType, &inName,
+                          PyMac_GetOSType, &inType,
+                          &inDataPtr__in__, &inDataPtr__in_len__))
+        return NULL;
+    inDataPtr__len__ = inDataPtr__in_len__;
+    _err = SetEventParameter(_self->ob_itself,
+                             inName,
+                             inType,
+                             inDataPtr__len__, inDataPtr__in__);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventRef_GetEventClass(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	UInt32 _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetEventClass(_self->ob_itself);
-	_res = Py_BuildValue("l",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    UInt32 _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetEventClass(_self->ob_itself);
+    _res = Py_BuildValue("l",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_GetEventKind(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	UInt32 _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetEventKind(_self->ob_itself);
-	_res = Py_BuildValue("l",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    UInt32 _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetEventKind(_self->ob_itself);
+    _res = Py_BuildValue("l",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_GetEventTime(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	double _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetEventTime(_self->ob_itself);
-	_res = Py_BuildValue("d",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    double _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetEventTime(_self->ob_itself);
+    _res = Py_BuildValue("d",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_SetEventTime(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	double inTime;
-	if (!PyArg_ParseTuple(_args, "d",
-	                      &inTime))
-		return NULL;
-	_err = SetEventTime(_self->ob_itself,
-	                    inTime);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    double inTime;
+    if (!PyArg_ParseTuple(_args, "d",
+                          &inTime))
+        return NULL;
+    _err = SetEventTime(_self->ob_itself,
+                        inTime);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventRef_IsUserCancelEventRef(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	Boolean _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = IsUserCancelEventRef(_self->ob_itself);
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    Boolean _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = IsUserCancelEventRef(_self->ob_itself);
+    _res = Py_BuildValue("b",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_ConvertEventRefToEventRecord(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	Boolean _rv;
-	EventRecord outEvent;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = ConvertEventRefToEventRecord(_self->ob_itself,
-	                                   &outEvent);
-	_res = Py_BuildValue("bO&",
-	                     _rv,
-	                     PyMac_BuildEventRecord, &outEvent);
-	return _res;
+    PyObject *_res = NULL;
+    Boolean _rv;
+    EventRecord outEvent;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = ConvertEventRefToEventRecord(_self->ob_itself,
+                                       &outEvent);
+    _res = Py_BuildValue("bO&",
+                         _rv,
+                         PyMac_BuildEventRecord, &outEvent);
+    return _res;
 }
 
 static PyObject *EventRef_IsEventInMask(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	Boolean _rv;
-	UInt16 inMask;
-	if (!PyArg_ParseTuple(_args, "H",
-	                      &inMask))
-		return NULL;
-	_rv = IsEventInMask(_self->ob_itself,
-	                    inMask);
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    Boolean _rv;
+    UInt16 inMask;
+    if (!PyArg_ParseTuple(_args, "H",
+                          &inMask))
+        return NULL;
+    _rv = IsEventInMask(_self->ob_itself,
+                        inMask);
+    _res = Py_BuildValue("b",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventRef_SendEventToEventTarget(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	EventTargetRef inTarget;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      EventTargetRef_Convert, &inTarget))
-		return NULL;
-	_err = SendEventToEventTarget(_self->ob_itself,
-	                              inTarget);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    EventTargetRef inTarget;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          EventTargetRef_Convert, &inTarget))
+        return NULL;
+    _err = SendEventToEventTarget(_self->ob_itself,
+                                  inTarget);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
+    PyObject *_res = NULL;
 
-	UInt32 bufferSize;
-	EventParamName inName;
-	EventParamType inType;
-	OSErr _err;
-	void * buffer;
+    UInt32 bufferSize;
+    EventParamName inName;
+    EventParamType inType;
+    OSErr _err;
+    void * buffer;
 
-	if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))
-	      return NULL;
+    if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetOSType, &inName, PyMac_GetOSType, &inType))
+          return NULL;
 
-	/* Figure out the size by passing a null buffer to GetEventParameter */
-	_err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);
+    /* Figure out the size by passing a null buffer to GetEventParameter */
+    _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, 0, &bufferSize, NULL);
 
-	if (_err != noErr)
-	      return PyMac_Error(_err);
-	buffer = PyMem_NEW(char, bufferSize);
-	if (buffer == NULL)
-	      return PyErr_NoMemory();
+    if (_err != noErr)
+          return PyMac_Error(_err);
+    buffer = PyMem_NEW(char, bufferSize);
+    if (buffer == NULL)
+          return PyErr_NoMemory();
 
-	_err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);
+    _err = GetEventParameter(_self->ob_itself, inName, inType, NULL, bufferSize, NULL, buffer);
 
-	if (_err != noErr) {
-	      PyMem_DEL(buffer);
-	      return PyMac_Error(_err);
-	}
-	_res = Py_BuildValue("s#", buffer, bufferSize);
-	PyMem_DEL(buffer);
-	return _res;
+    if (_err != noErr) {
+          PyMem_DEL(buffer);
+          return PyMac_Error(_err);
+    }
+    _res = Py_BuildValue("s#", buffer, bufferSize);
+    PyMem_DEL(buffer);
+    return _res;
 
 }
 
 static PyMethodDef EventRef_methods[] = {
-	{"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
-	 PyDoc_STR("() -> (EventRef _rv)")},
-	{"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
-	 PyDoc_STR("() -> (UInt32 _rv)")},
-	{"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
-	 PyDoc_STR("() -> None")},
-	{"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
-	 PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
-	{"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
-	 PyDoc_STR("() -> (UInt32 _rv)")},
-	{"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
-	 PyDoc_STR("() -> (UInt32 _rv)")},
-	{"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
-	 PyDoc_STR("() -> (double _rv)")},
-	{"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
-	 PyDoc_STR("(double inTime) -> None")},
-	{"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
-	 PyDoc_STR("() -> (Boolean _rv)")},
-	{"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
-	 PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
-	{"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
-	 PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
-	{"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
-	 PyDoc_STR("(EventTargetRef inTarget) -> None")},
-	{"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
-	 PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
-	{NULL, NULL, 0}
+    {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
+     PyDoc_STR("() -> (EventRef _rv)")},
+    {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
+     PyDoc_STR("() -> (UInt32 _rv)")},
+    {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
+     PyDoc_STR("() -> None")},
+    {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
+     PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
+    {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
+     PyDoc_STR("() -> (UInt32 _rv)")},
+    {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
+     PyDoc_STR("() -> (UInt32 _rv)")},
+    {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
+     PyDoc_STR("() -> (double _rv)")},
+    {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
+     PyDoc_STR("(double inTime) -> None")},
+    {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
+     PyDoc_STR("() -> (Boolean _rv)")},
+    {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
+     PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
+    {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
+     PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
+    {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
+     PyDoc_STR("(EventTargetRef inTarget) -> None")},
+    {"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
+     PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
+    {NULL, NULL, 0}
 };
 
 #define EventRef_getsetlist NULL
@@ -390,61 +390,61 @@ static PyMethodDef EventRef_methods[] = {
 
 static PyObject *EventRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventRef_tp_free PyObject_Del
 
 
 PyTypeObject EventRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventRef", /*tp_name*/
-	sizeof(EventRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventRef_compare, /*tp_compare*/
-	(reprfunc) EventRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventRef_tp_init, /* tp_init */
-	EventRef_tp_alloc, /* tp_alloc */
-	EventRef_tp_new, /* tp_new */
-	EventRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventRef", /*tp_name*/
+    sizeof(EventRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventRef_compare, /*tp_compare*/
+    (reprfunc) EventRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventRef_tp_init, /* tp_init */
+    EventRef_tp_alloc, /* tp_alloc */
+    EventRef_tp_new, /* tp_new */
+    EventRef_tp_free, /* tp_free */
 };
 
 /* -------------------- End object type EventRef -------------------- */
@@ -457,144 +457,144 @@ PyTypeObject EventQueueRef_Type;
 #define EventQueueRef_Check(x) ((x)->ob_type == &EventQueueRef_Type || PyObject_TypeCheck((x), &EventQueueRef_Type))
 
 typedef struct EventQueueRefObject {
-	PyObject_HEAD
-	EventQueueRef ob_itself;
+    PyObject_HEAD
+    EventQueueRef ob_itself;
 } EventQueueRefObject;
 
 PyObject *EventQueueRef_New(EventQueueRef itself)
 {
-	EventQueueRefObject *it;
-	it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventQueueRefObject *it;
+    it = PyObject_NEW(EventQueueRefObject, &EventQueueRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventQueueRef_Convert(PyObject *v, EventQueueRef *p_itself)
 {
-	if (!EventQueueRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventQueueRef required");
-		return 0;
-	}
-	*p_itself = ((EventQueueRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventQueueRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventQueueRef required");
+        return 0;
+    }
+    *p_itself = ((EventQueueRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventQueueRef_dealloc(EventQueueRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventQueueRef_PostEventToQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	EventRef inEvent;
-	SInt16 inPriority;
-	if (!PyArg_ParseTuple(_args, "O&h",
-	                      EventRef_Convert, &inEvent,
-	                      &inPriority))
-		return NULL;
-	_err = PostEventToQueue(_self->ob_itself,
-	                        inEvent,
-	                        inPriority);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    EventRef inEvent;
+    SInt16 inPriority;
+    if (!PyArg_ParseTuple(_args, "O&h",
+                          EventRef_Convert, &inEvent,
+                          &inPriority))
+        return NULL;
+    _err = PostEventToQueue(_self->ob_itself,
+                            inEvent,
+                            inPriority);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventQueueRef_FlushEventsMatchingListFromQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	UInt32 inNumTypes;
-	EventTypeSpec inList;
-	if (!PyArg_ParseTuple(_args, "lO&",
-	                      &inNumTypes,
-	                      EventTypeSpec_Convert, &inList))
-		return NULL;
-	_err = FlushEventsMatchingListFromQueue(_self->ob_itself,
-	                                        inNumTypes,
-	                                        &inList);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    UInt32 inNumTypes;
+    EventTypeSpec inList;
+    if (!PyArg_ParseTuple(_args, "lO&",
+                          &inNumTypes,
+                          EventTypeSpec_Convert, &inList))
+        return NULL;
+    _err = FlushEventsMatchingListFromQueue(_self->ob_itself,
+                                            inNumTypes,
+                                            &inList);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventQueueRef_FlushEventQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = FlushEventQueue(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = FlushEventQueue(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventQueueRef_GetNumEventsInQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	UInt32 _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetNumEventsInQueue(_self->ob_itself);
-	_res = Py_BuildValue("l",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    UInt32 _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetNumEventsInQueue(_self->ob_itself);
+    _res = Py_BuildValue("l",
+                         _rv);
+    return _res;
 }
 
 static PyObject *EventQueueRef_RemoveEventFromQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	EventRef inEvent;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      EventRef_Convert, &inEvent))
-		return NULL;
-	_err = RemoveEventFromQueue(_self->ob_itself,
-	                            inEvent);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    EventRef inEvent;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          EventRef_Convert, &inEvent))
+        return NULL;
+    _err = RemoveEventFromQueue(_self->ob_itself,
+                                inEvent);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	Boolean _rv;
-	EventRef inEvent;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      EventRef_Convert, &inEvent))
-		return NULL;
-	_rv = IsEventInQueue(_self->ob_itself,
-	                     inEvent);
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    Boolean _rv;
+    EventRef inEvent;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          EventRef_Convert, &inEvent))
+        return NULL;
+    _rv = IsEventInQueue(_self->ob_itself,
+                         inEvent);
+    _res = Py_BuildValue("b",
+                         _rv);
+    return _res;
 }
 
 static PyMethodDef EventQueueRef_methods[] = {
-	{"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
-	 PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
-	{"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
-	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
-	{"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
-	 PyDoc_STR("() -> None")},
-	{"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
-	 PyDoc_STR("() -> (UInt32 _rv)")},
-	{"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
-	 PyDoc_STR("(EventRef inEvent) -> None")},
-	{"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
-	 PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
-	{NULL, NULL, 0}
+    {"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
+     PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
+    {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
+     PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
+    {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
+     PyDoc_STR("() -> None")},
+    {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
+     PyDoc_STR("() -> (UInt32 _rv)")},
+    {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
+     PyDoc_STR("(EventRef inEvent) -> None")},
+    {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
+     PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
+    {NULL, NULL, 0}
 };
 
 #define EventQueueRef_getsetlist NULL
@@ -611,61 +611,61 @@ static PyMethodDef EventQueueRef_methods[] = {
 
 static PyObject *EventQueueRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventQueueRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventQueueRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventQueueRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventQueueRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventQueueRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventQueueRef_tp_free PyObject_Del
 
 
 PyTypeObject EventQueueRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventQueueRef", /*tp_name*/
-	sizeof(EventQueueRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventQueueRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventQueueRef_compare, /*tp_compare*/
-	(reprfunc) EventQueueRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventQueueRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventQueueRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventQueueRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventQueueRef_tp_init, /* tp_init */
-	EventQueueRef_tp_alloc, /* tp_alloc */
-	EventQueueRef_tp_new, /* tp_new */
-	EventQueueRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventQueueRef", /*tp_name*/
+    sizeof(EventQueueRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventQueueRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventQueueRef_compare, /*tp_compare*/
+    (reprfunc) EventQueueRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventQueueRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventQueueRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventQueueRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventQueueRef_tp_init, /* tp_init */
+    EventQueueRef_tp_alloc, /* tp_alloc */
+    EventQueueRef_tp_new, /* tp_new */
+    EventQueueRef_tp_free, /* tp_free */
 };
 
 /* ----------------- End object type EventQueueRef ------------------ */
@@ -678,53 +678,53 @@ PyTypeObject EventLoopRef_Type;
 #define EventLoopRef_Check(x) ((x)->ob_type == &EventLoopRef_Type || PyObject_TypeCheck((x), &EventLoopRef_Type))
 
 typedef struct EventLoopRefObject {
-	PyObject_HEAD
-	EventLoopRef ob_itself;
+    PyObject_HEAD
+    EventLoopRef ob_itself;
 } EventLoopRefObject;
 
 PyObject *EventLoopRef_New(EventLoopRef itself)
 {
-	EventLoopRefObject *it;
-	it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventLoopRefObject *it;
+    it = PyObject_NEW(EventLoopRefObject, &EventLoopRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventLoopRef_Convert(PyObject *v, EventLoopRef *p_itself)
 {
-	if (!EventLoopRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventLoopRef required");
-		return 0;
-	}
-	*p_itself = ((EventLoopRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventLoopRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventLoopRef required");
+        return 0;
+    }
+    *p_itself = ((EventLoopRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventLoopRef_dealloc(EventLoopRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = QuitEventLoop(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = QuitEventLoop(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyMethodDef EventLoopRef_methods[] = {
-	{"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
-	 PyDoc_STR("() -> None")},
-	{NULL, NULL, 0}
+    {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
+     PyDoc_STR("() -> None")},
+    {NULL, NULL, 0}
 };
 
 #define EventLoopRef_getsetlist NULL
@@ -741,61 +741,61 @@ static PyMethodDef EventLoopRef_methods[] = {
 
 static PyObject *EventLoopRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventLoopRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventLoopRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventLoopRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventLoopRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventLoopRef_tp_free PyObject_Del
 
 
 PyTypeObject EventLoopRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventLoopRef", /*tp_name*/
-	sizeof(EventLoopRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventLoopRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventLoopRef_compare, /*tp_compare*/
-	(reprfunc) EventLoopRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventLoopRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventLoopRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventLoopRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventLoopRef_tp_init, /* tp_init */
-	EventLoopRef_tp_alloc, /* tp_alloc */
-	EventLoopRef_tp_new, /* tp_new */
-	EventLoopRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventLoopRef", /*tp_name*/
+    sizeof(EventLoopRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventLoopRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventLoopRef_compare, /*tp_compare*/
+    (reprfunc) EventLoopRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventLoopRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventLoopRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventLoopRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventLoopRef_tp_init, /* tp_init */
+    EventLoopRef_tp_alloc, /* tp_alloc */
+    EventLoopRef_tp_new, /* tp_new */
+    EventLoopRef_tp_free, /* tp_free */
 };
 
 /* ------------------ End object type EventLoopRef ------------------ */
@@ -808,71 +808,71 @@ PyTypeObject EventLoopTimerRef_Type;
 #define EventLoopTimerRef_Check(x) ((x)->ob_type == &EventLoopTimerRef_Type || PyObject_TypeCheck((x), &EventLoopTimerRef_Type))
 
 typedef struct EventLoopTimerRefObject {
-	PyObject_HEAD
-	EventLoopTimerRef ob_itself;
+    PyObject_HEAD
+    EventLoopTimerRef ob_itself;
 } EventLoopTimerRefObject;
 
 PyObject *EventLoopTimerRef_New(EventLoopTimerRef itself)
 {
-	EventLoopTimerRefObject *it;
-	it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventLoopTimerRefObject *it;
+    it = PyObject_NEW(EventLoopTimerRefObject, &EventLoopTimerRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventLoopTimerRef_Convert(PyObject *v, EventLoopTimerRef *p_itself)
 {
-	if (!EventLoopTimerRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required");
-		return 0;
-	}
-	*p_itself = ((EventLoopTimerRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventLoopTimerRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventLoopTimerRef required");
+        return 0;
+    }
+    *p_itself = ((EventLoopTimerRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventLoopTimerRef_dealloc(EventLoopTimerRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventLoopTimerRef_RemoveEventLoopTimer(EventLoopTimerRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = RemoveEventLoopTimer(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = RemoveEventLoopTimer(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	double inNextFire;
-	if (!PyArg_ParseTuple(_args, "d",
-	                      &inNextFire))
-		return NULL;
-	_err = SetEventLoopTimerNextFireTime(_self->ob_itself,
-	                                     inNextFire);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    double inNextFire;
+    if (!PyArg_ParseTuple(_args, "d",
+                          &inNextFire))
+        return NULL;
+    _err = SetEventLoopTimerNextFireTime(_self->ob_itself,
+                                         inNextFire);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyMethodDef EventLoopTimerRef_methods[] = {
-	{"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
-	 PyDoc_STR("() -> None")},
-	{"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
-	 PyDoc_STR("(double inNextFire) -> None")},
-	{NULL, NULL, 0}
+    {"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
+     PyDoc_STR("() -> None")},
+    {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
+     PyDoc_STR("(double inNextFire) -> None")},
+    {NULL, NULL, 0}
 };
 
 #define EventLoopTimerRef_getsetlist NULL
@@ -889,61 +889,61 @@ static PyMethodDef EventLoopTimerRef_methods[] = {
 
 static PyObject *EventLoopTimerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventLoopTimerRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventLoopTimerRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventLoopTimerRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventLoopTimerRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventLoopTimerRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventLoopTimerRef_tp_free PyObject_Del
 
 
 PyTypeObject EventLoopTimerRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventLoopTimerRef", /*tp_name*/
-	sizeof(EventLoopTimerRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/
-	(reprfunc) EventLoopTimerRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventLoopTimerRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventLoopTimerRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventLoopTimerRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventLoopTimerRef_tp_init, /* tp_init */
-	EventLoopTimerRef_tp_alloc, /* tp_alloc */
-	EventLoopTimerRef_tp_new, /* tp_new */
-	EventLoopTimerRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventLoopTimerRef", /*tp_name*/
+    sizeof(EventLoopTimerRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventLoopTimerRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventLoopTimerRef_compare, /*tp_compare*/
+    (reprfunc) EventLoopTimerRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventLoopTimerRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventLoopTimerRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventLoopTimerRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventLoopTimerRef_tp_init, /* tp_init */
+    EventLoopTimerRef_tp_alloc, /* tp_alloc */
+    EventLoopTimerRef_tp_new, /* tp_new */
+    EventLoopTimerRef_tp_free, /* tp_free */
 };
 
 /* --------------- End object type EventLoopTimerRef ---------------- */
@@ -956,116 +956,116 @@ PyTypeObject EventHandlerRef_Type;
 #define EventHandlerRef_Check(x) ((x)->ob_type == &EventHandlerRef_Type || PyObject_TypeCheck((x), &EventHandlerRef_Type))
 
 typedef struct EventHandlerRefObject {
-	PyObject_HEAD
-	EventHandlerRef ob_itself;
-	PyObject *ob_callback;
+    PyObject_HEAD
+    EventHandlerRef ob_itself;
+    PyObject *ob_callback;
 } EventHandlerRefObject;
 
 PyObject *EventHandlerRef_New(EventHandlerRef itself)
 {
-	EventHandlerRefObject *it;
-	it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	it->ob_callback = NULL;
-	return (PyObject *)it;
+    EventHandlerRefObject *it;
+    it = PyObject_NEW(EventHandlerRefObject, &EventHandlerRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    it->ob_callback = NULL;
+    return (PyObject *)it;
 }
 
 int EventHandlerRef_Convert(PyObject *v, EventHandlerRef *p_itself)
 {
-	if (!EventHandlerRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventHandlerRef required");
-		return 0;
-	}
-	*p_itself = ((EventHandlerRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventHandlerRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventHandlerRef required");
+        return 0;
+    }
+    *p_itself = ((EventHandlerRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventHandlerRef_dealloc(EventHandlerRefObject *self)
 {
-	if (self->ob_itself != NULL) {
-		RemoveEventHandler(self->ob_itself);
-		Py_DECREF(self->ob_callback);
-	}
-	self->ob_type->tp_free((PyObject *)self);
+    if (self->ob_itself != NULL) {
+        RemoveEventHandler(self->ob_itself);
+        Py_DECREF(self->ob_callback);
+    }
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHandlerRef_AddEventTypesToHandler(EventHandlerRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	UInt32 inNumTypes;
-	EventTypeSpec inList;
-	if (_self->ob_itself == NULL) {
-		PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
-		return NULL;
-	}
-	if (!PyArg_ParseTuple(_args, "lO&",
-	                      &inNumTypes,
-	                      EventTypeSpec_Convert, &inList))
-		return NULL;
-	_err = AddEventTypesToHandler(_self->ob_itself,
-	                              inNumTypes,
-	                              &inList);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    UInt32 inNumTypes;
+    EventTypeSpec inList;
+    if (_self->ob_itself == NULL) {
+        PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
+        return NULL;
+    }
+    if (!PyArg_ParseTuple(_args, "lO&",
+                          &inNumTypes,
+                          EventTypeSpec_Convert, &inList))
+        return NULL;
+    _err = AddEventTypesToHandler(_self->ob_itself,
+                                  inNumTypes,
+                                  &inList);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventHandlerRef_RemoveEventTypesFromHandler(EventHandlerRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	UInt32 inNumTypes;
-	EventTypeSpec inList;
-	if (_self->ob_itself == NULL) {
-		PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
-		return NULL;
-	}
-	if (!PyArg_ParseTuple(_args, "lO&",
-	                      &inNumTypes,
-	                      EventTypeSpec_Convert, &inList))
-		return NULL;
-	_err = RemoveEventTypesFromHandler(_self->ob_itself,
-	                                   inNumTypes,
-	                                   &inList);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    UInt32 inNumTypes;
+    EventTypeSpec inList;
+    if (_self->ob_itself == NULL) {
+        PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
+        return NULL;
+    }
+    if (!PyArg_ParseTuple(_args, "lO&",
+                          &inNumTypes,
+                          EventTypeSpec_Convert, &inList))
+        return NULL;
+    _err = RemoveEventTypesFromHandler(_self->ob_itself,
+                                       inNumTypes,
+                                       &inList);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-
-	OSStatus _err;
-	if (_self->ob_itself == NULL) {
-	        PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
-	        return NULL;
-	}
-	if (!PyArg_ParseTuple(_args, ""))
-	        return NULL;
-	_err = RemoveEventHandler(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	_self->ob_itself = NULL;
-	Py_DECREF(_self->ob_callback);
-	_self->ob_callback = NULL;
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+
+    OSStatus _err;
+    if (_self->ob_itself == NULL) {
+        PyErr_SetString(CarbonEvents_Error, "Handler has been removed");
+        return NULL;
+    }
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = RemoveEventHandler(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    _self->ob_itself = NULL;
+    Py_DECREF(_self->ob_callback);
+    _self->ob_callback = NULL;
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyMethodDef EventHandlerRef_methods[] = {
-	{"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
-	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
-	{"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
-	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
-	{"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
-	 PyDoc_STR("() -> None")},
-	{NULL, NULL, 0}
+    {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
+     PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
+    {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
+     PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
+    {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
+     PyDoc_STR("() -> None")},
+    {NULL, NULL, 0}
 };
 
 #define EventHandlerRef_getsetlist NULL
@@ -1082,61 +1082,61 @@ static PyMethodDef EventHandlerRef_methods[] = {
 
 static PyObject *EventHandlerRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventHandlerRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventHandlerRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventHandlerRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventHandlerRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventHandlerRef_tp_free PyObject_Del
 
 
 PyTypeObject EventHandlerRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventHandlerRef", /*tp_name*/
-	sizeof(EventHandlerRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventHandlerRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventHandlerRef_compare, /*tp_compare*/
-	(reprfunc) EventHandlerRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventHandlerRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventHandlerRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventHandlerRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventHandlerRef_tp_init, /* tp_init */
-	EventHandlerRef_tp_alloc, /* tp_alloc */
-	EventHandlerRef_tp_new, /* tp_new */
-	EventHandlerRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventHandlerRef", /*tp_name*/
+    sizeof(EventHandlerRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventHandlerRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventHandlerRef_compare, /*tp_compare*/
+    (reprfunc) EventHandlerRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventHandlerRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventHandlerRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventHandlerRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventHandlerRef_tp_init, /* tp_init */
+    EventHandlerRef_tp_alloc, /* tp_alloc */
+    EventHandlerRef_tp_new, /* tp_new */
+    EventHandlerRef_tp_free, /* tp_free */
 };
 
 /* ---------------- End object type EventHandlerRef ----------------- */
@@ -1149,56 +1149,56 @@ PyTypeObject EventHandlerCallRef_Type;
 #define EventHandlerCallRef_Check(x) ((x)->ob_type == &EventHandlerCallRef_Type || PyObject_TypeCheck((x), &EventHandlerCallRef_Type))
 
 typedef struct EventHandlerCallRefObject {
-	PyObject_HEAD
-	EventHandlerCallRef ob_itself;
+    PyObject_HEAD
+    EventHandlerCallRef ob_itself;
 } EventHandlerCallRefObject;
 
 PyObject *EventHandlerCallRef_New(EventHandlerCallRef itself)
 {
-	EventHandlerCallRefObject *it;
-	it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventHandlerCallRefObject *it;
+    it = PyObject_NEW(EventHandlerCallRefObject, &EventHandlerCallRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventHandlerCallRef_Convert(PyObject *v, EventHandlerCallRef *p_itself)
 {
-	if (!EventHandlerCallRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required");
-		return 0;
-	}
-	*p_itself = ((EventHandlerCallRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventHandlerCallRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventHandlerCallRef required");
+        return 0;
+    }
+    *p_itself = ((EventHandlerCallRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventHandlerCallRef_dealloc(EventHandlerCallRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	EventRef inEvent;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      EventRef_Convert, &inEvent))
-		return NULL;
-	_err = CallNextEventHandler(_self->ob_itself,
-	                            inEvent);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    EventRef inEvent;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          EventRef_Convert, &inEvent))
+        return NULL;
+    _err = CallNextEventHandler(_self->ob_itself,
+                                inEvent);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyMethodDef EventHandlerCallRef_methods[] = {
-	{"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
-	 PyDoc_STR("(EventRef inEvent) -> None")},
-	{NULL, NULL, 0}
+    {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
+     PyDoc_STR("(EventRef inEvent) -> None")},
+    {NULL, NULL, 0}
 };
 
 #define EventHandlerCallRef_getsetlist NULL
@@ -1215,61 +1215,61 @@ static PyMethodDef EventHandlerCallRef_methods[] = {
 
 static PyObject *EventHandlerCallRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventHandlerCallRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventHandlerCallRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventHandlerCallRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHandlerCallRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventHandlerCallRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventHandlerCallRef_tp_free PyObject_Del
 
 
 PyTypeObject EventHandlerCallRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventHandlerCallRef", /*tp_name*/
-	sizeof(EventHandlerCallRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/
-	(reprfunc) EventHandlerCallRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventHandlerCallRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventHandlerCallRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventHandlerCallRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventHandlerCallRef_tp_init, /* tp_init */
-	EventHandlerCallRef_tp_alloc, /* tp_alloc */
-	EventHandlerCallRef_tp_new, /* tp_new */
-	EventHandlerCallRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventHandlerCallRef", /*tp_name*/
+    sizeof(EventHandlerCallRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventHandlerCallRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventHandlerCallRef_compare, /*tp_compare*/
+    (reprfunc) EventHandlerCallRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventHandlerCallRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventHandlerCallRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventHandlerCallRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventHandlerCallRef_tp_init, /* tp_init */
+    EventHandlerCallRef_tp_alloc, /* tp_alloc */
+    EventHandlerCallRef_tp_new, /* tp_new */
+    EventHandlerCallRef_tp_free, /* tp_free */
 };
 
 /* -------------- End object type EventHandlerCallRef --------------- */
@@ -1282,78 +1282,78 @@ PyTypeObject EventTargetRef_Type;
 #define EventTargetRef_Check(x) ((x)->ob_type == &EventTargetRef_Type || PyObject_TypeCheck((x), &EventTargetRef_Type))
 
 typedef struct EventTargetRefObject {
-	PyObject_HEAD
-	EventTargetRef ob_itself;
+    PyObject_HEAD
+    EventTargetRef ob_itself;
 } EventTargetRefObject;
 
 PyObject *EventTargetRef_New(EventTargetRef itself)
 {
-	EventTargetRefObject *it;
-	it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventTargetRefObject *it;
+    it = PyObject_NEW(EventTargetRefObject, &EventTargetRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventTargetRef_Convert(PyObject *v, EventTargetRef *p_itself)
 {
-	if (!EventTargetRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventTargetRef required");
-		return 0;
-	}
-	*p_itself = ((EventTargetRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventTargetRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventTargetRef required");
+        return 0;
+    }
+    *p_itself = ((EventTargetRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventTargetRef_dealloc(EventTargetRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventTargetRef_InstallStandardEventHandler(EventTargetRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = InstallStandardEventHandler(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = InstallStandardEventHandler(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
+    PyObject *_res = NULL;
 
-	EventTypeSpec inSpec;
-	PyObject *callback;
-	EventHandlerRef outRef;
-	OSStatus _err;
+    EventTypeSpec inSpec;
+    PyObject *callback;
+    EventHandlerRef outRef;
+    OSStatus _err;
 
-	if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))
-	        return NULL;
+    if (!PyArg_ParseTuple(_args, "O&O", EventTypeSpec_Convert, &inSpec, &callback))
+        return NULL;
 
-	_err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);
-	if (_err != noErr) return PyMac_Error(_err);
+    _err = InstallEventHandler(_self->ob_itself, myEventHandlerUPP, 1, &inSpec, (void *)callback, &outRef);
+    if (_err != noErr) return PyMac_Error(_err);
 
-	_res = EventHandlerRef_New(outRef);
-	if (_res != NULL) {
-	        ((EventHandlerRefObject*)_res)->ob_callback = callback;
-	        Py_INCREF(callback);
-	}
-	return _res;
+    _res = EventHandlerRef_New(outRef);
+    if (_res != NULL) {
+        ((EventHandlerRefObject*)_res)->ob_callback = callback;
+        Py_INCREF(callback);
+    }
+    return _res;
 }
 
 static PyMethodDef EventTargetRef_methods[] = {
-	{"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
-	 PyDoc_STR("() -> None")},
-	{"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
-	 PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
-	{NULL, NULL, 0}
+    {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
+     PyDoc_STR("() -> None")},
+    {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
+     PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
+    {NULL, NULL, 0}
 };
 
 #define EventTargetRef_getsetlist NULL
@@ -1370,61 +1370,61 @@ static PyMethodDef EventTargetRef_methods[] = {
 
 static PyObject *EventTargetRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventTargetRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventTargetRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventTargetRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventTargetRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventTargetRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventTargetRef_tp_free PyObject_Del
 
 
 PyTypeObject EventTargetRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventTargetRef", /*tp_name*/
-	sizeof(EventTargetRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventTargetRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventTargetRef_compare, /*tp_compare*/
-	(reprfunc) EventTargetRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventTargetRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventTargetRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventTargetRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventTargetRef_tp_init, /* tp_init */
-	EventTargetRef_tp_alloc, /* tp_alloc */
-	EventTargetRef_tp_new, /* tp_new */
-	EventTargetRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventTargetRef", /*tp_name*/
+    sizeof(EventTargetRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventTargetRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventTargetRef_compare, /*tp_compare*/
+    (reprfunc) EventTargetRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventTargetRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventTargetRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventTargetRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventTargetRef_tp_init, /* tp_init */
+    EventTargetRef_tp_alloc, /* tp_alloc */
+    EventTargetRef_tp_new, /* tp_new */
+    EventTargetRef_tp_free, /* tp_free */
 };
 
 /* ----------------- End object type EventTargetRef ----------------- */
@@ -1437,53 +1437,53 @@ PyTypeObject EventHotKeyRef_Type;
 #define EventHotKeyRef_Check(x) ((x)->ob_type == &EventHotKeyRef_Type || PyObject_TypeCheck((x), &EventHotKeyRef_Type))
 
 typedef struct EventHotKeyRefObject {
-	PyObject_HEAD
-	EventHotKeyRef ob_itself;
+    PyObject_HEAD
+    EventHotKeyRef ob_itself;
 } EventHotKeyRefObject;
 
 PyObject *EventHotKeyRef_New(EventHotKeyRef itself)
 {
-	EventHotKeyRefObject *it;
-	it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	return (PyObject *)it;
+    EventHotKeyRefObject *it;
+    it = PyObject_NEW(EventHotKeyRefObject, &EventHotKeyRef_Type);
+    if (it == NULL) return NULL;
+    it->ob_itself = itself;
+    return (PyObject *)it;
 }
 
 int EventHotKeyRef_Convert(PyObject *v, EventHotKeyRef *p_itself)
 {
-	if (!EventHotKeyRef_Check(v))
-	{
-		PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required");
-		return 0;
-	}
-	*p_itself = ((EventHotKeyRefObject *)v)->ob_itself;
-	return 1;
+    if (!EventHotKeyRef_Check(v))
+    {
+        PyErr_SetString(PyExc_TypeError, "EventHotKeyRef required");
+        return 0;
+    }
+    *p_itself = ((EventHotKeyRefObject *)v)->ob_itself;
+    return 1;
 }
 
 static void EventHotKeyRef_dealloc(EventHotKeyRefObject *self)
 {
-	/* Cleanup of self->ob_itself goes here */
-	self->ob_type->tp_free((PyObject *)self);
+    /* Cleanup of self->ob_itself goes here */
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = UnregisterEventHotKey(_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _err = UnregisterEventHotKey(_self->ob_itself);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyMethodDef EventHotKeyRef_methods[] = {
-	{"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
-	 PyDoc_STR("() -> None")},
-	{NULL, NULL, 0}
+    {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
+     PyDoc_STR("() -> None")},
+    {NULL, NULL, 0}
 };
 
 #define EventHotKeyRef_getsetlist NULL
@@ -1500,61 +1500,61 @@ static PyMethodDef EventHotKeyRef_methods[] = {
 
 static PyObject *EventHotKeyRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 {
-	PyObject *_self;
-	EventHotKeyRef itself;
-	char *kw[] = {"itself", 0};
+    PyObject *_self;
+    EventHotKeyRef itself;
+    char *kw[] = {"itself", 0};
 
-	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL;
-	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
-	((EventHotKeyRefObject *)_self)->ob_itself = itself;
-	return _self;
+    if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, EventHotKeyRef_Convert, &itself)) return NULL;
+    if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
+    ((EventHotKeyRefObject *)_self)->ob_itself = itself;
+    return _self;
 }
 
 #define EventHotKeyRef_tp_free PyObject_Del
 
 
 PyTypeObject EventHotKeyRef_Type = {
-	PyObject_HEAD_INIT(NULL)
-	0, /*ob_size*/
-	"_CarbonEvt.EventHotKeyRef", /*tp_name*/
-	sizeof(EventHotKeyRefObject), /*tp_basicsize*/
-	0, /*tp_itemsize*/
-	/* methods */
-	(destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/
-	0, /*tp_print*/
-	(getattrfunc)0, /*tp_getattr*/
-	(setattrfunc)0, /*tp_setattr*/
-	(cmpfunc) EventHotKeyRef_compare, /*tp_compare*/
-	(reprfunc) EventHotKeyRef_repr, /*tp_repr*/
-	(PyNumberMethods *)0, /* tp_as_number */
-	(PySequenceMethods *)0, /* tp_as_sequence */
-	(PyMappingMethods *)0, /* tp_as_mapping */
-	(hashfunc) EventHotKeyRef_hash, /*tp_hash*/
-	0, /*tp_call*/
-	0, /*tp_str*/
-	PyObject_GenericGetAttr, /*tp_getattro*/
-	PyObject_GenericSetAttr, /*tp_setattro */
-	0, /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-	0, /*tp_doc*/
-	0, /*tp_traverse*/
-	0, /*tp_clear*/
-	0, /*tp_richcompare*/
-	0, /*tp_weaklistoffset*/
-	0, /*tp_iter*/
-	0, /*tp_iternext*/
-	EventHotKeyRef_methods, /* tp_methods */
-	0, /*tp_members*/
-	EventHotKeyRef_getsetlist, /*tp_getset*/
-	0, /*tp_base*/
-	0, /*tp_dict*/
-	0, /*tp_descr_get*/
-	0, /*tp_descr_set*/
-	0, /*tp_dictoffset*/
-	EventHotKeyRef_tp_init, /* tp_init */
-	EventHotKeyRef_tp_alloc, /* tp_alloc */
-	EventHotKeyRef_tp_new, /* tp_new */
-	EventHotKeyRef_tp_free, /* tp_free */
+    PyObject_HEAD_INIT(NULL)
+    0, /*ob_size*/
+    "_CarbonEvt.EventHotKeyRef", /*tp_name*/
+    sizeof(EventHotKeyRefObject), /*tp_basicsize*/
+    0, /*tp_itemsize*/
+    /* methods */
+    (destructor) EventHotKeyRef_dealloc, /*tp_dealloc*/
+    0, /*tp_print*/
+    (getattrfunc)0, /*tp_getattr*/
+    (setattrfunc)0, /*tp_setattr*/
+    (cmpfunc) EventHotKeyRef_compare, /*tp_compare*/
+    (reprfunc) EventHotKeyRef_repr, /*tp_repr*/
+    (PyNumberMethods *)0, /* tp_as_number */
+    (PySequenceMethods *)0, /* tp_as_sequence */
+    (PyMappingMethods *)0, /* tp_as_mapping */
+    (hashfunc) EventHotKeyRef_hash, /*tp_hash*/
+    0, /*tp_call*/
+    0, /*tp_str*/
+    PyObject_GenericGetAttr, /*tp_getattro*/
+    PyObject_GenericSetAttr, /*tp_setattro */
+    0, /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
+    0, /*tp_doc*/
+    0, /*tp_traverse*/
+    0, /*tp_clear*/
+    0, /*tp_richcompare*/
+    0, /*tp_weaklistoffset*/
+    0, /*tp_iter*/
+    0, /*tp_iternext*/
+    EventHotKeyRef_methods, /* tp_methods */
+    0, /*tp_members*/
+    EventHotKeyRef_getsetlist, /*tp_getset*/
+    0, /*tp_base*/
+    0, /*tp_dict*/
+    0, /*tp_descr_get*/
+    0, /*tp_descr_set*/
+    0, /*tp_dictoffset*/
+    EventHotKeyRef_tp_init, /* tp_init */
+    EventHotKeyRef_tp_alloc, /* tp_alloc */
+    EventHotKeyRef_tp_new, /* tp_new */
+    EventHotKeyRef_tp_free, /* tp_free */
 };
 
 /* ----------------- End object type EventHotKeyRef ----------------- */
@@ -1562,577 +1562,577 @@ PyTypeObject EventHotKeyRef_Type = {
 
 static PyObject *CarbonEvents_GetCurrentEventLoop(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventLoopRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetCurrentEventLoop();
-	_res = Py_BuildValue("O&",
-	                     EventLoopRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventLoopRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetCurrentEventLoop();
+    _res = Py_BuildValue("O&",
+                         EventLoopRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetMainEventLoop(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventLoopRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetMainEventLoop();
-	_res = Py_BuildValue("O&",
-	                     EventLoopRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventLoopRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetMainEventLoop();
+    _res = Py_BuildValue("O&",
+                         EventLoopRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_RunCurrentEventLoop(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	double inTimeout;
-	if (!PyArg_ParseTuple(_args, "d",
-	                      &inTimeout))
-		return NULL;
-	_err = RunCurrentEventLoop(inTimeout);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    double inTimeout;
+    if (!PyArg_ParseTuple(_args, "d",
+                          &inTimeout))
+        return NULL;
+    _err = RunCurrentEventLoop(inTimeout);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_ReceiveNextEvent(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	UInt32 inNumTypes;
-	EventTypeSpec inList;
-	double inTimeout;
-	Boolean inPullEvent;
-	EventRef outEvent;
-	if (!PyArg_ParseTuple(_args, "lO&db",
-	                      &inNumTypes,
-	                      EventTypeSpec_Convert, &inList,
-	                      &inTimeout,
-	                      &inPullEvent))
-		return NULL;
-	_err = ReceiveNextEvent(inNumTypes,
-	                        &inList,
-	                        inTimeout,
-	                        inPullEvent,
-	                        &outEvent);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     EventRef_New, outEvent);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    UInt32 inNumTypes;
+    EventTypeSpec inList;
+    double inTimeout;
+    Boolean inPullEvent;
+    EventRef outEvent;
+    if (!PyArg_ParseTuple(_args, "lO&db",
+                          &inNumTypes,
+                          EventTypeSpec_Convert, &inList,
+                          &inTimeout,
+                          &inPullEvent))
+        return NULL;
+    _err = ReceiveNextEvent(inNumTypes,
+                            &inList,
+                            inTimeout,
+                            inPullEvent,
+                            &outEvent);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&",
+                         EventRef_New, outEvent);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetCurrentEventQueue(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventQueueRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetCurrentEventQueue();
-	_res = Py_BuildValue("O&",
-	                     EventQueueRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventQueueRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetCurrentEventQueue();
+    _res = Py_BuildValue("O&",
+                         EventQueueRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetMainEventQueue(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventQueueRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetMainEventQueue();
-	_res = Py_BuildValue("O&",
-	                     EventQueueRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventQueueRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetMainEventQueue();
+    _res = Py_BuildValue("O&",
+                         EventQueueRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetCurrentEventTime(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	double _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetCurrentEventTime();
-	_res = Py_BuildValue("d",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    double _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetCurrentEventTime();
+    _res = Py_BuildValue("d",
+                         _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_TrackMouseLocation(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	GrafPtr inPort;
-	Point outPt;
-	UInt16 outResult;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      GrafObj_Convert, &inPort))
-		return NULL;
-	_err = TrackMouseLocation(inPort,
-	                          &outPt,
-	                          &outResult);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&H",
-	                     PyMac_BuildPoint, outPt,
-	                     outResult);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    GrafPtr inPort;
+    Point outPt;
+    UInt16 outResult;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          GrafObj_Convert, &inPort))
+        return NULL;
+    _err = TrackMouseLocation(inPort,
+                              &outPt,
+                              &outResult);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&H",
+                         PyMac_BuildPoint, outPt,
+                         outResult);
+    return _res;
 }
 
 static PyObject *CarbonEvents_TrackMouseLocationWithOptions(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	GrafPtr inPort;
-	OptionBits inOptions;
-	double inTimeout;
-	Point outPt;
-	UInt32 outModifiers;
-	UInt16 outResult;
-	if (!PyArg_ParseTuple(_args, "O&ld",
-	                      GrafObj_Convert, &inPort,
-	                      &inOptions,
-	                      &inTimeout))
-		return NULL;
-	_err = TrackMouseLocationWithOptions(inPort,
-	                                     inOptions,
-	                                     inTimeout,
-	                                     &outPt,
-	                                     &outModifiers,
-	                                     &outResult);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&lH",
-	                     PyMac_BuildPoint, outPt,
-	                     outModifiers,
-	                     outResult);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    GrafPtr inPort;
+    OptionBits inOptions;
+    double inTimeout;
+    Point outPt;
+    UInt32 outModifiers;
+    UInt16 outResult;
+    if (!PyArg_ParseTuple(_args, "O&ld",
+                          GrafObj_Convert, &inPort,
+                          &inOptions,
+                          &inTimeout))
+        return NULL;
+    _err = TrackMouseLocationWithOptions(inPort,
+                                         inOptions,
+                                         inTimeout,
+                                         &outPt,
+                                         &outModifiers,
+                                         &outResult);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&lH",
+                         PyMac_BuildPoint, outPt,
+                         outModifiers,
+                         outResult);
+    return _res;
 }
 
 static PyObject *CarbonEvents_TrackMouseRegion(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	GrafPtr inPort;
-	RgnHandle inRegion;
-	Boolean ioWasInRgn;
-	UInt16 outResult;
-	if (!PyArg_ParseTuple(_args, "O&O&b",
-	                      GrafObj_Convert, &inPort,
-	                      ResObj_Convert, &inRegion,
-	                      &ioWasInRgn))
-		return NULL;
-	_err = TrackMouseRegion(inPort,
-	                        inRegion,
-	                        &ioWasInRgn,
-	                        &outResult);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("bH",
-	                     ioWasInRgn,
-	                     outResult);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    GrafPtr inPort;
+    RgnHandle inRegion;
+    Boolean ioWasInRgn;
+    UInt16 outResult;
+    if (!PyArg_ParseTuple(_args, "O&O&b",
+                          GrafObj_Convert, &inPort,
+                          ResObj_Convert, &inRegion,
+                          &ioWasInRgn))
+        return NULL;
+    _err = TrackMouseRegion(inPort,
+                            inRegion,
+                            &ioWasInRgn,
+                            &outResult);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("bH",
+                         ioWasInRgn,
+                         outResult);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	double _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetLastUserEventTime();
-	_res = Py_BuildValue("d",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    double _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetLastUserEventTime();
+    _res = Py_BuildValue("d",
+                         _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	Boolean _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = IsMouseCoalescingEnabled();
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
+    PyObject *_res = NULL;
+    Boolean _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = IsMouseCoalescingEnabled();
+    _res = Py_BuildValue("b",
+                         _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	Boolean inNewState;
-	Boolean outOldState;
-	if (!PyArg_ParseTuple(_args, "b",
-	                      &inNewState))
-		return NULL;
-	_err = SetMouseCoalescingEnabled(inNewState,
-	                                 &outOldState);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("b",
-	                     outOldState);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    Boolean inNewState;
+    Boolean outOldState;
+    if (!PyArg_ParseTuple(_args, "b",
+                          &inNewState))
+        return NULL;
+    _err = SetMouseCoalescingEnabled(inNewState,
+                                     &outOldState);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("b",
+                         outOldState);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_rv = GetWindowEventTarget(inWindow);
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _rv = GetWindowEventTarget(inWindow);
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetControlEventTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	ControlHandle inControl;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      CtlObj_Convert, &inControl))
-		return NULL;
-	_rv = GetControlEventTarget(inControl);
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    ControlHandle inControl;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          CtlObj_Convert, &inControl))
+        return NULL;
+    _rv = GetControlEventTarget(inControl);
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetMenuEventTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	MenuHandle inMenu;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      MenuObj_Convert, &inMenu))
-		return NULL;
-	_rv = GetMenuEventTarget(inMenu);
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    MenuHandle inMenu;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          MenuObj_Convert, &inMenu))
+        return NULL;
+    _rv = GetMenuEventTarget(inMenu);
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetApplicationEventTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetApplicationEventTarget();
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetApplicationEventTarget();
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetUserFocusEventTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetUserFocusEventTarget();
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetUserFocusEventTarget();
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetEventDispatcherTarget(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	EventTargetRef _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetEventDispatcherTarget();
-	_res = Py_BuildValue("O&",
-	                     EventTargetRef_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    EventTargetRef _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetEventDispatcherTarget();
+    _res = Py_BuildValue("O&",
+                         EventTargetRef_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	RunApplicationEventLoop();
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    RunApplicationEventLoop();
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_QuitApplicationEventLoop(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	QuitApplicationEventLoop();
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    QuitApplicationEventLoop();
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_RunAppModalLoopForWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = RunAppModalLoopForWindow(inWindow);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = RunAppModalLoopForWindow(inWindow);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_QuitAppModalLoopForWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = QuitAppModalLoopForWindow(inWindow);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = QuitAppModalLoopForWindow(inWindow);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_BeginAppModalStateForWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = BeginAppModalStateForWindow(inWindow);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = BeginAppModalStateForWindow(inWindow);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_EndAppModalStateForWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = EndAppModalStateForWindow(inWindow);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = EndAppModalStateForWindow(inWindow);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_SetUserFocusWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = SetUserFocusWindow(inWindow);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = SetUserFocusWindow(inWindow);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetUserFocusWindow(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	WindowPtr _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetUserFocusWindow();
-	_res = Py_BuildValue("O&",
-	                     WinObj_New, _rv);
-	return _res;
+    PyObject *_res = NULL;
+    WindowPtr _rv;
+    if (!PyArg_ParseTuple(_args, ""))
+        return NULL;
+    _rv = GetUserFocusWindow();
+    _res = Py_BuildValue("O&",
+                         WinObj_New, _rv);
+    return _res;
 }
 
 static PyObject *CarbonEvents_SetWindowDefaultButton(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	ControlHandle inControl;
-	if (!PyArg_ParseTuple(_args, "O&O&",
-	                      WinObj_Convert, &inWindow,
-	                      CtlObj_Convert, &inControl))
-		return NULL;
-	_err = SetWindowDefaultButton(inWindow,
-	                              inControl);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    ControlHandle inControl;
+    if (!PyArg_ParseTuple(_args, "O&O&",
+                          WinObj_Convert, &inWindow,
+                          CtlObj_Convert, &inControl))
+        return NULL;
+    _err = SetWindowDefaultButton(inWindow,
+                                  inControl);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_SetWindowCancelButton(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	ControlHandle inControl;
-	if (!PyArg_ParseTuple(_args, "O&O&",
-	                      WinObj_Convert, &inWindow,
-	                      CtlObj_Convert, &inControl))
-		return NULL;
-	_err = SetWindowCancelButton(inWindow,
-	                             inControl);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    ControlHandle inControl;
+    if (!PyArg_ParseTuple(_args, "O&O&",
+                          WinObj_Convert, &inWindow,
+                          CtlObj_Convert, &inControl))
+        return NULL;
+    _err = SetWindowCancelButton(inWindow,
+                                 inControl);
+    if (_err != noErr) return PyMac_Error(_err);
+    Py_INCREF(Py_None);
+    _res = Py_None;
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetWindowDefaultButton(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	ControlHandle outControl;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = GetWindowDefaultButton(inWindow,
-	                              &outControl);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     CtlObj_New, outControl);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    ControlHandle outControl;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = GetWindowDefaultButton(inWindow,
+                                  &outControl);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&",
+                         CtlObj_New, outControl);
+    return _res;
 }
 
 static PyObject *CarbonEvents_GetWindowCancelButton(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	WindowPtr inWindow;
-	ControlHandle outControl;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &inWindow))
-		return NULL;
-	_err = GetWindowCancelButton(inWindow,
-	                             &outControl);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     CtlObj_New, outControl);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    WindowPtr inWindow;
+    ControlHandle outControl;
+    if (!PyArg_ParseTuple(_args, "O&",
+                          WinObj_Convert, &inWindow))
+        return NULL;
+    _err = GetWindowCancelButton(inWindow,
+                                 &outControl);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&",
+                         CtlObj_New, outControl);
+    return _res;
 }
 
 static PyObject *CarbonEvents_RegisterEventHotKey(PyObject *_self, PyObject *_args)
 {
-	PyObject *_res = NULL;
-	OSStatus _err;
-	UInt32 inHotKeyCode;
-	UInt32 inHotKeyModifiers;
-	EventHotKeyID inHotKeyID;
-	EventTargetRef inTarget;
-	OptionBits inOptions;
-	EventHotKeyRef outRef;
-	if (!PyArg_ParseTuple(_args, "llO&O&l",
-	                      &inHotKeyCode,
-	                      &inHotKeyModifiers,
-	                      EventHotKeyID_Convert, &inHotKeyID,
-	                      EventTargetRef_Convert, &inTarget,
-	                      &inOptions))
-		return NULL;
-	_err = RegisterEventHotKey(inHotKeyCode,
-	                           inHotKeyModifiers,
-	                           inHotKeyID,
-	                           inTarget,
-	                           inOptions,
-	                           &outRef);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     EventHotKeyRef_New, outRef);
-	return _res;
+    PyObject *_res = NULL;
+    OSStatus _err;
+    UInt32 inHotKeyCode;
+    UInt32 inHotKeyModifiers;
+    EventHotKeyID inHotKeyID;
+    EventTargetRef inTarget;
+    OptionBits inOptions;
+    EventHotKeyRef outRef;
+    if (!PyArg_ParseTuple(_args, "llO&O&l",
+                          &inHotKeyCode,
+                          &inHotKeyModifiers,
+                          EventHotKeyID_Convert, &inHotKeyID,
+                          EventTargetRef_Convert, &inTarget,
+                          &inOptions))
+        return NULL;
+    _err = RegisterEventHotKey(inHotKeyCode,
+                               inHotKeyModifiers,
+                               inHotKeyID,
+                               inTarget,
+                               inOptions,
+                               &outRef);
+    if (_err != noErr) return PyMac_Error(_err);
+    _res = Py_BuildValue("O&",
+                         EventHotKeyRef_New, outRef);
+    return _res;
 }
 
 static PyMethodDef CarbonEvents_methods[] = {
-	{"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
-	 PyDoc_STR("() -> (EventLoopRef _rv)")},
-	{"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
-	 PyDoc_STR("() -> (EventLoopRef _rv)")},
-	{"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
-	 PyDoc_STR("(double inTimeout) -> None")},
-	{"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
-	 PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
-	{"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
-	 PyDoc_STR("() -> (EventQueueRef _rv)")},
-	{"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
-	 PyDoc_STR("() -> (EventQueueRef _rv)")},
-	{"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
-	 PyDoc_STR("() -> (double _rv)")},
-	{"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
-	 PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
-	{"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
-	 PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
-	{"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
-	 PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
-	{"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
-	 PyDoc_STR("() -> (double _rv)")},
-	{"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
-	 PyDoc_STR("() -> (Boolean _rv)")},
-	{"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
-	 PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
-	{"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
-	{"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
-	 PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
-	{"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
-	 PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
-	{"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
-	 PyDoc_STR("() -> (EventTargetRef _rv)")},
-	{"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
-	 PyDoc_STR("() -> (EventTargetRef _rv)")},
-	{"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
-	 PyDoc_STR("() -> (EventTargetRef _rv)")},
-	{"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
-	 PyDoc_STR("() -> None")},
-	{"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
-	 PyDoc_STR("() -> None")},
-	{"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> None")},
-	{"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> None")},
-	{"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> None")},
-	{"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> None")},
-	{"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> None")},
-	{"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
-	 PyDoc_STR("() -> (WindowPtr _rv)")},
-	{"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
-	 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
-	{"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
-	 PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
-	{"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
-	{"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
-	 PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
-	{"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
-	 PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
-	{NULL, NULL, 0}
+    {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
+     PyDoc_STR("() -> (EventLoopRef _rv)")},
+    {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
+     PyDoc_STR("() -> (EventLoopRef _rv)")},
+    {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
+     PyDoc_STR("(double inTimeout) -> None")},
+    {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
+     PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
+    {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
+     PyDoc_STR("() -> (EventQueueRef _rv)")},
+    {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
+     PyDoc_STR("() -> (EventQueueRef _rv)")},
+    {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
+     PyDoc_STR("() -> (double _rv)")},
+    {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
+     PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
+    {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
+     PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
+    {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
+     PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
+    {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
+     PyDoc_STR("() -> (double _rv)")},
+    {"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
+     PyDoc_STR("() -> (Boolean _rv)")},
+    {"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
+     PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
+    {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
+    {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
+     PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
+    {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
+     PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
+    {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
+     PyDoc_STR("() -> (EventTargetRef _rv)")},
+    {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
+     PyDoc_STR("() -> (EventTargetRef _rv)")},
+    {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
+     PyDoc_STR("() -> (EventTargetRef _rv)")},
+    {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
+     PyDoc_STR("() -> None")},
+    {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
+     PyDoc_STR("() -> None")},
+    {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> None")},
+    {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> None")},
+    {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> None")},
+    {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> None")},
+    {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> None")},
+    {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
+     PyDoc_STR("() -> (WindowPtr _rv)")},
+    {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
+     PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
+    {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
+     PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
+    {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
+    {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
+     PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
+    {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
+     PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
+    {NULL, NULL, 0}
 };
 
 #else /* __LP64__ */
 
 static PyMethodDef CarbonEvents_methods[] = {
-	{NULL, NULL, 0}
+    {NULL, NULL, 0}
 };
 
 #endif /* __LP64__ */
@@ -2141,77 +2141,77 @@ static PyMethodDef CarbonEvents_methods[] = {
 
 void init_CarbonEvt(void)
 {
-	PyObject *m;
+    PyObject *m;
 #ifndef __LP64__
-	PyObject *d;
+    PyObject *d;
 #endif /* !__LP64__ */
 
 
-	m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
+    m = Py_InitModule("_CarbonEvt", CarbonEvents_methods);
 
 #ifndef __LP64__
-	myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
-	d = PyModule_GetDict(m);
-	CarbonEvents_Error = PyMac_GetOSErrException();
-	if (CarbonEvents_Error == NULL ||
-	    PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
-		return;
-	EventRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventRef_Type) < 0) return;
-	Py_INCREF(&EventRef_Type);
-	PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventRef_Type);
-	PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
-	EventQueueRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventQueueRef_Type) < 0) return;
-	Py_INCREF(&EventQueueRef_Type);
-	PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventQueueRef_Type);
-	PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
-	EventLoopRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventLoopRef_Type) < 0) return;
-	Py_INCREF(&EventLoopRef_Type);
-	PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventLoopRef_Type);
-	PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
-	EventLoopTimerRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
-	Py_INCREF(&EventLoopTimerRef_Type);
-	PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventLoopTimerRef_Type);
-	PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
-	EventHandlerRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
-	Py_INCREF(&EventHandlerRef_Type);
-	PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventHandlerRef_Type);
-	PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
-	EventHandlerCallRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
-	Py_INCREF(&EventHandlerCallRef_Type);
-	PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventHandlerCallRef_Type);
-	PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
-	EventTargetRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventTargetRef_Type) < 0) return;
-	Py_INCREF(&EventTargetRef_Type);
-	PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventTargetRef_Type);
-	PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
-	EventHotKeyRef_Type.ob_type = &PyType_Type;
-	if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
-	Py_INCREF(&EventHotKeyRef_Type);
-	PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
-	/* Backward-compatible name */
-	Py_INCREF(&EventHotKeyRef_Type);
-	PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type);
+    myEventHandlerUPP = NewEventHandlerUPP(myEventHandler);
+    d = PyModule_GetDict(m);
+    CarbonEvents_Error = PyMac_GetOSErrException();
+    if (CarbonEvents_Error == NULL ||
+        PyDict_SetItemString(d, "Error", CarbonEvents_Error) != 0)
+        return;
+    EventRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventRef_Type) < 0) return;
+    Py_INCREF(&EventRef_Type);
+    PyModule_AddObject(m, "EventRef", (PyObject *)&EventRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventRef_Type);
+    PyModule_AddObject(m, "EventRefType", (PyObject *)&EventRef_Type);
+    EventQueueRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventQueueRef_Type) < 0) return;
+    Py_INCREF(&EventQueueRef_Type);
+    PyModule_AddObject(m, "EventQueueRef", (PyObject *)&EventQueueRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventQueueRef_Type);
+    PyModule_AddObject(m, "EventQueueRefType", (PyObject *)&EventQueueRef_Type);
+    EventLoopRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventLoopRef_Type) < 0) return;
+    Py_INCREF(&EventLoopRef_Type);
+    PyModule_AddObject(m, "EventLoopRef", (PyObject *)&EventLoopRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventLoopRef_Type);
+    PyModule_AddObject(m, "EventLoopRefType", (PyObject *)&EventLoopRef_Type);
+    EventLoopTimerRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventLoopTimerRef_Type) < 0) return;
+    Py_INCREF(&EventLoopTimerRef_Type);
+    PyModule_AddObject(m, "EventLoopTimerRef", (PyObject *)&EventLoopTimerRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventLoopTimerRef_Type);
+    PyModule_AddObject(m, "EventLoopTimerRefType", (PyObject *)&EventLoopTimerRef_Type);
+    EventHandlerRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventHandlerRef_Type) < 0) return;
+    Py_INCREF(&EventHandlerRef_Type);
+    PyModule_AddObject(m, "EventHandlerRef", (PyObject *)&EventHandlerRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventHandlerRef_Type);
+    PyModule_AddObject(m, "EventHandlerRefType", (PyObject *)&EventHandlerRef_Type);
+    EventHandlerCallRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventHandlerCallRef_Type) < 0) return;
+    Py_INCREF(&EventHandlerCallRef_Type);
+    PyModule_AddObject(m, "EventHandlerCallRef", (PyObject *)&EventHandlerCallRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventHandlerCallRef_Type);
+    PyModule_AddObject(m, "EventHandlerCallRefType", (PyObject *)&EventHandlerCallRef_Type);
+    EventTargetRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventTargetRef_Type) < 0) return;
+    Py_INCREF(&EventTargetRef_Type);
+    PyModule_AddObject(m, "EventTargetRef", (PyObject *)&EventTargetRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventTargetRef_Type);
+    PyModule_AddObject(m, "EventTargetRefType", (PyObject *)&EventTargetRef_Type);
+    EventHotKeyRef_Type.ob_type = &PyType_Type;
+    if (PyType_Ready(&EventHotKeyRef_Type) < 0) return;
+    Py_INCREF(&EventHotKeyRef_Type);
+    PyModule_AddObject(m, "EventHotKeyRef", (PyObject *)&EventHotKeyRef_Type);
+    /* Backward-compatible name */
+    Py_INCREF(&EventHotKeyRef_Type);
+    PyModule_AddObject(m, "EventHotKeyRefType", (PyObject *)&EventHotKeyRef_Type);
 #endif /* !__LP64__ */
 }