Whitespace normalization, via reindent.py.

3 files changed, 465 insertions, 465 deletions

diff --git a/Mac/Modules/ctl/ctledit.py b/Mac/Modules/ctl/ctledit.py
index 6ba024b..fdd9712 100644
--- a/Mac/Modules/ctl/ctledit.py
+++ b/Mac/Modules/ctl/ctledit.py
@@ -8,7 +8,7 @@ f = Function(ExistingControlHandle, 'FindControlUnderMouse',
 functions.append(f)
 
 f = Function(ControlHandle, 'as_Control',
-	(Handle, 'h', InMode))
+        (Handle, 'h', InMode))
 functions.append(f)
 
 f = Method(Handle, 'as_Resource', (ControlHandle, 'ctl', InMode))
@@ -18,16 +18,16 @@ f = Method(void, 'GetControlRect', (ControlHandle, 'ctl', InMode), (Rect, 'rect'
 methods.append(f)
 
 DisposeControl_body = """
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	if ( _self->ob_itself ) {
-		SetControlReference(_self->ob_itself, (long)0); /* Make it forget about us */
-		DisposeControl(_self->ob_itself);
-		_self->ob_itself = NULL;
-	}
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
+        if (!PyArg_ParseTuple(_args, ""))
+                return NULL;
+        if ( _self->ob_itself ) {
+                SetControlReference(_self->ob_itself, (long)0); /* Make it forget about us */
+                DisposeControl(_self->ob_itself);
+                _self->ob_itself = NULL;
+        }
+        Py_INCREF(Py_None);
+        _res = Py_None;
+        return _res;
 """
 
 f = ManualGenerator("DisposeControl", DisposeControl_body)
@@ -39,7 +39,7 @@ methods.append(f)
 # parameter; these should however be managed by us (we're creating them
 # after all), so set the type to ControlRef.
 for f in functions:
-	if f.name.startswith("Create"):
-		v = f.argumentList[-1]
-		if v.type == ExistingControlHandle:
-			v.type = ControlRef
+    if f.name.startswith("Create"):
+        v = f.argumentList[-1]
+        if v.type == ExistingControlHandle:
+            v.type = ControlRef
diff --git a/Mac/Modules/ctl/ctlscan.py b/Mac/Modules/ctl/ctlscan.py
index 818541e..25333f1 100644
--- a/Mac/Modules/ctl/ctlscan.py
+++ b/Mac/Modules/ctl/ctlscan.py
@@ -7,166 +7,166 @@ sys.path.append(BGENDIR)
 from scantools import Scanner
 
 def main():
-#	input = "Controls.h" # Universal Headers < 3.3
-	input = ["Controls.h", "ControlDefinitions.h"] # Universal Headers >= 3.3
-	output = "ctlgen.py"
-	defsoutput = TOOLBOXDIR + "Controls.py"
-	scanner = MyScanner(input, output, defsoutput)
-	scanner.scan()
-	scanner.close()
-	print "=== Testing definitions output code ==="
-	execfile(defsoutput, {}, {})
-	print "=== Done scanning and generating, now doing 'import ctlsupport' ==="
-	import ctlsupport
-	print "=== Done.  It's up to you to compile Ctlmodule.c ==="
+#       input = "Controls.h" # Universal Headers < 3.3
+    input = ["Controls.h", "ControlDefinitions.h"] # Universal Headers >= 3.3
+    output = "ctlgen.py"
+    defsoutput = TOOLBOXDIR + "Controls.py"
+    scanner = MyScanner(input, output, defsoutput)
+    scanner.scan()
+    scanner.close()
+    print "=== Testing definitions output code ==="
+    execfile(defsoutput, {}, {})
+    print "=== Done scanning and generating, now doing 'import ctlsupport' ==="
+    import ctlsupport
+    print "=== Done.  It's up to you to compile Ctlmodule.c ==="
 
 class MyScanner(Scanner):
 
-	def destination(self, type, name, arglist):
-		classname = "Function"
-		listname = "functions"
-		if arglist:
-			t, n, m = arglist[0]
-			if t in ("ControlHandle", "ControlRef") and m == "InMode":
-				classname = "Method"
-				listname = "methods"
-		return classname, listname
-
-	def writeinitialdefs(self):
-		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
-		self.defsfile.write("from Carbon.TextEdit import *\n")
-		self.defsfile.write("from Carbon.QuickDraw import *\n")
-		self.defsfile.write("from Carbon.Dragconst import *\n")
-		self.defsfile.write("from Carbon.CarbonEvents import *\n")
-		self.defsfile.write("from Carbon.Appearance import *\n")
-		self.defsfile.write("kDataBrowserItemAnyState = -1\n")
-		self.defsfile.write("kControlBevelButtonCenterPopupGlyphTag = -1\n")
-		self.defsfile.write("kDataBrowserClientPropertyFlagsMask = 0xFF000000\n")
-		self.defsfile.write("\n")
-
-	def makeblacklistnames(self):
-		return [
-			'FindControlUnderMouse', # Generated manually, returns an existing control, not a new one.
-			'DisposeControl', # Generated manually
-			'KillControls', # Implied by close of dialog
-			'SetCtlAction',
-			'TrackControl',	# Generated manually
-			'HandleControlClick',	# Generated manually
-			'SetControlData',	# Generated manually
-			'GetControlData',	# Generated manually
-			'kControlBevelButtonCenterPopupGlyphTag', # Constant with funny definition
-			'kDataBrowserClientPropertyFlagsMask',  # ditto
-			'kDataBrowserItemAnyState',   # and ditto
-			# The following are unavailable for static 68k (appearance manager)
-##			'GetBevelButtonMenuValue',
-##			'SetBevelButtonMenuValue',
-##			'GetBevelButtonMenuHandle',
-##			'SetBevelButtonTransform',
-			'SetBevelButtonGraphicAlignment',
-			'SetBevelButtonTextAlignment',
-			'SetBevelButtonTextPlacement',
-##			'SetImageWellTransform',
-##			'GetTabContentRect',
-##			'SetTabEnabled',
-##			'SetDisclosureTriangleLastValue',
-## 			# Unavailable in CW Pro 3 libraries
-## 			'SetUpControlTextColor',
-## 			# Unavailable in Jack's CW Pro 5.1 libraries
-## 			'GetControlRegion',
-## 			'RemoveControlProperty',
-## 			'IsValidControlHandle',
-## 			'SetControl32BitMinimum',
-## 			'GetControl32BitMinimum',
-## 			'SetControl32BitMaximum',
-## 			'GetControl32BitMaximum',
-## 			'SetControl32BitValue',
-## 			'GetControl32BitValue',
-## 			'SetControlViewSize',
-## 			'GetControlViewSize',
-			# Generally Bad News
-			'GetControlProperty',
-			'SetControlProperty',
-			'GetControlPropertySize',
-			'SendControlMessage', # Parameter changed from long to void* from UH3.3 to UH3.4
-			'CreateTabsControl',  # wrote manually
-			'GetControlAction',  # too much effort for too little usefulness
-			
-			# too lazy for now
-			'GetImageWellContentInfo',
-			'GetBevelButtonContentInfo',
-			# OS8 only
-			'GetAuxiliaryControlRecord',
-			'SetControlColor',
-			]
-
-	def makeblacklisttypes(self):
-		return [
-			'ProcPtr',
-#			'ControlActionUPP',
-			'Ptr',
-			'ControlDefSpec', # Don't know how to do this yet
-			'ControlDefSpec_ptr', # ditto
-			'Collection', # Ditto
-			# not-yet-supported stuff in Universal Headers 3.4:
-			'ControlColorUPP',
-			'ControlKind',  # XXX easy: 2-tuple containing 2 OSType's
-#			'ControlTabEntry_ptr', # XXX needed for tabs
-#			'ControlButtonContentInfoPtr',
-#			'ControlButtonContentInfo',  # XXX ugh: a union
-#			'ControlButtonContentInfo_ptr',  # XXX ugh: a union
-			'ListDefSpec_ptr',  # XXX see _Listmodule.c, tricky but possible
-			'DataBrowserItemID_ptr',  # XXX array of UInt32, for BrowserView
-			'DataBrowserItemUPP',
-			'DataBrowserItemDataRef', # XXX void *
-			'DataBrowserCallbacks', # difficult struct
-			'DataBrowserCallbacks_ptr',
-			'DataBrowserCustomCallbacks',
-			'DataBrowserCustomCallbacks_ptr',
-##			'DataBrowserTableViewColumnDesc',
-##			'DataBrowserListViewColumnDesc',
-			'CFDataRef',
-			'DataBrowserListViewHeaderDesc', # difficult struct
-			]
-
-	def makerepairinstructions(self):
-		return [
-			([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
-			 [("InBuffer", "*", "*")]),
-
-			([("void", "*", "OutMode"), ("long", "*", "InMode"),
-			                            ("long", "*", "OutMode")],
-			 [("VarVarOutBuffer", "*", "InOutMode")]),
-
-##			# For TrackControl
-##			([("ProcPtr", "actionProc", "InMode")],
-##			 [("FakeType('(ControlActionUPP)0')", "*", "*")]),
-##			([("ControlActionUPP", "actionProc", "InMode")],
-##			 [("FakeType('(ControlActionUPP)0')", "*", "*")]),
-
-			# For GetControlTitle
-			([('Str255', 'title', 'InMode')],
-			 [('Str255', 'title', 'OutMode')]),
-
-			([("ControlHandle", "*", "OutMode")],
-			 [("ExistingControlHandle", "*", "*")]),
-			([("ControlRef", "*", "OutMode")],	# Ditto, for Universal Headers
-			 [("ExistingControlHandle", "*", "*")]),
-			 
-			([("Rect_ptr", "*", "ReturnMode")], # GetControlBounds
-			 [("void", "*", "ReturnMode")]),
-
-			([("DataBrowserListViewColumnDesc", "*", "OutMode")],
-			 [("DataBrowserListViewColumnDesc", "*", "InMode")]),
-			 
-			([("ControlButtonContentInfoPtr", 'outContent', "InMode")],
-			 [("ControlButtonContentInfoPtr", '*', "OutMode")]),
-			 
-			([("ControlButtonContentInfo", '*', "OutMode")],
-			 [("ControlButtonContentInfo", '*', "InMode")]),
-			
-			([("ControlActionUPP", 'liveTrackingProc', "InMode")],
-			 [("ControlActionUPPNewControl", 'liveTrackingProc', "InMode")]),
-			]
+    def destination(self, type, name, arglist):
+        classname = "Function"
+        listname = "functions"
+        if arglist:
+            t, n, m = arglist[0]
+            if t in ("ControlHandle", "ControlRef") and m == "InMode":
+                classname = "Method"
+                listname = "methods"
+        return classname, listname
+
+    def writeinitialdefs(self):
+        self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+        self.defsfile.write("from Carbon.TextEdit import *\n")
+        self.defsfile.write("from Carbon.QuickDraw import *\n")
+        self.defsfile.write("from Carbon.Dragconst import *\n")
+        self.defsfile.write("from Carbon.CarbonEvents import *\n")
+        self.defsfile.write("from Carbon.Appearance import *\n")
+        self.defsfile.write("kDataBrowserItemAnyState = -1\n")
+        self.defsfile.write("kControlBevelButtonCenterPopupGlyphTag = -1\n")
+        self.defsfile.write("kDataBrowserClientPropertyFlagsMask = 0xFF000000\n")
+        self.defsfile.write("\n")
+
+    def makeblacklistnames(self):
+        return [
+                'FindControlUnderMouse', # Generated manually, returns an existing control, not a new one.
+                'DisposeControl', # Generated manually
+                'KillControls', # Implied by close of dialog
+                'SetCtlAction',
+                'TrackControl', # Generated manually
+                'HandleControlClick',   # Generated manually
+                'SetControlData',       # Generated manually
+                'GetControlData',       # Generated manually
+                'kControlBevelButtonCenterPopupGlyphTag', # Constant with funny definition
+                'kDataBrowserClientPropertyFlagsMask',  # ditto
+                'kDataBrowserItemAnyState',   # and ditto
+                # The following are unavailable for static 68k (appearance manager)
+##                      'GetBevelButtonMenuValue',
+##                      'SetBevelButtonMenuValue',
+##                      'GetBevelButtonMenuHandle',
+##                      'SetBevelButtonTransform',
+                'SetBevelButtonGraphicAlignment',
+                'SetBevelButtonTextAlignment',
+                'SetBevelButtonTextPlacement',
+##                      'SetImageWellTransform',
+##                      'GetTabContentRect',
+##                      'SetTabEnabled',
+##                      'SetDisclosureTriangleLastValue',
+##                      # Unavailable in CW Pro 3 libraries
+##                      'SetUpControlTextColor',
+##                      # Unavailable in Jack's CW Pro 5.1 libraries
+##                      'GetControlRegion',
+##                      'RemoveControlProperty',
+##                      'IsValidControlHandle',
+##                      'SetControl32BitMinimum',
+##                      'GetControl32BitMinimum',
+##                      'SetControl32BitMaximum',
+##                      'GetControl32BitMaximum',
+##                      'SetControl32BitValue',
+##                      'GetControl32BitValue',
+##                      'SetControlViewSize',
+##                      'GetControlViewSize',
+                # Generally Bad News
+                'GetControlProperty',
+                'SetControlProperty',
+                'GetControlPropertySize',
+                'SendControlMessage', # Parameter changed from long to void* from UH3.3 to UH3.4
+                'CreateTabsControl',  # wrote manually
+                'GetControlAction',  # too much effort for too little usefulness
+
+                # too lazy for now
+                'GetImageWellContentInfo',
+                'GetBevelButtonContentInfo',
+                # OS8 only
+                'GetAuxiliaryControlRecord',
+                'SetControlColor',
+                ]
+
+    def makeblacklisttypes(self):
+        return [
+                'ProcPtr',
+#                       'ControlActionUPP',
+                'Ptr',
+                'ControlDefSpec', # Don't know how to do this yet
+                'ControlDefSpec_ptr', # ditto
+                'Collection', # Ditto
+                # not-yet-supported stuff in Universal Headers 3.4:
+                'ControlColorUPP',
+                'ControlKind',  # XXX easy: 2-tuple containing 2 OSType's
+#                       'ControlTabEntry_ptr', # XXX needed for tabs
+#                       'ControlButtonContentInfoPtr',
+#                       'ControlButtonContentInfo',  # XXX ugh: a union
+#                       'ControlButtonContentInfo_ptr',  # XXX ugh: a union
+                'ListDefSpec_ptr',  # XXX see _Listmodule.c, tricky but possible
+                'DataBrowserItemID_ptr',  # XXX array of UInt32, for BrowserView
+                'DataBrowserItemUPP',
+                'DataBrowserItemDataRef', # XXX void *
+                'DataBrowserCallbacks', # difficult struct
+                'DataBrowserCallbacks_ptr',
+                'DataBrowserCustomCallbacks',
+                'DataBrowserCustomCallbacks_ptr',
+##                      'DataBrowserTableViewColumnDesc',
+##                      'DataBrowserListViewColumnDesc',
+                'CFDataRef',
+                'DataBrowserListViewHeaderDesc', # difficult struct
+                ]
+
+    def makerepairinstructions(self):
+        return [
+                ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+                 [("InBuffer", "*", "*")]),
+
+                ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+                                            ("long", "*", "OutMode")],
+                 [("VarVarOutBuffer", "*", "InOutMode")]),
+
+##                      # For TrackControl
+##                      ([("ProcPtr", "actionProc", "InMode")],
+##                       [("FakeType('(ControlActionUPP)0')", "*", "*")]),
+##                      ([("ControlActionUPP", "actionProc", "InMode")],
+##                       [("FakeType('(ControlActionUPP)0')", "*", "*")]),
+
+                # For GetControlTitle
+                ([('Str255', 'title', 'InMode')],
+                 [('Str255', 'title', 'OutMode')]),
+
+                ([("ControlHandle", "*", "OutMode")],
+                 [("ExistingControlHandle", "*", "*")]),
+                ([("ControlRef", "*", "OutMode")],      # Ditto, for Universal Headers
+                 [("ExistingControlHandle", "*", "*")]),
+
+                ([("Rect_ptr", "*", "ReturnMode")], # GetControlBounds
+                 [("void", "*", "ReturnMode")]),
+
+                ([("DataBrowserListViewColumnDesc", "*", "OutMode")],
+                 [("DataBrowserListViewColumnDesc", "*", "InMode")]),
+
+                ([("ControlButtonContentInfoPtr", 'outContent', "InMode")],
+                 [("ControlButtonContentInfoPtr", '*', "OutMode")]),
+
+                ([("ControlButtonContentInfo", '*', "OutMode")],
+                 [("ControlButtonContentInfo", '*', "InMode")]),
+
+                ([("ControlActionUPP", 'liveTrackingProc', "InMode")],
+                 [("ControlActionUPPNewControl", 'liveTrackingProc', "InMode")]),
+                ]
 
 if __name__ == "__main__":
-	main()
+    main()
diff --git a/Mac/Modules/ctl/ctlsupport.py b/Mac/Modules/ctl/ctlsupport.py
index b2d9ad5..d354d94 100644
--- a/Mac/Modules/ctl/ctlsupport.py
+++ b/Mac/Modules/ctl/ctlsupport.py
@@ -6,16 +6,16 @@
 import string
 
 # Declarations that change for each manager
-MACHEADERFILE = 'Controls.h'		# The Apple header file
-MODNAME = '_Ctl'				# The name of the module
-OBJECTNAME = 'Control'			# The basic name of the objects used here
+MACHEADERFILE = 'Controls.h'            # The Apple header file
+MODNAME = '_Ctl'                                # The name of the module
+OBJECTNAME = 'Control'                  # The basic name of the objects used here
 
 # The following is *usually* unchanged but may still require tuning
-MODPREFIX = 'Ctl'			# The prefix for module-wide routines
-OBJECTTYPE = OBJECTNAME + 'Handle'	# The C type used to represent them
-OBJECTPREFIX = MODPREFIX + 'Obj'	# The prefix for object methods
+MODPREFIX = 'Ctl'                       # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + 'Handle'      # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj'        # The prefix for object methods
 INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
-OUTPUTFILE = MODNAME + "module.c"	# The file generated by this program
+OUTPUTFILE = MODNAME + "module.c"       # The file generated by this program
 
 from macsupport import *
 
@@ -79,11 +79,11 @@ DataBrowserPropertyType = OSType
 ControlDisclosureTriangleOrientation = UInt16
 
 DataBrowserTableViewColumnDesc = OpaqueType("DataBrowserTableViewColumnDesc",
-		"DataBrowserTableViewColumnDesc")
+                "DataBrowserTableViewColumnDesc")
 DataBrowserListViewColumnDesc = OpaqueType("DataBrowserListViewColumnDesc",
-		"DataBrowserListViewColumnDesc")
+                "DataBrowserListViewColumnDesc")
 ControlButtonContentInfo = OpaqueType("ControlButtonContentInfo",
-		"ControlButtonContentInfo")
+                "ControlButtonContentInfo")
 ControlButtonContentInfoPtr = ControlButtonContentInfo_ptr = ControlButtonContentInfo
 
 ControlTabEntry_ptr = OpaqueType("ControlTabEntry", "ControlTabEntry")
@@ -95,17 +95,17 @@ ControlBevelButtonMenuPlacement = UInt16
 ControlPushButtonIconAlignment = UInt16
 
 class ControlActionDefinition(Type):
-	def declare(self, name):
-		Output("%s %s;", self.typeName, name)
-		Output("UniversalProcPtr c_callback;")
-	def passInput(self, name):
-		return "myactionproc_upp"
-	def cleanup(self, name):
-		Output("setcallback((PyObject*)_self, kMyControlActionProcTag, actionProc, &c_callback);")
+    def declare(self, name):
+        Output("%s %s;", self.typeName, name)
+        Output("UniversalProcPtr c_callback;")
+    def passInput(self, name):
+        return "myactionproc_upp"
+    def cleanup(self, name):
+        Output("setcallback((PyObject*)_self, kMyControlActionProcTag, actionProc, &c_callback);")
 
 class ControlActionDefinitionNewControl(ControlActionDefinition):
-	def cleanup(self, name):
-		Output("setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback);")
+    def cleanup(self, name):
+        Output("setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback);")
 
 ControlActionUPP = ControlActionDefinition("PyObject*", "O")
 ControlActionUPPNewControl = ControlActionDefinitionNewControl("PyObject*", "O")
@@ -138,19 +138,19 @@ static PyObject *
 ControlFontStyle_New(ControlFontStyleRec *itself)
 {
 
-	return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font,
-		itself->size, itself->style, itself->mode, itself->just,
-		QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor);
+        return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font,
+                itself->size, itself->style, itself->mode, itself->just,
+                QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor);
 }
 #endif
 
 static int
 ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself)
 {
-	return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags,
-		&itself->font, &itself->size, &itself->style, &itself->mode,
-		&itself->just, QdRGB_Convert, &itself->foreColor,
-		QdRGB_Convert, &itself->backColor);
+        return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags,
+                &itself->font, &itself->size, &itself->style, &itself->mode,
+                &itself->just, QdRGB_Convert, &itself->foreColor,
+                QdRGB_Convert, &itself->backColor);
 }
 
 /*
@@ -160,13 +160,13 @@ static PyObject *
 PyControlID_New(ControlID *itself)
 {
 
-	return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id);
+        return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id);
 }
 
 static int
 PyControlID_Convert(PyObject *v, ControlID *itself)
 {
-	return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id);
+        return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id);
 }
 
 /*
@@ -175,40 +175,40 @@ PyControlID_Convert(PyObject *v, ControlID *itself)
 static int
 DataBrowserTableViewColumnDesc_Convert(PyObject *v, DataBrowserTableViewColumnDesc *itself)
 {
-	return PyArg_Parse(v, "(lO&l)",
-	                   &itself->propertyID,
-	                   PyMac_GetOSType, &itself->propertyType,
-	                   &itself->propertyFlags);
+        return PyArg_Parse(v, "(lO&l)",
+                           &itself->propertyID,
+                           PyMac_GetOSType, &itself->propertyType,
+                           &itself->propertyFlags);
 }
 
 static int
 ControlButtonContentInfo_Convert(PyObject *v, ControlButtonContentInfo *itself)
 {
-	return PyArg_Parse(v, "(hO&)",
-	                   &itself->contentType,
-	                   OptResObj_Convert, &itself->u.iconSuite);
+        return PyArg_Parse(v, "(hO&)",
+                           &itself->contentType,
+                           OptResObj_Convert, &itself->u.iconSuite);
 }
 
 static int
 DataBrowserListViewHeaderDesc_Convert(PyObject *v, DataBrowserListViewHeaderDesc *itself)
 {
-	itself->version = kDataBrowserListViewLatestHeaderDesc;
-	return PyArg_Parse(v, "(HHhO&HO&O&)",
-	                   &itself->minimumWidth,
-	                   &itself->maximumWidth,
-	                   &itself->titleOffset,
-	                   CFStringRefObj_Convert, &itself->titleString,
-	                   &itself->initialOrder,
-	                   ControlFontStyle_Convert, &itself->btnFontStyle,
-	                   ControlButtonContentInfo_Convert, &itself->btnContentInfo);
+        itself->version = kDataBrowserListViewLatestHeaderDesc;
+        return PyArg_Parse(v, "(HHhO&HO&O&)",
+                           &itself->minimumWidth,
+                           &itself->maximumWidth,
+                           &itself->titleOffset,
+                           CFStringRefObj_Convert, &itself->titleString,
+                           &itself->initialOrder,
+                           ControlFontStyle_Convert, &itself->btnFontStyle,
+                           ControlButtonContentInfo_Convert, &itself->btnContentInfo);
 }
 
 static int
 DataBrowserListViewColumnDesc_Convert(PyObject *v, DataBrowserListViewColumnDesc *itself)
 {
-	return PyArg_Parse(v, "(O&O&)",
-	                   DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc,
-	                   DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc);
+        return PyArg_Parse(v, "(O&O&)",
+                           DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc,
+                           DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc);
 }
 
 /* TrackControl and HandleControlClick callback support */
@@ -223,8 +223,8 @@ static ControlUserPaneIdleUPP myidleproc_upp;
 static ControlUserPaneHitTestUPP myhittestproc_upp;
 static ControlUserPaneTrackingUPP mytrackingproc_upp;
 
-static int settrackfunc(PyObject *); 	/* forward */
-static void clrtrackfunc(void);	/* forward */
+static int settrackfunc(PyObject *);    /* forward */
+static void clrtrackfunc(void); /* forward */
 static int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *);
 """
 
@@ -232,239 +232,239 @@ finalstuff = finalstuff + """
 static PyObject *
 CtlObj_NewUnmanaged(ControlHandle itself)
 {
-	ControlObject *it;
-	if (itself == NULL) return PyMac_Error(resNotFound);
-	it = PyObject_NEW(ControlObject, &Control_Type);
-	if (it == NULL) return NULL;
-	it->ob_itself = itself;
-	it->ob_callbackdict = NULL;
-	return (PyObject *)it;
+        ControlObject *it;
+        if (itself == NULL) return PyMac_Error(resNotFound);
+        it = PyObject_NEW(ControlObject, &Control_Type);
+        if (it == NULL) return NULL;
+        it->ob_itself = itself;
+        it->ob_callbackdict = NULL;
+        return (PyObject *)it;
 }
 
 static PyObject *
 CtlObj_WhichControl(ControlHandle c)
 {
-	PyObject *it;
-
-	if (c == NULL)
-		it = Py_None;
-	else {
-		it = (PyObject *) GetControlReference(c);
-		/*
-		** If the refcon is zero or doesn't point back to the Python object
-		** the control is not ours. Return a temporary object.
-		*/
-		if (it == NULL || ((ControlObject *)it)->ob_itself != c)
-			return CtlObj_NewUnmanaged(c);
-	}
-	Py_INCREF(it);
-	return it;
+        PyObject *it;
+
+        if (c == NULL)
+                it = Py_None;
+        else {
+                it = (PyObject *) GetControlReference(c);
+                /*
+                ** If the refcon is zero or doesn't point back to the Python object
+                ** the control is not ours. Return a temporary object.
+                */
+                if (it == NULL || ((ControlObject *)it)->ob_itself != c)
+                        return CtlObj_NewUnmanaged(c);
+        }
+        Py_INCREF(it);
+        return it;
 }
 
 static int
 settrackfunc(PyObject *obj)
 {
-	if (tracker) {
-		PyErr_SetString(Ctl_Error, "Tracker function in use");
-		return 0;
-	}
-	tracker = obj;
-	Py_INCREF(tracker);
-	return 1;
+        if (tracker) {
+                PyErr_SetString(Ctl_Error, "Tracker function in use");
+                return 0;
+        }
+        tracker = obj;
+        Py_INCREF(tracker);
+        return 1;
 }
 
 static void
 clrtrackfunc(void)
 {
-	Py_XDECREF(tracker);
-	tracker = 0;
+        Py_XDECREF(tracker);
+        tracker = 0;
 }
 
 static pascal void
 mytracker(ControlHandle ctl, short part)
 {
-	PyObject *args, *rv=0;
-
-	args = Py_BuildValue("(O&i)", CtlObj_WhichControl, ctl, (int)part);
-	if (args && tracker) {
-		rv = PyEval_CallObject(tracker, args);
-		Py_DECREF(args);
-	}
-	if (rv)
-		Py_DECREF(rv);
-	else {
-		PySys_WriteStderr("TrackControl or HandleControlClick: exception in tracker function\\n");
-		PyErr_Print();
-	}
+        PyObject *args, *rv=0;
+
+        args = Py_BuildValue("(O&i)", CtlObj_WhichControl, ctl, (int)part);
+        if (args && tracker) {
+                rv = PyEval_CallObject(tracker, args);
+                Py_DECREF(args);
+        }
+        if (rv)
+                Py_DECREF(rv);
+        else {
+                PySys_WriteStderr("TrackControl or HandleControlClick: exception in tracker function\\n");
+                PyErr_Print();
+        }
 }
 
 static int
 setcallback(PyObject *myself, OSType which, PyObject *callback, UniversalProcPtr *uppp)
 {
-	ControlObject *self = (ControlObject *)myself;
-	char keybuf[9];
-	
-	if ( which == kMyControlActionProcTag )
-		*uppp = (UniversalProcPtr)myactionproc_upp;
-	else if ( which == kControlUserPaneKeyDownProcTag )
-		*uppp = (UniversalProcPtr)mykeydownproc_upp;
-	else if ( which == kControlUserPaneFocusProcTag )
-		*uppp = (UniversalProcPtr)myfocusproc_upp;
-	else if ( which == kControlUserPaneDrawProcTag )
-		*uppp = (UniversalProcPtr)mydrawproc_upp;
-	else if ( which == kControlUserPaneIdleProcTag )
-		*uppp = (UniversalProcPtr)myidleproc_upp;
-	else if ( which == kControlUserPaneHitTestProcTag )
-		*uppp = (UniversalProcPtr)myhittestproc_upp;
-	else if ( which == kControlUserPaneTrackingProcTag )
-		*uppp = (UniversalProcPtr)mytrackingproc_upp;
-	else
-		return -1;
-	/* Only now do we test for clearing of the callback: */
-	if ( callback == Py_None )
-		*uppp = NULL;
-	/* Create the dict if it doesn't exist yet (so we don't get such a dict for every control) */
-	if ( self->ob_callbackdict == NULL )
-		if ( (self->ob_callbackdict = PyDict_New()) == NULL )
-			return -1;
-	/* And store the Python callback */
-	sprintf(keybuf, "%x", (unsigned)which);
-	if (PyDict_SetItemString(self->ob_callbackdict, keybuf, callback) < 0)
-		return -1;
-	return 0;
+        ControlObject *self = (ControlObject *)myself;
+        char keybuf[9];
+
+        if ( which == kMyControlActionProcTag )
+                *uppp = (UniversalProcPtr)myactionproc_upp;
+        else if ( which == kControlUserPaneKeyDownProcTag )
+                *uppp = (UniversalProcPtr)mykeydownproc_upp;
+        else if ( which == kControlUserPaneFocusProcTag )
+                *uppp = (UniversalProcPtr)myfocusproc_upp;
+        else if ( which == kControlUserPaneDrawProcTag )
+                *uppp = (UniversalProcPtr)mydrawproc_upp;
+        else if ( which == kControlUserPaneIdleProcTag )
+                *uppp = (UniversalProcPtr)myidleproc_upp;
+        else if ( which == kControlUserPaneHitTestProcTag )
+                *uppp = (UniversalProcPtr)myhittestproc_upp;
+        else if ( which == kControlUserPaneTrackingProcTag )
+                *uppp = (UniversalProcPtr)mytrackingproc_upp;
+        else
+                return -1;
+        /* Only now do we test for clearing of the callback: */
+        if ( callback == Py_None )
+                *uppp = NULL;
+        /* Create the dict if it doesn't exist yet (so we don't get such a dict for every control) */
+        if ( self->ob_callbackdict == NULL )
+                if ( (self->ob_callbackdict = PyDict_New()) == NULL )
+                        return -1;
+        /* And store the Python callback */
+        sprintf(keybuf, "%x", (unsigned)which);
+        if (PyDict_SetItemString(self->ob_callbackdict, keybuf, callback) < 0)
+                return -1;
+        return 0;
 }
 
 static PyObject *
 callcallback(ControlObject *self, OSType which, PyObject *arglist)
 {
-	char keybuf[9];
-	PyObject *func, *rv;
-	
-	sprintf(keybuf, "%x", (unsigned)which);
-	if ( self->ob_callbackdict == NULL ||
-			(func = PyDict_GetItemString(self->ob_callbackdict, keybuf)) == NULL ) {
-		PySys_WriteStderr("Control callback %x without callback object\\n", (unsigned)which);
-		return NULL;
-	}
-	rv = PyEval_CallObject(func, arglist);
-	if ( rv == NULL ) {
-		PySys_WriteStderr("Exception in control callback %x handler\\n", (unsigned)which);
-		PyErr_Print();
-	}
-	return rv;
+        char keybuf[9];
+        PyObject *func, *rv;
+
+        sprintf(keybuf, "%x", (unsigned)which);
+        if ( self->ob_callbackdict == NULL ||
+                        (func = PyDict_GetItemString(self->ob_callbackdict, keybuf)) == NULL ) {
+                PySys_WriteStderr("Control callback %x without callback object\\n", (unsigned)which);
+                return NULL;
+        }
+        rv = PyEval_CallObject(func, arglist);
+        if ( rv == NULL ) {
+                PySys_WriteStderr("Exception in control callback %x handler\\n", (unsigned)which);
+                PyErr_Print();
+        }
+        return rv;
 }
 
 static pascal void
 myactionproc(ControlHandle control, SInt16 part)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("Oh", ctl_obj, part);
-	rv = callcallback(ctl_obj, kMyControlActionProcTag, arglist);
-	Py_XDECREF(arglist);
-	Py_XDECREF(rv);
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("Oh", ctl_obj, part);
+        rv = callcallback(ctl_obj, kMyControlActionProcTag, arglist);
+        Py_XDECREF(arglist);
+        Py_XDECREF(rv);
 }
 
 static pascal ControlPartCode
 mykeydownproc(ControlHandle control, SInt16 keyCode, SInt16 charCode, SInt16 modifiers)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	short c_rv = 0;
-	
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("Ohhh", ctl_obj, keyCode, charCode, modifiers);
-	rv = callcallback(ctl_obj, kControlUserPaneKeyDownProcTag, arglist);
-	Py_XDECREF(arglist);
-	if ( rv )
-		if (!PyArg_Parse(rv, "h", &c_rv))
-			PyErr_Clear();
-	Py_XDECREF(rv);
-	return (ControlPartCode)c_rv;
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+        short c_rv = 0;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("Ohhh", ctl_obj, keyCode, charCode, modifiers);
+        rv = callcallback(ctl_obj, kControlUserPaneKeyDownProcTag, arglist);
+        Py_XDECREF(arglist);
+        if ( rv )
+                if (!PyArg_Parse(rv, "h", &c_rv))
+                        PyErr_Clear();
+        Py_XDECREF(rv);
+        return (ControlPartCode)c_rv;
 }
 
 static pascal ControlPartCode
 myfocusproc(ControlHandle control, ControlPartCode part)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	short c_rv = kControlFocusNoPart;
-	
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("Oh", ctl_obj, part);
-	rv = callcallback(ctl_obj, kControlUserPaneFocusProcTag, arglist);
-	Py_XDECREF(arglist);
-	if ( rv )
-		if (!PyArg_Parse(rv, "h", &c_rv))
-			PyErr_Clear();
-	Py_XDECREF(rv);
-	return (ControlPartCode)c_rv;
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+        short c_rv = kControlFocusNoPart;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("Oh", ctl_obj, part);
+        rv = callcallback(ctl_obj, kControlUserPaneFocusProcTag, arglist);
+        Py_XDECREF(arglist);
+        if ( rv )
+                if (!PyArg_Parse(rv, "h", &c_rv))
+                        PyErr_Clear();
+        Py_XDECREF(rv);
+        return (ControlPartCode)c_rv;
 }
 
 static pascal void
 mydrawproc(ControlHandle control, SInt16 part)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("Oh", ctl_obj, part);
-	rv = callcallback(ctl_obj, kControlUserPaneDrawProcTag, arglist);
-	Py_XDECREF(arglist);
-	Py_XDECREF(rv);
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("Oh", ctl_obj, part);
+        rv = callcallback(ctl_obj, kControlUserPaneDrawProcTag, arglist);
+        Py_XDECREF(arglist);
+        Py_XDECREF(rv);
 }
 
 static pascal void
 myidleproc(ControlHandle control)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("O", ctl_obj);
-	rv = callcallback(ctl_obj, kControlUserPaneIdleProcTag, arglist);
-	Py_XDECREF(arglist);
-	Py_XDECREF(rv);
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("O", ctl_obj);
+        rv = callcallback(ctl_obj, kControlUserPaneIdleProcTag, arglist);
+        Py_XDECREF(arglist);
+        Py_XDECREF(rv);
 }
 
 static pascal ControlPartCode
 myhittestproc(ControlHandle control, Point where)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	short c_rv = -1;
-
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, where);
-	rv = callcallback(ctl_obj, kControlUserPaneHitTestProcTag, arglist);
-	Py_XDECREF(arglist);
-	/* Ignore errors, nothing we can do about them */
-	if ( rv )
-		if (!PyArg_Parse(rv, "h", &c_rv))
-			PyErr_Clear();
-	Py_XDECREF(rv);
-	return (ControlPartCode)c_rv;
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+        short c_rv = -1;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, where);
+        rv = callcallback(ctl_obj, kControlUserPaneHitTestProcTag, arglist);
+        Py_XDECREF(arglist);
+        /* Ignore errors, nothing we can do about them */
+        if ( rv )
+                if (!PyArg_Parse(rv, "h", &c_rv))
+                        PyErr_Clear();
+        Py_XDECREF(rv);
+        return (ControlPartCode)c_rv;
 }
 
 static pascal ControlPartCode
 mytrackingproc(ControlHandle control, Point startPt, ControlActionUPP actionProc)
 {
-	ControlObject *ctl_obj;
-	PyObject *arglist, *rv;
-	short c_rv = -1;
-
-	ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
-	/* We cannot pass the actionProc without lots of work */
-	arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, startPt);
-	rv = callcallback(ctl_obj, kControlUserPaneTrackingProcTag, arglist);
-	Py_XDECREF(arglist);
-	if ( rv )
-		if (!PyArg_Parse(rv, "h", &c_rv))
-			PyErr_Clear();
-	Py_XDECREF(rv);
-	return (ControlPartCode)c_rv;
+        ControlObject *ctl_obj;
+        PyObject *arglist, *rv;
+        short c_rv = -1;
+
+        ctl_obj = (ControlObject *)CtlObj_WhichControl(control);
+        /* We cannot pass the actionProc without lots of work */
+        arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, startPt);
+        rv = callcallback(ctl_obj, kControlUserPaneTrackingProcTag, arglist);
+        Py_XDECREF(arglist);
+        if ( rv )
+                if (!PyArg_Parse(rv, "h", &c_rv))
+                        PyErr_Clear();
+        Py_XDECREF(rv);
+        return (ControlPartCode)c_rv;
 }
 """
 
@@ -482,18 +482,18 @@ PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ControlHandle, CtlObj_Convert);
 """
 
 class MyObjectDefinition(PEP253Mixin, ObjectIdentityMixin, GlobalObjectDefinition):
-	def outputStructMembers(self):
-		GlobalObjectDefinition.outputStructMembers(self)
-		Output("PyObject *ob_callbackdict;")
-	def outputCheckNewArg(self):
-		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
-	def outputInitStructMembers(self):
-		GlobalObjectDefinition.outputInitStructMembers(self)
-		Output("SetControlReference(itself, (long)it);")
-		Output("it->ob_callbackdict = NULL;")
-	def outputCleanupStructMembers(self):
-		Output("Py_XDECREF(self->ob_callbackdict);")
-		Output("if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */")
+    def outputStructMembers(self):
+        GlobalObjectDefinition.outputStructMembers(self)
+        Output("PyObject *ob_callbackdict;")
+    def outputCheckNewArg(self):
+        Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+    def outputInitStructMembers(self):
+        GlobalObjectDefinition.outputInitStructMembers(self)
+        Output("SetControlReference(itself, (long)it);")
+        Output("it->ob_callbackdict = NULL;")
+    def outputCleanupStructMembers(self):
+        Output("Py_XDECREF(self->ob_callbackdict);")
+        Output("if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */")
 
 # Create the generator groups and link them
 module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
@@ -523,14 +523,14 @@ PyObject *callback = 0;
 
 if (!PyArg_ParseTuple(_args, "O&|O",
                       PyMac_GetPoint, &startPoint, &callback))
-	return NULL;
+        return NULL;
 if (callback && callback != Py_None) {
-	if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
-		upp = (ControlActionUPP)-1;
-	else {
-		settrackfunc(callback);
-		upp = mytracker_upp;
-	}
+        if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+                upp = (ControlActionUPP)-1;
+        else {
+                settrackfunc(callback);
+                upp = mytracker_upp;
+        }
 }
 _rv = TrackControl(_self->ob_itself,
                    startPoint,
@@ -558,14 +558,14 @@ if (!PyArg_ParseTuple(_args, "O&h|O",
                       PyMac_GetPoint, &startPoint,
                       &modifiers,
                       &callback))
-	return NULL;
+        return NULL;
 if (callback && callback != Py_None) {
-	if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
-		upp = (ControlActionUPP)-1;
-	else {
-		settrackfunc(callback);
-		upp = mytracker_upp;
-	}
+        if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1)
+                upp = (ControlActionUPP)-1;
+        else {
+                settrackfunc(callback);
+                upp = mytracker_upp;
+        }
 }
 _rv = HandleControlClick(_self->ob_itself,
                    startPoint,
@@ -593,16 +593,16 @@ if (!PyArg_ParseTuple(_args, "hO&s#",
                       &inPart,
                       PyMac_GetOSType, &inTagName,
                       &buffer, &bufferSize))
-	return NULL;
+        return NULL;
 
 _err = SetControlData(_self->ob_itself,
-	              inPart,
-	              inTagName,
-	              bufferSize,
+                      inPart,
+                      inTagName,
+                      bufferSize,
                       buffer);
 
 if (_err != noErr)
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 _res = Py_None;
 return _res;
 """
@@ -623,29 +623,29 @@ Size outSize;
 if (!PyArg_ParseTuple(_args, "hO&",
                       &inPart,
                       PyMac_GetOSType, &inTagName))
-	return NULL;
+        return NULL;
 
 /* allocate a buffer for the data */
 _err = GetControlDataSize(_self->ob_itself,
-	                  inPart,
-	                  inTagName,
+                          inPart,
+                          inTagName,
                           &bufferSize);
 if (_err != noErr)
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 buffer = PyMem_NEW(char, bufferSize);
 if (buffer == NULL)
-	return PyErr_NoMemory();
+        return PyErr_NoMemory();
 
 _err = GetControlData(_self->ob_itself,
-	              inPart,
-	              inTagName,
-	              bufferSize,
+                      inPart,
+                      inTagName,
+                      bufferSize,
                       buffer,
                       &outSize);
 
 if (_err != noErr) {
-	PyMem_DEL(buffer);
-	return PyMac_Error(_err);
+        PyMem_DEL(buffer);
+        return PyMac_Error(_err);
 }
 _res = Py_BuildValue("s#", buffer, outSize);
 PyMem_DEL(buffer);
@@ -667,16 +667,16 @@ if (!PyArg_ParseTuple(_args, "hO&O&",
                       &inPart,
                       PyMac_GetOSType, &inTagName,
                       OptResObj_Convert, &buffer))
-	return NULL;
+        return NULL;
 
 _err = SetControlData(_self->ob_itself,
-	              inPart,
-	              inTagName,
-	              sizeof(buffer),
+                      inPart,
+                      inTagName,
+                      sizeof(buffer),
                       (Ptr)&buffer);
 
 if (_err != noErr)
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 _res = Py_None;
 return _res;
 """
@@ -696,29 +696,29 @@ Handle hdl;
 if (!PyArg_ParseTuple(_args, "hO&",
                       &inPart,
                       PyMac_GetOSType, &inTagName))
-	return NULL;
+        return NULL;
 
 /* Check it is handle-sized */
 _err = GetControlDataSize(_self->ob_itself,
-	                  inPart,
-	                  inTagName,
+                          inPart,
+                          inTagName,
                           &bufferSize);
 if (_err != noErr)
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 if (bufferSize != sizeof(Handle)) {
-	PyErr_SetString(Ctl_Error, "GetControlDataSize() != sizeof(Handle)");
-	return NULL;
+        PyErr_SetString(Ctl_Error, "GetControlDataSize() != sizeof(Handle)");
+        return NULL;
 }
 
 _err = GetControlData(_self->ob_itself,
-	              inPart,
-	              inTagName,
-	              sizeof(Handle),
+                      inPart,
+                      inTagName,
+                      sizeof(Handle),
                       (Ptr)&hdl,
                       &bufferSize);
 
 if (_err != noErr) {
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 }
 _res = Py_BuildValue("O&", OptResObj_New, hdl);
 return _res;
@@ -740,18 +740,18 @@ if (!PyArg_ParseTuple(_args, "hO&O",
                       &inPart,
                       PyMac_GetOSType, &inTagName,
                       &callback))
-	return NULL;
+        return NULL;
 
 if ( setcallback((PyObject *)_self, inTagName, callback, &c_callback) < 0 )
-	return NULL;
+        return NULL;
 _err = SetControlData(_self->ob_itself,
-	              inPart,
-	              inTagName,
-	              sizeof(c_callback),
+                      inPart,
+                      inTagName,
+                      sizeof(c_callback),
                       (Ptr)&c_callback);
 
 if (_err != noErr)
-	return PyMac_Error(_err);
+        return PyMac_Error(_err);
 _res = Py_None;
 return _res;
 """
@@ -783,26 +783,26 @@ if (!PyArg_ParseTuple(_args, "O&O&HHO",
                       &size,
                       &direction,
                       &tabArrayObj))
-	return NULL;
+        return NULL;
 
 i = PySequence_Length(tabArrayObj);
 if (i == -1)
-	return NULL;
+        return NULL;
 if (i > MAXTABS) {
-	PyErr_SetString(Ctl_Error, "Too many tabs");
-	return NULL;
+        PyErr_SetString(Ctl_Error, "Too many tabs");
+        return NULL;
 }
 numTabs = i;
 for (i=0; i<numTabs; i++) {
-	tabEntry = PySequence_GetItem(tabArrayObj, i);
-	if (tabEntry == NULL)
-		return NULL;
-	if (!PyArg_Parse(tabEntry, "(O&O&B)",
-	                 ControlButtonContentInfo_Convert, &tabArray[i].icon,
-	                 CFStringRefObj_Convert, &tabArray[i].name,
-	                 &tabArray[i].enabled
-	                 ))
-		return NULL;
+        tabEntry = PySequence_GetItem(tabArrayObj, i);
+        if (tabEntry == NULL)
+                return NULL;
+        if (!PyArg_Parse(tabEntry, "(O&O&B)",
+                         ControlButtonContentInfo_Convert, &tabArray[i].icon,
+                         CFStringRefObj_Convert, &tabArray[i].name,
+                         &tabArray[i].enabled
+                         ))
+                return NULL;
 }
 
 _err = CreateTabsControl(window,