Regenerated from Universal Headers 3.0.1. Some new calls are

blacklisted, because they are not available in classic 68k programs,
and bgen doesn't have a way to put #ifdef/#endif in the generated
code. For now we only implement calls that work on all three models.

28 files changed, 2918 insertions, 1201 deletions

diff --git a/Mac/Modules/ae/AEmodule.c b/Mac/Modules/ae/AEmodule.c
index ed20b40..3127430 100644
--- a/Mac/Modules/ae/AEmodule.c
+++ b/Mac/Modules/ae/AEmodule.c
@@ -125,6 +125,117 @@ static void AEDesc_dealloc(self)
 	PyMem_DEL(self);
 }
 
+static PyObject *AEDesc_AESend(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	AppleEvent reply;
+	AESendMode sendMode;
+	AESendPriority sendPriority;
+	long timeOutInTicks;
+	if (!PyArg_ParseTuple(_args, "lhl",
+	                      &sendMode,
+	                      &sendPriority,
+	                      &timeOutInTicks))
+		return NULL;
+	_err = AESend(&_self->ob_itself,
+	              &reply,
+	              sendMode,
+	              sendPriority,
+	              timeOutInTicks,
+	              upp_AEIdleProc,
+	              (AEFilterUPP)0);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     AEDesc_New, &reply);
+	return _res;
+}
+
+static PyObject *AEDesc_AEResetTimer(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = AEResetTimer(&_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *AEDesc_AESuspendTheCurrentEvent(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = AESuspendTheCurrentEvent(&_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *AEDesc_AEResumeTheCurrentEvent(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	AppleEvent reply;
+	AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
+	PyObject *dispatcher;
+	if (!PyArg_ParseTuple(_args, "O&O",
+	                      AEDesc_Convert, &reply,
+	                      &dispatcher))
+		return NULL;
+	_err = AEResumeTheCurrentEvent(&_self->ob_itself,
+	                               &reply,
+	                               dispatcher__proc__, (long)dispatcher);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	Py_INCREF(dispatcher); /* XXX leak, but needed */
+	return _res;
+}
+
+static PyObject *AEDesc_AEGetTheCurrentEvent(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = AEGetTheCurrentEvent(&_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *AEDesc_AESetTheCurrentEvent(_self, _args)
+	AEDescObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = AESetTheCurrentEvent(&_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *AEDesc_AECoerceDesc(_self, _args)
 	AEDescObject *_self;
 	PyObject *_args;
@@ -617,118 +728,19 @@ static PyObject *AEDesc_AEPutAttributeDesc(_self, _args)
 	return _res;
 }
 
-static PyObject *AEDesc_AESend(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	AppleEvent reply;
-	AESendMode sendMode;
-	AESendPriority sendPriority;
-	long timeOutInTicks;
-	if (!PyArg_ParseTuple(_args, "lhl",
-	                      &sendMode,
-	                      &sendPriority,
-	                      &timeOutInTicks))
-		return NULL;
-	_err = AESend(&_self->ob_itself,
-	              &reply,
-	              sendMode,
-	              sendPriority,
-	              timeOutInTicks,
-	              upp_AEIdleProc,
-	              (AEFilterUPP)0);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &reply);
-	return _res;
-}
-
-static PyObject *AEDesc_AEResetTimer(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = AEResetTimer(&_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *AEDesc_AESuspendTheCurrentEvent(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = AESuspendTheCurrentEvent(&_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *AEDesc_AEResumeTheCurrentEvent(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	AppleEvent reply;
-	AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
-	PyObject *dispatcher;
-	if (!PyArg_ParseTuple(_args, "O&O",
-	                      AEDesc_Convert, &reply,
-	                      &dispatcher))
-		return NULL;
-	_err = AEResumeTheCurrentEvent(&_self->ob_itself,
-	                               &reply,
-	                               dispatcher__proc__, (long)dispatcher);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	Py_INCREF(dispatcher); /* XXX leak, but needed */
-	return _res;
-}
-
-static PyObject *AEDesc_AEGetTheCurrentEvent(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = AEGetTheCurrentEvent(&_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *AEDesc_AESetTheCurrentEvent(_self, _args)
-	AEDescObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_err = AESetTheCurrentEvent(&_self->ob_itself);
-	if (_err != noErr) return PyMac_Error(_err);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
 static PyMethodDef AEDesc_methods[] = {
+	{"AESend", (PyCFunction)AEDesc_AESend, 1,
+	 "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
+	{"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
+	 "() -> None"},
+	{"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
+	 "() -> None"},
+	{"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
+	 "(AppleEvent reply, EventHandler dispatcher) -> None"},
+	{"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
+	 "() -> None"},
+	{"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
+	 "() -> None"},
 	{"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
 	 "(DescType toType) -> (AEDesc result)"},
 	{"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
@@ -769,18 +781,6 @@ static PyMethodDef AEDesc_methods[] = {
 	 "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
 	{"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
 	 "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
-	{"AESend", (PyCFunction)AEDesc_AESend, 1,
-	 "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
-	{"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
-	 "() -> None"},
-	{"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
-	 "() -> None"},
-	{"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
-	 "(AppleEvent reply, EventHandler dispatcher) -> None"},
-	{"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
-	 "() -> None"},
-	{"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
-	 "() -> None"},
 	{NULL, NULL, 0}
 };
 
@@ -829,118 +829,6 @@ PyTypeObject AEDesc_Type = {
 /* --------------------- End object type AEDesc --------------------- */
 
 
-static PyObject *AE_AECreateDesc(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	DescType typeCode;
-	char *dataPtr__in__;
-	long dataPtr__len__;
-	int dataPtr__in_len__;
-	AEDesc result;
-	if (!PyArg_ParseTuple(_args, "O&s#",
-	                      PyMac_GetOSType, &typeCode,
-	                      &dataPtr__in__, &dataPtr__in_len__))
-		return NULL;
-	dataPtr__len__ = dataPtr__in_len__;
-	_err = AECreateDesc(typeCode,
-	                    dataPtr__in__, dataPtr__len__,
-	                    &result);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &result);
- dataPtr__error__: ;
-	return _res;
-}
-
-static PyObject *AE_AECoercePtr(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	DescType typeCode;
-	char *dataPtr__in__;
-	long dataPtr__len__;
-	int dataPtr__in_len__;
-	DescType toType;
-	AEDesc result;
-	if (!PyArg_ParseTuple(_args, "O&s#O&",
-	                      PyMac_GetOSType, &typeCode,
-	                      &dataPtr__in__, &dataPtr__in_len__,
-	                      PyMac_GetOSType, &toType))
-		return NULL;
-	dataPtr__len__ = dataPtr__in_len__;
-	_err = AECoercePtr(typeCode,
-	                   dataPtr__in__, dataPtr__len__,
-	                   toType,
-	                   &result);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &result);
- dataPtr__error__: ;
-	return _res;
-}
-
-static PyObject *AE_AECreateList(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	char *factoringPtr__in__;
-	long factoringPtr__len__;
-	int factoringPtr__in_len__;
-	Boolean isRecord;
-	AEDescList resultList;
-	if (!PyArg_ParseTuple(_args, "s#b",
-	                      &factoringPtr__in__, &factoringPtr__in_len__,
-	                      &isRecord))
-		return NULL;
-	factoringPtr__len__ = factoringPtr__in_len__;
-	_err = AECreateList(factoringPtr__in__, factoringPtr__len__,
-	                    isRecord,
-	                    &resultList);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &resultList);
- factoringPtr__error__: ;
-	return _res;
-}
-
-static PyObject *AE_AECreateAppleEvent(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	OSErr _err;
-	AEEventClass theAEEventClass;
-	AEEventID theAEEventID;
-	AEAddressDesc target;
-	short returnID;
-	long transactionID;
-	AppleEvent result;
-	if (!PyArg_ParseTuple(_args, "O&O&O&hl",
-	                      PyMac_GetOSType, &theAEEventClass,
-	                      PyMac_GetOSType, &theAEEventID,
-	                      AEDesc_Convert, &target,
-	                      &returnID,
-	                      &transactionID))
-		return NULL;
-	_err = AECreateAppleEvent(theAEEventClass,
-	                          theAEEventID,
-	                          &target,
-	                          returnID,
-	                          transactionID,
-	                          &result);
-	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     AEDesc_New, &result);
-	return _res;
-}
-
 static PyObject *AE_AEProcessAppleEvent(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -1102,15 +990,119 @@ static PyObject *AE_AEManagerInfo(_self, _args)
 	return _res;
 }
 
+static PyObject *AE_AECoercePtr(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	DescType typeCode;
+	char *dataPtr__in__;
+	long dataPtr__len__;
+	int dataPtr__in_len__;
+	DescType toType;
+	AEDesc result;
+	if (!PyArg_ParseTuple(_args, "O&s#O&",
+	                      PyMac_GetOSType, &typeCode,
+	                      &dataPtr__in__, &dataPtr__in_len__,
+	                      PyMac_GetOSType, &toType))
+		return NULL;
+	dataPtr__len__ = dataPtr__in_len__;
+	_err = AECoercePtr(typeCode,
+	                   dataPtr__in__, dataPtr__len__,
+	                   toType,
+	                   &result);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     AEDesc_New, &result);
+ dataPtr__error__: ;
+	return _res;
+}
+
+static PyObject *AE_AECreateDesc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	DescType typeCode;
+	char *dataPtr__in__;
+	long dataPtr__len__;
+	int dataPtr__in_len__;
+	AEDesc result;
+	if (!PyArg_ParseTuple(_args, "O&s#",
+	                      PyMac_GetOSType, &typeCode,
+	                      &dataPtr__in__, &dataPtr__in_len__))
+		return NULL;
+	dataPtr__len__ = dataPtr__in_len__;
+	_err = AECreateDesc(typeCode,
+	                    dataPtr__in__, dataPtr__len__,
+	                    &result);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     AEDesc_New, &result);
+ dataPtr__error__: ;
+	return _res;
+}
+
+static PyObject *AE_AECreateList(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	char *factoringPtr__in__;
+	long factoringPtr__len__;
+	int factoringPtr__in_len__;
+	Boolean isRecord;
+	AEDescList resultList;
+	if (!PyArg_ParseTuple(_args, "s#b",
+	                      &factoringPtr__in__, &factoringPtr__in_len__,
+	                      &isRecord))
+		return NULL;
+	factoringPtr__len__ = factoringPtr__in_len__;
+	_err = AECreateList(factoringPtr__in__, factoringPtr__len__,
+	                    isRecord,
+	                    &resultList);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     AEDesc_New, &resultList);
+ factoringPtr__error__: ;
+	return _res;
+}
+
+static PyObject *AE_AECreateAppleEvent(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	AEEventClass theAEEventClass;
+	AEEventID theAEEventID;
+	AEAddressDesc target;
+	AEReturnID returnID;
+	AETransactionID transactionID;
+	AppleEvent result;
+	if (!PyArg_ParseTuple(_args, "O&O&O&hh",
+	                      PyMac_GetOSType, &theAEEventClass,
+	                      PyMac_GetOSType, &theAEEventID,
+	                      AEDesc_Convert, &target,
+	                      &returnID,
+	                      &transactionID))
+		return NULL;
+	_err = AECreateAppleEvent(theAEEventClass,
+	                          theAEEventID,
+	                          &target,
+	                          returnID,
+	                          transactionID,
+	                          &result);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     AEDesc_New, &result);
+	return _res;
+}
+
 static PyMethodDef AE_methods[] = {
-	{"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
-	 "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
-	{"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
-	 "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
-	{"AECreateList", (PyCFunction)AE_AECreateList, 1,
-	 "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
-	{"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
-	 "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, short returnID, long transactionID) -> (AppleEvent result)"},
 	{"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
 	 "(EventRecord theEventRecord) -> None"},
 	{"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
@@ -1127,6 +1119,14 @@ static PyMethodDef AE_methods[] = {
 	 "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"},
 	{"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
 	 "(AEKeyword keyWord) -> (long result)"},
+	{"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
+	 "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
+	{"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
+	 "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
+	{"AECreateList", (PyCFunction)AE_AECreateList, 1,
+	 "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
+	{"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
+	 "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/ae/aescan.py b/Mac/Modules/ae/aescan.py
index 4317195..620a91c 100644
--- a/Mac/Modules/ae/aescan.py
+++ b/Mac/Modules/ae/aescan.py
@@ -19,7 +19,7 @@ def main():
 	input = "AERegistry.h"
 	output = "@dummy-registry.py"
 	defsoutput = TOOLBOXDIR + "AERegistry.py"
-	scanner = AppleEventsScanner(input, output, defsoutput)
+	scanner = AppleEventsRegScanner(input, output, defsoutput)
 	scanner.scan()
 	scanner.close()
 	print "=== Scanning AEObjects.h for defines ==="
@@ -32,11 +32,19 @@ def main():
 	scanner = AppleEventsScanner(input, output, defsoutput)
 	scanner.scan()
 	scanner.close()
-	print "=== Scanning AppleEvents.py ==="
+	print "=== Scanning AEDataModel.h ==="
+	input = "AEDataModel.h"
+	output = "aedatamodelgen.py"
+	defsoutput = TOOLBOXDIR + "AEDataModel.py"
+	scanner = AppleEventsScanner(input, output, defsoutput)
+	
+	scanner.scan()
+	scanner.close()
+	print "=== Scanning AppleEvents.h ==="
 	input = "AppleEvents.h"
 	output = "aegen.py"
 	defsoutput = TOOLBOXDIR + "AppleEvents.py"
-	scanner = AppleEventsScanner(input, output, defsoutput)
+	scanner = AppleEventsRegScanner(input, output, defsoutput)
 	scanner.scan()
 	scanner.close()
 	print "=== Done Scanning and Generating, now doing 'import aesupport' ==="
@@ -102,5 +110,13 @@ class AppleEventsScanner(Scanner):
 			 [("AEDescList_ptr", "*", "InMode")]),
 			]
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
+class AppleEventsRegScanner(AppleEventsScanner):
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+		self.defsfile.write("from AEDataModel import *\n")
+
 if __name__ == "__main__":
 	main()
diff --git a/Mac/Modules/ae/aesupport.py b/Mac/Modules/ae/aesupport.py
index ee6ee7a..f2c947f 100644
--- a/Mac/Modules/ae/aesupport.py
+++ b/Mac/Modules/ae/aesupport.py
@@ -13,6 +13,9 @@ AEArrayType = Type("AEArrayType", "c")
 AESendMode = Type("AESendMode", "l")
 AESendPriority = Type("AESendPriority", "h")
 AEInteractAllowed = Type("AEInteractAllowed", "b")
+AEReturnID = Type("AEReturnID", "h")
+AETransactionID = Type("AETransactionID", "h")
+
 
 
 AEEventClass = OSTypeType('AEEventClass')
@@ -199,6 +202,7 @@ functions = []
 aedescmethods = []
 
 execfile('aegen.py')
+execfile('aedatamodelgen.py')
 
 for f in functions: module.add(f)
 for f in aedescmethods: aedescobject.add(f)
diff --git a/Mac/Modules/cm/cmscan.py b/Mac/Modules/cm/cmscan.py
index ea2dc2f..3e091a6 100644
--- a/Mac/Modules/cm/cmscan.py
+++ b/Mac/Modules/cm/cmscan.py
@@ -6,7 +6,7 @@ from scantools import Scanner
 from bgenlocations import TOOLBOXDIR
 
 LONG = "Components"
-SHORT = "Cm"
+SHORT = "cm"
 
 def main():
 	input = "Components.h"
@@ -38,6 +38,9 @@ class MyScanner(Scanner):
 				listname = "ci_methods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
 	def makeblacklistnames(self):
 		return [
 			"OpenADefaultComponent",
diff --git a/Mac/Modules/ctl/Ctlmodule.c b/Mac/Modules/ctl/Ctlmodule.c
index 573f581..e043b61 100644
--- a/Mac/Modules/ctl/Ctlmodule.c
+++ b/Mac/Modules/ctl/Ctlmodule.c
@@ -47,11 +47,37 @@ extern PyObject *WinObj_WhichWindow(WindowPtr);
 #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
 
 extern PyObject *CtlObj_WhichControl(ControlHandle); /* Forward */
+extern PyObject *QdRGB_New(RGBColorPtr);
+extern QdRGB_Convert(PyObject *, RGBColorPtr);
 
 #ifdef THINK_C
 #define  ControlActionUPP ProcPtr
 #endif
 
+/*
+** Parse/generate ControlFontStyleRec records
+*/
+#if 0 /* Not needed */
+PyObject *ControlFontStyle_New(itself)
+	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);
+}
+#endif
+
+ControlFontStyle_Convert(v, itself)
+	PyObject *v;
+	ControlFontStyleRec *itself;
+{
+	return PyArg_ParseTuple(v, "hhhhhhO&O&", &itself->flags,
+		&itself->font, &itself->size, &itself->style, &itself->mode, 
+		&itself->just, QdRGB_Convert, &itself->foreColor, 
+		QdRGB_Convert, &itself->backColor);
+}
+
 static PyObject *Ctl_Error;
 
 /* ---------------------- Object type Control ----------------------- */
@@ -96,6 +122,22 @@ static void CtlObj_dealloc(self)
 	PyMem_DEL(self);
 }
 
+static PyObject *CtlObj_HiliteControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ControlPartCode hiliteState;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &hiliteState))
+		return NULL;
+	HiliteControl(_self->ob_itself,
+	              hiliteState);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *CtlObj_ShowControl(_self, _args)
 	ControlObject *_self;
 	PyObject *_args;
@@ -122,6 +164,85 @@ static PyObject *CtlObj_HideControl(_self, _args)
 	return _res;
 }
 
+static PyObject *CtlObj_IsControlActive(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsControlActive(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *CtlObj_IsControlVisible(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsControlVisible(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *CtlObj_ActivateControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = ActivateControl(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_DeactivateControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = DeactivateControl(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_SetControlVisibility(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Boolean inIsVisible;
+	Boolean inDoDraw;
+	if (!PyArg_ParseTuple(_args, "bb",
+	                      &inIsVisible,
+	                      &inDoDraw))
+		return NULL;
+	_err = SetControlVisibility(_self->ob_itself,
+	                            inIsVisible,
+	                            inDoDraw);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *CtlObj_Draw1Control(_self, _args)
 	ControlObject *_self;
 	PyObject *_args;
@@ -135,17 +256,73 @@ static PyObject *CtlObj_Draw1Control(_self, _args)
 	return _res;
 }
 
-static PyObject *CtlObj_HiliteControl(_self, _args)
+static PyObject *CtlObj_GetBestControlRect(_self, _args)
 	ControlObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	ControlPartCode hiliteState;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &hiliteState))
+	OSErr _err;
+	Rect outRect;
+	SInt16 outBaseLineOffset;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	HiliteControl(_self->ob_itself,
-	              hiliteState);
+	_err = GetBestControlRect(_self->ob_itself,
+	                          &outRect,
+	                          &outBaseLineOffset);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&h",
+	                     PyMac_BuildRect, &outRect,
+	                     outBaseLineOffset);
+	return _res;
+}
+
+static PyObject *CtlObj_SetControlFontStyle(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	ControlFontStyleRec inStyle;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ControlFontStyle_Convert, &inStyle))
+		return NULL;
+	_err = SetControlFontStyle(_self->ob_itself,
+	                           &inStyle);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_DrawControlInCurrentPort(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	DrawControlInCurrentPort(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_SetUpControlBackground(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inDepth;
+	Boolean inIsColorDevice;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &inDepth,
+	                      &inIsColorDevice))
+		return NULL;
+	_err = SetUpControlBackground(_self->ob_itself,
+	                              inDepth,
+	                              inIsColorDevice);
+	if (_err != noErr) return PyMac_Error(_err);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
@@ -157,12 +334,12 @@ static PyObject *CtlObj_TrackControl(_self, _args)
 {
 	PyObject *_res = NULL;
 	ControlPartCode _rv;
-	Point thePoint;
+	Point startPoint;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	                      PyMac_GetPoint, &startPoint))
 		return NULL;
 	_rv = TrackControl(_self->ob_itself,
-	                   thePoint,
+	                   startPoint,
 	                   (ControlActionUPP)0);
 	_res = Py_BuildValue("h",
 	                     _rv);
@@ -200,12 +377,35 @@ static PyObject *CtlObj_TestControl(_self, _args)
 {
 	PyObject *_res = NULL;
 	ControlPartCode _rv;
-	Point thePoint;
+	Point testPoint;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	                      PyMac_GetPoint, &testPoint))
 		return NULL;
 	_rv = TestControl(_self->ob_itself,
-	                  thePoint);
+	                  testPoint);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *CtlObj_HandleControlKey(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	SInt16 _rv;
+	SInt16 inKeyCode;
+	SInt16 inCharCode;
+	SInt16 inModifiers;
+	if (!PyArg_ParseTuple(_args, "hhh",
+	                      &inKeyCode,
+	                      &inCharCode,
+	                      &inModifiers))
+		return NULL;
+	_rv = HandleControlKey(_self->ob_itself,
+	                       inKeyCode,
+	                       inCharCode,
+	                       inModifiers);
 	_res = Py_BuildValue("h",
 	                     _rv);
 	return _res;
@@ -376,7 +576,7 @@ static PyObject *CtlObj_GetControlVariant(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	SInt16 _rv;
+	ControlVariant _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = GetControlVariant(_self->ob_itself);
@@ -462,6 +662,174 @@ static PyObject *CtlObj_SetControlColor(_self, _args)
 	return _res;
 }
 
+static PyObject *CtlObj_SendControlMessage(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	SInt32 _rv;
+	SInt16 inMessage;
+	SInt32 inParam;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &inMessage,
+	                      &inParam))
+		return NULL;
+	_rv = SendControlMessage(_self->ob_itself,
+	                         inMessage,
+	                         inParam);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *CtlObj_EmbedControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	ControlHandle inContainer;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CtlObj_Convert, &inContainer))
+		return NULL;
+	_err = EmbedControl(_self->ob_itself,
+	                    inContainer);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_AutoEmbedControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = AutoEmbedControl(_self->ob_itself,
+	                        inWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_GetSuperControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	ControlHandle outParent;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetSuperControl(_self->ob_itself,
+	                       &outParent);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_WhichControl, outParent);
+	return _res;
+}
+
+static PyObject *CtlObj_CountSubControls(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 outNumChildren;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = CountSubControls(_self->ob_itself,
+	                        &outNumChildren);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("h",
+	                     outNumChildren);
+	return _res;
+}
+
+static PyObject *CtlObj_GetIndexedSubControl(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inIndex;
+	ControlHandle outSubControl;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inIndex))
+		return NULL;
+	_err = GetIndexedSubControl(_self->ob_itself,
+	                            inIndex,
+	                            &outSubControl);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_WhichControl, outSubControl);
+	return _res;
+}
+
+static PyObject *CtlObj_SetControlSupervisor(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	ControlHandle inBoss;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CtlObj_Convert, &inBoss))
+		return NULL;
+	_err = SetControlSupervisor(_self->ob_itself,
+	                            inBoss);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *CtlObj_GetControlFeatures(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	UInt32 outFeatures;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetControlFeatures(_self->ob_itself,
+	                          &outFeatures);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outFeatures);
+	return _res;
+}
+
+static PyObject *CtlObj_GetControlDataSize(_self, _args)
+	ControlObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	ControlPartCode inPart;
+	ResType inTagName;
+	Size outMaxSize;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &inPart,
+	                      PyMac_GetOSType, &inTagName))
+		return NULL;
+	_err = GetControlDataSize(_self->ob_itself,
+	                          inPart,
+	                          inTagName,
+	                          &outMaxSize);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outMaxSize);
+	return _res;
+}
+
 static PyObject *CtlObj_as_Resource(_self, _args)
 	ControlObject *_self;
 	PyObject *_args;
@@ -492,20 +860,40 @@ static PyObject *CtlObj_DisposeControl(_self, _args)
 }
 
 static PyMethodDef CtlObj_methods[] = {
+	{"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1,
+	 "(ControlPartCode hiliteState) -> None"},
 	{"ShowControl", (PyCFunction)CtlObj_ShowControl, 1,
 	 "() -> None"},
 	{"HideControl", (PyCFunction)CtlObj_HideControl, 1,
 	 "() -> None"},
+	{"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1,
+	 "() -> (Boolean _rv)"},
+	{"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1,
+	 "() -> (Boolean _rv)"},
+	{"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1,
+	 "() -> None"},
+	{"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1,
+	 "() -> None"},
+	{"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1,
+	 "(Boolean inIsVisible, Boolean inDoDraw) -> None"},
 	{"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1,
 	 "() -> None"},
-	{"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1,
-	 "(ControlPartCode hiliteState) -> None"},
+	{"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1,
+	 "() -> (Rect outRect, SInt16 outBaseLineOffset)"},
+	{"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1,
+	 "(ControlFontStyleRec inStyle) -> None"},
+	{"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1,
+	 "() -> None"},
+	{"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1,
+	 "(SInt16 inDepth, Boolean inIsColorDevice) -> None"},
 	{"TrackControl", (PyCFunction)CtlObj_TrackControl, 1,
-	 "(Point thePoint) -> (ControlPartCode _rv)"},
+	 "(Point startPoint) -> (ControlPartCode _rv)"},
 	{"DragControl", (PyCFunction)CtlObj_DragControl, 1,
 	 "(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None"},
 	{"TestControl", (PyCFunction)CtlObj_TestControl, 1,
-	 "(Point thePoint) -> (ControlPartCode _rv)"},
+	 "(Point testPoint) -> (ControlPartCode _rv)"},
+	{"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1,
+	 "(SInt16 inKeyCode, SInt16 inCharCode, SInt16 inModifiers) -> (SInt16 _rv)"},
 	{"MoveControl", (PyCFunction)CtlObj_MoveControl, 1,
 	 "(SInt16 h, SInt16 v) -> None"},
 	{"SizeControl", (PyCFunction)CtlObj_SizeControl, 1,
@@ -527,7 +915,7 @@ static PyMethodDef CtlObj_methods[] = {
 	{"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1,
 	 "(SInt16 newMaximum) -> None"},
 	{"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1,
-	 "() -> (SInt16 _rv)"},
+	 "() -> (ControlVariant _rv)"},
 	{"SetControlAction", (PyCFunction)CtlObj_SetControlAction, 1,
 	 "() -> None"},
 	{"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1,
@@ -538,6 +926,24 @@ static PyMethodDef CtlObj_methods[] = {
 	 "() -> (Boolean _rv, AuxCtlHandle acHndl)"},
 	{"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1,
 	 "(CCTabHandle newColorTable) -> None"},
+	{"SendControlMessage", (PyCFunction)CtlObj_SendControlMessage, 1,
+	 "(SInt16 inMessage, SInt32 inParam) -> (SInt32 _rv)"},
+	{"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1,
+	 "(ControlHandle inContainer) -> None"},
+	{"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1,
+	 "(WindowPtr inWindow) -> None"},
+	{"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1,
+	 "() -> (ControlHandle outParent)"},
+	{"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1,
+	 "() -> (SInt16 outNumChildren)"},
+	{"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1,
+	 "(SInt16 inIndex) -> (ControlHandle outSubControl)"},
+	{"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1,
+	 "(ControlHandle inBoss) -> None"},
+	{"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1,
+	 "() -> (UInt32 outFeatures)"},
+	{"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1,
+	 "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"},
 	{"as_Resource", (PyCFunction)CtlObj_as_Resource, 1,
 	 "Return this Control as a Resource"},
 	{"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1,
@@ -578,35 +984,35 @@ static PyObject *Ctl_NewControl(_self, _args)
 {
 	PyObject *_res = NULL;
 	ControlHandle _rv;
-	WindowPtr theWindow;
+	WindowPtr owningWindow;
 	Rect boundsRect;
-	Str255 title;
-	Boolean visible;
-	SInt16 value;
-	SInt16 min;
-	SInt16 max;
+	Str255 controlTitle;
+	Boolean initiallyVisible;
+	SInt16 initialValue;
+	SInt16 minimumValue;
+	SInt16 maximumValue;
 	SInt16 procID;
-	SInt32 refCon;
+	SInt32 controlReference;
 	if (!PyArg_ParseTuple(_args, "O&O&O&bhhhhl",
-	                      WinObj_Convert, &theWindow,
+	                      WinObj_Convert, &owningWindow,
 	                      PyMac_GetRect, &boundsRect,
-	                      PyMac_GetStr255, title,
-	                      &visible,
-	                      &value,
-	                      &min,
-	                      &max,
+	                      PyMac_GetStr255, controlTitle,
+	                      &initiallyVisible,
+	                      &initialValue,
+	                      &minimumValue,
+	                      &maximumValue,
 	                      &procID,
-	                      &refCon))
+	                      &controlReference))
 		return NULL;
-	_rv = NewControl(theWindow,
+	_rv = NewControl(owningWindow,
 	                 &boundsRect,
-	                 title,
-	                 visible,
-	                 value,
-	                 min,
-	                 max,
+	                 controlTitle,
+	                 initiallyVisible,
+	                 initialValue,
+	                 minimumValue,
+	                 maximumValue,
 	                 procID,
-	                 refCon);
+	                 controlReference);
 	_res = Py_BuildValue("O&",
 	                     CtlObj_New, _rv);
 	return _res;
@@ -618,14 +1024,14 @@ static PyObject *Ctl_GetNewControl(_self, _args)
 {
 	PyObject *_res = NULL;
 	ControlHandle _rv;
-	SInt16 controlID;
-	WindowPtr owner;
+	SInt16 resourceID;
+	WindowPtr owningWindow;
 	if (!PyArg_ParseTuple(_args, "hO&",
-	                      &controlID,
-	                      WinObj_Convert, &owner))
+	                      &resourceID,
+	                      WinObj_Convert, &owningWindow))
 		return NULL;
-	_rv = GetNewControl(controlID,
-	                    owner);
+	_rv = GetNewControl(resourceID,
+	                    owningWindow);
 	_res = Py_BuildValue("O&",
 	                     CtlObj_New, _rv);
 	return _res;
@@ -670,14 +1076,14 @@ static PyObject *Ctl_FindControl(_self, _args)
 {
 	PyObject *_res = NULL;
 	ControlPartCode _rv;
-	Point thePoint;
+	Point testPoint;
 	WindowPtr theWindow;
 	ControlHandle theControl;
 	if (!PyArg_ParseTuple(_args, "O&O&",
-	                      PyMac_GetPoint, &thePoint,
+	                      PyMac_GetPoint, &testPoint,
 	                      WinObj_Convert, &theWindow))
 		return NULL;
-	_rv = FindControl(thePoint,
+	_rv = FindControl(testPoint,
 	                  theWindow,
 	                  &theControl);
 	_res = Py_BuildValue("hO&",
@@ -686,17 +1092,225 @@ static PyObject *Ctl_FindControl(_self, _args)
 	return _res;
 }
 
+static PyObject *Ctl_FindControlUnderMouse(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ControlHandle _rv;
+	Point inWhere;
+	WindowPtr inWindow;
+	SInt16 outPart;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &inWhere,
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_rv = FindControlUnderMouse(inWhere,
+	                            inWindow,
+	                            &outPart);
+	_res = Py_BuildValue("O&h",
+	                     CtlObj_New, _rv,
+	                     outPart);
+	return _res;
+}
+
+static PyObject *Ctl_IdleControls(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr inWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	IdleControls(inWindow);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Ctl_DumpControlHierarchy(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	FSSpec inDumpFile;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      WinObj_Convert, &inWindow,
+	                      PyMac_GetFSSpec, &inDumpFile))
+		return NULL;
+	_err = DumpControlHierarchy(inWindow,
+	                            &inDumpFile);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Ctl_CreateRootControl(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	ControlHandle outControl;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = CreateRootControl(inWindow,
+	                         &outControl);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_WhichControl, outControl);
+	return _res;
+}
+
+static PyObject *Ctl_GetRootControl(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	ControlHandle outControl;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = GetRootControl(inWindow,
+	                      &outControl);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_WhichControl, outControl);
+	return _res;
+}
+
+static PyObject *Ctl_GetKeyboardFocus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	ControlHandle outControl;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = GetKeyboardFocus(inWindow,
+	                        &outControl);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_WhichControl, outControl);
+	return _res;
+}
+
+static PyObject *Ctl_SetKeyboardFocus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	ControlHandle inControl;
+	ControlFocusPart inPart;
+	if (!PyArg_ParseTuple(_args, "O&O&h",
+	                      WinObj_Convert, &inWindow,
+	                      CtlObj_Convert, &inControl,
+	                      &inPart))
+		return NULL;
+	_err = SetKeyboardFocus(inWindow,
+	                        inControl,
+	                        inPart);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Ctl_AdvanceKeyboardFocus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = AdvanceKeyboardFocus(inWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Ctl_ReverseKeyboardFocus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = ReverseKeyboardFocus(inWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Ctl_ClearKeyboardFocus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	WindowPtr inWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inWindow))
+		return NULL;
+	_err = ClearKeyboardFocus(inWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyMethodDef Ctl_methods[] = {
 	{"NewControl", (PyCFunction)Ctl_NewControl, 1,
-	 "(WindowPtr theWindow, Rect boundsRect, Str255 title, Boolean visible, SInt16 value, SInt16 min, SInt16 max, SInt16 procID, SInt32 refCon) -> (ControlHandle _rv)"},
+	 "(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)"},
 	{"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1,
-	 "(SInt16 controlID, WindowPtr owner) -> (ControlHandle _rv)"},
+	 "(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)"},
 	{"DrawControls", (PyCFunction)Ctl_DrawControls, 1,
 	 "(WindowPtr theWindow) -> None"},
 	{"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1,
 	 "(WindowPtr theWindow, RgnHandle updateRegion) -> None"},
 	{"FindControl", (PyCFunction)Ctl_FindControl, 1,
-	 "(Point thePoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"},
+	 "(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"},
+	{"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1,
+	 "(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)"},
+	{"IdleControls", (PyCFunction)Ctl_IdleControls, 1,
+	 "(WindowPtr inWindow) -> None"},
+	{"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1,
+	 "(WindowPtr inWindow, FSSpec inDumpFile) -> None"},
+	{"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1,
+	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	{"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1,
+	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	{"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1,
+	 "(WindowPtr inWindow) -> (ControlHandle outControl)"},
+	{"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1,
+	 "(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None"},
+	{"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1,
+	 "(WindowPtr inWindow) -> None"},
+	{"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1,
+	 "(WindowPtr inWindow) -> None"},
+	{"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1,
+	 "(WindowPtr inWindow) -> None"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/ctl/ctlscan.py b/Mac/Modules/ctl/ctlscan.py
index 1f870c9..311295b 100644
--- a/Mac/Modules/ctl/ctlscan.py
+++ b/Mac/Modules/ctl/ctlscan.py
@@ -28,17 +28,39 @@ class MyScanner(Scanner):
 				listname = "methods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+		self.defsfile.write("from TextEdit import *\n")
+		self.defsfile.write("from QuickDraw import *\n")
+		self.defsfile.write("\n")
+
 	def makeblacklistnames(self):
 		return [
 			'DisposeControl', # Generated manually
 			'KillControls', # Implied by close of dialog
 			'SetCtlAction',
+			'kControlBevelButtonCenterPopupGlyphTag', # Constant with funny definition
+			'kControlProgressBarIndeterminateTag', # ditto
+			# The following are unavailable for static 68k (appearance manager)
+			'GetBevelButtonMenuValue',
+			'SetBevelButtonMenuValue',
+			'GetBevelButtonMenuHandle',
+			'SetBevelButtonTransform',
+			'SetBevelButtonGraphicAlignment',
+			'SetBevelButtonTextAlignment',
+			'SetBevelButtonTextPlacement',
+			'SetImageWellTransform',
+			'GetTabContentRect',
+			'SetTabEnabled',
+			'SetDisclosureTriangleLastValue',
 			]
 
 	def makeblacklisttypes(self):
 		return [
 			'ProcPtr',
 			'ControlActionUPP',
+			'ControlButtonContentInfoPtr',
+			'Ptr',
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/ctl/ctlsupport.py b/Mac/Modules/ctl/ctlsupport.py
index 50efd94..a905970 100644
--- a/Mac/Modules/ctl/ctlsupport.py
+++ b/Mac/Modules/ctl/ctlsupport.py
@@ -33,6 +33,16 @@ CCTabHandle = OpaqueByValueType("CCTabHandle", "ResObj")
 AuxCtlHandle = OpaqueByValueType("AuxCtlHandle", "ResObj")
 ControlPartCode = Type("ControlPartCode", "h")
 DragConstraint = Type("DragConstraint", "h")
+ControlVariant = Type("ControlVariant", "h")
+IconTransformType = Type("IconTransformType", "h")
+ControlButtonGraphicAlignment = Type("ControlButtonGraphicAlignment", "h")
+ControlButtonTextAlignment = Type("ControlButtonTextAlignment", "h")
+ControlButtonTextPlacement = Type("ControlButtonTextPlacement", "h")
+ControlContentType = Type("ControlContentType", "h")
+ControlFocusPart = Type("ControlFocusPart", "h")
+
+ControlFontStyleRec = OpaqueType('ControlFontStyleRec', 'ControlFontStyle')
+ControlFontStyleRec_ptr = ControlFontStyleRec
 
 includestuff = includestuff + """
 #include <%s>""" % MACHEADERFILE + """
@@ -40,10 +50,36 @@ includestuff = includestuff + """
 #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
 
 extern PyObject *CtlObj_WhichControl(ControlHandle); /* Forward */
+extern PyObject *QdRGB_New(RGBColorPtr);
+extern QdRGB_Convert(PyObject *, RGBColorPtr);
 
 #ifdef THINK_C
 #define  ControlActionUPP ProcPtr
 #endif
+
+/*
+** Parse/generate ControlFontStyleRec records
+*/
+#if 0 /* Not needed */
+PyObject *ControlFontStyle_New(itself)
+	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);
+}
+#endif
+
+ControlFontStyle_Convert(v, itself)
+	PyObject *v;
+	ControlFontStyleRec *itself;
+{
+	return PyArg_ParseTuple(v, "hhhhhhO&O&", &itself->flags,
+		&itself->font, &itself->size, &itself->style, &itself->mode, 
+		&itself->just, QdRGB_Convert, &itself->foreColor, 
+		QdRGB_Convert, &itself->backColor);
+}
 """
 
 finalstuff = finalstuff + """
diff --git a/Mac/Modules/dlg/Dlgmodule.c b/Mac/Modules/dlg/Dlgmodule.c
index 7ca2a59..75f8b28 100644
--- a/Mac/Modules/dlg/Dlgmodule.c
+++ b/Mac/Modules/dlg/Dlgmodule.c
@@ -184,61 +184,12 @@ static PyObject *DlgObj_UpdateDialog(_self, _args)
 	return _res;
 }
 
-static PyObject *DlgObj_GetDialogItem(_self, _args)
-	DialogObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	short itemNo;
-	short itemType;
-	Handle item;
-	Rect box;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &itemNo))
-		return NULL;
-	GetDialogItem(_self->ob_itself,
-	              itemNo,
-	              &itemType,
-	              &item,
-	              &box);
-	_res = Py_BuildValue("hO&O&",
-	                     itemType,
-	                     OptResObj_New, item,
-	                     PyMac_BuildRect, &box);
-	return _res;
-}
-
-static PyObject *DlgObj_SetDialogItem(_self, _args)
-	DialogObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	short itemNo;
-	short itemType;
-	Handle item;
-	Rect box;
-	if (!PyArg_ParseTuple(_args, "hhO&O&",
-	                      &itemNo,
-	                      &itemType,
-	                      ResObj_Convert, &item,
-	                      PyMac_GetRect, &box))
-		return NULL;
-	SetDialogItem(_self->ob_itself,
-	              itemNo,
-	              itemType,
-	              item,
-	              &box);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
 static PyObject *DlgObj_HideDialogItem(_self, _args)
 	DialogObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short itemNo;
+	DialogItemIndex itemNo;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &itemNo))
 		return NULL;
@@ -254,7 +205,7 @@ static PyObject *DlgObj_ShowDialogItem(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short itemNo;
+	DialogItemIndex itemNo;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &itemNo))
 		return NULL;
@@ -265,34 +216,12 @@ static PyObject *DlgObj_ShowDialogItem(_self, _args)
 	return _res;
 }
 
-static PyObject *DlgObj_SelectDialogItemText(_self, _args)
-	DialogObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	short itemNo;
-	short strtSel;
-	short endSel;
-	if (!PyArg_ParseTuple(_args, "hhh",
-	                      &itemNo,
-	                      &strtSel,
-	                      &endSel))
-		return NULL;
-	SelectDialogItemText(_self->ob_itself,
-	                     itemNo,
-	                     strtSel,
-	                     endSel);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
 static PyObject *DlgObj_FindDialogItem(_self, _args)
 	DialogObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
+	DialogItemIndexZeroBased _rv;
 	Point thePt;
 	if (!PyArg_ParseTuple(_args, "O&",
 	                      PyMac_GetPoint, &thePt))
@@ -356,6 +285,77 @@ static PyObject *DlgObj_DialogDelete(_self, _args)
 	return _res;
 }
 
+static PyObject *DlgObj_GetDialogItem(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	DialogItemIndex itemNo;
+	DialogItemType itemType;
+	Handle item;
+	Rect box;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &itemNo))
+		return NULL;
+	GetDialogItem(_self->ob_itself,
+	              itemNo,
+	              &itemType,
+	              &item,
+	              &box);
+	_res = Py_BuildValue("hO&O&",
+	                     itemType,
+	                     OptResObj_New, item,
+	                     PyMac_BuildRect, &box);
+	return _res;
+}
+
+static PyObject *DlgObj_SetDialogItem(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	DialogItemIndex itemNo;
+	DialogItemType itemType;
+	Handle item;
+	Rect box;
+	if (!PyArg_ParseTuple(_args, "hhO&O&",
+	                      &itemNo,
+	                      &itemType,
+	                      ResObj_Convert, &item,
+	                      PyMac_GetRect, &box))
+		return NULL;
+	SetDialogItem(_self->ob_itself,
+	              itemNo,
+	              itemType,
+	              item,
+	              &box);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *DlgObj_SelectDialogItemText(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	DialogItemIndex itemNo;
+	SInt16 strtSel;
+	SInt16 endSel;
+	if (!PyArg_ParseTuple(_args, "hhh",
+	                      &itemNo,
+	                      &strtSel,
+	                      &endSel))
+		return NULL;
+	SelectDialogItemText(_self->ob_itself,
+	                     itemNo,
+	                     strtSel,
+	                     endSel);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *DlgObj_AppendDITL(_self, _args)
 	DialogObject *_self;
 	PyObject *_args;
@@ -380,7 +380,7 @@ static PyObject *DlgObj_CountDITL(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
+	DialogItemIndex _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = CountDITL(_self->ob_itself);
@@ -394,7 +394,7 @@ static PyObject *DlgObj_ShortenDITL(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short numberItems;
+	DialogItemIndex numberItems;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &numberItems))
 		return NULL;
@@ -412,7 +412,7 @@ static PyObject *DlgObj_StdFilterProc(_self, _args)
 	PyObject *_res = NULL;
 	Boolean _rv;
 	EventRecord event;
-	short itemHit;
+	DialogItemIndex itemHit;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = StdFilterProc(_self->ob_itself,
@@ -431,7 +431,7 @@ static PyObject *DlgObj_SetDialogDefaultItem(_self, _args)
 {
 	PyObject *_res = NULL;
 	OSErr _err;
-	short newItem;
+	DialogItemIndex newItem;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &newItem))
 		return NULL;
@@ -449,7 +449,7 @@ static PyObject *DlgObj_SetDialogCancelItem(_self, _args)
 {
 	PyObject *_res = NULL;
 	OSErr _err;
-	short newItem;
+	DialogItemIndex newItem;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &newItem))
 		return NULL;
@@ -479,6 +479,89 @@ static PyObject *DlgObj_SetDialogTracksCursor(_self, _args)
 	return _res;
 }
 
+static PyObject *DlgObj_AutoSizeDialog(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = AutoSizeDialog(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *DlgObj_GetDialogItemAsControl(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItemNo;
+	ControlHandle outControl;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItemNo))
+		return NULL;
+	_err = GetDialogItemAsControl(_self->ob_itself,
+	                              inItemNo,
+	                              &outControl);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CtlObj_New, outControl);
+	return _res;
+}
+
+static PyObject *DlgObj_MoveDialogItem(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItemNo;
+	SInt16 inHoriz;
+	SInt16 inVert;
+	if (!PyArg_ParseTuple(_args, "hhh",
+	                      &inItemNo,
+	                      &inHoriz,
+	                      &inVert))
+		return NULL;
+	_err = MoveDialogItem(_self->ob_itself,
+	                      inItemNo,
+	                      inHoriz,
+	                      inVert);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *DlgObj_SizeDialogItem(_self, _args)
+	DialogObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItemNo;
+	SInt16 inHeight;
+	SInt16 inWidth;
+	if (!PyArg_ParseTuple(_args, "hhh",
+	                      &inItemNo,
+	                      &inHeight,
+	                      &inWidth))
+		return NULL;
+	_err = SizeDialogItem(_self->ob_itself,
+	                      inItemNo,
+	                      inHeight,
+	                      inWidth);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *DlgObj_GetDialogWindow(_self, _args)
 	DialogObject *_self;
 	PyObject *_args;
@@ -553,18 +636,12 @@ static PyMethodDef DlgObj_methods[] = {
 	 "() -> None"},
 	{"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
 	 "(RgnHandle updateRgn) -> None"},
-	{"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
-	 "(short itemNo) -> (short itemType, Handle item, Rect box)"},
-	{"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
-	 "(short itemNo, short itemType, Handle item, Rect box) -> None"},
 	{"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1,
-	 "(short itemNo) -> None"},
+	 "(DialogItemIndex itemNo) -> None"},
 	{"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1,
-	 "(short itemNo) -> None"},
-	{"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
-	 "(short itemNo, short strtSel, short endSel) -> None"},
+	 "(DialogItemIndex itemNo) -> None"},
 	{"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1,
-	 "(Point thePt) -> (short _rv)"},
+	 "(Point thePt) -> (DialogItemIndexZeroBased _rv)"},
 	{"DialogCut", (PyCFunction)DlgObj_DialogCut, 1,
 	 "() -> None"},
 	{"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1,
@@ -573,20 +650,34 @@ static PyMethodDef DlgObj_methods[] = {
 	 "() -> None"},
 	{"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1,
 	 "() -> None"},
+	{"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
+	 "(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)"},
+	{"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
+	 "(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None"},
+	{"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
+	 "(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None"},
 	{"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
 	 "(Handle theHandle, DITLMethod method) -> None"},
 	{"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
-	 "() -> (short _rv)"},
+	 "() -> (DialogItemIndex _rv)"},
 	{"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
-	 "(short numberItems) -> None"},
+	 "(DialogItemIndex numberItems) -> None"},
 	{"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1,
-	 "() -> (Boolean _rv, EventRecord event, short itemHit)"},
+	 "() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"},
 	{"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1,
-	 "(short newItem) -> None"},
+	 "(DialogItemIndex newItem) -> None"},
 	{"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1,
-	 "(short newItem) -> None"},
+	 "(DialogItemIndex newItem) -> None"},
 	{"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1,
 	 "(Boolean tracks) -> None"},
+	{"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1,
+	 "() -> None"},
+	{"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1,
+	 "(SInt16 inItemNo) -> (ControlHandle outControl)"},
+	{"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1,
+	 "(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None"},
+	{"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1,
+	 "(SInt16 inItemNo, SInt16 inHeight, SInt16 inWidth) -> None"},
 	{"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1,
 	 "() -> (DialogPtr _rv)"},
 	{"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1,
@@ -636,11 +727,11 @@ static PyObject *Dlg_NewDialog(_self, _args)
 	Rect boundsRect;
 	Str255 title;
 	Boolean visible;
-	short procID;
+	SInt16 procID;
 	WindowPtr behind;
 	Boolean goAwayFlag;
-	long refCon;
-	Handle itmLstHndl;
+	SInt32 refCon;
+	Handle items;
 	if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
 	                      PyMac_GetRect, &boundsRect,
 	                      PyMac_GetStr255, title,
@@ -649,7 +740,7 @@ static PyObject *Dlg_NewDialog(_self, _args)
 	                      WinObj_Convert, &behind,
 	                      &goAwayFlag,
 	                      &refCon,
-	                      ResObj_Convert, &itmLstHndl))
+	                      ResObj_Convert, &items))
 		return NULL;
 	_rv = NewDialog((void *)0,
 	                &boundsRect,
@@ -659,7 +750,7 @@ static PyObject *Dlg_NewDialog(_self, _args)
 	                behind,
 	                goAwayFlag,
 	                refCon,
-	                itmLstHndl);
+	                items);
 	_res = Py_BuildValue("O&",
 	                     DlgObj_New, _rv);
 	return _res;
@@ -671,7 +762,7 @@ static PyObject *Dlg_GetNewDialog(_self, _args)
 {
 	PyObject *_res = NULL;
 	DialogPtr _rv;
-	short dialogID;
+	SInt16 dialogID;
 	WindowPtr behind;
 	if (!PyArg_ParseTuple(_args, "hO&",
 	                      &dialogID,
@@ -685,27 +776,41 @@ static PyObject *Dlg_GetNewDialog(_self, _args)
 	return _res;
 }
 
-static PyObject *Dlg_ParamText(_self, _args)
+static PyObject *Dlg_NewColorDialog(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Str255 param0;
-	Str255 param1;
-	Str255 param2;
-	Str255 param3;
-	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
-	                      PyMac_GetStr255, param0,
-	                      PyMac_GetStr255, param1,
-	                      PyMac_GetStr255, param2,
-	                      PyMac_GetStr255, param3))
+	DialogPtr _rv;
+	Rect boundsRect;
+	Str255 title;
+	Boolean visible;
+	SInt16 procID;
+	WindowPtr behind;
+	Boolean goAwayFlag;
+	SInt32 refCon;
+	Handle items;
+	if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
+	                      PyMac_GetRect, &boundsRect,
+	                      PyMac_GetStr255, title,
+	                      &visible,
+	                      &procID,
+	                      WinObj_Convert, &behind,
+	                      &goAwayFlag,
+	                      &refCon,
+	                      ResObj_Convert, &items))
 		return NULL;
-	ParamText(param0,
-	          param1,
-	          param2,
-	          param3);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = NewColorDialog((void *)0,
+	                     &boundsRect,
+	                     title,
+	                     visible,
+	                     procID,
+	                     behind,
+	                     goAwayFlag,
+	                     refCon,
+	                     items);
+	_res = Py_BuildValue("O&",
+	                     DlgObj_New, _rv);
 	return _res;
 }
 
@@ -715,7 +820,7 @@ static PyObject *Dlg_ModalDialog(_self, _args)
 {
 	PyObject *_res = NULL;
 	PyObject* modalFilter;
-	short itemHit;
+	DialogItemIndex itemHit;
 	if (!PyArg_ParseTuple(_args, "O",
 	                      &modalFilter))
 		return NULL;
@@ -750,7 +855,7 @@ static PyObject *Dlg_DialogSelect(_self, _args)
 	Boolean _rv;
 	EventRecord theEvent;
 	DialogPtr theDialog;
-	short itemHit;
+	DialogItemIndex itemHit;
 	if (!PyArg_ParseTuple(_args, "O&",
 	                      PyMac_GetEventRecord, &theEvent))
 		return NULL;
@@ -769,8 +874,8 @@ static PyObject *Dlg_Alert(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	short alertID;
+	DialogItemIndex _rv;
+	SInt16 alertID;
 	PyObject* modalFilter;
 	if (!PyArg_ParseTuple(_args, "hO",
 	                      &alertID,
@@ -788,8 +893,8 @@ static PyObject *Dlg_StopAlert(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	short alertID;
+	DialogItemIndex _rv;
+	SInt16 alertID;
 	PyObject* modalFilter;
 	if (!PyArg_ParseTuple(_args, "hO",
 	                      &alertID,
@@ -807,8 +912,8 @@ static PyObject *Dlg_NoteAlert(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	short alertID;
+	DialogItemIndex _rv;
+	SInt16 alertID;
 	PyObject* modalFilter;
 	if (!PyArg_ParseTuple(_args, "hO",
 	                      &alertID,
@@ -826,8 +931,8 @@ static PyObject *Dlg_CautionAlert(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	short alertID;
+	DialogItemIndex _rv;
+	SInt16 alertID;
 	PyObject* modalFilter;
 	if (!PyArg_ParseTuple(_args, "hO",
 	                      &alertID,
@@ -840,6 +945,30 @@ static PyObject *Dlg_CautionAlert(_self, _args)
 	return _res;
 }
 
+static PyObject *Dlg_ParamText(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Str255 param0;
+	Str255 param1;
+	Str255 param2;
+	Str255 param3;
+	if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+	                      PyMac_GetStr255, param0,
+	                      PyMac_GetStr255, param1,
+	                      PyMac_GetStr255, param2,
+	                      PyMac_GetStr255, param3))
+		return NULL;
+	ParamText(param0,
+	          param1,
+	          param2,
+	          param3);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *Dlg_GetDialogItemText(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -875,55 +1004,32 @@ static PyObject *Dlg_SetDialogItemText(_self, _args)
 	return _res;
 }
 
-static PyObject *Dlg_NewColorDialog(_self, _args)
+static PyObject *Dlg_GetAlertStage(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	DialogPtr _rv;
-	Rect boundsRect;
-	Str255 title;
-	Boolean visible;
-	short procID;
-	WindowPtr behind;
-	Boolean goAwayFlag;
-	long refCon;
-	Handle items;
-	if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
-	                      PyMac_GetRect, &boundsRect,
-	                      PyMac_GetStr255, title,
-	                      &visible,
-	                      &procID,
-	                      WinObj_Convert, &behind,
-	                      &goAwayFlag,
-	                      &refCon,
-	                      ResObj_Convert, &items))
+	SInt16 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = NewColorDialog((void *)0,
-	                     &boundsRect,
-	                     title,
-	                     visible,
-	                     procID,
-	                     behind,
-	                     goAwayFlag,
-	                     refCon,
-	                     items);
-	_res = Py_BuildValue("O&",
-	                     DlgObj_New, _rv);
+	_rv = GetAlertStage();
+	_res = Py_BuildValue("h",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Dlg_GetAlertStage(_self, _args)
+static PyObject *Dlg_SetDialogFont(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	if (!PyArg_ParseTuple(_args, ""))
+	SInt16 value;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &value))
 		return NULL;
-	_rv = GetAlertStage();
-	_res = Py_BuildValue("h",
-	                     _rv);
+	SetDialogFont(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
@@ -940,54 +1046,82 @@ static PyObject *Dlg_ResetAlertStage(_self, _args)
 	return _res;
 }
 
-static PyObject *Dlg_SetDialogFont(_self, _args)
+static PyObject *Dlg_NewFeaturesDialog(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short value;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &value))
+	DialogPtr _rv;
+	Rect inBoundsRect;
+	Str255 inTitle;
+	Boolean inIsVisible;
+	SInt16 inProcID;
+	WindowPtr inBehind;
+	Boolean inGoAwayFlag;
+	SInt32 inRefCon;
+	Handle inItemListHandle;
+	UInt32 inFlags;
+	if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&l",
+	                      PyMac_GetRect, &inBoundsRect,
+	                      PyMac_GetStr255, inTitle,
+	                      &inIsVisible,
+	                      &inProcID,
+	                      WinObj_Convert, &inBehind,
+	                      &inGoAwayFlag,
+	                      &inRefCon,
+	                      ResObj_Convert, &inItemListHandle,
+	                      &inFlags))
 		return NULL;
-	SetDialogFont(value);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = NewFeaturesDialog((void *)0,
+	                        &inBoundsRect,
+	                        inTitle,
+	                        inIsVisible,
+	                        inProcID,
+	                        inBehind,
+	                        inGoAwayFlag,
+	                        inRefCon,
+	                        inItemListHandle,
+	                        inFlags);
+	_res = Py_BuildValue("O&",
+	                     DlgObj_New, _rv);
 	return _res;
 }
 
 static PyMethodDef Dlg_methods[] = {
 	{"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle itmLstHndl) -> (DialogPtr _rv)"},
+	 "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
 	{"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
-	 "(short dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
-	{"ParamText", (PyCFunction)Dlg_ParamText, 1,
-	 "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+	 "(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
+	{"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
+	 "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
 	{"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
-	 "(PyObject* modalFilter) -> (short itemHit)"},
+	 "(PyObject* modalFilter) -> (DialogItemIndex itemHit)"},
 	{"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
 	 "(EventRecord theEvent) -> (Boolean _rv)"},
 	{"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
-	 "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, short itemHit)"},
+	 "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)"},
 	{"Alert", (PyCFunction)Dlg_Alert, 1,
-	 "(short alertID, PyObject* modalFilter) -> (short _rv)"},
+	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
 	{"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
-	 "(short alertID, PyObject* modalFilter) -> (short _rv)"},
+	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
 	{"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
-	 "(short alertID, PyObject* modalFilter) -> (short _rv)"},
+	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
 	{"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
-	 "(short alertID, PyObject* modalFilter) -> (short _rv)"},
+	 "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
+	{"ParamText", (PyCFunction)Dlg_ParamText, 1,
+	 "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
 	{"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1,
 	 "(Handle item) -> (Str255 text)"},
 	{"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1,
 	 "(Handle item, Str255 text) -> None"},
-	{"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle items) -> (DialogPtr _rv)"},
 	{"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1,
-	 "() -> (short _rv)"},
+	 "() -> (SInt16 _rv)"},
+	{"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
+	 "(SInt16 value) -> None"},
 	{"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1,
 	 "() -> None"},
-	{"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
-	 "(short value) -> None"},
+	{"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1,
+	 "(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/dlg/dlgscan.py b/Mac/Modules/dlg/dlgscan.py
index 31c88dd..d51a2d1 100644
--- a/Mac/Modules/dlg/dlgscan.py
+++ b/Mac/Modules/dlg/dlgscan.py
@@ -51,6 +51,7 @@ class MyScanner(Scanner):
 
 	def makeblacklisttypes(self):
 		return [
+			"AlertStdAlertParamPtr",	# Too much work, for now
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/dlg/dlgsupport.py b/Mac/Modules/dlg/dlgsupport.py
index 14bef36..b8531ca 100644
--- a/Mac/Modules/dlg/dlgsupport.py
+++ b/Mac/Modules/dlg/dlgsupport.py
@@ -24,6 +24,11 @@ ModalFilterUPP = ModalFilterProcPtr
 RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
 
 DITLMethod = Type("DITLMethod", "h")
+DialogItemIndex = Type("DialogItemIndex", "h")
+DialogItemType = Type("DialogItemType", "h")
+DialogItemIndexZeroBased = Type("DialogItemIndexZeroBased", "h")
+AlertType = Type("AlertType", "h")
+StringPtr = Str255
 
 includestuff = includestuff + """
 #include <Dialogs.h>
diff --git a/Mac/Modules/evt/Evtmodule.c b/Mac/Modules/evt/Evtmodule.c
index b5bc573..edd8bc7 100644
--- a/Mac/Modules/evt/Evtmodule.c
+++ b/Mac/Modules/evt/Evtmodule.c
@@ -48,192 +48,192 @@ extern PyObject *WinObj_WhichWindow(WindowPtr);
 
 static PyObject *Evt_Error;
 
-static PyObject *Evt_GetCaretTime(_self, _args)
+static PyObject *Evt_GetMouse(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	UInt32 _rv;
+	Point mouseLoc;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = GetCaretTime();
-	_res = Py_BuildValue("l",
-	                     _rv);
+	GetMouse(&mouseLoc);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, mouseLoc);
 	return _res;
 }
 
-static PyObject *Evt_SetEventMask(_self, _args)
+static PyObject *Evt_Button(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	EventMask value;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &value))
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	SetEventMask(value);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = Button();
+	_res = Py_BuildValue("b",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_GetDblTime(_self, _args)
+static PyObject *Evt_StillDown(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	UInt32 _rv;
+	Boolean _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = GetDblTime();
-	_res = Py_BuildValue("l",
+	_rv = StillDown();
+	_res = Py_BuildValue("b",
 	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_GetNextEvent(_self, _args)
+static PyObject *Evt_WaitMouseUp(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	Boolean _rv;
-	EventMask eventMask;
-	EventRecord theEvent;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &eventMask))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = GetNextEvent(eventMask,
-	                   &theEvent);
-	_res = Py_BuildValue("bO&",
-	                     _rv,
-	                     PyMac_BuildEventRecord, &theEvent);
+	_rv = WaitMouseUp();
+	_res = Py_BuildValue("b",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_WaitNextEvent(_self, _args)
+static PyObject *Evt_TickCount(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
-	EventMask eventMask;
-	EventRecord theEvent;
-	UInt32 sleep;
-	if (!PyArg_ParseTuple(_args, "hl",
-	                      &eventMask,
-	                      &sleep))
+	UInt32 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = WaitNextEvent(eventMask,
-	                    &theEvent,
-	                    sleep,
-	                    (RgnHandle)0);
-	_res = Py_BuildValue("bO&",
-	                     _rv,
-	                     PyMac_BuildEventRecord, &theEvent);
+	_rv = TickCount();
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_EventAvail(_self, _args)
+static PyObject *Evt_GetCaretTime(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
-	EventMask eventMask;
-	EventRecord theEvent;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &eventMask))
+	UInt32 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = EventAvail(eventMask,
-	                 &theEvent);
-	_res = Py_BuildValue("bO&",
-	                     _rv,
-	                     PyMac_BuildEventRecord, &theEvent);
+	_rv = GetCaretTime();
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_GetMouse(_self, _args)
+static PyObject *Evt_GetKeys(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Point mouseLoc;
+	KeyMap theKeys__out__;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	GetMouse(&mouseLoc);
-	_res = Py_BuildValue("O&",
-	                     PyMac_BuildPoint, mouseLoc);
+	GetKeys(theKeys__out__);
+	_res = Py_BuildValue("s#",
+	                     (char *)&theKeys__out__, (int)sizeof(KeyMap));
+ theKeys__error__: ;
 	return _res;
 }
 
-static PyObject *Evt_Button(_self, _args)
+static PyObject *Evt_GetDblTime(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
+	UInt32 _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = Button();
-	_res = Py_BuildValue("b",
+	_rv = GetDblTime();
+	_res = Py_BuildValue("l",
 	                     _rv);
 	return _res;
 }
 
-static PyObject *Evt_StillDown(_self, _args)
+static PyObject *Evt_SetEventMask(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
-	if (!PyArg_ParseTuple(_args, ""))
+	EventMask value;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &value))
 		return NULL;
-	_rv = StillDown();
-	_res = Py_BuildValue("b",
-	                     _rv);
+	SetEventMask(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Evt_WaitMouseUp(_self, _args)
+static PyObject *Evt_GetNextEvent(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	Boolean _rv;
-	if (!PyArg_ParseTuple(_args, ""))
+	EventMask eventMask;
+	EventRecord theEvent;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &eventMask))
 		return NULL;
-	_rv = WaitMouseUp();
-	_res = Py_BuildValue("b",
-	                     _rv);
+	_rv = GetNextEvent(eventMask,
+	                   &theEvent);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &theEvent);
 	return _res;
 }
 
-static PyObject *Evt_GetKeys(_self, _args)
+static PyObject *Evt_WaitNextEvent(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	KeyMap theKeys__out__;
-	if (!PyArg_ParseTuple(_args, ""))
+	Boolean _rv;
+	EventMask eventMask;
+	EventRecord theEvent;
+	UInt32 sleep;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &eventMask,
+	                      &sleep))
 		return NULL;
-	GetKeys(theKeys__out__);
-	_res = Py_BuildValue("s#",
-	                     (char *)&theKeys__out__, (int)sizeof(KeyMap));
- theKeys__error__: ;
+	_rv = WaitNextEvent(eventMask,
+	                    &theEvent,
+	                    sleep,
+	                    (RgnHandle)0);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &theEvent);
 	return _res;
 }
 
-static PyObject *Evt_TickCount(_self, _args)
+static PyObject *Evt_EventAvail(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	UInt32 _rv;
-	if (!PyArg_ParseTuple(_args, ""))
+	Boolean _rv;
+	EventMask eventMask;
+	EventRecord theEvent;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &eventMask))
 		return NULL;
-	_rv = TickCount();
-	_res = Py_BuildValue("l",
-	                     _rv);
+	_rv = EventAvail(eventMask,
+	                 &theEvent);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &theEvent);
 	return _res;
 }
 
@@ -361,18 +361,6 @@ static PyObject *Evt_SystemEvent(_self, _args)
 }
 
 static PyMethodDef Evt_methods[] = {
-	{"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
-	 "() -> (UInt32 _rv)"},
-	{"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
-	 "(EventMask value) -> None"},
-	{"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
-	 "() -> (UInt32 _rv)"},
-	{"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
-	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
-	{"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
-	 "(EventMask eventMask, UInt32 sleep) -> (Boolean _rv, EventRecord theEvent)"},
-	{"EventAvail", (PyCFunction)Evt_EventAvail, 1,
-	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
 	{"GetMouse", (PyCFunction)Evt_GetMouse, 1,
 	 "() -> (Point mouseLoc)"},
 	{"Button", (PyCFunction)Evt_Button, 1,
@@ -381,10 +369,22 @@ static PyMethodDef Evt_methods[] = {
 	 "() -> (Boolean _rv)"},
 	{"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
 	 "() -> (Boolean _rv)"},
+	{"TickCount", (PyCFunction)Evt_TickCount, 1,
+	 "() -> (UInt32 _rv)"},
+	{"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
+	 "() -> (UInt32 _rv)"},
 	{"GetKeys", (PyCFunction)Evt_GetKeys, 1,
 	 "() -> (KeyMap theKeys)"},
-	{"TickCount", (PyCFunction)Evt_TickCount, 1,
+	{"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
 	 "() -> (UInt32 _rv)"},
+	{"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
+	 "(EventMask value) -> None"},
+	{"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
+	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+	{"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
+	 "(EventMask eventMask, UInt32 sleep) -> (Boolean _rv, EventRecord theEvent)"},
+	{"EventAvail", (PyCFunction)Evt_EventAvail, 1,
+	 "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
 	{"PostEvent", (PyCFunction)Evt_PostEvent, 1,
 	 "(EventKind eventNum, UInt32 eventMsg) -> None"},
 	{"OSEventAvail", (PyCFunction)Evt_OSEventAvail, 1,
diff --git a/Mac/Modules/fm/fmscan.py b/Mac/Modules/fm/fmscan.py
index 1a5d6a8..3f0e51b 100644
--- a/Mac/Modules/fm/fmscan.py
+++ b/Mac/Modules/fm/fmscan.py
@@ -6,7 +6,7 @@ from scantools import Scanner
 from bgenlocations import TOOLBOXDIR
 
 LONG = "Fonts"
-SHORT = "Fm"
+SHORT = "fm"
 
 def main():
 	input = "Fonts.h"
@@ -29,6 +29,11 @@ class MyScanner(Scanner):
 	def makeblacklistnames(self):
 		return [
 			"OutlineMetrics",	# Too complicated
+			"AntiTextIsAntiAliased",	# XXXX Missing from library...
+			"AntiTextGetEnabled",
+			"AntiTextSetEnabled",
+			"AntiTextGetApplicationAware",
+			"AntiTextSetApplicationAware",
 			]
 
 	def makeblacklisttypes(self):
diff --git a/Mac/Modules/help/Helpmodule.c b/Mac/Modules/help/Helpmodule.c
index e6cb0a2..9f5c6c4 100644
--- a/Mac/Modules/help/Helpmodule.c
+++ b/Mac/Modules/help/Helpmodule.c
@@ -54,7 +54,7 @@ static PyObject *Help_HMGetHelpMenuHandle(_self, _args)
 {
 	PyObject *_res = NULL;
 	OSErr _err;
-	MenuRef mh;
+	MenuHandle mh;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_err = HMGetHelpMenuHandle(&mh);
@@ -79,6 +79,20 @@ static PyObject *Help_HMRemoveBalloon(_self, _args)
 	return _res;
 }
 
+static PyObject *Help_HMIsBalloon(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = HMIsBalloon();
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
 static PyObject *Help_HMGetBalloons(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -110,20 +124,6 @@ static PyObject *Help_HMSetBalloons(_self, _args)
 	return _res;
 }
 
-static PyObject *Help_HMIsBalloon(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	Boolean _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = HMIsBalloon();
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
-}
-
 static PyObject *Help_HMSetFont(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -303,15 +303,15 @@ static PyObject *Help_HMGetBalloonWindow(_self, _args)
 
 static PyMethodDef Help_methods[] = {
 	{"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1,
-	 "() -> (MenuRef mh)"},
+	 "() -> (MenuHandle mh)"},
 	{"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1,
 	 "() -> None"},
+	{"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
+	 "() -> (Boolean _rv)"},
 	{"HMGetBalloons", (PyCFunction)Help_HMGetBalloons, 1,
 	 "() -> (Boolean _rv)"},
 	{"HMSetBalloons", (PyCFunction)Help_HMSetBalloons, 1,
 	 "(Boolean flag) -> None"},
-	{"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
-	 "() -> (Boolean _rv)"},
 	{"HMSetFont", (PyCFunction)Help_HMSetFont, 1,
 	 "(SInt16 font) -> None"},
 	{"HMSetFontSize", (PyCFunction)Help_HMSetFontSize, 1,
diff --git a/Mac/Modules/help/helpscan.py b/Mac/Modules/help/helpscan.py
index ddc83b7..3b1db65 100644
--- a/Mac/Modules/help/helpscan.py
+++ b/Mac/Modules/help/helpscan.py
@@ -33,6 +33,9 @@ class MyScanner(Scanner):
 				listname = "methods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
 	def makeblacklistnames(self):
 		return [
 			]
diff --git a/Mac/Modules/list/Listmodule.c b/Mac/Modules/list/Listmodule.c
index e0eace9..9b09341 100644
--- a/Mac/Modules/list/Listmodule.c
+++ b/Mac/Modules/list/Listmodule.c
@@ -54,11 +54,11 @@ PyTypeObject List_Type;
 
 typedef struct ListObject {
 	PyObject_HEAD
-	ListRef ob_itself;
+	ListHandle ob_itself;
 } ListObject;
 
 PyObject *ListObj_New(itself)
-	ListRef itself;
+	ListHandle itself;
 {
 	ListObject *it;
 	if (itself == NULL) {
@@ -72,7 +72,7 @@ PyObject *ListObj_New(itself)
 }
 ListObj_Convert(v, p_itself)
 	PyObject *v;
-	ListRef *p_itself;
+	ListHandle *p_itself;
 {
 	if (!ListObj_Check(v))
 	{
@@ -615,7 +615,7 @@ static PyObject *List_LNew(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	ListRef _rv;
+	ListHandle _rv;
 	Rect rView;
 	Rect dataBounds;
 	Point cSize;
@@ -652,7 +652,7 @@ static PyObject *List_LNew(_self, _args)
 
 static PyMethodDef List_methods[] = {
 	{"LNew", (PyCFunction)List_LNew, 1,
-	 "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListRef _rv)"},
+	 "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/list/listscan.py b/Mac/Modules/list/listscan.py
index ea11ba4..dbaed68 100644
--- a/Mac/Modules/list/listscan.py
+++ b/Mac/Modules/list/listscan.py
@@ -7,7 +7,7 @@ from bgenlocations import TOOLBOXDIR
 
 LONG = "Lists"
 SHORT = "list"
-OBJECT = "ListRef"
+OBJECT = "ListHandle"
 
 def main():
 	input = LONG + ".h"
diff --git a/Mac/Modules/list/listsupport.py b/Mac/Modules/list/listsupport.py
index 026953c..686875d 100644
--- a/Mac/Modules/list/listsupport.py
+++ b/Mac/Modules/list/listsupport.py
@@ -13,7 +13,7 @@ KIND = 'Handle'				# Usually 'Ptr' or 'Handle'
 
 # The following is *usually* unchanged but may still require tuning
 MODPREFIX = MODNAME			# The prefix for module-wide routines
-OBJECTTYPE = "ListRef"		# The C type used to represent them
+OBJECTTYPE = "ListHandle"		# 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
@@ -21,7 +21,7 @@ OUTPUTFILE = MODNAME + "module.c"	# The file generated by this program
 from macsupport import *
 
 # Create the type objects
-ListRef = OpaqueByValueType("ListRef", "ListObj")
+ListHandle = OpaqueByValueType("ListHandle", "ListObj")
 Cell = Point
 VarOutBufferShortsize = VarHeapOutputBufferType('char', 'short', 's')	# (buf, &len)
 InBufferShortsize = VarInputBufferType('char', 'short', 's')		# (buf, len)
diff --git a/Mac/Modules/menu/Menumodule.c b/Mac/Modules/menu/Menumodule.c
index b09d47d..ee3becb 100644
--- a/Mac/Modules/menu/Menumodule.c
+++ b/Mac/Modules/menu/Menumodule.c
@@ -118,22 +118,6 @@ static PyObject *MenuObj_AppendMenu(_self, _args)
 	return _res;
 }
 
-static PyObject *MenuObj_AppendResMenu(_self, _args)
-	MenuObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	ResType theType;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetOSType, &theType))
-		return NULL;
-	AppendResMenu(_self->ob_itself,
-	              theType);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
 static PyObject *MenuObj_InsertResMenu(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
@@ -169,6 +153,22 @@ static PyObject *MenuObj_InsertMenu(_self, _args)
 	return _res;
 }
 
+static PyObject *MenuObj_AppendResMenu(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	ResType theType;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetOSType, &theType))
+		return NULL;
+	AppendResMenu(_self->ob_itself,
+	              theType);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *MenuObj_InsertMenuItem(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
@@ -241,91 +241,77 @@ static PyObject *MenuObj_GetMenuItemText(_self, _args)
 	return _res;
 }
 
-static PyObject *MenuObj_DisableItem(_self, _args)
+static PyObject *MenuObj_SetItemMark(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &item))
+	CharParameter markChar;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &item,
+	                      &markChar))
 		return NULL;
-	DisableItem(_self->ob_itself,
-	            item);
+	SetItemMark(_self->ob_itself,
+	            item,
+	            markChar);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *MenuObj_EnableItem(_self, _args)
+static PyObject *MenuObj_GetItemMark(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
+	CharParameter markChar;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &item))
 		return NULL;
-	EnableItem(_self->ob_itself,
-	           item);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *MenuObj_CheckItem(_self, _args)
-	MenuObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	short item;
-	Boolean checked;
-	if (!PyArg_ParseTuple(_args, "hb",
-	                      &item,
-	                      &checked))
-		return NULL;
-	CheckItem(_self->ob_itself,
-	          item,
-	          checked);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	GetItemMark(_self->ob_itself,
+	            item,
+	            &markChar);
+	_res = Py_BuildValue("h",
+	                     markChar);
 	return _res;
 }
 
-static PyObject *MenuObj_SetItemMark(_self, _args)
+static PyObject *MenuObj_SetItemCmd(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
-	short markChar;
+	CharParameter cmdChar;
 	if (!PyArg_ParseTuple(_args, "hh",
 	                      &item,
-	                      &markChar))
+	                      &cmdChar))
 		return NULL;
-	SetItemMark(_self->ob_itself,
-	            item,
-	            markChar);
+	SetItemCmd(_self->ob_itself,
+	           item,
+	           cmdChar);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *MenuObj_GetItemMark(_self, _args)
+static PyObject *MenuObj_GetItemCmd(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
-	short markChar;
+	CharParameter cmdChar;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &item))
 		return NULL;
-	GetItemMark(_self->ob_itself,
-	            item,
-	            &markChar);
+	GetItemCmd(_self->ob_itself,
+	           item,
+	           &cmdChar);
 	_res = Py_BuildValue("h",
-	                     markChar);
+	                     cmdChar);
 	return _res;
 }
 
@@ -372,7 +358,7 @@ static PyObject *MenuObj_SetItemStyle(_self, _args)
 {
 	PyObject *_res = NULL;
 	short item;
-	short chStyle;
+	Style chStyle;
 	if (!PyArg_ParseTuple(_args, "hh",
 	                      &item,
 	                      &chStyle))
@@ -416,52 +402,33 @@ static PyObject *MenuObj_CalcMenuSize(_self, _args)
 	return _res;
 }
 
-static PyObject *MenuObj_CountMItems(_self, _args)
-	MenuObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	short _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = CountMItems(_self->ob_itself);
-	_res = Py_BuildValue("h",
-	                     _rv);
-	return _res;
-}
-
-static PyObject *MenuObj_GetItemCmd(_self, _args)
+static PyObject *MenuObj_DisableItem(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
-	short cmdChar;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &item))
 		return NULL;
-	GetItemCmd(_self->ob_itself,
-	           item,
-	           &cmdChar);
-	_res = Py_BuildValue("h",
-	                     cmdChar);
+	DisableItem(_self->ob_itself,
+	            item);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *MenuObj_SetItemCmd(_self, _args)
+static PyObject *MenuObj_EnableItem(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	short item;
-	short cmdChar;
-	if (!PyArg_ParseTuple(_args, "hh",
-	                      &item,
-	                      &cmdChar))
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &item))
 		return NULL;
-	SetItemCmd(_self->ob_itself,
-	           item,
-	           cmdChar);
+	EnableItem(_self->ob_itself,
+	           item);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
@@ -490,6 +457,39 @@ static PyObject *MenuObj_PopUpMenuSelect(_self, _args)
 	return _res;
 }
 
+static PyObject *MenuObj_CheckItem(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short item;
+	Boolean checked;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &item,
+	                      &checked))
+		return NULL;
+	CheckItem(_self->ob_itself,
+	          item,
+	          checked);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_CountMItems(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = CountMItems(_self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
 static PyObject *MenuObj_InsertFontResMenu(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
@@ -531,6 +531,381 @@ static PyObject *MenuObj_InsertIntlResMenu(_self, _args)
 	return _res;
 }
 
+static PyObject *MenuObj_SetMenuItemCommandID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 inCommandID;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &inItem,
+	                      &inCommandID))
+		return NULL;
+	_err = SetMenuItemCommandID(_self->ob_itself,
+	                            inItem,
+	                            inCommandID);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemCommandID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 outCommandID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemCommandID(_self->ob_itself,
+	                            inItem,
+	                            &outCommandID);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outCommandID);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemModifiers(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt8 inModifiers;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &inItem,
+	                      &inModifiers))
+		return NULL;
+	_err = SetMenuItemModifiers(_self->ob_itself,
+	                            inItem,
+	                            inModifiers);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemModifiers(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt8 outModifiers;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemModifiers(_self->ob_itself,
+	                            inItem,
+	                            &outModifiers);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("b",
+	                     outModifiers);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemIconHandle(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt8 inIconType;
+	Handle inIconHandle;
+	if (!PyArg_ParseTuple(_args, "hbO&",
+	                      &inItem,
+	                      &inIconType,
+	                      ResObj_Convert, &inIconHandle))
+		return NULL;
+	_err = SetMenuItemIconHandle(_self->ob_itself,
+	                             inItem,
+	                             inIconType,
+	                             inIconHandle);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemIconHandle(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt8 outIconType;
+	Handle outIconHandle;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemIconHandle(_self->ob_itself,
+	                             inItem,
+	                             &outIconType,
+	                             &outIconHandle);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("bO&",
+	                     outIconType,
+	                     ResObj_New, outIconHandle);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemTextEncoding(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	TextEncoding inScriptID;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &inItem,
+	                      &inScriptID))
+		return NULL;
+	_err = SetMenuItemTextEncoding(_self->ob_itself,
+	                               inItem,
+	                               inScriptID);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemTextEncoding(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	TextEncoding outScriptID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemTextEncoding(_self->ob_itself,
+	                               inItem,
+	                               &outScriptID);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outScriptID);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemHierarchicalID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 inHierID;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &inItem,
+	                      &inHierID))
+		return NULL;
+	_err = SetMenuItemHierarchicalID(_self->ob_itself,
+	                                 inItem,
+	                                 inHierID);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemHierarchicalID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 outHierID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemHierarchicalID(_self->ob_itself,
+	                                 inItem,
+	                                 &outHierID);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("h",
+	                     outHierID);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemFontID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 inFontID;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &inItem,
+	                      &inFontID))
+		return NULL;
+	_err = SetMenuItemFontID(_self->ob_itself,
+	                         inItem,
+	                         inFontID);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemFontID(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 outFontID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemFontID(_self->ob_itself,
+	                         inItem,
+	                         &outFontID);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("h",
+	                     outFontID);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemRefCon(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 inRefCon;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &inItem,
+	                      &inRefCon))
+		return NULL;
+	_err = SetMenuItemRefCon(_self->ob_itself,
+	                         inItem,
+	                         inRefCon);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemRefCon(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 outRefCon;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemRefCon(_self->ob_itself,
+	                         inItem,
+	                         &outRefCon);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outRefCon);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemRefCon2(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 inRefCon2;
+	if (!PyArg_ParseTuple(_args, "hl",
+	                      &inItem,
+	                      &inRefCon2))
+		return NULL;
+	_err = SetMenuItemRefCon2(_self->ob_itself,
+	                          inItem,
+	                          inRefCon2);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemRefCon2(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	UInt32 outRefCon2;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemRefCon2(_self->ob_itself,
+	                          inItem,
+	                          &outRefCon2);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     outRefCon2);
+	return _res;
+}
+
+static PyObject *MenuObj_SetMenuItemKeyGlyph(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 inGlyph;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &inItem,
+	                      &inGlyph))
+		return NULL;
+	_err = SetMenuItemKeyGlyph(_self->ob_itself,
+	                           inItem,
+	                           inGlyph);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *MenuObj_GetMenuItemKeyGlyph(_self, _args)
+	MenuObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	SInt16 inItem;
+	SInt16 outGlyph;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &inItem))
+		return NULL;
+	_err = GetMenuItemKeyGlyph(_self->ob_itself,
+	                           inItem,
+	                           &outGlyph);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("h",
+	                     outGlyph);
+	return _res;
+}
+
 static PyObject *MenuObj_as_Resource(_self, _args)
 	MenuObject *_self;
 	PyObject *_args;
@@ -546,12 +921,12 @@ static PyMethodDef MenuObj_methods[] = {
 	 "() -> None"},
 	{"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
 	 "(Str255 data) -> None"},
-	{"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
-	 "(ResType theType) -> None"},
 	{"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
 	 "(ResType theType, short afterItem) -> None"},
 	{"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
 	 "(short beforeID) -> None"},
+	{"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
+	 "(ResType theType) -> None"},
 	{"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
 	 "(Str255 itemString, short afterItem) -> None"},
 	{"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
@@ -560,38 +935,74 @@ static PyMethodDef MenuObj_methods[] = {
 	 "(short item, Str255 itemString) -> None"},
 	{"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
 	 "(short item) -> (Str255 itemString)"},
-	{"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
-	 "(short item) -> None"},
-	{"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
-	 "(short item) -> None"},
-	{"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
-	 "(short item, Boolean checked) -> None"},
 	{"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
-	 "(short item, short markChar) -> None"},
+	 "(short item, CharParameter markChar) -> None"},
 	{"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
-	 "(short item) -> (short markChar)"},
+	 "(short item) -> (CharParameter markChar)"},
+	{"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
+	 "(short item, CharParameter cmdChar) -> None"},
+	{"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
+	 "(short item) -> (CharParameter cmdChar)"},
 	{"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
 	 "(short item, short iconIndex) -> None"},
 	{"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
 	 "(short item) -> (short iconIndex)"},
 	{"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
-	 "(short item, short chStyle) -> None"},
+	 "(short item, Style chStyle) -> None"},
 	{"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
 	 "(short item) -> (Style chStyle)"},
 	{"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
 	 "() -> None"},
-	{"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
-	 "() -> (short _rv)"},
-	{"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
-	 "(short item) -> (short cmdChar)"},
-	{"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
-	 "(short item, short cmdChar) -> None"},
+	{"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
+	 "(short item) -> None"},
+	{"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
+	 "(short item) -> None"},
 	{"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
 	 "(short top, short left, short popUpItem) -> (long _rv)"},
+	{"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
+	 "(short item, Boolean checked) -> None"},
+	{"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
+	 "() -> (short _rv)"},
 	{"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
 	 "(short afterItem, short scriptFilter) -> None"},
 	{"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
 	 "(ResType theType, short afterItem, short scriptFilter) -> None"},
+	{"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1,
+	 "(SInt16 inItem, UInt32 inCommandID) -> None"},
+	{"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1,
+	 "(SInt16 inItem) -> (UInt32 outCommandID)"},
+	{"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1,
+	 "(SInt16 inItem, UInt8 inModifiers) -> None"},
+	{"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1,
+	 "(SInt16 inItem) -> (UInt8 outModifiers)"},
+	{"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1,
+	 "(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None"},
+	{"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1,
+	 "(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)"},
+	{"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1,
+	 "(SInt16 inItem, TextEncoding inScriptID) -> None"},
+	{"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1,
+	 "(SInt16 inItem) -> (TextEncoding outScriptID)"},
+	{"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1,
+	 "(SInt16 inItem, SInt16 inHierID) -> None"},
+	{"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1,
+	 "(SInt16 inItem) -> (SInt16 outHierID)"},
+	{"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1,
+	 "(SInt16 inItem, SInt16 inFontID) -> None"},
+	{"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1,
+	 "(SInt16 inItem) -> (SInt16 outFontID)"},
+	{"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1,
+	 "(SInt16 inItem, UInt32 inRefCon) -> None"},
+	{"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1,
+	 "(SInt16 inItem) -> (UInt32 outRefCon)"},
+	{"SetMenuItemRefCon2", (PyCFunction)MenuObj_SetMenuItemRefCon2, 1,
+	 "(SInt16 inItem, UInt32 inRefCon2) -> None"},
+	{"GetMenuItemRefCon2", (PyCFunction)MenuObj_GetMenuItemRefCon2, 1,
+	 "(SInt16 inItem) -> (UInt32 outRefCon2)"},
+	{"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1,
+	 "(SInt16 inItem, SInt16 inGlyph) -> None"},
+	{"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1,
+	 "(SInt16 inItem) -> (SInt16 outGlyph)"},
 	{"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
 	 "Return this Menu as a Resource"},
 	{NULL, NULL, 0}
@@ -686,33 +1097,38 @@ static PyObject *Menu_GetMenu(_self, _args)
 	return _res;
 }
 
-static PyObject *Menu_DrawMenuBar(_self, _args)
+static PyObject *Menu_DeleteMenu(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	short menuID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &menuID))
 		return NULL;
-	DrawMenuBar();
+	DeleteMenu(menuID);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_InvalMenuBar(_self, _args)
+static PyObject *Menu_MenuKey(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	long _rv;
+	CharParameter ch;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &ch))
 		return NULL;
-	InvalMenuBar();
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = MenuKey(ch);
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Menu_DeleteMenu(_self, _args)
+static PyObject *Menu_HiliteMenu(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
@@ -721,238 +1137,249 @@ static PyObject *Menu_DeleteMenu(_self, _args)
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &menuID))
 		return NULL;
-	DeleteMenu(menuID);
+	HiliteMenu(menuID);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_ClearMenuBar(_self, _args)
+static PyObject *Menu_GetMenuHandle(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	MenuHandle _rv;
+	short menuID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &menuID))
 		return NULL;
-	ClearMenuBar();
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = GetMenuHandle(menuID);
+	_res = Py_BuildValue("O&",
+	                     MenuObj_New, _rv);
 	return _res;
 }
 
-static PyObject *Menu_GetNewMBar(_self, _args)
+static PyObject *Menu_FlashMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Handle _rv;
-	short menuBarID;
+	short menuID;
 	if (!PyArg_ParseTuple(_args, "h",
-	                      &menuBarID))
+	                      &menuID))
 		return NULL;
-	_rv = GetNewMBar(menuBarID);
-	_res = Py_BuildValue("O&",
-	                     ResObj_New, _rv);
+	FlashMenuBar(menuID);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_GetMenuBar(_self, _args)
+static PyObject *Menu_MenuChoice(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Handle _rv;
+	long _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = GetMenuBar();
-	_res = Py_BuildValue("O&",
-	                     ResObj_New, _rv);
+	_rv = MenuChoice();
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
-static PyObject *Menu_SetMenuBar(_self, _args)
+static PyObject *Menu_DeleteMCEntries(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Handle menuList;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &menuList))
+	short menuID;
+	short menuItem;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &menuID,
+	                      &menuItem))
 		return NULL;
-	SetMenuBar(menuList);
+	DeleteMCEntries(menuID,
+	                menuItem);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_MenuKey(_self, _args)
+static PyObject *Menu_DrawMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	long _rv;
-	short ch;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &ch))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = MenuKey(ch);
-	_res = Py_BuildValue("l",
-	                     _rv);
+	DrawMenuBar();
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_HiliteMenu(_self, _args)
+static PyObject *Menu_InvalMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short menuID;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &menuID))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	HiliteMenu(menuID);
+	InvalMenuBar();
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_GetMenuHandle(_self, _args)
+static PyObject *Menu_InitProcMenu(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	MenuHandle _rv;
-	short menuID;
+	short resID;
 	if (!PyArg_ParseTuple(_args, "h",
-	                      &menuID))
+	                      &resID))
 		return NULL;
-	_rv = GetMenuHandle(menuID);
-	_res = Py_BuildValue("O&",
-	                     MenuObj_New, _rv);
+	InitProcMenu(resID);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_FlashMenuBar(_self, _args)
+static PyObject *Menu_GetMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short menuID;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &menuID))
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	FlashMenuBar(menuID);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = GetMenuBar();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
 	return _res;
 }
 
-static PyObject *Menu_SetMenuFlash(_self, _args)
+static PyObject *Menu_SetMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short count;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &count))
+	Handle menuList;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &menuList))
 		return NULL;
-	SetMenuFlash(count);
+	SetMenuBar(menuList);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_MenuSelect(_self, _args)
+static PyObject *Menu_SystemEdit(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	long _rv;
-	Point startPt;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &startPt))
+	Boolean _rv;
+	short editCmd;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &editCmd))
 		return NULL;
-	_rv = MenuSelect(startPt);
-	_res = Py_BuildValue("l",
+	_rv = SystemEdit(editCmd);
+	_res = Py_BuildValue("b",
 	                     _rv);
 	return _res;
 }
 
-static PyObject *Menu_InitProcMenu(_self, _args)
+static PyObject *Menu_SystemMenu(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short resID;
-	if (!PyArg_ParseTuple(_args, "h",
-	                      &resID))
+	long menuResult;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &menuResult))
 		return NULL;
-	InitProcMenu(resID);
+	SystemMenu(menuResult);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_MenuChoice(_self, _args)
+static PyObject *Menu_GetNewMBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	long _rv;
-	if (!PyArg_ParseTuple(_args, ""))
+	Handle _rv;
+	short menuBarID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &menuBarID))
 		return NULL;
-	_rv = MenuChoice();
-	_res = Py_BuildValue("l",
-	                     _rv);
+	_rv = GetNewMBar(menuBarID);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
 	return _res;
 }
 
-static PyObject *Menu_DeleteMCEntries(_self, _args)
+static PyObject *Menu_ClearMenuBar(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short menuID;
-	short menuItem;
-	if (!PyArg_ParseTuple(_args, "hh",
-	                      &menuID,
-	                      &menuItem))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	DeleteMCEntries(menuID,
-	                menuItem);
+	ClearMenuBar();
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Menu_SystemEdit(_self, _args)
+static PyObject *Menu_SetMenuFlash(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
-	short editCmd;
+	short count;
 	if (!PyArg_ParseTuple(_args, "h",
-	                      &editCmd))
+	                      &count))
 		return NULL;
-	_rv = SystemEdit(editCmd);
-	_res = Py_BuildValue("b",
+	SetMenuFlash(count);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Menu_MenuSelect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	Point startPt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &startPt))
+		return NULL;
+	_rv = MenuSelect(startPt);
+	_res = Py_BuildValue("l",
 	                     _rv);
 	return _res;
 }
 
-static PyObject *Menu_SystemMenu(_self, _args)
+static PyObject *Menu_MenuEvent(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	long menuResult;
-	if (!PyArg_ParseTuple(_args, "l",
-	                      &menuResult))
+	UInt32 _rv;
+	EventRecord inEvent;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetEventRecord, &inEvent))
 		return NULL;
-	SystemMenu(menuResult);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = MenuEvent(&inEvent);
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
@@ -980,42 +1407,44 @@ static PyMethodDef Menu_methods[] = {
 	 "(short menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
 	{"GetMenu", (PyCFunction)Menu_GetMenu, 1,
 	 "(short resourceID) -> (MenuHandle _rv)"},
-	{"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
-	 "() -> None"},
-	{"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
-	 "() -> None"},
 	{"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
 	 "(short menuID) -> None"},
-	{"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
-	 "() -> None"},
-	{"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
-	 "(short menuBarID) -> (Handle _rv)"},
-	{"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
-	 "() -> (Handle _rv)"},
-	{"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
-	 "(Handle menuList) -> None"},
 	{"MenuKey", (PyCFunction)Menu_MenuKey, 1,
-	 "(short ch) -> (long _rv)"},
+	 "(CharParameter ch) -> (long _rv)"},
 	{"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
 	 "(short menuID) -> None"},
 	{"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
 	 "(short menuID) -> (MenuHandle _rv)"},
 	{"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
 	 "(short menuID) -> None"},
-	{"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
-	 "(short count) -> None"},
-	{"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
-	 "(Point startPt) -> (long _rv)"},
-	{"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
-	 "(short resID) -> None"},
 	{"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
 	 "() -> (long _rv)"},
 	{"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
 	 "(short menuID, short menuItem) -> None"},
+	{"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
+	 "() -> None"},
+	{"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
+	 "() -> None"},
+	{"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
+	 "(short resID) -> None"},
+	{"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
+	 "() -> (Handle _rv)"},
+	{"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
+	 "(Handle menuList) -> None"},
 	{"SystemEdit", (PyCFunction)Menu_SystemEdit, 1,
 	 "(short editCmd) -> (Boolean _rv)"},
 	{"SystemMenu", (PyCFunction)Menu_SystemMenu, 1,
 	 "(long menuResult) -> None"},
+	{"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
+	 "(short menuBarID) -> (Handle _rv)"},
+	{"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
+	 "() -> None"},
+	{"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
+	 "(short count) -> None"},
+	{"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
+	 "(Point startPt) -> (long _rv)"},
+	{"MenuEvent", (PyCFunction)Menu_MenuEvent, 1,
+	 "(EventRecord inEvent) -> (UInt32 _rv)"},
 	{"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
 	 "(Str255 name) -> None"},
 	{NULL, NULL, 0}
diff --git a/Mac/Modules/qd/Qdmodule.c b/Mac/Modules/qd/Qdmodule.c
index f294d31..0fb1a7b 100644
--- a/Mac/Modules/qd/Qdmodule.c
+++ b/Mac/Modules/qd/Qdmodule.c
@@ -3586,6 +3586,38 @@ static PyObject *Qd_GetIndPattern(_self, _args)
 	return _res;
 }
 
+static PyObject *Qd_SlopeFromAngle(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Fixed _rv;
+	short angle;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &angle))
+		return NULL;
+	_rv = SlopeFromAngle(angle);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildFixed, _rv);
+	return _res;
+}
+
+static PyObject *Qd_AngleFromSlope(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Fixed slope;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetFixed, &slope))
+		return NULL;
+	_rv = AngleFromSlope(slope);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
 static PyObject *Qd_TextFont(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -3606,7 +3638,7 @@ static PyObject *Qd_TextFace(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short face;
+	Style face;
 	if (!PyArg_ParseTuple(_args, "h",
 	                      &face))
 		return NULL;
@@ -3666,8 +3698,8 @@ static PyObject *Qd_DrawChar(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short ch;
-	if (!PyArg_ParseTuple(_args, "h",
+	CharParameter ch;
+	if (!PyArg_ParseTuple(_args, "c",
 	                      &ch))
 		return NULL;
 	DrawChar(ch);
@@ -3721,8 +3753,8 @@ static PyObject *Qd_CharWidth(_self, _args)
 {
 	PyObject *_res = NULL;
 	short _rv;
-	short ch;
-	if (!PyArg_ParseTuple(_args, "h",
+	CharParameter ch;
+	if (!PyArg_ParseTuple(_args, "c",
 	                      &ch))
 		return NULL;
 	_rv = CharWidth(ch);
@@ -4215,10 +4247,14 @@ static PyMethodDef Qd_methods[] = {
 	 "() -> (short scrnHRes, short scrnVRes)"},
 	{"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
 	 "(short patternListID, short index) -> (Pattern thePat)"},
+	{"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
+	 "(short angle) -> (Fixed _rv)"},
+	{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
+	 "(Fixed slope) -> (short _rv)"},
 	{"TextFont", (PyCFunction)Qd_TextFont, 1,
 	 "(short font) -> None"},
 	{"TextFace", (PyCFunction)Qd_TextFace, 1,
-	 "(short face) -> None"},
+	 "(Style face) -> None"},
 	{"TextMode", (PyCFunction)Qd_TextMode, 1,
 	 "(short mode) -> None"},
 	{"TextSize", (PyCFunction)Qd_TextSize, 1,
@@ -4226,13 +4262,13 @@ static PyMethodDef Qd_methods[] = {
 	{"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
 	 "(Fixed extra) -> None"},
 	{"DrawChar", (PyCFunction)Qd_DrawChar, 1,
-	 "(short ch) -> None"},
+	 "(CharParameter ch) -> None"},
 	{"DrawString", (PyCFunction)Qd_DrawString, 1,
 	 "(Str255 s) -> None"},
 	{"DrawText", (PyCFunction)Qd_DrawText, 1,
 	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
 	{"CharWidth", (PyCFunction)Qd_CharWidth, 1,
-	 "(short ch) -> (short _rv)"},
+	 "(CharParameter ch) -> (short _rv)"},
 	{"StringWidth", (PyCFunction)Qd_StringWidth, 1,
 	 "(Str255 s) -> (short _rv)"},
 	{"TextWidth", (PyCFunction)Qd_TextWidth, 1,
diff --git a/Mac/Modules/qd/qdscan.py b/Mac/Modules/qd/qdscan.py
index cd5409e..46adaaa 100644
--- a/Mac/Modules/qd/qdscan.py
+++ b/Mac/Modules/qd/qdscan.py
@@ -72,6 +72,8 @@ class MyScanner(Scanner):
 			'InitCPort',
 			'CloseCPort',
 			'BitMapToRegionGlue',
+			'StdOpcode', 	# XXXX Missing from library...
+
 			]
 
 	def makeblacklisttypes(self):
diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py
index 3cef0f9..ebef23b 100644
--- a/Mac/Modules/qt/qtscan.py
+++ b/Mac/Modules/qt/qtscan.py
@@ -32,6 +32,9 @@ class MyScanner(Scanner):
 				listname = t + "_methods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
 	def makeblacklistnames(self):
 		return [
 			"DisposeMovie",		# Done on python-object disposal
diff --git a/Mac/Modules/res/Resmodule.c b/Mac/Modules/res/Resmodule.c
index f4ed648..879a887 100644
--- a/Mac/Modules/res/Resmodule.c
+++ b/Mac/Modules/res/Resmodule.c
@@ -605,7 +605,7 @@ static PyObject *Res_ResError(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
+	OSErr _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = ResError();
@@ -1275,7 +1275,7 @@ static PyMethodDef Res_methods[] = {
 	{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
 	 "(short refNum) -> None"},
 	{"ResError", (PyCFunction)Res_ResError, 1,
-	 "() -> (short _rv)"},
+	 "() -> (OSErr _rv)"},
 	{"CurResFile", (PyCFunction)Res_CurResFile, 1,
 	 "() -> (short _rv)"},
 	{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
diff --git a/Mac/Modules/snd/Sndmodule.c b/Mac/Modules/snd/Sndmodule.c
index 36d9fd2..06031ab 100644
--- a/Mac/Modules/snd/Sndmodule.c
+++ b/Mac/Modules/snd/Sndmodule.c
@@ -171,14 +171,14 @@ static PyObject *SndCh_SndPlay(_self, _args)
 {
 	PyObject *_res = NULL;
 	OSErr _err;
-	SndListHandle sndHdl;
+	SndListHandle sndHandle;
 	Boolean async;
 	if (!PyArg_ParseTuple(_args, "O&b",
-	                      ResObj_Convert, &sndHdl,
+	                      ResObj_Convert, &sndHandle,
 	                      &async))
 		return NULL;
 	_err = SndPlay(_self->ob_itself,
-	               sndHdl,
+	               sndHandle,
 	               async);
 	if (_err != noErr) return PyMac_Error(_err);
 	Py_INCREF(Py_None);
@@ -276,7 +276,7 @@ static PyMethodDef SndCh_methods[] = {
 	{"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
 	 "(SndCommand cmd) -> None"},
 	{"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
-	 "(SndListHandle sndHdl, Boolean async) -> None"},
+	 "(SndListHandle sndHandle, Boolean async) -> None"},
 	{"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
 	 "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
 	{"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
@@ -315,6 +315,21 @@ staticforward PyTypeObject SndChannel_Type = {
 /* ------------------- End object type SndChannel ------------------- */
 
 
+static PyObject *Snd_SysBeep(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short duration;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &duration))
+		return NULL;
+	SysBeep(duration);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *Snd_SndNewChannel(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -712,7 +727,244 @@ static PyObject *Snd_GetSoundHeaderOffset(_self, _args)
 	return _res;
 }
 
+static PyObject *Snd_SPBVersion(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	NumVersion _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = SPBVersion();
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildNumVersion, _rv);
+	return _res;
+}
+
+static PyObject *Snd_SPBSignInDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short deviceRefNum;
+	Str255 deviceName;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &deviceRefNum,
+	                      PyMac_GetStr255, deviceName))
+		return NULL;
+	_err = SPBSignInDevice(deviceRefNum,
+	                       deviceName);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBSignOutDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short deviceRefNum;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &deviceRefNum))
+		return NULL;
+	_err = SPBSignOutDevice(deviceRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBGetIndexedDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	short count;
+	Str255 deviceName;
+	Handle deviceIconHandle;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &count))
+		return NULL;
+	_err = SPBGetIndexedDevice(count,
+	                           deviceName,
+	                           &deviceIconHandle);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&O&",
+	                     PyMac_BuildStr255, deviceName,
+	                     ResObj_New, deviceIconHandle);
+	return _res;
+}
+
+static PyObject *Snd_SPBOpenDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Str255 deviceName;
+	short permission;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      PyMac_GetStr255, deviceName,
+	                      &permission))
+		return NULL;
+	_err = SPBOpenDevice(deviceName,
+	                     permission,
+	                     &inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     inRefNum);
+	return _res;
+}
+
+static PyObject *Snd_SPBCloseDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBCloseDevice(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBPauseRecording(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBPauseRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBResumeRecording(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBResumeRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBStopRecording(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBStopRecording(inRefNum);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Snd_SPBGetRecordingStatus(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	short recordingStatus;
+	short meterLevel;
+	unsigned long totalSamplesToRecord;
+	unsigned long numberOfSamplesRecorded;
+	unsigned long totalMsecsToRecord;
+	unsigned long numberOfMsecsRecorded;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBGetRecordingStatus(inRefNum,
+	                             &recordingStatus,
+	                             &meterLevel,
+	                             &totalSamplesToRecord,
+	                             &numberOfSamplesRecorded,
+	                             &totalMsecsToRecord,
+	                             &numberOfMsecsRecorded);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("hhllll",
+	                     recordingStatus,
+	                     meterLevel,
+	                     totalSamplesToRecord,
+	                     numberOfSamplesRecorded,
+	                     totalMsecsToRecord,
+	                     numberOfMsecsRecorded);
+	return _res;
+}
+
+static PyObject *Snd_SPBMillisecondsToBytes(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	long milliseconds;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBMillisecondsToBytes(inRefNum,
+	                              &milliseconds);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     milliseconds);
+	return _res;
+}
+
+static PyObject *Snd_SPBBytesToMilliseconds(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	long inRefNum;
+	long byteCount;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inRefNum))
+		return NULL;
+	_err = SPBBytesToMilliseconds(inRefNum,
+	                              &byteCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     byteCount);
+	return _res;
+}
+
 static PyMethodDef Snd_methods[] = {
+	{"SysBeep", (PyCFunction)Snd_SysBeep, 1,
+	 "(short duration) -> None"},
 	{"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
 	 "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
 	{"SndControl", (PyCFunction)Snd_SndControl, 1,
@@ -745,6 +997,30 @@ static PyMethodDef Snd_methods[] = {
 	 "(long level) -> None"},
 	{"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,
 	 "(SndListHandle sndHandle) -> (long offset)"},
+	{"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,
+	 "() -> (NumVersion _rv)"},
+	{"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,
+	 "(short deviceRefNum, Str255 deviceName) -> None"},
+	{"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,
+	 "(short deviceRefNum) -> None"},
+	{"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,
+	 "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"},
+	{"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,
+	 "(Str255 deviceName, short permission) -> (long inRefNum)"},
+	{"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,
+	 "(long inRefNum) -> None"},
+	{"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,
+	 "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"},
+	{"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,
+	 "(long inRefNum) -> (long milliseconds)"},
+	{"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,
+	 "(long inRefNum) -> (long byteCount)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/snd/sndscan.py b/Mac/Modules/snd/sndscan.py
index 249aa57..af5ecbb 100644
--- a/Mac/Modules/snd/sndscan.py
+++ b/Mac/Modules/snd/sndscan.py
@@ -31,6 +31,9 @@ class SoundScanner(Scanner):
 				listname = "sndmethods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
 	def makeblacklistnames(self):
 		return [
 			'SndDisposeChannel',		# automatic on deallocation
@@ -44,9 +47,12 @@ class SoundScanner(Scanner):
 			'GetSoundPreference',
 			'SetSoundPreference',
 			'GetCompressionInfo',
+			'GetCompressionName',
 			# Calls with void_ptr arguments (to be done).
 			'SndGetInfo',
 			'SndSetInfo',
+			'SPBGetDeviceInfo',
+			'SPBSetDeviceInfo',
 			# And old calls that are no longer supported
 			'SetSoundVol',
 			'GetSoundVol',
@@ -60,6 +66,13 @@ class SoundScanner(Scanner):
 			"UnsignedFixed",
 			# Don't have the time to dig into this...
 			"Component",
+			"ComponentInstance",
+			"SoundComponentDataPtr",
+			"SoundComponentData",
+			"SoundComponentData_ptr",
+			"SoundConverter",
+			"ModalFilterUPP",
+			"SPBPtr",
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/te/TEmodule.c b/Mac/Modules/te/TEmodule.c
index 611c262..70891ff 100644
--- a/Mac/Modules/te/TEmodule.c
+++ b/Mac/Modules/te/TEmodule.c
@@ -216,8 +216,8 @@ static PyObject *TEObj_TEKey(_self, _args)
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short key;
-	if (!PyArg_ParseTuple(_args, "h",
+	CharParameter key;
+	if (!PyArg_ParseTuple(_args, "c",
 	                      &key))
 		return NULL;
 	TEKey(key,
@@ -736,7 +736,7 @@ static PyMethodDef TEObj_methods[] = {
 	{"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1,
 	 "() -> None"},
 	{"TEKey", (PyCFunction)TEObj_TEKey, 1,
-	 "(short key) -> None"},
+	 "(CharParameter key) -> None"},
 	{"TECut", (PyCFunction)TEObj_TECut, 1,
 	 "() -> None"},
 	{"TECopy", (PyCFunction)TEObj_TECopy, 1,
diff --git a/Mac/Modules/win/Winmodule.c b/Mac/Modules/win/Winmodule.c
index eb5b046..ea24d62 100644
--- a/Mac/Modules/win/Winmodule.c
+++ b/Mac/Modules/win/Winmodule.c
@@ -102,220 +102,201 @@ static void WinObj_dealloc(self)
 	PyMem_DEL(self);
 }
 
-static PyObject *WinObj_GetWTitle(_self, _args)
-	WindowObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	Str255 title;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	GetWTitle(_self->ob_itself,
-	          title);
-	_res = Py_BuildValue("O&",
-	                     PyMac_BuildStr255, title);
-	return _res;
-}
-
-static PyObject *WinObj_SelectWindow(_self, _args)
+static PyObject *WinObj_SetWinColor(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	WCTabHandle newColorTable;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &newColorTable))
 		return NULL;
-	SelectWindow(_self->ob_itself);
+	SetWinColor(_self->ob_itself,
+	            newColorTable);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_HideWindow(_self, _args)
+static PyObject *WinObj_ClipAbove(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	HideWindow(_self->ob_itself);
+	ClipAbove(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_ShowWindow(_self, _args)
+static PyObject *WinObj_SaveOld(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	ShowWindow(_self->ob_itself);
+	SaveOld(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_ShowHide(_self, _args)
+static PyObject *WinObj_DrawNew(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean showFlag;
+	Boolean update;
 	if (!PyArg_ParseTuple(_args, "b",
-	                      &showFlag))
+	                      &update))
 		return NULL;
-	ShowHide(_self->ob_itself,
-	         showFlag);
+	DrawNew(_self->ob_itself,
+	        update);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_HiliteWindow(_self, _args)
+static PyObject *WinObj_PaintOne(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean fHilite;
-	if (!PyArg_ParseTuple(_args, "b",
-	                      &fHilite))
+	RgnHandle clobberedRgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &clobberedRgn))
 		return NULL;
-	HiliteWindow(_self->ob_itself,
-	             fHilite);
+	PaintOne(_self->ob_itself,
+	         clobberedRgn);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_BringToFront(_self, _args)
+static PyObject *WinObj_PaintBehind(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	RgnHandle clobberedRgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &clobberedRgn))
 		return NULL;
-	BringToFront(_self->ob_itself);
+	PaintBehind(_self->ob_itself,
+	            clobberedRgn);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_SendBehind(_self, _args)
+static PyObject *WinObj_CalcVis(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	WindowPtr behindWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &behindWindow))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	SendBehind(_self->ob_itself,
-	           behindWindow);
+	CalcVis(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_DrawGrowIcon(_self, _args)
+static PyObject *WinObj_CalcVisBehind(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	RgnHandle clobberedRgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &clobberedRgn))
 		return NULL;
-	DrawGrowIcon(_self->ob_itself);
+	CalcVisBehind(_self->ob_itself,
+	              clobberedRgn);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_MoveWindow(_self, _args)
+static PyObject *WinObj_BringToFront(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short hGlobal;
-	short vGlobal;
-	Boolean front;
-	if (!PyArg_ParseTuple(_args, "hhb",
-	                      &hGlobal,
-	                      &vGlobal,
-	                      &front))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	MoveWindow(_self->ob_itself,
-	           hGlobal,
-	           vGlobal,
-	           front);
+	BringToFront(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_SizeWindow(_self, _args)
+static PyObject *WinObj_SendBehind(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short w;
-	short h;
-	Boolean fUpdate;
-	if (!PyArg_ParseTuple(_args, "hhb",
-	                      &w,
-	                      &h,
-	                      &fUpdate))
+	WindowPtr behindWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &behindWindow))
 		return NULL;
-	SizeWindow(_self->ob_itself,
-	           w,
-	           h,
-	           fUpdate);
+	SendBehind(_self->ob_itself,
+	           behindWindow);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_ZoomWindow(_self, _args)
+static PyObject *WinObj_SelectWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short partCode;
-	Boolean front;
-	if (!PyArg_ParseTuple(_args, "hb",
-	                      &partCode,
-	                      &front))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	ZoomWindow(_self->ob_itself,
-	           partCode,
-	           front);
+	SelectWindow(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_BeginUpdate(_self, _args)
+static PyObject *WinObj_GetWindowFeatures(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
+	OSStatus _rv;
+	UInt32 outFeatures;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	BeginUpdate(_self->ob_itself);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = GetWindowFeatures(_self->ob_itself,
+	                        &outFeatures);
+	_res = Py_BuildValue("ll",
+	                     _rv,
+	                     outFeatures);
 	return _res;
 }
 
-static PyObject *WinObj_EndUpdate(_self, _args)
+static PyObject *WinObj_GetWindowRegion(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
+	OSStatus _rv;
+	WindowRegionCode inRegionCode;
+	RgnHandle ioWinRgn;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &inRegionCode,
+	                      ResObj_Convert, &ioWinRgn))
 		return NULL;
-	EndUpdate(_self->ob_itself);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = GetWindowRegion(_self->ob_itself,
+	                      inRegionCode,
+	                      ioWinRgn);
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
@@ -379,104 +360,209 @@ static PyObject *WinObj_GetWindowPic(_self, _args)
 	return _res;
 }
 
-static PyObject *WinObj_ClipAbove(_self, _args)
+static PyObject *WinObj_GetWVariant(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
+	short _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	ClipAbove(_self->ob_itself);
+	_rv = GetWVariant(_self->ob_itself);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *WinObj_BeginUpdate(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	BeginUpdate(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_SaveOld(_self, _args)
+static PyObject *WinObj_EndUpdate(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	SaveOld(_self->ob_itself);
+	EndUpdate(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_DrawNew(_self, _args)
+static PyObject *WinObj_DrawGrowIcon(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean update;
-	if (!PyArg_ParseTuple(_args, "b",
-	                      &update))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	DrawNew(_self->ob_itself,
-	        update);
+	DrawGrowIcon(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_PaintOne(_self, _args)
+static PyObject *WinObj_HiliteWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	RgnHandle clobberedRgn;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &clobberedRgn))
+	Boolean fHilite;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &fHilite))
 		return NULL;
-	PaintOne(_self->ob_itself,
-	         clobberedRgn);
+	HiliteWindow(_self->ob_itself,
+	             fHilite);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_PaintBehind(_self, _args)
+static PyObject *WinObj_SetWTitle(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	RgnHandle clobberedRgn;
+	Str255 title;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &clobberedRgn))
+	                      PyMac_GetStr255, title))
 		return NULL;
-	PaintBehind(_self->ob_itself,
-	            clobberedRgn);
+	SetWTitle(_self->ob_itself,
+	          title);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_CalcVis(_self, _args)
+static PyObject *WinObj_GetWTitle(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
+	Str255 title;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	CalcVis(_self->ob_itself);
+	GetWTitle(_self->ob_itself,
+	          title);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildStr255, title);
+	return _res;
+}
+
+static PyObject *WinObj_IsWindowCollapsable(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsWindowCollapsable(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *WinObj_IsWindowCollapsed(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsWindowCollapsed(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *WinObj_CollapseWindow(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	OSStatus _rv;
+	Boolean inCollapseIt;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &inCollapseIt))
+		return NULL;
+	_rv = CollapseWindow(_self->ob_itself,
+	                     inCollapseIt);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *WinObj_MoveWindow(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short hGlobal;
+	short vGlobal;
+	Boolean front;
+	if (!PyArg_ParseTuple(_args, "hhb",
+	                      &hGlobal,
+	                      &vGlobal,
+	                      &front))
+		return NULL;
+	MoveWindow(_self->ob_itself,
+	           hGlobal,
+	           vGlobal,
+	           front);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_CalcVisBehind(_self, _args)
+static PyObject *WinObj_SizeWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	RgnHandle clobberedRgn;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &clobberedRgn))
+	short w;
+	short h;
+	Boolean fUpdate;
+	if (!PyArg_ParseTuple(_args, "hhb",
+	                      &w,
+	                      &h,
+	                      &fUpdate))
 		return NULL;
-	CalcVisBehind(_self->ob_itself,
-	              clobberedRgn);
+	SizeWindow(_self->ob_itself,
+	           w,
+	           h,
+	           fUpdate);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *WinObj_ZoomWindow(_self, _args)
+	WindowObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short partCode;
+	Boolean front;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &partCode,
+	                      &front))
+		return NULL;
+	ZoomWindow(_self->ob_itself,
+	           partCode,
+	           front);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
@@ -502,105 +588,101 @@ static PyObject *WinObj_GrowWindow(_self, _args)
 	return _res;
 }
 
-static PyObject *WinObj_TrackBox(_self, _args)
+static PyObject *WinObj_DragWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Boolean _rv;
-	Point thePt;
-	short partCode;
-	if (!PyArg_ParseTuple(_args, "O&h",
-	                      PyMac_GetPoint, &thePt,
-	                      &partCode))
+	Point startPt;
+	Rect boundsRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &startPt,
+	                      PyMac_GetRect, &boundsRect))
 		return NULL;
-	_rv = TrackBox(_self->ob_itself,
-	               thePt,
-	               partCode);
-	_res = Py_BuildValue("b",
-	                     _rv);
+	DragWindow(_self->ob_itself,
+	           startPt,
+	           &boundsRect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_SetWinColor(_self, _args)
+static PyObject *WinObj_HideWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	WCTabHandle newColorTable;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &newColorTable))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	SetWinColor(_self->ob_itself,
-	            newColorTable);
+	HideWindow(_self->ob_itself);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_GetWVariant(_self, _args)
+static PyObject *WinObj_ShowWindow(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	_rv = GetWVariant(_self->ob_itself);
-	_res = Py_BuildValue("h",
-	                     _rv);
+	ShowWindow(_self->ob_itself);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_SetWTitle(_self, _args)
+static PyObject *WinObj_ShowHide(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Str255 title;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetStr255, title))
+	Boolean showFlag;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &showFlag))
 		return NULL;
-	SetWTitle(_self->ob_itself,
-	          title);
+	ShowHide(_self->ob_itself,
+	         showFlag);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *WinObj_TrackGoAway(_self, _args)
+static PyObject *WinObj_TrackBox(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
 	Boolean _rv;
 	Point thePt;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePt))
+	short partCode;
+	if (!PyArg_ParseTuple(_args, "O&h",
+	                      PyMac_GetPoint, &thePt,
+	                      &partCode))
 		return NULL;
-	_rv = TrackGoAway(_self->ob_itself,
-	                  thePt);
+	_rv = TrackBox(_self->ob_itself,
+	               thePt,
+	               partCode);
 	_res = Py_BuildValue("b",
 	                     _rv);
 	return _res;
 }
 
-static PyObject *WinObj_DragWindow(_self, _args)
+static PyObject *WinObj_TrackGoAway(_self, _args)
 	WindowObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Point startPt;
-	Rect boundsRect;
-	if (!PyArg_ParseTuple(_args, "O&O&",
-	                      PyMac_GetPoint, &startPt,
-	                      PyMac_GetRect, &boundsRect))
+	Boolean _rv;
+	Point thePt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &thePt))
 		return NULL;
-	DragWindow(_self->ob_itself,
-	           startPt,
-	           &boundsRect);
-	Py_INCREF(Py_None);
-	_res = Py_None;
+	_rv = TrackGoAway(_self->ob_itself,
+	                  thePt);
+	_res = Py_BuildValue("b",
+	                     _rv);
 	return _res;
 }
 
@@ -873,34 +955,32 @@ static PyObject *WinObj_SetWindowUserState(_self, _args)
 }
 
 static PyMethodDef WinObj_methods[] = {
-	{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
-	 "() -> (Str255 title)"},
-	{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
+	{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
+	 "(WCTabHandle newColorTable) -> None"},
+	{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
 	 "() -> None"},
-	{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
+	{"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
 	 "() -> None"},
-	{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
+	{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
+	 "(Boolean update) -> None"},
+	{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
+	 "(RgnHandle clobberedRgn) -> None"},
+	{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
+	 "(RgnHandle clobberedRgn) -> None"},
+	{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
 	 "() -> None"},
-	{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
-	 "(Boolean showFlag) -> None"},
-	{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
-	 "(Boolean fHilite) -> None"},
+	{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
+	 "(RgnHandle clobberedRgn) -> None"},
 	{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
 	 "() -> None"},
 	{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
 	 "(WindowPtr behindWindow) -> None"},
-	{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
-	 "() -> None"},
-	{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
-	 "(short hGlobal, short vGlobal, Boolean front) -> None"},
-	{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
-	 "(short w, short h, Boolean fUpdate) -> None"},
-	{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
-	 "(short partCode, Boolean front) -> None"},
-	{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
-	 "() -> None"},
-	{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
+	{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
 	 "() -> None"},
+	{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
+	 "() -> (OSStatus _rv, UInt32 outFeatures)"},
+	{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
+	 "(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> (OSStatus _rv)"},
 	{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
 	 "(long data) -> None"},
 	{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
@@ -909,34 +989,46 @@ static PyMethodDef WinObj_methods[] = {
 	 "(PicHandle pic) -> None"},
 	{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
 	 "() -> (PicHandle _rv)"},
-	{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
+	{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
+	 "() -> (short _rv)"},
+	{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
 	 "() -> None"},
-	{"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
+	{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
 	 "() -> None"},
-	{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
-	 "(Boolean update) -> None"},
-	{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
-	{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
-	{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
+	{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
 	 "() -> None"},
-	{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
-	 "(RgnHandle clobberedRgn) -> None"},
+	{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
+	 "(Boolean fHilite) -> None"},
+	{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
+	 "(Str255 title) -> None"},
+	{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
+	 "() -> (Str255 title)"},
+	{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
+	 "() -> (Boolean _rv)"},
+	{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
+	 "() -> (Boolean _rv)"},
+	{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
+	 "(Boolean inCollapseIt) -> (OSStatus _rv)"},
+	{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
+	 "(short hGlobal, short vGlobal, Boolean front) -> None"},
+	{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
+	 "(short w, short h, Boolean fUpdate) -> None"},
+	{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
+	 "(short partCode, Boolean front) -> None"},
 	{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
 	 "(Point startPt, Rect bBox) -> (long _rv)"},
+	{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
+	 "(Point startPt, Rect boundsRect) -> None"},
+	{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
+	 "() -> None"},
+	{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
+	 "() -> None"},
+	{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
+	 "(Boolean showFlag) -> None"},
 	{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
 	 "(Point thePt, short partCode) -> (Boolean _rv)"},
-	{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
-	 "(WCTabHandle newColorTable) -> None"},
-	{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
-	 "() -> (short _rv)"},
-	{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
-	 "(Str255 title) -> None"},
 	{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
 	 "(Point thePt) -> (Boolean _rv)"},
-	{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
-	 "(Point startPt, Rect boundsRect) -> None"},
 	{"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
 	 "() -> (Boolean _rv, AuxWinHandle awHndl)"},
 	{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
@@ -1003,44 +1095,23 @@ PyTypeObject Window_Type = {
 /* --------------------- End object type Window --------------------- */
 
 
-static PyObject *Win_GetGrayRgn(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	RgnHandle _rv;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = GetGrayRgn();
-	_res = Py_BuildValue("O&",
-	                     ResObj_New, _rv);
-	return _res;
-}
-
-static PyObject *Win_InitWindows(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	InitWindows();
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *Win_GetWMgrPort(_self, _args)
+static PyObject *Win_GetNewCWindow(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	GrafPtr wPort;
-	if (!PyArg_ParseTuple(_args, ""))
+	WindowPtr _rv;
+	short windowID;
+	WindowPtr behind;
+	if (!PyArg_ParseTuple(_args, "hO&",
+	                      &windowID,
+	                      WinObj_Convert, &behind))
 		return NULL;
-	GetWMgrPort(&wPort);
+	_rv = GetNewCWindow(windowID,
+	                    (void *)0,
+	                    behind);
 	_res = Py_BuildValue("O&",
-	                     GrafObj_New, wPort);
+	                     WinObj_New, _rv);
 	return _res;
 }
 
@@ -1099,6 +1170,91 @@ static PyObject *Win_GetNewWindow(_self, _args)
 	return _res;
 }
 
+static PyObject *Win_NewCWindow(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr _rv;
+	Rect boundsRect;
+	Str255 title;
+	Boolean visible;
+	short procID;
+	WindowPtr behind;
+	Boolean goAwayFlag;
+	long refCon;
+	if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
+	                      PyMac_GetRect, &boundsRect,
+	                      PyMac_GetStr255, title,
+	                      &visible,
+	                      &procID,
+	                      WinObj_Convert, &behind,
+	                      &goAwayFlag,
+	                      &refCon))
+		return NULL;
+	_rv = NewCWindow((void *)0,
+	                 &boundsRect,
+	                 title,
+	                 visible,
+	                 procID,
+	                 behind,
+	                 goAwayFlag,
+	                 refCon);
+	_res = Py_BuildValue("O&",
+	                     WinObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Win_SetDeskCPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle deskPixPat;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &deskPixPat))
+		return NULL;
+	SetDeskCPat(deskPixPat);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Win_CheckUpdate(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	EventRecord theEvent;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = CheckUpdate(&theEvent);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &theEvent);
+	return _res;
+}
+
+static PyObject *Win_FindWindow(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Point thePoint;
+	WindowPtr theWindow;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &thePoint))
+		return NULL;
+	_rv = FindWindow(thePoint,
+	                 &theWindow);
+	_res = Py_BuildValue("hO&",
+	                     _rv,
+	                     WinObj_WhichWindow, theWindow);
+	return _res;
+}
+
 static PyObject *Win_FrontWindow(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -1113,6 +1269,47 @@ static PyObject *Win_FrontWindow(_self, _args)
 	return _res;
 }
 
+static PyObject *Win_InitWindows(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	InitWindows();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Win_GetWMgrPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	GrafPtr wPort;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	GetWMgrPort(&wPort);
+	_res = Py_BuildValue("O&",
+	                     GrafObj_New, wPort);
+	return _res;
+}
+
+static PyObject *Win_GetCWMgrPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	CGrafPtr wMgrCPort;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	GetCWMgrPort(&wMgrCPort);
+	_res = Py_BuildValue("O&",
+	                     GrafObj_New, wMgrCPort);
+	return _res;
+}
+
 static PyObject *Win_InvalRect(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
@@ -1173,38 +1370,19 @@ static PyObject *Win_ValidRgn(_self, _args)
 	return _res;
 }
 
-static PyObject *Win_CheckUpdate(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	Boolean _rv;
-	EventRecord theEvent;
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = CheckUpdate(&theEvent);
-	_res = Py_BuildValue("bO&",
-	                     _rv,
-	                     PyMac_BuildEventRecord, &theEvent);
-	return _res;
-}
-
-static PyObject *Win_FindWindow(_self, _args)
+static PyObject *Win_CollapseAllWindows(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	short _rv;
-	Point thePoint;
-	WindowPtr theWindow;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	OSStatus _rv;
+	Boolean inCollapseEm;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &inCollapseEm))
 		return NULL;
-	_rv = FindWindow(thePoint,
-	                 &theWindow);
-	_res = Py_BuildValue("hO&",
-	                     _rv,
-	                     WinObj_WhichWindow, theWindow);
+	_rv = CollapseAllWindows(inCollapseEm);
+	_res = Py_BuildValue("l",
+	                     _rv);
 	return _res;
 }
 
@@ -1227,87 +1405,17 @@ static PyObject *Win_PinRect(_self, _args)
 	return _res;
 }
 
-static PyObject *Win_GetCWMgrPort(_self, _args)
+static PyObject *Win_GetGrayRgn(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	CGrafPtr wMgrCPort;
+	RgnHandle _rv;
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
-	GetCWMgrPort(&wMgrCPort);
-	_res = Py_BuildValue("O&",
-	                     GrafObj_New, wMgrCPort);
-	return _res;
-}
-
-static PyObject *Win_SetDeskCPat(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	PixPatHandle deskPixPat;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      ResObj_Convert, &deskPixPat))
-		return NULL;
-	SetDeskCPat(deskPixPat);
-	Py_INCREF(Py_None);
-	_res = Py_None;
-	return _res;
-}
-
-static PyObject *Win_NewCWindow(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	WindowPtr _rv;
-	Rect boundsRect;
-	Str255 title;
-	Boolean visible;
-	short procID;
-	WindowPtr behind;
-	Boolean goAwayFlag;
-	long refCon;
-	if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
-	                      PyMac_GetRect, &boundsRect,
-	                      PyMac_GetStr255, title,
-	                      &visible,
-	                      &procID,
-	                      WinObj_Convert, &behind,
-	                      &goAwayFlag,
-	                      &refCon))
-		return NULL;
-	_rv = NewCWindow((void *)0,
-	                 &boundsRect,
-	                 title,
-	                 visible,
-	                 procID,
-	                 behind,
-	                 goAwayFlag,
-	                 refCon);
-	_res = Py_BuildValue("O&",
-	                     WinObj_New, _rv);
-	return _res;
-}
-
-static PyObject *Win_GetNewCWindow(_self, _args)
-	PyObject *_self;
-	PyObject *_args;
-{
-	PyObject *_res = NULL;
-	WindowPtr _rv;
-	short windowID;
-	WindowPtr behind;
-	if (!PyArg_ParseTuple(_args, "hO&",
-	                      &windowID,
-	                      WinObj_Convert, &behind))
-		return NULL;
-	_rv = GetNewCWindow(windowID,
-	                    (void *)0,
-	                    behind);
+	_rv = GetGrayRgn();
 	_res = Py_BuildValue("O&",
-	                     WinObj_New, _rv);
+	                     ResObj_New, _rv);
 	return _res;
 }
 
@@ -1326,18 +1434,28 @@ static PyObject *Win_WhichWindow(_self, _args)
 }
 
 static PyMethodDef Win_methods[] = {
-	{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
-	 "() -> (RgnHandle _rv)"},
-	{"InitWindows", (PyCFunction)Win_InitWindows, 1,
-	 "() -> None"},
-	{"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
-	 "() -> (GrafPtr wPort)"},
+	{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
+	 "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
 	{"NewWindow", (PyCFunction)Win_NewWindow, 1,
 	 "(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
 	{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
 	 "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+	{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
+	 "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+	{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
+	 "(PixPatHandle deskPixPat) -> None"},
+	{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
+	 "() -> (Boolean _rv, EventRecord theEvent)"},
+	{"FindWindow", (PyCFunction)Win_FindWindow, 1,
+	 "(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
 	{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
 	 "() -> (WindowPtr _rv)"},
+	{"InitWindows", (PyCFunction)Win_InitWindows, 1,
+	 "() -> None"},
+	{"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
+	 "() -> (GrafPtr wPort)"},
+	{"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
+	 "() -> (CGrafPtr wMgrCPort)"},
 	{"InvalRect", (PyCFunction)Win_InvalRect, 1,
 	 "(Rect badRect) -> None"},
 	{"InvalRgn", (PyCFunction)Win_InvalRgn, 1,
@@ -1346,20 +1464,12 @@ static PyMethodDef Win_methods[] = {
 	 "(Rect goodRect) -> None"},
 	{"ValidRgn", (PyCFunction)Win_ValidRgn, 1,
 	 "(RgnHandle goodRgn) -> None"},
-	{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
-	 "() -> (Boolean _rv, EventRecord theEvent)"},
-	{"FindWindow", (PyCFunction)Win_FindWindow, 1,
-	 "(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
+	{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
+	 "(Boolean inCollapseEm) -> (OSStatus _rv)"},
 	{"PinRect", (PyCFunction)Win_PinRect, 1,
 	 "(Rect theRect, Point thePt) -> (long _rv)"},
-	{"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
-	 "() -> (CGrafPtr wMgrCPort)"},
-	{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
-	 "(PixPatHandle deskPixPat) -> None"},
-	{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
-	 "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
-	{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
-	 "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+	{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
+	 "() -> (RgnHandle _rv)"},
 	{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
 	 "Resolve an integer WindowPtr address to a Window object"},
 	{NULL, NULL, 0}
diff --git a/Mac/Modules/win/winscan.py b/Mac/Modules/win/winscan.py
index cafe36f..ae0462f 100644
--- a/Mac/Modules/win/winscan.py
+++ b/Mac/Modules/win/winscan.py
@@ -6,7 +6,7 @@ from bgenlocations import TOOLBOXDIR
 from scantools import Scanner
 
 def main():
-	input = "Windows.h"
+	input = "MacWindows.h"
 	output = "wingen.py"
 	defsoutput = TOOLBOXDIR + "Windows.py"
 	scanner = MyScanner(input, output, defsoutput)
@@ -28,6 +28,9 @@ class MyScanner(Scanner):
 				listname = "methods"
 		return classname, listname
 
+	def writeinitialdefs(self):
+		self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
 	def makeblacklistnames(self):
 		return [
 			'DisposeWindow', # Implied when the object is deleted
diff --git a/Mac/Modules/win/winsupport.py b/Mac/Modules/win/winsupport.py
index 5b1b45e..001a4a4 100644
--- a/Mac/Modules/win/winsupport.py
+++ b/Mac/Modules/win/winsupport.py
@@ -38,6 +38,8 @@ WCTabHandle = OpaqueByValueType("WCTabHandle", "ResObj")
 AuxWinHandle = OpaqueByValueType("AuxWinHandle", "ResObj")
 PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
 
+WindowRegionCode = Type("WindowRegionCode", "h")
+
 includestuff = includestuff + """
 #include <%s>""" % MACHEADERFILE + """