From e56db434a9eb91bd73d99f2f8a86f3a1af8c7ac8 Mon Sep 17 00:00:00 2001 From: Guido van Rossum 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 @@ -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