/* =========================== Module Qd ============================ */ #include "Python.h" #define SystemSevenOrLater 1 #include "macglue.h" #include #include #include #include extern PyObject *ResObj_New(Handle); extern int ResObj_Convert(PyObject *, Handle *); extern PyObject *OptResObj_New(Handle); extern int OptResObj_Convert(PyObject *, Handle *); extern PyObject *WinObj_New(WindowPtr); extern int WinObj_Convert(PyObject *, WindowPtr *); extern PyTypeObject Window_Type; #define WinObj_Check(x) ((x)->ob_type == &Window_Type) extern PyObject *DlgObj_New(DialogPtr); extern int DlgObj_Convert(PyObject *, DialogPtr *); extern PyTypeObject Dialog_Type; #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type) extern PyObject *MenuObj_New(MenuHandle); extern int MenuObj_Convert(PyObject *, MenuHandle *); extern PyObject *CtlObj_New(ControlHandle); extern int CtlObj_Convert(PyObject *, ControlHandle *); extern PyObject *GrafObj_New(GrafPtr); extern int GrafObj_Convert(PyObject *, GrafPtr *); extern PyObject *BMObj_New(BitMapPtr); extern int BMObj_Convert(PyObject *, BitMapPtr *); extern PyObject *WinObj_WhichWindow(WindowPtr); #include #define resNotFound -192 /* Can't include because of Python's "errors.h" */ /* ** Parse/generate RGB records */ PyObject *QdRGB_New(itself) RGBColorPtr itself; { return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue); } QdRGB_Convert(v, p_itself) PyObject *v; RGBColorPtr p_itself; { long red, green, blue; if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) ) return 0; p_itself->red = (unsigned short)red; p_itself->green = (unsigned short)green; p_itself->blue = (unsigned short)blue; return 1; } /* ** Generate FontInfo records */ static PyObject *QdFI_New(itself) FontInfo *itself; { return Py_BuildValue("hhhh", itself->ascent, itself->descent, itself->widMax, itself->leading); } static PyObject *Qd_Error; /* ---------------------- Object type GrafPort ---------------------- */ PyTypeObject GrafPort_Type; #define GrafObj_Check(x) ((x)->ob_type == &GrafPort_Type) typedef struct GrafPortObject { PyObject_HEAD GrafPtr ob_itself; } GrafPortObject; PyObject *GrafObj_New(itself) GrafPtr itself; { GrafPortObject *it; if (itself == NULL) return PyMac_Error(resNotFound); it = PyObject_NEW(GrafPortObject, &GrafPort_Type); if (it == NULL) return NULL; it->ob_itself = itself; return (PyObject *)it; } GrafObj_Convert(v, p_itself) PyObject *v; GrafPtr *p_itself; { if (DlgObj_Check(v) || WinObj_Check(v)) { *p_itself = ((GrafPortObject *)v)->ob_itself; return 1; } if (!GrafObj_Check(v)) { PyErr_SetString(PyExc_TypeError, "GrafPort required"); return 0; } *p_itself = ((GrafPortObject *)v)->ob_itself; return 1; } static void GrafObj_dealloc(self) GrafPortObject *self; { /* Cleanup of self->ob_itself goes here */ PyMem_DEL(self); } static PyMethodDef GrafObj_methods[] = { {NULL, NULL, 0} }; PyMethodChain GrafObj_chain = { GrafObj_methods, NULL }; static PyObject *GrafObj_getattr(self, name) GrafPortObject *self; char *name; { { CGrafPtr itself_color = (CGrafPtr)self->ob_itself; if ( strcmp(name, "data") == 0 ) return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(GrafPort)); if ( (itself_color->portVersion&0xc000) == 0xc000 ) { /* Color-only attributes */ if ( strcmp(name, "portBits") == 0 ) /* XXXX Do we need HLock() stuff here?? */ return BMObj_New((BitMapPtr)*itself_color->portPixMap); if ( strcmp(name, "grafVars") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->visRgn); if ( strcmp(name, "chExtra") == 0 ) return Py_BuildValue("h", itself_color->chExtra); if ( strcmp(name, "pnLocHFrac") == 0 ) return Py_BuildValue("h", itself_color->pnLocHFrac); if ( strcmp(name, "bkPixPat") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->bkPixPat); if ( strcmp(name, "rgbFgColor") == 0 ) return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbFgColor); if ( strcmp(name, "rgbBkColor") == 0 ) return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbBkColor); if ( strcmp(name, "pnPixPat") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->pnPixPat); if ( strcmp(name, "fillPixPat") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->fillPixPat); } else { /* Mono-only attributes */ if ( strcmp(name, "portBits") == 0 ) return BMObj_New(&self->ob_itself->portBits); if ( strcmp(name, "bkPat") == 0 ) return Py_BuildValue("s#", (char *)&self->ob_itself->bkPat, sizeof(Pattern)); if ( strcmp(name, "fillPat") == 0 ) return Py_BuildValue("s#", (char *)&self->ob_itself->fillPat, sizeof(Pattern)); if ( strcmp(name, "pnPat") == 0 ) return Py_BuildValue("s#", (char *)&self->ob_itself->pnPat, sizeof(Pattern)); } /* ** Accessible for both color/mono windows. ** portVersion is really color-only, but we put it here ** for convenience */ if ( strcmp(name, "portVersion") == 0 ) return Py_BuildValue("h", itself_color->portVersion); if ( strcmp(name, "device") == 0 ) return PyInt_FromLong((long)self->ob_itself->device); if ( strcmp(name, "portRect") == 0 ) return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect); if ( strcmp(name, "visRgn") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->visRgn); if ( strcmp(name, "clipRgn") == 0 ) return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->clipRgn); if ( strcmp(name, "pnLoc") == 0 ) return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnLoc); if ( strcmp(name, "pnSize") == 0 ) return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnSize); if ( strcmp(name, "pnMode") == 0 ) return Py_BuildValue("h", self->ob_itself->pnMode); if ( strcmp(name, "pnVis") == 0 ) return Py_BuildValue("h", self->ob_itself->pnVis); if ( strcmp(name, "txFont") == 0 ) return Py_BuildValue("h", self->ob_itself->txFont); if ( strcmp(name, "txFace") == 0 ) return Py_BuildValue("h", (short)self->ob_itself->txFace); if ( strcmp(name, "txMode") == 0 ) return Py_BuildValue("h", self->ob_itself->txMode); if ( strcmp(name, "txSize") == 0 ) return Py_BuildValue("h", self->ob_itself->txSize); if ( strcmp(name, "spExtra") == 0 ) return Py_BuildValue("O&", PyMac_BuildFixed, self->ob_itself->spExtra); /* XXXX Add more, as needed */ /* This one is so we can compare grafports: */ if ( strcmp(name, "_id") == 0 ) return Py_BuildValue("l", (long)self->ob_itself); } return Py_FindMethodInChain(&GrafObj_chain, (PyObject *)self, name); } #define GrafObj_setattr NULL PyTypeObject GrafPort_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "GrafPort", /*tp_name*/ sizeof(GrafPortObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) GrafObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc) GrafObj_getattr, /*tp_getattr*/ (setattrfunc) GrafObj_setattr, /*tp_setattr*/ }; /* -------------------- End object type GrafPort -------------------- */ /* ----------------------- Object type BitMap ----------------------- */ PyTypeObject BitMap_Type; #define BMObj_Check(x) ((x)->ob_type == &BitMap_Type) typedef struct BitMapObject { PyObject_HEAD BitMapPtr ob_itself; PyObject *referred_object; BitMap *referred_bitmap; } BitMapObject; PyObject *BMObj_New(itself) BitMapPtr itself; { BitMapObject *it; if (itself == NULL) return PyMac_Error(resNotFound); it = PyObject_NEW(BitMapObject, &BitMap_Type); if (it == NULL) return NULL; it->ob_itself = itself; it->referred_object = NULL; it->referred_bitmap = NULL; return (PyObject *)it; } BMObj_Convert(v, p_itself) PyObject *v; BitMapPtr *p_itself; { if (!BMObj_Check(v)) { PyErr_SetString(PyExc_TypeError, "BitMap required"); return 0; } *p_itself = ((BitMapObject *)v)->ob_itself; return 1; } static void BMObj_dealloc(self) BitMapObject *self; { Py_XDECREF(self->referred_object); if (self->referred_bitmap) free(self->referred_bitmap); PyMem_DEL(self); } static PyMethodDef BMObj_methods[] = { {NULL, NULL, 0} }; PyMethodChain BMObj_chain = { BMObj_methods, NULL }; static PyObject *BMObj_getattr(self, name) BitMapObject *self; char *name; { if ( strcmp(name, "baseAddr") == 0 ) return PyInt_FromLong((long)self->ob_itself->baseAddr); if ( strcmp(name, "rowBytes") == 0 ) return PyInt_FromLong((long)self->ob_itself->rowBytes); if ( strcmp(name, "bounds") == 0 ) return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds); /* XXXX Add more, as needed */ if ( strcmp(name, "bitmap_data") == 0 ) return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap)); if ( strcmp(name, "pixmap_data") == 0 ) return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap)); return Py_FindMethodInChain(&BMObj_chain, (PyObject *)self, name); } #define BMObj_setattr NULL PyTypeObject BitMap_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "BitMap", /*tp_name*/ sizeof(BitMapObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) BMObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc) BMObj_getattr, /*tp_getattr*/ (setattrfunc) BMObj_setattr, /*tp_setattr*/ }; /* --------------------- End object type BitMap --------------------- */ /* ------------------ Object type QDGlobalsAccess ------------------- */ staticforward PyTypeObject QDGlobalsAccess_Type; #define QDGA_Check(x) ((x)->ob_type == &QDGlobalsAccess_Type) typedef struct QDGlobalsAccessObject { PyObject_HEAD } QDGlobalsAccessObject; static PyObject *QDGA_New() { QDGlobalsAccessObject *it; it = PyObject_NEW(QDGlobalsAccessObject, &QDGlobalsAccess_Type); if (it == NULL) return NULL; return (PyObject *)it; } static void QDGA_dealloc(self) QDGlobalsAccessObject *self; { PyMem_DEL(self); } static PyMethodDef QDGA_methods[] = { {NULL, NULL, 0} }; static PyMethodChain QDGA_chain = { QDGA_methods, NULL }; static PyObject *QDGA_getattr(self, name) QDGlobalsAccessObject *self; char *name; { if ( strcmp(name, "arrow") == 0 ) return PyString_FromStringAndSize((char *)&qd.arrow, sizeof(qd.arrow)); if ( strcmp(name, "black") == 0 ) return PyString_FromStringAndSize((char *)&qd.black, sizeof(qd.black)); if ( strcmp(name, "white") == 0 ) return PyString_FromStringAndSize((char *)&qd.white, sizeof(qd.white)); if ( strcmp(name, "gray") == 0 ) return PyString_FromStringAndSize((char *)&qd.gray, sizeof(qd.gray)); if ( strcmp(name, "ltGray") == 0 ) return PyString_FromStringAndSize((char *)&qd.ltGray, sizeof(qd.ltGray)); if ( strcmp(name, "dkGray") == 0 ) return PyString_FromStringAndSize((char *)&qd.dkGray, sizeof(qd.dkGray)); if ( strcmp(name, "screenBits") == 0 ) return BMObj_New(&qd.screenBits); if ( strcmp(name, "thePort") == 0 ) return GrafObj_New(qd.thePort); if ( strcmp(name, "randSeed") == 0 ) return Py_BuildValue("l", &qd.randSeed); return Py_FindMethodInChain(&QDGA_chain, (PyObject *)self, name); } #define QDGA_setattr NULL staticforward PyTypeObject QDGlobalsAccess_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "QDGlobalsAccess", /*tp_name*/ sizeof(QDGlobalsAccessObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor) QDGA_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ (getattrfunc) QDGA_getattr, /*tp_getattr*/ (setattrfunc) QDGA_setattr, /*tp_setattr*/ }; /* ---------------- End object type QDGlobalsAccess ----------------- */ static PyObject *Qd_MacSetPort(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GrafPtr port; if (!PyArg_ParseTuple(_args, "O&", GrafObj_Convert, &port)) return NULL; MacSetPort(port); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetPort(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GrafPtr port; if (!PyArg_ParseTuple(_args, "")) return NULL; GetPort(&port); _res = Py_BuildValue("O&", GrafObj_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_SetPortBits(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMapPtr bm; if (!PyArg_ParseTuple(_args, "O&", BMObj_Convert, &bm)) return NULL; SetPortBits(bm); 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_BackPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "s#", (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } BackPat(pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_MacSetCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Cursor *crsr__in__; int crsr__in_len__; if (!PyArg_ParseTuple(_args, "s#", (char **)&crsr__in__, &crsr__in_len__)) return NULL; if (crsr__in_len__ != sizeof(Cursor)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Cursor)"); goto crsr__error__; } MacSetCursor(crsr__in__); Py_INCREF(Py_None); _res = Py_None; crsr__error__: ; 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_MacShowCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; if (!PyArg_ParseTuple(_args, "")) return NULL; MacShowCursor(); 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, "")) return NULL; GetPen(&pt); _res = Py_BuildValue("O&", PyMac_BuildPoint, pt); return _res; } static PyObject *Qd_GetPenState(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PenState pnState__out__; if (!PyArg_ParseTuple(_args, "")) return NULL; GetPenState(&pnState__out__); _res = Py_BuildValue("s#", (char *)&pnState__out__, (int)sizeof(PenState)); pnState__error__: ; return _res; } static PyObject *Qd_SetPenState(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PenState *pnState__in__; int pnState__in_len__; if (!PyArg_ParseTuple(_args, "s#", (char **)&pnState__in__, &pnState__in_len__)) return NULL; if (pnState__in_len__ != sizeof(PenState)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(PenState)"); goto pnState__error__; } SetPenState(pnState__in__); Py_INCREF(Py_None); _res = Py_None; pnState__error__: ; 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_PenPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "s#", (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } PenPat(pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_MacLineTo(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short h; short v; if (!PyArg_ParseTuple(_args, "hh", &h, &v)) return NULL; MacLineTo(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_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_MacSetRect(_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; MacSetRect(&r, left, top, right, bottom); _res = Py_BuildValue("O&", PyMac_BuildRect, &r); return _res; } static PyObject *Qd_MacOffsetRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; short dh; short dv; if (!PyArg_ParseTuple(_args, "O&hh", PyMac_GetRect, &r, &dh, &dv)) return NULL; MacOffsetRect(&r, dh, dv); _res = Py_BuildValue("O&", PyMac_BuildRect, &r); return _res; } static PyObject *Qd_MacInsetRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; short dh; short dv; if (!PyArg_ParseTuple(_args, "O&hh", PyMac_GetRect, &r, &dh, &dv)) return NULL; MacInsetRect(&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_MacUnionRect(_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; MacUnionRect(&src1, &src2, &dstRect); _res = Py_BuildValue("O&", PyMac_BuildRect, &dstRect); return _res; } static PyObject *Qd_MacEqualRect(_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 = MacEqualRect(&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_MacFrameRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetRect, &r)) return NULL; MacFrameRect(&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_MacInvertRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetRect, &r)) return NULL; MacInvertRect(&r); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_MacFillRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&s#", PyMac_GetRect, &r, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } MacFillRect(&r, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_FillOval(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&s#", PyMac_GetRect, &r, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } FillOval(&r, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_FillRoundRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; short ovalWidth; short ovalHeight; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&hhs#", PyMac_GetRect, &r, &ovalWidth, &ovalHeight, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } FillRoundRect(&r, ovalWidth, ovalHeight, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_FillArc(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; short startAngle; short arcAngle; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&hhs#", PyMac_GetRect, &r, &startAngle, &arcAngle, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } FillArc(&r, startAngle, arcAngle, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_BitMapToRegion(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; OSErr _err; RgnHandle region; BitMapPtr bMap; if (!PyArg_ParseTuple(_args, "O&O&", ResObj_Convert, ®ion, BMObj_Convert, &bMap)) return NULL; _err = BitMapToRegion(region, bMap); if (_err != noErr) return PyMac_Error(_err); 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_MacCopyRgn(_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; MacCopyRgn(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_MacSetRectRgn(_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; MacSetRectRgn(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_MacOffsetRgn(_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; MacOffsetRgn(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_MacUnionRgn(_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; MacUnionRgn(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_MacXorRgn(_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; MacXorRgn(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_MacEqualRgn(_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 = MacEqualRgn(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_MacFrameRgn(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RgnHandle rgn; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &rgn)) return NULL; MacFrameRgn(rgn); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_MacPaintRgn(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RgnHandle rgn; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &rgn)) return NULL; MacPaintRgn(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_MacInvertRgn(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RgnHandle rgn; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &rgn)) return NULL; MacInvertRgn(rgn); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_MacFillRgn(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RgnHandle rgn; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&s#", ResObj_Convert, &rgn, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } MacFillRgn(rgn, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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_CopyBits(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMapPtr srcBits; BitMapPtr dstBits; Rect srcRect; Rect dstRect; short mode; RgnHandle maskRgn; if (!PyArg_ParseTuple(_args, "O&O&O&O&hO&", BMObj_Convert, &srcBits, BMObj_Convert, &dstBits, PyMac_GetRect, &srcRect, PyMac_GetRect, &dstRect, &mode, OptResObj_Convert, &maskRgn)) return NULL; CopyBits(srcBits, dstBits, &srcRect, &dstRect, mode, maskRgn); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_CopyMask(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMapPtr srcBits; BitMapPtr maskBits; BitMapPtr dstBits; Rect srcRect; Rect maskRect; Rect dstRect; if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&", BMObj_Convert, &srcBits, BMObj_Convert, &maskBits, BMObj_Convert, &dstBits, PyMac_GetRect, &srcRect, PyMac_GetRect, &maskRect, PyMac_GetRect, &dstRect)) return NULL; CopyMask(srcBits, maskBits, dstBits, &srcRect, &maskRect, &dstRect); 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_FillPoly(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PolyHandle poly; Pattern *pat__in__; int pat__in_len__; if (!PyArg_ParseTuple(_args, "O&s#", ResObj_Convert, &poly, (char **)&pat__in__, &pat__in_len__)) return NULL; if (pat__in_len__ != sizeof(Pattern)) { PyErr_SetString(PyExc_TypeError, "buffer length should be sizeof(Pattern)"); goto pat__error__; } FillPoly(poly, pat__in__); Py_INCREF(Py_None); _res = Py_None; pat__error__: ; 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, "hh", &h, &v)) return NULL; SetPt(&pt, h, v); _res = Py_BuildValue("O&", PyMac_BuildPoint, pt); return _res; } static PyObject *Qd_LocalToGlobal(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Point pt; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetPoint, &pt)) return NULL; LocalToGlobal(&pt); _res = Py_BuildValue("O&", PyMac_BuildPoint, pt); return _res; } static PyObject *Qd_GlobalToLocal(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Point pt; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetPoint, &pt)) return NULL; GlobalToLocal(&pt); _res = Py_BuildValue("O&", PyMac_BuildPoint, pt); return _res; } static PyObject *Qd_Random(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = Random(); _res = Py_BuildValue("h", _rv); return _res; } static PyObject *Qd_MacGetPixel(_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 = MacGetPixel(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&O&", PyMac_GetRect, &r, 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_StdBits(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMapPtr srcBits; Rect srcRect; Rect dstRect; short mode; RgnHandle maskRgn; if (!PyArg_ParseTuple(_args, "O&O&O&hO&", BMObj_Convert, &srcBits, PyMac_GetRect, &srcRect, PyMac_GetRect, &dstRect, &mode, OptResObj_Convert, &maskRgn)) return NULL; StdBits(srcBits, &srcRect, &dstRect, mode, maskRgn); 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_MacPtInRect(_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 = MacPtInRect(pt, &r); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *Qd_Pt2Rect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Point pt1; Point pt2; Rect dstRect; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetPoint, &pt1, PyMac_GetPoint, &pt2)) return NULL; Pt2Rect(pt1, pt2, &dstRect); _res = Py_BuildValue("O&", PyMac_BuildRect, &dstRect); return _res; } static PyObject *Qd_PtToAngle(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; Point pt; short angle; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetRect, &r, PyMac_GetPoint, &pt)) return NULL; PtToAngle(&r, pt, &angle); _res = Py_BuildValue("h", angle); return _res; } static PyObject *Qd_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_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_DisposePixMap(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixMapHandle pm; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &pm)) return NULL; DisposePixMap(pm); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_CopyPixMap(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixMapHandle srcPM; PixMapHandle dstPM; if (!PyArg_ParseTuple(_args, "O&O&", ResObj_Convert, &srcPM, ResObj_Convert, &dstPM)) return NULL; CopyPixMap(srcPM, dstPM); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_NewPixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = NewPixPat(); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_DisposePixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &pp)) return NULL; DisposePixPat(pp); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_CopyPixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle srcPP; PixPatHandle dstPP; if (!PyArg_ParseTuple(_args, "O&O&", ResObj_Convert, &srcPP, ResObj_Convert, &dstPP)) return NULL; CopyPixPat(srcPP, dstPP); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_PenPixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &pp)) return NULL; PenPixPat(pp); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_BackPixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &pp)) return NULL; BackPixPat(pp); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetPixPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle _rv; short patID; if (!PyArg_ParseTuple(_args, "h", &patID)) return NULL; _rv = GetPixPat(patID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_MakeRGBPat(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PixPatHandle pp; RGBColor myColor; if (!PyArg_ParseTuple(_args, "O&O&", ResObj_Convert, &pp, QdRGB_Convert, &myColor)) return NULL; MakeRGBPat(pp, &myColor); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_FillCRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetRect, &r, ResObj_Convert, &pp)) return NULL; FillCRect(&r, pp); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_FillCOval(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetRect, &r, ResObj_Convert, &pp)) return NULL; FillCOval(&r, pp); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_FillCRoundRect(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect r; short ovalWidth; short ovalHeight; PixPatHandle pp; if (!PyArg_ParseTuple(_args, "O&hhO&", PyMac_GetRect, &r, &ovalWidth, &ovalHeight, ResObj_Convert, &pp)) return NULL; FillCRoundRect(&r, ovalWidth, ovalHeight, pp); Py_INCREF(Py_None); _res = Py_None; return _res; } 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_RGBForeColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &color)) return NULL; RGBForeColor(&color); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_RGBBackColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &color)) return NULL; RGBBackColor(&color); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_SetCPixel(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short h; short v; RGBColor cPix; if (!PyArg_ParseTuple(_args, "hhO&", &h, &v, QdRGB_Convert, &cPix)) return NULL; SetCPixel(h, v, &cPix); 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&", ResObj_Convert, &pm)) return NULL; SetPortPix(pm); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetCPixel(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short h; short v; RGBColor cPix; if (!PyArg_ParseTuple(_args, "hh", &h, &v)) return NULL; GetCPixel(h, v, &cPix); _res = Py_BuildValue("O&", QdRGB_New, &cPix); return _res; } static PyObject *Qd_GetForeColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "")) return NULL; GetForeColor(&color); _res = Py_BuildValue("O&", QdRGB_New, &color); return _res; } static PyObject *Qd_GetBackColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "")) return NULL; GetBackColor(&color); _res = Py_BuildValue("O&", QdRGB_New, &color); return _res; } static PyObject *Qd_OpColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &color)) return NULL; OpColor(&color); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_HiliteColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor color; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &color)) return NULL; HiliteColor(&color); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_DisposeCTable(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CTabHandle cTable; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &cTable)) return NULL; DisposeCTable(cTable); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetCTable(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CTabHandle _rv; short ctID; if (!PyArg_ParseTuple(_args, "h", &ctID)) return NULL; _rv = GetCTable(ctID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_GetCCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CCrsrHandle _rv; short crsrID; if (!PyArg_ParseTuple(_args, "h", &crsrID)) return NULL; _rv = GetCCursor(crsrID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_SetCCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CCrsrHandle cCrsr; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &cCrsr)) return NULL; SetCCursor(cCrsr); 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_DisposeCCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CCrsrHandle cCrsr; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &cCrsr)) return NULL; DisposeCCursor(cCrsr); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetMaxDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; Rect globalRect; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetRect, &globalRect)) return NULL; _rv = GetMaxDevice(&globalRect); _res = Py_BuildValue("O&", ResObj_New, _rv); 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_GetDeviceList(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetDeviceList(); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_GetMainDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetMainDevice(); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_GetNextDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; GDHandle curDevice; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &curDevice)) return NULL; _rv = GetNextDevice(curDevice); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_TestDeviceAttribute(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; GDHandle gdh; short attribute; if (!PyArg_ParseTuple(_args, "O&h", ResObj_Convert, &gdh, &attribute)) return NULL; _rv = TestDeviceAttribute(gdh, attribute); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *Qd_SetDeviceAttribute(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle gdh; short attribute; Boolean value; if (!PyArg_ParseTuple(_args, "O&hb", ResObj_Convert, &gdh, &attribute, &value)) return NULL; SetDeviceAttribute(gdh, attribute, value); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_InitGDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short qdRefNum; long mode; GDHandle gdh; if (!PyArg_ParseTuple(_args, "hlO&", &qdRefNum, &mode, ResObj_Convert, &gdh)) return NULL; InitGDevice(qdRefNum, mode, gdh); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_NewGDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; short refNum; long mode; if (!PyArg_ParseTuple(_args, "hl", &refNum, &mode)) return NULL; _rv = NewGDevice(refNum, mode); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_DisposeGDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle gdh; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &gdh)) return NULL; DisposeGDevice(gdh); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_SetGDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle gd; if (!PyArg_ParseTuple(_args, "O&", ResObj_Convert, &gd)) return NULL; SetGDevice(gd); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetGDevice(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; GDHandle _rv; if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = GetGDevice(); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_Color2Index(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; long _rv; RGBColor myColor; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &myColor)) return NULL; _rv = Color2Index(&myColor); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qd_Index2Color(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; long index; RGBColor aColor; if (!PyArg_ParseTuple(_args, "l", &index)) return NULL; Index2Color(index, &aColor); _res = Py_BuildValue("O&", QdRGB_New, &aColor); return _res; } static PyObject *Qd_InvertColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; RGBColor myColor; if (!PyArg_ParseTuple(_args, "")) return NULL; InvertColor(&myColor); _res = Py_BuildValue("O&", QdRGB_New, &myColor); return _res; } static PyObject *Qd_RealColor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Boolean _rv; RGBColor color; if (!PyArg_ParseTuple(_args, "O&", QdRGB_Convert, &color)) return NULL; _rv = RealColor(&color); _res = Py_BuildValue("b", _rv); return _res; } static PyObject *Qd_GetSubTable(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CTabHandle myColors; short iTabRes; CTabHandle targetTbl; if (!PyArg_ParseTuple(_args, "O&hO&", ResObj_Convert, &myColors, &iTabRes, ResObj_Convert, &targetTbl)) return NULL; GetSubTable(myColors, iTabRes, targetTbl); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_MakeITable(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CTabHandle cTabH; ITabHandle iTabH; short res; if (!PyArg_ParseTuple(_args, "O&O&h", ResObj_Convert, &cTabH, ResObj_Convert, &iTabH, &res)) return NULL; MakeITable(cTabH, iTabH, res); Py_INCREF(Py_None); _res = Py_None; 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; 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 PyObject *Qd_CopyDeepMask(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMapPtr srcBits; BitMapPtr maskBits; BitMapPtr dstBits; Rect srcRect; Rect maskRect; Rect dstRect; short mode; RgnHandle maskRgn; if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&hO&", BMObj_Convert, &srcBits, BMObj_Convert, &maskBits, BMObj_Convert, &dstBits, PyMac_GetRect, &srcRect, PyMac_GetRect, &maskRect, PyMac_GetRect, &dstRect, &mode, OptResObj_Convert, &maskRgn)) return NULL; CopyDeepMask(srcBits, maskBits, dstBits, &srcRect, &maskRect, &dstRect, mode, maskRgn); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_GetPattern(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PatHandle _rv; short patternID; if (!PyArg_ParseTuple(_args, "h", &patternID)) return NULL; _rv = GetPattern(patternID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_MacGetCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; CursHandle _rv; short cursorID; if (!PyArg_ParseTuple(_args, "h", &cursorID)) return NULL; _rv = MacGetCursor(cursorID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_GetPicture(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; PicHandle _rv; short pictureID; if (!PyArg_ParseTuple(_args, "h", &pictureID)) return NULL; _rv = GetPicture(pictureID); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyObject *Qd_DeltaPoint(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; long _rv; Point ptA; Point ptB; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetPoint, &ptA, PyMac_GetPoint, &ptB)) return NULL; _rv = DeltaPoint(ptA, ptB); _res = Py_BuildValue("l", _rv); return _res; } static PyObject *Qd_ShieldCursor(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Rect shieldRect; Point offsetPt; if (!PyArg_ParseTuple(_args, "O&O&", PyMac_GetRect, &shieldRect, PyMac_GetPoint, &offsetPt)) return NULL; ShieldCursor(&shieldRect, offsetPt); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_ScreenRes(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short scrnHRes; short scrnVRes; if (!PyArg_ParseTuple(_args, "")) return NULL; ScreenRes(&scrnHRes, &scrnVRes); _res = Py_BuildValue("hh", scrnHRes, scrnVRes); return _res; } static PyObject *Qd_GetIndPattern(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Pattern thePat__out__; short patternListID; short index; if (!PyArg_ParseTuple(_args, "hh", &patternListID, &index)) return NULL; GetIndPattern(&thePat__out__, patternListID, index); _res = Py_BuildValue("s#", (char *)&thePat__out__, (int)sizeof(Pattern)); thePat__error__: ; return _res; } static PyObject *Qd_SlopeFromAngle(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Fixed _rv; short angle; if (!PyArg_ParseTuple(_args, "h", &angle)) return NULL; _rv = SlopeFromAngle(angle); _res = Py_BuildValue("O&", PyMac_BuildFixed, _rv); return _res; } static PyObject *Qd_AngleFromSlope(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; short _rv; Fixed slope; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetFixed, &slope)) return NULL; _rv = AngleFromSlope(slope); _res = Py_BuildValue("h", _rv); 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; StyleParameter 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; Fixed extra; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetFixed, &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; CharParameter 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_MacDrawText(_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; MacDrawText(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; CharParameter 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_GetFontInfo(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; FontInfo info; if (!PyArg_ParseTuple(_args, "")) return NULL; GetFontInfo(&info); _res = Py_BuildValue("O&", QdFI_New, &info); return _res; } static PyObject *Qd_CharExtra(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; Fixed extra; if (!PyArg_ParseTuple(_args, "O&", PyMac_GetFixed, &extra)) return NULL; CharExtra(extra); Py_INCREF(Py_None); _res = Py_None; return _res; } static PyObject *Qd_BitMap(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMap *ptr; PyObject *source; Rect bounds; int rowbytes; char *data; if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect, &bounds) ) return NULL; data = PyString_AsString(source); if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL ) return PyErr_NoMemory(); ptr->baseAddr = (Ptr)data; ptr->rowBytes = rowbytes; ptr->bounds = bounds; if ( (_res = BMObj_New(ptr)) == NULL ) { free(ptr); return NULL; } ((BitMapObject *)_res)->referred_object = source; Py_INCREF(source); ((BitMapObject *)_res)->referred_bitmap = ptr; return _res; } static PyObject *Qd_RawBitMap(_self, _args) PyObject *_self; PyObject *_args; { PyObject *_res = NULL; BitMap *ptr; PyObject *source; if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) ) return NULL; if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) { PyErr_BadArgument(); return NULL; } ptr = (BitMapPtr)PyString_AsString(source); if ( (_res = BMObj_New(ptr)) == NULL ) { return NULL; } ((BitMapObject *)_res)->referred_object = source; Py_INCREF(source); return _res; } static PyMethodDef Qd_methods[] = { {"MacSetPort", (PyCFunction)Qd_MacSetPort, 1, "(GrafPtr port) -> None"}, {"GetPort", (PyCFunction)Qd_GetPort, 1, "() -> (GrafPtr port)"}, {"GrafDevice", (PyCFunction)Qd_GrafDevice, 1, "(short device) -> None"}, {"SetPortBits", (PyCFunction)Qd_SetPortBits, 1, "(BitMapPtr bm) -> 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"}, {"BackPat", (PyCFunction)Qd_BackPat, 1, "(Pattern pat) -> None"}, {"InitCursor", (PyCFunction)Qd_InitCursor, 1, "() -> None"}, {"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1, "(Cursor crsr) -> None"}, {"HideCursor", (PyCFunction)Qd_HideCursor, 1, "() -> None"}, {"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 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)"}, {"GetPenState", (PyCFunction)Qd_GetPenState, 1, "() -> (PenState pnState)"}, {"SetPenState", (PyCFunction)Qd_SetPenState, 1, "(PenState pnState) -> None"}, {"PenSize", (PyCFunction)Qd_PenSize, 1, "(short width, short height) -> None"}, {"PenMode", (PyCFunction)Qd_PenMode, 1, "(short mode) -> None"}, {"PenPat", (PyCFunction)Qd_PenPat, 1, "(Pattern pat) -> 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"}, {"MacLineTo", (PyCFunction)Qd_MacLineTo, 1, "(short h, short v) -> None"}, {"Line", (PyCFunction)Qd_Line, 1, "(short dh, short dv) -> None"}, {"ForeColor", (PyCFunction)Qd_ForeColor, 1, "(long color) -> None"}, {"BackColor", (PyCFunction)Qd_BackColor, 1, "(long color) -> None"}, {"ColorBit", (PyCFunction)Qd_ColorBit, 1, "(short whichBit) -> None"}, {"MacSetRect", (PyCFunction)Qd_MacSetRect, 1, "(short left, short top, short right, short bottom) -> (Rect r)"}, {"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1, "(Rect r, short dh, short dv) -> (Rect r)"}, {"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1, "(Rect r, short dh, short dv) -> (Rect r)"}, {"SectRect", (PyCFunction)Qd_SectRect, 1, "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"}, {"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1, "(Rect src1, Rect src2) -> (Rect dstRect)"}, {"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1, "(Rect rect1, Rect rect2) -> (Boolean _rv)"}, {"EmptyRect", (PyCFunction)Qd_EmptyRect, 1, "(Rect r) -> (Boolean _rv)"}, {"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1, "(Rect r) -> None"}, {"PaintRect", (PyCFunction)Qd_PaintRect, 1, "(Rect r) -> None"}, {"EraseRect", (PyCFunction)Qd_EraseRect, 1, "(Rect r) -> None"}, {"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1, "(Rect r) -> None"}, {"MacFillRect", (PyCFunction)Qd_MacFillRect, 1, "(Rect r, Pattern pat) -> 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"}, {"FillOval", (PyCFunction)Qd_FillOval, 1, "(Rect r, Pattern pat) -> 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"}, {"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1, "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> 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"}, {"FillArc", (PyCFunction)Qd_FillArc, 1, "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"}, {"NewRgn", (PyCFunction)Qd_NewRgn, 1, "() -> (RgnHandle _rv)"}, {"OpenRgn", (PyCFunction)Qd_OpenRgn, 1, "() -> None"}, {"CloseRgn", (PyCFunction)Qd_CloseRgn, 1, "(RgnHandle dstRgn) -> None"}, {"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1, "(RgnHandle region, BitMapPtr bMap) -> None"}, {"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1, "(RgnHandle rgn) -> None"}, {"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1, "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"}, {"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1, "(RgnHandle rgn) -> None"}, {"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1, "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"}, {"RectRgn", (PyCFunction)Qd_RectRgn, 1, "(RgnHandle rgn, Rect r) -> None"}, {"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 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"}, {"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1, "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, {"DiffRgn", (PyCFunction)Qd_DiffRgn, 1, "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, {"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1, "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, {"RectInRgn", (PyCFunction)Qd_RectInRgn, 1, "(Rect r, RgnHandle rgn) -> (Boolean _rv)"}, {"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1, "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"}, {"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1, "(RgnHandle rgn) -> (Boolean _rv)"}, {"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1, "(RgnHandle rgn) -> None"}, {"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1, "(RgnHandle rgn) -> None"}, {"EraseRgn", (PyCFunction)Qd_EraseRgn, 1, "(RgnHandle rgn) -> None"}, {"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1, "(RgnHandle rgn) -> None"}, {"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1, "(RgnHandle rgn, Pattern pat) -> None"}, {"ScrollRect", (PyCFunction)Qd_ScrollRect, 1, "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"}, {"CopyBits", (PyCFunction)Qd_CopyBits, 1, "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, {"CopyMask", (PyCFunction)Qd_CopyMask, 1, "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> 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"}, {"FillPoly", (PyCFunction)Qd_FillPoly, 1, "(PolyHandle poly, Pattern pat) -> None"}, {"SetPt", (PyCFunction)Qd_SetPt, 1, "(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)"}, {"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 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 r, 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"}, {"StdBits", (PyCFunction)Qd_StdBits, 1, "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, {"AddPt", (PyCFunction)Qd_AddPt, 1, "(Point src, Point dst) -> (Point dst)"}, {"EqualPt", (PyCFunction)Qd_EqualPt, 1, "(Point pt1, Point pt2) -> (Boolean _rv)"}, {"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 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)"}, {"SubPt", (PyCFunction)Qd_SubPt, 1, "(Point src, Point dst) -> (Point dst)"}, {"PtInRgn", (PyCFunction)Qd_PtInRgn, 1, "(Point pt, RgnHandle rgn) -> (Boolean _rv)"}, {"NewPixMap", (PyCFunction)Qd_NewPixMap, 1, "() -> (PixMapHandle _rv)"}, {"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)"}, {"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)"}, {"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1, "(PixPatHandle pp, RGBColor myColor) -> None"}, {"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"}, {"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1, "(RGBColor color) -> None"}, {"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1, "(RGBColor color) -> None"}, {"SetCPixel", (PyCFunction)Qd_SetCPixel, 1, "(short h, short v, RGBColor cPix) -> None"}, {"SetPortPix", (PyCFunction)Qd_SetPortPix, 1, "(PixMapHandle pm) -> None"}, {"GetCPixel", (PyCFunction)Qd_GetCPixel, 1, "(short h, short v) -> (RGBColor cPix)"}, {"GetForeColor", (PyCFunction)Qd_GetForeColor, 1, "() -> (RGBColor color)"}, {"GetBackColor", (PyCFunction)Qd_GetBackColor, 1, "() -> (RGBColor color)"}, {"OpColor", (PyCFunction)Qd_OpColor, 1, "(RGBColor color) -> None"}, {"HiliteColor", (PyCFunction)Qd_HiliteColor, 1, "(RGBColor color) -> None"}, {"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1, "(CTabHandle cTable) -> None"}, {"GetCTable", (PyCFunction)Qd_GetCTable, 1, "(short ctID) -> (CTabHandle _rv)"}, {"GetCCursor", (PyCFunction)Qd_GetCCursor, 1, "(short crsrID) -> (CCrsrHandle _rv)"}, {"SetCCursor", (PyCFunction)Qd_SetCCursor, 1, "(CCrsrHandle cCrsr) -> None"}, {"AllocCursor", (PyCFunction)Qd_AllocCursor, 1, "() -> None"}, {"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1, "(CCrsrHandle cCrsr) -> None"}, {"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1, "(Rect globalRect) -> (GDHandle _rv)"}, {"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1, "() -> (long _rv)"}, {"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1, "() -> (GDHandle _rv)"}, {"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1, "() -> (GDHandle _rv)"}, {"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1, "(GDHandle curDevice) -> (GDHandle _rv)"}, {"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1, "(GDHandle gdh, short attribute) -> (Boolean _rv)"}, {"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1, "(GDHandle gdh, short attribute, Boolean value) -> None"}, {"InitGDevice", (PyCFunction)Qd_InitGDevice, 1, "(short qdRefNum, long mode, GDHandle gdh) -> None"}, {"NewGDevice", (PyCFunction)Qd_NewGDevice, 1, "(short refNum, long mode) -> (GDHandle _rv)"}, {"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1, "(GDHandle gdh) -> None"}, {"SetGDevice", (PyCFunction)Qd_SetGDevice, 1, "(GDHandle gd) -> None"}, {"GetGDevice", (PyCFunction)Qd_GetGDevice, 1, "() -> (GDHandle _rv)"}, {"Color2Index", (PyCFunction)Qd_Color2Index, 1, "(RGBColor myColor) -> (long _rv)"}, {"Index2Color", (PyCFunction)Qd_Index2Color, 1, "(long index) -> (RGBColor aColor)"}, {"InvertColor", (PyCFunction)Qd_InvertColor, 1, "() -> (RGBColor myColor)"}, {"RealColor", (PyCFunction)Qd_RealColor, 1, "(RGBColor color) -> (Boolean _rv)"}, {"GetSubTable", (PyCFunction)Qd_GetSubTable, 1, "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"}, {"MakeITable", (PyCFunction)Qd_MakeITable, 1, "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"}, {"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)"}, {"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1, "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, {"GetPattern", (PyCFunction)Qd_GetPattern, 1, "(short patternID) -> (PatHandle _rv)"}, {"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1, "(short cursorID) -> (CursHandle _rv)"}, {"GetPicture", (PyCFunction)Qd_GetPicture, 1, "(short pictureID) -> (PicHandle _rv)"}, {"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1, "(Point ptA, Point ptB) -> (long _rv)"}, {"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1, "(Rect shieldRect, Point offsetPt) -> None"}, {"ScreenRes", (PyCFunction)Qd_ScreenRes, 1, "() -> (short scrnHRes, short scrnVRes)"}, {"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1, "(short patternListID, short index) -> (Pattern thePat)"}, {"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1, "(short angle) -> (Fixed _rv)"}, {"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1, "(Fixed slope) -> (short _rv)"}, {"TextFont", (PyCFunction)Qd_TextFont, 1, "(short font) -> None"}, {"TextFace", (PyCFunction)Qd_TextFace, 1, "(StyleParameter face) -> None"}, {"TextMode", (PyCFunction)Qd_TextMode, 1, "(short mode) -> None"}, {"TextSize", (PyCFunction)Qd_TextSize, 1, "(short size) -> None"}, {"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1, "(Fixed extra) -> None"}, {"DrawChar", (PyCFunction)Qd_DrawChar, 1, "(CharParameter ch) -> None"}, {"DrawString", (PyCFunction)Qd_DrawString, 1, "(Str255 s) -> None"}, {"MacDrawText", (PyCFunction)Qd_MacDrawText, 1, "(Buffer textBuf, short firstByte, short byteCount) -> None"}, {"CharWidth", (PyCFunction)Qd_CharWidth, 1, "(CharParameter 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)"}, {"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1, "() -> (FontInfo info)"}, {"CharExtra", (PyCFunction)Qd_CharExtra, 1, "(Fixed extra) -> None"}, {"BitMap", (PyCFunction)Qd_BitMap, 1, "Take (string, int, Rect) argument and create BitMap"}, {"RawBitMap", (PyCFunction)Qd_RawBitMap, 1, "Take string BitMap and turn into BitMap object"}, {NULL, NULL, 0} }; void initQd() { PyObject *m; PyObject *d; m = Py_InitModule("Qd", Qd_methods); d = PyModule_GetDict(m); Qd_Error = PyMac_GetOSErrException(); if (Qd_Error == NULL || PyDict_SetItemString(d, "Error", Qd_Error) != 0) Py_FatalError("can't initialize Qd.Error"); GrafPort_Type.ob_type = &PyType_Type; Py_INCREF(&GrafPort_Type); if (PyDict_SetItemString(d, "GrafPortType", (PyObject *)&GrafPort_Type) != 0) Py_FatalError("can't initialize GrafPortType"); BitMap_Type.ob_type = &PyType_Type; Py_INCREF(&BitMap_Type); if (PyDict_SetItemString(d, "BitMapType", (PyObject *)&BitMap_Type) != 0) Py_FatalError("can't initialize BitMapType"); QDGlobalsAccess_Type.ob_type = &PyType_Type; Py_INCREF(&QDGlobalsAccess_Type); if (PyDict_SetItemString(d, "QDGlobalsAccessType", (PyObject *)&QDGlobalsAccess_Type) != 0) Py_FatalError("can't initialize QDGlobalsAccessType"); { PyObject *o; o = QDGA_New(); if (o == NULL || PyDict_SetItemString(d, "qd", o) != 0) Py_FatalError("can't initialize Qd.qd"); } } /* ========================= End module Qd ========================== */