diff --git a/Mac/Modules/app/_Appmodule.c b/Mac/Modules/app/_Appmodule.c
index 4e9adc2..ab330a5 100644
--- a/Mac/Modules/app/_Appmodule.c
+++ b/Mac/Modules/app/_Appmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c
index bb2b0b3..a748813 100644
--- a/Mac/Modules/cf/_CFmodule.c
+++ b/Mac/Modules/cf/_CFmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/cg/_CGmodule.c b/Mac/Modules/cg/_CGmodule.c
index 729162b..3bcb260 100755
--- a/Mac/Modules/cg/_CGmodule.c
+++ b/Mac/Modules/cg/_CGmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/cm/_Cmmodule.c b/Mac/Modules/cm/_Cmmodule.c
index 6fb0832..a2da9c2 100644
--- a/Mac/Modules/cm/_Cmmodule.c
+++ b/Mac/Modules/cm/_Cmmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/ctl/_Ctlmodule.c b/Mac/Modules/ctl/_Ctlmodule.c
index 7571c3f..b2ba986 100644
--- a/Mac/Modules/ctl/_Ctlmodule.c
+++ b/Mac/Modules/ctl/_Ctlmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/dlg/_Dlgmodule.c b/Mac/Modules/dlg/_Dlgmodule.c
index afa50cc..d118e11 100644
--- a/Mac/Modules/dlg/_Dlgmodule.c
+++ b/Mac/Modules/dlg/_Dlgmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/drag/_Dragmodule.c b/Mac/Modules/drag/_Dragmodule.c
index 6e35e03..5312023 100644
--- a/Mac/Modules/drag/_Dragmodule.c
+++ b/Mac/Modules/drag/_Dragmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/evt/evtedit.py b/Mac/Modules/evt/evtedit.py
index 50b4b1a..3426b70 100644
--- a/Mac/Modules/evt/evtedit.py
+++ b/Mac/Modules/evt/evtedit.py
@@ -4,3 +4,7 @@
 )
 functions.append(f)
 
+f = Function(UInt32, 'TickCount',
+)
+functions.append(f)
+
diff --git a/Mac/Modules/fm/_Fmmodule.c b/Mac/Modules/fm/_Fmmodule.c
index 9cafebc..c5ab18a 100644
--- a/Mac/Modules/fm/_Fmmodule.c
+++ b/Mac/Modules/fm/_Fmmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/help/_Helpmodule.c b/Mac/Modules/help/_Helpmodule.c
index 0b42fc4..46f1a35 100644
--- a/Mac/Modules/help/_Helpmodule.c
+++ b/Mac/Modules/help/_Helpmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/icn/_Icnmodule.c b/Mac/Modules/icn/_Icnmodule.c
index a9af768..bc27732 100644
--- a/Mac/Modules/icn/_Icnmodule.c
+++ b/Mac/Modules/icn/_Icnmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/list/_Listmodule.c b/Mac/Modules/list/_Listmodule.c
index af23548..94e3bcf 100644
--- a/Mac/Modules/list/_Listmodule.c
+++ b/Mac/Modules/list/_Listmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/menu/_Menumodule.c b/Mac/Modules/menu/_Menumodule.c
index 91063cf..398f6fa 100644
--- a/Mac/Modules/menu/_Menumodule.c
+++ b/Mac/Modules/menu/_Menumodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/mlte/_Mltemodule.c b/Mac/Modules/mlte/_Mltemodule.c
index a72ea0e..4acc4b5 100644
--- a/Mac/Modules/mlte/_Mltemodule.c
+++ b/Mac/Modules/mlte/_Mltemodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
@@ -241,23 +245,23 @@
 	return _res;
 }
 
-#if 0
+#if TARGET_API_MAC_OS8
 
 static PyObject *TXNObj_TXNTSMCheck(TXNObjectObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
 	Boolean _rv;
-	EventRecord iEvent;
+	EventRecord ioEvent;
 #ifndef TXNTSMCheck
 	PyMac_PRECHECK(TXNTSMCheck);
 #endif
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetEventRecord, &iEvent))
+	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = TXNTSMCheck(_self->ob_itself,
-	                  &iEvent);
-	_res = Py_BuildValue("b",
-	                     _rv);
+	                  &ioEvent);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildEventRecord, &ioEvent);
 	return _res;
 }
 #endif
@@ -606,8 +610,8 @@
 {
 	PyObject *_res = NULL;
 	OSStatus _err;
-	UInt32 iStartOffset;
-	UInt32 iEndOffset;
+	TXNOffset iStartOffset;
+	TXNOffset iEndOffset;
 	ItemCount oRunCount;
 #ifndef TXNCountRunsInRange
 	PyMac_PRECHECK(TXNCountRunsInRange);
@@ -773,7 +777,7 @@
 {
 	PyObject *_res = NULL;
 	OSStatus _err;
-	OSType iType;
+	TXNFileType iType;
 	OSType iResType;
 	TXNPermanentTextEncodingType iPermanentEncoding;
 	FSSpec iFileSpecification;
@@ -867,6 +871,23 @@
 	return _res;
 }
 
+static PyObject *TXNObj_TXNSetViewRect(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Rect iViewRect;
+#ifndef TXNSetViewRect
+	PyMac_PRECHECK(TXNSetViewRect);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &iViewRect))
+		return NULL;
+	TXNSetViewRect(_self->ob_itself,
+	               &iViewRect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *TXNObj_TXNAttachObjectToWindow(TXNObjectObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1029,6 +1050,111 @@
 	return _res;
 }
 
+static PyObject *TXNObj_TXNPointToOffset(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	Point iPoint;
+	TXNOffset oOffset;
+#ifndef TXNPointToOffset
+	PyMac_PRECHECK(TXNPointToOffset);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &iPoint))
+		return NULL;
+	_err = TXNPointToOffset(_self->ob_itself,
+	                        iPoint,
+	                        &oOffset);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     oOffset);
+	return _res;
+}
+
+static PyObject *TXNObj_TXNOffsetToPoint(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	TXNOffset iOffset;
+	Point oPoint;
+#ifndef TXNOffsetToPoint
+	PyMac_PRECHECK(TXNOffsetToPoint);
+#endif
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &iOffset))
+		return NULL;
+	_err = TXNOffsetToPoint(_self->ob_itself,
+	                        iOffset,
+	                        &oPoint);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, oPoint);
+	return _res;
+}
+
+static PyObject *TXNObj_TXNGetLineCount(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ItemCount oLineTotal;
+#ifndef TXNGetLineCount
+	PyMac_PRECHECK(TXNGetLineCount);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = TXNGetLineCount(_self->ob_itself,
+	                       &oLineTotal);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     oLineTotal);
+	return _res;
+}
+
+static PyObject *TXNObj_TXNGetLineMetrics(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	UInt32 iLineNumber;
+	Fixed oLineWidth;
+	Fixed oLineHeight;
+#ifndef TXNGetLineMetrics
+	PyMac_PRECHECK(TXNGetLineMetrics);
+#endif
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &iLineNumber))
+		return NULL;
+	_err = TXNGetLineMetrics(_self->ob_itself,
+	                         iLineNumber,
+	                         &oLineWidth,
+	                         &oLineHeight);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&O&",
+	                     PyMac_BuildFixed, oLineWidth,
+	                     PyMac_BuildFixed, oLineHeight);
+	return _res;
+}
+
+static PyObject *TXNObj_TXNIsObjectAttachedToSpecificWindow(TXNObjectObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowPtr iWindow;
+	Boolean oAttached;
+#ifndef TXNIsObjectAttachedToSpecificWindow
+	PyMac_PRECHECK(TXNIsObjectAttachedToSpecificWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &iWindow))
+		return NULL;
+	_err = TXNIsObjectAttachedToSpecificWindow(_self->ob_itself,
+	                                           iWindow,
+	                                           &oAttached);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("b",
+	                     oAttached);
+	return _res;
+}
+
 static PyMethodDef TXNObj_methods[] = {
 	{"TXNDeleteObject", (PyCFunction)TXNObj_TXNDeleteObject, 1,
 	 "() -> None"},
@@ -1043,9 +1169,9 @@
 	{"TXNClick", (PyCFunction)TXNObj_TXNClick, 1,
 	 "(EventRecord iEvent) -> None"},
 
-#if 0
+#if TARGET_API_MAC_OS8
 	{"TXNTSMCheck", (PyCFunction)TXNObj_TXNTSMCheck, 1,
-	 "(EventRecord iEvent) -> (Boolean _rv)"},
+	 "() -> (Boolean _rv, EventRecord ioEvent)"},
 #endif
 	{"TXNSelectAll", (PyCFunction)TXNObj_TXNSelectAll, 1,
 	 "() -> None"},
@@ -1090,7 +1216,7 @@
 	{"TXNSetSelection", (PyCFunction)TXNObj_TXNSetSelection, 1,
 	 "(TXNOffset iStartOffset, TXNOffset iEndOffset) -> None"},
 	{"TXNCountRunsInRange", (PyCFunction)TXNObj_TXNCountRunsInRange, 1,
-	 "(UInt32 iStartOffset, UInt32 iEndOffset) -> (ItemCount oRunCount)"},
+	 "(TXNOffset iStartOffset, TXNOffset iEndOffset) -> (ItemCount oRunCount)"},
 	{"TXNDataSize", (PyCFunction)TXNObj_TXNDataSize, 1,
 	 "() -> (ByteCount _rv)"},
 	{"TXNGetData", (PyCFunction)TXNObj_TXNGetData, 1,
@@ -1104,7 +1230,7 @@
 	{"TXNGetChangeCount", (PyCFunction)TXNObj_TXNGetChangeCount, 1,
 	 "() -> (ItemCount _rv)"},
 	{"TXNSave", (PyCFunction)TXNObj_TXNSave, 1,
-	 "(OSType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None"},
+	 "(TXNFileType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None"},
 	{"TXNRevert", (PyCFunction)TXNObj_TXNRevert, 1,
 	 "() -> None"},
 	{"TXNPageSetup", (PyCFunction)TXNObj_TXNPageSetup, 1,
@@ -1113,6 +1239,8 @@
 	 "() -> None"},
 	{"TXNGetViewRect", (PyCFunction)TXNObj_TXNGetViewRect, 1,
 	 "() -> (Rect oViewRect)"},
+	{"TXNSetViewRect", (PyCFunction)TXNObj_TXNSetViewRect, 1,
+	 "(Rect iViewRect) -> None"},
 	{"TXNAttachObjectToWindow", (PyCFunction)TXNObj_TXNAttachObjectToWindow, 1,
 	 "(GWorldPtr iWindow, Boolean iIsActualWindow) -> None"},
 	{"TXNIsObjectAttachedToWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToWindow, 1,
@@ -1127,6 +1255,16 @@
 	 "(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None"},
 	{"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1,
 	 "(TXNFontMenuObject iTXNFontMenuObject) -> None"},
+	{"TXNPointToOffset", (PyCFunction)TXNObj_TXNPointToOffset, 1,
+	 "(Point iPoint) -> (TXNOffset oOffset)"},
+	{"TXNOffsetToPoint", (PyCFunction)TXNObj_TXNOffsetToPoint, 1,
+	 "(TXNOffset iOffset) -> (Point oPoint)"},
+	{"TXNGetLineCount", (PyCFunction)TXNObj_TXNGetLineCount, 1,
+	 "() -> (ItemCount oLineTotal)"},
+	{"TXNGetLineMetrics", (PyCFunction)TXNObj_TXNGetLineMetrics, 1,
+	 "(UInt32 iLineNumber) -> (Fixed oLineWidth, Fixed oLineHeight)"},
+	{"TXNIsObjectAttachedToSpecificWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToSpecificWindow, 1,
+	 "(WindowPtr iWindow) -> (Boolean oAttached)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/mlte/mltescan.py b/Mac/Modules/mlte/mltescan.py
index ae45f79..c4b3d47 100644
--- a/Mac/Modules/mlte/mltescan.py
+++ b/Mac/Modules/mlte/mltescan.py
@@ -77,7 +77,7 @@
 
 	def makegreylist(self):
 		return [
-			('#if !TARGET_API_MAC_OSX', [
+			('#if TARGET_API_MAC_OS8', [
 				'TXNTSMCheck',
 			])]
 
@@ -94,7 +94,14 @@
 			"TXNMatchTextRecord", #TBD
 			"TXNBackground", #TBD
 			"UniChar", #TBD
+			"UniCharCount", #TBD
+			"UniChar_ptr", #TBD
 			"TXNFindUPP", 
+			"ATSUStyle", #TBD
+			"TXNActionKeyMapperProcPtr",
+			"TXNActionKeyMapperUPP",
+			"TXNTextBoxOptionsData",
+			"TXNCountOptions",
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/mlte/mltesupport.py b/Mac/Modules/mlte/mltesupport.py
index 3a11e88..3ce2463 100644
--- a/Mac/Modules/mlte/mltesupport.py
+++ b/Mac/Modules/mlte/mltesupport.py
@@ -125,6 +125,7 @@
 GWorldPtr = OpaqueByValueType("GWorldPtr", "GWorldObj")
 OptGWorldPtr = OpaqueByValueType("GWorldPtr", "OptGWorldObj")
 MlteInBuffer = VarInputBufferType('void *', 'ByteCount', 'l')
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
 
 OptFSSpecPtr = OpaqueByValueType("FSSpec *", "OptFSSpecPtr")
 OptRectPtr = OpaqueByValueType("Rect *", "OptRectPtr")
diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c
index 7c176d8..81fe2cd 100644
--- a/Mac/Modules/qd/_Qdmodule.c
+++ b/Mac/Modules/qd/_Qdmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
@@ -1645,6 +1649,25 @@
 	return _res;
 }
 
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_RgnToHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RgnHandle region;
+	Handle flattenedRgnDataHdl;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &region,
+	                      ResObj_Convert, &flattenedRgnDataHdl))
+		return NULL;
+	RgnToHandle(region,
+	            flattenedRgnDataHdl);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
 static PyObject *Qd_DisposeRgn(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -3502,6 +3525,23 @@
 	return _res;
 }
 
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_IsValidPort(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	CGrafPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      GrafObj_Convert, &port))
+		return NULL;
+	_rv = IsValidPort(port);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+#endif
+
 static PyObject *Qd_GetPortPixMap(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -3878,6 +3918,23 @@
 
 #if TARGET_API_MAC_CARBON
 
+static PyObject *Qd_IsPortPolyBeingDefined(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	CGrafPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      GrafObj_Convert, &port))
+		return NULL;
+	_rv = IsPortPolyBeingDefined(port);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
 static PyObject *Qd_IsPortOffscreen(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -3990,6 +4047,22 @@
 	return _res;
 }
 
+static PyObject *Qd_SetPortFillPixPat(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	CGrafPtr port;
+	PixPatHandle penPattern;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      GrafObj_Convert, &port,
+	                      ResObj_Convert, &penPattern))
+		return NULL;
+	SetPortFillPixPat(port,
+	                  penPattern);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *Qd_SetPortBackPixPat(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -4347,6 +4420,398 @@
 	return _res;
 }
 
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_QDGetDirtyRegion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CGrafPtr port;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      GrafObj_Convert, &port,
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	_err = QDGetDirtyRegion(port,
+	                        rgn);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Qd_QDSetDirtyRegion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CGrafPtr port;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      GrafObj_Convert, &port,
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	_err = QDSetDirtyRegion(port,
+	                        rgn);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+static PyObject *Qd_LMGetScrVRes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt16 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetScrVRes();
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetScrVRes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt16 value;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &value))
+		return NULL;
+	LMSetScrVRes(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetScrHRes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt16 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetScrHRes();
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetScrHRes(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt16 value;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &value))
+		return NULL;
+	LMSetScrHRes(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetMainDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetMainDevice();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetMainDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetMainDevice(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetDeviceList(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetDeviceList();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetDeviceList(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetDeviceList(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetQDColors(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetQDColors();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetQDColors(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetQDColors(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetWidthListHand(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetWidthListHand();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetWidthListHand(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetWidthListHand(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetHiliteMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	UInt8 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetHiliteMode();
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetHiliteMode(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	UInt8 value;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &value))
+		return NULL;
+	LMSetHiliteMode(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetWidthTabHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetWidthTabHandle();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetWidthTabHandle(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetWidthTabHandle(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetLastSPExtra(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt32 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetLastSPExtra();
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetLastSPExtra(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	SInt32 value;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &value))
+		return NULL;
+	LMSetLastSPExtra(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetLastFOND(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetLastFOND();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetLastFOND(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetLastFOND(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetFractEnable(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	UInt8 _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetFractEnable();
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetFractEnable(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	UInt8 value;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &value))
+		return NULL;
+	LMSetFractEnable(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetTheGDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetTheGDevice();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetTheGDevice(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	GDHandle value;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &value))
+		return NULL;
+	LMSetTheGDevice(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetHiliteRGB(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RGBColor hiliteRGBValue;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	LMGetHiliteRGB(&hiliteRGBValue);
+	_res = Py_BuildValue("O&",
+	                     QdRGB_New, &hiliteRGBValue);
+	return _res;
+}
+
+static PyObject *Qd_LMSetHiliteRGB(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RGBColor hiliteRGBValue;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      QdRGB_Convert, &hiliteRGBValue))
+		return NULL;
+	LMSetHiliteRGB(&hiliteRGBValue);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LMGetCursorNew(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = LMGetCursorNew();
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_LMSetCursorNew(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean value;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &value))
+		return NULL;
+	LMSetCursorNew(value);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *Qd_TextFont(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -4536,6 +5001,26 @@
 	return _res;
 }
 
+static PyObject *Qd_TruncString(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short width;
+	Str255 theString;
+	TruncCode truncWhere;
+	if (!PyArg_ParseTuple(_args, "hO&h",
+	                      &width,
+	                      PyMac_GetStr255, theString,
+	                      &truncWhere))
+		return NULL;
+	_rv = TruncString(width,
+	                  theString,
+	                  truncWhere);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
 static PyObject *Qd_SetPort(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -5169,6 +5654,11 @@
 	 "(RgnHandle dstRgn) -> None"},
 	{"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
 	 "(RgnHandle region, BitMapPtr bMap) -> None"},
+
+#if TARGET_API_MAC_CARBON
+	{"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1,
+	 "(RgnHandle region, Handle flattenedRgnDataHdl) -> None"},
+#endif
 	{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
 	 "(RgnHandle rgn) -> None"},
 	{"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
@@ -5403,6 +5893,11 @@
 	 "(short angle) -> (Fixed _rv)"},
 	{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
 	 "(Fixed slope) -> (short _rv)"},
+
+#if TARGET_API_MAC_CARBON
+	{"IsValidPort", (PyCFunction)Qd_IsValidPort, 1,
+	 "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
 	{"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
 	 "(CGrafPtr port) -> (PixMapHandle _rv)"},
 	{"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
@@ -5455,6 +5950,11 @@
 	 "(CGrafPtr port) -> (Boolean _rv)"},
 
 #if TARGET_API_MAC_CARBON
+	{"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1,
+	 "(CGrafPtr port) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
 	{"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
 	 "(CGrafPtr port) -> (Boolean _rv)"},
 #endif
@@ -5473,6 +5973,8 @@
 	 "(CGrafPtr port, RgnHandle clipRgn) -> None"},
 	{"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
 	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+	{"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1,
+	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
 	{"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
 	 "(CGrafPtr port, PixPatHandle backPattern) -> None"},
 	{"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
@@ -5535,6 +6037,72 @@
 	 "(CGrafPtr port) -> (Boolean _rv)"},
 	{"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
 	 "(CGrafPtr port, RgnHandle region) -> None"},
+
+#if TARGET_API_MAC_CARBON
+	{"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1,
+	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+	{"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1,
+	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+#endif
+	{"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1,
+	 "() -> (SInt16 _rv)"},
+	{"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1,
+	 "(SInt16 value) -> None"},
+	{"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1,
+	 "() -> (SInt16 _rv)"},
+	{"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1,
+	 "(SInt16 value) -> None"},
+	{"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1,
+	 "() -> (GDHandle _rv)"},
+	{"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1,
+	 "(GDHandle value) -> None"},
+	{"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1,
+	 "() -> (GDHandle _rv)"},
+	{"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1,
+	 "(GDHandle value) -> None"},
+	{"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1,
+	 "() -> (Handle _rv)"},
+	{"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1,
+	 "(Handle value) -> None"},
+	{"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1,
+	 "() -> (Handle _rv)"},
+	{"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1,
+	 "(Handle value) -> None"},
+	{"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1,
+	 "() -> (UInt8 _rv)"},
+	{"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1,
+	 "(UInt8 value) -> None"},
+	{"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1,
+	 "() -> (Handle _rv)"},
+	{"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1,
+	 "(Handle value) -> None"},
+	{"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1,
+	 "() -> (SInt32 _rv)"},
+	{"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1,
+	 "(SInt32 value) -> None"},
+	{"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1,
+	 "() -> (Handle _rv)"},
+	{"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1,
+	 "(Handle value) -> None"},
+	{"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1,
+	 "() -> (UInt8 _rv)"},
+	{"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1,
+	 "(UInt8 value) -> None"},
+	{"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1,
+	 "() -> (GDHandle _rv)"},
+	{"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1,
+	 "(GDHandle value) -> None"},
+	{"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1,
+	 "() -> (RGBColor hiliteRGBValue)"},
+	{"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1,
+	 "(RGBColor hiliteRGBValue) -> None"},
+	{"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1,
+	 "() -> (Boolean _rv)"},
+	{"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1,
+	 "(Boolean value) -> None"},
 	{"TextFont", (PyCFunction)Qd_TextFont, 1,
 	 "(short font) -> None"},
 	{"TextFace", (PyCFunction)Qd_TextFace, 1,
@@ -5561,6 +6129,8 @@
 	 "() -> (FontInfo info)"},
 	{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
 	 "(Fixed extra) -> None"},
+	{"TruncString", (PyCFunction)Qd_TruncString, 1,
+	 "(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"},
 	{"SetPort", (PyCFunction)Qd_SetPort, 1,
 	 "(GrafPtr thePort) -> None"},
 	{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
diff --git a/Mac/Modules/qd/qdscan.py b/Mac/Modules/qd/qdscan.py
index d47b46a..7562915 100644
--- a/Mac/Modules/qd/qdscan.py
+++ b/Mac/Modules/qd/qdscan.py
@@ -122,6 +122,11 @@
 				'CreateNewPort',
 				'DisposePort',
 				'SetQDError',
+				'IsPortPolyBeingDefined',
+				'QDSetDirtyRegion',
+				'QDGetDirtyRegion',
+				'IsValidPort',
+				'RgnToHandle',
 			])]
 
 
diff --git a/Mac/Modules/qd/qdsupport.py b/Mac/Modules/qd/qdsupport.py
index 0c969d7..561aefd 100644
--- a/Mac/Modules/qd/qdsupport.py
+++ b/Mac/Modules/qd/qdsupport.py
@@ -63,6 +63,7 @@
 Pattern_ptr = StructInputBufferType('Pattern')
 PenState = StructOutputBufferType('PenState')
 PenState_ptr = StructInputBufferType('PenState')
+TruncCode = Type("TruncCode", "h")
 
 includestuff = includestuff + """
 #ifdef WITHOUT_FRAMEWORKS
diff --git a/Mac/Modules/qdoffs/_Qdoffsmodule.c b/Mac/Modules/qdoffs/_Qdoffsmodule.c
index 5af63ef..c2edf17 100644
--- a/Mac/Modules/qdoffs/_Qdoffsmodule.c
+++ b/Mac/Modules/qdoffs/_Qdoffsmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 962ee2a..594d156 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
@@ -822,6 +826,36 @@
 	return _res;
 }
 
+static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	Movie srcMovie;
+	Boolean scaled;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      MovieObj_Convert, &srcMovie,
+	                      &scaled))
+		return NULL;
+	_rv = MCAddMovieSegment(_self->ob_itself,
+	                        srcMovie,
+	                        scaled);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = MCTrimMovieSegment(_self->ob_itself);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
 static PyMethodDef MovieCtlObj_methods[] = {
 	{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
 	 "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
@@ -911,6 +945,10 @@
 	 "(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
 	{"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
 	 "(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
+	{"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
+	 "(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)"},
+	{"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
+	 "() -> (ComponentResult _rv)"},
 	{NULL, NULL, 0}
 };
 
@@ -3311,6 +3349,27 @@
 	return _res;
 }
 
+static PyObject *TrackObj_AddClonedTrackToMovie(TrackObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Movie dstMovie;
+	long flags;
+	Track dstTrack;
+	if (!PyArg_ParseTuple(_args, "O&l",
+	                      MovieObj_Convert, &dstMovie,
+	                      &flags))
+		return NULL;
+	_err = AddClonedTrackToMovie(_self->ob_itself,
+	                             dstMovie,
+	                             flags,
+	                             &dstTrack);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     TrackObj_New, dstTrack);
+	return _res;
+}
+
 static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -3673,6 +3732,8 @@
 	 "(Track dstTrack) -> None"},
 	{"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
 	 "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
+	{"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
+	 "(Movie dstMovie, long flags) -> (Track dstTrack)"},
 	{"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
 	 "(Track refTrack, OSType refType) -> (long addedIndex)"},
 	{"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
@@ -4252,6 +4313,20 @@
 	return _res;
 }
 
+static PyObject *MovieObj_SetMovieVideoOutput(MovieObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentInstance vout;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &vout))
+		return NULL;
+	SetMovieVideoOutput(_self->ob_itself,
+	                    vout);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -5614,6 +5689,8 @@
 	 "() -> (RgnHandle _rv)"},
 	{"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
 	 "() -> (RgnHandle _rv)"},
+	{"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
+	 "(ComponentInstance vout) -> None"},
 	{"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
 	 "(Handle publicMovie) -> None"},
 	{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
@@ -6027,6 +6104,32 @@
 	return _res;
 }
 
+static PyObject *Qt_QTGetMIMETypeInfo(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	char* mimeStringStart;
+	short mimeStringLength;
+	OSType infoSelector;
+	void * infoDataPtr;
+	long infoDataSize;
+	if (!PyArg_ParseTuple(_args, "shO&s",
+	                      &mimeStringStart,
+	                      &mimeStringLength,
+	                      PyMac_GetOSType, &infoSelector,
+	                      &infoDataPtr))
+		return NULL;
+	_err = QTGetMIMETypeInfo(mimeStringStart,
+	                         mimeStringLength,
+	                         infoSelector,
+	                         infoDataPtr,
+	                         &infoDataSize);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     infoDataSize);
+	return _res;
+}
+
 static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -6331,6 +6434,67 @@
 	return _res;
 }
 
+static PyObject *Qt_CanQuickTimeOpenFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	FSSpec fileSpec;
+	OSType fileType;
+	OSType fileNameExtension;
+	Boolean outCanOpenWithGraphicsImporter;
+	Boolean outCanOpenAsMovie;
+	Boolean outPreferGraphicsImporter;
+	UInt32 inFlags;
+	if (!PyArg_ParseTuple(_args, "O&O&O&l",
+	                      PyMac_GetFSSpec, &fileSpec,
+	                      PyMac_GetOSType, &fileType,
+	                      PyMac_GetOSType, &fileNameExtension,
+	                      &inFlags))
+		return NULL;
+	_err = CanQuickTimeOpenFile(&fileSpec,
+	                            fileType,
+	                            fileNameExtension,
+	                            &outCanOpenWithGraphicsImporter,
+	                            &outCanOpenAsMovie,
+	                            &outPreferGraphicsImporter,
+	                            inFlags);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("bbb",
+	                     outCanOpenWithGraphicsImporter,
+	                     outCanOpenAsMovie,
+	                     outPreferGraphicsImporter);
+	return _res;
+}
+
+static PyObject *Qt_CanQuickTimeOpenDataRef(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSErr _err;
+	Handle dataRef;
+	OSType dataRefType;
+	Boolean outCanOpenWithGraphicsImporter;
+	Boolean outCanOpenAsMovie;
+	Boolean outPreferGraphicsImporter;
+	UInt32 inFlags;
+	if (!PyArg_ParseTuple(_args, "O&O&l",
+	                      ResObj_Convert, &dataRef,
+	                      PyMac_GetOSType, &dataRefType,
+	                      &inFlags))
+		return NULL;
+	_err = CanQuickTimeOpenDataRef(dataRef,
+	                               dataRefType,
+	                               &outCanOpenWithGraphicsImporter,
+	                               &outCanOpenAsMovie,
+	                               &outPreferGraphicsImporter,
+	                               inFlags);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("bbb",
+	                     outCanOpenWithGraphicsImporter,
+	                     outCanOpenAsMovie,
+	                     outPreferGraphicsImporter);
+	return _res;
+}
+
 static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -6909,6 +7073,32 @@
 	return _res;
 }
 
+static PyObject *Qt_TextMediaGetTextProperty(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MediaHandler mh;
+	TimeValue atMediaTime;
+	long propertyType;
+	void * data;
+	long dataSize;
+	if (!PyArg_ParseTuple(_args, "O&llsl",
+	                      CmpInstObj_Convert, &mh,
+	                      &atMediaTime,
+	                      &propertyType,
+	                      &data,
+	                      &dataSize))
+		return NULL;
+	_rv = TextMediaGetTextProperty(mh,
+	                               atMediaTime,
+	                               propertyType,
+	                               data,
+	                               dataSize);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
 static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -7617,6 +7807,95 @@
 	return _res;
 }
 
+static PyObject *Qt_FlashMediaGetFlashVariable(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MediaHandler mh;
+	char path;
+	char name;
+	Handle theVariableCStringOut;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &mh))
+		return NULL;
+	_rv = FlashMediaGetFlashVariable(mh,
+	                                 &path,
+	                                 &name,
+	                                 &theVariableCStringOut);
+	_res = Py_BuildValue("lccO&",
+	                     _rv,
+	                     path,
+	                     name,
+	                     ResObj_New, theVariableCStringOut);
+	return _res;
+}
+
+static PyObject *Qt_FlashMediaSetFlashVariable(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MediaHandler mh;
+	char path;
+	char name;
+	char value;
+	Boolean updateFocus;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      CmpInstObj_Convert, &mh,
+	                      &updateFocus))
+		return NULL;
+	_rv = FlashMediaSetFlashVariable(mh,
+	                                 &path,
+	                                 &name,
+	                                 &value,
+	                                 updateFocus);
+	_res = Py_BuildValue("lccc",
+	                     _rv,
+	                     path,
+	                     name,
+	                     value);
+	return _res;
+}
+
+static PyObject *Qt_FlashMediaDoButtonActions(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MediaHandler mh;
+	char path;
+	long buttonID;
+	long transition;
+	if (!PyArg_ParseTuple(_args, "O&ll",
+	                      CmpInstObj_Convert, &mh,
+	                      &buttonID,
+	                      &transition))
+		return NULL;
+	_rv = FlashMediaDoButtonActions(mh,
+	                                &path,
+	                                buttonID,
+	                                transition);
+	_res = Py_BuildValue("lc",
+	                     _rv,
+	                     path);
+	return _res;
+}
+
+static PyObject *Qt_FlashMediaGetSupportedSwfVersion(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ComponentResult _rv;
+	MediaHandler mh;
+	UInt8 swfVersion;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CmpInstObj_Convert, &mh))
+		return NULL;
+	_rv = FlashMediaGetSupportedSwfVersion(mh,
+	                                       &swfVersion);
+	_res = Py_BuildValue("lb",
+	                     _rv,
+	                     swfVersion);
+	return _res;
+}
+
 #if !TARGET_API_MAC_CARBON
 
 static PyObject *Qt_MovieMediaGetCurrentMovieProperty(PyObject *_self, PyObject *_args)
@@ -7985,32 +8264,30 @@
 static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	TimeRecord inout;
+	TimeRecord theTime;
 	TimeBase newBase;
-	if (!PyArg_ParseTuple(_args, "O&O&",
-	                      QtTimeRecord_Convert, &inout,
+	if (!PyArg_ParseTuple(_args, "O&",
 	                      TimeBaseObj_Convert, &newBase))
 		return NULL;
-	ConvertTime(&inout,
+	ConvertTime(&theTime,
 	            newBase);
 	_res = Py_BuildValue("O&",
-	                     QtTimeRecord_New, &inout);
+	                     QtTimeRecord_New, &theTime);
 	return _res;
 }
 
 static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	TimeRecord inout;
+	TimeRecord theTime;
 	TimeScale newScale;
-	if (!PyArg_ParseTuple(_args, "O&l",
-	                      QtTimeRecord_Convert, &inout,
+	if (!PyArg_ParseTuple(_args, "l",
 	                      &newScale))
 		return NULL;
-	ConvertTimeScale(&inout,
+	ConvertTimeScale(&theTime,
 	                 newScale);
 	_res = Py_BuildValue("O&",
-	                     QtTimeRecord_New, &inout);
+	                     QtTimeRecord_New, &theTime);
 	return _res;
 }
 
@@ -8150,6 +8427,8 @@
 	 "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
 	{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
 	 "(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
+	{"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
+	 "(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)"},
 	{"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
 	 "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
 	{"NewUserData", (PyCFunction)Qt_NewUserData, 1,
@@ -8178,6 +8457,10 @@
 	 "(short resRefNum, short resId) -> None"},
 	{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
 	 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
+	{"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
+	 "(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+	{"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
+	 "(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
 	{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
 	 "(long newMovieFlags) -> (Movie _rv)"},
 	{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
@@ -8226,6 +8509,8 @@
 	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
 	{"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
 	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
+	{"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
+	 "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
 	{"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
 	 "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
 	{"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
@@ -8295,6 +8580,14 @@
 	 "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
 	{"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
 	 "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+	{"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
+	 "(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)"},
+	{"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
+	 "(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)"},
+	{"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
+	 "(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)"},
+	{"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
+	 "(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)"},
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
@@ -8348,9 +8641,9 @@
 	{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
 	 "() -> (TimeBase _rv)"},
 	{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
-	 "(TimeRecord inout, TimeBase newBase) -> (TimeRecord inout)"},
+	 "(TimeBase newBase) -> (TimeRecord theTime)"},
 	{"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
-	 "(TimeRecord inout, TimeScale newScale) -> (TimeRecord inout)"},
+	 "(TimeScale newScale) -> (TimeRecord theTime)"},
 	{"AddTime", (PyCFunction)Qt_AddTime, 1,
 	 "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
 	{"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py
index 45ef428..f0e3d1e 100644
--- a/Mac/Modules/qt/qtscan.py
+++ b/Mac/Modules/qt/qtscan.py
@@ -144,6 +144,11 @@
 			
 			# AddTime and SubtractTime
 			([('TimeRecord', 'dst', 'OutMode')], [('TimeRecord', 'dst', 'InOutMode')]),
+			
+			# Funny definitions
+			([('char_ptr', '*', 'InMode')], [('stringptr', '*', 'InMode')]),
+			([('FSSpecPtr', '*', 'InMode')], [('FSSpec_ptr', '*', 'InMode')]),
+			([('unsigned_char', 'swfVersion', 'OutMode')], [('UInt8', 'swfVersion', 'OutMode')]),
 			]
 			
 if __name__ == "__main__":
diff --git a/Mac/Modules/res/_Resmodule.c b/Mac/Modules/res/_Resmodule.c
index b29e852..0c4576b 100644
--- a/Mac/Modules/res/_Resmodule.c
+++ b/Mac/Modules/res/_Resmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
@@ -1357,6 +1361,51 @@
 }
 #endif
 
+static PyObject *Res_FSOpenResFile(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short _rv;
+	FSRef ref;
+	SignedByte permission;
+	if (!PyArg_ParseTuple(_args, "O&b",
+	                      PyMac_GetFSRef, &ref,
+	                      &permission))
+		return NULL;
+	_rv = FSOpenResFile(&ref,
+	                    permission);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Res_FSResourceFileAlreadyOpen(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	FSRef resourceFileRef;
+	Boolean inChain;
+	SInt16 refNum;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetFSRef, &resourceFileRef))
+		return NULL;
+	_rv = FSResourceFileAlreadyOpen(&resourceFileRef,
+	                                &inChain,
+	                                &refNum);
+	{
+		OSErr _err = ResError();
+		if (_err != noErr) return PyMac_Error(_err);
+	}
+	_res = Py_BuildValue("bbh",
+	                     _rv,
+	                     inChain,
+	                     refNum);
+	return _res;
+}
+
 static PyObject *Res_Resource(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1518,6 +1567,10 @@
 	{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
 	 "(SInt16 curRefNum) -> (OSErr _rv, SInt16 nextRefNum)"},
 #endif
+	{"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
+	 "(FSRef ref, SignedByte permission) -> (short _rv)"},
+	{"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
+	 "(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
 	{"Resource", (PyCFunction)Res_Resource, 1,
 	 "Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
 	{"Handle", (PyCFunction)Res_Handle, 1,
diff --git a/Mac/Modules/res/resscan.py b/Mac/Modules/res/resscan.py
index d748adb..ecdd86b 100644
--- a/Mac/Modules/res/resscan.py
+++ b/Mac/Modules/res/resscan.py
@@ -46,6 +46,11 @@
 ##			"MaxSizeRsrc",		# GetMaxResourceSize
 			]
 			
+	def makeblacklisttypes(self):
+		return [
+			"UniCharCount", #TBD
+			]
+			
 	def makegreylist(self):
 		return [
 			('#if TARGET_API_MAC_OS8', [
diff --git a/Mac/Modules/res/ressupport.py b/Mac/Modules/res/ressupport.py
index f7a1f45..056e214 100644
--- a/Mac/Modules/res/ressupport.py
+++ b/Mac/Modules/res/ressupport.py
@@ -5,6 +5,7 @@
 
 from macsupport import *
 
+FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
 
 class ResMixIn:
 
diff --git a/Mac/Modules/snd/_Sndmodule.c b/Mac/Modules/snd/_Sndmodule.c
index 3812507..dc2f5da 100644
--- a/Mac/Modules/snd/_Sndmodule.c
+++ b/Mac/Modules/snd/_Sndmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/te/_TEmodule.c b/Mac/Modules/te/_TEmodule.c
index c545c8b..f57b7e6 100644
--- a/Mac/Modules/te/_TEmodule.c
+++ b/Mac/Modules/te/_TEmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/waste/wastemodule.c b/Mac/Modules/waste/wastemodule.c
index 734a2e7..f459c11 100644
--- a/Mac/Modules/waste/wastemodule.c
+++ b/Mac/Modules/waste/wastemodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
diff --git a/Mac/Modules/win/_Winmodule.c b/Mac/Modules/win/_Winmodule.c
index fa0cfeb..6db74a9 100644
--- a/Mac/Modules/win/_Winmodule.c
+++ b/Mac/Modules/win/_Winmodule.c
@@ -5,8 +5,12 @@
 
 
 
+#ifdef _WIN32
+#include "pywintoolbox.h"
+#else
 #include "macglue.h"
 #include "pymactoolbox.h"
+#endif
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
@@ -153,7 +157,63 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowRetainCount(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	ItemCount _rv;
+#ifndef GetWindowRetainCount
+	PyMac_PRECHECK(GetWindowRetainCount);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = GetWindowRetainCount(_self->ob_itself);
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_RetainWindow(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+#ifndef RetainWindow
+	PyMac_PRECHECK(RetainWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = RetainWindow(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ReleaseWindow(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+#ifndef ReleaseWindow
+	PyMac_PRECHECK(ReleaseWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = ReleaseWindow(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
 {
@@ -172,6 +232,24 @@
 }
 #endif
 
+static PyObject *WinObj_GetWindowWidgetHilite(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowDefPartCode outHilite;
+#ifndef GetWindowWidgetHilite
+	PyMac_PRECHECK(GetWindowWidgetHilite);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetWindowWidgetHilite(_self->ob_itself,
+	                             &outHilite);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("h",
+	                     outHilite);
+	return _res;
+}
+
 static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -208,7 +286,7 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
 {
@@ -233,6 +311,77 @@
 }
 #endif
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowClass(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowClass inWindowClass;
+#ifndef SetWindowClass
+	PyMac_PRECHECK(SetWindowClass);
+#endif
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inWindowClass))
+		return NULL;
+	_err = SetWindowClass(_self->ob_itself,
+	                      inWindowClass);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowModality(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowModality inModalKind;
+	WindowPtr inUnavailableWindow;
+#ifndef SetWindowModality
+	PyMac_PRECHECK(SetWindowModality);
+#endif
+	if (!PyArg_ParseTuple(_args, "lO&",
+	                      &inModalKind,
+	                      WinObj_Convert, &inUnavailableWindow))
+		return NULL;
+	_err = SetWindowModality(_self->ob_itself,
+	                         inModalKind,
+	                         inUnavailableWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowModality(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowModality outModalKind;
+	WindowPtr outUnavailableWindow;
+#ifndef GetWindowModality
+	PyMac_PRECHECK(GetWindowModality);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetWindowModality(_self->ob_itself,
+	                         &outModalKind,
+	                         &outUnavailableWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("lO&",
+	                     outModalKind,
+	                     WinObj_WhichWindow, outUnavailableWindow);
+	return _res;
+}
+#endif
+
 #if !TARGET_API_MAC_CARBON
 
 static PyObject *WinObj_SetWinColor(WindowObject *_self, PyObject *_args)
@@ -328,7 +477,7 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
 {
@@ -362,7 +511,7 @@
 }
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
 {
@@ -557,7 +706,7 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
 {
@@ -581,6 +730,49 @@
 }
 #endif
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowAlternateTitle(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CFStringRef inTitle;
+#ifndef SetWindowAlternateTitle
+	PyMac_PRECHECK(SetWindowAlternateTitle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CFStringRefObj_Convert, &inTitle))
+		return NULL;
+	_err = SetWindowAlternateTitle(_self->ob_itself,
+	                               inTitle);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_CopyWindowAlternateTitle(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CFStringRef outTitle;
+#ifndef CopyWindowAlternateTitle
+	PyMac_PRECHECK(CopyWindowAlternateTitle);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = CopyWindowAlternateTitle(_self->ob_itself,
+	                                &outTitle);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CFStringRefObj_New, outTitle);
+	return _res;
+}
+#endif
+
 #if !TARGET_API_MAC_CARBON
 
 static PyObject *WinObj_IsValidWindowPtr(WindowObject *_self, PyObject *_args)
@@ -735,6 +927,24 @@
 	return _res;
 }
 
+static PyObject *WinObj_GetWindowStructureWidths(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	Rect outRect;
+#ifndef GetWindowStructureWidths
+	PyMac_PRECHECK(GetWindowStructureWidths);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetWindowStructureWidths(_self->ob_itself,
+	                                &outRect);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &outRect);
+	return _res;
+}
+
 static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -886,6 +1096,49 @@
 	return _res;
 }
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_SetWindowTitleWithCFString(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CFStringRef inString;
+#ifndef SetWindowTitleWithCFString
+	PyMac_PRECHECK(SetWindowTitleWithCFString);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      CFStringRefObj_Convert, &inString))
+		return NULL;
+	_err = SetWindowTitleWithCFString(_self->ob_itself,
+	                                  inString);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_CopyWindowTitleAsCFString(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	CFStringRef outString;
+#ifndef CopyWindowTitleAsCFString
+	PyMac_PRECHECK(CopyWindowTitleAsCFString);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = CopyWindowTitleAsCFString(_self->ob_itself,
+	                                 &outString);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     CFStringRefObj_New, outString);
+	return _res;
+}
+#endif
+
 static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1239,6 +1492,37 @@
 	return _res;
 }
 
+#if TARGET_API_MAC_OSX
+
+static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowPtr parentWindow;
+	WindowTransitionEffect effect;
+	WindowTransitionAction action;
+	Rect rect;
+#ifndef TransitionWindowAndParent
+	PyMac_PRECHECK(TransitionWindowAndParent);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&llO&",
+	                      WinObj_Convert, &parentWindow,
+	                      &effect,
+	                      &action,
+	                      PyMac_GetRect, &rect))
+		return NULL;
+	_err = TransitionWindowAndParent(_self->ob_itself,
+	                                 parentWindow,
+	                                 effect,
+	                                 action,
+	                                 &rect);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
 static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1574,16 +1858,74 @@
 #ifndef SetWindowIdealUserState
 	PyMac_PRECHECK(SetWindowIdealUserState);
 #endif
-	if (!PyArg_ParseTuple(_args, ""))
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &userState))
 		return NULL;
 	_err = SetWindowIdealUserState(_self->ob_itself,
 	                               &userState);
 	if (_err != noErr) return PyMac_Error(_err);
-	_res = Py_BuildValue("O&",
-	                     PyMac_BuildRect, &userState);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetWindowGreatestAreaDevice(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowRegionCode inRegion;
+	GDHandle outGreatestDevice;
+	Rect outGreatestDeviceRect;
+#ifndef GetWindowGreatestAreaDevice
+	PyMac_PRECHECK(GetWindowGreatestAreaDevice);
+#endif
+	if (!PyArg_ParseTuple(_args, "H",
+	                      &inRegion))
+		return NULL;
+	_err = GetWindowGreatestAreaDevice(_self->ob_itself,
+	                                   inRegion,
+	                                   &outGreatestDevice,
+	                                   &outGreatestDeviceRect);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&O&",
+	                     ResObj_New, outGreatestDevice,
+	                     PyMac_BuildRect, &outGreatestDeviceRect);
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ConstrainWindowToScreen(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowRegionCode inRegionCode;
+	WindowConstrainOptions inOptions;
+	Rect inScreenRect;
+	Rect outStructure;
+#ifndef ConstrainWindowToScreen
+	PyMac_PRECHECK(ConstrainWindowToScreen);
+#endif
+	if (!PyArg_ParseTuple(_args, "HlO&",
+	                      &inRegionCode,
+	                      &inOptions,
+	                      PyMac_GetRect, &inScreenRect))
+		return NULL;
+	_err = ConstrainWindowToScreen(_self->ob_itself,
+	                               inRegionCode,
+	                               inOptions,
+	                               &inScreenRect,
+	                               &outStructure);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &outStructure);
+	return _res;
+}
+#endif
+
 static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1629,7 +1971,84 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+#ifndef MacIsWindowVisible
+	PyMac_PRECHECK(MacIsWindowVisible);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = MacIsWindowVisible(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_ShowSheetWindow(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowPtr inParentWindow;
+#ifndef ShowSheetWindow
+	PyMac_PRECHECK(ShowSheetWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &inParentWindow))
+		return NULL;
+	_err = ShowSheetWindow(_self->ob_itself,
+	                       inParentWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_HideSheetWindow(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+#ifndef HideSheetWindow
+	PyMac_PRECHECK(HideSheetWindow);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = HideSheetWindow(_self->ob_itself);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *WinObj_GetSheetWindowParent(WindowObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	WindowPtr outParentWindow;
+#ifndef GetSheetWindowParent
+	PyMac_PRECHECK(GetSheetWindowParent);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetSheetWindowParent(_self->ob_itself,
+	                            &outParentWindow);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     WinObj_WhichWindow, outParentWindow);
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
 {
@@ -1656,7 +2075,7 @@
 }
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
 {
@@ -1813,21 +2232,6 @@
 	return _res;
 }
 
-static PyObject *WinObj_MacIsWindowVisible(WindowObject *_self, PyObject *_args)
-{
-	PyObject *_res = NULL;
-	Boolean _rv;
-#ifndef MacIsWindowVisible
-	PyMac_PRECHECK(MacIsWindowVisible);
-#endif
-	if (!PyArg_ParseTuple(_args, ""))
-		return NULL;
-	_rv = MacIsWindowVisible(_self->ob_itself);
-	_res = Py_BuildValue("b",
-	                     _rv);
-	return _res;
-}
-
 static PyObject *WinObj_IsWindowHilited(WindowObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -1843,7 +2247,7 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *WinObj_IsWindowUpdatePending(WindowObject *_self, PyObject *_args)
 {
@@ -2166,20 +2570,52 @@
 	{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
 	 "() -> None"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
+	{"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
+	 "() -> (ItemCount _rv)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
+	 "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
+	 "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
 	{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
 	 "() -> None"},
 #endif
+	{"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
+	 "() -> (WindowDefPartCode outHilite)"},
 	{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
 	 "() -> (WindowClass outClass)"},
 	{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
 	 "() -> (WindowAttributes outAttributes)"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
 	 "(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
 #endif
 
+#if !TARGET_API_MAC_OS8
+	{"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
+	 "(WindowClass inWindowClass) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
+	 "(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
+	 "() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)"},
+#endif
+
 #if !TARGET_API_MAC_CARBON
 	{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
 	 "(WCTabHandle newColorTable) -> None"},
@@ -2193,12 +2629,12 @@
 	{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
 	 "(PixPatHandle pixPat) -> None"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
 	 "(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
 	 "(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
 #endif
@@ -2229,11 +2665,21 @@
 	{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
 	 "() -> None"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
 	 "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
 #endif
 
+#if !TARGET_API_MAC_OS8
+	{"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
+	 "(CFStringRef inTitle) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
+	 "() -> (CFStringRef outTitle)"},
+#endif
+
 #if !TARGET_API_MAC_CARBON
 	{"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
 	 "() -> (Boolean _rv)"},
@@ -2254,6 +2700,8 @@
 	 "() -> (UInt32 outFeatures)"},
 	{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
 	 "(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
+	{"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
+	 "() -> (Rect outRect)"},
 	{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
 	 "() -> None"},
 	{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
@@ -2272,6 +2720,16 @@
 	 "(Str255 title) -> None"},
 	{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
 	 "() -> (Str255 title)"},
+
+#if !TARGET_API_MAC_OS8
+	{"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
+	 "(CFStringRef inString) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
+	 "() -> (CFStringRef outString)"},
+#endif
 	{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
 	 "(FSSpec inFile) -> None"},
 	{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
@@ -2308,6 +2766,11 @@
 	 "(Boolean hilited) -> None"},
 	{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
 	 "(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+
+#if TARGET_API_MAC_OSX
+	{"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
+	 "(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
+#endif
 	{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
 	 "(short hGlobal, short vGlobal, Boolean front) -> None"},
 	{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
@@ -2341,20 +2804,47 @@
 	{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
 	 "() -> (Rect userState)"},
 	{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
-	 "() -> (Rect userState)"},
+	 "(Rect userState) -> None"},
+
+#if !TARGET_API_MAC_OS8
+	{"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
+	 "(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
+	 "(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)"},
+#endif
 	{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
 	 "() -> None"},
 	{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
 	 "() -> None"},
 	{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
 	 "(Boolean showFlag) -> None"},
+	{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
+	 "() -> (Boolean _rv)"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
+	{"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
+	 "(WindowPtr inParentWindow) -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
+	 "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
+	 "() -> (WindowPtr outParentWindow)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
 	{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
 	 "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
 	 "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
 #endif
@@ -2381,12 +2871,10 @@
 	 "() -> (CGrafPtr _rv)"},
 	{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
 	 "() -> (short _rv)"},
-	{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
-	 "() -> (Boolean _rv)"},
 	{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
 	 "() -> (Boolean _rv)"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
 	 "() -> (Boolean _rv)"},
 #endif
@@ -2781,7 +3269,7 @@
 	return _res;
 }
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
 {
@@ -2804,7 +3292,7 @@
 }
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 
 static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
 {
@@ -2833,6 +3321,29 @@
 }
 #endif
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_CreateStandardWindowMenu(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	OptionBits inOptions;
+	MenuHandle outMenu;
+#ifndef CreateStandardWindowMenu
+	PyMac_PRECHECK(CreateStandardWindowMenu);
+#endif
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &inOptions))
+		return NULL;
+	_err = CreateStandardWindowMenu(inOptions,
+	                                &outMenu);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     MenuObj_New, outMenu);
+	return _res;
+}
+#endif
+
 #if !TARGET_API_MAC_CARBON
 
 static PyObject *Win_InitWindows(PyObject *_self, PyObject *_args)
@@ -2999,6 +3510,67 @@
 	return _res;
 }
 
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	GDHandle inDevice;
+	Rect availableRect;
+#ifndef GetAvailableWindowPositioningBounds
+	PyMac_PRECHECK(GetAvailableWindowPositioningBounds);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &inDevice))
+		return NULL;
+	_err = GetAvailableWindowPositioningBounds(inDevice,
+	                                           &availableRect);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &availableRect);
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_DisableScreenUpdates(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+#ifndef DisableScreenUpdates
+	PyMac_PRECHECK(DisableScreenUpdates);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = DisableScreenUpdates();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_OS8
+
+static PyObject *Win_EnableScreenUpdates(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+#ifndef EnableScreenUpdates
+	PyMac_PRECHECK(EnableScreenUpdates);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = EnableScreenUpdates();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif
+
 static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -3117,16 +3689,21 @@
 	{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
 	 "() -> (WindowPtr _rv)"},
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
 	 "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
 #endif
 
-#if TARGET_API_MAC_CARBON
+#if !TARGET_API_MAC_OS8
 	{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
 	 "(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
 #endif
 
+#if !TARGET_API_MAC_OS8
+	{"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
+	 "(OptionBits inOptions) -> (MenuHandle outMenu)"},
+#endif
+
 #if !TARGET_API_MAC_CARBON
 	{"InitWindows", (PyCFunction)Win_InitWindows, 1,
 	 "() -> None"},
@@ -3168,6 +3745,21 @@
 #endif
 	{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
 	 "(Boolean collapse) -> None"},
+
+#if !TARGET_API_MAC_OS8
+	{"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
+	 "(GDHandle inDevice) -> (Rect availableRect)"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
+	 "() -> None"},
+#endif
+
+#if !TARGET_API_MAC_OS8
+	{"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
+	 "() -> None"},
+#endif
 	{"PinRect", (PyCFunction)Win_PinRect, 1,
 	 "(Rect theRect, Point thePt) -> (long _rv)"},
 	{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
diff --git a/Mac/Modules/win/winscan.py b/Mac/Modules/win/winscan.py
index dcb62c3..82f4441 100644
--- a/Mac/Modules/win/winscan.py
+++ b/Mac/Modules/win/winscan.py
@@ -71,7 +71,7 @@
 				'GetWindowGoAwayFlag',
 				'GetWindowSpareFlag',
 			]),
-			('#if TARGET_API_MAC_CARBON', [
+			('#if !TARGET_API_MAC_OS8', [
 				'IsWindowUpdatePending',
 				'FindWindowOfClass',
 				'GetFrontWindowOfClass',
@@ -82,6 +82,28 @@
 				'ScrollWindowRect',
 				'ChangeWindowAttributes',
 				'ReshapeCustomWindow',
+				'EnableScreenUpdates',
+				'DisableScreenUpdates',
+				'GetAvailableWindowPositioningBounds',
+				'CreateStandardWindowMenu',
+				'GetSheetWindowParent',
+				'HideSheetWindow',
+				'ShowSheetWindow',
+				'ConstrainWindowToScreen',
+				'GetWindowGreatestAreaDevice',
+				'CopyWindowTitleAsCFString',
+				'SetWindowTitleWithCFString',
+				'CopyWindowAlternateTitle',
+				'SetWindowAlternateTitle',
+				'GetWindowModality',
+				'SetWindowModality',
+				'SetWindowClass',
+				'ReleaseWindow',
+				'RetainWindow',
+				'GetWindowRetainCount',
+			]),
+			('#if TARGET_API_MAC_OSX', [
+				'TransitionWindowAndParent',
 			])]
 			
 	def makeblacklisttypes(self):
@@ -92,6 +114,7 @@
 			'Collection',		# For now, to be done later
 			'WindowDefSpec',	# Too difficult for now
 			'WindowDefSpec_ptr',
+			'EventRef', #TBD
 			]
 
 	def makerepairinstructions(self):
diff --git a/Mac/Modules/win/winsupport.py b/Mac/Modules/win/winsupport.py
index 81e6b53..022cf94 100644
--- a/Mac/Modules/win/winsupport.py
+++ b/Mac/Modules/win/winsupport.py
@@ -49,6 +49,11 @@
 RGBColor_ptr = RGBColor
 ScrollWindowOptions = Type("ScrollWindowOptions", "l")
 WindowPartCode = Type("WindowPartCode", "h")
+WindowDefPartCode = Type("WindowDefPartCode", "h")
+WindowModality = Type("WindowModality", "l")
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
+GDHandle = OpaqueByValueType("GDHandle", "ResObj")
+WindowConstrainOptions = Type("WindowConstrainOptions", "l")
 
 PropertyCreator = OSTypeType("PropertyCreator")
 PropertyTag = OSTypeType("PropertyTag")