/* =========================== Module _Qd =========================== */

#include "Python.h"


#ifndef __LP64__

#include "pymactoolbox.h"

/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
        PyErr_SetString(PyExc_NotImplementedError, \
        "Not available in this shared library/OS version"); \
        return NULL; \
    }} while(0)


#include <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE
extern PyObject *_GrafObj_New(GrafPtr);
extern int _GrafObj_Convert(PyObject *, GrafPtr *);
extern PyObject *_BMObj_New(BitMapPtr);
extern int _BMObj_Convert(PyObject *, BitMapPtr *);
extern PyObject *_QdRGB_New(RGBColorPtr);
extern int _QdRGB_Convert(PyObject *, RGBColorPtr);

#define GrafObj_New _GrafObj_New
#define GrafObj_Convert _GrafObj_Convert
#define BMObj_New _BMObj_New
#define BMObj_Convert _BMObj_Convert
#define QdRGB_New _QdRGB_New
#define QdRGB_Convert _QdRGB_Convert
#endif

static PyObject *BMObj_NewCopied(BitMapPtr);

/*
** Parse/generate RGB records
*/
PyObject *QdRGB_New(RGBColorPtr itself)
{

        return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
}

int QdRGB_Convert(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(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 || PyObject_TypeCheck((x), &GrafPort_Type))

typedef struct GrafPortObject {
	PyObject_HEAD
	GrafPtr ob_itself;
} GrafPortObject;

PyObject *GrafObj_New(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;
}

int GrafObj_Convert(PyObject *v, GrafPtr *p_itself)
{
#if 1
	{
		WindowRef win;
		if (WinObj_Convert(v, &win) && v) {
			*p_itself = (GrafPtr)GetWindowPort(win);
			return 1;
		}
		PyErr_Clear();
	}
#else
	if (DlgObj_Check(v)) {
		DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;
		*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));
		return 1;
	}
	if (WinObj_Check(v)) {
		WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;
		*p_itself = (GrafPtr)GetWindowPort(win);
		return 1;
	}
#endif
	if (!GrafObj_Check(v))
	{
		PyErr_SetString(PyExc_TypeError, "GrafPort required");
		return 0;
	}
	*p_itself = ((GrafPortObject *)v)->ob_itself;
	return 1;
}

static void GrafObj_dealloc(GrafPortObject *self)
{
	/* Cleanup of self->ob_itself goes here */
	self->ob_type->tp_free((PyObject *)self);
}

static PyObject *GrafObj_MacSetPort(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef MacSetPort
	PyMac_PRECHECK(MacSetPort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	MacSetPort(_self->ob_itself);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_QDSwapPort(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	CGrafPtr outOldPort;
#ifndef QDSwapPort
	PyMac_PRECHECK(QDSwapPort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = QDSwapPort(_self->ob_itself,
	                 &outOldPort);
	_res = Py_BuildValue("bO&",
	                     _rv,
	                     GrafObj_New, outOldPort);
	return _res;
}

static PyObject *GrafObj_IsValidPort(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsValidPort
	PyMac_PRECHECK(IsValidPort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsValidPort(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortPixMap(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixMapHandle _rv;
#ifndef GetPortPixMap
	PyMac_PRECHECK(GetPortPixMap);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortPixMap(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortBitMapForCopyBits(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	const BitMap * _rv;
#ifndef GetPortBitMapForCopyBits
	PyMac_PRECHECK(GetPortBitMapForCopyBits);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortBitMapForCopyBits(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     BMObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortBounds(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Rect rect;
#ifndef GetPortBounds
	PyMac_PRECHECK(GetPortBounds);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPortBounds(_self->ob_itself,
	              &rect);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &rect);
	return _res;
}

static PyObject *GrafObj_GetPortForeColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RGBColor foreColor;
#ifndef GetPortForeColor
	PyMac_PRECHECK(GetPortForeColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPortForeColor(_self->ob_itself,
	                 &foreColor);
	_res = Py_BuildValue("O&",
	                     QdRGB_New, &foreColor);
	return _res;
}

static PyObject *GrafObj_GetPortBackColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RGBColor backColor;
#ifndef GetPortBackColor
	PyMac_PRECHECK(GetPortBackColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPortBackColor(_self->ob_itself,
	                 &backColor);
	_res = Py_BuildValue("O&",
	                     QdRGB_New, &backColor);
	return _res;
}

static PyObject *GrafObj_GetPortOpColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RGBColor opColor;
#ifndef GetPortOpColor
	PyMac_PRECHECK(GetPortOpColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPortOpColor(_self->ob_itself,
	               &opColor);
	_res = Py_BuildValue("O&",
	                     QdRGB_New, &opColor);
	return _res;
}

static PyObject *GrafObj_GetPortHiliteColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RGBColor hiliteColor;
#ifndef GetPortHiliteColor
	PyMac_PRECHECK(GetPortHiliteColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPortHiliteColor(_self->ob_itself,
	                   &hiliteColor);
	_res = Py_BuildValue("O&",
	                     QdRGB_New, &hiliteColor);
	return _res;
}

static PyObject *GrafObj_GetPortTextFont(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortTextFont
	PyMac_PRECHECK(GetPortTextFont);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortTextFont(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortTextFace(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Style _rv;
#ifndef GetPortTextFace
	PyMac_PRECHECK(GetPortTextFace);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortTextFace(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortTextMode(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortTextMode
	PyMac_PRECHECK(GetPortTextMode);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortTextMode(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortTextSize(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortTextSize
	PyMac_PRECHECK(GetPortTextSize);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortTextSize(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortChExtra(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortChExtra
	PyMac_PRECHECK(GetPortChExtra);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortChExtra(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortFracHPenLocation(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortFracHPenLocation
	PyMac_PRECHECK(GetPortFracHPenLocation);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortFracHPenLocation(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortSpExtra(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Fixed _rv;
#ifndef GetPortSpExtra
	PyMac_PRECHECK(GetPortSpExtra);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortSpExtra(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildFixed, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortPenVisibility(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
#ifndef GetPortPenVisibility
	PyMac_PRECHECK(GetPortPenVisibility);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortPenVisibility(_self->ob_itself);
	_res = Py_BuildValue("h",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortVisibleRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle _rv;
	RgnHandle visRgn;
#ifndef GetPortVisibleRegion
	PyMac_PRECHECK(GetPortVisibleRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &visRgn))
		return NULL;
	_rv = GetPortVisibleRegion(_self->ob_itself,
	                           visRgn);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortClipRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle _rv;
	RgnHandle clipRgn;
#ifndef GetPortClipRegion
	PyMac_PRECHECK(GetPortClipRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &clipRgn))
		return NULL;
	_rv = GetPortClipRegion(_self->ob_itself,
	                        clipRgn);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortBackPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle _rv;
	PixPatHandle backPattern;
#ifndef GetPortBackPixPat
	PyMac_PRECHECK(GetPortBackPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &backPattern))
		return NULL;
	_rv = GetPortBackPixPat(_self->ob_itself,
	                        backPattern);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortPenPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle _rv;
	PixPatHandle penPattern;
#ifndef GetPortPenPixPat
	PyMac_PRECHECK(GetPortPenPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &penPattern))
		return NULL;
	_rv = GetPortPenPixPat(_self->ob_itself,
	                       penPattern);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortFillPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle _rv;
	PixPatHandle fillPattern;
#ifndef GetPortFillPixPat
	PyMac_PRECHECK(GetPortFillPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &fillPattern))
		return NULL;
	_rv = GetPortFillPixPat(_self->ob_itself,
	                        fillPattern);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_GetPortPenSize(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point penSize;
#ifndef GetPortPenSize
	PyMac_PRECHECK(GetPortPenSize);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &penSize))
		return NULL;
	GetPortPenSize(_self->ob_itself,
	               &penSize);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildPoint, penSize);
	return _res;
}

static PyObject *GrafObj_GetPortPenMode(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	SInt32 _rv;
#ifndef GetPortPenMode
	PyMac_PRECHECK(GetPortPenMode);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetPortPenMode(_self->ob_itself);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_GetPortPenLocation(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point penLocation;
#ifndef GetPortPenLocation
	PyMac_PRECHECK(GetPortPenLocation);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &penLocation))
		return NULL;
	GetPortPenLocation(_self->ob_itself,
	                   &penLocation);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildPoint, penLocation);
	return _res;
}

static PyObject *GrafObj_IsPortRegionBeingDefined(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortRegionBeingDefined
	PyMac_PRECHECK(IsPortRegionBeingDefined);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortRegionBeingDefined(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortPictureBeingDefined(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortPictureBeingDefined
	PyMac_PRECHECK(IsPortPictureBeingDefined);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortPictureBeingDefined(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortPolyBeingDefined(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortPolyBeingDefined
	PyMac_PRECHECK(IsPortPolyBeingDefined);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortPolyBeingDefined(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortOffscreen(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortOffscreen
	PyMac_PRECHECK(IsPortOffscreen);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortOffscreen(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortColor
	PyMac_PRECHECK(IsPortColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortColor(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortVisibleRegionEmpty(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortVisibleRegionEmpty
	PyMac_PRECHECK(IsPortVisibleRegionEmpty);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortVisibleRegionEmpty(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_IsPortClipRegionEmpty(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef IsPortClipRegionEmpty
	PyMac_PRECHECK(IsPortClipRegionEmpty);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsPortClipRegionEmpty(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_SectRegionWithPortClipRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle ioRegion;
#ifndef SectRegionWithPortClipRegion
	PyMac_PRECHECK(SectRegionWithPortClipRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &ioRegion))
		return NULL;
	SectRegionWithPortClipRegion(_self->ob_itself,
	                             ioRegion);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SectRegionWithPortVisibleRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle ioRegion;
#ifndef SectRegionWithPortVisibleRegion
	PyMac_PRECHECK(SectRegionWithPortVisibleRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &ioRegion))
		return NULL;
	SectRegionWithPortVisibleRegion(_self->ob_itself,
	                                ioRegion);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SwapPortPicSaveHandle(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Handle _rv;
	Handle inPicSaveHdl;
#ifndef SwapPortPicSaveHandle
	PyMac_PRECHECK(SwapPortPicSaveHandle);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &inPicSaveHdl))
		return NULL;
	_rv = SwapPortPicSaveHandle(_self->ob_itself,
	                            inPicSaveHdl);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_SwapPortPolySaveHandle(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Handle _rv;
	Handle inPolySaveHdl;
#ifndef SwapPortPolySaveHandle
	PyMac_PRECHECK(SwapPortPolySaveHandle);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &inPolySaveHdl))
		return NULL;
	_rv = SwapPortPolySaveHandle(_self->ob_itself,
	                             inPolySaveHdl);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_SwapPortRegionSaveHandle(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Handle _rv;
	Handle inRegionSaveHdl;
#ifndef SwapPortRegionSaveHandle
	PyMac_PRECHECK(SwapPortRegionSaveHandle);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &inRegionSaveHdl))
		return NULL;
	_rv = SwapPortRegionSaveHandle(_self->ob_itself,
	                               inRegionSaveHdl);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_SetPortBounds(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Rect rect;
#ifndef SetPortBounds
	PyMac_PRECHECK(SetPortBounds);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetRect, &rect))
		return NULL;
	SetPortBounds(_self->ob_itself,
	              &rect);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortOpColor(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RGBColor opColor;
#ifndef SetPortOpColor
	PyMac_PRECHECK(SetPortOpColor);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      QdRGB_Convert, &opColor))
		return NULL;
	SetPortOpColor(_self->ob_itself,
	               &opColor);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortTextFont(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short txFont;
#ifndef SetPortTextFont
	PyMac_PRECHECK(SetPortTextFont);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &txFont))
		return NULL;
	SetPortTextFont(_self->ob_itself,
	                txFont);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortTextSize(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short txSize;
#ifndef SetPortTextSize
	PyMac_PRECHECK(SetPortTextSize);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &txSize))
		return NULL;
	SetPortTextSize(_self->ob_itself,
	                txSize);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortTextFace(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	StyleParameter face;
#ifndef SetPortTextFace
	PyMac_PRECHECK(SetPortTextFace);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &face))
		return NULL;
	SetPortTextFace(_self->ob_itself,
	                face);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortTextMode(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short mode;
#ifndef SetPortTextMode
	PyMac_PRECHECK(SetPortTextMode);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &mode))
		return NULL;
	SetPortTextMode(_self->ob_itself,
	                mode);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortVisibleRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle visRgn;
#ifndef SetPortVisibleRegion
	PyMac_PRECHECK(SetPortVisibleRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &visRgn))
		return NULL;
	SetPortVisibleRegion(_self->ob_itself,
	                     visRgn);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortClipRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle clipRgn;
#ifndef SetPortClipRegion
	PyMac_PRECHECK(SetPortClipRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &clipRgn))
		return NULL;
	SetPortClipRegion(_self->ob_itself,
	                  clipRgn);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortPenPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle penPattern;
#ifndef SetPortPenPixPat
	PyMac_PRECHECK(SetPortPenPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &penPattern))
		return NULL;
	SetPortPenPixPat(_self->ob_itself,
	                 penPattern);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortFillPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle penPattern;
#ifndef SetPortFillPixPat
	PyMac_PRECHECK(SetPortFillPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &penPattern))
		return NULL;
	SetPortFillPixPat(_self->ob_itself,
	                  penPattern);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortBackPixPat(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PixPatHandle backPattern;
#ifndef SetPortBackPixPat
	PyMac_PRECHECK(SetPortBackPixPat);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &backPattern))
		return NULL;
	SetPortBackPixPat(_self->ob_itself,
	                  backPattern);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortPenSize(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point penSize;
#ifndef SetPortPenSize
	PyMac_PRECHECK(SetPortPenSize);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &penSize))
		return NULL;
	SetPortPenSize(_self->ob_itself,
	               penSize);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortPenMode(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	SInt32 penMode;
#ifndef SetPortPenMode
	PyMac_PRECHECK(SetPortPenMode);
#endif
	if (!PyArg_ParseTuple(_args, "l",
	                      &penMode))
		return NULL;
	SetPortPenMode(_self->ob_itself,
	               penMode);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_SetPortFracHPenLocation(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short pnLocHFrac;
#ifndef SetPortFracHPenLocation
	PyMac_PRECHECK(SetPortFracHPenLocation);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &pnLocHFrac))
		return NULL;
	SetPortFracHPenLocation(_self->ob_itself,
	                        pnLocHFrac);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_DisposePort(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef DisposePort
	PyMac_PRECHECK(DisposePort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	DisposePort(_self->ob_itself);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_QDLocalToGlobalPoint(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point point;
#ifndef QDLocalToGlobalPoint
	PyMac_PRECHECK(QDLocalToGlobalPoint);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &point))
		return NULL;
	QDLocalToGlobalPoint(_self->ob_itself,
	                     &point);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildPoint, point);
	return _res;
}

static PyObject *GrafObj_QDGlobalToLocalPoint(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point point;
#ifndef QDGlobalToLocalPoint
	PyMac_PRECHECK(QDGlobalToLocalPoint);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &point))
		return NULL;
	QDGlobalToLocalPoint(_self->ob_itself,
	                     &point);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildPoint, point);
	return _res;
}

static PyObject *GrafObj_QDLocalToGlobalRect(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Rect bounds;
#ifndef QDLocalToGlobalRect
	PyMac_PRECHECK(QDLocalToGlobalRect);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	QDLocalToGlobalRect(_self->ob_itself,
	                    &bounds);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &bounds);
	return _res;
}

static PyObject *GrafObj_QDGlobalToLocalRect(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Rect bounds;
#ifndef QDGlobalToLocalRect
	PyMac_PRECHECK(QDGlobalToLocalRect);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	QDGlobalToLocalRect(_self->ob_itself,
	                    &bounds);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &bounds);
	return _res;
}

static PyObject *GrafObj_QDLocalToGlobalRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle _rv;
	RgnHandle region;
#ifndef QDLocalToGlobalRegion
	PyMac_PRECHECK(QDLocalToGlobalRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &region))
		return NULL;
	_rv = QDLocalToGlobalRegion(_self->ob_itself,
	                            region);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_QDGlobalToLocalRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle _rv;
	RgnHandle region;
#ifndef QDGlobalToLocalRegion
	PyMac_PRECHECK(QDGlobalToLocalRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &region))
		return NULL;
	_rv = QDGlobalToLocalRegion(_self->ob_itself,
	                            region);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *GrafObj_QDIsPortBuffered(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef QDIsPortBuffered
	PyMac_PRECHECK(QDIsPortBuffered);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = QDIsPortBuffered(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_QDIsPortBufferDirty(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef QDIsPortBufferDirty
	PyMac_PRECHECK(QDIsPortBufferDirty);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = QDIsPortBufferDirty(_self->ob_itself);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *GrafObj_QDFlushPortBuffer(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle region;
#ifndef QDFlushPortBuffer
	PyMac_PRECHECK(QDFlushPortBuffer);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      OptResObj_Convert, &region))
		return NULL;
	QDFlushPortBuffer(_self->ob_itself,
	                  region);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_QDGetDirtyRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	RgnHandle rgn;
#ifndef QDGetDirtyRegion
	PyMac_PRECHECK(QDGetDirtyRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &rgn))
		return NULL;
	_err = QDGetDirtyRegion(_self->ob_itself,
	                        rgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *GrafObj_QDSetDirtyRegion(GrafPortObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	RgnHandle rgn;
#ifndef QDSetDirtyRegion
	PyMac_PRECHECK(QDSetDirtyRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &rgn))
		return NULL;
	_err = QDSetDirtyRegion(_self->ob_itself,
	                        rgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyMethodDef GrafObj_methods[] = {
	{"MacSetPort", (PyCFunction)GrafObj_MacSetPort, 1,
	 PyDoc_STR("() -> None")},
	{"QDSwapPort", (PyCFunction)GrafObj_QDSwapPort, 1,
	 PyDoc_STR("() -> (Boolean _rv, CGrafPtr outOldPort)")},
	{"IsValidPort", (PyCFunction)GrafObj_IsValidPort, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"GetPortPixMap", (PyCFunction)GrafObj_GetPortPixMap, 1,
	 PyDoc_STR("() -> (PixMapHandle _rv)")},
	{"GetPortBitMapForCopyBits", (PyCFunction)GrafObj_GetPortBitMapForCopyBits, 1,
	 PyDoc_STR("() -> (const BitMap * _rv)")},
	{"GetPortBounds", (PyCFunction)GrafObj_GetPortBounds, 1,
	 PyDoc_STR("() -> (Rect rect)")},
	{"GetPortForeColor", (PyCFunction)GrafObj_GetPortForeColor, 1,
	 PyDoc_STR("() -> (RGBColor foreColor)")},
	{"GetPortBackColor", (PyCFunction)GrafObj_GetPortBackColor, 1,
	 PyDoc_STR("() -> (RGBColor backColor)")},
	{"GetPortOpColor", (PyCFunction)GrafObj_GetPortOpColor, 1,
	 PyDoc_STR("() -> (RGBColor opColor)")},
	{"GetPortHiliteColor", (PyCFunction)GrafObj_GetPortHiliteColor, 1,
	 PyDoc_STR("() -> (RGBColor hiliteColor)")},
	{"GetPortTextFont", (PyCFunction)GrafObj_GetPortTextFont, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortTextFace", (PyCFunction)GrafObj_GetPortTextFace, 1,
	 PyDoc_STR("() -> (Style _rv)")},
	{"GetPortTextMode", (PyCFunction)GrafObj_GetPortTextMode, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortTextSize", (PyCFunction)GrafObj_GetPortTextSize, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortChExtra", (PyCFunction)GrafObj_GetPortChExtra, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortFracHPenLocation", (PyCFunction)GrafObj_GetPortFracHPenLocation, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortSpExtra", (PyCFunction)GrafObj_GetPortSpExtra, 1,
	 PyDoc_STR("() -> (Fixed _rv)")},
	{"GetPortPenVisibility", (PyCFunction)GrafObj_GetPortPenVisibility, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetPortVisibleRegion", (PyCFunction)GrafObj_GetPortVisibleRegion, 1,
	 PyDoc_STR("(RgnHandle visRgn) -> (RgnHandle _rv)")},
	{"GetPortClipRegion", (PyCFunction)GrafObj_GetPortClipRegion, 1,
	 PyDoc_STR("(RgnHandle clipRgn) -> (RgnHandle _rv)")},
	{"GetPortBackPixPat", (PyCFunction)GrafObj_GetPortBackPixPat, 1,
	 PyDoc_STR("(PixPatHandle backPattern) -> (PixPatHandle _rv)")},
	{"GetPortPenPixPat", (PyCFunction)GrafObj_GetPortPenPixPat, 1,
	 PyDoc_STR("(PixPatHandle penPattern) -> (PixPatHandle _rv)")},
	{"GetPortFillPixPat", (PyCFunction)GrafObj_GetPortFillPixPat, 1,
	 PyDoc_STR("(PixPatHandle fillPattern) -> (PixPatHandle _rv)")},
	{"GetPortPenSize", (PyCFunction)GrafObj_GetPortPenSize, 1,
	 PyDoc_STR("(Point penSize) -> (Point penSize)")},
	{"GetPortPenMode", (PyCFunction)GrafObj_GetPortPenMode, 1,
	 PyDoc_STR("() -> (SInt32 _rv)")},
	{"GetPortPenLocation", (PyCFunction)GrafObj_GetPortPenLocation, 1,
	 PyDoc_STR("(Point penLocation) -> (Point penLocation)")},
	{"IsPortRegionBeingDefined", (PyCFunction)GrafObj_IsPortRegionBeingDefined, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortPictureBeingDefined", (PyCFunction)GrafObj_IsPortPictureBeingDefined, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortPolyBeingDefined", (PyCFunction)GrafObj_IsPortPolyBeingDefined, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortOffscreen", (PyCFunction)GrafObj_IsPortOffscreen, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortColor", (PyCFunction)GrafObj_IsPortColor, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortVisibleRegionEmpty", (PyCFunction)GrafObj_IsPortVisibleRegionEmpty, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsPortClipRegionEmpty", (PyCFunction)GrafObj_IsPortClipRegionEmpty, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"SectRegionWithPortClipRegion", (PyCFunction)GrafObj_SectRegionWithPortClipRegion, 1,
	 PyDoc_STR("(RgnHandle ioRegion) -> None")},
	{"SectRegionWithPortVisibleRegion", (PyCFunction)GrafObj_SectRegionWithPortVisibleRegion, 1,
	 PyDoc_STR("(RgnHandle ioRegion) -> None")},
	{"SwapPortPicSaveHandle", (PyCFunction)GrafObj_SwapPortPicSaveHandle, 1,
	 PyDoc_STR("(Handle inPicSaveHdl) -> (Handle _rv)")},
	{"SwapPortPolySaveHandle", (PyCFunction)GrafObj_SwapPortPolySaveHandle, 1,
	 PyDoc_STR("(Handle inPolySaveHdl) -> (Handle _rv)")},
	{"SwapPortRegionSaveHandle", (PyCFunction)GrafObj_SwapPortRegionSaveHandle, 1,
	 PyDoc_STR("(Handle inRegionSaveHdl) -> (Handle _rv)")},
	{"SetPortBounds", (PyCFunction)GrafObj_SetPortBounds, 1,
	 PyDoc_STR("(Rect rect) -> None")},
	{"SetPortOpColor", (PyCFunction)GrafObj_SetPortOpColor, 1,
	 PyDoc_STR("(RGBColor opColor) -> None")},
	{"SetPortTextFont", (PyCFunction)GrafObj_SetPortTextFont, 1,
	 PyDoc_STR("(short txFont) -> None")},
	{"SetPortTextSize", (PyCFunction)GrafObj_SetPortTextSize, 1,
	 PyDoc_STR("(short txSize) -> None")},
	{"SetPortTextFace", (PyCFunction)GrafObj_SetPortTextFace, 1,
	 PyDoc_STR("(StyleParameter face) -> None")},
	{"SetPortTextMode", (PyCFunction)GrafObj_SetPortTextMode, 1,
	 PyDoc_STR("(short mode) -> None")},
	{"SetPortVisibleRegion", (PyCFunction)GrafObj_SetPortVisibleRegion, 1,
	 PyDoc_STR("(RgnHandle visRgn) -> None")},
	{"SetPortClipRegion", (PyCFunction)GrafObj_SetPortClipRegion, 1,
	 PyDoc_STR("(RgnHandle clipRgn) -> None")},
	{"SetPortPenPixPat", (PyCFunction)GrafObj_SetPortPenPixPat, 1,
	 PyDoc_STR("(PixPatHandle penPattern) -> None")},
	{"SetPortFillPixPat", (PyCFunction)GrafObj_SetPortFillPixPat, 1,
	 PyDoc_STR("(PixPatHandle penPattern) -> None")},
	{"SetPortBackPixPat", (PyCFunction)GrafObj_SetPortBackPixPat, 1,
	 PyDoc_STR("(PixPatHandle backPattern) -> None")},
	{"SetPortPenSize", (PyCFunction)GrafObj_SetPortPenSize, 1,
	 PyDoc_STR("(Point penSize) -> None")},
	{"SetPortPenMode", (PyCFunction)GrafObj_SetPortPenMode, 1,
	 PyDoc_STR("(SInt32 penMode) -> None")},
	{"SetPortFracHPenLocation", (PyCFunction)GrafObj_SetPortFracHPenLocation, 1,
	 PyDoc_STR("(short pnLocHFrac) -> None")},
	{"DisposePort", (PyCFunction)GrafObj_DisposePort, 1,
	 PyDoc_STR("() -> None")},
	{"QDLocalToGlobalPoint", (PyCFunction)GrafObj_QDLocalToGlobalPoint, 1,
	 PyDoc_STR("(Point point) -> (Point point)")},
	{"QDGlobalToLocalPoint", (PyCFunction)GrafObj_QDGlobalToLocalPoint, 1,
	 PyDoc_STR("(Point point) -> (Point point)")},
	{"QDLocalToGlobalRect", (PyCFunction)GrafObj_QDLocalToGlobalRect, 1,
	 PyDoc_STR("() -> (Rect bounds)")},
	{"QDGlobalToLocalRect", (PyCFunction)GrafObj_QDGlobalToLocalRect, 1,
	 PyDoc_STR("() -> (Rect bounds)")},
	{"QDLocalToGlobalRegion", (PyCFunction)GrafObj_QDLocalToGlobalRegion, 1,
	 PyDoc_STR("(RgnHandle region) -> (RgnHandle _rv)")},
	{"QDGlobalToLocalRegion", (PyCFunction)GrafObj_QDGlobalToLocalRegion, 1,
	 PyDoc_STR("(RgnHandle region) -> (RgnHandle _rv)")},
	{"QDIsPortBuffered", (PyCFunction)GrafObj_QDIsPortBuffered, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"QDIsPortBufferDirty", (PyCFunction)GrafObj_QDIsPortBufferDirty, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"QDFlushPortBuffer", (PyCFunction)GrafObj_QDFlushPortBuffer, 1,
	 PyDoc_STR("(RgnHandle region) -> None")},
	{"QDGetDirtyRegion", (PyCFunction)GrafObj_QDGetDirtyRegion, 1,
	 PyDoc_STR("(RgnHandle rgn) -> None")},
	{"QDSetDirtyRegion", (PyCFunction)GrafObj_QDSetDirtyRegion, 1,
	 PyDoc_STR("(RgnHandle rgn) -> None")},
	{NULL, NULL, 0}
};

static PyObject *GrafObj_get_visRgn(GrafPortObject *self, void *closure)
{
	RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
	            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(self->ob_itself, h));
	            
}

#define GrafObj_set_visRgn NULL

static PyObject *GrafObj_get_clipRgn(GrafPortObject *self, void *closure)
{
	RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
	            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(self->ob_itself, h));
	            
}

#define GrafObj_set_clipRgn NULL

static PyGetSetDef GrafObj_getsetlist[] = {
	{"visRgn", (getter)GrafObj_get_visRgn, (setter)GrafObj_set_visRgn, "Convenience attribute: return a copy of the visible region"},
	{"clipRgn", (getter)GrafObj_get_clipRgn, (setter)GrafObj_set_clipRgn, "Convenience attribute: return a copy of the clipping region"},
	{NULL, NULL, NULL, NULL},
};


#define GrafObj_compare NULL

#define GrafObj_repr NULL

#define GrafObj_hash NULL
#define GrafObj_tp_init 0

#define GrafObj_tp_alloc PyType_GenericAlloc

static PyObject *GrafObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
	PyObject *_self;
	GrafPtr itself;
	char *kw[] = {"itself", 0};

	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, GrafObj_Convert, &itself)) return NULL;
	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
	((GrafPortObject *)_self)->ob_itself = itself;
	return _self;
}

#define GrafObj_tp_free PyObject_Del


PyTypeObject GrafPort_Type = {
	PyObject_HEAD_INIT(NULL)
	0, /*ob_size*/
	"_Qd.GrafPort", /*tp_name*/
	sizeof(GrafPortObject), /*tp_basicsize*/
	0, /*tp_itemsize*/
	/* methods */
	(destructor) GrafObj_dealloc, /*tp_dealloc*/
	0, /*tp_print*/
	(getattrfunc)0, /*tp_getattr*/
	(setattrfunc)0, /*tp_setattr*/
	(cmpfunc) GrafObj_compare, /*tp_compare*/
	(reprfunc) GrafObj_repr, /*tp_repr*/
	(PyNumberMethods *)0, /* tp_as_number */
	(PySequenceMethods *)0, /* tp_as_sequence */
	(PyMappingMethods *)0, /* tp_as_mapping */
	(hashfunc) GrafObj_hash, /*tp_hash*/
	0, /*tp_call*/
	0, /*tp_str*/
	PyObject_GenericGetAttr, /*tp_getattro*/
	PyObject_GenericSetAttr, /*tp_setattro */
	0, /*tp_as_buffer*/
	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
	0, /*tp_doc*/
	0, /*tp_traverse*/
	0, /*tp_clear*/
	0, /*tp_richcompare*/
	0, /*tp_weaklistoffset*/
	0, /*tp_iter*/
	0, /*tp_iternext*/
	GrafObj_methods, /* tp_methods */
	0, /*tp_members*/
	GrafObj_getsetlist, /*tp_getset*/
	0, /*tp_base*/
	0, /*tp_dict*/
	0, /*tp_descr_get*/
	0, /*tp_descr_set*/
	0, /*tp_dictoffset*/
	GrafObj_tp_init, /* tp_init */
	GrafObj_tp_alloc, /* tp_alloc */
	GrafObj_tp_new, /* tp_new */
	GrafObj_tp_free, /* tp_free */
};

/* -------------------- End object type GrafPort -------------------- */


/* ----------------------- Object type BitMap ----------------------- */

PyTypeObject BitMap_Type;

#define BMObj_Check(x) ((x)->ob_type == &BitMap_Type || PyObject_TypeCheck((x), &BitMap_Type))

typedef struct BitMapObject {
	PyObject_HEAD
	BitMapPtr ob_itself;
	PyObject *referred_object;
	BitMap *referred_bitmap;
} BitMapObject;

PyObject *BMObj_New(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;
}

int BMObj_Convert(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(BitMapObject *self)
{
	Py_XDECREF(self->referred_object);
	if (self->referred_bitmap) free(self->referred_bitmap);
	self->ob_type->tp_free((PyObject *)self);
}

static PyObject *BMObj_getdata(BitMapObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;

	int from, length;
	char *cp;

	if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
	        return NULL;
	cp = _self->ob_itself->baseAddr+from;
	_res = PyString_FromStringAndSize(cp, length);
	return _res;

}

static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;

	int from, length;
	char *cp, *icp;

	if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
	        return NULL;
	cp = _self->ob_itself->baseAddr+from;
	memcpy(cp, icp, length);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;

}

static PyMethodDef BMObj_methods[] = {
	{"getdata", (PyCFunction)BMObj_getdata, 1,
	 PyDoc_STR("(int start, int size) -> string. Return bytes from the bitmap")},
	{"putdata", (PyCFunction)BMObj_putdata, 1,
	 PyDoc_STR("(int start, string data). Store bytes into the bitmap")},
	{NULL, NULL, 0}
};

static PyObject *BMObj_get_baseAddr(BitMapObject *self, void *closure)
{
	return PyInt_FromLong((long)self->ob_itself->baseAddr);
}

#define BMObj_set_baseAddr NULL

static PyObject *BMObj_get_rowBytes(BitMapObject *self, void *closure)
{
	return PyInt_FromLong((long)self->ob_itself->rowBytes);
}

#define BMObj_set_rowBytes NULL

static PyObject *BMObj_get_bounds(BitMapObject *self, void *closure)
{
	return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);
}

#define BMObj_set_bounds NULL

static PyObject *BMObj_get_bitmap_data(BitMapObject *self, void *closure)
{
	return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
}

#define BMObj_set_bitmap_data NULL

static PyObject *BMObj_get_pixmap_data(BitMapObject *self, void *closure)
{
	return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
}

#define BMObj_set_pixmap_data NULL

static PyGetSetDef BMObj_getsetlist[] = {
	{"baseAddr", (getter)BMObj_get_baseAddr, (setter)BMObj_set_baseAddr, NULL},
	{"rowBytes", (getter)BMObj_get_rowBytes, (setter)BMObj_set_rowBytes, NULL},
	{"bounds", (getter)BMObj_get_bounds, (setter)BMObj_set_bounds, NULL},
	{"bitmap_data", (getter)BMObj_get_bitmap_data, (setter)BMObj_set_bitmap_data, NULL},
	{"pixmap_data", (getter)BMObj_get_pixmap_data, (setter)BMObj_set_pixmap_data, NULL},
	{NULL, NULL, NULL, NULL},
};


#define BMObj_compare NULL

#define BMObj_repr NULL

#define BMObj_hash NULL
#define BMObj_tp_init 0

#define BMObj_tp_alloc PyType_GenericAlloc

static PyObject *BMObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
{
	PyObject *_self;
	BitMapPtr itself;
	char *kw[] = {"itself", 0};

	if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, BMObj_Convert, &itself)) return NULL;
	if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
	((BitMapObject *)_self)->ob_itself = itself;
	return _self;
}

#define BMObj_tp_free PyObject_Del


PyTypeObject BitMap_Type = {
	PyObject_HEAD_INIT(NULL)
	0, /*ob_size*/
	"_Qd.BitMap", /*tp_name*/
	sizeof(BitMapObject), /*tp_basicsize*/
	0, /*tp_itemsize*/
	/* methods */
	(destructor) BMObj_dealloc, /*tp_dealloc*/
	0, /*tp_print*/
	(getattrfunc)0, /*tp_getattr*/
	(setattrfunc)0, /*tp_setattr*/
	(cmpfunc) BMObj_compare, /*tp_compare*/
	(reprfunc) BMObj_repr, /*tp_repr*/
	(PyNumberMethods *)0, /* tp_as_number */
	(PySequenceMethods *)0, /* tp_as_sequence */
	(PyMappingMethods *)0, /* tp_as_mapping */
	(hashfunc) BMObj_hash, /*tp_hash*/
	0, /*tp_call*/
	0, /*tp_str*/
	PyObject_GenericGetAttr, /*tp_getattro*/
	PyObject_GenericSetAttr, /*tp_setattro */
	0, /*tp_as_buffer*/
	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
	0, /*tp_doc*/
	0, /*tp_traverse*/
	0, /*tp_clear*/
	0, /*tp_richcompare*/
	0, /*tp_weaklistoffset*/
	0, /*tp_iter*/
	0, /*tp_iternext*/
	BMObj_methods, /* tp_methods */
	0, /*tp_members*/
	BMObj_getsetlist, /*tp_getset*/
	0, /*tp_base*/
	0, /*tp_dict*/
	0, /*tp_descr_get*/
	0, /*tp_descr_set*/
	0, /*tp_dictoffset*/
	BMObj_tp_init, /* tp_init */
	BMObj_tp_alloc, /* tp_alloc */
	BMObj_tp_new, /* tp_new */
	BMObj_tp_free, /* tp_free */
};

/* --------------------- End object type BitMap --------------------- */


static PyObject *Qd_GetPort(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	GrafPtr port;
#ifndef GetPort
	PyMac_PRECHECK(GetPort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetPort(&port);
	_res = Py_BuildValue("O&",
	                     GrafObj_New, port);
	return _res;
}

static PyObject *Qd_GrafDevice(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short device;
#ifndef GrafDevice
	PyMac_PRECHECK(GrafDevice);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &device))
		return NULL;
	GrafDevice(device);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Qd_SetPortBits(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	BitMapPtr bm;
#ifndef SetPortBits
	PyMac_PRECHECK(SetPortBits);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short width;
	short height;
#ifndef PortSize
	PyMac_PRECHECK(PortSize);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short leftGlobal;
	short topGlobal;
#ifndef MovePortTo
	PyMac_PRECHECK(MovePortTo);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short h;
	short v;
#ifndef SetOrigin
	PyMac_PRECHECK(SetOrigin);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle rgn;
#ifndef SetClip
	PyMac_PRECHECK(SetClip);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle rgn;
#ifndef GetClip
	PyMac_PRECHECK(GetClip);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Rect r;
#ifndef ClipRect
	PyMac_PRECHECK(ClipRect);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Pattern *pat__in__;
	int pat__in_len__;
#ifndef BackPat
	PyMac_PRECHECK(BackPat);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef InitCursor
	PyMac_PRECHECK(InitCursor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	InitCursor();
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Qd_MacSetCursor(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Cursor *crsr__in__;
	int crsr__in_len__;
#ifndef MacSetCursor
	PyMac_PRECHECK(MacSetCursor);
#endif
	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(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef HideCursor
	PyMac_PRECHECK(HideCursor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	HideCursor();
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Qd_MacShowCursor(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef MacShowCursor
	PyMac_PRECHECK(MacShowCursor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	MacShowCursor();
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Qd_ObscureCursor(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef ObscureCursor
	PyMac_PRECHECK(ObscureCursor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	ObscureCursor();
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Qd_HidePen(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
#ifndef HidePen
	PyMac_PRECHECK(HidePen);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	HidePen();
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

stati…