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

#include "Python.h"

#ifndef __LP64__

#include "pymactoolbox.h"

/* Macro to test whether a weak-loaded CFM function exists */

#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

        PyErr_SetString(PyExc_NotImplementedError, \

        "Not available in this shared library/OS version"); \

        return NULL; \

    }} while(0)

#include <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_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)

{