Commits

Anonymous committed 91bc907

first cut at the whole quickdraw.h header file ...

Comments (0)

Files changed (5)

Mac/Lib/toolbox/QuickDraw.py

+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:QuickDraw.h'
+
+invalColReq = -1
+srcCopy = 0
+srcOr = 1
+srcXor = 2
+srcBic = 3
+notSrcCopy = 4
+notSrcOr = 5
+notSrcXor = 6
+notSrcBic = 7
+patCopy = 8
+patOr = 9
+patXor = 10
+patBic = 11
+notPatCopy = 12
+notPatOr = 13
+notPatXor = 14
+notPatBic = 15
+grayishTextOr = 49
+blend = 32
+addPin = 33
+addOver = 34
+subPin = 35
+addMax = 37
+adMax = 37
+subOver = 38
+adMin = 39
+ditherCopy = 64
+transparent = 36
+normalBit = 0
+inverseBit = 1
+redBit = 4
+greenBit = 3
+blueBit = 2
+cyanBit = 8
+magentaBit = 7
+yellowBit = 6
+blackBit = 5
+blackColor = 33
+whiteColor = 30
+redColor = 205
+greenColor = 341
+blueColor = 409
+cyanColor = 273
+magentaColor = 137
+yellowColor = 69
+picLParen = 0
+picRParen = 1
+normal = 0
+bold = 1
+italic = 2
+underline = 4
+outline = 8
+shadow = 0x10
+condense = 0x20
+extend = 0x40
+clutType = 0
+fixedType = 1
+directType = 2
+gdDevType = 0
+burstDevice = 7
+ext32Device = 8
+ramInit = 10
+mainScreen = 11
+allInit = 12
+screenDevice = 13
+noDriver = 14
+screenActive = 15
+hiliteBit = 7
+pHiliteBit = 0
+defQDColors = 127
+RGBDirect = 16
+baseAddr32 = 4
+rgnOverflowErr = -147
+insufficientStackErr = -149
+allDevices = 1 << allDevicesBit

Mac/Modules/qd/Qdmodule.c

 
 static PyObject *Qd_Error;
 
-static PyObject *Qd_GlobalToLocal(_self, _args)
+static PyObject *Qd_OpenPort(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Point thePoint;
+	WindowPtr port;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	                      WinObj_Convert, &port))
 		return NULL;
-	GlobalToLocal(&thePoint);
-	_res = Py_BuildValue("O&",
-	                     PyMac_BuildPoint, thePoint);
+	OpenPort(port);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Qd_LocalToGlobal(_self, _args)
+static PyObject *Qd_InitPort(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Point thePoint;
+	WindowPtr port;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	                      WinObj_Convert, &port))
 		return NULL;
-	LocalToGlobal(&thePoint);
-	_res = Py_BuildValue("O&",
-	                     PyMac_BuildPoint, thePoint);
+	InitPort(port);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ClosePort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &port))
+		return NULL;
+	ClosePort(port);
+	Py_INCREF(Py_None);
+	_res = Py_None;
 	return _res;
 }
 
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	WindowPtr thePort;
+	WindowPtr port;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &thePort))
+	                      WinObj_Convert, &port))
 		return NULL;
-	SetPort(thePort);
+	SetPort(port);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_GetPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr port;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	GetPort(&port);
+	_res = Py_BuildValue("O&",
+	                     WinObj_New, port);
+	return _res;
+}
+
+static PyObject *Qd_GrafDevice(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short device;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &device))
+		return NULL;
+	GrafDevice(device);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PortSize(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short width;
+	short height;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &width,
+	                      &height))
+		return NULL;
+	PortSize(width,
+	         height);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_MovePortTo(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short leftGlobal;
+	short topGlobal;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &leftGlobal,
+	                      &topGlobal))
+		return NULL;
+	MovePortTo(leftGlobal,
+	           topGlobal);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetOrigin(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short h;
+	short v;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &h,
+	                      &v))
+		return NULL;
+	SetOrigin(h,
+	          v);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetClip(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	SetClip(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_GetClip(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	GetClip(rgn);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 	return _res;
 }
 
+static PyObject *Qd_InitCursor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	InitCursor();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_HideCursor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	HideCursor();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ShowCursor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	ShowCursor();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ObscureCursor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	ObscureCursor();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_HidePen(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	HidePen();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ShowPen(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	ShowPen();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_GetPen(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &pt))
+		return NULL;
+	GetPen(&pt);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_PenSize(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short width;
+	short height;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &width,
+	                      &height))
+		return NULL;
+	PenSize(width,
+	        height);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PenMode(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short mode;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &mode))
+		return NULL;
+	PenMode(mode);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PenNormal(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	PenNormal();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_MoveTo(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short h;
+	short v;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &h,
+	                      &v))
+		return NULL;
+	MoveTo(h,
+	       v);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_Move(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	Move(dh,
+	     dv);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_LineTo(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short h;
+	short v;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &h,
+	                      &v))
+		return NULL;
+	LineTo(h,
+	       v);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_Line(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	Line(dh,
+	     dv);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_TextFont(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short font;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &font))
+		return NULL;
+	TextFont(font);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_TextFace(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short face;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &face))
+		return NULL;
+	TextFace(face);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_TextMode(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short mode;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &mode))
+		return NULL;
+	TextMode(mode);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_TextSize(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short size;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &size))
+		return NULL;
+	TextSize(size);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SpaceExtra(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long extra;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &extra))
+		return NULL;
+	SpaceExtra(extra);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DrawChar(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short ch;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &ch))
+		return NULL;
+	DrawChar(ch);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DrawString(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Str255 s;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetStr255, s))
+		return NULL;
+	DrawString(s);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DrawText(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	char *textBuf__in__;
+	int textBuf__len__;
+	int textBuf__in_len__;
+	short firstByte;
+	short byteCount;
+	if (!PyArg_ParseTuple(_args, "s#hh",
+	                      &textBuf__in__, &textBuf__in_len__,
+	                      &firstByte,
+	                      &byteCount))
+		return NULL;
+	DrawText(textBuf__in__,
+	         firstByte,
+	         byteCount);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+ textBuf__error__: ;
+	return _res;
+}
+
+static PyObject *Qd_CharWidth(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	short ch;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &ch))
+		return NULL;
+	_rv = CharWidth(ch);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_StringWidth(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	Str255 s;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetStr255, s))
+		return NULL;
+	_rv = StringWidth(s);
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_TextWidth(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	char *textBuf__in__;
+	int textBuf__len__;
+	int textBuf__in_len__;
+	short firstByte;
+	short byteCount;
+	if (!PyArg_ParseTuple(_args, "s#hh",
+	                      &textBuf__in__, &textBuf__in_len__,
+	                      &firstByte,
+	                      &byteCount))
+		return NULL;
+	_rv = TextWidth(textBuf__in__,
+	                firstByte,
+	                byteCount);
+	_res = Py_BuildValue("h",
+	                     _rv);
+ textBuf__error__: ;
+	return _res;
+}
+
+static PyObject *Qd_ForeColor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long color;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &color))
+		return NULL;
+	ForeColor(color);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_BackColor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long color;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &color))
+		return NULL;
+	BackColor(color);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ColorBit(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short whichBit;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &whichBit))
+		return NULL;
+	ColorBit(whichBit);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short left;
+	short top;
+	short right;
+	short bottom;
+	if (!PyArg_ParseTuple(_args, "hhhh",
+	                      &left,
+	                      &top,
+	                      &right,
+	                      &bottom))
+		return NULL;
+	SetRect(&r,
+	        left,
+	        top,
+	        right,
+	        bottom);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qd_OffsetRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	OffsetRect(&r,
+	           dh,
+	           dv);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qd_InsetRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &dh,
+	                      &dv))
+		return NULL;
+	InsetRect(&r,
+	          dh,
+	          dv);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qd_SectRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Rect src1;
+	Rect src2;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &src1,
+	                      PyMac_GetRect, &src2))
+		return NULL;
+	_rv = SectRect(&src1,
+	               &src2,
+	               &dstRect);
+	_res = Py_BuildValue("bO&",
+	                     _rv,
+	                     PyMac_BuildRect, &dstRect);
+	return _res;
+}
+
+static PyObject *Qd_UnionRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect src1;
+	Rect src2;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &src1,
+	                      PyMac_GetRect, &src2))
+		return NULL;
+	UnionRect(&src1,
+	          &src2,
+	          &dstRect);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &dstRect);
+	return _res;
+}
+
+static PyObject *Qd_EqualRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Rect rect1;
+	Rect rect2;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &rect1,
+	                      PyMac_GetRect, &rect2))
+		return NULL;
+	_rv = EqualRect(&rect1,
+	                &rect2);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_EmptyRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	_rv = EmptyRect(&r);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_FrameRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	FrameRect(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	PaintRect(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
 static PyObject *Qd_EraseRect(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 	return _res;
 }
 
-static PyObject *Qd_OpenDeskAcc(_self, _args)
+static PyObject *Qd_InvertRect(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Str255 name;
+	Rect r;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetStr255, name))
+	                      PyMac_GetRect, &r))
 		return NULL;
-	OpenDeskAcc(name);
+	InvertRect(&r);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
+static PyObject *Qd_FrameOval(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	FrameOval(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintOval(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	PaintOval(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_EraseOval(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	EraseOval(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertOval(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	InvertOval(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FrameRoundRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short ovalWidth;
+	short ovalHeight;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &ovalWidth,
+	                      &ovalHeight))
+		return NULL;
+	FrameRoundRect(&r,
+	               ovalWidth,
+	               ovalHeight);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintRoundRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short ovalWidth;
+	short ovalHeight;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &ovalWidth,
+	                      &ovalHeight))
+		return NULL;
+	PaintRoundRect(&r,
+	               ovalWidth,
+	               ovalHeight);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_EraseRoundRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short ovalWidth;
+	short ovalHeight;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &ovalWidth,
+	                      &ovalHeight))
+		return NULL;
+	EraseRoundRect(&r,
+	               ovalWidth,
+	               ovalHeight);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertRoundRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short ovalWidth;
+	short ovalHeight;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &ovalWidth,
+	                      &ovalHeight))
+		return NULL;
+	InvertRoundRect(&r,
+	                ovalWidth,
+	                ovalHeight);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FrameArc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short startAngle;
+	short arcAngle;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &startAngle,
+	                      &arcAngle))
+		return NULL;
+	FrameArc(&r,
+	         startAngle,
+	         arcAngle);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintArc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short startAngle;
+	short arcAngle;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &startAngle,
+	                      &arcAngle))
+		return NULL;
+	PaintArc(&r,
+	         startAngle,
+	         arcAngle);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_EraseArc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short startAngle;
+	short arcAngle;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &startAngle,
+	                      &arcAngle))
+		return NULL;
+	EraseArc(&r,
+	         startAngle,
+	         arcAngle);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertArc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short startAngle;
+	short arcAngle;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetRect, &r,
+	                      &startAngle,
+	                      &arcAngle))
+		return NULL;
+	InvertArc(&r,
+	          startAngle,
+	          arcAngle);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_NewRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = NewRgn();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_OpenRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	OpenRgn();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_CloseRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	CloseRgn(dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DisposeRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	DisposeRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_CopyRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle srcRgn;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &srcRgn,
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	CopyRgn(srcRgn,
+	        dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetEmptyRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	SetEmptyRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetRectRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	short left;
+	short top;
+	short right;
+	short bottom;
+	if (!PyArg_ParseTuple(_args, "O&hhhh",
+	                      ResObj_Convert, &rgn,
+	                      &left,
+	                      &top,
+	                      &right,
+	                      &bottom))
+		return NULL;
+	SetRectRgn(rgn,
+	           left,
+	           top,
+	           right,
+	           bottom);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_RectRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &rgn,
+	                      PyMac_GetRect, &r))
+		return NULL;
+	RectRgn(rgn,
+	        &r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_OffsetRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      ResObj_Convert, &rgn,
+	                      &dh,
+	                      &dv))
+		return NULL;
+	OffsetRgn(rgn,
+	          dh,
+	          dv);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InsetRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      ResObj_Convert, &rgn,
+	                      &dh,
+	                      &dv))
+		return NULL;
+	InsetRgn(rgn,
+	         dh,
+	         dv);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SectRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle srcRgnA;
+	RgnHandle srcRgnB;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &srcRgnA,
+	                      ResObj_Convert, &srcRgnB,
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	SectRgn(srcRgnA,
+	        srcRgnB,
+	        dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_UnionRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle srcRgnA;
+	RgnHandle srcRgnB;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &srcRgnA,
+	                      ResObj_Convert, &srcRgnB,
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	UnionRgn(srcRgnA,
+	         srcRgnB,
+	         dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DiffRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle srcRgnA;
+	RgnHandle srcRgnB;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &srcRgnA,
+	                      ResObj_Convert, &srcRgnB,
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	DiffRgn(srcRgnA,
+	        srcRgnB,
+	        dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_XorRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle srcRgnA;
+	RgnHandle srcRgnB;
+	RgnHandle dstRgn;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &srcRgnA,
+	                      ResObj_Convert, &srcRgnB,
+	                      ResObj_Convert, &dstRgn))
+		return NULL;
+	XorRgn(srcRgnA,
+	       srcRgnB,
+	       dstRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_RectInRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Rect r;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &r,
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	_rv = RectInRgn(&r,
+	                rgn);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_EqualRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	RgnHandle rgnA;
+	RgnHandle rgnB;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &rgnA,
+	                      ResObj_Convert, &rgnB))
+		return NULL;
+	_rv = EqualRgn(rgnA,
+	               rgnB);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_EmptyRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	_rv = EmptyRgn(rgn);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_FrameRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	FrameRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	PaintRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_EraseRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	EraseRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	InvertRgn(rgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ScrollRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short dh;
+	short dv;
+	RgnHandle updateRgn;
+	if (!PyArg_ParseTuple(_args, "O&hhO&",
+	                      PyMac_GetRect, &r,
+	                      &dh,
+	                      &dv,
+	                      ResObj_Convert, &updateRgn))
+		return NULL;
+	ScrollRect(&r,
+	           dh,
+	           dv,
+	           updateRgn);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_OpenPicture(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PicHandle _rv;
+	Rect picFrame;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &picFrame))
+		return NULL;
+	_rv = OpenPicture(&picFrame);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_PicComment(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short kind;
+	short dataSize;
+	Handle dataHandle;
+	if (!PyArg_ParseTuple(_args, "hhO&",
+	                      &kind,
+	                      &dataSize,
+	                      ResObj_Convert, &dataHandle))
+		return NULL;
+	PicComment(kind,
+	           dataSize,
+	           dataHandle);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ClosePicture(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	ClosePicture();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DrawPicture(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PicHandle myPicture;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &myPicture,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	DrawPicture(myPicture,
+	            &dstRect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_KillPicture(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PicHandle myPicture;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &myPicture))
+		return NULL;
+	KillPicture(myPicture);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_OpenPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = OpenPoly();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_ClosePoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	ClosePoly();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_KillPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &poly))
+		return NULL;
+	KillPoly(poly);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_OffsetPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	short dh;
+	short dv;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      ResObj_Convert, &poly,
+	                      &dh,
+	                      &dv))
+		return NULL;
+	OffsetPoly(poly,
+	           dh,
+	           dv);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FramePoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &poly))
+		return NULL;
+	FramePoly(poly);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PaintPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &poly))
+		return NULL;
+	PaintPoly(poly);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ErasePoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &poly))
+		return NULL;
+	ErasePoly(poly);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &poly))
+		return NULL;
+	InvertPoly(poly);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetPt(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	short h;
+	short v;
+	if (!PyArg_ParseTuple(_args, "O&hh",
+	                      PyMac_GetPoint, &pt,
+	                      &h,
+	                      &v))
+		return NULL;
+	SetPt(&pt,
+	      h,
+	      v);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_LocalToGlobal(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &pt))
+		return NULL;
+	LocalToGlobal(&pt);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_GlobalToLocal(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetPoint, &pt))
+		return NULL;
+	GlobalToLocal(&pt);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_Random(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = Random();
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_GetPixel(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	short h;
+	short v;
+	if (!PyArg_ParseTuple(_args, "hh",
+	                      &h,
+	                      &v))
+		return NULL;
+	_rv = GetPixel(h,
+	               v);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_ScalePt(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	Rect srcRect;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      PyMac_GetPoint, &pt,
+	                      PyMac_GetRect, &srcRect,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	ScalePt(&pt,
+	        &srcRect,
+	        &dstRect);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_MapPt(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt;
+	Rect srcRect;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      PyMac_GetPoint, &pt,
+	                      PyMac_GetRect, &srcRect,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	MapPt(&pt,
+	      &srcRect,
+	      &dstRect);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, pt);
+	return _res;
+}
+
+static PyObject *Qd_MapRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	Rect srcRect;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &srcRect,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	MapRect(&r,
+	        &srcRect,
+	        &dstRect);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &r);
+	return _res;
+}
+
+static PyObject *Qd_MapRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	Rect srcRect;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &rgn,
+	                      PyMac_GetRect, &srcRect,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	MapRgn(rgn,
+	       &srcRect,
+	       &dstRect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_MapPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	Rect srcRect;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&O&",
+	                      ResObj_Convert, &poly,
+	                      PyMac_GetRect, &srcRect,
+	                      PyMac_GetRect, &dstRect))
+		return NULL;
+	MapPoly(poly,
+	        &srcRect,
+	        &dstRect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_AddPt(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point src;
+	Point dst;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &src,
+	                      PyMac_GetPoint, &dst))
+		return NULL;
+	AddPt(src,
+	      &dst);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, dst);
+	return _res;
+}
+
+static PyObject *Qd_EqualPt(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Point pt1;
+	Point pt2;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &pt1,
+	                      PyMac_GetPoint, &pt2))
+		return NULL;
+	_rv = EqualPt(pt1,
+	              pt2);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_PtInRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Point pt;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &pt,
+	                      PyMac_GetRect, &r))
+		return NULL;
+	_rv = PtInRect(pt,
+	               &r);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_Pt2Rect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Point pt1;
+	Point pt2;
+	Rect dstRect;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &pt1,
+	                      PyMac_GetPoint, &pt2))
+		return NULL;
+	Pt2Rect(pt1,
+	        pt2,
+	        &dstRect);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildRect, &dstRect);
+	return _res;
+}
+
+static PyObject *Qd_PtToAngle(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	Point pt;
+	short angle;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &r,
+	                      PyMac_GetPoint, &pt))
+		return NULL;
+	PtToAngle(&r,
+	          pt,
+	          &angle);
+	_res = Py_BuildValue("h",
+	                     angle);
+	return _res;
+}
+
+static PyObject *Qd_PtInRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Boolean _rv;
+	Point pt;
+	RgnHandle rgn;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetPoint, &pt,
+	                      ResObj_Convert, &rgn))
+		return NULL;
+	_rv = PtInRgn(pt,
+	              rgn);
+	_res = Py_BuildValue("b",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_NewPixMap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixMapHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = NewPixMap();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_DisposPixMap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixMapHandle pm;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pm))
+		return NULL;
+	DisposPixMap(pm);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DisposePixMap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixMapHandle pm;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pm))
+		return NULL;
+	DisposePixMap(pm);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_CopyPixMap(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixMapHandle srcPM;
+	PixMapHandle dstPM;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &srcPM,
+	                      ResObj_Convert, &dstPM))
+		return NULL;
+	CopyPixMap(srcPM,
+	           dstPM);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_NewPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = NewPixPat();
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_DisposPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pp))
+		return NULL;
+	DisposPixPat(pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_DisposePixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pp))
+		return NULL;
+	DisposePixPat(pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_CopyPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle srcPP;
+	PixPatHandle dstPP;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &srcPP,
+	                      ResObj_Convert, &dstPP))
+		return NULL;
+	CopyPixPat(srcPP,
+	           dstPP);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_PenPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pp))
+		return NULL;
+	PenPixPat(pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_BackPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      ResObj_Convert, &pp))
+		return NULL;
+	BackPixPat(pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_GetPixPat(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixPatHandle _rv;
+	short patID;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &patID))
+		return NULL;
+	_rv = GetPixPat(patID);
+	_res = Py_BuildValue("O&",
+	                     ResObj_New, _rv);
+	return _res;
+}
+
+static PyObject *Qd_FillCRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &r,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCRect(&r,
+	          pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FillCOval(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      PyMac_GetRect, &r,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCOval(&r,
+	          pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FillCRoundRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short ovalWidth;
+	short ovalHeight;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&hhO&",
+	                      PyMac_GetRect, &r,
+	                      &ovalWidth,
+	                      &ovalHeight,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCRoundRect(&r,
+	               ovalWidth,
+	               ovalHeight,
+	               pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}