Finished update to UH 3.4.2.

diff --git a/Mac/Modules/carbonevt/_CarbonEvtmodule.c b/Mac/Modules/carbonevt/_CarbonEvtmodule.c
index 097f11a6a2f25a4ce59258d0c91df9d5625e4ee4..560b470c8069a2f1155c29669d3927ba6178fac1 100755 (executable)
--- a/Mac/Modules/carbonevt/_CarbonEvtmodule.c
+++ b/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,

diff --git a/Mac/Modules/help/_Helpmodule.c b/Mac/Modules/help/_Helpmodule.c
index 0da66cc0dd9e7d88559fa2840d6b52c897eb9412..b9c9599f2a6da72c7ff277a54dc5ec033b9dfd23 100644 (file)
--- a/Mac/Modules/help/_Helpmodule.c
+++ b/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}
 };
 

diff --git a/Mac/Modules/menu/_Menumodule.c b/Mac/Modules/menu/_Menumodule.c
index feb9bd26cccd7d3ed7c54c39354ea2dbe4071e97..8596a9d9d8462637c746784a92e02d570e3bb9c2 100644 (file)
--- a/Mac/Modules/menu/_Menumodule.c
+++ b/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;
-       ItemCount numItems;
+       MenuItemIndex inFirstItem;
+       ItemCount inNumItems;
 #ifndef InvalidateMenuItems
        PyMac_PRECHECK(InvalidateMenuItems);
 #endif
        if (!PyArg_ParseTuple(_args, "hl",
-                             &firstItem,
-                             &numItems))
+                             &inFirstItem,
+                             &inNumItems))
                return NULL;
        _err = InvalidateMenuItems(_self->ob_itself,
-                                  firstItem,
-                                  numItems);
+                                  inFirstItem,
+                                  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,

diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c
index 793c9721be2f863a9c7ffefcaa48e949a015a940..86db3c76059692ef901e7c701aa5131c84b08494 100644 (file)
--- a/Mac/Modules/qd/_Qdmodule.c
+++ b/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,

diff --git a/Mac/Modules/qd/qdscan.py b/Mac/Modules/qd/qdscan.py
index 2c54c3fc56d7221339d6c310b786290e1546933e..f58bb225aacb2595a203388db7bbf1f1aca70be4 100644 (file)
--- a/Mac/Modules/qd/qdscan.py
+++ b/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__":