Regenerated with PyDoc_STR() around docstrings.

1 files changed, 315 insertions, 315 deletions

diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c
index f7956b8..1084031 100644
--- a/Mac/Modules/qd/_Qdmodule.c
+++ b/Mac/Modules/qd/_Qdmodule.c
@@ -470,9 +470,9 @@ static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args)
 
 static PyMethodDef BMObj_methods[] = {
 	{"getdata", (PyCFunction)BMObj_getdata, 1,
-	 "(int start, int size) -> string. Return bytes from the bitmap"},
+	 PyDoc_STR("(int start, int size) -> string. Return bytes from the bitmap")},
 	{"putdata", (PyCFunction)BMObj_putdata, 1,
-	 "(int start, string data). Store bytes into the bitmap"},
+	 PyDoc_STR("(int start, string data). Store bytes into the bitmap")},
 	{NULL, NULL, 0}
 };
 
@@ -6462,664 +6462,664 @@ static PyObject *Qd_RawBitMap(PyObject *_self, PyObject *_args)
 
 static PyMethodDef Qd_methods[] = {
 	{"MacSetPort", (PyCFunction)Qd_MacSetPort, 1,
-	 "(GrafPtr port) -> None"},
+	 PyDoc_STR("(GrafPtr port) -> None")},
 	{"GetPort", (PyCFunction)Qd_GetPort, 1,
-	 "() -> (GrafPtr port)"},
+	 PyDoc_STR("() -> (GrafPtr port)")},
 	{"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
-	 "(short device) -> None"},
+	 PyDoc_STR("(short device) -> None")},
 	{"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
-	 "(BitMapPtr bm) -> None"},
+	 PyDoc_STR("(BitMapPtr bm) -> None")},
 	{"PortSize", (PyCFunction)Qd_PortSize, 1,
-	 "(short width, short height) -> None"},
+	 PyDoc_STR("(short width, short height) -> None")},
 	{"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
-	 "(short leftGlobal, short topGlobal) -> None"},
+	 PyDoc_STR("(short leftGlobal, short topGlobal) -> None")},
 	{"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"SetClip", (PyCFunction)Qd_SetClip, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"GetClip", (PyCFunction)Qd_GetClip, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"ClipRect", (PyCFunction)Qd_ClipRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"BackPat", (PyCFunction)Qd_BackPat, 1,
-	 "(Pattern pat) -> None"},
+	 PyDoc_STR("(Pattern pat) -> None")},
 	{"InitCursor", (PyCFunction)Qd_InitCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1,
-	 "(Cursor crsr) -> None"},
+	 PyDoc_STR("(Cursor crsr) -> None")},
 	{"HideCursor", (PyCFunction)Qd_HideCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"HidePen", (PyCFunction)Qd_HidePen, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ShowPen", (PyCFunction)Qd_ShowPen, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetPen", (PyCFunction)Qd_GetPen, 1,
-	 "() -> (Point pt)"},
+	 PyDoc_STR("() -> (Point pt)")},
 	{"GetPenState", (PyCFunction)Qd_GetPenState, 1,
-	 "() -> (PenState pnState)"},
+	 PyDoc_STR("() -> (PenState pnState)")},
 	{"SetPenState", (PyCFunction)Qd_SetPenState, 1,
-	 "(PenState pnState) -> None"},
+	 PyDoc_STR("(PenState pnState) -> None")},
 	{"PenSize", (PyCFunction)Qd_PenSize, 1,
-	 "(short width, short height) -> None"},
+	 PyDoc_STR("(short width, short height) -> None")},
 	{"PenMode", (PyCFunction)Qd_PenMode, 1,
-	 "(short mode) -> None"},
+	 PyDoc_STR("(short mode) -> None")},
 	{"PenPat", (PyCFunction)Qd_PenPat, 1,
-	 "(Pattern pat) -> None"},
+	 PyDoc_STR("(Pattern pat) -> None")},
 	{"PenNormal", (PyCFunction)Qd_PenNormal, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"MoveTo", (PyCFunction)Qd_MoveTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"Move", (PyCFunction)Qd_Move, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"MacLineTo", (PyCFunction)Qd_MacLineTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"Line", (PyCFunction)Qd_Line, 1,
-	 "(short dh, short dv) -> None"},
+	 PyDoc_STR("(short dh, short dv) -> None")},
 	{"ForeColor", (PyCFunction)Qd_ForeColor, 1,
-	 "(long color) -> None"},
+	 PyDoc_STR("(long color) -> None")},
 	{"BackColor", (PyCFunction)Qd_BackColor, 1,
-	 "(long color) -> None"},
+	 PyDoc_STR("(long color) -> None")},
 	{"ColorBit", (PyCFunction)Qd_ColorBit, 1,
-	 "(short whichBit) -> None"},
+	 PyDoc_STR("(short whichBit) -> None")},
 	{"MacSetRect", (PyCFunction)Qd_MacSetRect, 1,
-	 "(short left, short top, short right, short bottom) -> (Rect r)"},
+	 PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
 	{"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"SectRect", (PyCFunction)Qd_SectRect, 1,
-	 "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)")},
 	{"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1,
-	 "(Rect src1, Rect src2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
 	{"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1,
-	 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
 	{"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
-	 "(Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect r) -> (Boolean _rv)")},
 	{"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"PaintRect", (PyCFunction)Qd_PaintRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"EraseRect", (PyCFunction)Qd_EraseRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"MacFillRect", (PyCFunction)Qd_MacFillRect, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"FrameOval", (PyCFunction)Qd_FrameOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"PaintOval", (PyCFunction)Qd_PaintOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"EraseOval", (PyCFunction)Qd_EraseOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"InvertOval", (PyCFunction)Qd_InvertOval, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"FillOval", (PyCFunction)Qd_FillOval, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
 	{"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None")},
 	{"FrameArc", (PyCFunction)Qd_FrameArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"PaintArc", (PyCFunction)Qd_PaintArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"EraseArc", (PyCFunction)Qd_EraseArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"InvertArc", (PyCFunction)Qd_InvertArc, 1,
-	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
 	{"FillArc", (PyCFunction)Qd_FillArc, 1,
-	 "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle, Pattern pat) -> None")},
 	{"NewRgn", (PyCFunction)Qd_NewRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
-	 "(RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle dstRgn) -> None")},
 	{"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
-	 "(RgnHandle region, BitMapPtr bMap) -> None"},
+	 PyDoc_STR("(RgnHandle region, BitMapPtr bMap) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1,
-	 "(RgnHandle region, Handle flattenedRgnDataHdl) -> None"},
+	 PyDoc_STR("(RgnHandle region, Handle flattenedRgnDataHdl) -> None")},
 #endif
 	{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
-	 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
 	{"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1,
-	 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
 	{"RectRgn", (PyCFunction)Qd_RectRgn, 1,
-	 "(RgnHandle rgn, Rect r) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Rect r) -> None")},
 	{"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"SectRgn", (PyCFunction)Qd_SectRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
-	 "(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect r, RgnHandle rgn) -> (Boolean _rv)")},
 	{"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1,
-	 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
 	{"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
-	 "(RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgn) -> (Boolean _rv)")},
 	{"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1,
-	 "(RgnHandle rgn, Pattern pat) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
 	{"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
-	 "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
+	 PyDoc_STR("(Rect r, short dh, short dv, RgnHandle updateRgn) -> None")},
 	{"CopyBits", (PyCFunction)Qd_CopyBits, 1,
-	 "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"CopyMask", (PyCFunction)Qd_CopyMask, 1,
-	 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None")},
 	{"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
-	 "(Rect picFrame) -> (PicHandle _rv)"},
+	 PyDoc_STR("(Rect picFrame) -> (PicHandle _rv)")},
 	{"PicComment", (PyCFunction)Qd_PicComment, 1,
-	 "(short kind, short dataSize, Handle dataHandle) -> None"},
+	 PyDoc_STR("(short kind, short dataSize, Handle dataHandle) -> None")},
 	{"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
-	 "(PicHandle myPicture, Rect dstRect) -> None"},
+	 PyDoc_STR("(PicHandle myPicture, Rect dstRect) -> None")},
 	{"KillPicture", (PyCFunction)Qd_KillPicture, 1,
-	 "(PicHandle myPicture) -> None"},
+	 PyDoc_STR("(PicHandle myPicture) -> None")},
 	{"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
-	 "() -> (PolyHandle _rv)"},
+	 PyDoc_STR("() -> (PolyHandle _rv)")},
 	{"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"KillPoly", (PyCFunction)Qd_KillPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
-	 "(PolyHandle poly, short dh, short dv) -> None"},
+	 PyDoc_STR("(PolyHandle poly, short dh, short dv) -> None")},
 	{"FramePoly", (PyCFunction)Qd_FramePoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
-	 "(PolyHandle poly) -> None"},
+	 PyDoc_STR("(PolyHandle poly) -> None")},
 	{"FillPoly", (PyCFunction)Qd_FillPoly, 1,
-	 "(PolyHandle poly, Pattern pat) -> None"},
+	 PyDoc_STR("(PolyHandle poly, Pattern pat) -> None")},
 	{"SetPt", (PyCFunction)Qd_SetPt, 1,
-	 "(short h, short v) -> (Point pt)"},
+	 PyDoc_STR("(short h, short v) -> (Point pt)")},
 	{"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
-	 "(Point pt) -> (Point pt)"},
+	 PyDoc_STR("(Point pt) -> (Point pt)")},
 	{"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
-	 "(Point pt) -> (Point pt)"},
+	 PyDoc_STR("(Point pt) -> (Point pt)")},
 	{"Random", (PyCFunction)Qd_Random, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1,
-	 "(short h, short v) -> (Boolean _rv)"},
+	 PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
 	{"ScalePt", (PyCFunction)Qd_ScalePt, 1,
-	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	 PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
 	{"MapPt", (PyCFunction)Qd_MapPt, 1,
-	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	 PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
 	{"MapRect", (PyCFunction)Qd_MapRect, 1,
-	 "(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)")},
 	{"MapRgn", (PyCFunction)Qd_MapRgn, 1,
-	 "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None")},
 	{"MapPoly", (PyCFunction)Qd_MapPoly, 1,
-	 "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
+	 PyDoc_STR("(PolyHandle poly, Rect srcRect, Rect dstRect) -> None")},
 	{"StdBits", (PyCFunction)Qd_StdBits, 1,
-	 "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"AddPt", (PyCFunction)Qd_AddPt, 1,
-	 "(Point src, Point dst) -> (Point dst)"},
+	 PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
 	{"EqualPt", (PyCFunction)Qd_EqualPt, 1,
-	 "(Point pt1, Point pt2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt1, Point pt2) -> (Boolean _rv)")},
 	{"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1,
-	 "(Point pt, Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
 	{"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
-	 "(Point pt1, Point pt2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Point pt1, Point pt2) -> (Rect dstRect)")},
 	{"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
-	 "(Rect r, Point pt) -> (short angle)"},
+	 PyDoc_STR("(Rect r, Point pt) -> (short angle)")},
 	{"SubPt", (PyCFunction)Qd_SubPt, 1,
-	 "(Point src, Point dst) -> (Point dst)"},
+	 PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
 	{"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
-	 "(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, RgnHandle rgn) -> (Boolean _rv)")},
 	{"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
-	 "() -> (PixMapHandle _rv)"},
+	 PyDoc_STR("() -> (PixMapHandle _rv)")},
 	{"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
-	 "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
+	 PyDoc_STR("(PixMapHandle srcPM, PixMapHandle dstPM) -> None")},
 	{"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
-	 "() -> (PixPatHandle _rv)"},
+	 PyDoc_STR("() -> (PixPatHandle _rv)")},
 	{"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
-	 "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
+	 PyDoc_STR("(PixPatHandle srcPP, PixPatHandle dstPP) -> None")},
 	{"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
-	 "(PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PixPatHandle pp) -> None")},
 	{"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
-	 "(short patID) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(short patID) -> (PixPatHandle _rv)")},
 	{"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1,
-	 "(PixPatHandle pp, RGBColor myColor) -> None"},
+	 PyDoc_STR("(PixPatHandle pp, RGBColor myColor) -> None")},
 	{"FillCRect", (PyCFunction)Qd_FillCRect, 1,
-	 "(Rect r, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
 	{"FillCOval", (PyCFunction)Qd_FillCOval, 1,
-	 "(Rect r, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
 	{"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
-	 "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None")},
 	{"FillCArc", (PyCFunction)Qd_FillCArc, 1,
-	 "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None")},
 	{"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
-	 "(RgnHandle rgn, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, PixPatHandle pp) -> None")},
 	{"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
-	 "(PolyHandle poly, PixPatHandle pp) -> None"},
+	 PyDoc_STR("(PolyHandle poly, PixPatHandle pp) -> None")},
 	{"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"SetCPixel", (PyCFunction)Qd_SetCPixel, 1,
-	 "(short h, short v, RGBColor cPix) -> None"},
+	 PyDoc_STR("(short h, short v, RGBColor cPix) -> None")},
 	{"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
-	 "(PixMapHandle pm) -> None"},
+	 PyDoc_STR("(PixMapHandle pm) -> None")},
 	{"GetCPixel", (PyCFunction)Qd_GetCPixel, 1,
-	 "(short h, short v) -> (RGBColor cPix)"},
+	 PyDoc_STR("(short h, short v) -> (RGBColor cPix)")},
 	{"GetForeColor", (PyCFunction)Qd_GetForeColor, 1,
-	 "() -> (RGBColor color)"},
+	 PyDoc_STR("() -> (RGBColor color)")},
 	{"GetBackColor", (PyCFunction)Qd_GetBackColor, 1,
-	 "() -> (RGBColor color)"},
+	 PyDoc_STR("() -> (RGBColor color)")},
 	{"OpColor", (PyCFunction)Qd_OpColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"HiliteColor", (PyCFunction)Qd_HiliteColor, 1,
-	 "(RGBColor color) -> None"},
+	 PyDoc_STR("(RGBColor color) -> None")},
 	{"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1,
-	 "(CTabHandle cTable) -> None"},
+	 PyDoc_STR("(CTabHandle cTable) -> None")},
 	{"GetCTable", (PyCFunction)Qd_GetCTable, 1,
-	 "(short ctID) -> (CTabHandle _rv)"},
+	 PyDoc_STR("(short ctID) -> (CTabHandle _rv)")},
 	{"GetCCursor", (PyCFunction)Qd_GetCCursor, 1,
-	 "(short crsrID) -> (CCrsrHandle _rv)"},
+	 PyDoc_STR("(short crsrID) -> (CCrsrHandle _rv)")},
 	{"SetCCursor", (PyCFunction)Qd_SetCCursor, 1,
-	 "(CCrsrHandle cCrsr) -> None"},
+	 PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
 	{"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1,
-	 "(CCrsrHandle cCrsr) -> None"},
+	 PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
 	{"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1,
-	 "(Rect globalRect) -> (GDHandle _rv)"},
+	 PyDoc_STR("(Rect globalRect) -> (GDHandle _rv)")},
 	{"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1,
-	 "(GDHandle curDevice) -> (GDHandle _rv)"},
+	 PyDoc_STR("(GDHandle curDevice) -> (GDHandle _rv)")},
 	{"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1,
-	 "(GDHandle gdh, short attribute) -> (Boolean _rv)"},
+	 PyDoc_STR("(GDHandle gdh, short attribute) -> (Boolean _rv)")},
 	{"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1,
-	 "(GDHandle gdh, short attribute, Boolean value) -> None"},
+	 PyDoc_STR("(GDHandle gdh, short attribute, Boolean value) -> None")},
 	{"InitGDevice", (PyCFunction)Qd_InitGDevice, 1,
-	 "(short qdRefNum, long mode, GDHandle gdh) -> None"},
+	 PyDoc_STR("(short qdRefNum, long mode, GDHandle gdh) -> None")},
 	{"NewGDevice", (PyCFunction)Qd_NewGDevice, 1,
-	 "(short refNum, long mode) -> (GDHandle _rv)"},
+	 PyDoc_STR("(short refNum, long mode) -> (GDHandle _rv)")},
 	{"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1,
-	 "(GDHandle gdh) -> None"},
+	 PyDoc_STR("(GDHandle gdh) -> None")},
 	{"SetGDevice", (PyCFunction)Qd_SetGDevice, 1,
-	 "(GDHandle gd) -> None"},
+	 PyDoc_STR("(GDHandle gd) -> None")},
 	{"GetGDevice", (PyCFunction)Qd_GetGDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"Color2Index", (PyCFunction)Qd_Color2Index, 1,
-	 "(RGBColor myColor) -> (long _rv)"},
+	 PyDoc_STR("(RGBColor myColor) -> (long _rv)")},
 	{"Index2Color", (PyCFunction)Qd_Index2Color, 1,
-	 "(long index) -> (RGBColor aColor)"},
+	 PyDoc_STR("(long index) -> (RGBColor aColor)")},
 	{"InvertColor", (PyCFunction)Qd_InvertColor, 1,
-	 "() -> (RGBColor myColor)"},
+	 PyDoc_STR("() -> (RGBColor myColor)")},
 	{"RealColor", (PyCFunction)Qd_RealColor, 1,
-	 "(RGBColor color) -> (Boolean _rv)"},
+	 PyDoc_STR("(RGBColor color) -> (Boolean _rv)")},
 	{"GetSubTable", (PyCFunction)Qd_GetSubTable, 1,
-	 "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"},
+	 PyDoc_STR("(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None")},
 	{"MakeITable", (PyCFunction)Qd_MakeITable, 1,
-	 "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"},
+	 PyDoc_STR("(CTabHandle cTabH, ITabHandle iTabH, short res) -> None")},
 	{"SetClientID", (PyCFunction)Qd_SetClientID, 1,
-	 "(short id) -> None"},
+	 PyDoc_STR("(short id) -> None")},
 	{"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
-	 "(short index, Boolean protect) -> None"},
+	 PyDoc_STR("(short index, Boolean protect) -> None")},
 	{"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
-	 "(short index, Boolean reserve) -> None"},
+	 PyDoc_STR("(short index, Boolean reserve) -> None")},
 	{"QDError", (PyCFunction)Qd_QDError, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
-	 "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+	 PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
 	{"GetPattern", (PyCFunction)Qd_GetPattern, 1,
-	 "(short patternID) -> (PatHandle _rv)"},
+	 PyDoc_STR("(short patternID) -> (PatHandle _rv)")},
 	{"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1,
-	 "(short cursorID) -> (CursHandle _rv)"},
+	 PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
 	{"GetPicture", (PyCFunction)Qd_GetPicture, 1,
-	 "(short pictureID) -> (PicHandle _rv)"},
+	 PyDoc_STR("(short pictureID) -> (PicHandle _rv)")},
 	{"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1,
-	 "(Point ptA, Point ptB) -> (long _rv)"},
+	 PyDoc_STR("(Point ptA, Point ptB) -> (long _rv)")},
 	{"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1,
-	 "(Rect shieldRect, Point offsetPt) -> None"},
+	 PyDoc_STR("(Rect shieldRect, Point offsetPt) -> None")},
 	{"ScreenRes", (PyCFunction)Qd_ScreenRes, 1,
-	 "() -> (short scrnHRes, short scrnVRes)"},
+	 PyDoc_STR("() -> (short scrnHRes, short scrnVRes)")},
 	{"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
-	 "(short patternListID, short index) -> (Pattern thePat)"},
+	 PyDoc_STR("(short patternListID, short index) -> (Pattern thePat)")},
 	{"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
-	 "(short angle) -> (Fixed _rv)"},
+	 PyDoc_STR("(short angle) -> (Fixed _rv)")},
 	{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
-	 "(Fixed slope) -> (short _rv)"},
+	 PyDoc_STR("(Fixed slope) -> (short _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsValidPort", (PyCFunction)Qd_IsValidPort, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 	{"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
-	 "(CGrafPtr port) -> (PixMapHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (PixMapHandle _rv)")},
 	{"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
-	 "(CGrafPtr port) -> (const BitMap * _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (const BitMap * _rv)")},
 	{"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1,
-	 "(CGrafPtr port) -> (Rect rect)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Rect rect)")},
 	{"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1,
-	 "(CGrafPtr port) -> (RGBColor foreColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor foreColor)")},
 	{"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1,
-	 "(CGrafPtr port) -> (RGBColor backColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor backColor)")},
 	{"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1,
-	 "(CGrafPtr port) -> (RGBColor opColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor opColor)")},
 	{"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1,
-	 "(CGrafPtr port) -> (RGBColor hiliteColor)"},
+	 PyDoc_STR("(CGrafPtr port) -> (RGBColor hiliteColor)")},
 	{"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1,
-	 "(CGrafPtr port) -> (Style _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Style _rv)")},
 	{"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1,
-	 "(CGrafPtr port) -> (Fixed _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Fixed _rv)")},
 	{"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1,
-	 "(CGrafPtr port) -> (short _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
 	{"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1,
-	 "(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)")},
 	{"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1,
-	 "(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)")},
 	{"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)")},
 	{"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)")},
 	{"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)")},
 	{"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1,
-	 "(CGrafPtr port, Point penSize) -> (Point penSize)"},
+	 PyDoc_STR("(CGrafPtr port, Point penSize) -> (Point penSize)")},
 	{"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1,
-	 "(CGrafPtr port) -> (SInt32 _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (SInt32 _rv)")},
 	{"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1,
-	 "(CGrafPtr port, Point penLocation) -> (Point penLocation)"},
+	 PyDoc_STR("(CGrafPtr port, Point penLocation) -> (Point penLocation)")},
 	{"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"IsPortColor", (PyCFunction)Qd_IsPortColor, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 #endif
 	{"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1,
-	 "(CGrafPtr port, Rect rect) -> None"},
+	 PyDoc_STR("(CGrafPtr port, Rect rect) -> None")},
 	{"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1,
-	 "(CGrafPtr port, RGBColor opColor) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RGBColor opColor) -> None")},
 	{"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1,
-	 "(CGrafPtr port, RgnHandle visRgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> None")},
 	{"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1,
-	 "(CGrafPtr port, RgnHandle clipRgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> None")},
 	{"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
 	{"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle penPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
 	{"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
-	 "(CGrafPtr port, PixPatHandle backPattern) -> None"},
+	 PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> None")},
 	{"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
-	 "(CGrafPtr port, Point penSize) -> None"},
+	 PyDoc_STR("(CGrafPtr port, Point penSize) -> None")},
 	{"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1,
-	 "(CGrafPtr port, SInt32 penMode) -> None"},
+	 PyDoc_STR("(CGrafPtr port, SInt32 penMode) -> None")},
 	{"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1,
-	 "(CGrafPtr port, short pnLocHFrac) -> None"},
+	 PyDoc_STR("(CGrafPtr port, short pnLocHFrac) -> None")},
 	{"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1,
-	 "(PixMapHandle pixMap) -> (Rect bounds)"},
+	 PyDoc_STR("(PixMapHandle pixMap) -> (Rect bounds)")},
 	{"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1,
-	 "(PixMapHandle pixMap) -> (short _rv)"},
+	 PyDoc_STR("(PixMapHandle pixMap) -> (short _rv)")},
 	{"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1,
-	 "() -> (BitMap screenBits)"},
+	 PyDoc_STR("() -> (BitMap screenBits)")},
 	{"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1,
-	 "() -> (Cursor arrow)"},
+	 PyDoc_STR("() -> (Cursor arrow)")},
 	{"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1,
-	 "() -> (Pattern dkGray)"},
+	 PyDoc_STR("() -> (Pattern dkGray)")},
 	{"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1,
-	 "() -> (Pattern ltGray)"},
+	 PyDoc_STR("() -> (Pattern ltGray)")},
 	{"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1,
-	 "() -> (Pattern gray)"},
+	 PyDoc_STR("() -> (Pattern gray)")},
 	{"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1,
-	 "() -> (Pattern black)"},
+	 PyDoc_STR("() -> (Pattern black)")},
 	{"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1,
-	 "() -> (Pattern white)"},
+	 PyDoc_STR("() -> (Pattern white)")},
 	{"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1,
-	 "(long randomSeed) -> None"},
+	 PyDoc_STR("(long randomSeed) -> None")},
 	{"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1,
-	 "(Cursor arrow) -> None"},
+	 PyDoc_STR("(Cursor arrow) -> None")},
 	{"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1,
-	 "(RgnHandle region) -> (Rect bounds)"},
+	 PyDoc_STR("(RgnHandle region) -> (Rect bounds)")},
 
 #if TARGET_API_MAC_CARBON
 	{"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1,
-	 "(RgnHandle region) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle region) -> (Boolean _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"DisposePort", (PyCFunction)Qd_DisposePort, 1,
-	 "(CGrafPtr port) -> None"},
+	 PyDoc_STR("(CGrafPtr port) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"SetQDError", (PyCFunction)Qd_SetQDError, 1,
-	 "(OSErr err) -> None"},
+	 PyDoc_STR("(OSErr err) -> None")},
 #endif
 	{"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1,
-	 "(CGrafPtr port) -> (Boolean _rv)"},
+	 PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
 	{"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
-	 "(CGrafPtr port, RgnHandle region) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle region) -> None")},
 
 #if TARGET_API_MAC_CARBON
 	{"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1,
-	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
 #endif
 
 #if TARGET_API_MAC_CARBON
 	{"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1,
-	 "(CGrafPtr port, RgnHandle rgn) -> None"},
+	 PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
 #endif
 	{"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1,
-	 "() -> (SInt16 _rv)"},
+	 PyDoc_STR("() -> (SInt16 _rv)")},
 	{"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1,
-	 "(SInt16 value) -> None"},
+	 PyDoc_STR("(SInt16 value) -> None")},
 	{"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1,
-	 "() -> (SInt32 _rv)"},
+	 PyDoc_STR("() -> (SInt32 _rv)")},
 	{"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1,
-	 "(SInt32 value) -> None"},
+	 PyDoc_STR("(SInt32 value) -> None")},
 	{"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1,
-	 "() -> (Handle _rv)"},
+	 PyDoc_STR("() -> (Handle _rv)")},
 	{"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1,
-	 "(Handle value) -> None"},
+	 PyDoc_STR("(Handle value) -> None")},
 	{"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1,
-	 "() -> (UInt8 _rv)"},
+	 PyDoc_STR("() -> (UInt8 _rv)")},
 	{"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1,
-	 "(UInt8 value) -> None"},
+	 PyDoc_STR("(UInt8 value) -> None")},
 	{"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1,
-	 "() -> (GDHandle _rv)"},
+	 PyDoc_STR("() -> (GDHandle _rv)")},
 	{"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1,
-	 "(GDHandle value) -> None"},
+	 PyDoc_STR("(GDHandle value) -> None")},
 	{"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1,
-	 "() -> (RGBColor hiliteRGBValue)"},
+	 PyDoc_STR("() -> (RGBColor hiliteRGBValue)")},
 	{"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1,
-	 "(RGBColor hiliteRGBValue) -> None"},
+	 PyDoc_STR("(RGBColor hiliteRGBValue) -> None")},
 	{"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1,
-	 "(Boolean value) -> None"},
+	 PyDoc_STR("(Boolean value) -> None")},
 	{"TextFont", (PyCFunction)Qd_TextFont, 1,
-	 "(short font) -> None"},
+	 PyDoc_STR("(short font) -> None")},
 	{"TextFace", (PyCFunction)Qd_TextFace, 1,
-	 "(StyleParameter face) -> None"},
+	 PyDoc_STR("(StyleParameter face) -> None")},
 	{"TextMode", (PyCFunction)Qd_TextMode, 1,
-	 "(short mode) -> None"},
+	 PyDoc_STR("(short mode) -> None")},
 	{"TextSize", (PyCFunction)Qd_TextSize, 1,
-	 "(short size) -> None"},
+	 PyDoc_STR("(short size) -> None")},
 	{"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
-	 "(Fixed extra) -> None"},
+	 PyDoc_STR("(Fixed extra) -> None")},
 	{"DrawChar", (PyCFunction)Qd_DrawChar, 1,
-	 "(CharParameter ch) -> None"},
+	 PyDoc_STR("(CharParameter ch) -> None")},
 	{"DrawString", (PyCFunction)Qd_DrawString, 1,
-	 "(Str255 s) -> None"},
+	 PyDoc_STR("(Str255 s) -> None")},
 	{"MacDrawText", (PyCFunction)Qd_MacDrawText, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
 	{"CharWidth", (PyCFunction)Qd_CharWidth, 1,
-	 "(CharParameter ch) -> (short _rv)"},
+	 PyDoc_STR("(CharParameter ch) -> (short _rv)")},
 	{"StringWidth", (PyCFunction)Qd_StringWidth, 1,
-	 "(Str255 s) -> (short _rv)"},
+	 PyDoc_STR("(Str255 s) -> (short _rv)")},
 	{"TextWidth", (PyCFunction)Qd_TextWidth, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)")},
 	{"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1,
-	 "() -> (FontInfo info)"},
+	 PyDoc_STR("() -> (FontInfo info)")},
 	{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
-	 "(Fixed extra) -> None"},
+	 PyDoc_STR("(Fixed extra) -> None")},
 	{"TruncString", (PyCFunction)Qd_TruncString, 1,
-	 "(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"},
+	 PyDoc_STR("(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)")},
 	{"SetPort", (PyCFunction)Qd_SetPort, 1,
-	 "(GrafPtr thePort) -> None"},
+	 PyDoc_STR("(GrafPtr thePort) -> None")},
 	{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
-	 "(short cursorID) -> (CursHandle _rv)"},
+	 PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
 	{"SetCursor", (PyCFunction)Qd_SetCursor, 1,
-	 "(Cursor crsr) -> None"},
+	 PyDoc_STR("(Cursor crsr) -> None")},
 	{"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"LineTo", (PyCFunction)Qd_LineTo, 1,
-	 "(short h, short v) -> None"},
+	 PyDoc_STR("(short h, short v) -> None")},
 	{"SetRect", (PyCFunction)Qd_SetRect, 1,
-	 "(short left, short top, short right, short bottom) -> (Rect r)"},
+	 PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
 	{"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"InsetRect", (PyCFunction)Qd_InsetRect, 1,
-	 "(Rect r, short dh, short dv) -> (Rect r)"},
+	 PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
 	{"UnionRect", (PyCFunction)Qd_UnionRect, 1,
-	 "(Rect src1, Rect src2) -> (Rect dstRect)"},
+	 PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
 	{"EqualRect", (PyCFunction)Qd_EqualRect, 1,
-	 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+	 PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
 	{"FrameRect", (PyCFunction)Qd_FrameRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"InvertRect", (PyCFunction)Qd_InvertRect, 1,
-	 "(Rect r) -> None"},
+	 PyDoc_STR("(Rect r) -> None")},
 	{"FillRect", (PyCFunction)Qd_FillRect, 1,
-	 "(Rect r, Pattern pat) -> None"},
+	 PyDoc_STR("(Rect r, Pattern pat) -> None")},
 	{"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
-	 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
 	{"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
-	 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
 	{"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
-	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
 	{"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"XorRgn", (PyCFunction)Qd_XorRgn, 1,
-	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	 PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
 	{"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
-	 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+	 PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
 	{"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
-	 "(RgnHandle rgn) -> None"},
+	 PyDoc_STR("(RgnHandle rgn) -> None")},
 	{"FillRgn", (PyCFunction)Qd_FillRgn, 1,
-	 "(RgnHandle rgn, Pattern pat) -> None"},
+	 PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
 	{"GetPixel", (PyCFunction)Qd_GetPixel, 1,
-	 "(short h, short v) -> (Boolean _rv)"},
+	 PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
 	{"PtInRect", (PyCFunction)Qd_PtInRect, 1,
-	 "(Point pt, Rect r) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
 	{"DrawText", (PyCFunction)Qd_DrawText, 1,
-	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+	 PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
 	{"BitMap", (PyCFunction)Qd_BitMap, 1,
-	 "Take (string, int, Rect) argument and create BitMap"},
+	 PyDoc_STR("Take (string, int, Rect) argument and create BitMap")},
 	{"RawBitMap", (PyCFunction)Qd_RawBitMap, 1,
-	 "Take string BitMap and turn into BitMap object"},
+	 PyDoc_STR("Take string BitMap and turn into BitMap object")},
 	{NULL, NULL, 0}
 };