From e56db434a9eb91bd73d99f2f8a86f3a1af8c7ac8 Mon Sep 17 00:00:00 2001
From: Guido van Rossum <guido@python.org>
Date: Sun, 19 Mar 1995 22:49:50 +0000
Subject: first cut at the whole quickdraw.h header file ...

---
 Mac/Lib/toolbox/QuickDraw.py |   77 ++
 Mac/Modules/qd/Qdmodule.c    | 2643 +++++++++++++++++++++++++++++++++++++++++-
 Mac/Modules/qd/qdgen.py      |  789 +++++++++++++
 Mac/Modules/qd/qdscan.py     |   83 ++
 Mac/Modules/qd/qdsupport.py  |   23 +-
 5 files changed, 3580 insertions(+), 35 deletions(-)
 create mode 100644 Mac/Lib/toolbox/QuickDraw.py
 create mode 100644 Mac/Modules/qd/qdgen.py
 create mode 100644 Mac/Modules/qd/qdscan.py

diff --git a/Mac/Lib/toolbox/QuickDraw.py b/Mac/Lib/toolbox/QuickDraw.py
new file mode 100644
index 0000000..b09628f
--- /dev/null
+++ b/Mac/Lib/toolbox/QuickDraw.py
@@ -0,0 +1,77 @@
+# 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
diff --git a/Mac/Modules/qd/Qdmodule.c b/Mac/Modules/qd/Qdmodule.c
index 2f88857..959df31 100644
--- a/Mac/Modules/qd/Qdmodule.c
+++ b/Mac/Modules/qd/Qdmodule.c
@@ -39,109 +39,2686 @@ extern PyObject *WinObj_WhichWindow(WindowPtr);
 
 static PyObject *Qd_Error;
 
+static PyObject *Qd_OpenPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &port))
+		return NULL;
+	OpenPort(port);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InitPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &port))
+		return NULL;
+	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;
+}
+
+static PyObject *Qd_SetPort(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	WindowPtr port;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      WinObj_Convert, &port))
+		return NULL;
+	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;
+}
+
+static PyObject *Qd_ClipRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	ClipRect(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	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;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	EraseRect(&r);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_InvertRect(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetRect, &r))
+		return NULL;
+	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 thePoint;
-	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	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;
-	GlobalToLocal(&thePoint);
+	Pt2Rect(pt1,
+	        pt2,
+	        &dstRect);
 	_res = Py_BuildValue("O&",
-	                     PyMac_BuildPoint, thePoint);
+	                     PyMac_BuildRect, &dstRect);
 	return _res;
 }
 
-static PyObject *Qd_LocalToGlobal(_self, _args)
+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;
-	Point thePoint;
+	PixMapHandle pm;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetPoint, &thePoint))
+	                      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;
-	LocalToGlobal(&thePoint);
+	_rv = NewPixPat();
 	_res = Py_BuildValue("O&",
-	                     PyMac_BuildPoint, thePoint);
+	                     ResObj_New, _rv);
 	return _res;
 }
 
-static PyObject *Qd_SetPort(_self, _args)
+static PyObject *Qd_DisposPixPat(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	WindowPtr thePort;
+	PixPatHandle pp;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      WinObj_Convert, &thePort))
+	                      ResObj_Convert, &pp))
 		return NULL;
-	SetPort(thePort);
+	DisposPixPat(pp);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Qd_ClipRect(_self, _args)
+static PyObject *Qd_DisposePixPat(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Rect r;
+	PixPatHandle pp;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetRect, &r))
+	                      ResObj_Convert, &pp))
 		return NULL;
-	ClipRect(&r);
+	DisposePixPat(pp);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
-static PyObject *Qd_EraseRect(_self, _args)
+static PyObject *Qd_CopyPixPat(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Rect r;
+	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&",
-	                      PyMac_GetRect, &r))
+	                      ResObj_Convert, &pp))
 		return NULL;
-	EraseRect(&r);
+	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_OpenDeskAcc(_self, _args)
+static PyObject *Qd_FillCRoundRect(_self, _args)
 	PyObject *_self;
 	PyObject *_args;
 {
 	PyObject *_res = NULL;
-	Str255 name;
+	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;
+}
+
+static PyObject *Qd_FillCArc(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	Rect r;
+	short startAngle;
+	short arcAngle;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&hhO&",
+	                      PyMac_GetRect, &r,
+	                      &startAngle,
+	                      &arcAngle,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCArc(&r,
+	         startAngle,
+	         arcAngle,
+	         pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FillCRgn(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	RgnHandle rgn;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &rgn,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCRgn(rgn,
+	         pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_FillCPoly(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PolyHandle poly;
+	PixPatHandle pp;
+	if (!PyArg_ParseTuple(_args, "O&O&",
+	                      ResObj_Convert, &poly,
+	                      ResObj_Convert, &pp))
+		return NULL;
+	FillCPoly(poly,
+	          pp);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_SetPortPix(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	PixMapHandle pm;
 	if (!PyArg_ParseTuple(_args, "O&",
-	                      PyMac_GetStr255, name))
+	                      ResObj_Convert, &pm))
+		return NULL;
+	SetPortPix(pm);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_AllocCursor(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	AllocCursor();
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_CharExtra(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long extra;
+	if (!PyArg_ParseTuple(_args, "l",
+	                      &extra))
+		return NULL;
+	CharExtra(extra);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_GetCTSeed(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	long _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = GetCTSeed();
+	_res = Py_BuildValue("l",
+	                     _rv);
+	return _res;
+}
+
+static PyObject *Qd_SubPt(_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;
+	SubPt(src,
+	      &dst);
+	_res = Py_BuildValue("O&",
+	                     PyMac_BuildPoint, dst);
+	return _res;
+}
+
+static PyObject *Qd_SetClientID(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short id;
+	if (!PyArg_ParseTuple(_args, "h",
+	                      &id))
+		return NULL;
+	SetClientID(id);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ProtectEntry(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short index;
+	Boolean protect;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &index,
+	                      &protect))
+		return NULL;
+	ProtectEntry(index,
+	             protect);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Qd_ReserveEntry(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short index;
+	Boolean reserve;
+	if (!PyArg_ParseTuple(_args, "hb",
+	                      &index,
+	                      &reserve))
 		return NULL;
-	OpenDeskAcc(name);
+	ReserveEntry(index,
+	             reserve);
 	Py_INCREF(Py_None);
 	_res = Py_None;
 	return _res;
 }
 
+static PyObject *Qd_QDError(_self, _args)
+	PyObject *_self;
+	PyObject *_args;
+{
+	PyObject *_res = NULL;
+	short _rv;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_rv = QDError();
+	_res = Py_BuildValue("h",
+	                     _rv);
+	return _res;
+}
+
 static PyMethodDef Qd_methods[] = {
-	{"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
-	 "(Point thePoint) -> (Point thePoint)"},
-	{"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
-	 "(Point thePoint) -> (Point thePoint)"},
+	{"OpenPort", (PyCFunction)Qd_OpenPort, 1,
+	 "(WindowPtr port) -> None"},
+	{"InitPort", (PyCFunction)Qd_InitPort, 1,
+	 "(WindowPtr port) -> None"},
+	{"ClosePort", (PyCFunction)Qd_ClosePort, 1,
+	 "(WindowPtr port) -> None"},
 	{"SetPort", (PyCFunction)Qd_SetPort, 1,
-	 "(WindowPtr thePort) -> None"},
+	 "(WindowPtr port) -> None"},
+	{"GetPort", (PyCFunction)Qd_GetPort, 1,
+	 "() -> (WindowPtr port)"},
+	{"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
+	 "(short device) -> None"},
+	{"PortSize", (PyCFunction)Qd_PortSize, 1,
+	 "(short width, short height) -> None"},
+	{"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
+	 "(short leftGlobal, short topGlobal) -> None"},
+	{"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
+	 "(short h, short v) -> None"},
+	{"SetClip", (PyCFunction)Qd_SetClip, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"GetClip", (PyCFunction)Qd_GetClip, 1,
+	 "(RgnHandle rgn) -> None"},
 	{"ClipRect", (PyCFunction)Qd_ClipRect, 1,
 	 "(Rect r) -> None"},
+	{"InitCursor", (PyCFunction)Qd_InitCursor, 1,
+	 "() -> None"},
+	{"HideCursor", (PyCFunction)Qd_HideCursor, 1,
+	 "() -> None"},
+	{"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
+	 "() -> None"},
+	{"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
+	 "() -> None"},
+	{"HidePen", (PyCFunction)Qd_HidePen, 1,
+	 "() -> None"},
+	{"ShowPen", (PyCFunction)Qd_ShowPen, 1,
+	 "() -> None"},
+	{"GetPen", (PyCFunction)Qd_GetPen, 1,
+	 "(Point pt) -> (Point pt)"},
+	{"PenSize", (PyCFunction)Qd_PenSize, 1,
+	 "(short width, short height) -> None"},
+	{"PenMode", (PyCFunction)Qd_PenMode, 1,
+	 "(short mode) -> None"},
+	{"PenNormal", (PyCFunction)Qd_PenNormal, 1,
+	 "() -> None"},
+	{"MoveTo", (PyCFunction)Qd_MoveTo, 1,
+	 "(short h, short v) -> None"},
+	{"Move", (PyCFunction)Qd_Move, 1,
+	 "(short dh, short dv) -> None"},
+	{"LineTo", (PyCFunction)Qd_LineTo, 1,
+	 "(short h, short v) -> None"},
+	{"Line", (PyCFunction)Qd_Line, 1,
+	 "(short dh, short dv) -> None"},
+	{"TextFont", (PyCFunction)Qd_TextFont, 1,
+	 "(short font) -> None"},
+	{"TextFace", (PyCFunction)Qd_TextFace, 1,
+	 "(short face) -> None"},
+	{"TextMode", (PyCFunction)Qd_TextMode, 1,
+	 "(short mode) -> None"},
+	{"TextSize", (PyCFunction)Qd_TextSize, 1,
+	 "(short size) -> None"},
+	{"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
+	 "(long extra) -> None"},
+	{"DrawChar", (PyCFunction)Qd_DrawChar, 1,
+	 "(short ch) -> None"},
+	{"DrawString", (PyCFunction)Qd_DrawString, 1,
+	 "(Str255 s) -> None"},
+	{"DrawText", (PyCFunction)Qd_DrawText, 1,
+	 "(Buffer textBuf, short firstByte, short byteCount) -> None"},
+	{"CharWidth", (PyCFunction)Qd_CharWidth, 1,
+	 "(short ch) -> (short _rv)"},
+	{"StringWidth", (PyCFunction)Qd_StringWidth, 1,
+	 "(Str255 s) -> (short _rv)"},
+	{"TextWidth", (PyCFunction)Qd_TextWidth, 1,
+	 "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
+	{"ForeColor", (PyCFunction)Qd_ForeColor, 1,
+	 "(long color) -> None"},
+	{"BackColor", (PyCFunction)Qd_BackColor, 1,
+	 "(long color) -> None"},
+	{"ColorBit", (PyCFunction)Qd_ColorBit, 1,
+	 "(short whichBit) -> None"},
+	{"SetRect", (PyCFunction)Qd_SetRect, 1,
+	 "(short left, short top, short right, short bottom) -> (Rect r)"},
+	{"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
+	 "(short dh, short dv) -> (Rect r)"},
+	{"InsetRect", (PyCFunction)Qd_InsetRect, 1,
+	 "(short dh, short dv) -> (Rect r)"},
+	{"SectRect", (PyCFunction)Qd_SectRect, 1,
+	 "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
+	{"UnionRect", (PyCFunction)Qd_UnionRect, 1,
+	 "(Rect src1, Rect src2) -> (Rect dstRect)"},
+	{"EqualRect", (PyCFunction)Qd_EqualRect, 1,
+	 "(Rect rect1, Rect rect2) -> (Boolean _rv)"},
+	{"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
+	 "(Rect r) -> (Boolean _rv)"},
+	{"FrameRect", (PyCFunction)Qd_FrameRect, 1,
+	 "(Rect r) -> None"},
+	{"PaintRect", (PyCFunction)Qd_PaintRect, 1,
+	 "(Rect r) -> None"},
 	{"EraseRect", (PyCFunction)Qd_EraseRect, 1,
 	 "(Rect r) -> None"},
-	{"OpenDeskAcc", (PyCFunction)Qd_OpenDeskAcc, 1,
-	 "(Str255 name) -> None"},
+	{"InvertRect", (PyCFunction)Qd_InvertRect, 1,
+	 "(Rect r) -> None"},
+	{"FrameOval", (PyCFunction)Qd_FrameOval, 1,
+	 "(Rect r) -> None"},
+	{"PaintOval", (PyCFunction)Qd_PaintOval, 1,
+	 "(Rect r) -> None"},
+	{"EraseOval", (PyCFunction)Qd_EraseOval, 1,
+	 "(Rect r) -> None"},
+	{"InvertOval", (PyCFunction)Qd_InvertOval, 1,
+	 "(Rect r) -> None"},
+	{"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
+	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	{"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
+	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	{"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
+	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	{"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
+	 "(Rect r, short ovalWidth, short ovalHeight) -> None"},
+	{"FrameArc", (PyCFunction)Qd_FrameArc, 1,
+	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	{"PaintArc", (PyCFunction)Qd_PaintArc, 1,
+	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	{"EraseArc", (PyCFunction)Qd_EraseArc, 1,
+	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	{"InvertArc", (PyCFunction)Qd_InvertArc, 1,
+	 "(Rect r, short startAngle, short arcAngle) -> None"},
+	{"NewRgn", (PyCFunction)Qd_NewRgn, 1,
+	 "() -> (RgnHandle _rv)"},
+	{"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
+	 "() -> None"},
+	{"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
+	 "(RgnHandle dstRgn) -> None"},
+	{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
+	 "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
+	{"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
+	 "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
+	{"RectRgn", (PyCFunction)Qd_RectRgn, 1,
+	 "(RgnHandle rgn, Rect r) -> None"},
+	{"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
+	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	{"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
+	 "(RgnHandle rgn, short dh, short dv) -> None"},
+	{"SectRgn", (PyCFunction)Qd_SectRgn, 1,
+	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	{"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
+	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	{"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
+	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	{"XorRgn", (PyCFunction)Qd_XorRgn, 1,
+	 "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
+	{"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
+	 "(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
+	{"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
+	 "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
+	{"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
+	 "(RgnHandle rgn) -> (Boolean _rv)"},
+	{"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
+	 "(RgnHandle rgn) -> None"},
+	{"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
+	 "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
+	{"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
+	 "(Rect picFrame) -> (PicHandle _rv)"},
+	{"PicComment", (PyCFunction)Qd_PicComment, 1,
+	 "(short kind, short dataSize, Handle dataHandle) -> None"},
+	{"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
+	 "() -> None"},
+	{"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
+	 "(PicHandle myPicture, Rect dstRect) -> None"},
+	{"KillPicture", (PyCFunction)Qd_KillPicture, 1,
+	 "(PicHandle myPicture) -> None"},
+	{"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
+	 "() -> (PolyHandle _rv)"},
+	{"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
+	 "() -> None"},
+	{"KillPoly", (PyCFunction)Qd_KillPoly, 1,
+	 "(PolyHandle poly) -> None"},
+	{"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
+	 "(PolyHandle poly, short dh, short dv) -> None"},
+	{"FramePoly", (PyCFunction)Qd_FramePoly, 1,
+	 "(PolyHandle poly) -> None"},
+	{"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
+	 "(PolyHandle poly) -> None"},
+	{"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
+	 "(PolyHandle poly) -> None"},
+	{"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
+	 "(PolyHandle poly) -> None"},
+	{"SetPt", (PyCFunction)Qd_SetPt, 1,
+	 "(Point pt, short h, short v) -> (Point pt)"},
+	{"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
+	 "(Point pt) -> (Point pt)"},
+	{"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
+	 "(Point pt) -> (Point pt)"},
+	{"Random", (PyCFunction)Qd_Random, 1,
+	 "() -> (short _rv)"},
+	{"GetPixel", (PyCFunction)Qd_GetPixel, 1,
+	 "(short h, short v) -> (Boolean _rv)"},
+	{"ScalePt", (PyCFunction)Qd_ScalePt, 1,
+	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	{"MapPt", (PyCFunction)Qd_MapPt, 1,
+	 "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
+	{"MapRect", (PyCFunction)Qd_MapRect, 1,
+	 "(Rect srcRect, Rect dstRect) -> (Rect r)"},
+	{"MapRgn", (PyCFunction)Qd_MapRgn, 1,
+	 "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
+	{"MapPoly", (PyCFunction)Qd_MapPoly, 1,
+	 "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
+	{"AddPt", (PyCFunction)Qd_AddPt, 1,
+	 "(Point src, Point dst) -> (Point dst)"},
+	{"EqualPt", (PyCFunction)Qd_EqualPt, 1,
+	 "(Point pt1, Point pt2) -> (Boolean _rv)"},
+	{"PtInRect", (PyCFunction)Qd_PtInRect, 1,
+	 "(Point pt, Rect r) -> (Boolean _rv)"},
+	{"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
+	 "(Point pt1, Point pt2) -> (Rect dstRect)"},
+	{"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
+	 "(Rect r, Point pt) -> (short angle)"},
+	{"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
+	 "(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
+	{"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
+	 "() -> (PixMapHandle _rv)"},
+	{"DisposPixMap", (PyCFunction)Qd_DisposPixMap, 1,
+	 "(PixMapHandle pm) -> None"},
+	{"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
+	 "(PixMapHandle pm) -> None"},
+	{"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
+	 "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
+	{"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
+	 "() -> (PixPatHandle _rv)"},
+	{"DisposPixPat", (PyCFunction)Qd_DisposPixPat, 1,
+	 "(PixPatHandle pp) -> None"},
+	{"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
+	 "(PixPatHandle pp) -> None"},
+	{"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
+	 "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
+	{"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
+	 "(PixPatHandle pp) -> None"},
+	{"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
+	 "(PixPatHandle pp) -> None"},
+	{"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
+	 "(short patID) -> (PixPatHandle _rv)"},
+	{"FillCRect", (PyCFunction)Qd_FillCRect, 1,
+	 "(Rect r, PixPatHandle pp) -> None"},
+	{"FillCOval", (PyCFunction)Qd_FillCOval, 1,
+	 "(Rect r, PixPatHandle pp) -> None"},
+	{"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
+	 "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
+	{"FillCArc", (PyCFunction)Qd_FillCArc, 1,
+	 "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
+	{"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
+	 "(RgnHandle rgn, PixPatHandle pp) -> None"},
+	{"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
+	 "(PolyHandle poly, PixPatHandle pp) -> None"},
+	{"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
+	 "(PixMapHandle pm) -> None"},
+	{"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
+	 "() -> None"},
+	{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
+	 "(long extra) -> None"},
+	{"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
+	 "() -> (long _rv)"},
+	{"SubPt", (PyCFunction)Qd_SubPt, 1,
+	 "(Point src, Point dst) -> (Point dst)"},
+	{"SetClientID", (PyCFunction)Qd_SetClientID, 1,
+	 "(short id) -> None"},
+	{"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
+	 "(short index, Boolean protect) -> None"},
+	{"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
+	 "(short index, Boolean reserve) -> None"},
+	{"QDError", (PyCFunction)Qd_QDError, 1,
+	 "() -> (short _rv)"},
 	{NULL, NULL, 0}
 };
 
diff --git a/Mac/Modules/qd/qdgen.py b/Mac/Modules/qd/qdgen.py
new file mode 100644
index 0000000..975e438
--- /dev/null
+++ b/Mac/Modules/qd/qdgen.py
@@ -0,0 +1,789 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:QuickDraw.h'
+
+f = Function(void, 'OpenPort',
+    (GrafPtr, 'port', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InitPort',
+    (GrafPtr, 'port', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ClosePort',
+    (GrafPtr, 'port', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetPort',
+    (GrafPtr, 'port', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'GetPort',
+    (GrafPtr, 'port', OutMode),
+)
+functions.append(f)
+
+f = Function(void, 'GrafDevice',
+    (short, 'device', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PortSize',
+    (short, 'width', InMode),
+    (short, 'height', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'MovePortTo',
+    (short, 'leftGlobal', InMode),
+    (short, 'topGlobal', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetOrigin',
+    (short, 'h', InMode),
+    (short, 'v', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetClip',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'GetClip',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ClipRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InitCursor',
+)
+functions.append(f)
+
+f = Function(void, 'HideCursor',
+)
+functions.append(f)
+
+f = Function(void, 'ShowCursor',
+)
+functions.append(f)
+
+f = Function(void, 'ObscureCursor',
+)
+functions.append(f)
+
+f = Function(void, 'HidePen',
+)
+functions.append(f)
+
+f = Function(void, 'ShowPen',
+)
+functions.append(f)
+
+f = Function(void, 'GetPen',
+    (Point, 'pt', InOutMode),
+)
+functions.append(f)
+
+f = Function(void, 'PenSize',
+    (short, 'width', InMode),
+    (short, 'height', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PenMode',
+    (short, 'mode', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PenNormal',
+)
+functions.append(f)
+
+f = Function(void, 'MoveTo',
+    (short, 'h', InMode),
+    (short, 'v', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'Move',
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'LineTo',
+    (short, 'h', InMode),
+    (short, 'v', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'Line',
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'TextFont',
+    (short, 'font', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'TextFace',
+    (short, 'face', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'TextMode',
+    (short, 'mode', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'TextSize',
+    (short, 'size', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SpaceExtra',
+    (Fixed, 'extra', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DrawChar',
+    (short, 'ch', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DrawString',
+    (ConstStr255Param, 's', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DrawText',
+    (TextThingie, 'textBuf', InMode),
+    (short, 'firstByte', InMode),
+    (short, 'byteCount', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'CharWidth',
+    (short, 'ch', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'StringWidth',
+    (ConstStr255Param, 's', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'TextWidth',
+    (TextThingie, 'textBuf', InMode),
+    (short, 'firstByte', InMode),
+    (short, 'byteCount', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ForeColor',
+    (long, 'color', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'BackColor',
+    (long, 'color', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ColorBit',
+    (short, 'whichBit', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetRect',
+    (Rect, 'r', OutMode),
+    (short, 'left', InMode),
+    (short, 'top', InMode),
+    (short, 'right', InMode),
+    (short, 'bottom', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'OffsetRect',
+    (Rect, 'r', OutMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InsetRect',
+    (Rect, 'r', OutMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'SectRect',
+    (Rect_ptr, 'src1', InMode),
+    (Rect_ptr, 'src2', InMode),
+    (Rect, 'dstRect', OutMode),
+)
+functions.append(f)
+
+f = Function(void, 'UnionRect',
+    (Rect_ptr, 'src1', InMode),
+    (Rect_ptr, 'src2', InMode),
+    (Rect, 'dstRect', OutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EqualRect',
+    (Rect_ptr, 'rect1', InMode),
+    (Rect_ptr, 'rect2', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EmptyRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FrameRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertRect',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FrameOval',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintOval',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseOval',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertOval',
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FrameRoundRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'ovalWidth', InMode),
+    (short, 'ovalHeight', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintRoundRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'ovalWidth', InMode),
+    (short, 'ovalHeight', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseRoundRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'ovalWidth', InMode),
+    (short, 'ovalHeight', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertRoundRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'ovalWidth', InMode),
+    (short, 'ovalHeight', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FrameArc',
+    (Rect_ptr, 'r', InMode),
+    (short, 'startAngle', InMode),
+    (short, 'arcAngle', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintArc',
+    (Rect_ptr, 'r', InMode),
+    (short, 'startAngle', InMode),
+    (short, 'arcAngle', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseArc',
+    (Rect_ptr, 'r', InMode),
+    (short, 'startAngle', InMode),
+    (short, 'arcAngle', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertArc',
+    (Rect_ptr, 'r', InMode),
+    (short, 'startAngle', InMode),
+    (short, 'arcAngle', InMode),
+)
+functions.append(f)
+
+f = Function(RgnHandle, 'NewRgn',
+)
+functions.append(f)
+
+f = Function(void, 'OpenRgn',
+)
+functions.append(f)
+
+f = Function(void, 'CloseRgn',
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DisposeRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CopyRgn',
+    (RgnHandle, 'srcRgn', InMode),
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetEmptyRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetRectRgn',
+    (RgnHandle, 'rgn', InMode),
+    (short, 'left', InMode),
+    (short, 'top', InMode),
+    (short, 'right', InMode),
+    (short, 'bottom', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'RectRgn',
+    (RgnHandle, 'rgn', InMode),
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'OffsetRgn',
+    (RgnHandle, 'rgn', InMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InsetRgn',
+    (RgnHandle, 'rgn', InMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SectRgn',
+    (RgnHandle, 'srcRgnA', InMode),
+    (RgnHandle, 'srcRgnB', InMode),
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'UnionRgn',
+    (RgnHandle, 'srcRgnA', InMode),
+    (RgnHandle, 'srcRgnB', InMode),
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DiffRgn',
+    (RgnHandle, 'srcRgnA', InMode),
+    (RgnHandle, 'srcRgnB', InMode),
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'XorRgn',
+    (RgnHandle, 'srcRgnA', InMode),
+    (RgnHandle, 'srcRgnB', InMode),
+    (RgnHandle, 'dstRgn', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'RectInRgn',
+    (Rect_ptr, 'r', InMode),
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EqualRgn',
+    (RgnHandle, 'rgnA', InMode),
+    (RgnHandle, 'rgnB', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EmptyRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FrameRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertRgn',
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ScrollRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+    (RgnHandle, 'updateRgn', InMode),
+)
+functions.append(f)
+
+f = Function(PicHandle, 'OpenPicture',
+    (Rect_ptr, 'picFrame', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PicComment',
+    (short, 'kind', InMode),
+    (short, 'dataSize', InMode),
+    (Handle, 'dataHandle', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ClosePicture',
+)
+functions.append(f)
+
+f = Function(void, 'DrawPicture',
+    (PicHandle, 'myPicture', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'KillPicture',
+    (PicHandle, 'myPicture', InMode),
+)
+functions.append(f)
+
+f = Function(PolyHandle, 'OpenPoly',
+)
+functions.append(f)
+
+f = Function(void, 'ClosePoly',
+)
+functions.append(f)
+
+f = Function(void, 'KillPoly',
+    (PolyHandle, 'poly', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'OffsetPoly',
+    (PolyHandle, 'poly', InMode),
+    (short, 'dh', InMode),
+    (short, 'dv', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FramePoly',
+    (PolyHandle, 'poly', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PaintPoly',
+    (PolyHandle, 'poly', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ErasePoly',
+    (PolyHandle, 'poly', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InvertPoly',
+    (PolyHandle, 'poly', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetPt',
+    (Point, 'pt', InOutMode),
+    (short, 'h', InMode),
+    (short, 'v', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'LocalToGlobal',
+    (Point, 'pt', InOutMode),
+)
+functions.append(f)
+
+f = Function(void, 'GlobalToLocal',
+    (Point, 'pt', InOutMode),
+)
+functions.append(f)
+
+f = Function(short, 'Random',
+)
+functions.append(f)
+
+f = Function(Boolean, 'GetPixel',
+    (short, 'h', InMode),
+    (short, 'v', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ScalePt',
+    (Point, 'pt', InOutMode),
+    (Rect_ptr, 'srcRect', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'MapPt',
+    (Point, 'pt', InOutMode),
+    (Rect_ptr, 'srcRect', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'MapRect',
+    (Rect, 'r', OutMode),
+    (Rect_ptr, 'srcRect', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'MapRgn',
+    (RgnHandle, 'rgn', InMode),
+    (Rect_ptr, 'srcRect', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'MapPoly',
+    (PolyHandle, 'poly', InMode),
+    (Rect_ptr, 'srcRect', InMode),
+    (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'AddPt',
+    (Point, 'src', InMode),
+    (Point, 'dst', InOutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EqualPt',
+    (Point, 'pt1', InMode),
+    (Point, 'pt2', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'PtInRect',
+    (Point, 'pt', InMode),
+    (Rect_ptr, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'Pt2Rect',
+    (Point, 'pt1', InMode),
+    (Point, 'pt2', InMode),
+    (Rect, 'dstRect', OutMode),
+)
+functions.append(f)
+
+f = Function(void, 'PtToAngle',
+    (Rect_ptr, 'r', InMode),
+    (Point, 'pt', InMode),
+    (short, 'angle', OutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'PtInRgn',
+    (Point, 'pt', InMode),
+    (RgnHandle, 'rgn', InMode),
+)
+functions.append(f)
+
+f = Function(PixMapHandle, 'NewPixMap',
+)
+functions.append(f)
+
+f = Function(void, 'DisposPixMap',
+    (PixMapHandle, 'pm', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DisposePixMap',
+    (PixMapHandle, 'pm', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CopyPixMap',
+    (PixMapHandle, 'srcPM', InMode),
+    (PixMapHandle, 'dstPM', InMode),
+)
+functions.append(f)
+
+f = Function(PixPatHandle, 'NewPixPat',
+)
+functions.append(f)
+
+f = Function(void, 'DisposPixPat',
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'DisposePixPat',
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CopyPixPat',
+    (PixPatHandle, 'srcPP', InMode),
+    (PixPatHandle, 'dstPP', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'PenPixPat',
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'BackPixPat',
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(PixPatHandle, 'GetPixPat',
+    (short, 'patID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCRect',
+    (Rect_ptr, 'r', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCOval',
+    (Rect_ptr, 'r', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCRoundRect',
+    (Rect_ptr, 'r', InMode),
+    (short, 'ovalWidth', InMode),
+    (short, 'ovalHeight', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCArc',
+    (Rect_ptr, 'r', InMode),
+    (short, 'startAngle', InMode),
+    (short, 'arcAngle', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCRgn',
+    (RgnHandle, 'rgn', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FillCPoly',
+    (PolyHandle, 'poly', InMode),
+    (PixPatHandle, 'pp', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetPortPix',
+    (PixMapHandle, 'pm', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'AllocCursor',
+)
+functions.append(f)
+
+f = Function(void, 'CharExtra',
+    (Fixed, 'extra', InMode),
+)
+functions.append(f)
+
+f = Function(long, 'GetCTSeed',
+)
+functions.append(f)
+
+f = Function(void, 'SubPt',
+    (Point, 'src', InMode),
+    (Point, 'dst', InOutMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetClientID',
+    (short, 'id', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ProtectEntry',
+    (short, 'index', InMode),
+    (Boolean, 'protect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ReserveEntry',
+    (short, 'index', InMode),
+    (Boolean, 'reserve', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'QDError',
+)
+functions.append(f)
+
diff --git a/Mac/Modules/qd/qdscan.py b/Mac/Modules/qd/qdscan.py
new file mode 100644
index 0000000..057db6d
--- /dev/null
+++ b/Mac/Modules/qd/qdscan.py
@@ -0,0 +1,83 @@
+# Scan an Apple header file, generating a Python file of generator calls.
+
+import addpack
+addpack.addpack('D:python:Tools:bgen:bgen')
+
+from scantools import Scanner
+
+def main():
+	input = "QuickDraw.h"
+	output = "qdgen.py"
+	defsoutput = "QuickDraw.py"
+	scanner = MyScanner(input, output, defsoutput)
+	scanner.scan()
+	scanner.close()
+	print "=== Done scanning and generating, now importing the generated code... ==="
+	import qdsupport
+	print "=== Done.  It's up to you to compile it now! ==="
+
+class MyScanner(Scanner):
+
+	def destination(self, type, name, arglist):
+		classname = "Function"
+		listname = "functions"
+		if arglist:
+			t, n, m = arglist[0]
+			if t in ("WindowPtr", "WindowPeek") and m == "InMode":
+				classname = "Method"
+				listname = "methods"
+		return classname, listname
+
+	def makeblacklistnames(self):
+		return [
+			'InitGraf',
+			'StuffHex',
+			'StdLine',
+			'StdComment',
+			'StdGetPic',
+			'StdLine',
+			]
+
+	def makeblacklisttypes(self):
+		return [
+			'BitMap_ptr',
+			'CCrsrHandle',
+			'CGrafPtr',
+			'CIconHandle',
+			'CQDProcs',
+			'CSpecArray',
+			'CTabHandle',
+			'ColorComplementProcPtr',
+			'ColorSearchProcPtr',
+			'ConstPatternParam',
+			'Cursor_ptr',
+			'DeviceLoopDrawingProcPtr',
+			'DeviceLoopFlags',
+			'FontInfo',
+			'GDHandle',
+			'GrafVerb',
+			'OpenCPicParams_ptr',
+			'PenState',
+			'PenState_ptr',
+			'Ptr',
+			'QDProcs',
+			'RGBColor',
+			'RGBColor_ptr',
+			'ReqListRec',
+			'void_ptr',
+			]
+
+	def makerepairinstructions(self):
+		return [
+			([('void_ptr', 'textBuf', 'InMode'),
+			  ('short', 'firstByte', 'InMode'),
+			  ('short', 'byteCount', 'InMode')],
+			 [('TextThingie', '*', '*'), ('*', '*', '*'), ('*', '*', '*')]),
+			
+			([('Point', '*', 'OutMode')],
+			 [('*', '*', 'InOutMode')]),
+			
+			]
+
+if __name__ == "__main__":
+	main()
diff --git a/Mac/Modules/qd/qdsupport.py b/Mac/Modules/qd/qdsupport.py
index e98b27a..0aa439c 100644
--- a/Mac/Modules/qd/qdsupport.py
+++ b/Mac/Modules/qd/qdsupport.py
@@ -5,6 +5,9 @@
 
 import string
 
+import addpack
+addpack.addpack('D:python:Tools:bgen:bgen')
+
 # Declarations that change for each manager
 MACHEADERFILE = 'QuickDraw.h'		# The Apple header file
 MODNAME = 'Qd'				# The name of the module
@@ -22,6 +25,22 @@ from macsupport import *
 
 # Create the type objects
 
+GrafPtr = WindowPtr
+
+class TextThingieClass(FixedInputBufferType):
+	def getargsCheck(self, name):
+		pass
+
+TextThingie = TextThingieClass(None)
+
+# These are temporary!
+Fixed = long
+RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
+PicHandle = OpaqueByValueType("PicHandle", "ResObj")
+PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")
+PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
+PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
+
 includestuff = includestuff + """
 #include <%s>""" % MACHEADERFILE + """
 #include <Desk.h>
@@ -58,8 +77,8 @@ Method = OSErrMethodGenerator
 # Create and populate the lists
 functions = []
 methods = []
-#execfile(INPUTFILE)
-execfile(EXTRAFILE)
+execfile(INPUTFILE)
+#execfile(EXTRAFILE)
 
 # add the populated lists to the generator groups
 # (in a different wordl the scan program would generate this)
-- 
cgit v0.12

