/* ========================== Module _Ctl =========================== */

#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 *_CtlObj_New(ControlHandle);

extern int _CtlObj_Convert(PyObject *, ControlHandle *);

#define CtlObj_New _CtlObj_New

#define CtlObj_Convert _CtlObj_Convert

#endif

static PyObject *CtlObj_WhichControl(ControlHandle);

#define as_Control(h) ((ControlHandle)h)

#define as_Resource(ctl) ((Handle)ctl)

#define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp)

#define MAXTABS 32  /* maximum number of tabs that we support in a tabs control */

/*

** Parse/generate ControlFontStyleRec records

*/

#if 0 /* Not needed */

static PyObject *

ControlFontStyle_New(ControlFontStyleRec *itself)

{

        return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font,

                itself->size, itself->style, itself->mode, itself->just,

                QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor);

}

#endif

static int

ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself)

{

        return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags,

                &itself->font, &itself->size, &itself->style, &itself->mode,

                &itself->just, QdRGB_Convert, &itself->foreColor,

                QdRGB_Convert, &itself->backColor);

}

/*

** Parse/generate ControlID records

*/

static PyObject *

PyControlID_New(ControlID *itself)

{

        return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id);

}

static int

PyControlID_Convert(PyObject *v, ControlID *itself)

{

        return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id);

}

/*

** generate DataBrowserListViewColumnDesc records

*/

static int

DataBrowserTableViewColumnDesc_Convert(PyObject *v, DataBrowserTableViewColumnDesc *itself)

{

        return PyArg_Parse(v, "(lO&l)",

                           &itself->propertyID,

                           PyMac_GetOSType, &itself->propertyType,

                           &itself->propertyFlags);

}

static int

ControlButtonContentInfo_Convert(PyObject *v, ControlButtonContentInfo *itself)

{

        return PyArg_Parse(v, "(hO&)",

                           &itself->contentType,

                           OptResObj_Convert, &itself->u.iconSuite);

}

static int

DataBrowserListViewHeaderDesc_Convert(PyObject *v, DataBrowserListViewHeaderDesc *itself)

{

        itself->version = kDataBrowserListViewLatestHeaderDesc;

        return PyArg_Parse(v, "(HHhO&HO&O&)",

                           &itself->minimumWidth,

                           &itself->maximumWidth,

                           &itself->titleOffset,

                           CFStringRefObj_Convert, &itself->titleString,

                           &itself->initialOrder,

                           ControlFontStyle_Convert, &itself->btnFontStyle,

                           ControlButtonContentInfo_Convert, &itself->btnContentInfo);

}

static int

DataBrowserListViewColumnDesc_Convert(PyObject *v, DataBrowserListViewColumnDesc *itself)

{

        return PyArg_Parse(v, "(O&O&)",

                           DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc,

                           DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc);

}

/* TrackControl and HandleControlClick callback support */

#define kMyControlActionProcTag 'ACTN'  /* not an official tag, only for internal use */

static PyObject *tracker;

static ControlActionUPP mytracker_upp;

static ControlActionUPP myactionproc_upp;

static ControlUserPaneKeyDownUPP mykeydownproc_upp;

static ControlUserPaneFocusUPP myfocusproc_upp;

static ControlUserPaneDrawUPP mydrawproc_upp;

static ControlUserPaneIdleUPP myidleproc_upp;

static ControlUserPaneHitTestUPP myhittestproc_upp;

static ControlUserPaneTrackingUPP mytrackingproc_upp;

static int settrackfunc(PyObject *);    /* forward */

static void clrtrackfunc(void); /* forward */

static int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *);

static PyObject *Ctl_Error;

/* ---------------------- Object type Control ----------------------- */

PyTypeObject Control_Type;

#define CtlObj_Check(x) ((x)->ob_type == &Control_Type || PyObject_TypeCheck((x), &Control_Type))

typedef struct ControlObject {

	PyObject_HEAD

	ControlHandle ob_itself;

	PyObject *ob_callbackdict;

} ControlObject;

PyObject *CtlObj_New(ControlHandle itself)

{

	ControlObject *it;

	if (itself == NULL) return PyMac_Error(resNotFound);

	it = PyObject_NEW(ControlObject, &Control_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	SetControlReference(itself, (long)it);

	it->ob_callbackdict = NULL;

	return (PyObject *)it;

}

int CtlObj_Convert(PyObject *v, ControlHandle *p_itself)

{

	if (!CtlObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "Control required");

		return 0;

	}

	*p_itself = ((ControlObject *)v)->ob_itself;

	return 1;

}

static void CtlObj_dealloc(ControlObject *self)

{

	Py_XDECREF(self->ob_callbackdict);

	if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */

	self->ob_type->tp_free((PyObject *)self);

}

static PyObject *CtlObj_HiliteControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ControlPartCode hiliteState;

#ifndef HiliteControl

	PyMac_PRECHECK(HiliteControl);

#endif

	if (!PyArg_ParseTuple(_args, "h",

	                      &hiliteState))

		return NULL;

	HiliteControl(_self->ob_itself,

	              hiliteState);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_ShowControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef ShowControl

	PyMac_PRECHECK(ShowControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	ShowControl(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_HideControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef HideControl

	PyMac_PRECHECK(HideControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	HideControl(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_IsControlActive(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef IsControlActive

	PyMac_PRECHECK(IsControlActive);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = IsControlActive(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *CtlObj_IsControlVisible(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef IsControlVisible

	PyMac_PRECHECK(IsControlVisible);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = IsControlVisible(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *CtlObj_ActivateControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

#ifndef ActivateControl

	PyMac_PRECHECK(ActivateControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = ActivateControl(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_DeactivateControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

#ifndef DeactivateControl

	PyMac_PRECHECK(DeactivateControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = DeactivateControl(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_SetControlVisibility(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	Boolean inIsVisible;

	Boolean inDoDraw;

#ifndef SetControlVisibility

	PyMac_PRECHECK(SetControlVisibility);

#endif

	if (!PyArg_ParseTuple(_args, "bb",

	                      &inIsVisible,

	                      &inDoDraw))

		return NULL;

	_err = SetControlVisibility(_self->ob_itself,

	                            inIsVisible,

	                            inDoDraw);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_IsControlEnabled(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

#ifndef IsControlEnabled

	PyMac_PRECHECK(IsControlEnabled);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = IsControlEnabled(_self->ob_itself);

	_res = Py_BuildValue("b",

	                     _rv);

	return _res;

}

static PyObject *CtlObj_EnableControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

#ifndef EnableControl

	PyMac_PRECHECK(EnableControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = EnableControl(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_DisableControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

#ifndef DisableControl

	PyMac_PRECHECK(DisableControl);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = DisableControl(_self->ob_itself);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_Draw1Control(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef Draw1Control

	PyMac_PRECHECK(Draw1Control);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	Draw1Control(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_GetBestControlRect(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	Rect outRect;

	SInt16 outBaseLineOffset;

#ifndef GetBestControlRect

	PyMac_PRECHECK(GetBestControlRect);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_err = GetBestControlRect(_self->ob_itself,

	                          &outRect,

	                          &outBaseLineOffset);

	if (_err != noErr) return PyMac_Error(_err);

	_res = Py_BuildValue("O&h",

	                     PyMac_BuildRect, &outRect,

	                     outBaseLineOffset);

	return _res;

}

static PyObject *CtlObj_SetControlFontStyle(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	ControlFontStyleRec inStyle;

#ifndef SetControlFontStyle

	PyMac_PRECHECK(SetControlFontStyle);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      ControlFontStyle_Convert, &inStyle))

		return NULL;

	_err = SetControlFontStyle(_self->ob_itself,

	                           &inStyle);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_DrawControlInCurrentPort(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef DrawControlInCurrentPort

	PyMac_PRECHECK(DrawControlInCurrentPort);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	DrawControlInCurrentPort(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_SetUpControlBackground(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	SInt16 inDepth;

	Boolean inIsColorDevice;

#ifndef SetUpControlBackground

	PyMac_PRECHECK(SetUpControlBackground);

#endif

	if (!PyArg_ParseTuple(_args, "hb",

	                      &inDepth,

	                      &inIsColorDevice))

		return NULL;

	_err = SetUpControlBackground(_self->ob_itself,

	                              inDepth,

	                              inIsColorDevice);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_SetUpControlTextColor(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSErr _err;

	SInt16 inDepth;

	Boolean inIsColorDevice;

#ifndef SetUpControlTextColor

	PyMac_PRECHECK(SetUpControlTextColor);

#endif

	if (!PyArg_ParseTuple(_args, "hb",

	                      &inDepth,

	                      &inIsColorDevice))

		return NULL;

	_err = SetUpControlTextColor(_self->ob_itself,

	                             inDepth,

	                             inIsColorDevice);

	if (_err != noErr) return PyMac_Error(_err);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_DragControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Point startPoint;

	Rect limitRect;

	Rect slopRect;

	DragConstraint axis;

#ifndef DragControl

	PyMac_PRECHECK(DragControl);

#endif

	if (!PyArg_ParseTuple(_args, "O&O&O&H",

	                      PyMac_GetPoint, &startPoint,

	                      PyMac_GetRect, &limitRect,

	                      PyMac_GetRect, &slopRect,

	                      &axis))

		return NULL;

	DragControl(_self->ob_itself,

	            startPoint,

	            &limitRect,

	            &slopRect,

	            axis);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CtlObj_TestControl(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	ControlPartCode _rv;

	Point testPoint;

#ifndef TestControl

	PyMac_PRECHECK(TestControl);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      PyMac_GetPoint, &testPoint))

		return NULL;

	_rv = TestControl(_self->ob_itself,

	                  testPoint);

	_res = Py_BuildValue("h",

	                     _rv);

	return _res;

}

static PyObject *CtlObj_HandleControlContextualMenuClick(ControlObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	OSStatus _err;

	Point inWhere;

	Boolean menuDisplayed;

#ifndef HandleControlContextualMenuClick

	PyMac_PRECHECK(HandleControlContextualMenuClick);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      PyMac_GetPoint, &inWhere))

		return NULL;

	_err = HandleControlContextualMenuClick(_self->ob_itself,

	                                        inWhere,

	                                        &menuDisplayed);

	if (_err != noErr) return PyMac_Error(_err);

	_res = Py_BuildValue("b",

	                     menuDisplayed);

	return _res;

}