Finished update to UH 3.4.2.

Mac/Modules/carbonevt/_CarbonEvtmodule.c

@@ -1750,6 +1750,35 @@ static PyObject *CarbonEvents_GetLastUserEventTime(PyObject *_self, PyObject *_a
 	return _res;
 }
 
+static PyObject *CarbonEvents_IsMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsMouseCoalescingEnabled();
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *CarbonEvents_SetMouseCoalescingEnabled(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	Boolean inNewState;
+	Boolean outOldState;
+	if (!PyArg_ParseTuple(_args, "b",
+	                      &inNewState))
+		return NULL;
+	_err = SetMouseCoalescingEnabled(inNewState,
+	                                 &outOldState);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("b",
+	                     outOldState);
+	return _res;
+}
+
 static PyObject *CarbonEvents_GetWindowEventTarget(PyObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -2059,6 +2088,10 @@ static PyMethodDef CarbonEvents_methods[] = {
 	 PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
 	{"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
 	 PyDoc_STR("() -> (double _rv)")},
+	{"IsMouseCoalescingEnabled", (PyCFunction)CarbonEvents_IsMouseCoalescingEnabled, 1,
+	 PyDoc_STR("() -> (Boolean _rv)")},
+	{"SetMouseCoalescingEnabled", (PyCFunction)CarbonEvents_SetMouseCoalescingEnabled, 1,
+	 PyDoc_STR("(Boolean inNewState) -> (Boolean outOldState)")},
 	{"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
 	 PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
 	{"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,

Mac/Modules/help/_Helpmodule.c

@@ -131,6 +131,19 @@ static PyObject *Help_HMSetDialogHelpFromBalloonRsrc(PyObject *_self, PyObject *
 	return _res;
 }
 
+static PyObject *Help_HMHideTag(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = HMHideTag();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyMethodDef Help_methods[] = {
 	{"HMGetHelpMenu", (PyCFunction)Help_HMGetHelpMenu, 1,
 	 PyDoc_STR("() -> (MenuRef outHelpMenu, MenuItemIndex outFirstCustomItemIndex)")},
@@ -146,6 +159,8 @@ static PyMethodDef Help_methods[] = {
 	 PyDoc_STR("(MenuRef inMenu, SInt16 inHmnuRsrcID) -> None")},
 	{"HMSetDialogHelpFromBalloonRsrc", (PyCFunction)Help_HMSetDialogHelpFromBalloonRsrc, 1,
 	 PyDoc_STR("(DialogPtr inDialog, SInt16 inHdlgRsrcID, SInt16 inItemStart) -> None")},
+	{"HMHideTag", (PyCFunction)Help_HMHideTag, 1,
+	 PyDoc_STR("() -> None")},
 	{NULL, NULL, 0}
 };
 

Mac/Modules/menu/_Menumodule.c

@@ -120,14 +120,14 @@ static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args)
 static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
-	short _rv;
+	UInt16 _rv;
 #ifndef CountMenuItems
 	PyMac_PRECHECK(CountMenuItems);
 #endif
 	if (!PyArg_ParseTuple(_args, ""))
 		return NULL;
 	_rv = CountMenuItems(_self->ob_itself);
-	_res = Py_BuildValue("h",
+	_res = Py_BuildValue("H",
 	                     _rv);
 	return _res;
 }
@@ -1973,15 +1973,15 @@ static PyObject *MenuObj_IsMenuItemInvalid(MenuObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
 	Boolean _rv;
-	MenuItemIndex item;
+	MenuItemIndex inItem;
 #ifndef IsMenuItemInvalid
 	PyMac_PRECHECK(IsMenuItemInvalid);
 #endif
 	if (!PyArg_ParseTuple(_args, "h",
-	                      &item))
+	                      &inItem))
 		return NULL;
 	_rv = IsMenuItemInvalid(_self->ob_itself,
-	                        item);
+	                        inItem);
 	_res = Py_BuildValue("b",
 	                     _rv);
 	return _res;
@@ -1991,18 +1991,18 @@ static PyObject *MenuObj_InvalidateMenuItems(MenuObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
 	OSStatus _err;
-	MenuItemIndex firstItem;
+	MenuItemIndex inFirstItem;
-	ItemCount numItems;
+	ItemCount inNumItems;
 #ifndef InvalidateMenuItems
 	PyMac_PRECHECK(InvalidateMenuItems);
 #endif
 	if (!PyArg_ParseTuple(_args, "hl",
-	                      &firstItem,
+	                      &inFirstItem,
-	                      &numItems))
+	                      &inNumItems))
 		return NULL;
 	_err = InvalidateMenuItems(_self->ob_itself,
-	                           firstItem,
+	                           inFirstItem,
-	                           numItems);
+	                           inNumItems);
 	if (_err != noErr) return PyMac_Error(_err);
 	Py_INCREF(Py_None);
 	_res = Py_None;
@@ -2302,7 +2302,7 @@ static PyMethodDef MenuObj_methods[] = {
 	{"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
 	 PyDoc_STR("() -> None")},
 	{"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
-	 PyDoc_STR("() -> (short _rv)")},
+	 PyDoc_STR("() -> (UInt16 _rv)")},
 	{"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
 	 PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")},
 	{"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
@@ -2486,9 +2486,9 @@ static PyMethodDef MenuObj_methods[] = {
 	{"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
 	 PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
 	{"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1,
-	 PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
+	 PyDoc_STR("(MenuItemIndex inItem) -> (Boolean _rv)")},
 	{"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1,
-	 PyDoc_STR("(MenuItemIndex firstItem, ItemCount numItems) -> None")},
+	 PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")},
 	{"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1,
 	 PyDoc_STR("() -> None")},
 	{"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1,

Mac/Modules/qd/_Qdmodule.c

@@ -141,6 +141,24 @@ static PyObject *GrafObj_MacSetPort(GrafPortObject *_self, PyObject *_args)
 	return _res;
 }
 
+static PyObject *GrafObj_QDSwapPort(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	CGrafPtr outOldPort;
+#ifndef QDSwapPort
+	PyMac_PRECHECK(QDSwapPort);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = QDSwapPort(_self->ob_itself,
+	                 &outOldPort);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     GrafObj_New, outOldPort);
+	return _res;
+}
+
 static PyObject *GrafObj_IsValidPort(GrafPortObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -600,6 +618,124 @@ static PyObject *GrafObj_IsPortColor(GrafPortObject *_self, PyObject *_args)
 	return _res;
 }
 
+static PyObject *GrafObj_IsPortVisibleRegionEmpty(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+#ifndef IsPortVisibleRegionEmpty
+	PyMac_PRECHECK(IsPortVisibleRegionEmpty);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsPortVisibleRegionEmpty(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *GrafObj_IsPortClipRegionEmpty(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+#ifndef IsPortClipRegionEmpty
+	PyMac_PRECHECK(IsPortClipRegionEmpty);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = IsPortClipRegionEmpty(_self->ob_itself);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *GrafObj_SectRegionWithPortClipRegion(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RgnHandle ioRegion;
+#ifndef SectRegionWithPortClipRegion
+	PyMac_PRECHECK(SectRegionWithPortClipRegion);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &ioRegion))
+		return NULL;
+	SectRegionWithPortClipRegion(_self->ob_itself,
+	                             ioRegion);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *GrafObj_SectRegionWithPortVisibleRegion(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RgnHandle ioRegion;
+#ifndef SectRegionWithPortVisibleRegion
+	PyMac_PRECHECK(SectRegionWithPortVisibleRegion);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &ioRegion))
+		return NULL;
+	SectRegionWithPortVisibleRegion(_self->ob_itself,
+	                                ioRegion);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *GrafObj_SwapPortPicSaveHandle(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	Handle inPicSaveHdl;
+#ifndef SwapPortPicSaveHandle
+	PyMac_PRECHECK(SwapPortPicSaveHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &inPicSaveHdl))
+		return NULL;
+	_rv = SwapPortPicSaveHandle(_self->ob_itself,
+	                            inPicSaveHdl);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *GrafObj_SwapPortPolySaveHandle(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	Handle inPolySaveHdl;
+#ifndef SwapPortPolySaveHandle
+	PyMac_PRECHECK(SwapPortPolySaveHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &inPolySaveHdl))
+		return NULL;
+	_rv = SwapPortPolySaveHandle(_self->ob_itself,
+	                             inPolySaveHdl);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *GrafObj_SwapPortRegionSaveHandle(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Handle _rv;
+	Handle inRegionSaveHdl;
+#ifndef SwapPortRegionSaveHandle
+	PyMac_PRECHECK(SwapPortRegionSaveHandle);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &inRegionSaveHdl))
+		return NULL;
+	_rv = SwapPortRegionSaveHandle(_self->ob_itself,
+	                               inRegionSaveHdl);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
 static PyObject *GrafObj_SetPortBounds(GrafPortObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -634,6 +770,74 @@ static PyObject *GrafObj_SetPortOpColor(GrafPortObject *_self, PyObject *_args)
 	return _res;
 }
 
+static PyObject *GrafObj_SetPortTextFont(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short txFont;
+#ifndef SetPortTextFont
+	PyMac_PRECHECK(SetPortTextFont);
+#endif
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &txFont))
+		return NULL;
+	SetPortTextFont(_self->ob_itself,
+	                txFont);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *GrafObj_SetPortTextSize(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short txSize;
+#ifndef SetPortTextSize
+	PyMac_PRECHECK(SetPortTextSize);
+#endif
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &txSize))
+		return NULL;
+	SetPortTextSize(_self->ob_itself,
+	                txSize);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *GrafObj_SetPortTextFace(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	StyleParameter face;
+#ifndef SetPortTextFace
+	PyMac_PRECHECK(SetPortTextFace);
+#endif
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &face))
+		return NULL;
+	SetPortTextFace(_self->ob_itself,
+	                face);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *GrafObj_SetPortTextMode(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	short mode;
+#ifndef SetPortTextMode
+	PyMac_PRECHECK(SetPortTextMode);
+#endif
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &mode))
+		return NULL;
+	SetPortTextMode(_self->ob_itself,
+	                mode);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *GrafObj_SetPortVisibleRegion(GrafPortObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -784,6 +988,108 @@ static PyObject *GrafObj_DisposePort(GrafPortObject *_self, PyObject *_args)
 	return _res;
 }
 
+static PyObject *GrafObj_QDLocalToGlobalPoint(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Point point;
+#ifndef QDLocalToGlobalPoint
+	PyMac_PRECHECK(QDLocalToGlobalPoint);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &point))
+		return NULL;
+	QDLocalToGlobalPoint(_self->ob_itself,
+	                     &point);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, point);
+	return _res;
+}
+
+static PyObject *GrafObj_QDGlobalToLocalPoint(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Point point;
+#ifndef QDGlobalToLocalPoint
+	PyMac_PRECHECK(QDGlobalToLocalPoint);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &point))
+		return NULL;
+	QDGlobalToLocalPoint(_self->ob_itself,
+	                     &point);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, point);
+	return _res;
+}
+
+static PyObject *GrafObj_QDLocalToGlobalRect(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Rect bounds;
+#ifndef QDLocalToGlobalRect
+	PyMac_PRECHECK(QDLocalToGlobalRect);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	QDLocalToGlobalRect(_self->ob_itself,
+	                    &bounds);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &bounds);
+	return _res;
+}
+
+static PyObject *GrafObj_QDGlobalToLocalRect(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	Rect bounds;
+#ifndef QDGlobalToLocalRect
+	PyMac_PRECHECK(QDGlobalToLocalRect);
+#endif
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	QDGlobalToLocalRect(_self->ob_itself,
+	                    &bounds);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &bounds);
+	return _res;
+}
+
+static PyObject *GrafObj_QDLocalToGlobalRegion(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RgnHandle _rv;
+	RgnHandle region;
+#ifndef QDLocalToGlobalRegion
+	PyMac_PRECHECK(QDLocalToGlobalRegion);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &region))
+		return NULL;
+	_rv = QDLocalToGlobalRegion(_self->ob_itself,
+	                            region);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *GrafObj_QDGlobalToLocalRegion(GrafPortObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	RgnHandle _rv;
+	RgnHandle region;
+#ifndef QDGlobalToLocalRegion
+	PyMac_PRECHECK(QDGlobalToLocalRegion);
+#endif
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &region))
+		return NULL;
+	_rv = QDGlobalToLocalRegion(_self->ob_itself,
+	                            region);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
 static PyObject *GrafObj_QDIsPortBuffered(GrafPortObject *_self, PyObject *_args)
 {
 	PyObject *_res = NULL;
@@ -872,6 +1178,8 @@ static PyObject *GrafObj_QDSetDirtyRegion(GrafPortObject *_self, PyObject *_args
 static PyMethodDef GrafObj_methods[] = {
 	{"MacSetPort", (PyCFunction)GrafObj_MacSetPort, 1,
 	 PyDoc_STR("() -> None")},
+	{"QDSwapPort", (PyCFunction)GrafObj_QDSwapPort, 1,
+	 PyDoc_STR("() -> (Boolean _rv, CGrafPtr outOldPort)")},
 	{"IsValidPort", (PyCFunction)GrafObj_IsValidPort, 1,
 	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"GetPortPixMap", (PyCFunction)GrafObj_GetPortPixMap, 1,
@@ -930,10 +1238,32 @@ static PyMethodDef GrafObj_methods[] = {
 	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"IsPortColor", (PyCFunction)GrafObj_IsPortColor, 1,
 	 PyDoc_STR("() -> (Boolean _rv)")},
+	{"IsPortVisibleRegionEmpty", (PyCFunction)GrafObj_IsPortVisibleRegionEmpty, 1,
+	 PyDoc_STR("() -> (Boolean _rv)")},
+	{"IsPortClipRegionEmpty", (PyCFunction)GrafObj_IsPortClipRegionEmpty, 1,
+	 PyDoc_STR("() -> (Boolean _rv)")},
+	{"SectRegionWithPortClipRegion", (PyCFunction)GrafObj_SectRegionWithPortClipRegion, 1,
+	 PyDoc_STR("(RgnHandle ioRegion) -> None")},
+	{"SectRegionWithPortVisibleRegion", (PyCFunction)GrafObj_SectRegionWithPortVisibleRegion, 1,
+	 PyDoc_STR("(RgnHandle ioRegion) -> None")},
+	{"SwapPortPicSaveHandle", (PyCFunction)GrafObj_SwapPortPicSaveHandle, 1,
+	 PyDoc_STR("(Handle inPicSaveHdl) -> (Handle _rv)")},
+	{"SwapPortPolySaveHandle", (PyCFunction)GrafObj_SwapPortPolySaveHandle, 1,
+	 PyDoc_STR("(Handle inPolySaveHdl) -> (Handle _rv)")},
+	{"SwapPortRegionSaveHandle", (PyCFunction)GrafObj_SwapPortRegionSaveHandle, 1,
+	 PyDoc_STR("(Handle inRegionSaveHdl) -> (Handle _rv)")},
 	{"SetPortBounds", (PyCFunction)GrafObj_SetPortBounds, 1,
 	 PyDoc_STR("(Rect rect) -> None")},
 	{"SetPortOpColor", (PyCFunction)GrafObj_SetPortOpColor, 1,
 	 PyDoc_STR("(RGBColor opColor) -> None")},
+	{"SetPortTextFont", (PyCFunction)GrafObj_SetPortTextFont, 1,
+	 PyDoc_STR("(short txFont) -> None")},
+	{"SetPortTextSize", (PyCFunction)GrafObj_SetPortTextSize, 1,
+	 PyDoc_STR("(short txSize) -> None")},
+	{"SetPortTextFace", (PyCFunction)GrafObj_SetPortTextFace, 1,
+	 PyDoc_STR("(StyleParameter face) -> None")},
+	{"SetPortTextMode", (PyCFunction)GrafObj_SetPortTextMode, 1,
+	 PyDoc_STR("(short mode) -> None")},
 	{"SetPortVisibleRegion", (PyCFunction)GrafObj_SetPortVisibleRegion, 1,
 	 PyDoc_STR("(RgnHandle visRgn) -> None")},
 	{"SetPortClipRegion", (PyCFunction)GrafObj_SetPortClipRegion, 1,
@@ -952,6 +1282,18 @@ static PyMethodDef GrafObj_methods[] = {
 	 PyDoc_STR("(short pnLocHFrac) -> None")},
 	{"DisposePort", (PyCFunction)GrafObj_DisposePort, 1,
 	 PyDoc_STR("() -> None")},
+	{"QDLocalToGlobalPoint", (PyCFunction)GrafObj_QDLocalToGlobalPoint, 1,
+	 PyDoc_STR("(Point point) -> (Point point)")},
+	{"QDGlobalToLocalPoint", (PyCFunction)GrafObj_QDGlobalToLocalPoint, 1,
+	 PyDoc_STR("(Point point) -> (Point point)")},
+	{"QDLocalToGlobalRect", (PyCFunction)GrafObj_QDLocalToGlobalRect, 1,
+	 PyDoc_STR("() -> (Rect bounds)")},
+	{"QDGlobalToLocalRect", (PyCFunction)GrafObj_QDGlobalToLocalRect, 1,
+	 PyDoc_STR("() -> (Rect bounds)")},
+	{"QDLocalToGlobalRegion", (PyCFunction)GrafObj_QDLocalToGlobalRegion, 1,
+	 PyDoc_STR("(RgnHandle region) -> (RgnHandle _rv)")},
+	{"QDGlobalToLocalRegion", (PyCFunction)GrafObj_QDGlobalToLocalRegion, 1,
+	 PyDoc_STR("(RgnHandle region) -> (RgnHandle _rv)")},
 	{"QDIsPortBuffered", (PyCFunction)GrafObj_QDIsPortBuffered, 1,
 	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"QDIsPortBufferDirty", (PyCFunction)GrafObj_QDIsPortBufferDirty, 1,

Mac/Modules/qd/qdscan.py

@@ -120,6 +120,7 @@ extend						= 0x40
 
 	def makeblacklisttypes(self):
 		return [
+			"QDRegionBitsRef", # Should do this, but too lazy now.
 			'CIconHandle', # Obsolete
 			'CQDProcs',
 			'CQDProcsPtr',
@@ -216,6 +217,18 @@ extend						= 0x40
 			 ([('Pattern_ptr', '*', 'ReturnMode')],
 			  [('void', '*', 'ReturnMode')]),
 			
+			 ([('Point_ptr', 'QDLocalToGlobalPoint', 'ReturnMode')],
+			  [('void', '*', 'ReturnMode')]),
+			
+			 ([('Rect_ptr', 'QDLocalToGlobalRect', 'ReturnMode')],
+			  [('void', '*', 'ReturnMode')]),
+			
+			 ([('Point_ptr', 'QDGlobalToLocalPoint', 'ReturnMode')],
+			  [('void', '*', 'ReturnMode')]),
+			
+			 ([('Rect_ptr', 'QDGlobalToLocalRect', 'ReturnMode')],
+			  [('void', '*', 'ReturnMode')]),
+			
 			]
 
 if __name__ == "__main__":