Rooba
/
cpython
mirror of https://github.com/python/cpython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cpython/Mac/Modules/qd/Qdmodule.c

4330 lines
100 KiB
C
Raw Blame History

/* =========================== Module Qd ============================ */
#include "Python.h"
#define SystemSevenOrLater 1
#include "macglue.h"
#include <Memory.h>
#include <Dialogs.h>
#include <Menus.h>
#include <Controls.h>
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 <QuickDraw.h>
#define resNotFound -192 /* Can't include <Errors.h> 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_SetPort(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
GrafPtr port;
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_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;
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_SetCursor(_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__;
}
SetCursor(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_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, ""))
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_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_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, "O&hh",
PyMac_GetRect, &r,
&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, "O&hh",
PyMac_GetRect, &r,
&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_FillRect(_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__;
}
FillRect(&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, &region,
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_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_FillRgn(_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__;
}
FillRgn(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_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&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_PtInRect(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Boolean _rv;
Point pt;
Rect r;
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt,
PyMac_GetRect, &r))
return NULL;
_rv = PtInRect(pt,
&r);
_res = Py_BuildValue("b",
_rv);
return _res;
}
static PyObject *Qd_Pt2Rect(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Point pt1;
Point pt2;
Rect dstRect;
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt1,
PyMac_GetPoint, &pt2))
return NULL;
Pt2Rect(pt1,
pt2,
&dstRect);
_res = Py_BuildValue("O&",
PyMac_BuildRect, &dstRect);
return _res;
}
static PyObject *Qd_PtToAngle(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
Rect r;
Point pt;
short angle;
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &r,
PyMac_GetPoint, &pt))
return NULL;
PtToAngle(&r,
pt,
&angle);
_res = Py_BuildValue("h",
angle);
return _res;
}
static PyObject *Qd_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_GetCursor(_self, _args)
PyObject *_self;
PyObject *_args;
{
PyObject *_res = NULL;
CursHandle _rv;
short cursorID;
if (!PyArg_ParseTuple(_args, "h",
&cursorID))
return NULL;
_rv = GetCursor(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_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;
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[] = {
{"SetPort", (PyCFunction)Qd_SetPort, 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"},
{"SetCursor", (PyCFunction)Qd_SetCursor, 1,
"(Cursor crsr) -> 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)"},
{"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"},
{"LineTo", (PyCFunction)Qd_LineTo, 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"},
{"SetRect", (PyCFunction)Qd_SetRect, 1,
"(short left, short top, short right, short bottom) -> (Rect r)"},
{"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
"(Rect r, short dh, short dv) -> (Rect r)"},
{"InsetRect", (PyCFunction)Qd_InsetRect, 1,
"(Rect r, 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"},
{"InvertRect", (PyCFunction)Qd_InvertRect, 1,
"(Rect r) -> None"},
{"FillRect", (PyCFunction)Qd_FillRect, 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"},
{"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"},
{"FillRgn", (PyCFunction)Qd_FillRgn, 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)"},
{"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 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)"},
{"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)"},
{"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)"},
{"GetCursor", (PyCFunction)Qd_GetCursor, 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"},
{"DrawText", (PyCFunction)Qd_DrawText, 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 ========================== */
Reference in New Issue View Git Blame Copy Permalink