cpython/Mac/Modules/win/_Winmodule.c

/* ========================== Module _Win =========================== */

#include "Python.h"



#ifdef _WIN32
#include "pywintoolbox.h"
#else
#include "macglue.h"
#include "pymactoolbox.h"
#endif

/* 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)


#ifdef WITHOUT_FRAMEWORKS
#include <Windows.h>
#else
#include <Carbon/Carbon.h>
#endif

#ifdef USE_TOOLBOX_OBJECT_GLUE
extern PyObject *_WinObj_New(WindowRef);
extern PyObject *_WinObj_WhichWindow(WindowRef);
extern int _WinObj_Convert(PyObject *, WindowRef *);

#define WinObj_New _WinObj_New
#define WinObj_WhichWindow _WinObj_WhichWindow
#define WinObj_Convert _WinObj_Convert
#endif

/* Classic calls that we emulate in carbon mode */
#define GetWindowUpdateRgn(win, rgn) GetWindowRegion((win), kWindowUpdateRgn, (rgn))
#define GetWindowStructureRgn(win, rgn) GetWindowRegion((win), kWindowStructureRgn, (rgn))
#define GetWindowContentRgn(win, rgn) GetWindowRegion((win), kWindowContentRgn, (rgn))

/* Function to dispose a window, with a "normal" calling sequence */
static void
PyMac_AutoDisposeWindow(WindowPtr w)
{
	DisposeWindow(w);
}

static PyObject *Win_Error;

/* ----------------------- Object type Window ----------------------- */

PyTypeObject Window_Type;

#define WinObj_Check(x) ((x)->ob_type == &Window_Type || PyObject_TypeCheck((x), &Window_Type))

typedef struct WindowObject {
	PyObject_HEAD
	WindowPtr ob_itself;
	void (*ob_freeit)(WindowPtr ptr);
} WindowObject;

PyObject *WinObj_New(WindowPtr itself)
{
	WindowObject *it;
	if (itself == NULL) return PyMac_Error(resNotFound);
	/* XXXX Or should we use WhichWindow code here? */
	it = PyObject_NEW(WindowObject, &Window_Type);
	if (it == NULL) return NULL;
	it->ob_itself = itself;
	it->ob_freeit = NULL;
	if (GetWRefCon(itself) == 0)
	{
		SetWRefCon(itself, (long)it);
		it->ob_freeit = PyMac_AutoDisposeWindow;
	}
	return (PyObject *)it;
}
int WinObj_Convert(PyObject *v, WindowPtr *p_itself)
{

	if (v == Py_None) { *p_itself = NULL; return 1; }
	if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }

	{
		DialogRef dlg;
		if (DlgObj_Convert(v, &dlg) && dlg) {
			*p_itself = GetDialogWindow(dlg);
			return 1;
		}
		PyErr_Clear();
	}
	if (!WinObj_Check(v))
	{
		PyErr_SetString(PyExc_TypeError, "Window required");
		return 0;
	}
	*p_itself = ((WindowObject *)v)->ob_itself;
	return 1;
}

static void WinObj_dealloc(WindowObject *self)
{
	if (self->ob_freeit && self->ob_itself)
	{
		SetWRefCon(self->ob_itself, 0);
		self->ob_freeit(self->ob_itself);
	}
	self->ob_itself = NULL;
	self->ob_freeit = NULL;
	self->ob_type->tp_free((PyObject *)self);
}

static PyObject *WinObj_GetWindowOwnerCount(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	UInt32 outCount;
#ifndef GetWindowOwnerCount
	PyMac_PRECHECK(GetWindowOwnerCount);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowOwnerCount(_self->ob_itself,
	                           &outCount);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     outCount);
	return _res;
}

static PyObject *WinObj_CloneWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef CloneWindow
	PyMac_PRECHECK(CloneWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = CloneWindow(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowRetainCount(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	ItemCount _rv;
#ifndef GetWindowRetainCount
	PyMac_PRECHECK(GetWindowRetainCount);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetWindowRetainCount(_self->ob_itself);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyObject *WinObj_RetainWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef RetainWindow
	PyMac_PRECHECK(RetainWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = RetainWindow(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_ReleaseWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef ReleaseWindow
	PyMac_PRECHECK(ReleaseWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = ReleaseWindow(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_ReshapeCustomWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef ReshapeCustomWindow
	PyMac_PRECHECK(ReshapeCustomWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = ReshapeCustomWindow(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowWidgetHilite(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowDefPartCode outHilite;
#ifndef GetWindowWidgetHilite
	PyMac_PRECHECK(GetWindowWidgetHilite);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowWidgetHilite(_self->ob_itself,
	                             &outHilite);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("h",
	                     outHilite);
	return _res;
}

static PyObject *WinObj_GetWindowClass(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowClass outClass;
#ifndef GetWindowClass
	PyMac_PRECHECK(GetWindowClass);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowClass(_self->ob_itself,
	                      &outClass);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     outClass);
	return _res;
}

static PyObject *WinObj_GetWindowAttributes(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowAttributes outAttributes;
#ifndef GetWindowAttributes
	PyMac_PRECHECK(GetWindowAttributes);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowAttributes(_self->ob_itself,
	                           &outAttributes);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     outAttributes);
	return _res;
}

static PyObject *WinObj_ChangeWindowAttributes(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowAttributes setTheseAttributes;
	WindowAttributes clearTheseAttributes;
#ifndef ChangeWindowAttributes
	PyMac_PRECHECK(ChangeWindowAttributes);
#endif
	if (!PyArg_ParseTuple(_args, "ll",
	                      &setTheseAttributes,
	                      &clearTheseAttributes))
		return NULL;
	_err = ChangeWindowAttributes(_self->ob_itself,
	                              setTheseAttributes,
	                              clearTheseAttributes);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_SetWindowClass(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowClass inWindowClass;
#ifndef SetWindowClass
	PyMac_PRECHECK(SetWindowClass);
#endif
	if (!PyArg_ParseTuple(_args, "l",
	                      &inWindowClass))
		return NULL;
	_err = SetWindowClass(_self->ob_itself,
	                      inWindowClass);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_SetWindowModality(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowModality inModalKind;
	WindowPtr inUnavailableWindow;
#ifndef SetWindowModality
	PyMac_PRECHECK(SetWindowModality);
#endif
	if (!PyArg_ParseTuple(_args, "lO&",
	                      &inModalKind,
	                      WinObj_Convert, &inUnavailableWindow))
		return NULL;
	_err = SetWindowModality(_self->ob_itself,
	                         inModalKind,
	                         inUnavailableWindow);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowModality(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowModality outModalKind;
	WindowPtr outUnavailableWindow;
#ifndef GetWindowModality
	PyMac_PRECHECK(GetWindowModality);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowModality(_self->ob_itself,
	                         &outModalKind,
	                         &outUnavailableWindow);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("lO&",
	                     outModalKind,
	                     WinObj_WhichWindow, outUnavailableWindow);
	return _res;
}

static PyObject *WinObj_SetWindowContentColor(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	RGBColor color;
#ifndef SetWindowContentColor
	PyMac_PRECHECK(SetWindowContentColor);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      QdRGB_Convert, &color))
		return NULL;
	_err = SetWindowContentColor(_self->ob_itself,
	                             &color);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowContentColor(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	RGBColor color;
#ifndef GetWindowContentColor
	PyMac_PRECHECK(GetWindowContentColor);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowContentColor(_self->ob_itself,
	                             &color);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     QdRGB_New, &color);
	return _res;
}

static PyObject *WinObj_GetWindowContentPattern(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	PixPatHandle outPixPat;
#ifndef GetWindowContentPattern
	PyMac_PRECHECK(GetWindowContentPattern);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &outPixPat))
		return NULL;
	_err = GetWindowContentPattern(_self->ob_itself,
	                               outPixPat);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_SetWindowContentPattern(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	PixPatHandle pixPat;
#ifndef SetWindowContentPattern
	PyMac_PRECHECK(SetWindowContentPattern);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &pixPat))
		return NULL;
	_err = SetWindowContentPattern(_self->ob_itself,
	                               pixPat);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_ScrollWindowRect(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect inScrollRect;
	SInt16 inHPixels;
	SInt16 inVPixels;
	ScrollWindowOptions inOptions;
	RgnHandle outExposedRgn;
#ifndef ScrollWindowRect
	PyMac_PRECHECK(ScrollWindowRect);
#endif
	if (!PyArg_ParseTuple(_args, "O&hhlO&",
	                      PyMac_GetRect, &inScrollRect,
	                      &inHPixels,
	                      &inVPixels,
	                      &inOptions,
	                      ResObj_Convert, &outExposedRgn))
		return NULL;
	_err = ScrollWindowRect(_self->ob_itself,
	                        &inScrollRect,
	                        inHPixels,
	                        inVPixels,
	                        inOptions,
	                        outExposedRgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_ScrollWindowRegion(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	RgnHandle inScrollRgn;
	SInt16 inHPixels;
	SInt16 inVPixels;
	ScrollWindowOptions inOptions;
	RgnHandle outExposedRgn;
#ifndef ScrollWindowRegion
	PyMac_PRECHECK(ScrollWindowRegion);
#endif
	if (!PyArg_ParseTuple(_args, "O&hhlO&",
	                      ResObj_Convert, &inScrollRgn,
	                      &inHPixels,
	                      &inVPixels,
	                      &inOptions,
	                      ResObj_Convert, &outExposedRgn))
		return NULL;
	_err = ScrollWindowRegion(_self->ob_itself,
	                          inScrollRgn,
	                          inHPixels,
	                          inVPixels,
	                          inOptions,
	                          outExposedRgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

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

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

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

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

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

static PyObject *WinObj_SendBehind(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr behindWindow;
#ifndef SendBehind
	PyMac_PRECHECK(SendBehind);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      WinObj_Convert, &behindWindow))
		return NULL;
	SendBehind(_self->ob_itself,
	           behindWindow);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_GetNextWindowOfClass(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	WindowClass inWindowClass;
	Boolean mustBeVisible;
#ifndef GetNextWindowOfClass
	PyMac_PRECHECK(GetNextWindowOfClass);
#endif
	if (!PyArg_ParseTuple(_args, "lb",
	                      &inWindowClass,
	                      &mustBeVisible))
		return NULL;
	_rv = GetNextWindowOfClass(_self->ob_itself,
	                           inWindowClass,
	                           mustBeVisible);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *WinObj_SetWindowAlternateTitle(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	CFStringRef inTitle;
#ifndef SetWindowAlternateTitle
	PyMac_PRECHECK(SetWindowAlternateTitle);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      CFStringRefObj_Convert, &inTitle))
		return NULL;
	_err = SetWindowAlternateTitle(_self->ob_itself,
	                               inTitle);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_CopyWindowAlternateTitle(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	CFStringRef outTitle;
#ifndef CopyWindowAlternateTitle
	PyMac_PRECHECK(CopyWindowAlternateTitle);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = CopyWindowAlternateTitle(_self->ob_itself,
	                                &outTitle);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     CFStringRefObj_New, outTitle);
	return _res;
}

static PyObject *WinObj_HiliteWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean fHilite;
#ifndef HiliteWindow
	PyMac_PRECHECK(HiliteWindow);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &fHilite))
		return NULL;
	HiliteWindow(_self->ob_itself,
	             fHilite);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_SetWRefCon(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	long data;
#ifndef SetWRefCon
	PyMac_PRECHECK(SetWRefCon);
#endif
	if (!PyArg_ParseTuple(_args, "l",
	                      &data))
		return NULL;
	SetWRefCon(_self->ob_itself,
	           data);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWRefCon(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	long _rv;
#ifndef GetWRefCon
	PyMac_PRECHECK(GetWRefCon);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetWRefCon(_self->ob_itself);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyObject *WinObj_SetWindowPic(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PicHandle pic;
#ifndef SetWindowPic
	PyMac_PRECHECK(SetWindowPic);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &pic))
		return NULL;
	SetWindowPic(_self->ob_itself,
	             pic);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowPic(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	PicHandle _rv;
#ifndef GetWindowPic
	PyMac_PRECHECK(GetWindowPic);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetWindowPic(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

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

static PyObject *WinObj_GetWindowFeatures(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	UInt32 outFeatures;
#ifndef GetWindowFeatures
	PyMac_PRECHECK(GetWindowFeatures);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowFeatures(_self->ob_itself,
	                         &outFeatures);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     outFeatures);
	return _res;
}

static PyObject *WinObj_GetWindowRegion(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowRegionCode inRegionCode;
	RgnHandle ioWinRgn;
#ifndef GetWindowRegion
	PyMac_PRECHECK(GetWindowRegion);
#endif
	if (!PyArg_ParseTuple(_args, "HO&",
	                      &inRegionCode,
	                      ResObj_Convert, &ioWinRgn))
		return NULL;
	_err = GetWindowRegion(_self->ob_itself,
	                       inRegionCode,
	                       ioWinRgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowStructureWidths(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect outRect;
#ifndef GetWindowStructureWidths
	PyMac_PRECHECK(GetWindowStructureWidths);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowStructureWidths(_self->ob_itself,
	                                &outRect);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &outRect);
	return _res;
}

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

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

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

static PyObject *WinObj_InvalWindowRect(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect bounds;
#ifndef InvalWindowRect
	PyMac_PRECHECK(InvalWindowRect);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetRect, &bounds))
		return NULL;
	_err = InvalWindowRect(_self->ob_itself,
	                       &bounds);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_ValidWindowRect(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect bounds;
#ifndef ValidWindowRect
	PyMac_PRECHECK(ValidWindowRect);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetRect, &bounds))
		return NULL;
	_err = ValidWindowRect(_self->ob_itself,
	                       &bounds);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_SetWTitle(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Str255 title;
#ifndef SetWTitle
	PyMac_PRECHECK(SetWTitle);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetStr255, title))
		return NULL;
	SetWTitle(_self->ob_itself,
	          title);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWTitle(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Str255 title;
#ifndef GetWTitle
	PyMac_PRECHECK(GetWTitle);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	GetWTitle(_self->ob_itself,
	          title);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildStr255, title);
	return _res;
}

static PyObject *WinObj_SetWindowTitleWithCFString(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	CFStringRef inString;
#ifndef SetWindowTitleWithCFString
	PyMac_PRECHECK(SetWindowTitleWithCFString);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      CFStringRefObj_Convert, &inString))
		return NULL;
	_err = SetWindowTitleWithCFString(_self->ob_itself,
	                                  inString);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_CopyWindowTitleAsCFString(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	CFStringRef outString;
#ifndef CopyWindowTitleAsCFString
	PyMac_PRECHECK(CopyWindowTitleAsCFString);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = CopyWindowTitleAsCFString(_self->ob_itself,
	                                 &outString);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     CFStringRefObj_New, outString);
	return _res;
}

static PyObject *WinObj_SetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	FSSpec inFile;
#ifndef SetWindowProxyFSSpec
	PyMac_PRECHECK(SetWindowProxyFSSpec);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetFSSpec, &inFile))
		return NULL;
	_err = SetWindowProxyFSSpec(_self->ob_itself,
	                            &inFile);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowProxyFSSpec(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	FSSpec outFile;
#ifndef GetWindowProxyFSSpec
	PyMac_PRECHECK(GetWindowProxyFSSpec);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowProxyFSSpec(_self->ob_itself,
	                            &outFile);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildFSSpec, &outFile);
	return _res;
}

static PyObject *WinObj_SetWindowProxyAlias(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	AliasHandle alias;
#ifndef SetWindowProxyAlias
	PyMac_PRECHECK(SetWindowProxyAlias);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &alias))
		return NULL;
	_err = SetWindowProxyAlias(_self->ob_itself,
	                           alias);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowProxyAlias(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	AliasHandle alias;
#ifndef GetWindowProxyAlias
	PyMac_PRECHECK(GetWindowProxyAlias);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowProxyAlias(_self->ob_itself,
	                           &alias);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     ResObj_New, alias);
	return _res;
}

static PyObject *WinObj_SetWindowProxyCreatorAndType(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	OSType fileCreator;
	OSType fileType;
	SInt16 vRefNum;
#ifndef SetWindowProxyCreatorAndType
	PyMac_PRECHECK(SetWindowProxyCreatorAndType);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&h",
	                      PyMac_GetOSType, &fileCreator,
	                      PyMac_GetOSType, &fileType,
	                      &vRefNum))
		return NULL;
	_err = SetWindowProxyCreatorAndType(_self->ob_itself,
	                                    fileCreator,
	                                    fileType,
	                                    vRefNum);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowProxyIcon(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	IconRef outIcon;
#ifndef GetWindowProxyIcon
	PyMac_PRECHECK(GetWindowProxyIcon);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowProxyIcon(_self->ob_itself,
	                          &outIcon);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     ResObj_New, outIcon);
	return _res;
}

static PyObject *WinObj_SetWindowProxyIcon(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	IconRef icon;
#ifndef SetWindowProxyIcon
	PyMac_PRECHECK(SetWindowProxyIcon);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &icon))
		return NULL;
	_err = SetWindowProxyIcon(_self->ob_itself,
	                          icon);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_RemoveWindowProxy(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef RemoveWindowProxy
	PyMac_PRECHECK(RemoveWindowProxy);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = RemoveWindowProxy(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_BeginWindowProxyDrag(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	DragReference outNewDrag;
	RgnHandle outDragOutlineRgn;
#ifndef BeginWindowProxyDrag
	PyMac_PRECHECK(BeginWindowProxyDrag);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &outDragOutlineRgn))
		return NULL;
	_err = BeginWindowProxyDrag(_self->ob_itself,
	                            &outNewDrag,
	                            outDragOutlineRgn);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     DragObj_New, outNewDrag);
	return _res;
}

static PyObject *WinObj_EndWindowProxyDrag(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	DragReference theDrag;
#ifndef EndWindowProxyDrag
	PyMac_PRECHECK(EndWindowProxyDrag);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      DragObj_Convert, &theDrag))
		return NULL;
	_err = EndWindowProxyDrag(_self->ob_itself,
	                          theDrag);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_TrackWindowProxyFromExistingDrag(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Point startPt;
	DragReference drag;
	RgnHandle inDragOutlineRgn;
#ifndef TrackWindowProxyFromExistingDrag
	PyMac_PRECHECK(TrackWindowProxyFromExistingDrag);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&O&",
	                      PyMac_GetPoint, &startPt,
	                      DragObj_Convert, &drag,
	                      ResObj_Convert, &inDragOutlineRgn))
		return NULL;
	_err = TrackWindowProxyFromExistingDrag(_self->ob_itself,
	                                        startPt,
	                                        drag,
	                                        inDragOutlineRgn);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_TrackWindowProxyDrag(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Point startPt;
#ifndef TrackWindowProxyDrag
	PyMac_PRECHECK(TrackWindowProxyDrag);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &startPt))
		return NULL;
	_err = TrackWindowProxyDrag(_self->ob_itself,
	                            startPt);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_SetWindowModified(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Boolean modified;
#ifndef SetWindowModified
	PyMac_PRECHECK(SetWindowModified);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &modified))
		return NULL;
	_err = SetWindowModified(_self->ob_itself,
	                         modified);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_IsWindowPathSelectClick(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	EventRecord event;
#ifndef IsWindowPathSelectClick
	PyMac_PRECHECK(IsWindowPathSelectClick);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetEventRecord, &event))
		return NULL;
	_rv = IsWindowPathSelectClick(_self->ob_itself,
	                              &event);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *WinObj_WindowPathSelect(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	MenuHandle menu;
	SInt32 outMenuResult;
#ifndef WindowPathSelect
	PyMac_PRECHECK(WindowPathSelect);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      MenuObj_Convert, &menu))
		return NULL;
	_err = WindowPathSelect(_self->ob_itself,
	                        menu,
	                        &outMenuResult);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     outMenuResult);
	return _res;
}

static PyObject *WinObj_HiliteWindowFrameForDrag(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Boolean hilited;
#ifndef HiliteWindowFrameForDrag
	PyMac_PRECHECK(HiliteWindowFrameForDrag);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &hilited))
		return NULL;
	_err = HiliteWindowFrameForDrag(_self->ob_itself,
	                                hilited);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_TransitionWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowTransitionEffect effect;
	WindowTransitionAction action;
	Rect rect;
#ifndef TransitionWindow
	PyMac_PRECHECK(TransitionWindow);
#endif
	if (!PyArg_ParseTuple(_args, "llO&",
	                      &effect,
	                      &action,
	                      PyMac_GetRect, &rect))
		return NULL;
	_err = TransitionWindow(_self->ob_itself,
	                        effect,
	                        action,
	                        &rect);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

#if TARGET_API_MAC_OSX

static PyObject *WinObj_TransitionWindowAndParent(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowPtr parentWindow;
	WindowTransitionEffect effect;
	WindowTransitionAction action;
	Rect rect;
#ifndef TransitionWindowAndParent
	PyMac_PRECHECK(TransitionWindowAndParent);
#endif
	if (!PyArg_ParseTuple(_args, "O&llO&",
	                      WinObj_Convert, &parentWindow,
	                      &effect,
	                      &action,
	                      PyMac_GetRect, &rect))
		return NULL;
	_err = TransitionWindowAndParent(_self->ob_itself,
	                                 parentWindow,
	                                 effect,
	                                 action,
	                                 &rect);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}
#endif

static PyObject *WinObj_MacMoveWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short hGlobal;
	short vGlobal;
	Boolean front;
#ifndef MacMoveWindow
	PyMac_PRECHECK(MacMoveWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hhb",
	                      &hGlobal,
	                      &vGlobal,
	                      &front))
		return NULL;
	MacMoveWindow(_self->ob_itself,
	              hGlobal,
	              vGlobal,
	              front);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_SizeWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short w;
	short h;
	Boolean fUpdate;
#ifndef SizeWindow
	PyMac_PRECHECK(SizeWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hhb",
	                      &w,
	                      &h,
	                      &fUpdate))
		return NULL;
	SizeWindow(_self->ob_itself,
	           w,
	           h,
	           fUpdate);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GrowWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	long _rv;
	Point startPt;
	Rect bBox;
#ifndef GrowWindow
	PyMac_PRECHECK(GrowWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&",
	                      PyMac_GetPoint, &startPt,
	                      PyMac_GetRect, &bBox))
		return NULL;
	_rv = GrowWindow(_self->ob_itself,
	                 startPt,
	                 &bBox);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyObject *WinObj_DragWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Point startPt;
	Rect boundsRect;
#ifndef DragWindow
	PyMac_PRECHECK(DragWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&",
	                      PyMac_GetPoint, &startPt,
	                      PyMac_GetRect, &boundsRect))
		return NULL;
	DragWindow(_self->ob_itself,
	           startPt,
	           &boundsRect);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_ZoomWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPartCode partCode;
	Boolean front;
#ifndef ZoomWindow
	PyMac_PRECHECK(ZoomWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hb",
	                      &partCode,
	                      &front))
		return NULL;
	ZoomWindow(_self->ob_itself,
	           partCode,
	           front);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

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

static PyObject *WinObj_CollapseWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Boolean collapse;
#ifndef CollapseWindow
	PyMac_PRECHECK(CollapseWindow);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &collapse))
		return NULL;
	_err = CollapseWindow(_self->ob_itself,
	                      collapse);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowBounds(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowRegionCode regionCode;
	Rect globalBounds;
#ifndef GetWindowBounds
	PyMac_PRECHECK(GetWindowBounds);
#endif
	if (!PyArg_ParseTuple(_args, "H",
	                      &regionCode))
		return NULL;
	_err = GetWindowBounds(_self->ob_itself,
	                       regionCode,
	                       &globalBounds);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &globalBounds);
	return _res;
}

static PyObject *WinObj_ResizeWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	Point startPoint;
	Rect sizeConstraints;
	Rect newContentRect;
#ifndef ResizeWindow
	PyMac_PRECHECK(ResizeWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&",
	                      PyMac_GetPoint, &startPoint,
	                      PyMac_GetRect, &sizeConstraints))
		return NULL;
	_rv = ResizeWindow(_self->ob_itself,
	                   startPoint,
	                   &sizeConstraints,
	                   &newContentRect);
	_res = Py_BuildValue("bO&",
	                     _rv,
	                     PyMac_BuildRect, &newContentRect);
	return _res;
}

static PyObject *WinObj_SetWindowBounds(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowRegionCode regionCode;
	Rect globalBounds;
#ifndef SetWindowBounds
	PyMac_PRECHECK(SetWindowBounds);
#endif
	if (!PyArg_ParseTuple(_args, "HO&",
	                      &regionCode,
	                      PyMac_GetRect, &globalBounds))
		return NULL;
	_err = SetWindowBounds(_self->ob_itself,
	                       regionCode,
	                       &globalBounds);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_RepositionWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowPtr parentWindow;
	WindowPositionMethod method;
#ifndef RepositionWindow
	PyMac_PRECHECK(RepositionWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&l",
	                      WinObj_Convert, &parentWindow,
	                      &method))
		return NULL;
	_err = RepositionWindow(_self->ob_itself,
	                        parentWindow,
	                        method);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_MoveWindowStructure(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	short hGlobal;
	short vGlobal;
#ifndef MoveWindowStructure
	PyMac_PRECHECK(MoveWindowStructure);
#endif
	if (!PyArg_ParseTuple(_args, "hh",
	                      &hGlobal,
	                      &vGlobal))
		return NULL;
	_err = MoveWindowStructure(_self->ob_itself,
	                           hGlobal,
	                           vGlobal);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_IsWindowInStandardState(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	Point idealSize;
	Rect idealStandardState;
#ifndef IsWindowInStandardState
	PyMac_PRECHECK(IsWindowInStandardState);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = IsWindowInStandardState(_self->ob_itself,
	                              &idealSize,
	                              &idealStandardState);
	_res = Py_BuildValue("bO&O&",
	                     _rv,
	                     PyMac_BuildPoint, idealSize,
	                     PyMac_BuildRect, &idealStandardState);
	return _res;
}

static PyObject *WinObj_ZoomWindowIdeal(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowPartCode partCode;
	Point ioIdealSize;
#ifndef ZoomWindowIdeal
	PyMac_PRECHECK(ZoomWindowIdeal);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &partCode))
		return NULL;
	_err = ZoomWindowIdeal(_self->ob_itself,
	                       partCode,
	                       &ioIdealSize);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildPoint, ioIdealSize);
	return _res;
}

static PyObject *WinObj_GetWindowIdealUserState(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect userState;
#ifndef GetWindowIdealUserState
	PyMac_PRECHECK(GetWindowIdealUserState);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetWindowIdealUserState(_self->ob_itself,
	                               &userState);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &userState);
	return _res;
}

static PyObject *WinObj_SetWindowIdealUserState(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Rect userState;
#ifndef SetWindowIdealUserState
	PyMac_PRECHECK(SetWindowIdealUserState);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetRect, &userState))
		return NULL;
	_err = SetWindowIdealUserState(_self->ob_itself,
	                               &userState);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetWindowGreatestAreaDevice(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowRegionCode inRegion;
	GDHandle outGreatestDevice;
	Rect outGreatestDeviceRect;
#ifndef GetWindowGreatestAreaDevice
	PyMac_PRECHECK(GetWindowGreatestAreaDevice);
#endif
	if (!PyArg_ParseTuple(_args, "H",
	                      &inRegion))
		return NULL;
	_err = GetWindowGreatestAreaDevice(_self->ob_itself,
	                                   inRegion,
	                                   &outGreatestDevice,
	                                   &outGreatestDeviceRect);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&O&",
	                     ResObj_New, outGreatestDevice,
	                     PyMac_BuildRect, &outGreatestDeviceRect);
	return _res;
}

static PyObject *WinObj_ConstrainWindowToScreen(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowRegionCode inRegionCode;
	WindowConstrainOptions inOptions;
	Rect inScreenRect;
	Rect outStructure;
#ifndef ConstrainWindowToScreen
	PyMac_PRECHECK(ConstrainWindowToScreen);
#endif
	if (!PyArg_ParseTuple(_args, "HlO&",
	                      &inRegionCode,
	                      &inOptions,
	                      PyMac_GetRect, &inScreenRect))
		return NULL;
	_err = ConstrainWindowToScreen(_self->ob_itself,
	                               inRegionCode,
	                               inOptions,
	                               &inScreenRect,
	                               &outStructure);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &outStructure);
	return _res;
}

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

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

static PyObject *WinObj_ShowHide(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean showFlag;
#ifndef ShowHide
	PyMac_PRECHECK(ShowHide);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &showFlag))
		return NULL;
	ShowHide(_self->ob_itself,
	         showFlag);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_ShowSheetWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowPtr inParentWindow;
#ifndef ShowSheetWindow
	PyMac_PRECHECK(ShowSheetWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      WinObj_Convert, &inParentWindow))
		return NULL;
	_err = ShowSheetWindow(_self->ob_itself,
	                       inParentWindow);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_HideSheetWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef HideSheetWindow
	PyMac_PRECHECK(HideSheetWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = HideSheetWindow(_self->ob_itself);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_GetSheetWindowParent(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowPtr outParentWindow;
#ifndef GetSheetWindowParent
	PyMac_PRECHECK(GetSheetWindowParent);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = GetSheetWindowParent(_self->ob_itself,
	                            &outParentWindow);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     WinObj_WhichWindow, outParentWindow);
	return _res;
}

static PyObject *WinObj_GetWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	OSType propertyCreator;
	OSType propertyTag;
	UInt32 attributes;
#ifndef GetWindowPropertyAttributes
	PyMac_PRECHECK(GetWindowPropertyAttributes);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&",
	                      PyMac_GetOSType, &propertyCreator,
	                      PyMac_GetOSType, &propertyTag))
		return NULL;
	_err = GetWindowPropertyAttributes(_self->ob_itself,
	                                   propertyCreator,
	                                   propertyTag,
	                                   &attributes);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("l",
	                     attributes);
	return _res;
}

static PyObject *WinObj_ChangeWindowPropertyAttributes(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	OSType propertyCreator;
	OSType propertyTag;
	UInt32 attributesToSet;
	UInt32 attributesToClear;
#ifndef ChangeWindowPropertyAttributes
	PyMac_PRECHECK(ChangeWindowPropertyAttributes);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&ll",
	                      PyMac_GetOSType, &propertyCreator,
	                      PyMac_GetOSType, &propertyTag,
	                      &attributesToSet,
	                      &attributesToClear))
		return NULL;
	_err = ChangeWindowPropertyAttributes(_self->ob_itself,
	                                      propertyCreator,
	                                      propertyTag,
	                                      attributesToSet,
	                                      attributesToClear);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *WinObj_TrackBox(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	Point thePt;
	WindowPartCode partCode;
#ifndef TrackBox
	PyMac_PRECHECK(TrackBox);
#endif
	if (!PyArg_ParseTuple(_args, "O&h",
	                      PyMac_GetPoint, &thePt,
	                      &partCode))
		return NULL;
	_rv = TrackBox(_self->ob_itself,
	               thePt,
	               partCode);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *WinObj_TrackGoAway(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	Point thePt;
#ifndef TrackGoAway
	PyMac_PRECHECK(TrackGoAway);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &thePt))
		return NULL;
	_rv = TrackGoAway(_self->ob_itself,
	                  thePt);
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *WinObj_GetWindowPort(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	CGrafPtr _rv;
#ifndef GetWindowPort
	PyMac_PRECHECK(GetWindowPort);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetWindowPort(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     GrafObj_New, _rv);
	return _res;
}

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

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

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

static PyObject *WinObj_MacGetNextWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
#ifndef MacGetNextWindow
	PyMac_PRECHECK(MacGetNextWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = MacGetNextWindow(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

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

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

static PyObject *WinObj_SetWindowKind(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short kind;
#ifndef SetWindowKind
	PyMac_PRECHECK(SetWindowKind);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &kind))
		return NULL;
	SetWindowKind(_self->ob_itself,
	              kind);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

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

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

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

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

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

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

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

static PyObject *WinObj_GetNextWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
#ifndef GetNextWindow
	PyMac_PRECHECK(GetNextWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetNextWindow(_self->ob_itself);
	_res = Py_BuildValue("O&",
	                     WinObj_WhichWindow, _rv);
	return _res;
}

static PyObject *WinObj_MoveWindow(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short hGlobal;
	short vGlobal;
	Boolean front;
#ifndef MoveWindow
	PyMac_PRECHECK(MoveWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hhb",
	                      &hGlobal,
	                      &vGlobal,
	                      &front))
		return NULL;
	MoveWindow(_self->ob_itself,
	           hGlobal,
	           vGlobal,
	           front);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

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

static PyObject *WinObj_AutoDispose(WindowObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;

	int onoff, old = 0;
	if (!PyArg_ParseTuple(_args, "i", &onoff))
		return NULL;
	if ( _self->ob_freeit )
		old = 1;
	if ( onoff )
		_self->ob_freeit = PyMac_AutoDisposeWindow;
	else
		_self->ob_freeit = NULL;
	_res = Py_BuildValue("i", old);
	return _res;

}

static PyMethodDef WinObj_methods[] = {
	{"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
	 PyDoc_STR("() -> (UInt32 outCount)")},
	{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
	 PyDoc_STR("() -> None")},
	{"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
	 PyDoc_STR("() -> (ItemCount _rv)")},
	{"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
	 PyDoc_STR("() -> None")},
	{"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
	 PyDoc_STR("() -> None")},
	{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
	 PyDoc_STR("() -> None")},
	{"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
	 PyDoc_STR("() -> (WindowDefPartCode outHilite)")},
	{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
	 PyDoc_STR("() -> (WindowClass outClass)")},
	{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
	 PyDoc_STR("() -> (WindowAttributes outAttributes)")},
	{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
	 PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")},
	{"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
	 PyDoc_STR("(WindowClass inWindowClass) -> None")},
	{"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
	 PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")},
	{"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
	 PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")},
	{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
	 PyDoc_STR("(RGBColor color) -> None")},
	{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
	 PyDoc_STR("() -> (RGBColor color)")},
	{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
	 PyDoc_STR("(PixPatHandle outPixPat) -> None")},
	{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
	 PyDoc_STR("(PixPatHandle pixPat) -> None")},
	{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
	 PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
	{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
	 PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
	{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
	 PyDoc_STR("() -> None")},
	{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
	{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
	{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
	 PyDoc_STR("() -> None")},
	{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
	 PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
	{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
	 PyDoc_STR("() -> None")},
	{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
	 PyDoc_STR("(WindowPtr behindWindow) -> None")},
	{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
	 PyDoc_STR("() -> None")},
	{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
	 PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
	{"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
	 PyDoc_STR("(CFStringRef inTitle) -> None")},
	{"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
	 PyDoc_STR("() -> (CFStringRef outTitle)")},
	{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
	 PyDoc_STR("(Boolean fHilite) -> None")},
	{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
	 PyDoc_STR("(long data) -> None")},
	{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
	 PyDoc_STR("() -> (long _rv)")},
	{"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
	 PyDoc_STR("(PicHandle pic) -> None")},
	{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
	 PyDoc_STR("() -> (PicHandle _rv)")},
	{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
	 PyDoc_STR("() -> (UInt32 outFeatures)")},
	{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
	 PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")},
	{"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
	 PyDoc_STR("() -> (Rect outRect)")},
	{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
	 PyDoc_STR("() -> None")},
	{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
	 PyDoc_STR("() -> None")},
	{"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
	 PyDoc_STR("(RgnHandle region) -> None")},
	{"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
	 PyDoc_STR("(Rect bounds) -> None")},
	{"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
	 PyDoc_STR("(RgnHandle region) -> None")},
	{"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
	 PyDoc_STR("(Rect bounds) -> None")},
	{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
	 PyDoc_STR("() -> None")},
	{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
	 PyDoc_STR("(Str255 title) -> None")},
	{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
	 PyDoc_STR("() -> (Str255 title)")},
	{"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
	 PyDoc_STR("(CFStringRef inString) -> None")},
	{"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
	 PyDoc_STR("() -> (CFStringRef outString)")},
	{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
	 PyDoc_STR("(FSSpec inFile) -> None")},
	{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
	 PyDoc_STR("() -> (FSSpec outFile)")},
	{"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
	 PyDoc_STR("(AliasHandle alias) -> None")},
	{"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
	 PyDoc_STR("() -> (AliasHandle alias)")},
	{"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
	 PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")},
	{"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
	 PyDoc_STR("() -> (IconRef outIcon)")},
	{"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
	 PyDoc_STR("(IconRef icon) -> None")},
	{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
	 PyDoc_STR("() -> None")},
	{"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
	 PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")},
	{"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
	 PyDoc_STR("(DragReference theDrag) -> None")},
	{"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
	 PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")},
	{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
	 PyDoc_STR("(Point startPt) -> None")},
	{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
	 PyDoc_STR("(Boolean modified) -> None")},
	{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
	 PyDoc_STR("(EventRecord event) -> (Boolean _rv)")},
	{"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
	 PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")},
	{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
	 PyDoc_STR("(Boolean hilited) -> None")},
	{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
	 PyDoc_STR("(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},

#if TARGET_API_MAC_OSX
	{"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
	 PyDoc_STR("(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},
#endif
	{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
	 PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
	{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
	 PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")},
	{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
	 PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")},
	{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
	 PyDoc_STR("(Point startPt, Rect boundsRect) -> None")},
	{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
	 PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")},
	{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
	 PyDoc_STR("(Boolean collapse) -> None")},
	{"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
	 PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")},
	{"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
	 PyDoc_STR("(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)")},
	{"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
	 PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")},
	{"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
	 PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")},
	{"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
	 PyDoc_STR("(short hGlobal, short vGlobal) -> None")},
	{"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
	 PyDoc_STR("() -> (Boolean _rv, Point idealSize, Rect idealStandardState)")},
	{"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
	 PyDoc_STR("(WindowPartCode partCode) -> (Point ioIdealSize)")},
	{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
	 PyDoc_STR("() -> (Rect userState)")},
	{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
	 PyDoc_STR("(Rect userState) -> None")},
	{"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
	 PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")},
	{"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
	 PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")},
	{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
	 PyDoc_STR("() -> None")},
	{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
	 PyDoc_STR("() -> None")},
	{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
	 PyDoc_STR("(Boolean showFlag) -> None")},
	{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
	 PyDoc_STR("(WindowPtr inParentWindow) -> None")},
	{"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
	 PyDoc_STR("() -> None")},
	{"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
	 PyDoc_STR("() -> (WindowPtr outParentWindow)")},
	{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
	{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
	 PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
	{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
	 PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")},
	{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
	 PyDoc_STR("(Point thePt) -> (Boolean _rv)")},
	{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
	 PyDoc_STR("() -> (CGrafPtr _rv)")},
	{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
	 PyDoc_STR("() -> (short _rv)")},
	{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
	 PyDoc_STR("() -> (WindowPtr _rv)")},
	{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
	 PyDoc_STR("() -> (Rect rect)")},
	{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
	 PyDoc_STR("() -> (Rect rect)")},
	{"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
	 PyDoc_STR("(short kind) -> None")},
	{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
	 PyDoc_STR("(Rect rect) -> None")},
	{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
	 PyDoc_STR("(Rect rect) -> None")},
	{"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
	 PyDoc_STR("() -> None")},
	{"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
	 PyDoc_STR("() -> (Rect bounds)")},
	{"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
	 PyDoc_STR("(RgnHandle r) -> None")},
	{"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
	 PyDoc_STR("(RgnHandle r) -> None")},
	{"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
	 PyDoc_STR("(RgnHandle r) -> None")},
	{"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
	 PyDoc_STR("() -> (WindowPtr _rv)")},
	{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
	 PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
	{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
	 PyDoc_STR("() -> None")},
	{"AutoDispose", (PyCFunction)WinObj_AutoDispose, 1,
	 PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},
	{NULL, NULL, 0}
};

#define WinObj_getsetlist NULL


static int WinObj_compare(WindowObject *self, WindowObject *other)
{
	if ( self->ob_itself > other->ob_itself ) return 1;
	if ( self->ob_itself < other->ob_itself ) return -1;
	return 0;
}

static PyObject * WinObj_repr(WindowObject *self)
{
	char buf[100];
	sprintf(buf, "<Window object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
	return PyString_FromString(buf);
}

static int WinObj_hash(WindowObject *self)
{
	return (int)self->ob_itself;
}
#define WinObj_tp_init 0

#define WinObj_tp_alloc PyType_GenericAlloc

static PyObject *WinObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
	PyObject *self;
	WindowPtr itself;
	char *kw[] = {"itself", 0};

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, WinObj_Convert, &itself)) return NULL;
	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
	((WindowObject *)self)->ob_itself = itself;
	return self;
}

#define WinObj_tp_free PyObject_Del


PyTypeObject Window_Type = {
	PyObject_HEAD_INIT(NULL)
	0, /*ob_size*/
	"_Win.Window", /*tp_name*/
	sizeof(WindowObject), /*tp_basicsize*/
	0, /*tp_itemsize*/
	/* methods */
	(destructor) WinObj_dealloc, /*tp_dealloc*/
	0, /*tp_print*/
	(getattrfunc)0, /*tp_getattr*/
	(setattrfunc)0, /*tp_setattr*/
	(cmpfunc) WinObj_compare, /*tp_compare*/
	(reprfunc) WinObj_repr, /*tp_repr*/
	(PyNumberMethods *)0, /* tp_as_number */
	(PySequenceMethods *)0, /* tp_as_sequence */
	(PyMappingMethods *)0, /* tp_as_mapping */
	(hashfunc) WinObj_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*/
	WinObj_methods, /* tp_methods */
	0, /*tp_members*/
	WinObj_getsetlist, /*tp_getset*/
	0, /*tp_base*/
	0, /*tp_dict*/
	0, /*tp_descr_get*/
	0, /*tp_descr_set*/
	0, /*tp_dictoffset*/
	WinObj_tp_init, /* tp_init */
	WinObj_tp_alloc, /* tp_alloc */
	WinObj_tp_new, /* tp_new */
	WinObj_tp_free, /* tp_free */
};

/* --------------------- End object type Window --------------------- */


static PyObject *Win_GetNewCWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	short windowID;
	WindowPtr behind;
#ifndef GetNewCWindow
	PyMac_PRECHECK(GetNewCWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hO&",
	                      &windowID,
	                      WinObj_Convert, &behind))
		return NULL;
	_rv = GetNewCWindow(windowID,
	                    (void *)0,
	                    behind);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *Win_NewWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	Rect boundsRect;
	Str255 title;
	Boolean visible;
	short theProc;
	WindowPtr behind;
	Boolean goAwayFlag;
	long refCon;
#ifndef NewWindow
	PyMac_PRECHECK(NewWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
	                      PyMac_GetRect, &boundsRect,
	                      PyMac_GetStr255, title,
	                      &visible,
	                      &theProc,
	                      WinObj_Convert, &behind,
	                      &goAwayFlag,
	                      &refCon))
		return NULL;
	_rv = NewWindow((void *)0,
	                &boundsRect,
	                title,
	                visible,
	                theProc,
	                behind,
	                goAwayFlag,
	                refCon);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *Win_GetNewWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	short windowID;
	WindowPtr behind;
#ifndef GetNewWindow
	PyMac_PRECHECK(GetNewWindow);
#endif
	if (!PyArg_ParseTuple(_args, "hO&",
	                      &windowID,
	                      WinObj_Convert, &behind))
		return NULL;
	_rv = GetNewWindow(windowID,
	                   (void *)0,
	                   behind);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *Win_NewCWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	Rect boundsRect;
	Str255 title;
	Boolean visible;
	short procID;
	WindowPtr behind;
	Boolean goAwayFlag;
	long refCon;
#ifndef NewCWindow
	PyMac_PRECHECK(NewCWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
	                      PyMac_GetRect, &boundsRect,
	                      PyMac_GetStr255, title,
	                      &visible,
	                      &procID,
	                      WinObj_Convert, &behind,
	                      &goAwayFlag,
	                      &refCon))
		return NULL;
	_rv = NewCWindow((void *)0,
	                 &boundsRect,
	                 title,
	                 visible,
	                 procID,
	                 behind,
	                 goAwayFlag,
	                 refCon);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *Win_CreateNewWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	WindowClass windowClass;
	WindowAttributes attributes;
	Rect contentBounds;
	WindowPtr outWindow;
#ifndef CreateNewWindow
	PyMac_PRECHECK(CreateNewWindow);
#endif
	if (!PyArg_ParseTuple(_args, "llO&",
	                      &windowClass,
	                      &attributes,
	                      PyMac_GetRect, &contentBounds))
		return NULL;
	_err = CreateNewWindow(windowClass,
	                       attributes,
	                       &contentBounds,
	                       &outWindow);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     WinObj_New, outWindow);
	return _res;
}

static PyObject *Win_CreateWindowFromResource(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	SInt16 resID;
	WindowPtr outWindow;
#ifndef CreateWindowFromResource
	PyMac_PRECHECK(CreateWindowFromResource);
#endif
	if (!PyArg_ParseTuple(_args, "h",
	                      &resID))
		return NULL;
	_err = CreateWindowFromResource(resID,
	                                &outWindow);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     WinObj_New, outWindow);
	return _res;
}

static PyObject *Win_ShowFloatingWindows(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef ShowFloatingWindows
	PyMac_PRECHECK(ShowFloatingWindows);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = ShowFloatingWindows();
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Win_HideFloatingWindows(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef HideFloatingWindows
	PyMac_PRECHECK(HideFloatingWindows);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = HideFloatingWindows();
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Win_AreFloatingWindowsVisible(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
#ifndef AreFloatingWindowsVisible
	PyMac_PRECHECK(AreFloatingWindowsVisible);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = AreFloatingWindowsVisible();
	_res = Py_BuildValue("b",
	                     _rv);
	return _res;
}

static PyObject *Win_CheckUpdate(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	Boolean _rv;
	EventRecord theEvent;
#ifndef CheckUpdate
	PyMac_PRECHECK(CheckUpdate);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = CheckUpdate(&theEvent);
	_res = Py_BuildValue("bO&",
	                     _rv,
	                     PyMac_BuildEventRecord, &theEvent);
	return _res;
}

static PyObject *Win_MacFindWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPartCode _rv;
	Point thePoint;
	WindowPtr window;
#ifndef MacFindWindow
	PyMac_PRECHECK(MacFindWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &thePoint))
		return NULL;
	_rv = MacFindWindow(thePoint,
	                    &window);
	_res = Py_BuildValue("hO&",
	                     _rv,
	                     WinObj_WhichWindow, window);
	return _res;
}

static PyObject *Win_FrontWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
#ifndef FrontWindow
	PyMac_PRECHECK(FrontWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = FrontWindow();
	_res = Py_BuildValue("O&",
	                     WinObj_WhichWindow, _rv);
	return _res;
}

static PyObject *Win_FrontNonFloatingWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
#ifndef FrontNonFloatingWindow
	PyMac_PRECHECK(FrontNonFloatingWindow);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = FrontNonFloatingWindow();
	_res = Py_BuildValue("O&",
	                     WinObj_WhichWindow, _rv);
	return _res;
}

static PyObject *Win_GetFrontWindowOfClass(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	WindowClass inWindowClass;
	Boolean mustBeVisible;
#ifndef GetFrontWindowOfClass
	PyMac_PRECHECK(GetFrontWindowOfClass);
#endif
	if (!PyArg_ParseTuple(_args, "lb",
	                      &inWindowClass,
	                      &mustBeVisible))
		return NULL;
	_rv = GetFrontWindowOfClass(inWindowClass,
	                            mustBeVisible);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

static PyObject *Win_FindWindowOfClass(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Point where;
	WindowClass inWindowClass;
	WindowPtr outWindow;
	WindowPartCode outWindowPart;
#ifndef FindWindowOfClass
	PyMac_PRECHECK(FindWindowOfClass);
#endif
	if (!PyArg_ParseTuple(_args, "O&l",
	                      PyMac_GetPoint, &where,
	                      &inWindowClass))
		return NULL;
	_err = FindWindowOfClass(&where,
	                         inWindowClass,
	                         &outWindow,
	                         &outWindowPart);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&h",
	                     WinObj_WhichWindow, outWindow,
	                     outWindowPart);
	return _res;
}

static PyObject *Win_CreateStandardWindowMenu(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	OptionBits inOptions;
	MenuHandle outMenu;
#ifndef CreateStandardWindowMenu
	PyMac_PRECHECK(CreateStandardWindowMenu);
#endif
	if (!PyArg_ParseTuple(_args, "l",
	                      &inOptions))
		return NULL;
	_err = CreateStandardWindowMenu(inOptions,
	                                &outMenu);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     MenuObj_New, outMenu);
	return _res;
}

static PyObject *Win_CollapseAllWindows(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	Boolean collapse;
#ifndef CollapseAllWindows
	PyMac_PRECHECK(CollapseAllWindows);
#endif
	if (!PyArg_ParseTuple(_args, "b",
	                      &collapse))
		return NULL;
	_err = CollapseAllWindows(collapse);
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Win_GetAvailableWindowPositioningBounds(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
	GDHandle inDevice;
	Rect availableRect;
#ifndef GetAvailableWindowPositioningBounds
	PyMac_PRECHECK(GetAvailableWindowPositioningBounds);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      ResObj_Convert, &inDevice))
		return NULL;
	_err = GetAvailableWindowPositioningBounds(inDevice,
	                                           &availableRect);
	if (_err != noErr) return PyMac_Error(_err);
	_res = Py_BuildValue("O&",
	                     PyMac_BuildRect, &availableRect);
	return _res;
}

static PyObject *Win_DisableScreenUpdates(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef DisableScreenUpdates
	PyMac_PRECHECK(DisableScreenUpdates);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = DisableScreenUpdates();
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Win_EnableScreenUpdates(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	OSStatus _err;
#ifndef EnableScreenUpdates
	PyMac_PRECHECK(EnableScreenUpdates);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_err = EnableScreenUpdates();
	if (_err != noErr) return PyMac_Error(_err);
	Py_INCREF(Py_None);
	_res = Py_None;
	return _res;
}

static PyObject *Win_PinRect(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	long _rv;
	Rect theRect;
	Point thePt;
#ifndef PinRect
	PyMac_PRECHECK(PinRect);
#endif
	if (!PyArg_ParseTuple(_args, "O&O&",
	                      PyMac_GetRect, &theRect,
	                      PyMac_GetPoint, &thePt))
		return NULL;
	_rv = PinRect(&theRect,
	              thePt);
	_res = Py_BuildValue("l",
	                     _rv);
	return _res;
}

static PyObject *Win_GetGrayRgn(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	RgnHandle _rv;
#ifndef GetGrayRgn
	PyMac_PRECHECK(GetGrayRgn);
#endif
	if (!PyArg_ParseTuple(_args, ""))
		return NULL;
	_rv = GetGrayRgn();
	_res = Py_BuildValue("O&",
	                     ResObj_New, _rv);
	return _res;
}

static PyObject *Win_GetWindowFromPort(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	WindowPtr _rv;
	CGrafPtr port;
#ifndef GetWindowFromPort
	PyMac_PRECHECK(GetWindowFromPort);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      GrafObj_Convert, &port))
		return NULL;
	_rv = GetWindowFromPort(port);
	_res = Py_BuildValue("O&",
	                     WinObj_New, _rv);
	return _res;
}

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

	long ptr;

	if ( !PyArg_ParseTuple(_args, "i", &ptr) )
		return NULL;
	_res = WinObj_WhichWindow((WindowPtr)ptr);
	return _res;

}

static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
{
	PyObject *_res = NULL;
	short _rv;
	Point thePoint;
	WindowPtr theWindow;
#ifndef FindWindow
	PyMac_PRECHECK(FindWindow);
#endif
	if (!PyArg_ParseTuple(_args, "O&",
	                      PyMac_GetPoint, &thePoint))
		return NULL;
	_rv = FindWindow(thePoint,
	                 &theWindow);
	_res = Py_BuildValue("hO&",
	                     _rv,
	                     WinObj_WhichWindow, theWindow);
	return _res;
}

static PyMethodDef Win_methods[] = {
	{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
	 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
	{"NewWindow", (PyCFunction)Win_NewWindow, 1,
	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
	{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
	 PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
	{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
	 PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
	{"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
	 PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
	{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
	 PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
	{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
	 PyDoc_STR("() -> None")},
	{"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
	 PyDoc_STR("() -> None")},
	{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
	 PyDoc_STR("() -> (Boolean _rv)")},
	{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
	 PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
	{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
	 PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
	{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
	 PyDoc_STR("() -> (WindowPtr _rv)")},
	{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
	 PyDoc_STR("() -> (WindowPtr _rv)")},
	{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
	 PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
	{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
	 PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
	{"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
	 PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
	{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
	 PyDoc_STR("(Boolean collapse) -> None")},
	{"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
	 PyDoc_STR("(GDHandle inDevice) -> (Rect availableRect)")},
	{"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
	 PyDoc_STR("() -> None")},
	{"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
	 PyDoc_STR("() -> None")},
	{"PinRect", (PyCFunction)Win_PinRect, 1,
	 PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
	{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
	 PyDoc_STR("() -> (RgnHandle _rv)")},
	{"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
	 PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
	{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
	 PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
	{"FindWindow", (PyCFunction)Win_FindWindow, 1,
	 PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
	{NULL, NULL, 0}
};



/* Return the object corresponding to the window, or NULL */

PyObject *
WinObj_WhichWindow(WindowPtr w)
{
	PyObject *it;
	
	if (w == NULL) {
		it = Py_None;
		Py_INCREF(it);
	} else {
		it = (PyObject *) GetWRefCon(w);
		if (it == NULL || !IsPointerValid((Ptr)it) || ((WindowObject *)it)->ob_itself != w || !WinObj_Check(it)) {
			it = WinObj_New(w);
			((WindowObject *)it)->ob_freeit = NULL;
		} else {
			Py_INCREF(it);
		}
	}
	return it;
}


void init_Win(void)
{
	PyObject *m;
	PyObject *d;



		PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_New);
		PyMac_INIT_TOOLBOX_OBJECT_NEW(WindowPtr, WinObj_WhichWindow);
		PyMac_INIT_TOOLBOX_OBJECT_CONVERT(WindowPtr, WinObj_Convert);


	m = Py_InitModule("_Win", Win_methods);
	d = PyModule_GetDict(m);
	Win_Error = PyMac_GetOSErrException();
	if (Win_Error == NULL ||
	    PyDict_SetItemString(d, "Error", Win_Error) != 0)
		return;
	Window_Type.ob_type = &PyType_Type;
	if (PyType_Ready(&Window_Type) < 0) return;
	Py_INCREF(&Window_Type);
	PyModule_AddObject(m, "Window", (PyObject *)&Window_Type);
	/* Backward-compatible name */
	Py_INCREF(&Window_Type);
	PyModule_AddObject(m, "WindowType", (PyObject *)&Window_Type);
}

/* ======================== End module _Win ========================= */